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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
499
|
B
|
Lecture
|
PROGRAMMING
| 1,000
|
[
"implementation",
"strings"
] | null | null |
You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.
You know two languages, and the professor is giving the lecture in the first one. The words in both languages consist of lowercase English characters, each language consists of several words. For each language, all words are distinct, i.e. they are spelled differently. Moreover, the words of these languages have a one-to-one correspondence, that is, for each word in each language, there exists exactly one word in the other language having has the same meaning.
You can write down every word the professor says in either the first language or the second language. Of course, during the lecture you write down each word in the language in which the word is shorter. In case of equal lengths of the corresponding words you prefer the word of the first language.
You are given the text of the lecture the professor is going to read. Find out how the lecture will be recorded in your notes.
|
The first line contains two integers, *n* and *m* (1<=≤<=*n*<=≤<=3000, 1<=≤<=*m*<=≤<=3000) — the number of words in the professor's lecture and the number of words in each of these languages.
The following *m* lines contain the words. The *i*-th line contains two strings *a**i*, *b**i* meaning that the word *a**i* belongs to the first language, the word *b**i* belongs to the second language, and these two words have the same meaning. It is guaranteed that no word occurs in both languages, and each word occurs in its language exactly once.
The next line contains *n* space-separated strings *c*1,<=*c*2,<=...,<=*c**n* — the text of the lecture. It is guaranteed that each of the strings *c**i* belongs to the set of strings {*a*1,<=*a*2,<=... *a**m*}.
All the strings in the input are non-empty, each consisting of no more than 10 lowercase English letters.
|
Output exactly *n* words: how you will record the lecture in your notebook. Output the words of the lecture in the same order as in the input.
|
[
"4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest\n",
"5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll\n"
] |
[
"codeforces round letter round\n",
"hbnyiyc joll joll un joll\n"
] |
none
| 500
|
[
{
"input": "4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest",
"output": "codeforces round letter round"
},
{
"input": "5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll",
"output": "hbnyiyc joll joll un joll"
},
{
"input": "5 5\nqueyqj f\nb vn\ntabzvk qpfzoqx\nytnyonoc hnxsd\njpggvr lchinjmt\nqueyqj jpggvr b ytnyonoc b",
"output": "f jpggvr b hnxsd b"
},
{
"input": "10 22\nazbrll oen\ngh vdyayei\njphveblohx vfglv\nmfyxib jepnvhcuwo\nrpikazqj uam\nl rx\nokjenof qpnyi\nj tixqrno\nod itozmfct\nikkdxmirx ev\nqexftojc p\nkdazb zjs\nmbk ykvqjrxaxu\nhbcwhouzq pwt\nmirpsz zfaegpl\nuhkkvcj rlvwj\nef iqnnwtolrc\npjzfcpmeag ecdayth\nsa qcthz\ncbfhfxi qrnbvdryz\nwqel tj\natx smkbid\nef hbcwhouzq cbfhfxi hbcwhouzq mirpsz cbfhfxi cbfhfxi okjenof pjzfcpmeag kdazb",
"output": "ef pwt cbfhfxi pwt mirpsz cbfhfxi cbfhfxi qpnyi ecdayth zjs"
},
{
"input": "1 1\namit am\namit",
"output": "am"
},
{
"input": "1 1\na c\na",
"output": "a"
}
] | 1,691,833,309
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 37
| 46
| 1,228,800
|
import math
n,l=[int(x) for x in input().split()]
d={}
for _ in range(l):
a,b=input().split()
if len(a)<=len(b):
ans=a
else:
ans=b
d[a]=ans
d[b]=ans
s=list(map(str,input().split()))
for x in s:
print(d[x],end=" ")
|
Title: Lecture
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.
You know two languages, and the professor is giving the lecture in the first one. The words in both languages consist of lowercase English characters, each language consists of several words. For each language, all words are distinct, i.e. they are spelled differently. Moreover, the words of these languages have a one-to-one correspondence, that is, for each word in each language, there exists exactly one word in the other language having has the same meaning.
You can write down every word the professor says in either the first language or the second language. Of course, during the lecture you write down each word in the language in which the word is shorter. In case of equal lengths of the corresponding words you prefer the word of the first language.
You are given the text of the lecture the professor is going to read. Find out how the lecture will be recorded in your notes.
Input Specification:
The first line contains two integers, *n* and *m* (1<=≤<=*n*<=≤<=3000, 1<=≤<=*m*<=≤<=3000) — the number of words in the professor's lecture and the number of words in each of these languages.
The following *m* lines contain the words. The *i*-th line contains two strings *a**i*, *b**i* meaning that the word *a**i* belongs to the first language, the word *b**i* belongs to the second language, and these two words have the same meaning. It is guaranteed that no word occurs in both languages, and each word occurs in its language exactly once.
The next line contains *n* space-separated strings *c*1,<=*c*2,<=...,<=*c**n* — the text of the lecture. It is guaranteed that each of the strings *c**i* belongs to the set of strings {*a*1,<=*a*2,<=... *a**m*}.
All the strings in the input are non-empty, each consisting of no more than 10 lowercase English letters.
Output Specification:
Output exactly *n* words: how you will record the lecture in your notebook. Output the words of the lecture in the same order as in the input.
Demo Input:
['4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest\n', '5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll\n']
Demo Output:
['codeforces round letter round\n', 'hbnyiyc joll joll un joll\n']
Note:
none
|
```python
import math
n,l=[int(x) for x in input().split()]
d={}
for _ in range(l):
a,b=input().split()
if len(a)<=len(b):
ans=a
else:
ans=b
d[a]=ans
d[b]=ans
s=list(map(str,input().split()))
for x in s:
print(d[x],end=" ")
```
| 3
|
|
908
|
A
|
New Year and Counting Cards
|
PROGRAMMING
| 800
|
[
"brute force",
"implementation"
] | null | null |
Your friend has *n* cards.
You know that each card has a lowercase English letter on one side and a digit on the other.
Currently, your friend has laid out the cards on a table so only one side of each card is visible.
You would like to know if the following statement is true for cards that your friend owns: "If a card has a vowel on one side, then it has an even digit on the other side." More specifically, a vowel is one of 'a', 'e', 'i', 'o' or 'u', and even digit is one of '0', '2', '4', '6' or '8'.
For example, if a card has 'a' on one side, and '6' on the other side, then this statement is true for it. Also, the statement is true, for example, for a card with 'b' and '4', and for a card with 'b' and '3' (since the letter is not a vowel). The statement is false, for example, for card with 'e' and '5'. You are interested if the statement is true for all cards. In particular, if no card has a vowel, the statement is true.
To determine this, you can flip over some cards to reveal the other side. You would like to know what is the minimum number of cards you need to flip in the worst case in order to verify that the statement is true.
|
The first and only line of input will contain a string *s* (1<=≤<=|*s*|<=≤<=50), denoting the sides of the cards that you can see on the table currently. Each character of *s* is either a lowercase English letter or a digit.
|
Print a single integer, the minimum number of cards you must turn over to verify your claim.
|
[
"ee\n",
"z\n",
"0ay1\n"
] |
[
"2\n",
"0\n",
"2\n"
] |
In the first sample, we must turn over both cards. Note that even though both cards have the same letter, they could possibly have different numbers on the other side.
In the second sample, we don't need to turn over any cards. The statement is vacuously true, since you know your friend has no cards with a vowel on them.
In the third sample, we need to flip the second and fourth cards.
| 500
|
[
{
"input": "ee",
"output": "2"
},
{
"input": "z",
"output": "0"
},
{
"input": "0ay1",
"output": "2"
},
{
"input": "0abcdefghijklmnopqrstuvwxyz1234567896",
"output": "10"
},
{
"input": "0a0a9e9e2i2i9o9o6u6u9z9z4x4x9b9b",
"output": "18"
},
{
"input": "01234567890123456789012345678901234567890123456789",
"output": "25"
},
{
"input": "qwertyuioplkjhgfdsazxcvbnmqwertyuioplkjhgfdsazxcvb",
"output": "10"
},
{
"input": "cjw2dwmr10pku4yxohe0wglktd",
"output": "4"
},
{
"input": "6z2tx805jie8cfybwtfqvmlveec3iak5z5u3lu62vbxyqht6",
"output": "13"
},
{
"input": "kaq7jyialrfp4ilkni90eq8v3amcbygon7py0hb8z26fbl8ss1",
"output": "13"
},
{
"input": "hpwn50zgbmct80k9rizjqg40nycgs0acwikjqt11nr6m61krfs",
"output": "8"
},
{
"input": "l3rw91a4m25l8iytxyeuixsegzcbm4h41ornf3pixkrmwznrzc",
"output": "14"
},
{
"input": "2222",
"output": "0"
},
{
"input": "13579",
"output": "5"
},
{
"input": "1",
"output": "1"
},
{
"input": "0",
"output": "0"
},
{
"input": "a",
"output": "1"
},
{
"input": "y",
"output": "0"
},
{
"input": "w",
"output": "0"
},
{
"input": "oo",
"output": "2"
},
{
"input": "oy",
"output": "1"
},
{
"input": "yo",
"output": "1"
},
{
"input": "yy",
"output": "0"
},
{
"input": "a0",
"output": "1"
},
{
"input": "a9",
"output": "2"
},
{
"input": "y0",
"output": "0"
},
{
"input": "y7",
"output": "1"
},
{
"input": "0a",
"output": "1"
},
{
"input": "3a",
"output": "2"
},
{
"input": "06",
"output": "0"
},
{
"input": "07",
"output": "1"
},
{
"input": "70",
"output": "1"
},
{
"input": "77",
"output": "2"
},
{
"input": "13570",
"output": "4"
},
{
"input": "0000000000011111",
"output": "5"
},
{
"input": "1357",
"output": "4"
},
{
"input": "uuuuuuuuuuuuuuuuuu",
"output": "18"
},
{
"input": "gabieurat",
"output": "5"
}
] | 1,602,188,012
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 93
| 0
|
string = input()
vowels = ['a', 'e', 'i', 'o', 'u']
even = ['0', '2', '4', '6', '8']
turns = 0
for s in string:
if s in vowels or s in even:
turns += 1
print(turns)
|
Title: New Year and Counting Cards
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Your friend has *n* cards.
You know that each card has a lowercase English letter on one side and a digit on the other.
Currently, your friend has laid out the cards on a table so only one side of each card is visible.
You would like to know if the following statement is true for cards that your friend owns: "If a card has a vowel on one side, then it has an even digit on the other side." More specifically, a vowel is one of 'a', 'e', 'i', 'o' or 'u', and even digit is one of '0', '2', '4', '6' or '8'.
For example, if a card has 'a' on one side, and '6' on the other side, then this statement is true for it. Also, the statement is true, for example, for a card with 'b' and '4', and for a card with 'b' and '3' (since the letter is not a vowel). The statement is false, for example, for card with 'e' and '5'. You are interested if the statement is true for all cards. In particular, if no card has a vowel, the statement is true.
To determine this, you can flip over some cards to reveal the other side. You would like to know what is the minimum number of cards you need to flip in the worst case in order to verify that the statement is true.
Input Specification:
The first and only line of input will contain a string *s* (1<=≤<=|*s*|<=≤<=50), denoting the sides of the cards that you can see on the table currently. Each character of *s* is either a lowercase English letter or a digit.
Output Specification:
Print a single integer, the minimum number of cards you must turn over to verify your claim.
Demo Input:
['ee\n', 'z\n', '0ay1\n']
Demo Output:
['2\n', '0\n', '2\n']
Note:
In the first sample, we must turn over both cards. Note that even though both cards have the same letter, they could possibly have different numbers on the other side.
In the second sample, we don't need to turn over any cards. The statement is vacuously true, since you know your friend has no cards with a vowel on them.
In the third sample, we need to flip the second and fourth cards.
|
```python
string = input()
vowels = ['a', 'e', 'i', 'o', 'u']
even = ['0', '2', '4', '6', '8']
turns = 0
for s in string:
if s in vowels or s in even:
turns += 1
print(turns)
```
| 0
|
|
399
|
A
|
Pages
|
PROGRAMMING
| 0
|
[
"implementation"
] | null | null |
User ainta is making a web site. This time he is going to make a navigation of the pages. In his site, there are *n* pages numbered by integers from 1 to *n*. Assume that somebody is on the *p*-th page now. The navigation will look like this:
When someone clicks the button "<<" he is redirected to page 1, and when someone clicks the button ">>" he is redirected to page *n*. Of course if someone clicks on a number, he is redirected to the corresponding page.
There are some conditions in the navigation:
- If page 1 is in the navigation, the button "<<" must not be printed. - If page *n* is in the navigation, the button ">>" must not be printed. - If the page number is smaller than 1 or greater than *n*, it must not be printed.
You can see some examples of the navigations. Make a program that prints the navigation.
|
The first and the only line contains three integers *n*, *p*, *k* (3<=≤<=*n*<=≤<=100; 1<=≤<=*p*<=≤<=*n*; 1<=≤<=*k*<=≤<=*n*)
|
Print the proper navigation. Follow the format of the output from the test samples.
|
[
"17 5 2\n",
"6 5 2\n",
"6 1 2\n",
"6 2 2\n",
"9 6 3\n",
"10 6 3\n",
"8 5 4\n"
] |
[
"<< 3 4 (5) 6 7 >> ",
"<< 3 4 (5) 6 ",
"(1) 2 3 >> ",
"1 (2) 3 4 >>",
"<< 3 4 5 (6) 7 8 9",
"<< 3 4 5 (6) 7 8 9 >>",
"1 2 3 4 (5) 6 7 8 "
] |
none
| 500
|
[
{
"input": "17 5 2",
"output": "<< 3 4 (5) 6 7 >> "
},
{
"input": "6 5 2",
"output": "<< 3 4 (5) 6 "
},
{
"input": "6 1 2",
"output": "(1) 2 3 >> "
},
{
"input": "6 2 2",
"output": "1 (2) 3 4 >> "
},
{
"input": "9 6 3",
"output": "<< 3 4 5 (6) 7 8 9 "
},
{
"input": "10 6 3",
"output": "<< 3 4 5 (6) 7 8 9 >> "
},
{
"input": "8 5 4",
"output": "1 2 3 4 (5) 6 7 8 "
},
{
"input": "100 10 20",
"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 >> "
},
{
"input": "100 25 11",
"output": "<< 14 15 16 17 18 19 20 21 22 23 24 (25) 26 27 28 29 30 31 32 33 34 35 36 >> "
},
{
"input": "5 2 1",
"output": "1 (2) 3 >> "
},
{
"input": "5 3 1",
"output": "<< 2 (3) 4 >> "
},
{
"input": "79 35 12",
"output": "<< 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 >> "
},
{
"input": "100 99 5",
"output": "<< 94 95 96 97 98 (99) 100 "
},
{
"input": "100 99 15",
"output": "<< 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 (99) 100 "
},
{
"input": "100 100 17",
"output": "<< 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 (100) "
},
{
"input": "100 35 28",
"output": "<< 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 (35) 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 >> "
},
{
"input": "100 46 38",
"output": "<< 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 (46) 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 >> "
},
{
"input": "100 46 48",
"output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 (46) 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 >> "
},
{
"input": "100 10 100",
"output": "1 2 3 4 5 6 7 8 9 (10) 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 "
},
{
"input": "3 1 1",
"output": "(1) 2 >> "
},
{
"input": "3 2 1",
"output": "1 (2) 3 "
},
{
"input": "17 5 3",
"output": "<< 2 3 4 (5) 6 7 8 >> "
},
{
"input": "3 1 3",
"output": "(1) 2 3 "
},
{
"input": "7 5 1",
"output": "<< 4 (5) 6 >> "
},
{
"input": "5 5 5",
"output": "1 2 3 4 (5) "
},
{
"input": "5 3 5",
"output": "1 2 (3) 4 5 "
}
] | 1,542,459,011
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 26
| 109
| 0
|
n,p,k=map(int,input().split())
s=str()
if p-k>1:s+="<< "
for _ in range(max(1,p-k),min(n,p+k)+1):s+=(str(_) if _!=p else"("+str(_)+")")+" "
if p+k<n:s+=">>"
print(s)
|
Title: Pages
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
User ainta is making a web site. This time he is going to make a navigation of the pages. In his site, there are *n* pages numbered by integers from 1 to *n*. Assume that somebody is on the *p*-th page now. The navigation will look like this:
When someone clicks the button "<<" he is redirected to page 1, and when someone clicks the button ">>" he is redirected to page *n*. Of course if someone clicks on a number, he is redirected to the corresponding page.
There are some conditions in the navigation:
- If page 1 is in the navigation, the button "<<" must not be printed. - If page *n* is in the navigation, the button ">>" must not be printed. - If the page number is smaller than 1 or greater than *n*, it must not be printed.
You can see some examples of the navigations. Make a program that prints the navigation.
Input Specification:
The first and the only line contains three integers *n*, *p*, *k* (3<=≤<=*n*<=≤<=100; 1<=≤<=*p*<=≤<=*n*; 1<=≤<=*k*<=≤<=*n*)
Output Specification:
Print the proper navigation. Follow the format of the output from the test samples.
Demo Input:
['17 5 2\n', '6 5 2\n', '6 1 2\n', '6 2 2\n', '9 6 3\n', '10 6 3\n', '8 5 4\n']
Demo Output:
['<< 3 4 (5) 6 7 >> ', '<< 3 4 (5) 6 ', '(1) 2 3 >> ', '1 (2) 3 4 >>', '<< 3 4 5 (6) 7 8 9', '<< 3 4 5 (6) 7 8 9 >>', '1 2 3 4 (5) 6 7 8 ']
Note:
none
|
```python
n,p,k=map(int,input().split())
s=str()
if p-k>1:s+="<< "
for _ in range(max(1,p-k),min(n,p+k)+1):s+=(str(_) if _!=p else"("+str(_)+")")+" "
if p+k<n:s+=">>"
print(s)
```
| 3
|
|
379
|
A
|
New Year Candles
|
PROGRAMMING
| 1,000
|
[
"implementation"
] | null | null |
Vasily the Programmer loves romance, so this year he decided to illuminate his room with candles.
Vasily has *a* candles.When Vasily lights up a new candle, it first burns for an hour and then it goes out. Vasily is smart, so he can make *b* went out candles into a new candle. As a result, this new candle can be used like any other new candle.
Now Vasily wonders: for how many hours can his candles light up the room if he acts optimally well? Help him find this number.
|
The single line contains two integers, *a* and *b* (1<=≤<=*a*<=≤<=1000; 2<=≤<=*b*<=≤<=1000).
|
Print a single integer — the number of hours Vasily can light up the room for.
|
[
"4 2\n",
"6 3\n"
] |
[
"7\n",
"8\n"
] |
Consider the first sample. For the first four hours Vasily lights up new candles, then he uses four burned out candles to make two new ones and lights them up. When these candles go out (stop burning), Vasily can make another candle. Overall, Vasily can light up the room for 7 hours.
| 500
|
[
{
"input": "4 2",
"output": "7"
},
{
"input": "6 3",
"output": "8"
},
{
"input": "1000 1000",
"output": "1001"
},
{
"input": "123 5",
"output": "153"
},
{
"input": "1000 2",
"output": "1999"
},
{
"input": "1 2",
"output": "1"
},
{
"input": "1 3",
"output": "1"
},
{
"input": "1 4",
"output": "1"
},
{
"input": "2 2",
"output": "3"
},
{
"input": "3 2",
"output": "5"
},
{
"input": "3 3",
"output": "4"
},
{
"input": "999 2",
"output": "1997"
},
{
"input": "1000 3",
"output": "1499"
},
{
"input": "1000 4",
"output": "1333"
},
{
"input": "1 1000",
"output": "1"
},
{
"input": "80 970",
"output": "80"
},
{
"input": "80 970",
"output": "80"
},
{
"input": "80 970",
"output": "80"
},
{
"input": "80 970",
"output": "80"
},
{
"input": "80 970",
"output": "80"
},
{
"input": "80 970",
"output": "80"
},
{
"input": "10 4",
"output": "13"
},
{
"input": "4 3",
"output": "5"
},
{
"input": "91 5",
"output": "113"
},
{
"input": "777 17",
"output": "825"
},
{
"input": "100 4",
"output": "133"
},
{
"input": "5 3",
"output": "7"
},
{
"input": "6 4",
"output": "7"
},
{
"input": "26 8",
"output": "29"
},
{
"input": "9 4",
"output": "11"
},
{
"input": "20 3",
"output": "29"
},
{
"input": "17 3",
"output": "25"
}
] | 1,641,887,097
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 3
| 62
| 0
|
a,b = map(int,input().split())
x=a
c=a
while(x>=b):
x//=b
c+=x
print(c)
|
Title: New Year Candles
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasily the Programmer loves romance, so this year he decided to illuminate his room with candles.
Vasily has *a* candles.When Vasily lights up a new candle, it first burns for an hour and then it goes out. Vasily is smart, so he can make *b* went out candles into a new candle. As a result, this new candle can be used like any other new candle.
Now Vasily wonders: for how many hours can his candles light up the room if he acts optimally well? Help him find this number.
Input Specification:
The single line contains two integers, *a* and *b* (1<=≤<=*a*<=≤<=1000; 2<=≤<=*b*<=≤<=1000).
Output Specification:
Print a single integer — the number of hours Vasily can light up the room for.
Demo Input:
['4 2\n', '6 3\n']
Demo Output:
['7\n', '8\n']
Note:
Consider the first sample. For the first four hours Vasily lights up new candles, then he uses four burned out candles to make two new ones and lights them up. When these candles go out (stop burning), Vasily can make another candle. Overall, Vasily can light up the room for 7 hours.
|
```python
a,b = map(int,input().split())
x=a
c=a
while(x>=b):
x//=b
c+=x
print(c)
```
| 0
|
|
6
|
A
|
Triangle
|
PROGRAMMING
| 900
|
[
"brute force",
"geometry"
] |
A. Triangle
|
2
|
64
|
Johnny has a younger sister Anne, who is very clever and smart. As she came home from the kindergarten, she told his brother about the task that her kindergartener asked her to solve. The task was just to construct a triangle out of four sticks of different colours. Naturally, one of the sticks is extra. It is not allowed to break the sticks or use their partial length. Anne has perfectly solved this task, now she is asking Johnny to do the same.
The boy answered that he would cope with it without any difficulty. However, after a while he found out that different tricky things can occur. It can happen that it is impossible to construct a triangle of a positive area, but it is possible to construct a degenerate triangle. It can be so, that it is impossible to construct a degenerate triangle even. As Johnny is very lazy, he does not want to consider such a big amount of cases, he asks you to help him.
|
The first line of the input contains four space-separated positive integer numbers not exceeding 100 — lengthes of the sticks.
|
Output TRIANGLE if it is possible to construct a non-degenerate triangle. Output SEGMENT if the first case cannot take place and it is possible to construct a degenerate triangle. Output IMPOSSIBLE if it is impossible to construct any triangle. Remember that you are to use three sticks. It is not allowed to break the sticks or use their partial length.
|
[
"4 2 1 3\n",
"7 2 2 4\n",
"3 5 9 1\n"
] |
[
"TRIANGLE\n",
"SEGMENT\n",
"IMPOSSIBLE\n"
] |
none
| 0
|
[
{
"input": "4 2 1 3",
"output": "TRIANGLE"
},
{
"input": "7 2 2 4",
"output": "SEGMENT"
},
{
"input": "3 5 9 1",
"output": "IMPOSSIBLE"
},
{
"input": "3 1 5 1",
"output": "IMPOSSIBLE"
},
{
"input": "10 10 10 10",
"output": "TRIANGLE"
},
{
"input": "11 5 6 11",
"output": "TRIANGLE"
},
{
"input": "1 1 1 1",
"output": "TRIANGLE"
},
{
"input": "10 20 30 40",
"output": "TRIANGLE"
},
{
"input": "45 25 5 15",
"output": "IMPOSSIBLE"
},
{
"input": "20 5 8 13",
"output": "TRIANGLE"
},
{
"input": "10 30 7 20",
"output": "SEGMENT"
},
{
"input": "3 2 3 2",
"output": "TRIANGLE"
},
{
"input": "70 10 100 30",
"output": "SEGMENT"
},
{
"input": "4 8 16 2",
"output": "IMPOSSIBLE"
},
{
"input": "3 3 3 10",
"output": "TRIANGLE"
},
{
"input": "1 5 5 5",
"output": "TRIANGLE"
},
{
"input": "13 25 12 1",
"output": "SEGMENT"
},
{
"input": "10 100 7 3",
"output": "SEGMENT"
},
{
"input": "50 1 50 100",
"output": "TRIANGLE"
},
{
"input": "50 1 100 49",
"output": "SEGMENT"
},
{
"input": "49 51 100 1",
"output": "SEGMENT"
},
{
"input": "5 11 2 25",
"output": "IMPOSSIBLE"
},
{
"input": "91 50 9 40",
"output": "IMPOSSIBLE"
},
{
"input": "27 53 7 97",
"output": "IMPOSSIBLE"
},
{
"input": "51 90 24 8",
"output": "IMPOSSIBLE"
},
{
"input": "3 5 1 1",
"output": "IMPOSSIBLE"
},
{
"input": "13 49 69 15",
"output": "IMPOSSIBLE"
},
{
"input": "16 99 9 35",
"output": "IMPOSSIBLE"
},
{
"input": "27 6 18 53",
"output": "IMPOSSIBLE"
},
{
"input": "57 88 17 8",
"output": "IMPOSSIBLE"
},
{
"input": "95 20 21 43",
"output": "IMPOSSIBLE"
},
{
"input": "6 19 32 61",
"output": "IMPOSSIBLE"
},
{
"input": "100 21 30 65",
"output": "IMPOSSIBLE"
},
{
"input": "85 16 61 9",
"output": "IMPOSSIBLE"
},
{
"input": "5 6 19 82",
"output": "IMPOSSIBLE"
},
{
"input": "1 5 1 3",
"output": "IMPOSSIBLE"
},
{
"input": "65 10 36 17",
"output": "IMPOSSIBLE"
},
{
"input": "81 64 9 7",
"output": "IMPOSSIBLE"
},
{
"input": "11 30 79 43",
"output": "IMPOSSIBLE"
},
{
"input": "1 1 5 3",
"output": "IMPOSSIBLE"
},
{
"input": "21 94 61 31",
"output": "IMPOSSIBLE"
},
{
"input": "49 24 9 74",
"output": "IMPOSSIBLE"
},
{
"input": "11 19 5 77",
"output": "IMPOSSIBLE"
},
{
"input": "52 10 19 71",
"output": "SEGMENT"
},
{
"input": "2 3 7 10",
"output": "SEGMENT"
},
{
"input": "1 2 6 3",
"output": "SEGMENT"
},
{
"input": "2 6 1 8",
"output": "SEGMENT"
},
{
"input": "1 2 4 1",
"output": "SEGMENT"
},
{
"input": "4 10 6 2",
"output": "SEGMENT"
},
{
"input": "2 10 7 3",
"output": "SEGMENT"
},
{
"input": "5 2 3 9",
"output": "SEGMENT"
},
{
"input": "6 1 4 10",
"output": "SEGMENT"
},
{
"input": "10 6 4 1",
"output": "SEGMENT"
},
{
"input": "3 2 9 1",
"output": "SEGMENT"
},
{
"input": "22 80 29 7",
"output": "SEGMENT"
},
{
"input": "2 6 3 9",
"output": "SEGMENT"
},
{
"input": "3 1 2 1",
"output": "SEGMENT"
},
{
"input": "3 4 7 1",
"output": "SEGMENT"
},
{
"input": "8 4 3 1",
"output": "SEGMENT"
},
{
"input": "2 8 3 5",
"output": "SEGMENT"
},
{
"input": "4 1 2 1",
"output": "SEGMENT"
},
{
"input": "8 1 3 2",
"output": "SEGMENT"
},
{
"input": "6 2 1 8",
"output": "SEGMENT"
},
{
"input": "3 3 3 6",
"output": "TRIANGLE"
},
{
"input": "3 6 3 3",
"output": "TRIANGLE"
},
{
"input": "4 10 4 4",
"output": "TRIANGLE"
},
{
"input": "1 1 2 1",
"output": "TRIANGLE"
},
{
"input": "3 3 3 6",
"output": "TRIANGLE"
},
{
"input": "5 4 5 5",
"output": "TRIANGLE"
},
{
"input": "8 7 8 8",
"output": "TRIANGLE"
},
{
"input": "3 3 3 1",
"output": "TRIANGLE"
},
{
"input": "1 1 6 6",
"output": "TRIANGLE"
},
{
"input": "1 9 1 9",
"output": "TRIANGLE"
},
{
"input": "7 2 2 7",
"output": "TRIANGLE"
},
{
"input": "7 2 3 2",
"output": "TRIANGLE"
},
{
"input": "4 4 10 10",
"output": "TRIANGLE"
},
{
"input": "7 7 10 7",
"output": "TRIANGLE"
},
{
"input": "4 4 4 5",
"output": "TRIANGLE"
},
{
"input": "1 10 9 2",
"output": "TRIANGLE"
},
{
"input": "1 8 2 7",
"output": "TRIANGLE"
},
{
"input": "4 3 2 8",
"output": "TRIANGLE"
},
{
"input": "5 9 5 3",
"output": "TRIANGLE"
},
{
"input": "4 10 3 5",
"output": "TRIANGLE"
}
] | 1,627,742,687
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 10
| 216
| 20,172,800
|
a, b, c, d = map(int, input().split())
if a + b > c and a + c > b and b + c > a or a + b > d and a + d > b and b + d > a or a + c > d and a + d > c and c + d > a or b + c > d and b + d > c and c + d > b:
print("TRIANGLE")
elif a + b == c or a + b == d or a + c == b or a + c == d or b + c == a or b + c == d or c + d == a or c + d == b:
print("SEGMENT")
else:
print("IMPOSSIBLE")
|
Title: Triangle
Time Limit: 2 seconds
Memory Limit: 64 megabytes
Problem Description:
Johnny has a younger sister Anne, who is very clever and smart. As she came home from the kindergarten, she told his brother about the task that her kindergartener asked her to solve. The task was just to construct a triangle out of four sticks of different colours. Naturally, one of the sticks is extra. It is not allowed to break the sticks or use their partial length. Anne has perfectly solved this task, now she is asking Johnny to do the same.
The boy answered that he would cope with it without any difficulty. However, after a while he found out that different tricky things can occur. It can happen that it is impossible to construct a triangle of a positive area, but it is possible to construct a degenerate triangle. It can be so, that it is impossible to construct a degenerate triangle even. As Johnny is very lazy, he does not want to consider such a big amount of cases, he asks you to help him.
Input Specification:
The first line of the input contains four space-separated positive integer numbers not exceeding 100 — lengthes of the sticks.
Output Specification:
Output TRIANGLE if it is possible to construct a non-degenerate triangle. Output SEGMENT if the first case cannot take place and it is possible to construct a degenerate triangle. Output IMPOSSIBLE if it is impossible to construct any triangle. Remember that you are to use three sticks. It is not allowed to break the sticks or use their partial length.
Demo Input:
['4 2 1 3\n', '7 2 2 4\n', '3 5 9 1\n']
Demo Output:
['TRIANGLE\n', 'SEGMENT\n', 'IMPOSSIBLE\n']
Note:
none
|
```python
a, b, c, d = map(int, input().split())
if a + b > c and a + c > b and b + c > a or a + b > d and a + d > b and b + d > a or a + c > d and a + d > c and c + d > a or b + c > d and b + d > c and c + d > b:
print("TRIANGLE")
elif a + b == c or a + b == d or a + c == b or a + c == d or b + c == a or b + c == d or c + d == a or c + d == b:
print("SEGMENT")
else:
print("IMPOSSIBLE")
```
| 0
|
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,632,050,258
| 2,147,483,647
|
PyPy 3
|
RUNTIME_ERROR
|
TESTS
| 2
| 108
| 22,528,000
|
a = int(input())
lA = [''] + list(map(int, input().split()))
b = int(input())
lB = [''] + list(map(int, input().split()))
mem = [[-1 for i in range(b+1)] for j in range(a+1)]
succ = [[-1 for i in range(b+1)] for j in range(a+1)]
for i in range(a):
mem[i][0] = 0
for j in range(b):
mem[0][j] = 0
def LCS(i,j):
if mem[i][j] != -1:
return mem[i][j]
if lA[i] == lB[j]:
mem[i][j] = 1 + LCS(i-1, j-1)
succ[i][j] = (i-1,j-1, lA[i])
return mem[i][j]
x = LCS(i-1, j)
y = LCS(i, j-1)
z = max(x,y)
if x > y:
succ[i][j] = (i-1,j, '')
else:
succ[i][j] = (i,j-1, '')
mem[i][j] = z
return z
suite = LCS(a,b)
i,j = a,b
rep = [0]*suite
compteur = suite - 1
while succ[i][j] != -1:
i,j, lettre = succ[i][j]
if lettre != '':
rep[compteur] = lettre
compteur -= 1
dp = [float("inf")]*(suite+1)
pred = [-1]*(suite+1)
dp[0] = -1
ancestor = [-1]*(suite + 1)
for index, elem in enumerate(rep):
indice = -1
bond = suite
while bond > 0:
while indice + bond <= suite and dp[indice+bond] != float("inf") and dp[indice + bond] <= elem:
indice += bond
bond //= 2
indice += 1
if indice <= suite and (dp[indice] > elem or dp[indice] == float("inf")):
dp[indice] = elem
pred[indice] = index
ancestor[index] = pred[indice-1]
depart = 0
for i in range(suite+1):
if dp[i] < float("inf"):
depart = pred[i]
reponse = []
compteur = 0
while depart != -1:
#print(depart)
reponse.append(rep[depart])
depart = ancestor[depart]
compteur += 1
reponse.reverse()
print(compteur)
print(*reponse)
|
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
a = int(input())
lA = [''] + list(map(int, input().split()))
b = int(input())
lB = [''] + list(map(int, input().split()))
mem = [[-1 for i in range(b+1)] for j in range(a+1)]
succ = [[-1 for i in range(b+1)] for j in range(a+1)]
for i in range(a):
mem[i][0] = 0
for j in range(b):
mem[0][j] = 0
def LCS(i,j):
if mem[i][j] != -1:
return mem[i][j]
if lA[i] == lB[j]:
mem[i][j] = 1 + LCS(i-1, j-1)
succ[i][j] = (i-1,j-1, lA[i])
return mem[i][j]
x = LCS(i-1, j)
y = LCS(i, j-1)
z = max(x,y)
if x > y:
succ[i][j] = (i-1,j, '')
else:
succ[i][j] = (i,j-1, '')
mem[i][j] = z
return z
suite = LCS(a,b)
i,j = a,b
rep = [0]*suite
compteur = suite - 1
while succ[i][j] != -1:
i,j, lettre = succ[i][j]
if lettre != '':
rep[compteur] = lettre
compteur -= 1
dp = [float("inf")]*(suite+1)
pred = [-1]*(suite+1)
dp[0] = -1
ancestor = [-1]*(suite + 1)
for index, elem in enumerate(rep):
indice = -1
bond = suite
while bond > 0:
while indice + bond <= suite and dp[indice+bond] != float("inf") and dp[indice + bond] <= elem:
indice += bond
bond //= 2
indice += 1
if indice <= suite and (dp[indice] > elem or dp[indice] == float("inf")):
dp[indice] = elem
pred[indice] = index
ancestor[index] = pred[indice-1]
depart = 0
for i in range(suite+1):
if dp[i] < float("inf"):
depart = pred[i]
reponse = []
compteur = 0
while depart != -1:
#print(depart)
reponse.append(rep[depart])
depart = ancestor[depart]
compteur += 1
reponse.reverse()
print(compteur)
print(*reponse)
```
| -1
|
358
|
A
|
Dima and Continuous Line
|
PROGRAMMING
| 1,400
|
[
"brute force",
"implementation"
] | null | null |
Dima and Seryozha live in an ordinary dormitory room for two. One day Dima had a date with his girl and he asked Seryozha to leave the room. As a compensation, Seryozha made Dima do his homework.
The teacher gave Seryozha the coordinates of *n* distinct points on the abscissa axis and asked to consecutively connect them by semi-circus in a certain order: first connect the first point with the second one, then connect the second point with the third one, then the third one with the fourth one and so on to the *n*-th point. Two points with coordinates (*x*1,<=0) and (*x*2,<=0) should be connected by a semi-circle that passes above the abscissa axis with the diameter that coincides with the segment between points. Seryozha needs to find out if the line on the picture intersects itself. For clarifications, see the picture Seryozha showed to Dima (the left picture has self-intersections, the right picture doesn't have any).
Seryozha is not a small boy, so the coordinates of the points can be rather large. Help Dima cope with the problem.
|
The first line contains a single integer *n* (1<=≤<=*n*<=≤<=103). The second line contains *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=106<=≤<=*x**i*<=≤<=106) — the *i*-th point has coordinates (*x**i*,<=0). The points are not necessarily sorted by their *x* coordinate.
|
In the single line print "yes" (without the quotes), if the line has self-intersections. Otherwise, print "no" (without the quotes).
|
[
"4\n0 10 5 15\n",
"4\n0 15 5 10\n"
] |
[
"yes\n",
"no\n"
] |
The first test from the statement is on the picture to the left, the second test is on the picture to the right.
| 500
|
[
{
"input": "4\n0 10 5 15",
"output": "yes"
},
{
"input": "4\n0 15 5 10",
"output": "no"
},
{
"input": "5\n0 1000 2000 3000 1500",
"output": "yes"
},
{
"input": "5\n-724093 710736 -383722 -359011 439613",
"output": "no"
},
{
"input": "50\n384672 661179 -775591 -989608 611120 442691 601796 502406 384323 -315945 -934146 873993 -156910 -94123 -930137 208544 816236 466922 473696 463604 794454 -872433 -149791 -858684 -467655 -555239 623978 -217138 -408658 493342 -733576 -350871 711210 884148 -426172 519986 -356885 527171 661680 977247 141654 906254 -961045 -759474 -48634 891473 -606365 -513781 -966166 27696",
"output": "yes"
},
{
"input": "100\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100",
"output": "no"
},
{
"input": "11\n1 11 10 2 3 9 8 4 5 7 6",
"output": "no"
},
{
"input": "10\n3 2 4 5 1 6 9 7 8 10",
"output": "yes"
},
{
"input": "11\n3 4 2 5 1 6 11 7 10 8 9",
"output": "no"
},
{
"input": "15\n0 -1 1 2 3 13 12 4 11 10 5 6 7 9 8",
"output": "no"
},
{
"input": "16\n6 7 8 9 5 10 11 12 13 14 15 4 16 2 1 3",
"output": "yes"
},
{
"input": "1\n0",
"output": "no"
},
{
"input": "4\n3 1 4 2",
"output": "yes"
},
{
"input": "5\n0 2 4 -2 5",
"output": "no"
},
{
"input": "5\n1 9 8 7 0",
"output": "yes"
},
{
"input": "3\n5 10 0",
"output": "no"
},
{
"input": "6\n1 3 -1 5 2 4",
"output": "yes"
},
{
"input": "4\n3 2 4 1",
"output": "no"
},
{
"input": "4\n10 5 15 0",
"output": "no"
},
{
"input": "2\n-5 -10",
"output": "no"
},
{
"input": "3\n1 0 3",
"output": "no"
},
{
"input": "4\n-2 -4 1 -3",
"output": "yes"
},
{
"input": "4\n3 6 0 2",
"output": "no"
},
{
"input": "4\n-9 10 -10 0",
"output": "yes"
},
{
"input": "4\n5 10 1 15",
"output": "no"
},
{
"input": "3\n1 0 2",
"output": "no"
},
{
"input": "4\n2 3 4 1",
"output": "no"
},
{
"input": "4\n7 5 9 12",
"output": "no"
}
] | 1,472,021,879
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 12
| 62
| 4,812,800
|
import sys
n = int(input())
inp = input().split()
x = []
for i in range(0,n):
x.append([int(inp[i]),i+1])
x.sort()
"""print(x)
for i in range(0,n):
print(x[i][1])
"""
be = 0
en = n-1
cur = 1
while be != en:
if x[be][1]==cur:
cur += 1
be += 1
elif x[en][1]==cur:
cur += 1
en -= 1
else:
print("yes")
sys.exit()
print("no")
|
Title: Dima and Continuous Line
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Dima and Seryozha live in an ordinary dormitory room for two. One day Dima had a date with his girl and he asked Seryozha to leave the room. As a compensation, Seryozha made Dima do his homework.
The teacher gave Seryozha the coordinates of *n* distinct points on the abscissa axis and asked to consecutively connect them by semi-circus in a certain order: first connect the first point with the second one, then connect the second point with the third one, then the third one with the fourth one and so on to the *n*-th point. Two points with coordinates (*x*1,<=0) and (*x*2,<=0) should be connected by a semi-circle that passes above the abscissa axis with the diameter that coincides with the segment between points. Seryozha needs to find out if the line on the picture intersects itself. For clarifications, see the picture Seryozha showed to Dima (the left picture has self-intersections, the right picture doesn't have any).
Seryozha is not a small boy, so the coordinates of the points can be rather large. Help Dima cope with the problem.
Input Specification:
The first line contains a single integer *n* (1<=≤<=*n*<=≤<=103). The second line contains *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=106<=≤<=*x**i*<=≤<=106) — the *i*-th point has coordinates (*x**i*,<=0). The points are not necessarily sorted by their *x* coordinate.
Output Specification:
In the single line print "yes" (without the quotes), if the line has self-intersections. Otherwise, print "no" (without the quotes).
Demo Input:
['4\n0 10 5 15\n', '4\n0 15 5 10\n']
Demo Output:
['yes\n', 'no\n']
Note:
The first test from the statement is on the picture to the left, the second test is on the picture to the right.
|
```python
import sys
n = int(input())
inp = input().split()
x = []
for i in range(0,n):
x.append([int(inp[i]),i+1])
x.sort()
"""print(x)
for i in range(0,n):
print(x[i][1])
"""
be = 0
en = n-1
cur = 1
while be != en:
if x[be][1]==cur:
cur += 1
be += 1
elif x[en][1]==cur:
cur += 1
en -= 1
else:
print("yes")
sys.exit()
print("no")
```
| 0
|
|
250
|
B
|
Restoring IPv6
|
PROGRAMMING
| 1,500
|
[
"implementation",
"strings"
] | null | null |
An IPv6-address is a 128-bit number. For convenience, this number is recorded in blocks of 16 bits in hexadecimal record, the blocks are separated by colons — 8 blocks in total, each block has four hexadecimal digits. Here is an example of the correct record of a IPv6 address: "0124:5678:90ab:cdef:0124:5678:90ab:cdef". We'll call such format of recording an IPv6-address full.
Besides the full record of an IPv6 address there is a short record format. The record of an IPv6 address can be shortened by removing one or more leading zeroes at the beginning of each block. However, each block should contain at least one digit in the short format. For example, the leading zeroes can be removed like that: "a56f:00d3:0000:0124:0001:f19a:1000:0000" <=→<= "a56f:d3:0:0124:01:f19a:1000:00". There are more ways to shorten zeroes in this IPv6 address.
Some IPv6 addresses contain long sequences of zeroes. Continuous sequences of 16-bit zero blocks can be shortened to "::". A sequence can consist of one or several consecutive blocks, with all 16 bits equal to 0.
You can see examples of zero block shortenings below:
- "a56f:00d3:0000:0124:0001:0000:0000:0000" <=→<= "a56f:00d3:0000:0124:0001::"; - "a56f:0000:0000:0124:0001:0000:1234:0ff0" <=→<= "a56f::0124:0001:0000:1234:0ff0"; - "a56f:0000:0000:0000:0001:0000:1234:0ff0" <=→<= "a56f:0000::0000:0001:0000:1234:0ff0"; - "a56f:00d3:0000:0124:0001:0000:0000:0000" <=→<= "a56f:00d3:0000:0124:0001::0000"; - "0000:0000:0000:0000:0000:0000:0000:0000" <=→<= "::".
It is not allowed to shorten zero blocks in the address more than once. This means that the short record can't contain the sequence of characters "::" more than once. Otherwise, it will sometimes be impossible to determine the number of zero blocks, each represented by a double colon.
The format of the record of the IPv6 address after removing the leading zeroes and shortening the zero blocks is called short.
You've got several short records of IPv6 addresses. Restore their full record.
|
The first line contains a single integer *n* — the number of records to restore (1<=≤<=*n*<=≤<=100).
Each of the following *n* lines contains a string — the short IPv6 addresses. Each string only consists of string characters "0123456789abcdef:".
It is guaranteed that each short address is obtained by the way that is described in the statement from some full IPv6 address.
|
For each short IPv6 address from the input print its full record on a separate line. Print the full records for the short IPv6 addresses in the order, in which the short records follow in the input.
|
[
"6\na56f:d3:0:0124:01:f19a:1000:00\na56f:00d3:0000:0124:0001::\na56f::0124:0001:0000:1234:0ff0\na56f:0000::0000:0001:0000:1234:0ff0\n::\n0ea::4d:f4:6:0\n"
] |
[
"a56f:00d3:0000:0124:0001:f19a:1000:0000\na56f:00d3:0000:0124:0001:0000:0000:0000\na56f:0000:0000:0124:0001:0000:1234:0ff0\na56f:0000:0000:0000:0001:0000:1234:0ff0\n0000:0000:0000:0000:0000:0000:0000:0000\n00ea:0000:0000:0000:004d:00f4:0006:0000\n"
] |
none
| 1,000
|
[
{
"input": "6\na56f:d3:0:0124:01:f19a:1000:00\na56f:00d3:0000:0124:0001::\na56f::0124:0001:0000:1234:0ff0\na56f:0000::0000:0001:0000:1234:0ff0\n::\n0ea::4d:f4:6:0",
"output": "a56f:00d3:0000:0124:0001:f19a:1000:0000\na56f:00d3:0000:0124:0001:0000:0000:0000\na56f:0000:0000:0124:0001:0000:1234:0ff0\na56f:0000:0000:0000:0001:0000:1234:0ff0\n0000:0000:0000:0000:0000:0000:0000:0000\n00ea:0000:0000:0000:004d:00f4:0006:0000"
},
{
"input": "20\n0:0:9e39:9:b21:c9b:c:0\n0:0:0:0:0:a27:6b:cb0a\n2:7:4d:b:0:3:2:f401\n17:2dc6::0:89e3:0:dc:0\nca:4:0:0:d6:b999:e:0\n4af:553:b29:dd7:2:5b:0:7\n0:c981:8f:a4d:0:d4:0:f61\n0:0:1:0:dc33:0:1964:0\n84:da:0:6d6:0ecc:1:f:0\n4:fb:4d37:0:8c:4:4a52:24\nc:e:a:0:0:0:e:0\n0:3761:72ed:b7:3b0:ff7:fc:102\n5ae:8ca7:10::0:9b2:0:525a\n0::ab:8d64:86:767:2\ne6b:3cb:0:81ce:0ac4:11::1\n4:0:5238:7b:591d:ff15:0:e\n0:f9a5:0::118e:dde:0\n0:d4c:feb:b:10a:0:d:e\n0:0:0:ff38:b5d:a3c2:f3:0\n2:a:6:c50:83:4f:7f0d::",
"output": "0000:0000:9e39:0009:0b21:0c9b:000c:0000\n0000:0000:0000:0000:0000:0a27:006b:cb0a\n0002:0007:004d:000b:0000:0003:0002:f401\n0017:2dc6:0000:0000:89e3:0000:00dc:0000\n00ca:0004:0000:0000:00d6:b999:000e:0000\n04af:0553:0b29:0dd7:0002:005b:0000:0007\n0000:c981:008f:0a4d:0000:00d4:0000:0f61\n0000:0000:0001:0000:dc33:0000:1964:0000\n0084:00da:0000:06d6:0ecc:0001:000f:0000\n0004:00fb:4d37:0000:008c:0004:4a52:0024\n000c:000e:000a:0000:0000:0000:000e:0000\n0000:3761:72ed:00b7:03b0:0ff7:00fc:0102\n05ae:8ca7:0010:0000..."
},
{
"input": "10\n1::7\n0:0::1\n::1ed\n::30:44\n::eaf:ff:000b\n56fe::\ndf0:3df::\nd03:ab:0::\n85::0485:0\n::",
"output": "0001:0000:0000:0000:0000:0000:0000:0007\n0000:0000:0000:0000:0000:0000:0000:0001\n0000:0000:0000:0000:0000:0000:0000:01ed\n0000:0000:0000:0000:0000:0000:0030:0044\n0000:0000:0000:0000:0000:0eaf:00ff:000b\n56fe:0000:0000:0000:0000:0000:0000:0000\n0df0:03df:0000:0000:0000:0000:0000:0000\n0d03:00ab:0000:0000:0000:0000:0000:0000\n0085:0000:0000:0000:0000:0000:0485:0000\n0000:0000:0000:0000:0000:0000:0000:0000"
},
{
"input": "6\n0:00:000:0000::\n1:01:001:0001::\nf:0f:00f:000f::\n1:10:100:1000::\nf:f0:f00:f000::\nf:ff:fff:ffff::",
"output": "0000:0000:0000:0000:0000:0000:0000:0000\n0001:0001:0001:0001:0000:0000:0000:0000\n000f:000f:000f:000f:0000:0000:0000:0000\n0001:0010:0100:1000:0000:0000:0000:0000\n000f:00f0:0f00:f000:0000:0000:0000:0000\n000f:00ff:0fff:ffff:0000:0000:0000:0000"
},
{
"input": "3\n::\n::\n::",
"output": "0000:0000:0000:0000:0000:0000:0000:0000\n0000:0000:0000:0000:0000:0000:0000:0000\n0000:0000:0000:0000:0000:0000:0000:0000"
},
{
"input": "4\n1:2:3:4:5:6:7:8\n0:0:0:0:0:0:0:0\nf:0f:00f:000f:ff:0ff:00ff:fff\n0fff:0ff0:0f0f:f0f:0f0:f0f0:f00f:ff0f",
"output": "0001:0002:0003:0004:0005:0006:0007:0008\n0000:0000:0000:0000:0000:0000:0000:0000\n000f:000f:000f:000f:00ff:00ff:00ff:0fff\n0fff:0ff0:0f0f:0f0f:00f0:f0f0:f00f:ff0f"
}
] | 1,672,306,961
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 40
| 92
| 0
|
n = int(input())
for i in range(n):
s = input().split(':')
if (s[0] == ''):
s[0] = '0'*4
if s[-1] == '':
s[-1] = '0'*4
idx = -1
for i in range(len(s)):
if s[i] == '':
idx = i
break
for i in range(len(s)):
if (len(s[i]) < 4):
s[i] = (4-len(s[i]))*'0'+s[i]
if idx != -1:
s[idx:idx+1] = (8-len(s)+1)*['0'*4]
print(':'.join(s))
|
Title: Restoring IPv6
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
An IPv6-address is a 128-bit number. For convenience, this number is recorded in blocks of 16 bits in hexadecimal record, the blocks are separated by colons — 8 blocks in total, each block has four hexadecimal digits. Here is an example of the correct record of a IPv6 address: "0124:5678:90ab:cdef:0124:5678:90ab:cdef". We'll call such format of recording an IPv6-address full.
Besides the full record of an IPv6 address there is a short record format. The record of an IPv6 address can be shortened by removing one or more leading zeroes at the beginning of each block. However, each block should contain at least one digit in the short format. For example, the leading zeroes can be removed like that: "a56f:00d3:0000:0124:0001:f19a:1000:0000" <=→<= "a56f:d3:0:0124:01:f19a:1000:00". There are more ways to shorten zeroes in this IPv6 address.
Some IPv6 addresses contain long sequences of zeroes. Continuous sequences of 16-bit zero blocks can be shortened to "::". A sequence can consist of one or several consecutive blocks, with all 16 bits equal to 0.
You can see examples of zero block shortenings below:
- "a56f:00d3:0000:0124:0001:0000:0000:0000" <=→<= "a56f:00d3:0000:0124:0001::"; - "a56f:0000:0000:0124:0001:0000:1234:0ff0" <=→<= "a56f::0124:0001:0000:1234:0ff0"; - "a56f:0000:0000:0000:0001:0000:1234:0ff0" <=→<= "a56f:0000::0000:0001:0000:1234:0ff0"; - "a56f:00d3:0000:0124:0001:0000:0000:0000" <=→<= "a56f:00d3:0000:0124:0001::0000"; - "0000:0000:0000:0000:0000:0000:0000:0000" <=→<= "::".
It is not allowed to shorten zero blocks in the address more than once. This means that the short record can't contain the sequence of characters "::" more than once. Otherwise, it will sometimes be impossible to determine the number of zero blocks, each represented by a double colon.
The format of the record of the IPv6 address after removing the leading zeroes and shortening the zero blocks is called short.
You've got several short records of IPv6 addresses. Restore their full record.
Input Specification:
The first line contains a single integer *n* — the number of records to restore (1<=≤<=*n*<=≤<=100).
Each of the following *n* lines contains a string — the short IPv6 addresses. Each string only consists of string characters "0123456789abcdef:".
It is guaranteed that each short address is obtained by the way that is described in the statement from some full IPv6 address.
Output Specification:
For each short IPv6 address from the input print its full record on a separate line. Print the full records for the short IPv6 addresses in the order, in which the short records follow in the input.
Demo Input:
['6\na56f:d3:0:0124:01:f19a:1000:00\na56f:00d3:0000:0124:0001::\na56f::0124:0001:0000:1234:0ff0\na56f:0000::0000:0001:0000:1234:0ff0\n::\n0ea::4d:f4:6:0\n']
Demo Output:
['a56f:00d3:0000:0124:0001:f19a:1000:0000\na56f:00d3:0000:0124:0001:0000:0000:0000\na56f:0000:0000:0124:0001:0000:1234:0ff0\na56f:0000:0000:0000:0001:0000:1234:0ff0\n0000:0000:0000:0000:0000:0000:0000:0000\n00ea:0000:0000:0000:004d:00f4:0006:0000\n']
Note:
none
|
```python
n = int(input())
for i in range(n):
s = input().split(':')
if (s[0] == ''):
s[0] = '0'*4
if s[-1] == '':
s[-1] = '0'*4
idx = -1
for i in range(len(s)):
if s[i] == '':
idx = i
break
for i in range(len(s)):
if (len(s[i]) < 4):
s[i] = (4-len(s[i]))*'0'+s[i]
if idx != -1:
s[idx:idx+1] = (8-len(s)+1)*['0'*4]
print(':'.join(s))
```
| 3
|
|
658
|
A
|
Bear and Reverse Radewoosh
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be *n* problems. The *i*-th problem has initial score *p**i* and it takes exactly *t**i* minutes to solve it. Problems are sorted by difficulty — it's guaranteed that *p**i*<=<<=*p**i*<=+<=1 and *t**i*<=<<=*t**i*<=+<=1.
A constant *c* is given too, representing the speed of loosing points. Then, submitting the *i*-th problem at time *x* (*x* minutes after the start of the contest) gives *max*(0,<= *p**i*<=-<=*c*·*x*) points.
Limak is going to solve problems in order 1,<=2,<=...,<=*n* (sorted increasingly by *p**i*). Radewoosh is going to solve them in order *n*,<=*n*<=-<=1,<=...,<=1 (sorted decreasingly by *p**i*). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all *t**i*. That means both Limak and Radewoosh will accept all *n* problems.
|
The first line contains two integers *n* and *c* (1<=≤<=*n*<=≤<=50,<=1<=≤<=*c*<=≤<=1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains *n* integers *p*1,<=*p*2,<=...,<=*p**n* (1<=≤<=*p**i*<=≤<=1000,<=*p**i*<=<<=*p**i*<=+<=1) — initial scores.
The third line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=1000,<=*t**i*<=<<=*t**i*<=+<=1) where *t**i* denotes the number of minutes one needs to solve the *i*-th problem.
|
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
|
[
"3 2\n50 85 250\n10 15 25\n",
"3 6\n50 85 250\n10 15 25\n",
"8 1\n10 20 30 40 50 60 70 80\n8 10 58 63 71 72 75 76\n"
] |
[
"Limak\n",
"Radewoosh\n",
"Tie\n"
] |
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - *c*·10 = 50 - 2·10 = 30 points. 1. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points. 1. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points. 1. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem. 1. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets *max*(0, 50 - 2·50) = *max*(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
| 500
|
[
{
"input": "3 2\n50 85 250\n10 15 25",
"output": "Limak"
},
{
"input": "3 6\n50 85 250\n10 15 25",
"output": "Radewoosh"
},
{
"input": "8 1\n10 20 30 40 50 60 70 80\n8 10 58 63 71 72 75 76",
"output": "Tie"
},
{
"input": "4 1\n3 5 6 9\n1 2 4 8",
"output": "Limak"
},
{
"input": "4 1\n1 3 6 10\n1 5 7 8",
"output": "Radewoosh"
},
{
"input": "4 1\n2 4 5 10\n2 3 9 10",
"output": "Tie"
},
{
"input": "18 4\n68 97 121 132 146 277 312 395 407 431 458 461 595 634 751 855 871 994\n1 2 3 4 9 10 13 21 22 29 31 34 37 38 39 41 48 49",
"output": "Radewoosh"
},
{
"input": "50 1\n5 14 18 73 137 187 195 197 212 226 235 251 262 278 287 304 310 322 342 379 393 420 442 444 448 472 483 485 508 515 517 523 559 585 618 627 636 646 666 682 703 707 780 853 937 951 959 989 991 992\n30 84 113 173 199 220 235 261 266 277 300 306 310 312 347 356 394 396 397 409 414 424 446 462 468 487 507 517 537 566 594 643 656 660 662 668 706 708 773 774 779 805 820 827 868 896 929 942 961 995",
"output": "Tie"
},
{
"input": "4 1\n4 6 9 10\n2 3 4 5",
"output": "Radewoosh"
},
{
"input": "4 1\n4 6 9 10\n3 4 5 7",
"output": "Radewoosh"
},
{
"input": "4 1\n1 6 7 10\n2 7 8 10",
"output": "Tie"
},
{
"input": "4 1\n4 5 7 9\n1 4 5 8",
"output": "Limak"
},
{
"input": "50 1\n6 17 44 82 94 127 134 156 187 211 212 252 256 292 294 303 352 355 379 380 398 409 424 434 480 524 584 594 631 714 745 756 777 778 789 793 799 821 841 849 859 878 879 895 925 932 944 952 958 990\n15 16 40 42 45 71 99 100 117 120 174 181 186 204 221 268 289 332 376 394 403 409 411 444 471 487 499 539 541 551 567 589 619 623 639 669 689 722 735 776 794 822 830 840 847 907 917 927 936 988",
"output": "Radewoosh"
},
{
"input": "50 10\n25 49 52 73 104 117 127 136 149 164 171 184 226 251 257 258 286 324 337 341 386 390 428 453 464 470 492 517 543 565 609 634 636 660 678 693 710 714 729 736 739 749 781 836 866 875 956 960 977 979\n2 4 7 10 11 22 24 26 27 28 31 35 37 38 42 44 45 46 52 53 55 56 57 59 60 61 64 66 67 68 69 71 75 76 77 78 79 81 83 85 86 87 89 90 92 93 94 98 99 100",
"output": "Limak"
},
{
"input": "50 10\n11 15 25 71 77 83 95 108 143 150 182 183 198 203 213 223 279 280 346 348 350 355 375 376 412 413 415 432 470 545 553 562 589 595 607 633 635 637 688 719 747 767 771 799 842 883 905 924 942 944\n1 3 5 6 7 10 11 12 13 14 15 16 19 20 21 23 25 32 35 36 37 38 40 41 42 43 47 50 51 54 55 56 57 58 59 60 62 63 64 65 66 68 69 70 71 72 73 75 78 80",
"output": "Radewoosh"
},
{
"input": "32 6\n25 77 141 148 157 159 192 196 198 244 245 255 332 392 414 457 466 524 575 603 629 700 738 782 838 841 845 847 870 945 984 985\n1 2 4 5 8 9 10 12 13 14 15 16 17 18 20 21 22 23 24 26 28 31 38 39 40 41 42 43 45 47 48 49",
"output": "Radewoosh"
},
{
"input": "5 1\n256 275 469 671 842\n7 9 14 17 26",
"output": "Limak"
},
{
"input": "2 1000\n1 2\n1 2",
"output": "Tie"
},
{
"input": "3 1\n1 50 809\n2 8 800",
"output": "Limak"
},
{
"input": "1 13\n866\n10",
"output": "Tie"
},
{
"input": "15 1\n9 11 66 128 199 323 376 386 393 555 585 718 935 960 971\n3 11 14 19 20 21 24 26 32 38 40 42 44 47 50",
"output": "Limak"
},
{
"input": "1 10\n546\n45",
"output": "Tie"
},
{
"input": "50 20\n21 43 51 99 117 119 158 167 175 190 196 244 250 316 335 375 391 403 423 428 451 457 460 480 487 522 539 559 566 584 598 602 604 616 626 666 675 730 771 787 828 841 861 867 886 889 898 970 986 991\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50",
"output": "Limak"
},
{
"input": "50 21\n13 20 22 38 62 84 118 135 141 152 170 175 194 218 227 229 232 253 260 263 278 313 329 357 396 402 422 452 454 533 575 576 580 594 624 644 653 671 676 759 789 811 816 823 831 833 856 924 933 987\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50",
"output": "Tie"
},
{
"input": "1 36\n312\n42",
"output": "Tie"
},
{
"input": "1 1000\n1\n1000",
"output": "Tie"
},
{
"input": "1 1\n1000\n1",
"output": "Tie"
},
{
"input": "50 35\n9 17 28 107 136 152 169 174 186 188 201 262 291 312 324 330 341 358 385 386 393 397 425 431 479 498 502 523 530 540 542 554 578 588 622 623 684 696 709 722 784 819 836 845 850 932 945 969 983 984\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50",
"output": "Tie"
},
{
"input": "50 20\n12 113 116 120 138 156 167 183 185 194 211 228 234 261 278 287 310 317 346 361 364 397 424 470 496 522 527 536 611 648 668 704 707 712 717 752 761 766 815 828 832 864 872 885 889 901 904 929 982 993\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50",
"output": "Limak"
}
] | 1,562,334,814
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 29
| 124
| 0
|
m,n = list(map(int,input().split(' ')))
l1= list(map(int,input().split(' ')))
l2= list(map(int,input().split(' ')))
k1=0
t=0
k2=0
for i in range(m):
t = t+l2[i]
c=l1[i] -n*t
if c>0:
k1=k1+c
i=m-1
t=0
while i>=0:
t = t+l2[i]
c=l1[i]-n*t
if c>0:
k2=k2+c
i=i-1
if k1>k2:
print('Limak')
elif k1<k2:
print('Radewoosh')
else:
print('Tie')
|
Title: Bear and Reverse Radewoosh
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Limak and Radewoosh are going to compete against each other in the upcoming algorithmic contest. They are equally skilled but they won't solve problems in the same order.
There will be *n* problems. The *i*-th problem has initial score *p**i* and it takes exactly *t**i* minutes to solve it. Problems are sorted by difficulty — it's guaranteed that *p**i*<=<<=*p**i*<=+<=1 and *t**i*<=<<=*t**i*<=+<=1.
A constant *c* is given too, representing the speed of loosing points. Then, submitting the *i*-th problem at time *x* (*x* minutes after the start of the contest) gives *max*(0,<= *p**i*<=-<=*c*·*x*) points.
Limak is going to solve problems in order 1,<=2,<=...,<=*n* (sorted increasingly by *p**i*). Radewoosh is going to solve them in order *n*,<=*n*<=-<=1,<=...,<=1 (sorted decreasingly by *p**i*). Your task is to predict the outcome — print the name of the winner (person who gets more points at the end) or a word "Tie" in case of a tie.
You may assume that the duration of the competition is greater or equal than the sum of all *t**i*. That means both Limak and Radewoosh will accept all *n* problems.
Input Specification:
The first line contains two integers *n* and *c* (1<=≤<=*n*<=≤<=50,<=1<=≤<=*c*<=≤<=1000) — the number of problems and the constant representing the speed of loosing points.
The second line contains *n* integers *p*1,<=*p*2,<=...,<=*p**n* (1<=≤<=*p**i*<=≤<=1000,<=*p**i*<=<<=*p**i*<=+<=1) — initial scores.
The third line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=1000,<=*t**i*<=<<=*t**i*<=+<=1) where *t**i* denotes the number of minutes one needs to solve the *i*-th problem.
Output Specification:
Print "Limak" (without quotes) if Limak will get more points in total. Print "Radewoosh" (without quotes) if Radewoosh will get more points in total. Print "Tie" (without quotes) if Limak and Radewoosh will get the same total number of points.
Demo Input:
['3 2\n50 85 250\n10 15 25\n', '3 6\n50 85 250\n10 15 25\n', '8 1\n10 20 30 40 50 60 70 80\n8 10 58 63 71 72 75 76\n']
Demo Output:
['Limak\n', 'Radewoosh\n', 'Tie\n']
Note:
In the first sample, there are 3 problems. Limak solves them as follows:
1. Limak spends 10 minutes on the 1-st problem and he gets 50 - *c*·10 = 50 - 2·10 = 30 points. 1. Limak spends 15 minutes on the 2-nd problem so he submits it 10 + 15 = 25 minutes after the start of the contest. For the 2-nd problem he gets 85 - 2·25 = 35 points. 1. He spends 25 minutes on the 3-rd problem so he submits it 10 + 15 + 25 = 50 minutes after the start. For this problem he gets 250 - 2·50 = 150 points.
So, Limak got 30 + 35 + 150 = 215 points.
Radewoosh solves problem in the reversed order:
1. Radewoosh solves 3-rd problem after 25 minutes so he gets 250 - 2·25 = 200 points. 1. He spends 15 minutes on the 2-nd problem so he submits it 25 + 15 = 40 minutes after the start. He gets 85 - 2·40 = 5 points for this problem. 1. He spends 10 minutes on the 1-st problem so he submits it 25 + 15 + 10 = 50 minutes after the start. He gets *max*(0, 50 - 2·50) = *max*(0, - 50) = 0 points.
Radewoosh got 200 + 5 + 0 = 205 points in total. Limak has 215 points so Limak wins.
In the second sample, Limak will get 0 points for each problem and Radewoosh will first solve the hardest problem and he will get 250 - 6·25 = 100 points for that. Radewoosh will get 0 points for other two problems but he is the winner anyway.
In the third sample, Limak will get 2 points for the 1-st problem and 2 points for the 2-nd problem. Radewoosh will get 4 points for the 8-th problem. They won't get points for other problems and thus there is a tie because 2 + 2 = 4.
|
```python
m,n = list(map(int,input().split(' ')))
l1= list(map(int,input().split(' ')))
l2= list(map(int,input().split(' ')))
k1=0
t=0
k2=0
for i in range(m):
t = t+l2[i]
c=l1[i] -n*t
if c>0:
k1=k1+c
i=m-1
t=0
while i>=0:
t = t+l2[i]
c=l1[i]-n*t
if c>0:
k2=k2+c
i=i-1
if k1>k2:
print('Limak')
elif k1<k2:
print('Radewoosh')
else:
print('Tie')
```
| 3
|
|
673
|
A
|
Bear and Game
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Bear Limak likes watching sports on TV. He is going to watch a game today. The game lasts 90 minutes and there are no breaks.
Each minute can be either interesting or boring. If 15 consecutive minutes are boring then Limak immediately turns TV off.
You know that there will be *n* interesting minutes *t*1,<=*t*2,<=...,<=*t**n*. Your task is to calculate for how many minutes Limak will watch the game.
|
The first line of the input contains one integer *n* (1<=≤<=*n*<=≤<=90) — the number of interesting minutes.
The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t*1<=<<=*t*2<=<<=... *t**n*<=≤<=90), given in the increasing order.
|
Print the number of minutes Limak will watch the game.
|
[
"3\n7 20 88\n",
"9\n16 20 30 40 50 60 70 80 90\n",
"9\n15 20 30 40 50 60 70 80 90\n"
] |
[
"35\n",
"15\n",
"90\n"
] |
In the first sample, minutes 21, 22, ..., 35 are all boring and thus Limak will turn TV off immediately after the 35-th minute. So, he would watch the game for 35 minutes.
In the second sample, the first 15 minutes are boring.
In the third sample, there are no consecutive 15 boring minutes. So, Limak will watch the whole game.
| 500
|
[
{
"input": "3\n7 20 88",
"output": "35"
},
{
"input": "9\n16 20 30 40 50 60 70 80 90",
"output": "15"
},
{
"input": "9\n15 20 30 40 50 60 70 80 90",
"output": "90"
},
{
"input": "30\n6 11 12 15 22 24 30 31 32 33 34 35 40 42 44 45 47 50 53 54 57 58 63 67 75 77 79 81 83 88",
"output": "90"
},
{
"input": "60\n1 2 4 5 6 7 11 14 16 18 20 21 22 23 24 25 26 33 34 35 36 37 38 39 41 42 43 44 46 47 48 49 52 55 56 57 58 59 60 61 63 64 65 67 68 70 71 72 73 74 75 77 78 80 82 83 84 85 86 88",
"output": "90"
},
{
"input": "90\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90",
"output": "90"
},
{
"input": "1\n1",
"output": "16"
},
{
"input": "5\n15 30 45 60 75",
"output": "90"
},
{
"input": "6\n14 29 43 59 70 74",
"output": "58"
},
{
"input": "1\n15",
"output": "30"
},
{
"input": "1\n16",
"output": "15"
},
{
"input": "14\n14 22 27 31 35 44 46 61 62 69 74 79 88 89",
"output": "90"
},
{
"input": "76\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90",
"output": "90"
},
{
"input": "1\n90",
"output": "15"
},
{
"input": "6\n13 17 32 47 60 66",
"output": "81"
},
{
"input": "84\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84",
"output": "90"
},
{
"input": "9\n6 20 27 28 40 53 59 70 85",
"output": "90"
},
{
"input": "12\n14 22 27 31 35 44 62 69 74 79 88 89",
"output": "59"
},
{
"input": "5\n15 30 45 60 74",
"output": "89"
},
{
"input": "72\n3 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 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89",
"output": "54"
},
{
"input": "8\n1 16 30 31 32 33 34 50",
"output": "49"
},
{
"input": "12\n1 3 6 10 15 21 28 36 45 55 66 78",
"output": "90"
},
{
"input": "25\n1 2 3 4 5 6 7 8 9 10 11 23 36 50 65 81 82 83 84 85 86 87 88 89 90",
"output": "80"
},
{
"input": "8\n5 17 20 35 42 53 67 76",
"output": "90"
},
{
"input": "9\n15 28 39 48 55 60 63 64 74",
"output": "89"
},
{
"input": "10\n15 28 39 48 55 60 63 64 74 82",
"output": "90"
},
{
"input": "2\n1 18",
"output": "16"
},
{
"input": "9\n10 20 30 40 50 60 70 80 84",
"output": "90"
},
{
"input": "2\n16 50",
"output": "15"
},
{
"input": "6\n15 30 45 60 75 84",
"output": "90"
},
{
"input": "8\n15 20 30 40 50 60 73 83",
"output": "90"
},
{
"input": "8\n10 20 30 40 50 60 70 80",
"output": "90"
},
{
"input": "3\n1 20 90",
"output": "16"
},
{
"input": "6\n15 30 45 60 74 89",
"output": "90"
}
] | 1,546,760,302
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 93
| 0
|
x = int(input())
y = list(map(int, input().split(' ')))
offset = 0
watched = 0
base = 15
for t in y:
duration = t - offset
if duration > base:
watched = offset + base
break
else:
watched = t
offset = t
print(watched)
|
Title: Bear and Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bear Limak likes watching sports on TV. He is going to watch a game today. The game lasts 90 minutes and there are no breaks.
Each minute can be either interesting or boring. If 15 consecutive minutes are boring then Limak immediately turns TV off.
You know that there will be *n* interesting minutes *t*1,<=*t*2,<=...,<=*t**n*. Your task is to calculate for how many minutes Limak will watch the game.
Input Specification:
The first line of the input contains one integer *n* (1<=≤<=*n*<=≤<=90) — the number of interesting minutes.
The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t*1<=<<=*t*2<=<<=... *t**n*<=≤<=90), given in the increasing order.
Output Specification:
Print the number of minutes Limak will watch the game.
Demo Input:
['3\n7 20 88\n', '9\n16 20 30 40 50 60 70 80 90\n', '9\n15 20 30 40 50 60 70 80 90\n']
Demo Output:
['35\n', '15\n', '90\n']
Note:
In the first sample, minutes 21, 22, ..., 35 are all boring and thus Limak will turn TV off immediately after the 35-th minute. So, he would watch the game for 35 minutes.
In the second sample, the first 15 minutes are boring.
In the third sample, there are no consecutive 15 boring minutes. So, Limak will watch the whole game.
|
```python
x = int(input())
y = list(map(int, input().split(' ')))
offset = 0
watched = 0
base = 15
for t in y:
duration = t - offset
if duration > base:
watched = offset + base
break
else:
watched = t
offset = t
print(watched)
```
| 0
|
|
59
|
A
|
Word
|
PROGRAMMING
| 800
|
[
"implementation",
"strings"
] |
A. Word
|
2
|
256
|
Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At that as little as possible letters should be changed in the word. For example, the word HoUse must be replaced with house, and the word ViP — with VIP. If a word contains an equal number of uppercase and lowercase letters, you should replace all the letters with lowercase ones. For example, maTRIx should be replaced by matrix. Your task is to use the given method on one given word.
|
The first line contains a word *s* — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100.
|
Print the corrected word *s*. If the given word *s* has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one.
|
[
"HoUse\n",
"ViP\n",
"maTRIx\n"
] |
[
"house\n",
"VIP\n",
"matrix\n"
] |
none
| 500
|
[
{
"input": "HoUse",
"output": "house"
},
{
"input": "ViP",
"output": "VIP"
},
{
"input": "maTRIx",
"output": "matrix"
},
{
"input": "BNHWpnpawg",
"output": "bnhwpnpawg"
},
{
"input": "VTYGP",
"output": "VTYGP"
},
{
"input": "CHNenu",
"output": "chnenu"
},
{
"input": "ERPZGrodyu",
"output": "erpzgrodyu"
},
{
"input": "KSXBXWpebh",
"output": "KSXBXWPEBH"
},
{
"input": "qvxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaiv",
"output": "qvxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaiv"
},
{
"input": "Amnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfd",
"output": "amnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfd"
},
{
"input": "ISAGFJFARYFBLOPQDSHWGMCNKMFTLVFUGNJEWGWNBLXUIATXEkqiettmmjgydwcpafqrppdsrrrtguinqbgmzzfqwonkpgpcwenv",
"output": "isagfjfaryfblopqdshwgmcnkmftlvfugnjewgwnblxuiatxekqiettmmjgydwcpafqrppdsrrrtguinqbgmzzfqwonkpgpcwenv"
},
{
"input": "XHRPXZEGHSOCJPICUIXSKFUZUPYTSGJSDIYBCMNMNBPNDBXLXBzhbfnqvwcffvrdhtickyqhupmcehlsyvncqmfhautvxudqdhgg",
"output": "xhrpxzeghsocjpicuixskfuzupytsgjsdiybcmnmnbpndbxlxbzhbfnqvwcffvrdhtickyqhupmcehlsyvncqmfhautvxudqdhgg"
},
{
"input": "RJIQZMJCIMSNDBOHBRAWIENODSALETAKGKPYUFGVEFGCBRENZGAdkcetqjljtmttlonpekcovdzebzdkzggwfsxhapmjkdbuceak",
"output": "RJIQZMJCIMSNDBOHBRAWIENODSALETAKGKPYUFGVEFGCBRENZGADKCETQJLJTMTTLONPEKCOVDZEBZDKZGGWFSXHAPMJKDBUCEAK"
},
{
"input": "DWLWOBHNMMGTFOLFAECKBRNNGLYLYDXTGTVRLMEESZOIUATZZZXUFUZDLSJXMEVRTESSFBWLNZZCLCQWEVNNUCXYVHNGNXHCBDFw",
"output": "DWLWOBHNMMGTFOLFAECKBRNNGLYLYDXTGTVRLMEESZOIUATZZZXUFUZDLSJXMEVRTESSFBWLNZZCLCQWEVNNUCXYVHNGNXHCBDFW"
},
{
"input": "NYCNHJWGBOCOTSPETKKHVWFGAQYNHOVJWJHCIEFOUQZXOYUIEQDZALFKTEHTVDBVJMEUBJUBCMNVPWGDPNCHQHZJRCHYRFPVIGUB",
"output": "NYCNHJWGBOCOTSPETKKHVWFGAQYNHOVJWJHCIEFOUQZXOYUIEQDZALFKTEHTVDBVJMEUBJUBCMNVPWGDPNCHQHZJRCHYRFPVIGUB"
},
{
"input": "igxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwge",
"output": "igxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwge"
},
{
"input": "Ykkekrsqolzryiwsmdlnbmfautxxxauoojrddvwklgnlyrfcvhorrzbmtcrvpaypqhcffdqhwziipyyskcmztjprjqvmzzqhqnw",
"output": "ykkekrsqolzryiwsmdlnbmfautxxxauoojrddvwklgnlyrfcvhorrzbmtcrvpaypqhcffdqhwziipyyskcmztjprjqvmzzqhqnw"
},
{
"input": "YQOMLKYAORUQQUCQZCDYMIVDHGWZFFRMUVTAWCHERFPMNRYRIkgqrciokgajamehmcxgerpudvsqyonjonsxgbnefftzmygncks",
"output": "yqomlkyaoruqqucqzcdymivdhgwzffrmuvtawcherfpmnryrikgqrciokgajamehmcxgerpudvsqyonjonsxgbnefftzmygncks"
},
{
"input": "CDOZDPBVVVHNBJVBYHEOXWFLJKRWJCAJMIFCOZWWYFKVWOGTVJcuusigdqfkumewjtdyitveeiaybwrhomrwmpdipjwiuxfnwuz",
"output": "CDOZDPBVVVHNBJVBYHEOXWFLJKRWJCAJMIFCOZWWYFKVWOGTVJCUUSIGDQFKUMEWJTDYITVEEIAYBWRHOMRWMPDIPJWIUXFNWUZ"
},
{
"input": "WHIUVEXHVOOIJIDVJVPQUBJMEVPMPDKQWJKFBZSGSKUXMIPPMJWuckzcpxosodcjaaakvlxpbiigsiauviilylnnqlyucziihqg",
"output": "WHIUVEXHVOOIJIDVJVPQUBJMEVPMPDKQWJKFBZSGSKUXMIPPMJWUCKZCPXOSODCJAAAKVLXPBIIGSIAUVIILYLNNQLYUCZIIHQG"
},
{
"input": "VGHUNFOXKETUYMZDJNGTAOIOANYXSGYNFOGOFFLDAWEUKYFOZXCJTCAFXZYLQZERYZLRSQXYQGAPCSUDPMEYTNCTTTMFAGVDWBO",
"output": "VGHUNFOXKETUYMZDJNGTAOIOANYXSGYNFOGOFFLDAWEUKYFOZXCJTCAFXZYLQZERYZLRSQXYQGAPCSUDPMEYTNCTTTMFAGVDWBO"
},
{
"input": "EDUANHCQDOCJHFONTTSWBUJSTTIXBIXMAIUFSGFLXWAYIURTVAVZPYQDLAWIGCLMPHXCEFCJPFAAHXVNGQUFNHADAIUAZIDMHDd",
"output": "EDUANHCQDOCJHFONTTSWBUJSTTIXBIXMAIUFSGFLXWAYIURTVAVZPYQDLAWIGCLMPHXCEFCJPFAAHXVNGQUFNHADAIUAZIDMHDD"
},
{
"input": "EBWOVSNLYTWWXrnovgugogtjahnmatomubebyxakas",
"output": "ebwovsnlytwwxrnovgugogtjahnmatomubebyxakas"
},
{
"input": "AORNNDKTRLRVGDPXJKXFTPFpopuzrlqumrxssskvbm",
"output": "AORNNDKTRLRVGDPXJKXFTPFPOPUZRLQUMRXSSSKVBM"
},
{
"input": "DBBZJCWQEVGYHEEUHJAWRHBDPsnplijbwtdibqrrheebfxqcvn",
"output": "dbbzjcwqevgyheeuhjawrhbdpsnplijbwtdibqrrheebfxqcvn"
},
{
"input": "t",
"output": "t"
},
{
"input": "N",
"output": "N"
},
{
"input": "kv",
"output": "kv"
},
{
"input": "Ur",
"output": "ur"
},
{
"input": "CN",
"output": "CN"
}
] | 1,499,857,382
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 30
| 154
| 6,041,600
|
import re
Cadena = str(input())
Mayus = re.sub('[^A-Z]','',Cadena)
Minus = re.sub('[^a-z]', '', Cadena)
if(len(Minus)>=len(Mayus)):
print(Cadena.lower())
else:
print(Cadena.upper())
|
Title: Word
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At that as little as possible letters should be changed in the word. For example, the word HoUse must be replaced with house, and the word ViP — with VIP. If a word contains an equal number of uppercase and lowercase letters, you should replace all the letters with lowercase ones. For example, maTRIx should be replaced by matrix. Your task is to use the given method on one given word.
Input Specification:
The first line contains a word *s* — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100.
Output Specification:
Print the corrected word *s*. If the given word *s* has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one.
Demo Input:
['HoUse\n', 'ViP\n', 'maTRIx\n']
Demo Output:
['house\n', 'VIP\n', 'matrix\n']
Note:
none
|
```python
import re
Cadena = str(input())
Mayus = re.sub('[^A-Z]','',Cadena)
Minus = re.sub('[^a-z]', '', Cadena)
if(len(Minus)>=len(Mayus)):
print(Cadena.lower())
else:
print(Cadena.upper())
```
| 3.950247
|
992
|
A
|
Nastya and an Array
|
PROGRAMMING
| 800
|
[
"implementation",
"sortings"
] | null | null |
Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties:
- In one second we can add an arbitrary (possibly negative) integer to all elements of the array that are not equal to zero. - When all elements of the array become equal to zero, the array explodes.
Nastya is always busy, so she wants to explode the array as fast as possible. Compute the minimum time in which the array can be exploded.
|
The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the size of the array.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=105<=≤<=*a**i*<=≤<=105) — the elements of the array.
|
Print a single integer — the minimum number of seconds needed to make all elements of the array equal to zero.
|
[
"5\n1 1 1 1 1\n",
"3\n2 0 -1\n",
"4\n5 -6 -5 1\n"
] |
[
"1\n",
"2\n",
"4\n"
] |
In the first example you can add - 1 to all non-zero elements in one second and make them equal to zero.
In the second example you can add - 2 on the first second, then the array becomes equal to [0, 0, - 3]. On the second second you can add 3 to the third (the only non-zero) element.
| 500
|
[
{
"input": "5\n1 1 1 1 1",
"output": "1"
},
{
"input": "3\n2 0 -1",
"output": "2"
},
{
"input": "4\n5 -6 -5 1",
"output": "4"
},
{
"input": "1\n0",
"output": "0"
},
{
"input": "2\n21794 -79194",
"output": "2"
},
{
"input": "3\n-63526 95085 -5239",
"output": "3"
},
{
"input": "3\n0 53372 -20572",
"output": "2"
},
{
"input": "13\n-2075 -32242 27034 -37618 -96962 82203 64846 48249 -71761 28908 -21222 -61370 46899",
"output": "13"
},
{
"input": "5\n806 0 1308 1954 683",
"output": "4"
},
{
"input": "8\n-26 0 -249 -289 -126 -206 288 -11",
"output": "7"
},
{
"input": "10\n2 2 2 1 2 -1 0 2 -1 1",
"output": "3"
},
{
"input": "1\n8",
"output": "1"
},
{
"input": "3\n0 0 0",
"output": "0"
},
{
"input": "10\n1 2 3 4 5 6 7 8 9 10",
"output": "10"
},
{
"input": "5\n2 0 -1 0 0",
"output": "2"
},
{
"input": "2\n0 0",
"output": "0"
},
{
"input": "5\n0 0 0 0 0",
"output": "0"
},
{
"input": "2\n1 0",
"output": "1"
},
{
"input": "2\n-1 0",
"output": "1"
},
{
"input": "4\n0 0 0 0",
"output": "0"
},
{
"input": "8\n10 9 -1 0 0 3 2 3",
"output": "5"
},
{
"input": "5\n5 0 1 2 3",
"output": "4"
},
{
"input": "3\n1 1 0",
"output": "1"
},
{
"input": "1\n-1",
"output": "1"
},
{
"input": "5\n1 2 0 0 0",
"output": "2"
},
{
"input": "5\n1 0 0 0 0",
"output": "1"
},
{
"input": "5\n4 5 6 0 0",
"output": "3"
},
{
"input": "4\n-1 0 0 1",
"output": "2"
},
{
"input": "5\n3 0 0 4 5",
"output": "3"
},
{
"input": "3\n0 0 2",
"output": "1"
},
{
"input": "3\n1 0 0",
"output": "1"
},
{
"input": "4\n0 0 0 4",
"output": "1"
},
{
"input": "5\n-1 0 0 0 0",
"output": "1"
},
{
"input": "2\n0 1",
"output": "1"
},
{
"input": "3\n1 2 3",
"output": "3"
},
{
"input": "1\n5",
"output": "1"
},
{
"input": "10\n0 0 0 0 0 1 2 3 0 0",
"output": "3"
},
{
"input": "4\n0 1 2 3",
"output": "3"
},
{
"input": "3\n0 1 2",
"output": "2"
},
{
"input": "4\n2 0 0 -1",
"output": "2"
}
] | 1,544,180,690
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 79
| 170
| 7,372,800
|
n=int(input())
l=list(map(int,input().split()))
y=list(set(l))
x=[]
for i in range(len(y)):
if y[i]!=0:
x.append(y[i])
print(len(x))
|
Title: Nastya and an Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties:
- In one second we can add an arbitrary (possibly negative) integer to all elements of the array that are not equal to zero. - When all elements of the array become equal to zero, the array explodes.
Nastya is always busy, so she wants to explode the array as fast as possible. Compute the minimum time in which the array can be exploded.
Input Specification:
The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the size of the array.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=105<=≤<=*a**i*<=≤<=105) — the elements of the array.
Output Specification:
Print a single integer — the minimum number of seconds needed to make all elements of the array equal to zero.
Demo Input:
['5\n1 1 1 1 1\n', '3\n2 0 -1\n', '4\n5 -6 -5 1\n']
Demo Output:
['1\n', '2\n', '4\n']
Note:
In the first example you can add - 1 to all non-zero elements in one second and make them equal to zero.
In the second example you can add - 2 on the first second, then the array becomes equal to [0, 0, - 3]. On the second second you can add 3 to the third (the only non-zero) element.
|
```python
n=int(input())
l=list(map(int,input().split()))
y=list(set(l))
x=[]
for i in range(len(y)):
if y[i]!=0:
x.append(y[i])
print(len(x))
```
| 3
|
|
448
|
A
|
Rewards
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Bizon the Champion is called the Champion for a reason.
Bizon the Champion has recently got a present — a new glass cupboard with *n* shelves and he decided to put all his presents there. All the presents can be divided into two types: medals and cups. Bizon the Champion has *a*1 first prize cups, *a*2 second prize cups and *a*3 third prize cups. Besides, he has *b*1 first prize medals, *b*2 second prize medals and *b*3 third prize medals.
Naturally, the rewards in the cupboard must look good, that's why Bizon the Champion decided to follow the rules:
- any shelf cannot contain both cups and medals at the same time; - no shelf can contain more than five cups; - no shelf can have more than ten medals.
Help Bizon the Champion find out if we can put all the rewards so that all the conditions are fulfilled.
|
The first line contains integers *a*1, *a*2 and *a*3 (0<=≤<=*a*1,<=*a*2,<=*a*3<=≤<=100). The second line contains integers *b*1, *b*2 and *b*3 (0<=≤<=*b*1,<=*b*2,<=*b*3<=≤<=100). The third line contains integer *n* (1<=≤<=*n*<=≤<=100).
The numbers in the lines are separated by single spaces.
|
Print "YES" (without the quotes) if all the rewards can be put on the shelves in the described manner. Otherwise, print "NO" (without the quotes).
|
[
"1 1 1\n1 1 1\n4\n",
"1 1 3\n2 3 4\n2\n",
"1 0 0\n1 0 0\n1\n"
] |
[
"YES\n",
"YES\n",
"NO\n"
] |
none
| 500
|
[
{
"input": "1 1 1\n1 1 1\n4",
"output": "YES"
},
{
"input": "1 1 3\n2 3 4\n2",
"output": "YES"
},
{
"input": "1 0 0\n1 0 0\n1",
"output": "NO"
},
{
"input": "0 0 0\n0 0 0\n1",
"output": "YES"
},
{
"input": "100 100 100\n100 100 100\n100",
"output": "YES"
},
{
"input": "100 100 100\n100 100 100\n1",
"output": "NO"
},
{
"input": "1 10 100\n100 10 1\n20",
"output": "NO"
},
{
"input": "1 1 1\n0 0 0\n1",
"output": "YES"
},
{
"input": "0 0 0\n1 1 1\n1",
"output": "YES"
},
{
"input": "5 5 5\n0 0 0\n2",
"output": "NO"
},
{
"input": "0 0 0\n10 10 10\n2",
"output": "NO"
},
{
"input": "21 61 39\n63 58 69\n44",
"output": "YES"
},
{
"input": "18 95 4\n7 1 75\n46",
"output": "YES"
},
{
"input": "64 27 81\n72 35 23\n48",
"output": "YES"
},
{
"input": "6 6 6\n11 11 11\n7",
"output": "NO"
},
{
"input": "1 2 3\n2 4 6\n3",
"output": "NO"
},
{
"input": "1 2 3\n2 4 6\n4",
"output": "YES"
},
{
"input": "99 99 99\n99 99 99\n89",
"output": "NO"
},
{
"input": "5 0 0\n15 0 0\n2",
"output": "NO"
},
{
"input": "10 10 10\n0 0 0\n1",
"output": "NO"
},
{
"input": "1 1 1\n1 1 1\n15",
"output": "YES"
},
{
"input": "2 3 5\n2 3 5\n2",
"output": "NO"
},
{
"input": "2 2 2\n3 3 5\n3",
"output": "NO"
},
{
"input": "1 2 2\n2 4 4\n1",
"output": "NO"
},
{
"input": "1 2 3\n1 5 5\n2",
"output": "NO"
}
] | 1,678,932,280
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 25
| 46
| 0
|
a = list(map(int, input().split()))
b = list(map(int, input().split()))
n = int(input())
total_cups = sum(a)
total_medals = sum(b)
if total_cups % 5 == 0:
shelves_for_cups = total_cups // 5
else:
shelves_for_cups = total_cups // 5 + 1
if total_medals % 10 == 0:
shelves_for_medals = total_medals // 10
else:
shelves_for_medals = total_medals // 10 + 1
if shelves_for_cups + shelves_for_medals <= n:
print("YES")
else:
print("NO")
|
Title: Rewards
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bizon the Champion is called the Champion for a reason.
Bizon the Champion has recently got a present — a new glass cupboard with *n* shelves and he decided to put all his presents there. All the presents can be divided into two types: medals and cups. Bizon the Champion has *a*1 first prize cups, *a*2 second prize cups and *a*3 third prize cups. Besides, he has *b*1 first prize medals, *b*2 second prize medals and *b*3 third prize medals.
Naturally, the rewards in the cupboard must look good, that's why Bizon the Champion decided to follow the rules:
- any shelf cannot contain both cups and medals at the same time; - no shelf can contain more than five cups; - no shelf can have more than ten medals.
Help Bizon the Champion find out if we can put all the rewards so that all the conditions are fulfilled.
Input Specification:
The first line contains integers *a*1, *a*2 and *a*3 (0<=≤<=*a*1,<=*a*2,<=*a*3<=≤<=100). The second line contains integers *b*1, *b*2 and *b*3 (0<=≤<=*b*1,<=*b*2,<=*b*3<=≤<=100). The third line contains integer *n* (1<=≤<=*n*<=≤<=100).
The numbers in the lines are separated by single spaces.
Output Specification:
Print "YES" (without the quotes) if all the rewards can be put on the shelves in the described manner. Otherwise, print "NO" (without the quotes).
Demo Input:
['1 1 1\n1 1 1\n4\n', '1 1 3\n2 3 4\n2\n', '1 0 0\n1 0 0\n1\n']
Demo Output:
['YES\n', 'YES\n', 'NO\n']
Note:
none
|
```python
a = list(map(int, input().split()))
b = list(map(int, input().split()))
n = int(input())
total_cups = sum(a)
total_medals = sum(b)
if total_cups % 5 == 0:
shelves_for_cups = total_cups // 5
else:
shelves_for_cups = total_cups // 5 + 1
if total_medals % 10 == 0:
shelves_for_medals = total_medals // 10
else:
shelves_for_medals = total_medals // 10 + 1
if shelves_for_cups + shelves_for_medals <= n:
print("YES")
else:
print("NO")
```
| 3
|
|
269
|
C
|
Flawed Flow
|
PROGRAMMING
| 2,100
|
[
"constructive algorithms",
"flows",
"graphs",
"greedy"
] | null | null |
Emuskald considers himself a master of flow algorithms. Now he has completed his most ingenious program yet — it calculates the maximum flow in an undirected graph. The graph consists of *n* vertices and *m* edges. Vertices are numbered from 1 to *n*. Vertices 1 and *n* being the source and the sink respectively.
However, his max-flow algorithm seems to have a little flaw — it only finds the flow volume for each edge, but not its direction. Help him find for each edge the direction of the flow through this edges. Note, that the resulting flow should be correct maximum flow.
More formally. You are given an undirected graph. For each it's undirected edge (*a**i*, *b**i*) you are given the flow volume *c**i*. You should direct all edges in such way that the following conditions hold:
1. for each vertex *v* (1<=<<=*v*<=<<=*n*), sum of *c**i* of incoming edges is equal to the sum of *c**i* of outcoming edges; 1. vertex with number 1 has no incoming edges; 1. the obtained directed graph does not have cycles.
|
The first line of input contains two space-separated integers *n* and *m* (2<=≤<=*n*<=≤<=2·105, *n*<=-<=1<=≤<=*m*<=≤<=2·105), the number of vertices and edges in the graph. The following *m* lines contain three space-separated integers *a**i*, *b**i* and *c**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*, 1<=≤<=*c**i*<=≤<=104), which means that there is an undirected edge from *a**i* to *b**i* with flow volume *c**i*.
It is guaranteed that there are no two edges connecting the same vertices; the given graph is connected; a solution always exists.
|
Output *m* lines, each containing one integer *d**i*, which should be 0 if the direction of the *i*-th edge is *a**i*<=→<=*b**i* (the flow goes from vertex *a**i* to vertex *b**i*) and should be 1 otherwise. The edges are numbered from 1 to *m* in the order they are given in the input.
If there are several solutions you can print any of them.
|
[
"3 3\n3 2 10\n1 2 10\n3 1 5\n",
"4 5\n1 2 10\n1 3 10\n2 3 5\n4 2 15\n3 4 5\n"
] |
[
"1\n0\n1\n",
"0\n0\n1\n1\n0\n"
] |
In the first test case, 10 flow units pass through path <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/609340f155794c4e9eebcd9cdfa23c73cf982f28.png" style="max-width: 100.0%;max-height: 100.0%;"/>, and 5 flow units pass directly from source to sink: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/04481aced8a9d501ae5d785ab654c542ff5497a1.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
| 1,500
|
[
{
"input": "3 3\n3 2 10\n1 2 10\n3 1 5",
"output": "1\n0\n1"
},
{
"input": "4 5\n1 2 10\n1 3 10\n2 3 5\n4 2 15\n3 4 5",
"output": "0\n0\n1\n1\n0"
},
{
"input": "10 17\n8 1 1\n4 8 2\n7 10 8\n1 4 1\n5 4 3\n6 9 6\n3 5 4\n1 9 1\n3 9 5\n7 1 1\n1 2 1\n1 3 1\n6 7 7\n8 2 1\n1 10 1\n1 5 1\n6 1 1",
"output": "1\n1\n0\n0\n1\n1\n1\n0\n0\n1\n0\n0\n0\n1\n0\n0\n1"
},
{
"input": "10 20\n3 8 41\n1 2 21\n9 1 31\n1 3 53\n5 9 67\n10 1 8\n6 1 16\n5 2 21\n1 7 50\n5 4 38\n6 4 16\n4 8 16\n5 10 93\n9 10 126\n8 9 16\n4 1 38\n5 7 50\n3 9 12\n1 5 10\n5 8 41",
"output": "0\n0\n1\n0\n0\n1\n1\n1\n0\n1\n0\n0\n0\n0\n0\n1\n1\n0\n0\n1"
},
{
"input": "2 1\n1 2 1",
"output": "0"
},
{
"input": "2 1\n2 1 1",
"output": "1"
},
{
"input": "3 2\n1 2 1\n2 3 1",
"output": "0\n0"
},
{
"input": "4 4\n4 3 5000\n1 2 10000\n3 1 5000\n4 2 10000",
"output": "1\n0\n1\n1"
},
{
"input": "3 3\n3 1 10000\n2 1 10000\n3 2 10000",
"output": "1\n1\n1"
},
{
"input": "3 3\n3 2 10000\n2 1 10000\n3 1 10000",
"output": "1\n1\n1"
},
{
"input": "10 17\n9 1 8\n7 10 1\n5 4 4\n1 10 1\n3 10 1\n10 5 1\n6 3 6\n10 4 1\n4 6 5\n7 5 3\n2 10 1\n9 3 7\n9 10 1\n8 10 1\n10 6 1\n2 7 2\n2 8 1",
"output": "1\n0\n1\n0\n0\n1\n1\n1\n1\n1\n0\n0\n0\n0\n1\n1\n0"
},
{
"input": "5 6\n1 3 10\n2 1 10\n3 5 10\n1 4 10\n2 5 10\n4 5 10",
"output": "0\n1\n0\n0\n0\n0"
},
{
"input": "5 6\n2 1 8\n5 2 8\n5 3 4\n4 1 9\n3 1 4\n5 4 9",
"output": "1\n1\n1\n1\n1\n1"
},
{
"input": "10 23\n10 5 94\n6 9 20\n10 2 79\n3 9 63\n1 6 80\n7 8 21\n3 5 6\n3 1 94\n2 5 21\n1 2 100\n1 7 79\n6 10 59\n8 1 60\n10 3 37\n9 1 37\n4 8 40\n7 10 100\n6 4 41\n5 1 79\n8 10 79\n9 10 80\n10 4 60\n4 1 59",
"output": "1\n1\n1\n0\n0\n1\n1\n1\n0\n0\n0\n0\n1\n1\n1\n0\n0\n0\n1\n0\n0\n1\n1"
},
{
"input": "9 9\n1 2 1\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 9 1\n8 9 1\n1 8 1",
"output": "0\n0\n0\n0\n0\n0\n0\n0\n0"
},
{
"input": "6 6\n1 2 1\n2 6 1\n1 3 1\n3 4 1\n4 5 1\n5 6 1",
"output": "0\n0\n0\n0\n0\n0"
}
] | 1,680,677,401
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 31
| 0
|
n=int(input())
k=0
if n<7:
print(k)
else:
print(n//7)
|
Title: Flawed Flow
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Emuskald considers himself a master of flow algorithms. Now he has completed his most ingenious program yet — it calculates the maximum flow in an undirected graph. The graph consists of *n* vertices and *m* edges. Vertices are numbered from 1 to *n*. Vertices 1 and *n* being the source and the sink respectively.
However, his max-flow algorithm seems to have a little flaw — it only finds the flow volume for each edge, but not its direction. Help him find for each edge the direction of the flow through this edges. Note, that the resulting flow should be correct maximum flow.
More formally. You are given an undirected graph. For each it's undirected edge (*a**i*, *b**i*) you are given the flow volume *c**i*. You should direct all edges in such way that the following conditions hold:
1. for each vertex *v* (1<=<<=*v*<=<<=*n*), sum of *c**i* of incoming edges is equal to the sum of *c**i* of outcoming edges; 1. vertex with number 1 has no incoming edges; 1. the obtained directed graph does not have cycles.
Input Specification:
The first line of input contains two space-separated integers *n* and *m* (2<=≤<=*n*<=≤<=2·105, *n*<=-<=1<=≤<=*m*<=≤<=2·105), the number of vertices and edges in the graph. The following *m* lines contain three space-separated integers *a**i*, *b**i* and *c**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*, 1<=≤<=*c**i*<=≤<=104), which means that there is an undirected edge from *a**i* to *b**i* with flow volume *c**i*.
It is guaranteed that there are no two edges connecting the same vertices; the given graph is connected; a solution always exists.
Output Specification:
Output *m* lines, each containing one integer *d**i*, which should be 0 if the direction of the *i*-th edge is *a**i*<=→<=*b**i* (the flow goes from vertex *a**i* to vertex *b**i*) and should be 1 otherwise. The edges are numbered from 1 to *m* in the order they are given in the input.
If there are several solutions you can print any of them.
Demo Input:
['3 3\n3 2 10\n1 2 10\n3 1 5\n', '4 5\n1 2 10\n1 3 10\n2 3 5\n4 2 15\n3 4 5\n']
Demo Output:
['1\n0\n1\n', '0\n0\n1\n1\n0\n']
Note:
In the first test case, 10 flow units pass through path <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/609340f155794c4e9eebcd9cdfa23c73cf982f28.png" style="max-width: 100.0%;max-height: 100.0%;"/>, and 5 flow units pass directly from source to sink: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/04481aced8a9d501ae5d785ab654c542ff5497a1.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
|
```python
n=int(input())
k=0
if n<7:
print(k)
else:
print(n//7)
```
| -1
|
|
626
|
A
|
Robot Sequence
|
PROGRAMMING
| 1,000
|
[
"brute force",
"implementation"
] | null | null |
Calvin the robot lies in an infinite rectangular grid. Calvin's source code contains a list of *n* commands, each either 'U', 'R', 'D', or 'L' — instructions to move a single square up, right, down, or left, respectively. How many ways can Calvin execute a non-empty contiguous substrings of commands and return to the same square he starts in? Two substrings are considered different if they have different starting or ending indices.
|
The first line of the input contains a single positive integer, *n* (1<=≤<=*n*<=≤<=200) — the number of commands.
The next line contains *n* characters, each either 'U', 'R', 'D', or 'L' — Calvin's source code.
|
Print a single integer — the number of contiguous substrings that Calvin can execute and return to his starting square.
|
[
"6\nURLLDR\n",
"4\nDLUU\n",
"7\nRLRLRLR\n"
] |
[
"2\n",
"0\n",
"12\n"
] |
In the first case, the entire source code works, as well as the "RL" substring in the second and third characters.
Note that, in the third case, the substring "LR" appears three times, and is therefore counted three times to the total result.
| 500
|
[
{
"input": "6\nURLLDR",
"output": "2"
},
{
"input": "4\nDLUU",
"output": "0"
},
{
"input": "7\nRLRLRLR",
"output": "12"
},
{
"input": "1\nR",
"output": "0"
},
{
"input": "100\nURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDLURDL",
"output": "1225"
},
{
"input": "200\nLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR",
"output": "100"
},
{
"input": "20\nLDURLDURRLRUDLRRUDLU",
"output": "29"
},
{
"input": "140\nDLDLULULDRDDDLLUDRRDLLUULLDDLDLUURLDLDRDUDDLRRDURUUUUURLDUDDLLRRLLDRRRDDDDDUDUULLURRDLDULUDLLUUDRRLUDULUDUDULULUURURRDUURRDLULLURUDDDDRDRDRD",
"output": "125"
},
{
"input": "194\nULLLDLLDRUUDURRULLRLUUURDRLLURDUDDUDLULRLDRUDURLDLRDLLLLUDDRRRULULULUDDULRURURLLDLDLDRUDUUDULRULDDRRLRDRULLDRULLLLRRDDLLLLULDRLUULRUUULDUUDLDLDUUUDDLDDRULDRRLUURRULLDULRRDLLRDURDLUUDUDLLUDDULDDD",
"output": "282"
},
{
"input": "200\nDDDURLLUUULUDDURRDLLDDLLRLUULUULDDDLRRDLRRDUDURDUDRRLLDRDUDDLDDRDLURRRLLRDRRLLLRDDDRDRRLLRRLULRUULRLDLUDRRRDDUUURLLUDRLDUDRLLRLRRLUDLRULDUDDRRLLRLURDLRUDDDURLRDUDUUURLLULULRDRLDLDRURDDDLLRUDDRDUDDDLRU",
"output": "408"
},
{
"input": "197\nDUUDUDUDUDUUDUUDUUUDDDDUUUDUUUDUUUUUDUUUDDUDDDUUDUDDDUUDDUUUUUUUDUDDDDDUUUUUDDDDDDUUUUDDUDDUDDDUDUUUDUUDUDUDUUUDUDDDDUUDDUDDDDUDDDUDUUUDUUDUUUDDDDUUUDUUDDUUUUUDDDDUUDUUDDDDUDDUUDUUUDDDDUDUUUDDDUUDU",
"output": "1995"
},
{
"input": "200\nLLLLRLLRLLRRRRLLRRLRRLRRRLLLRRLRRRRLLRRLLRRRLRLRLRRLLRLLRRLLLRRRRLRLLRLLLRLLLRRLLLRLRLRRRRRRRLRRRLRLRLLLLRLRRRRRLRRLRLLLLRLLLRRLRRLLRLRLLLRRLLRRLRRRRRLRLRRLRLLRLLLLRLRRRLRRLRLLRLRRLRRRRRLRRLLLRRRRRLLR",
"output": "1368"
},
{
"input": "184\nUUUDDUDDDDDUDDDDUDDUUUUUDDDUUDDUDUUDUUUDDUDDDDDDDDDDUDUDDUUDDDUUDDUDUDDDUUDUDUUUUDDUDUUUDDUDUUUUDUUDDUUDUUUDUDUDDUDUDDDUUDDDDUUUUUDDDUDUDUDUDUDUUUDUDDUUDDUDUUDUDUUUDUUDDDDUDDDDUDUUDUUD",
"output": "1243"
},
{
"input": "187\nRLLRLRRLLRRLRRRRLLRLLRLLLLRRRLLLRLLLLRRLRLRRRRRRLLRRLRLLRRRLLRRLLLRRLRRLRLLLLRRRRLRRLLRRLRRRRLLLLRRLRLRLRRRRRLLRLRLRLRLRLRLLLRLLLLLRRRLLRLRRRLLLRRLLLLLRLLRLLLRRRLLLRRLRRRLLLRRLRLLRRLRLRLR",
"output": "1501"
},
{
"input": "190\nUULLLUUULLLULLUULUUUUULUUULLULLULUULLUULLUUULULUULLUULLUUULULLLLLLULLLLLULUULLULLULLLUULUULLLUUUULLLLUUULLUUULLLULULUULULLUULULULUUULLUUUULLUUULULUULLLLULLLLLUULLUULULLULUUUUUULULLLULLUULUUU",
"output": "0"
},
{
"input": "46\nULUURRRRLDRDRDDDURRRLLLDDULLRRRRRLUDDLRDRULLLL",
"output": "23"
},
{
"input": "70\nUUDRLDRDRUDLLURURULRDULRRDULDUDDRUULLDDDDDRLLRDURRDULRDLRUUUDDLRUURRLD",
"output": "86"
},
{
"input": "198\nURLLUDRDUUDRDLLRURULLRRLRRUULRLULUUDRRURLRUURRDRUUDRLRURLLULRDDDDDRDDRRRLRUDULLDDLLLUDRLDRUDRDLDUULLUUUULULLRLDDRDURDRURLULDRURLLDDULURULDLUUUUULDLURRLLDLULLDULRUURRLDLLUUURDLDDUDUULRLUDULLULDRDRLRL",
"output": "160"
},
{
"input": "22\nDUDDDURURUDURRUDRDULUL",
"output": "10"
},
{
"input": "200\nUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUDUD",
"output": "10000"
},
{
"input": "4\nRRDR",
"output": "0"
},
{
"input": "6\nUULLLL",
"output": "0"
},
{
"input": "2\nDU",
"output": "1"
},
{
"input": "6\nUURRRR",
"output": "0"
},
{
"input": "101\nRDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
"output": "0"
}
] | 1,459,461,735
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 25
| 62
| 4,608,000
|
n = int(input())
s = input()
a,b = 0,0
E = [[0,0]]
times = [1]
for i in range(n):
if s[i] == "U":
b += 1
elif s[i] == "R":
a += 1
elif s[i] == "D":
b -= 1
else:
a -= 1
if [a,b] not in E:
E.append([a,b])
times.append(1)
else:
times[E.index([a,b])] += 1
c = 0
for i in times:
c += (i*(i-1))//2
print(c)
|
Title: Robot Sequence
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Calvin the robot lies in an infinite rectangular grid. Calvin's source code contains a list of *n* commands, each either 'U', 'R', 'D', or 'L' — instructions to move a single square up, right, down, or left, respectively. How many ways can Calvin execute a non-empty contiguous substrings of commands and return to the same square he starts in? Two substrings are considered different if they have different starting or ending indices.
Input Specification:
The first line of the input contains a single positive integer, *n* (1<=≤<=*n*<=≤<=200) — the number of commands.
The next line contains *n* characters, each either 'U', 'R', 'D', or 'L' — Calvin's source code.
Output Specification:
Print a single integer — the number of contiguous substrings that Calvin can execute and return to his starting square.
Demo Input:
['6\nURLLDR\n', '4\nDLUU\n', '7\nRLRLRLR\n']
Demo Output:
['2\n', '0\n', '12\n']
Note:
In the first case, the entire source code works, as well as the "RL" substring in the second and third characters.
Note that, in the third case, the substring "LR" appears three times, and is therefore counted three times to the total result.
|
```python
n = int(input())
s = input()
a,b = 0,0
E = [[0,0]]
times = [1]
for i in range(n):
if s[i] == "U":
b += 1
elif s[i] == "R":
a += 1
elif s[i] == "D":
b -= 1
else:
a -= 1
if [a,b] not in E:
E.append([a,b])
times.append(1)
else:
times[E.index([a,b])] += 1
c = 0
for i in times:
c += (i*(i-1))//2
print(c)
```
| 3
|
|
1
|
A
|
Theatre Square
|
PROGRAMMING
| 1,000
|
[
"math"
] |
A. Theatre Square
|
1
|
256
|
Theatre Square in the capital city of Berland has a rectangular shape with the size *n*<=×<=*m* meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each flagstone is of the size *a*<=×<=*a*.
What is the least number of flagstones needed to pave the Square? It's allowed to cover the surface larger than the Theatre Square, but the Square has to be covered. It's not allowed to break the flagstones. The sides of flagstones should be parallel to the sides of the Square.
|
The input contains three positive integer numbers in the first line: *n*,<=<=*m* and *a* (1<=≤<=<=*n*,<=*m*,<=*a*<=≤<=109).
|
Write the needed number of flagstones.
|
[
"6 6 4\n"
] |
[
"4\n"
] |
none
| 0
|
[
{
"input": "6 6 4",
"output": "4"
},
{
"input": "1 1 1",
"output": "1"
},
{
"input": "2 1 1",
"output": "2"
},
{
"input": "1 2 1",
"output": "2"
},
{
"input": "2 2 1",
"output": "4"
},
{
"input": "2 1 2",
"output": "1"
},
{
"input": "1 1 3",
"output": "1"
},
{
"input": "2 3 4",
"output": "1"
},
{
"input": "1000000000 1000000000 1",
"output": "1000000000000000000"
},
{
"input": "12 13 4",
"output": "12"
},
{
"input": "222 332 5",
"output": "3015"
},
{
"input": "1000 1000 10",
"output": "10000"
},
{
"input": "1001 1000 10",
"output": "10100"
},
{
"input": "100 10001 1000000000",
"output": "1"
},
{
"input": "1000000000 1000000000 1000000000",
"output": "1"
},
{
"input": "1000000000 1000000000 999999999",
"output": "4"
},
{
"input": "1000000000 1000000000 192",
"output": "27126743055556"
},
{
"input": "1000000000 987654321 1",
"output": "987654321000000000"
},
{
"input": "456784567 1000000000 51",
"output": "175618850864484"
},
{
"input": "39916800 134217728 40320",
"output": "3295710"
}
] | 1,690,145,004
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 8
| 1,000
| 0
|
n,m,a = input().split()
n=int(n)
m=int(m)
a=int(a)
n1=n
m1=m
result=0
if n==m and n==a:
result=1
elif n >=m :
while n>0:
n-=a
result+=1
m2=m-a
if m2 > 0 :
while n1 >0:
n1 -= a
result += 1
elif n<m :
while m>0:
m-=a
result+=1
n2=n-a
if n2 > 0:
while m1 > 0:
m1 -= a
result += 1
print(result)
|
Title: Theatre Square
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Theatre Square in the capital city of Berland has a rectangular shape with the size *n*<=×<=*m* meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each flagstone is of the size *a*<=×<=*a*.
What is the least number of flagstones needed to pave the Square? It's allowed to cover the surface larger than the Theatre Square, but the Square has to be covered. It's not allowed to break the flagstones. The sides of flagstones should be parallel to the sides of the Square.
Input Specification:
The input contains three positive integer numbers in the first line: *n*,<=<=*m* and *a* (1<=≤<=<=*n*,<=*m*,<=*a*<=≤<=109).
Output Specification:
Write the needed number of flagstones.
Demo Input:
['6 6 4\n']
Demo Output:
['4\n']
Note:
none
|
```python
n,m,a = input().split()
n=int(n)
m=int(m)
a=int(a)
n1=n
m1=m
result=0
if n==m and n==a:
result=1
elif n >=m :
while n>0:
n-=a
result+=1
m2=m-a
if m2 > 0 :
while n1 >0:
n1 -= a
result += 1
elif n<m :
while m>0:
m-=a
result+=1
n2=n-a
if n2 > 0:
while m1 > 0:
m1 -= a
result += 1
print(result)
```
| 0
|
202
|
A
|
LLPS
|
PROGRAMMING
| 800
|
[
"binary search",
"bitmasks",
"brute force",
"greedy",
"implementation",
"strings"
] | null | null |
This problem's actual name, "Lexicographically Largest Palindromic Subsequence" is too long to fit into the page headline.
You are given string *s* consisting of lowercase English letters only. Find its lexicographically largest palindromic subsequence.
We'll call a non-empty string *s*[*p*1*p*2... *p**k*] = *s**p*1*s**p*2... *s**p**k* (1 <=≤<= *p*1<=<<=*p*2<=<<=...<=<<=*p**k* <=≤<= |*s*|) a subsequence of string *s* = *s*1*s*2... *s*|*s*|, where |*s*| is the length of string *s*. For example, strings "abcb", "b" and "abacaba" are subsequences of string "abacaba".
String *x* = *x*1*x*2... *x*|*x*| is lexicographically larger than string *y* = *y*1*y*2... *y*|*y*| if either |*x*| > |*y*| and *x*1<==<=*y*1, *x*2<==<=*y*2, ...,<=*x*|*y*|<==<=*y*|*y*|, or there exists such number *r* (*r*<=<<=|*x*|, *r*<=<<=|*y*|) that *x*1<==<=*y*1, *x*2<==<=*y*2, ..., *x**r*<==<=*y**r* and *x**r*<=<=+<=<=1<=><=*y**r*<=<=+<=<=1. Characters in the strings are compared according to their ASCII codes. For example, string "ranger" is lexicographically larger than string "racecar" and string "poster" is lexicographically larger than string "post".
String *s* = *s*1*s*2... *s*|*s*| is a palindrome if it matches string *rev*(*s*) = *s*|*s*|*s*|*s*|<=-<=1... *s*1. In other words, a string is a palindrome if it reads the same way from left to right and from right to left. For example, palindromic strings are "racecar", "refer" and "z".
|
The only input line contains a non-empty string *s* consisting of lowercase English letters only. Its length does not exceed 10.
|
Print the lexicographically largest palindromic subsequence of string *s*.
|
[
"radar\n",
"bowwowwow\n",
"codeforces\n",
"mississipp\n"
] |
[
"rr\n",
"wwwww\n",
"s\n",
"ssss\n"
] |
Among all distinct subsequences of string "radar" the following ones are palindromes: "a", "d", "r", "aa", "rr", "ada", "rar", "rdr", "raar" and "radar". The lexicographically largest of them is "rr".
| 500
|
[
{
"input": "radar",
"output": "rr"
},
{
"input": "bowwowwow",
"output": "wwwww"
},
{
"input": "codeforces",
"output": "s"
},
{
"input": "mississipp",
"output": "ssss"
},
{
"input": "tourist",
"output": "u"
},
{
"input": "romka",
"output": "r"
},
{
"input": "helloworld",
"output": "w"
},
{
"input": "zzzzzzzazz",
"output": "zzzzzzzzz"
},
{
"input": "testcase",
"output": "tt"
},
{
"input": "hahahahaha",
"output": "hhhhh"
},
{
"input": "abbbbbbbbb",
"output": "bbbbbbbbb"
},
{
"input": "zaz",
"output": "zz"
},
{
"input": "aza",
"output": "z"
},
{
"input": "dcbaedcba",
"output": "e"
},
{
"input": "abcdeabcd",
"output": "e"
},
{
"input": "edcbabcde",
"output": "ee"
},
{
"input": "aaaaaaaaab",
"output": "b"
},
{
"input": "testzzzzzz",
"output": "zzzzzz"
},
{
"input": "zzzzzzwait",
"output": "zzzzzz"
},
{
"input": "rrrrrqponm",
"output": "rrrrr"
},
{
"input": "zzyzyy",
"output": "zzz"
},
{
"input": "aababb",
"output": "bbb"
},
{
"input": "zanzibar",
"output": "zz"
},
{
"input": "hhgfedcbaa",
"output": "hh"
},
{
"input": "aabcdefghh",
"output": "hh"
},
{
"input": "aruaru",
"output": "uu"
},
{
"input": "uraura",
"output": "uu"
},
{
"input": "aru",
"output": "u"
},
{
"input": "aburvabur",
"output": "v"
},
{
"input": "ura",
"output": "u"
},
{
"input": "eurottat",
"output": "u"
},
{
"input": "referee",
"output": "rr"
},
{
"input": "joking",
"output": "o"
},
{
"input": "seriously",
"output": "y"
},
{
"input": "sets",
"output": "t"
},
{
"input": "test",
"output": "tt"
},
{
"input": "klmgameklm",
"output": "mmm"
},
{
"input": "dfkjafdkdd",
"output": "kk"
},
{
"input": "zzzzzzzzzz",
"output": "zzzzzzzzzz"
},
{
"input": "aaaaaaaaaa",
"output": "aaaaaaaaaa"
},
{
"input": "buzz",
"output": "zz"
},
{
"input": "b",
"output": "b"
},
{
"input": "y",
"output": "y"
},
{
"input": "yy",
"output": "yy"
},
{
"input": "zz",
"output": "zz"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "a",
"output": "a"
},
{
"input": "z",
"output": "z"
},
{
"input": "zz",
"output": "zz"
},
{
"input": "zzazazzzaz",
"output": "zzzzzzz"
},
{
"input": "hellhellhe",
"output": "llll"
},
{
"input": "hellohello",
"output": "oo"
},
{
"input": "refer",
"output": "rr"
}
] | 1,690,908,090
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 54
| 62
| 0
|
string = input()
m = ""
for i in string:
if i > m:
m = i
for i in string:
if i == m:
print(i, end="")
|
Title: LLPS
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
This problem's actual name, "Lexicographically Largest Palindromic Subsequence" is too long to fit into the page headline.
You are given string *s* consisting of lowercase English letters only. Find its lexicographically largest palindromic subsequence.
We'll call a non-empty string *s*[*p*1*p*2... *p**k*] = *s**p*1*s**p*2... *s**p**k* (1 <=≤<= *p*1<=<<=*p*2<=<<=...<=<<=*p**k* <=≤<= |*s*|) a subsequence of string *s* = *s*1*s*2... *s*|*s*|, where |*s*| is the length of string *s*. For example, strings "abcb", "b" and "abacaba" are subsequences of string "abacaba".
String *x* = *x*1*x*2... *x*|*x*| is lexicographically larger than string *y* = *y*1*y*2... *y*|*y*| if either |*x*| > |*y*| and *x*1<==<=*y*1, *x*2<==<=*y*2, ...,<=*x*|*y*|<==<=*y*|*y*|, or there exists such number *r* (*r*<=<<=|*x*|, *r*<=<<=|*y*|) that *x*1<==<=*y*1, *x*2<==<=*y*2, ..., *x**r*<==<=*y**r* and *x**r*<=<=+<=<=1<=><=*y**r*<=<=+<=<=1. Characters in the strings are compared according to their ASCII codes. For example, string "ranger" is lexicographically larger than string "racecar" and string "poster" is lexicographically larger than string "post".
String *s* = *s*1*s*2... *s*|*s*| is a palindrome if it matches string *rev*(*s*) = *s*|*s*|*s*|*s*|<=-<=1... *s*1. In other words, a string is a palindrome if it reads the same way from left to right and from right to left. For example, palindromic strings are "racecar", "refer" and "z".
Input Specification:
The only input line contains a non-empty string *s* consisting of lowercase English letters only. Its length does not exceed 10.
Output Specification:
Print the lexicographically largest palindromic subsequence of string *s*.
Demo Input:
['radar\n', 'bowwowwow\n', 'codeforces\n', 'mississipp\n']
Demo Output:
['rr\n', 'wwwww\n', 's\n', 'ssss\n']
Note:
Among all distinct subsequences of string "radar" the following ones are palindromes: "a", "d", "r", "aa", "rr", "ada", "rar", "rdr", "raar" and "radar". The lexicographically largest of them is "rr".
|
```python
string = input()
m = ""
for i in string:
if i > m:
m = i
for i in string:
if i == m:
print(i, end="")
```
| 3
|
|
550
|
A
|
Two Substrings
|
PROGRAMMING
| 1,500
|
[
"brute force",
"dp",
"greedy",
"implementation",
"strings"
] | null | null |
You are given string *s*. Your task is to determine if the given string *s* contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
|
The only line of input contains a string *s* of length between 1 and 105 consisting of uppercase Latin letters.
|
Print "YES" (without the quotes), if string *s* contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
|
[
"ABA\n",
"BACFAB\n",
"AXBYBXA\n"
] |
[
"NO\n",
"YES\n",
"NO\n"
] |
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
| 1,000
|
[
{
"input": "ABA",
"output": "NO"
},
{
"input": "BACFAB",
"output": "YES"
},
{
"input": "AXBYBXA",
"output": "NO"
},
{
"input": "ABABAB",
"output": "YES"
},
{
"input": "BBBBBBBBBB",
"output": "NO"
},
{
"input": "ABBA",
"output": "YES"
},
{
"input": "ABAXXXAB",
"output": "YES"
},
{
"input": "TESTABAXXABTEST",
"output": "YES"
},
{
"input": "A",
"output": "NO"
},
{
"input": "B",
"output": "NO"
},
{
"input": "X",
"output": "NO"
},
{
"input": "BA",
"output": "NO"
},
{
"input": "AB",
"output": "NO"
},
{
"input": "AA",
"output": "NO"
},
{
"input": "BB",
"output": "NO"
},
{
"input": "BAB",
"output": "NO"
},
{
"input": "AAB",
"output": "NO"
},
{
"input": "BAA",
"output": "NO"
},
{
"input": "ABB",
"output": "NO"
},
{
"input": "BBA",
"output": "NO"
},
{
"input": "AAA",
"output": "NO"
},
{
"input": "BBB",
"output": "NO"
},
{
"input": "AXBXBXA",
"output": "NO"
},
{
"input": "SKDSKDJABSDBADKFJDK",
"output": "YES"
},
{
"input": "ABAXXBBXXAA",
"output": "NO"
},
{
"input": "ABAB",
"output": "NO"
},
{
"input": "BABA",
"output": "NO"
},
{
"input": "AAAB",
"output": "NO"
},
{
"input": "AAAA",
"output": "NO"
},
{
"input": "AABA",
"output": "NO"
},
{
"input": "ABAA",
"output": "NO"
},
{
"input": "BAAA",
"output": "NO"
},
{
"input": "AABB",
"output": "NO"
},
{
"input": "BAAB",
"output": "YES"
},
{
"input": "BBAA",
"output": "NO"
},
{
"input": "BBBA",
"output": "NO"
},
{
"input": "BBAB",
"output": "NO"
},
{
"input": "BABB",
"output": "NO"
},
{
"input": "ABBB",
"output": "NO"
},
{
"input": "BBBB",
"output": "NO"
},
{
"input": "BABAB",
"output": "YES"
},
{
"input": "ABABA",
"output": "YES"
},
{
"input": "AAABAAACBBBC",
"output": "NO"
},
{
"input": "AABBBACBBBBBBAACBCCACBBAABBBBBCAACABAACABCACCBCBCCCBCBCABCBBCCBCBBAACBACAABACBBCACCBCCACCABBCBABBAAC",
"output": "YES"
},
{
"input": "CBBABDDBBADAC",
"output": "YES"
},
{
"input": "ABYFAB",
"output": "NO"
},
{
"input": "BABXXAB",
"output": "YES"
},
{
"input": "ABAXAB",
"output": "YES"
},
{
"input": "ABABXAB",
"output": "YES"
},
{
"input": "ABXABXABXABXABXBAXBAXBAXBA",
"output": "YES"
},
{
"input": "QQQQQQQQQABABQQQQQQQQ",
"output": "NO"
}
] | 1,678,457,776
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 7
| 78
| 3,788,800
|
a = str(input())
q, w = [], []
for i in range(0, len(a), 2):
q.append(a[i:i+2])
for i in range(1, len(a), 2):
w.append(a[i:i+2])
print("YES") if (("AB" in q and "BA" in q) or ("AB" in w and "BA" in w) or ("BA" in q and "BA" in w) or ("AB" in q and "AB" in w) or ("AB" in q and "BA" in w) or ("AB" in w and "BA" in q))and len(a) > 3 else print("NO")
|
Title: Two Substrings
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given string *s*. Your task is to determine if the given string *s* contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input Specification:
The only line of input contains a string *s* of length between 1 and 105 consisting of uppercase Latin letters.
Output Specification:
Print "YES" (without the quotes), if string *s* contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Demo Input:
['ABA\n', 'BACFAB\n', 'AXBYBXA\n']
Demo Output:
['NO\n', 'YES\n', 'NO\n']
Note:
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
|
```python
a = str(input())
q, w = [], []
for i in range(0, len(a), 2):
q.append(a[i:i+2])
for i in range(1, len(a), 2):
w.append(a[i:i+2])
print("YES") if (("AB" in q and "BA" in q) or ("AB" in w and "BA" in w) or ("BA" in q and "BA" in w) or ("AB" in q and "AB" in w) or ("AB" in q and "BA" in w) or ("AB" in w and "BA" in q))and len(a) > 3 else print("NO")
```
| 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,586,662,603
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 5
| 108
| 0
|
for _ in range(int(input())):
a,b = map(int, input().split()[1:])
if a>b>=2400:
print("YES")
exit()
print("NO")
|
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
for _ in range(int(input())):
a,b = map(int, input().split()[1:])
if a>b>=2400:
print("YES")
exit()
print("NO")
```
| 0
|
|
822
|
A
|
I'm bored with life
|
PROGRAMMING
| 800
|
[
"implementation",
"math",
"number theory"
] | null | null |
Holidays have finished. Thanks to the help of the hacker Leha, Noora managed to enter the university of her dreams which is located in a town Pavlopolis. It's well known that universities provide students with dormitory for the period of university studies. Consequently Noora had to leave Vičkopolis and move to Pavlopolis. Thus Leha was left completely alone in a quiet town Vičkopolis. He almost even fell into a depression from boredom!
Leha came up with a task for himself to relax a little. He chooses two integers *A* and *B* and then calculates the greatest common divisor of integers "*A* factorial" and "*B* factorial". Formally the hacker wants to find out GCD(*A*!,<=*B*!). It's well known that the factorial of an integer *x* is a product of all positive integers less than or equal to *x*. Thus *x*!<==<=1·2·3·...·(*x*<=-<=1)·*x*. For example 4!<==<=1·2·3·4<==<=24. Recall that GCD(*x*,<=*y*) is the largest positive integer *q* that divides (without a remainder) both *x* and *y*.
Leha has learned how to solve this task very effective. You are able to cope with it not worse, aren't you?
|
The first and single line contains two integers *A* and *B* (1<=≤<=*A*,<=*B*<=≤<=109,<=*min*(*A*,<=*B*)<=≤<=12).
|
Print a single integer denoting the greatest common divisor of integers *A*! and *B*!.
|
[
"4 3\n"
] |
[
"6\n"
] |
Consider the sample.
4! = 1·2·3·4 = 24. 3! = 1·2·3 = 6. The greatest common divisor of integers 24 and 6 is exactly 6.
| 500
|
[
{
"input": "4 3",
"output": "6"
},
{
"input": "10 399603090",
"output": "3628800"
},
{
"input": "6 973151934",
"output": "720"
},
{
"input": "2 841668075",
"output": "2"
},
{
"input": "7 415216919",
"output": "5040"
},
{
"input": "3 283733059",
"output": "6"
},
{
"input": "11 562314608",
"output": "39916800"
},
{
"input": "3 990639260",
"output": "6"
},
{
"input": "11 859155400",
"output": "39916800"
},
{
"input": "1 1",
"output": "1"
},
{
"input": "5 3",
"output": "6"
},
{
"input": "1 4",
"output": "1"
},
{
"input": "5 4",
"output": "24"
},
{
"input": "1 12",
"output": "1"
},
{
"input": "9 7",
"output": "5040"
},
{
"input": "2 3",
"output": "2"
},
{
"input": "6 11",
"output": "720"
},
{
"input": "6 7",
"output": "720"
},
{
"input": "11 11",
"output": "39916800"
},
{
"input": "4 999832660",
"output": "24"
},
{
"input": "7 999228288",
"output": "5040"
},
{
"input": "11 999257105",
"output": "39916800"
},
{
"input": "11 999286606",
"output": "39916800"
},
{
"input": "3 999279109",
"output": "6"
},
{
"input": "999632727 11",
"output": "39916800"
},
{
"input": "999625230 7",
"output": "5040"
},
{
"input": "999617047 3",
"output": "6"
},
{
"input": "999646548 7",
"output": "5040"
},
{
"input": "999639051 3",
"output": "6"
},
{
"input": "12 12",
"output": "479001600"
},
{
"input": "12 1",
"output": "1"
},
{
"input": "1213 5",
"output": "120"
},
{
"input": "8 9",
"output": "40320"
},
{
"input": "12 9",
"output": "362880"
},
{
"input": "12 1000000000",
"output": "479001600"
},
{
"input": "1000000000 1",
"output": "1"
},
{
"input": "12 13",
"output": "479001600"
},
{
"input": "2 29845",
"output": "2"
},
{
"input": "10 21",
"output": "3628800"
},
{
"input": "12 20",
"output": "479001600"
},
{
"input": "15 12",
"output": "479001600"
},
{
"input": "1 1",
"output": "1"
},
{
"input": "1000000000 12",
"output": "479001600"
},
{
"input": "11 30",
"output": "39916800"
},
{
"input": "17 12",
"output": "479001600"
},
{
"input": "4 19",
"output": "24"
},
{
"input": "12 15",
"output": "479001600"
},
{
"input": "20 6",
"output": "720"
},
{
"input": "10 20",
"output": "3628800"
},
{
"input": "10 10",
"output": "3628800"
},
{
"input": "22 12",
"output": "479001600"
},
{
"input": "20 12",
"output": "479001600"
},
{
"input": "12 23",
"output": "479001600"
},
{
"input": "12 22",
"output": "479001600"
},
{
"input": "18 3",
"output": "6"
},
{
"input": "14 10",
"output": "3628800"
},
{
"input": "14 12",
"output": "479001600"
},
{
"input": "8 3",
"output": "6"
},
{
"input": "5 5",
"output": "120"
}
] | 1,666,672,196
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 59
| 46
| 0
|
import math
c,d = (int(x) for x in input().split())
def gof(c, d) :
return math.factorial(min(c, d))
print(gof(c, d))
|
Title: I'm bored with life
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Holidays have finished. Thanks to the help of the hacker Leha, Noora managed to enter the university of her dreams which is located in a town Pavlopolis. It's well known that universities provide students with dormitory for the period of university studies. Consequently Noora had to leave Vičkopolis and move to Pavlopolis. Thus Leha was left completely alone in a quiet town Vičkopolis. He almost even fell into a depression from boredom!
Leha came up with a task for himself to relax a little. He chooses two integers *A* and *B* and then calculates the greatest common divisor of integers "*A* factorial" and "*B* factorial". Formally the hacker wants to find out GCD(*A*!,<=*B*!). It's well known that the factorial of an integer *x* is a product of all positive integers less than or equal to *x*. Thus *x*!<==<=1·2·3·...·(*x*<=-<=1)·*x*. For example 4!<==<=1·2·3·4<==<=24. Recall that GCD(*x*,<=*y*) is the largest positive integer *q* that divides (without a remainder) both *x* and *y*.
Leha has learned how to solve this task very effective. You are able to cope with it not worse, aren't you?
Input Specification:
The first and single line contains two integers *A* and *B* (1<=≤<=*A*,<=*B*<=≤<=109,<=*min*(*A*,<=*B*)<=≤<=12).
Output Specification:
Print a single integer denoting the greatest common divisor of integers *A*! and *B*!.
Demo Input:
['4 3\n']
Demo Output:
['6\n']
Note:
Consider the sample.
4! = 1·2·3·4 = 24. 3! = 1·2·3 = 6. The greatest common divisor of integers 24 and 6 is exactly 6.
|
```python
import math
c,d = (int(x) for x in input().split())
def gof(c, d) :
return math.factorial(min(c, d))
print(gof(c, d))
```
| 3
|
|
660
|
C
|
Hard Process
|
PROGRAMMING
| 1,600
|
[
"binary search",
"dp",
"two pointers"
] | null | null |
You are given an array *a* with *n* elements. Each element of *a* is either 0 or 1.
Let's denote the length of the longest subsegment of consecutive elements in *a*, consisting of only numbers one, as *f*(*a*). You can change no more than *k* zeroes to ones to maximize *f*(*a*).
|
The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=3·105,<=0<=≤<=*k*<=≤<=*n*) — the number of elements in *a* and the parameter *k*.
The second line contains *n* integers *a**i* (0<=≤<=*a**i*<=≤<=1) — the elements of *a*.
|
On the first line print a non-negative integer *z* — the maximal value of *f*(*a*) after no more than *k* changes of zeroes to ones.
On the second line print *n* integers *a**j* — the elements of the array *a* after the changes.
If there are multiple answers, you can print any one of them.
|
[
"7 1\n1 0 0 1 1 0 1\n",
"10 2\n1 0 0 1 0 1 0 1 0 1\n"
] |
[
"4\n1 0 0 1 1 1 1\n",
"5\n1 0 0 1 1 1 1 1 0 1\n"
] |
none
| 0
|
[
{
"input": "7 1\n1 0 0 1 1 0 1",
"output": "4\n1 0 0 1 1 1 1"
},
{
"input": "10 2\n1 0 0 1 0 1 0 1 0 1",
"output": "5\n1 0 0 1 1 1 1 1 0 1"
},
{
"input": "1 0\n0",
"output": "0\n0"
},
{
"input": "1 0\n0",
"output": "0\n0"
},
{
"input": "7 0\n0 1 0 0 0 1 0",
"output": "1\n0 1 0 0 0 1 0"
},
{
"input": "7 2\n1 0 1 1 0 0 0",
"output": "5\n1 1 1 1 1 0 0"
},
{
"input": "7 3\n1 0 0 0 0 1 0",
"output": "4\n1 1 1 1 0 1 0"
},
{
"input": "3 0\n1 1 1",
"output": "3\n1 1 1"
},
{
"input": "1 0\n1",
"output": "1\n1"
},
{
"input": "2 0\n0 1",
"output": "1\n0 1"
},
{
"input": "1 1\n0",
"output": "1\n1"
},
{
"input": "3 1\n0 0 1",
"output": "2\n0 1 1"
},
{
"input": "2 0\n0 0",
"output": "0\n0 0"
},
{
"input": "3 1\n0 0 0",
"output": "1\n1 0 0"
},
{
"input": "7 7\n1 0 1 0 0 0 0",
"output": "7\n1 1 1 1 1 1 1"
},
{
"input": "1 1\n1",
"output": "1\n1"
},
{
"input": "3 0\n0 0 0",
"output": "0\n0 0 0"
},
{
"input": "7 3\n1 1 1 1 1 1 1",
"output": "7\n1 1 1 1 1 1 1"
},
{
"input": "10 3\n0 0 1 0 0 1 0 0 1 1",
"output": "6\n0 0 1 0 1 1 1 1 1 1"
},
{
"input": "2 1\n0 0",
"output": "1\n1 0"
},
{
"input": "2 2\n1 0",
"output": "2\n1 1"
}
] | 1,691,646,472
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 0
| 46
| 0
|
n,k = map(int,input().split())
arr = list(map(int,input().split()))
ans= 0
start = 0
end = 0
ciunt0 = 0
a1,b1 = float("-inf"),float("inf")
while start<n:
if arr[start] == 0:ciunt0+=1
while ciunt0>k:
if arr[end] == 0:
ciunt0-=1
end+=1
if start-end+1>ans:
b1 = start
a1 = end
ans= max(ans,start-end+1)
start+=1
for x in range(a1,b1+1):
arr[x] = 1
print(ans)
print(arr)
|
Title: Hard Process
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given an array *a* with *n* elements. Each element of *a* is either 0 or 1.
Let's denote the length of the longest subsegment of consecutive elements in *a*, consisting of only numbers one, as *f*(*a*). You can change no more than *k* zeroes to ones to maximize *f*(*a*).
Input Specification:
The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=3·105,<=0<=≤<=*k*<=≤<=*n*) — the number of elements in *a* and the parameter *k*.
The second line contains *n* integers *a**i* (0<=≤<=*a**i*<=≤<=1) — the elements of *a*.
Output Specification:
On the first line print a non-negative integer *z* — the maximal value of *f*(*a*) after no more than *k* changes of zeroes to ones.
On the second line print *n* integers *a**j* — the elements of the array *a* after the changes.
If there are multiple answers, you can print any one of them.
Demo Input:
['7 1\n1 0 0 1 1 0 1\n', '10 2\n1 0 0 1 0 1 0 1 0 1\n']
Demo Output:
['4\n1 0 0 1 1 1 1\n', '5\n1 0 0 1 1 1 1 1 0 1\n']
Note:
none
|
```python
n,k = map(int,input().split())
arr = list(map(int,input().split()))
ans= 0
start = 0
end = 0
ciunt0 = 0
a1,b1 = float("-inf"),float("inf")
while start<n:
if arr[start] == 0:ciunt0+=1
while ciunt0>k:
if arr[end] == 0:
ciunt0-=1
end+=1
if start-end+1>ans:
b1 = start
a1 = end
ans= max(ans,start-end+1)
start+=1
for x in range(a1,b1+1):
arr[x] = 1
print(ans)
print(arr)
```
| 0
|
|
960
|
A
|
Check the string
|
PROGRAMMING
| 1,200
|
[
"implementation"
] | null | null |
A has a string consisting of some number of lowercase English letters 'a'. He gives it to his friend B who appends some number of letters 'b' to the end of this string. Since both A and B like the characters 'a' and 'b', they have made sure that at this point, at least one 'a' and one 'b' exist in the string.
B now gives this string to C and he appends some number of letters 'c' to the end of the string. However, since C is a good friend of A and B, the number of letters 'c' he appends is equal to the number of 'a' or to the number of 'b' in the string. It is also possible that the number of letters 'c' equals both to the number of letters 'a' and to the number of letters 'b' at the same time.
You have a string in your hands, and you want to check if it is possible to obtain the string in this way or not. If it is possible to obtain the string, print "YES", otherwise print "NO" (without the quotes).
|
The first and only line consists of a string $S$ ($ 1 \le |S| \le 5\,000 $). It is guaranteed that the string will only consist of the lowercase English letters 'a', 'b', 'c'.
|
Print "YES" or "NO", according to the condition.
|
[
"aaabccc\n",
"bbacc\n",
"aabc\n"
] |
[
"YES\n",
"NO\n",
"YES\n"
] |
Consider first example: the number of 'c' is equal to the number of 'a'.
Consider second example: although the number of 'c' is equal to the number of the 'b', the order is not correct.
Consider third example: the number of 'c' is equal to the number of 'b'.
| 500
|
[
{
"input": "aaabccc",
"output": "YES"
},
{
"input": "bbacc",
"output": "NO"
},
{
"input": "aabc",
"output": "YES"
},
{
"input": "aabbcc",
"output": "YES"
},
{
"input": "aaacccbb",
"output": "NO"
},
{
"input": "abc",
"output": "YES"
},
{
"input": "acba",
"output": "NO"
},
{
"input": "bbabbc",
"output": "NO"
},
{
"input": "bbbabacca",
"output": "NO"
},
{
"input": "aabcbcaca",
"output": "NO"
},
{
"input": "aaaaabbbbbb",
"output": "NO"
},
{
"input": "c",
"output": "NO"
},
{
"input": "cc",
"output": "NO"
},
{
"input": "bbb",
"output": "NO"
},
{
"input": "bc",
"output": "NO"
},
{
"input": "ccbcc",
"output": "NO"
},
{
"input": "aaa",
"output": "NO"
},
{
"input": "aaccaa",
"output": "NO"
},
{
"input": "a",
"output": "NO"
},
{
"input": "b",
"output": "NO"
},
{
"input": "abca",
"output": "NO"
},
{
"input": "aabbcccc",
"output": "NO"
},
{
"input": "abac",
"output": "NO"
},
{
"input": "abcc",
"output": "NO"
},
{
"input": "abcb",
"output": "NO"
},
{
"input": "aacc",
"output": "NO"
},
{
"input": "aabbaacccc",
"output": "NO"
},
{
"input": "aabb",
"output": "NO"
},
{
"input": "ac",
"output": "NO"
},
{
"input": "abbacc",
"output": "NO"
},
{
"input": "abacc",
"output": "NO"
},
{
"input": "ababc",
"output": "NO"
},
{
"input": "aa",
"output": "NO"
},
{
"input": "aabaccc",
"output": "NO"
},
{
"input": "bbcc",
"output": "NO"
},
{
"input": "aaabcbc",
"output": "NO"
},
{
"input": "acbbc",
"output": "NO"
},
{
"input": "babc",
"output": "NO"
},
{
"input": "bbbcc",
"output": "NO"
},
{
"input": "bbc",
"output": "NO"
},
{
"input": "abababccc",
"output": "NO"
},
{
"input": "ccbbaa",
"output": "NO"
}
] | 1,527,372,831
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 49
| 93
| 0
|
l = input().replace("ab", "a|b").replace("bc", "b|c").split('|')
if len(l) != 3:
print("NO")
else:
if len(l[0]) == len(l[2]) or len(l[1]) == len(l[2]):
print("YES")
else:
print("NO")
|
Title: Check the string
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A has a string consisting of some number of lowercase English letters 'a'. He gives it to his friend B who appends some number of letters 'b' to the end of this string. Since both A and B like the characters 'a' and 'b', they have made sure that at this point, at least one 'a' and one 'b' exist in the string.
B now gives this string to C and he appends some number of letters 'c' to the end of the string. However, since C is a good friend of A and B, the number of letters 'c' he appends is equal to the number of 'a' or to the number of 'b' in the string. It is also possible that the number of letters 'c' equals both to the number of letters 'a' and to the number of letters 'b' at the same time.
You have a string in your hands, and you want to check if it is possible to obtain the string in this way or not. If it is possible to obtain the string, print "YES", otherwise print "NO" (without the quotes).
Input Specification:
The first and only line consists of a string $S$ ($ 1 \le |S| \le 5\,000 $). It is guaranteed that the string will only consist of the lowercase English letters 'a', 'b', 'c'.
Output Specification:
Print "YES" or "NO", according to the condition.
Demo Input:
['aaabccc\n', 'bbacc\n', 'aabc\n']
Demo Output:
['YES\n', 'NO\n', 'YES\n']
Note:
Consider first example: the number of 'c' is equal to the number of 'a'.
Consider second example: although the number of 'c' is equal to the number of the 'b', the order is not correct.
Consider third example: the number of 'c' is equal to the number of 'b'.
|
```python
l = input().replace("ab", "a|b").replace("bc", "b|c").split('|')
if len(l) != 3:
print("NO")
else:
if len(l[0]) == len(l[2]) or len(l[1]) == len(l[2]):
print("YES")
else:
print("NO")
```
| 0
|
|
0
|
none
|
none
|
none
| 0
|
[
"none"
] | null | null |
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made *y* submissions, out of which *x* have been successful. Thus, your current success rate on Codeforces is equal to *x*<=/<=*y*.
Your favorite rational number in the [0;1] range is *p*<=/<=*q*. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be *p*<=/<=*q*?
|
The first line contains a single integer *t* (1<=≤<=*t*<=≤<=1000) — the number of test cases.
Each of the next *t* lines contains four integers *x*, *y*, *p* and *q* (0<=≤<=*x*<=≤<=*y*<=≤<=109; 0<=≤<=*p*<=≤<=*q*<=≤<=109; *y*<=><=0; *q*<=><=0).
It is guaranteed that *p*<=/<=*q* is an irreducible fraction.
Hacks. For hacks, an additional constraint of *t*<=≤<=5 must be met.
|
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
|
[
"4\n3 10 1 2\n7 14 3 8\n20 70 2 7\n5 6 1 1\n"
] |
[
"4\n10\n0\n-1\n"
] |
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
| 0
|
[
{
"input": "4\n3 10 1 2\n7 14 3 8\n20 70 2 7\n5 6 1 1",
"output": "4\n10\n0\n-1"
},
{
"input": "8\n0 1 0 1\n0 2 1 2\n0 3 1 1\n1 2 0 1\n1 2 1 1\n2 2 0 1\n3 3 1 2\n4 4 1 1",
"output": "0\n2\n-1\n-1\n-1\n-1\n3\n0"
},
{
"input": "5\n1 1000000000 1 2\n1 1000000000 1 2\n1 1000000000 1 2\n1 1000000000 1 2\n1 1000000000 1 2",
"output": "999999998\n999999998\n999999998\n999999998\n999999998"
},
{
"input": "5\n999999999 1000000000 1 1000000000\n999999999 1000000000 1 1000000000\n999999999 1000000000 1 1000000000\n999999999 1000000000 1 1000000000\n999999999 1000000000 1 1000000000",
"output": "999999998000000000\n999999998000000000\n999999998000000000\n999999998000000000\n999999998000000000"
},
{
"input": "5\n0 1000000000 999999999 1000000000\n0 1000000000 999999999 1000000000\n0 1000000000 999999999 1000000000\n0 1000000000 999999999 1000000000\n0 1000000000 999999999 1000000000",
"output": "999999999000000000\n999999999000000000\n999999999000000000\n999999999000000000\n999999999000000000"
},
{
"input": "1\n999999999 1000000000 1 2",
"output": "999999998"
},
{
"input": "1\n50 50 1 1",
"output": "0"
},
{
"input": "1\n100000000 100000000 1 2",
"output": "100000000"
},
{
"input": "1\n3 999999990 1 1000000000",
"output": "2000000010"
},
{
"input": "5\n3 10 1 2\n7 14 3 8\n20 70 2 7\n5 6 1 1\n1 1 1 1",
"output": "4\n10\n0\n-1\n0"
},
{
"input": "5\n9999999 10000000 1 1000000000\n9999999 10000000 1 1000000000\n9999999 10000000 1 1000000000\n9999999 10000000 1 1000000000\n9999999 10000000 1 1000000000",
"output": "9999998990000000\n9999998990000000\n9999998990000000\n9999998990000000\n9999998990000000"
},
{
"input": "1\n0 1000000000 999999999 1000000000",
"output": "999999999000000000"
},
{
"input": "5\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000",
"output": "999999998000000000\n999999998000000000\n999999998000000000\n999999998000000000\n999999998000000000"
},
{
"input": "5\n1 1000000000 999999999 1000000000\n2 1000000000 999999999 1000000000\n3 1000000000 999999999 1000000000\n4 1000000000 999999999 1000000000\n5 1000000000 999999999 1000000000",
"output": "999999998000000000\n999999997000000000\n999999996000000000\n999999995000000000\n999999994000000000"
},
{
"input": "1\n1 1 1 1",
"output": "0"
},
{
"input": "5\n999999997 999999998 2 999999999\n999999997 999999998 2 999999999\n999999997 999999998 2 999999999\n999999997 999999998 2 999999999\n999999997 999999998 2 999999999",
"output": "499999997500000003\n499999997500000003\n499999997500000003\n499999997500000003\n499999997500000003"
},
{
"input": "5\n1000000000 1000000000 1 1000000000\n1000000000 1000000000 1 1000000000\n1000000000 1000000000 1 1000000000\n1000000000 1000000000 1 1000000000\n1000000000 1000000000 1 1000000000",
"output": "999999999000000000\n999999999000000000\n999999999000000000\n999999999000000000\n999999999000000000"
},
{
"input": "5\n99999997 999999998 999999998 999999999\n99999996 999999997 999999997 999999999\n99999997 999999998 999999998 999999999\n99999996 999999997 999999997 999999999\n99999997 999999998 999999998 999999999",
"output": "899999999100000001\n449999999550000002\n899999999100000001\n449999999550000002\n899999999100000001"
},
{
"input": "1\n1000000000 1000000000 1 1000000000",
"output": "999999999000000000"
},
{
"input": "1\n7 7 1 1",
"output": "0"
},
{
"input": "5\n1000000000 1000000000 1 2\n1000000000 1000000000 1 2\n1000000000 1000000000 1 2\n1000000000 1000000000 1 2\n1000000000 1000000000 1 2",
"output": "1000000000\n1000000000\n1000000000\n1000000000\n1000000000"
},
{
"input": "1\n1000000000 1000000000 1 1",
"output": "0"
},
{
"input": "1\n1 1000000000 999999999 1000000000",
"output": "999999998000000000"
},
{
"input": "4\n1 1000000000 999999999 1000000000\n999999999 1000000000 1 1000000000\n1 2 0 1\n0 1 0 1",
"output": "999999998000000000\n999999998000000000\n-1\n0"
},
{
"input": "1\n1 1000000000 1 2",
"output": "999999998"
},
{
"input": "5\n1 982449707 1 2\n1 982449707 1 2\n1 982449707 1 2\n1 982449707 1 2\n1 982449707 1 2",
"output": "982449705\n982449705\n982449705\n982449705\n982449705"
},
{
"input": "5\n13 900000007 900000007 900000009\n13 900000007 900000007 900000009\n13 900000007 900000007 900000009\n13 900000007 900000007 900000009\n13 900000007 900000007 900000009",
"output": "405000000449999966\n405000000449999966\n405000000449999966\n405000000449999966\n405000000449999966"
},
{
"input": "1\n5 10 0 1",
"output": "-1"
},
{
"input": "1\n2 2 1 1",
"output": "0"
},
{
"input": "5\n0 999999999 999999999 1000000000\n0 999999999 999999999 1000000000\n0 999999999 999999999 1000000000\n0 999999999 999999999 1000000000\n0 999999999 999999999 1000000000",
"output": "999999998000000001\n999999998000000001\n999999998000000001\n999999998000000001\n999999998000000001"
},
{
"input": "1\n0 5 0 1",
"output": "0"
},
{
"input": "5\n999999999 1000000000 1 9999\n999999999 1000000000 1 9999\n999999999 1000000000 1 9999\n999999999 1000000000 1 9999\n999999999 1000000000 1 9999",
"output": "9997999990001\n9997999990001\n9997999990001\n9997999990001\n9997999990001"
},
{
"input": "5\n999999997 1000000000 3 1000000000\n999999997 1000000000 3 1000000000\n999999997 1000000000 3 1000000000\n999999997 1000000000 3 1000000000\n999999997 1000000000 3 1000000000",
"output": "333333332000000000\n333333332000000000\n333333332000000000\n333333332000000000\n333333332000000000"
},
{
"input": "5\n1000000000 1000000000 1 1000000000\n1000000000 1000000000 1 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000",
"output": "999999999000000000\n999999999000000000\n999999998000000000\n999999998000000000\n999999998000000000"
},
{
"input": "5\n1000000000 1000000000 1 1000000000\n1000000000 1000000000 1 1000000000\n1000000000 1000000000 1 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000",
"output": "999999999000000000\n999999999000000000\n999999999000000000\n999999998000000000\n999999998000000000"
},
{
"input": "1\n999999998 999999999 1 10",
"output": "8999999981"
},
{
"input": "5\n1 1 1 1\n2 2 1 1\n100 100 1 1\n1000000000 1000000000 1 1\n1000000000 1000000000 1 1",
"output": "0\n0\n0\n0\n0"
},
{
"input": "4\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000\n1 1000000000 999999999 1000000000",
"output": "999999998000000000\n999999998000000000\n999999998000000000\n999999998000000000"
}
] | 1,494,177,545
| 5,645
|
PyPy 3
|
RUNTIME_ERROR
|
PRETESTS
| 0
| 78
| 0
|
#!/usr/bin/env python3
import math
def extgcd(a, b):
if b == 0:
return 1, 0
else:
na, nb = extgcd(b, a % b)
return nb, na - a//b * nb
def floor(a,b):
if a%b == 0:
return a//b
if a > 0:
return a//b
else:
return a//b-1
t = int(input())
for loop in range(t):
x,y,p,q = list(map(int, input().split()))
if p == 0:
if x == 0:
print(0)
else:
print(-1)
continue
if p == q:
if x == y:
print(0)
else:
print(-1)
continue
r = q * x - p * y;
g = math.gcd(p,q)
a,b = extgcd(p,q)
b = -b;
if r < 0:
a = -a
b = -b
r = -r
if r % g != 0:
print(-1)
continue
tmp = r//g;
a *= tmp
b *= tmp
num = a - b
den = q - p
k = floor(num,den);
k = min(k, floor(b,p));
a += -q * k;
b -= p * k;
if a < b:
print(-1)
else:
print(a)
|
Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made *y* submissions, out of which *x* have been successful. Thus, your current success rate on Codeforces is equal to *x*<=/<=*y*.
Your favorite rational number in the [0;1] range is *p*<=/<=*q*. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be *p*<=/<=*q*?
Input Specification:
The first line contains a single integer *t* (1<=≤<=*t*<=≤<=1000) — the number of test cases.
Each of the next *t* lines contains four integers *x*, *y*, *p* and *q* (0<=≤<=*x*<=≤<=*y*<=≤<=109; 0<=≤<=*p*<=≤<=*q*<=≤<=109; *y*<=><=0; *q*<=><=0).
It is guaranteed that *p*<=/<=*q* is an irreducible fraction.
Hacks. For hacks, an additional constraint of *t*<=≤<=5 must be met.
Output Specification:
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Demo Input:
['4\n3 10 1 2\n7 14 3 8\n20 70 2 7\n5 6 1 1\n']
Demo Output:
['4\n10\n0\n-1\n']
Note:
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
|
```python
#!/usr/bin/env python3
import math
def extgcd(a, b):
if b == 0:
return 1, 0
else:
na, nb = extgcd(b, a % b)
return nb, na - a//b * nb
def floor(a,b):
if a%b == 0:
return a//b
if a > 0:
return a//b
else:
return a//b-1
t = int(input())
for loop in range(t):
x,y,p,q = list(map(int, input().split()))
if p == 0:
if x == 0:
print(0)
else:
print(-1)
continue
if p == q:
if x == y:
print(0)
else:
print(-1)
continue
r = q * x - p * y;
g = math.gcd(p,q)
a,b = extgcd(p,q)
b = -b;
if r < 0:
a = -a
b = -b
r = -r
if r % g != 0:
print(-1)
continue
tmp = r//g;
a *= tmp
b *= tmp
num = a - b
den = q - p
k = floor(num,den);
k = min(k, floor(b,p));
a += -q * k;
b -= p * k;
if a < b:
print(-1)
else:
print(a)
```
| -1
|
|
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,612,361,219
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 37
| 109
| 2,969,600
|
n,k = map(int,input().split())
a = list(map(int,input().split()))
p = sorted(a)
p = p[-k:]
s = sum(p)
print(s)
idx = 0
i = 0
count = 0
ans = []
while len(ans)<k-1:
idx+=1
count+=1
if a[i] in p:
p.remove(a[i])
ans.append(count)
count = 0
i+=1
for i in ans:
print(i,end = " ")
print(n-idx)
|
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()))
p = sorted(a)
p = p[-k:]
s = sum(p)
print(s)
idx = 0
i = 0
count = 0
ans = []
while len(ans)<k-1:
idx+=1
count+=1
if a[i] in p:
p.remove(a[i])
ans.append(count)
count = 0
i+=1
for i in ans:
print(i,end = " ")
print(n-idx)
```
| 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,697,460,496
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 30
| 1,091
| 9,216,000
|
n=int(input())
sum=0
for i in range(n):
k=input()
if k=='Tetrahedron':sum+=4
elif k=='Cube':sum+=6
elif k=='Octahedron':sum+=8
elif k=='Dodecahedron':sum+=12
else:sum+=20
print(sum)
|
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
n=int(input())
sum=0
for i in range(n):
k=input()
if k=='Tetrahedron':sum+=4
elif k=='Cube':sum+=6
elif k=='Octahedron':sum+=8
elif k=='Dodecahedron':sum+=12
else:sum+=20
print(sum)
```
| 3
|
|
748
|
C
|
Santa Claus and Robot
|
PROGRAMMING
| 1,400
|
[
"constructive algorithms",
"math"
] | null | null |
Santa Claus has Robot which lives on the infinite grid and can move along its lines. He can also, having a sequence of *m* points *p*1,<=*p*2,<=...,<=*p**m* with integer coordinates, do the following: denote its initial location by *p*0. First, the robot will move from *p*0 to *p*1 along one of the shortest paths between them (please notice that since the robot moves only along the grid lines, there can be several shortest paths). Then, after it reaches *p*1, it'll move to *p*2, again, choosing one of the shortest ways, then to *p*3, and so on, until he has visited all points in the given order. Some of the points in the sequence may coincide, in that case Robot will visit that point several times according to the sequence order.
While Santa was away, someone gave a sequence of points to Robot. This sequence is now lost, but Robot saved the protocol of its unit movements. Please, find the minimum possible length of the sequence.
|
The first line of input contains the only positive integer *n* (1<=≤<=*n*<=≤<=2·105) which equals the number of unit segments the robot traveled. The second line contains the movements protocol, which consists of *n* letters, each being equal either L, or R, or U, or D. *k*-th letter stands for the direction which Robot traveled the *k*-th unit segment in: L means that it moved to the left, R — to the right, U — to the top and D — to the bottom. Have a look at the illustrations for better explanation.
|
The only line of input should contain the minimum possible length of the sequence.
|
[
"4\nRURD\n",
"6\nRRULDD\n",
"26\nRRRULURURUULULLLDLDDRDRDLD\n",
"3\nRLL\n",
"4\nLRLR\n"
] |
[
"2\n",
"2\n",
"7\n",
"2\n",
"4\n"
] |
The illustrations to the first three tests are given below.
<img class="tex-graphics" src="https://espresso.codeforces.com/832fb8f97a482be815e0f87edde26c9791a0d330.png" style="max-width: 100.0%;max-height: 100.0%;"/> <img class="tex-graphics" src="https://espresso.codeforces.com/119a8ba68772b2c2bf76f2acdc58027f6c5cde1f.png" style="max-width: 100.0%;max-height: 100.0%;"/> <img class="tex-graphics" src="https://espresso.codeforces.com/c7b4534f24cbad48148bcba24bc44f37bf7a2dbf.png" style="max-width: 100.0%;max-height: 100.0%;"/>
The last example illustrates that each point in the sequence should be counted as many times as it is presented in the sequence.
| 1,500
|
[
{
"input": "4\nRURD",
"output": "2"
},
{
"input": "6\nRRULDD",
"output": "2"
},
{
"input": "26\nRRRULURURUULULLLDLDDRDRDLD",
"output": "7"
},
{
"input": "3\nRLL",
"output": "2"
},
{
"input": "4\nLRLR",
"output": "4"
},
{
"input": "5\nLRDLR",
"output": "4"
},
{
"input": "10\nDDRDUULUDD",
"output": "3"
},
{
"input": "1\nD",
"output": "1"
}
] | 1,611,800,276
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 32
| 140
| 3,993,600
|
import sys
input = sys.stdin.readline
'''
'''
start = cur = (0, 0)
steps = 0
result = 0
n = int(input())
for char in input().rstrip():
steps += 1
r, c = cur
sr, sc = start
prev = cur
if char == "R":
c += 1
elif char == "L":
c -= 1
elif char == "U":
r += 1
else:
r -= 1
cur = r,c
if abs(sr-r) + abs(sc-c) == steps:
continue
else:
start = prev
steps = 1
result += 1
print(result+1)
|
Title: Santa Claus and Robot
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Santa Claus has Robot which lives on the infinite grid and can move along its lines. He can also, having a sequence of *m* points *p*1,<=*p*2,<=...,<=*p**m* with integer coordinates, do the following: denote its initial location by *p*0. First, the robot will move from *p*0 to *p*1 along one of the shortest paths between them (please notice that since the robot moves only along the grid lines, there can be several shortest paths). Then, after it reaches *p*1, it'll move to *p*2, again, choosing one of the shortest ways, then to *p*3, and so on, until he has visited all points in the given order. Some of the points in the sequence may coincide, in that case Robot will visit that point several times according to the sequence order.
While Santa was away, someone gave a sequence of points to Robot. This sequence is now lost, but Robot saved the protocol of its unit movements. Please, find the minimum possible length of the sequence.
Input Specification:
The first line of input contains the only positive integer *n* (1<=≤<=*n*<=≤<=2·105) which equals the number of unit segments the robot traveled. The second line contains the movements protocol, which consists of *n* letters, each being equal either L, or R, or U, or D. *k*-th letter stands for the direction which Robot traveled the *k*-th unit segment in: L means that it moved to the left, R — to the right, U — to the top and D — to the bottom. Have a look at the illustrations for better explanation.
Output Specification:
The only line of input should contain the minimum possible length of the sequence.
Demo Input:
['4\nRURD\n', '6\nRRULDD\n', '26\nRRRULURURUULULLLDLDDRDRDLD\n', '3\nRLL\n', '4\nLRLR\n']
Demo Output:
['2\n', '2\n', '7\n', '2\n', '4\n']
Note:
The illustrations to the first three tests are given below.
<img class="tex-graphics" src="https://espresso.codeforces.com/832fb8f97a482be815e0f87edde26c9791a0d330.png" style="max-width: 100.0%;max-height: 100.0%;"/> <img class="tex-graphics" src="https://espresso.codeforces.com/119a8ba68772b2c2bf76f2acdc58027f6c5cde1f.png" style="max-width: 100.0%;max-height: 100.0%;"/> <img class="tex-graphics" src="https://espresso.codeforces.com/c7b4534f24cbad48148bcba24bc44f37bf7a2dbf.png" style="max-width: 100.0%;max-height: 100.0%;"/>
The last example illustrates that each point in the sequence should be counted as many times as it is presented in the sequence.
|
```python
import sys
input = sys.stdin.readline
'''
'''
start = cur = (0, 0)
steps = 0
result = 0
n = int(input())
for char in input().rstrip():
steps += 1
r, c = cur
sr, sc = start
prev = cur
if char == "R":
c += 1
elif char == "L":
c -= 1
elif char == "U":
r += 1
else:
r -= 1
cur = r,c
if abs(sr-r) + abs(sc-c) == steps:
continue
else:
start = prev
steps = 1
result += 1
print(result+1)
```
| 3
|
|
79
|
B
|
Colorful Field
|
PROGRAMMING
| 1,400
|
[
"implementation",
"sortings"
] |
B. Colorful Field
|
2
|
256
|
Fox Ciel saw a large field while she was on a bus. The field was a *n*<=×<=*m* rectangle divided into 1<=×<=1 cells. Some cells were wasteland, and other each cell contained crop plants: either carrots or kiwis or grapes.
After seeing the field carefully, Ciel found that the crop plants of each cell were planted in following procedure:
- Assume that the rows are numbered 1 to *n* from top to bottom and the columns are numbered 1 to *m* from left to right, and a cell in row *i* and column *j* is represented as (*i*,<=*j*). - First, each field is either cultivated or waste. Crop plants will be planted in the cultivated cells in the order of (1,<=1)<=→<=...<=→<=(1,<=*m*)<=→<=(2,<=1)<=→<=...<=→<=(2,<=*m*)<=→<=...<=→<=(*n*,<=1)<=→<=...<=→<=(*n*,<=*m*). Waste cells will be ignored. - Crop plants (either carrots or kiwis or grapes) will be planted in each cell one after another cyclically. Carrots will be planted in the first cell, then kiwis in the second one, grapes in the third one, carrots in the forth one, kiwis in the fifth one, and so on.
The following figure will show you the example of this procedure. Here, a white square represents a cultivated cell, and a black square represents a waste cell.
Now she is wondering how to determine the crop plants in some certain cells.
|
In the first line there are four positive integers *n*,<=*m*,<=*k*,<=*t* (1<=≤<=*n*<=≤<=4·104,<=1<=≤<=*m*<=≤<=4·104,<=1<=≤<=*k*<=≤<=103,<=1<=≤<=*t*<=≤<=103), each of which represents the height of the field, the width of the field, the number of waste cells and the number of queries that ask the kind of crop plants in a certain cell.
Following each *k* lines contains two integers *a*,<=*b* (1<=≤<=*a*<=≤<=*n*,<=1<=≤<=*b*<=≤<=*m*), which denotes a cell (*a*,<=*b*) is waste. It is guaranteed that the same cell will not appear twice in this section.
Following each *t* lines contains two integers *i*,<=*j* (1<=≤<=*i*<=≤<=*n*,<=1<=≤<=*j*<=≤<=*m*), which is a query that asks you the kind of crop plants of a cell (*i*,<=*j*).
|
For each query, if the cell is waste, print Waste. Otherwise, print the name of crop plants in the cell: either Carrots or Kiwis or Grapes.
|
[
"4 5 5 6\n4 3\n1 3\n3 3\n2 5\n3 2\n1 3\n1 4\n2 3\n2 4\n1 1\n1 1\n"
] |
[
"Waste\nGrapes\nCarrots\nKiwis\nCarrots\nCarrots\n"
] |
The sample corresponds to the figure in the statement.
| 1,000
|
[
{
"input": "4 5 5 6\n4 3\n1 3\n3 3\n2 5\n3 2\n1 3\n1 4\n2 3\n2 4\n1 1\n1 1",
"output": "Waste\nGrapes\nCarrots\nKiwis\nCarrots\nCarrots"
},
{
"input": "2 3 2 2\n1 1\n2 2\n2 1\n2 2",
"output": "Grapes\nWaste"
},
{
"input": "31 31 31 4\n4 9\n16 27\n11 29\n8 28\n11 2\n10 7\n22 6\n1 25\n14 8\n9 7\n9 1\n2 3\n5 2\n21 16\n20 19\n23 14\n27 6\n25 21\n14 1\n18 14\n7 2\n19 12\n30 27\n4 27\n24 12\n25 20\n26 22\n21 17\n11 6\n5 28\n28 24\n17 30\n2 5\n30 10\n4 21",
"output": "Kiwis\nCarrots\nGrapes\nGrapes"
},
{
"input": "39898 39898 3 1\n4567 8901\n12345 23456\n24680 35679\n29292 12121",
"output": "Grapes"
},
{
"input": "1 1 1 1\n1 1\n1 1",
"output": "Waste"
},
{
"input": "1 2 1 2\n1 1\n1 2\n1 1",
"output": "Carrots\nWaste"
},
{
"input": "1 6 3 12\n1 2\n1 4\n1 6\n1 1\n1 2\n1 6\n1 2\n1 5\n1 3\n1 4\n1 5\n1 5\n1 4\n1 6\n1 3",
"output": "Carrots\nWaste\nWaste\nWaste\nGrapes\nKiwis\nWaste\nGrapes\nGrapes\nWaste\nWaste\nKiwis"
},
{
"input": "1 10 1 3\n1 5\n1 5\n1 5\n1 5",
"output": "Waste\nWaste\nWaste"
},
{
"input": "5 5 1 3\n2 2\n2 2\n2 2\n2 2",
"output": "Waste\nWaste\nWaste"
},
{
"input": "3 3 3 5\n1 1\n2 2\n3 3\n1 1\n2 2\n2 2\n2 2\n3 3",
"output": "Waste\nWaste\nWaste\nWaste\nWaste"
},
{
"input": "1 10 2 4\n1 9\n1 5\n1 5\n1 6\n1 9\n1 10",
"output": "Waste\nKiwis\nWaste\nKiwis"
},
{
"input": "5 2 2 1\n3 2\n4 2\n5 2",
"output": "Kiwis"
}
] | 1,663,690,373
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 62
| 0
|
numbers = list(map(int, input().split()))
rows = numbers[0]
columns = numbers[1]
waste = numbers[2]
queries = numbers[3]
arr =[]
frutis = ['Carrots' , 'kiwis' , 'Grapes']
counter = 0
for i in range(0 , rows):
column = []
for j in range (0 , columns):
column.append('')
arr.append(column)
for i in range(0 , waste):
x = list(map(int, input().split()))
arr[x[0]-1][x[1]-1] ='Waste'
for i in range(0 , rows):
for j in range(0,columns):
if arr[i][j] != 'Waste':
arr[i][j] = frutis[counter %3]
counter += 1
for i in range(0 , queries):
x = list(map(int , input().split()))
print(arr[x[0]-1][x[1]-1])
|
Title: Colorful Field
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Fox Ciel saw a large field while she was on a bus. The field was a *n*<=×<=*m* rectangle divided into 1<=×<=1 cells. Some cells were wasteland, and other each cell contained crop plants: either carrots or kiwis or grapes.
After seeing the field carefully, Ciel found that the crop plants of each cell were planted in following procedure:
- Assume that the rows are numbered 1 to *n* from top to bottom and the columns are numbered 1 to *m* from left to right, and a cell in row *i* and column *j* is represented as (*i*,<=*j*). - First, each field is either cultivated or waste. Crop plants will be planted in the cultivated cells in the order of (1,<=1)<=→<=...<=→<=(1,<=*m*)<=→<=(2,<=1)<=→<=...<=→<=(2,<=*m*)<=→<=...<=→<=(*n*,<=1)<=→<=...<=→<=(*n*,<=*m*). Waste cells will be ignored. - Crop plants (either carrots or kiwis or grapes) will be planted in each cell one after another cyclically. Carrots will be planted in the first cell, then kiwis in the second one, grapes in the third one, carrots in the forth one, kiwis in the fifth one, and so on.
The following figure will show you the example of this procedure. Here, a white square represents a cultivated cell, and a black square represents a waste cell.
Now she is wondering how to determine the crop plants in some certain cells.
Input Specification:
In the first line there are four positive integers *n*,<=*m*,<=*k*,<=*t* (1<=≤<=*n*<=≤<=4·104,<=1<=≤<=*m*<=≤<=4·104,<=1<=≤<=*k*<=≤<=103,<=1<=≤<=*t*<=≤<=103), each of which represents the height of the field, the width of the field, the number of waste cells and the number of queries that ask the kind of crop plants in a certain cell.
Following each *k* lines contains two integers *a*,<=*b* (1<=≤<=*a*<=≤<=*n*,<=1<=≤<=*b*<=≤<=*m*), which denotes a cell (*a*,<=*b*) is waste. It is guaranteed that the same cell will not appear twice in this section.
Following each *t* lines contains two integers *i*,<=*j* (1<=≤<=*i*<=≤<=*n*,<=1<=≤<=*j*<=≤<=*m*), which is a query that asks you the kind of crop plants of a cell (*i*,<=*j*).
Output Specification:
For each query, if the cell is waste, print Waste. Otherwise, print the name of crop plants in the cell: either Carrots or Kiwis or Grapes.
Demo Input:
['4 5 5 6\n4 3\n1 3\n3 3\n2 5\n3 2\n1 3\n1 4\n2 3\n2 4\n1 1\n1 1\n']
Demo Output:
['Waste\nGrapes\nCarrots\nKiwis\nCarrots\nCarrots\n']
Note:
The sample corresponds to the figure in the statement.
|
```python
numbers = list(map(int, input().split()))
rows = numbers[0]
columns = numbers[1]
waste = numbers[2]
queries = numbers[3]
arr =[]
frutis = ['Carrots' , 'kiwis' , 'Grapes']
counter = 0
for i in range(0 , rows):
column = []
for j in range (0 , columns):
column.append('')
arr.append(column)
for i in range(0 , waste):
x = list(map(int, input().split()))
arr[x[0]-1][x[1]-1] ='Waste'
for i in range(0 , rows):
for j in range(0,columns):
if arr[i][j] != 'Waste':
arr[i][j] = frutis[counter %3]
counter += 1
for i in range(0 , queries):
x = list(map(int , input().split()))
print(arr[x[0]-1][x[1]-1])
```
| 0
|
716
|
B
|
Complete the Word
|
PROGRAMMING
| 1,300
|
[
"greedy",
"two pointers"
] | null | null |
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
|
The first and only line of the input contains a single string *s* (1<=≤<=|*s*|<=≤<=50<=000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
|
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print <=-<=1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
|
[
"ABC??FGHIJK???OPQR?TUVWXY?\n",
"WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO\n",
"??????????????????????????\n",
"AABCDEFGHIJKLMNOPQRSTUVW??M\n"
] |
[
"ABCDEFGHIJKLMNOPQRZTUVWXYS",
"-1",
"MNBVCXZLKJHGFDSAQPWOEIRUYT",
"-1"
] |
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
| 1,000
|
[
{
"input": "ABC??FGHIJK???OPQR?TUVWXY?",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO",
"output": "-1"
},
{
"input": "??????????????????????????",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "AABCDEFGHIJKLMNOPQRSTUVW??M",
"output": "-1"
},
{
"input": "QWERTYUIOPASDFGHJKL???????",
"output": "QWERTYUIOPASDFGHJKLBCMNVXZ"
},
{
"input": "ABABABBAB????????????ABABABABA???????????ABABABABA?????????KLCSJB?????????Z",
"output": "ABABABBABAAAAAAAAAAAAABABABABAAAAAAAAAAAAABABABABADEFGHIMNOKLCSJBPQRTUVWXYZ"
},
{
"input": "Q?E?T?U?O?A?D?G?J?L?X?V?MMQ?E?T?U?O?A?D?G?J?L?X?V?N",
"output": "QAEATAUAOAAADAGAJALAXAVAMMQBECTFUHOIAKDPGRJSLWXYVZN"
},
{
"input": "???????????????????????????",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZA"
},
{
"input": "EJMGJAXCHXYIKZSQKUGRCLSTWDLNCVZIGXGWILAVFBEIGOHWGVEPRJTHWEDQRPOVZUQOSRVTIHFFHJMCLOWGHCIGJBCAAVBJFMJEFTEGFXZFVRZOXAFOFVXRAIZEWIKILFLYDZVDADYWYWYJXAGDFGNZBQKKKTGWPINLCDBZVULROGAKEKXXTWNYKQBMLQMQRUYOWUTWMNTJVGUXENHXWMFWMSBKVNGXSNFFTRTTGEGBBHMFZTKNJQDYUQOXVDWTDHZCCQNYYIOFPMKYQIGEEYBCKBAYVCTWARVMHIENKXKFXNXEFUHUNRQPEDFUBMKNQOYCQHGTLRHLWUAVZJDRBRTSVQHBKRDJFKKYEZAJWJKATRFZLNELPYGFUIWBXLIWVTHUILJHTQKDGRNCFTFELCOQPJDBYSPYJOUDKIFRCKEMJPUXTTAMHVENEVMNTZLUYSUALQOUPPRLZHCYICXAQFFRQZAAJNFKVRJDMDXFTBRJSAAHTSVG",
"output": "-1"
},
{
"input": "SVBWLLLPMPJUQVIGVXPCKMPEBPWMYORVTYELJOQGKEOJVCRBUJOOKQZQBYJIBCSHGSDBTIIMNGAXAQJRHHKQFAJSOJLAYRKWBASMLBQVUPPQWDGAVKDLFHEHVVWGSYQHYCPDIECHBTOIFYUFGKWIIMCKEBLECHCETBQMJPBPPGDHRLJIIMVJBZDRSDWWEJASQFRSCLOBAOLZQDPEZWDLMYTGDLUHCJMTXVURWQFCFDIGSUADTFMNGVHRYHQKWBGWWLQJQSFSWXGWIYUTSBUNZFDONBCFTGWTTQIISXJZUWSZWXXFMNB?UWPOWVWIWMBAPXYMGTRSGWMQRXULCMDTUKZS?CNMBRIYDZCUQWAKYQLLJLTXSVMUAYZHVBZFYBABBECIADQPUPZVVYHTGKOWKDNEUYPBTNUSQLLQRODUXFMSYUYIQGERINAPZWL?VKBVQJQLUJGDPFHNVXXSNOWHBZPMLOXVC?IEUMVLIBYLEATFUTILPPTP",
"output": "-1"
},
{
"input": "DMWSBHPGSJJD?EEV?CYAXQCCGNNQWNN?OMEDD?VC?CTKNQQPYXKKJFAYMJ?FMPXXCLKOL?OTRCE",
"output": "-1"
},
{
"input": "EOYJRKFABJIUOZILSHHCXIFQTXAVXJOVTQCDHXPNYPW?RVRKTB?OVXEL?NQHMZZXJLGSA?OTFSZQBV?SBHGKPJPCIQMLRSYDCFPYMEMXUEVHANXELHKSKNLGHGDCYMURXQRWMHEYXXCMGMUFZIPVOZQQBJGVKESTCDZCWFUCSGGIRWMXYXJLFLGUXQAWLZIKFUTVYDGKBVKBKXTICIKHXWFVJRHNMYRJZYNNYXMUOFERZPY?AJKSMUCTLOFH?LV?EHHCHKBHOJZAHFKJHHZJKZIEYAOAPDQRIUWDBMJGOOSNWN?CBKUXJCTEWVTRBDCNFMGBJUAODCCZVPZBQJNIRJVVF?QBWBV?AXOVOYNAWSKUVPHWJK?YPYOKTVFBWAGCC?JOWPPCAZDOYETAYYECWWURYHY?SJHMSJXDIMXFOTUWJLYDKCHOAPLFYPMFYFRNRKWY?CBPLQJJJ?BJYGBJT?FV?VDQEQAUFWZSOJHZFBVEALMMT?XP",
"output": "-1"
},
{
"input": "E?BIVQUPQQEJNMINFD?NKV?IROHPTGUIPMEVYPII?LZJMRI?FTKKKBHPOVQZZSAPDDWVSPVHOBT",
"output": "-1"
},
{
"input": "FDQHJSNDDXHJLWVZVXJZUGKVHWCZVRWVZTIURLMJNGAMCUBDGVSIDEYRJZOLDISDNTOEKLSNLBSOQZLJVPAMLEBAVUNBXNKMLZBGJJQCGCSKBFSEEDXEVSWGZHFJIZJESPZIKIONJWTFFYYZKIDBSDNPJVAUHQMRFKIJWCEGTBVZHWZEKLPHGZVKZFAFAQRNKHGACNRTSXQKKCYBMEMKNKKSURKHOSMEVUXNGOCVCLVVSKULGBKFPCEKVRAJMBWCFFFSCCNDOSEKXEFFZETTUZHMQETWCVZASTTULYOPBNMOMXMVUEEEYZHSMRPAEIHUKNPNJTARJKQKIOXDJASSQPQQHEQIQJQLVPIJRCFVOVECHBOCRYWQEDXZLJXUDZUBFTRWEWNYTSKGDBEBWFFLMUYWELNVAAXSMKYEZXQFKKHJTZKMKMYOBTVXAOVBRMAMHTBDDYMDGQYEEBYZUBMUCKLKXCZGTWVZAYJOXZVGUYNXOVAPXQVE",
"output": "-1"
},
{
"input": "KMNTIOJTLEKZW?JALAZYWYMKWRXTLAKNMDJLICZMETAKHVPTDOLAPCGHOEYSNIUJZVLPBTZ?YSR",
"output": "-1"
},
{
"input": "?MNURVAKIVSOGITVJZEZCAOZEFVNZERAHVNCVCYKTJVEHK?ZMDL?CROLIDFSG?EIFHYKELMQRBVLE?CERELHDVFODJ?LBGJVFPO?CVMPBW?DPGZMVA?BKPXQQCRMKHJWDNAJSGOTGLBNSWMXMKAQ?MWMXCNRSGHTL?LGLAHSDHAGZRGTNDFI?KJ?GSAWOEPOENXTJCVJGMYOFIQKKDWOCIKPGCMFEKNEUPFGBCBYQCM?EQSAX?HZ?MFKAUHOHRKZZSIVZCAKYIKBDJYOCZJRYNLSOKGAEGQRQ?TBURXXLHAFCNVGAUVWBXZILMHWSBYJTIMWPNEGATPURPTJYFWKHRL?QPYUQ?HKDDHWAHOWUSONQKSZFIYFMFUJAMIYAMPNBGVPJSDFDFSAHDWWGEAKXLHBURNTIMCUZIAFAOCVNKPJRNLNGSJVMGKQ?IFQSRHTZGKHGXFJBDGPLCUUMEWNOSCONIVCLAOAPPSFFLCPRIXTKNBSSOVM",
"output": "-1"
},
{
"input": "MRHKVVRBFEIFWIZGWCATJPBSZWNYANEWSSEVFQUUVNJKQOKVIGYBPFSZFTBUCNQEJEYVOWSPYER",
"output": "-1"
},
{
"input": "CNRFBWKRTQTDFOMIGPPGDBHPRNRXFASDDBCZXHORGXDRSIORLJEROJBLLEHLNBILBPX?KHQLCOUPTKUADCDNHNBWMVNUUVUFPIRXSPNUCCRLJTDSUIUDLBKNKMXSAVBJDUGWIMNBIUWJX?TCBDEBNDYUGPS?MQSSEIIUGEE?XXKW?CMFQMWUAEXTSZNNOCPHBAEAKWALYBBMUMQZXUKTQPWNMZKIDECWIZFHKQIUJZRSBZPQFUQNVKQZMYJDHXZWXFHIZ?HWPIPIWV?JMIYKEJDNPMKTTOY?NTOMZZXTNMWQENYRWFYM?WLJJFCIJSETZSJORBZZHAFWYKGQJAPYQQXUWROOZUDOJJLNCDRSGUKYAZLLENGUICGOYPLJQ?POSKHPMOFJMAOXCITWWL?LOEDKHZPQFZZCTB?JYZNXZSDREAMGGXHMCFTQNOUALEYHULSDQVOXZIWFHNNHHG?FYUOCQNKBLFGGZ?YNFNVLRMENYBDWMDSP",
"output": "-1"
},
{
"input": "KSRVTPFVRJWNPYUZMXBRLKVXIQPPBYVSYKRQPNGKTKRPFMKLIYFACFKBIQGPAXLEUESVGPBBXLY",
"output": "-1"
},
{
"input": "LLVYUOXHBHUZSAPUMQEKWSQAFRKSMEENXDQYOPQFXNNFXSRBGXFUIRBFJDSDKQIDMCPPTWRJOZCRHZYZPBVUJPQXHNALAOCJDTTBDZWYDBVPMNSQNVMLHHUJAOIWFSEJEJSRBYREOZKHEXTBAXPTISPGIPOYBFFEJNAKKXAEPNGKWYGEJTNEZIXAWRSCEIRTKNEWSKSGKNIKDEOVXGYVEVFRGTNDFNWIFDRZQEJQZYIWNZXCONVZAKKKETPTPPXZMIVDWPGXOFODRNJZBATKGXAPXYHTUUFFASCHOLSMVSWBIJBAENEGNQTWKKOJUYQNXWDCDXBXBJOOWETWLQMGKHAJEMGXMYNVEHRAEGZOJJQPZGYRHXRNKMSWFYDIZLIBUTSKIKGQJZLGZQFJVIMNOHNZJKWVVPFMFACVXKJKTBZRXRZDJKSWSXBBKWIKEICSZEIPTOJCKJQYYPNUPRNPQNNCVITNXPLAKQBYAIQGNAHXDUQWQLYN",
"output": "-1"
},
{
"input": "PVCKCT?KLTFPIBBIHODCAABEQLJKQECRUJUSHSXPMBEVBKHQTIKQLBLTIRQZPOGPWMMNWWCUKAD",
"output": "-1"
},
{
"input": "BRTYNUVBBWMFDSRXAMLNSBIN???WDDQVPCSWGJTHLRAKTPFKGVLHAKNRIEYIDDRDZLLTBRKXRVRSPBSLXIZRRBEVMHJSAFPLZAIHFVTTEKDO?DYWKILEYRM?VHSEQCBYZZRZMICVZRYA?ONCSZOPGZUMIHJQJPIFX?YJMIERCMKTSFTDZIKEZPLDEOOCJLQIZ?RPHUEQHPNNSBRQRTDGLWNSCZ?WQVIZPTOETEXYI?DRQUOMREPUTOAJKFNBGYNWMGCAOELXEPLLZEYHTVLT?ETJJXLHJMAUDQESNQ?ZCGNDGI?JSGUXQV?QAWQIYKXBKCCSWNRTGHPZF?CSWDQSAZIWQNHOWHYAEZNXRMPAZEQQPPIBQQJEDHJEDHVXNEDETEN?ZHEPJJ?VVDYGPJUWGCBMB?ANFJHJXQVAJWCAZEZXZX?BACPPXORNENMCRMQPIYKNPHX?NSKGEABWWVLHQ?ESWLJUPQJSFIUEGMGHEYVLYEDWJG?L",
"output": "-1"
},
{
"input": "TESTEIGHTYFOUR",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRSTUVWXY",
"output": "-1"
},
{
"input": "?????????????????????????",
"output": "-1"
},
{
"input": "Q?RYJPGLNQ",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRZTUVWXYS",
"output": "ABCDEFGHIJKLMNOPQRZTUVWXYS"
},
{
"input": "AACDEFGHIJKLMNOPQRZTUVWXYS",
"output": "-1"
},
{
"input": "ZA?ABCDEFGHIJKLMNOPQRSTUVWXY",
"output": "ZAZABCDEFGHIJKLMNOPQRSTUVWXY"
},
{
"input": "AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRSTUVWXYYYZABC",
"output": "-1"
},
{
"input": "????",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRZTUVWXYS??",
"output": "ABCDEFGHIJKLMNOPQRZTUVWXYSAA"
},
{
"input": "A",
"output": "-1"
},
{
"input": "NKBDABACEFGGGIJLLLLMMMOMPQWZSSRHHTTUWUWVXYY",
"output": "-1"
},
{
"input": "AA",
"output": "-1"
},
{
"input": "BAAAAAAAAAAAAAAAAAAAAAAAAAAAXA?CDEFGHIJKLMNOPQRSTUVWXYZ",
"output": "BAAAAAAAAAAAAAAAAAAAAAAAAAAAXABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "???DEFGHIJKL??L?PQRSTUVW???",
"output": "-1"
},
{
"input": "?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A",
"output": "-1"
},
{
"input": "A?AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA?????????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA???????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA??????????",
"output": "-1"
},
{
"input": "ZXXCVBNMLKJHGFDSAQWWERTYUIOP",
"output": "-1"
},
{
"input": "ABCA???????????????????????",
"output": "ABCADEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "AB",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "BCDEFGHIAJKLMNOPQARSTUVWXYZ",
"output": "-1"
},
{
"input": "AABBCDEFGHIJKLMNOPQRSTUVWXYZ",
"output": "-1"
},
{
"input": "???AA????????????????????BB???",
"output": "-1"
},
{
"input": "ABC??FGAHIJ??MNOPQRST??WXYZ",
"output": "ABCDEFGAHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "QWERTYUIOPASDFGHJKLZXCVBN",
"output": "-1"
},
{
"input": "??????AAAAAAAAAAAAAAAAAAAABBBBB??????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBB????????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA??????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASSSSSSSSFFFFFFF?????????DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD??????WWWWWWWWWWEEEEEEEEEEERRRRRRRRRRRRRRRRRRRRRRRRRHHHHHHHHHH?????",
"output": "-1"
}
] | 1,676,951,821
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 115
| 78
| 307,200
|
from collections import defaultdict, deque, Counter
from heapq import heapify, heappop, heappush
def main():
t = 1
# t = int(input())
for _ in range(t):
run_test_case()
def run_test_case():
word = input()
if len(word) < 26:
print(-1)
else:
question = 0
visited = set()
left = i = 0
ok = False
for i in range(0, len(word)):
while visited and word[i] in visited:
if word[left] == "?":
question -= 1
else:
visited.remove(word[left])
left += 1
if word[i] == "?":
question += 1
else:
visited.add(word[i])
if len(visited) + question == 26:
ok = True
break
if ok:
remaining = set()
for j in range(0, 26):
remaining.add(chr(ord('A') + j))
result = []
for j in range(left, i + 1):
if word[j] != '?':
remaining.remove(word[j])
l = list(remaining)
for j in range(left, i + 1):
if word[j] == '?':
result.append(l[-1])
l.pop()
else:
result.append(word[j])
prefix = word[ : left]
infix = "".join(result)
suffix = word[i + 1 :]
prefix = prefix.replace("?","A")
suffix = suffix.replace("?", "A")
result = "".join([prefix, infix, suffix])
print( result)
else:
print(-1)
if __name__ == "__main__":
main()
"""
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/
"""
|
Title: Complete the Word
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input Specification:
The first and only line of the input contains a single string *s* (1<=≤<=|*s*|<=≤<=50<=000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output Specification:
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print <=-<=1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Demo Input:
['ABC??FGHIJK???OPQR?TUVWXY?\n', 'WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO\n', '??????????????????????????\n', 'AABCDEFGHIJKLMNOPQRSTUVW??M\n']
Demo Output:
['ABCDEFGHIJKLMNOPQRZTUVWXYS', '-1', 'MNBVCXZLKJHGFDSAQPWOEIRUYT', '-1']
Note:
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
|
```python
from collections import defaultdict, deque, Counter
from heapq import heapify, heappop, heappush
def main():
t = 1
# t = int(input())
for _ in range(t):
run_test_case()
def run_test_case():
word = input()
if len(word) < 26:
print(-1)
else:
question = 0
visited = set()
left = i = 0
ok = False
for i in range(0, len(word)):
while visited and word[i] in visited:
if word[left] == "?":
question -= 1
else:
visited.remove(word[left])
left += 1
if word[i] == "?":
question += 1
else:
visited.add(word[i])
if len(visited) + question == 26:
ok = True
break
if ok:
remaining = set()
for j in range(0, 26):
remaining.add(chr(ord('A') + j))
result = []
for j in range(left, i + 1):
if word[j] != '?':
remaining.remove(word[j])
l = list(remaining)
for j in range(left, i + 1):
if word[j] == '?':
result.append(l[-1])
l.pop()
else:
result.append(word[j])
prefix = word[ : left]
infix = "".join(result)
suffix = word[i + 1 :]
prefix = prefix.replace("?","A")
suffix = suffix.replace("?", "A")
result = "".join([prefix, infix, suffix])
print( result)
else:
print(-1)
if __name__ == "__main__":
main()
"""
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/
"""
```
| 3
|
|
894
|
A
|
QAQ
|
PROGRAMMING
| 800
|
[
"brute force",
"dp"
] | null | null |
"QAQ" is a word to denote an expression of crying. Imagine "Q" as eyes with tears and "A" as a mouth.
Now Diamond has given Bort a string consisting of only uppercase English letters of length *n*. There is a great number of "QAQ" in the string (Diamond is so cute!).
Bort wants to know how many subsequences "QAQ" are in the string Diamond has given. Note that the letters "QAQ" don't have to be consecutive, but the order of letters should be exact.
|
The only line contains a string of length *n* (1<=≤<=*n*<=≤<=100). It's guaranteed that the string only contains uppercase English letters.
|
Print a single integer — the number of subsequences "QAQ" in the string.
|
[
"QAQAQYSYIOIWIN\n",
"QAQQQZZYNOIWIN\n"
] |
[
"4\n",
"3\n"
] |
In the first example there are 4 subsequences "QAQ": "QAQAQYSYIOIWIN", "QAQAQYSYIOIWIN", "QAQAQYSYIOIWIN", "QAQAQYSYIOIWIN".
| 500
|
[
{
"input": "QAQAQYSYIOIWIN",
"output": "4"
},
{
"input": "QAQQQZZYNOIWIN",
"output": "3"
},
{
"input": "QA",
"output": "0"
},
{
"input": "IAQVAQZLQBQVQFTQQQADAQJA",
"output": "24"
},
{
"input": "QQAAQASGAYAAAAKAKAQIQEAQAIAAIAQQQQQ",
"output": "378"
},
{
"input": "AMVFNFJIAVNQJWIVONQOAOOQSNQSONOASONAONQINAONAOIQONANOIQOANOQINAONOQINAONOXJCOIAQOAOQAQAQAQAQWWWAQQAQ",
"output": "1077"
},
{
"input": "AAQQAXBQQBQQXBNQRJAQKQNAQNQVDQASAGGANQQQQTJFFQQQTQQA",
"output": "568"
},
{
"input": "KAZXAVLPJQBQVQQQQQAPAQQGQTQVZQAAAOYA",
"output": "70"
},
{
"input": "W",
"output": "0"
},
{
"input": "DBA",
"output": "0"
},
{
"input": "RQAWNACASAAKAGAAAAQ",
"output": "10"
},
{
"input": "QJAWZAAOAAGIAAAAAOQATASQAEAAAAQFQQHPA",
"output": "111"
},
{
"input": "QQKWQAQAAAAAAAAGAAVAQUEQQUMQMAQQQNQLAMAAAUAEAAEMAAA",
"output": "411"
},
{
"input": "QQUMQAYAUAAGWAAAQSDAVAAQAAAASKQJJQQQQMAWAYYAAAAAAEAJAXWQQ",
"output": "625"
},
{
"input": "QORZOYAQ",
"output": "1"
},
{
"input": "QCQAQAGAWAQQQAQAVQAQQQQAQAQQQAQAAATQAAVAAAQQQQAAAUUQAQQNQQWQQWAQAAQQKQYAQAAQQQAAQRAQQQWBQQQQAPBAQGQA",
"output": "13174"
},
{
"input": "QQAQQAKQFAQLQAAWAMQAZQAJQAAQQOACQQAAAYANAQAQQAQAAQQAOBQQJQAQAQAQQQAAAAABQQQAVNZAQQQQAMQQAFAAEAQAQHQT",
"output": "10420"
},
{
"input": "AQEGQHQQKQAQQPQKAQQQAAAAQQQAQEQAAQAAQAQFSLAAQQAQOQQAVQAAAPQQAWAQAQAFQAXAQQQQTRLOQAQQJQNQXQQQQSQVDQQQ",
"output": "12488"
},
{
"input": "QNQKQQQLASQBAVQQQQAAQQOQRJQQAQQQEQZUOANAADAAQQJAQAQARAAAQQQEQBHTQAAQAAAAQQMKQQQIAOJJQQAQAAADADQUQQQA",
"output": "9114"
},
{
"input": "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
"output": "35937"
},
{
"input": "AMQQAAQAAQAAAAAAQQQBOAAANAAKQJCYQAE",
"output": "254"
},
{
"input": "AYQBAEQGAQEOAKGIXLQJAIAKQAAAQPUAJAKAATFWQQAOQQQUFQYAQQMQHOKAAJXGFCARAQSATHAUQQAATQJJQDQRAANQQAE",
"output": "2174"
},
{
"input": "AAQXAAQAYQAAAAGAQHVQYAGIVACADFAAQAAAAQZAAQMAKZAADQAQDAAQDAAAMQQOXYAQQQAKQBAAQQKAXQBJZDDLAAHQQ",
"output": "2962"
},
{
"input": "AYQQYAVAMNIAUAAKBBQVACWKTQSAQZAAQAAASZJAWBCAALAARHACQAKQQAQAARPAQAAQAQAAZQUSHQAMFVFZQQQQSAQQXAA",
"output": "2482"
},
{
"input": "LQMAQQARQAQBJQQQAGAAZQQXALQQAARQAQQQQAAQQAQQQAQQCAQQAQQAYQQQRAAZATQALYQQAAHHAAQHAAAAAAAAQQMAAQNAKQ",
"output": "7768"
},
{
"input": "MAQQWAQOYQMAAAQAQPQZAOAAQAUAQNAAQAAAITQSAQAKAQKAQQWSQAAQQAGUCDQMQWKQUXKWQQAAQQAAQQZQDQQQAABXQUUXQOA",
"output": "5422"
},
{
"input": "QTAAQDAQXAQQJQQQGAAAQQQQSBQZKAQQAQQQQEAQNUQBZCQLYQZQEQQAAQHQVAORKQVAQYQNASZQAARZAAGAAAAOQDCQ",
"output": "3024"
},
{
"input": "QQWAQQGQQUZQQQLZAAQYQXQVAQFQUAQZUQZZQUKBHSHTQYLQAOQXAQQGAQQTQOAQARQADAJRAAQPQAQQUQAUAMAUVQAAAQQAWQ",
"output": "4527"
},
{
"input": "QQAAQQAQVAQZQQQQAOEAQZPQIBQZACQQAFQQLAAQDATZQANHKYQQAQTAAFQRQAIQAJPWQAQTEIRXAEQQAYWAAAUKQQAQAQQQSQQH",
"output": "6416"
},
{
"input": "AQQQQAQAAQQAQAQAAAAAAAAAQAQAAAAAQAQAQQQAQQQAAAQQQAAAAAAAQAAAAQQQQQQQAQQQQAQAAAQAAAAAQAQAAAAAQAQAAAA",
"output": "14270"
},
{
"input": "AQQQQAQAAQQAQAQAAAAAAAAAQAQAAAAAQAQAQQQAQQQAAAQQQAAAAAAAQAAAAQQQQQQQAQQQQAQAAAQAAAAAQAQAAAAAQ",
"output": "13136"
},
{
"input": "AQQQQAQAAQQAQAQAAAAAAAAAQAQAAAAAQAQAQQQAQQQAAAQQQAAAAAAAQAAAAQQQQQQQAQQQQAQAAAQAAAAAQAQAAAAAQAQAA",
"output": "14270"
},
{
"input": "AQQQQAQAAQQAQAQAAAAAAAAAQAQAAAAAQAQAQQQAQQQAAAQQQAAAAAAAQAAAAQQQQQQQAQQQQAQAAAQAAAAAQAQAAAAAQQAA",
"output": "14231"
},
{
"input": "QQQQQAQAAQQAQAQAAAAAAAAAQAQAAAAAQAQAQQQAQQQAAAQQQAAAAAAAQAAAAQQQQQQQAQQQQAQAAAQAAAAAQAQAAAAAQAQAA",
"output": "15296"
},
{
"input": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
"output": "0"
},
{
"input": "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
"output": "0"
},
{
"input": "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
"output": "0"
},
{
"input": "QAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQA",
"output": "20825"
},
{
"input": "AQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQAQ",
"output": "20825"
},
{
"input": "Q",
"output": "0"
},
{
"input": "A",
"output": "0"
},
{
"input": "FFF",
"output": "0"
},
{
"input": "AAAAAA",
"output": "0"
}
] | 1,678,282,103
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 43
| 77
| 2,355,200
|
"""
Since n ≤ 100, we can iterate on the place of first 'Q','A' and second 'Q'.
The brute force solution will work in O(n3) time which can surely pass.
If we only iterate on the place of 'A', we can get the number of 'Q' before and after it using prefix sums, and it leads to O(n) solution.
"""
"""
a = input()
lower = a.find("A")# находим A
l = 0# кол-во Q до A
b = 0# кол-во Q после А
for i in range(lower):
if a[i] == "Q":
l += 1
for i in range(lower,len(a)):
if a[i] == "Q":
b += 1
ans = l * b # для единственного A в строке
print(ans)# асимптотика O(n) - проходим через весь массив для подсчета Q
"""
#_____________#
"""
a = input()
ans = 0
counter = a.count("A")
for j in range(counter):
l = 0# кол-во Q до A
b = 0# кол-во Q после А
lower = a.find("A")# находим A
a.pop(lower)# удаляем A для рассмотрения следующего А
for i in range(lower):
if a[i] == "Q":
l += 1
for i in range(lower-1,len(a)):
if a[i] == "Q":
b += 1
ans += l * b # для единственного A в строке
print(ans)# асимптотика O(n) - проходим через весь массив для подсчета Q
"""
#_____________#
s = input()
i = 0
answer = 0
while i < len(s):
j = i+1
while j < len(s):
k = j + 1
while k < len(s):
if (s[i]=="Q") and (s[j]=="A") and (s[k]=="Q"):
answer += 1
k += 1
j += 1
i += 1
print(answer)
|
Title: QAQ
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
"QAQ" is a word to denote an expression of crying. Imagine "Q" as eyes with tears and "A" as a mouth.
Now Diamond has given Bort a string consisting of only uppercase English letters of length *n*. There is a great number of "QAQ" in the string (Diamond is so cute!).
Bort wants to know how many subsequences "QAQ" are in the string Diamond has given. Note that the letters "QAQ" don't have to be consecutive, but the order of letters should be exact.
Input Specification:
The only line contains a string of length *n* (1<=≤<=*n*<=≤<=100). It's guaranteed that the string only contains uppercase English letters.
Output Specification:
Print a single integer — the number of subsequences "QAQ" in the string.
Demo Input:
['QAQAQYSYIOIWIN\n', 'QAQQQZZYNOIWIN\n']
Demo Output:
['4\n', '3\n']
Note:
In the first example there are 4 subsequences "QAQ": "QAQAQYSYIOIWIN", "QAQAQYSYIOIWIN", "QAQAQYSYIOIWIN", "QAQAQYSYIOIWIN".
|
```python
"""
Since n ≤ 100, we can iterate on the place of first 'Q','A' and second 'Q'.
The brute force solution will work in O(n3) time which can surely pass.
If we only iterate on the place of 'A', we can get the number of 'Q' before and after it using prefix sums, and it leads to O(n) solution.
"""
"""
a = input()
lower = a.find("A")# находим A
l = 0# кол-во Q до A
b = 0# кол-во Q после А
for i in range(lower):
if a[i] == "Q":
l += 1
for i in range(lower,len(a)):
if a[i] == "Q":
b += 1
ans = l * b # для единственного A в строке
print(ans)# асимптотика O(n) - проходим через весь массив для подсчета Q
"""
#_____________#
"""
a = input()
ans = 0
counter = a.count("A")
for j in range(counter):
l = 0# кол-во Q до A
b = 0# кол-во Q после А
lower = a.find("A")# находим A
a.pop(lower)# удаляем A для рассмотрения следующего А
for i in range(lower):
if a[i] == "Q":
l += 1
for i in range(lower-1,len(a)):
if a[i] == "Q":
b += 1
ans += l * b # для единственного A в строке
print(ans)# асимптотика O(n) - проходим через весь массив для подсчета Q
"""
#_____________#
s = input()
i = 0
answer = 0
while i < len(s):
j = i+1
while j < len(s):
k = j + 1
while k < len(s):
if (s[i]=="Q") and (s[j]=="A") and (s[k]=="Q"):
answer += 1
k += 1
j += 1
i += 1
print(answer)
```
| 3
|
|
118
|
A
|
String Task
|
PROGRAMMING
| 1,000
|
[
"implementation",
"strings"
] | null | null |
Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
- deletes all the vowels, - inserts a character "." before each consonant, - replaces all uppercase consonants with corresponding lowercase ones.
Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
|
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
|
Print the resulting string. It is guaranteed that this string is not empty.
|
[
"tour\n",
"Codeforces\n",
"aBAcAba\n"
] |
[
".t.r\n",
".c.d.f.r.c.s\n",
".b.c.b\n"
] |
none
| 500
|
[
{
"input": "tour",
"output": ".t.r"
},
{
"input": "Codeforces",
"output": ".c.d.f.r.c.s"
},
{
"input": "aBAcAba",
"output": ".b.c.b"
},
{
"input": "obn",
"output": ".b.n"
},
{
"input": "wpwl",
"output": ".w.p.w.l"
},
{
"input": "ggdvq",
"output": ".g.g.d.v.q"
},
{
"input": "pumesz",
"output": ".p.m.s.z"
},
{
"input": "g",
"output": ".g"
},
{
"input": "zjuotps",
"output": ".z.j.t.p.s"
},
{
"input": "jzbwuehe",
"output": ".j.z.b.w.h"
},
{
"input": "tnkgwuugu",
"output": ".t.n.k.g.w.g"
},
{
"input": "kincenvizh",
"output": ".k.n.c.n.v.z.h"
},
{
"input": "xattxjenual",
"output": ".x.t.t.x.j.n.l"
},
{
"input": "ktajqhpqsvhw",
"output": ".k.t.j.q.h.p.q.s.v.h.w"
},
{
"input": "xnhcigytnqcmy",
"output": ".x.n.h.c.g.t.n.q.c.m"
},
{
"input": "jfmtbejyilxcec",
"output": ".j.f.m.t.b.j.l.x.c.c"
},
{
"input": "D",
"output": ".d"
},
{
"input": "ab",
"output": ".b"
},
{
"input": "Ab",
"output": ".b"
},
{
"input": "aB",
"output": ".b"
},
{
"input": "AB",
"output": ".b"
},
{
"input": "ba",
"output": ".b"
},
{
"input": "bA",
"output": ".b"
},
{
"input": "Ba",
"output": ".b"
},
{
"input": "BA",
"output": ".b"
},
{
"input": "aab",
"output": ".b"
},
{
"input": "baa",
"output": ".b"
},
{
"input": "femOZeCArKCpUiHYnbBPTIOFmsHmcpObtPYcLCdjFrUMIyqYzAokKUiiKZRouZiNMoiOuGVoQzaaCAOkquRjmmKKElLNqCnhGdQM",
"output": ".f.m.z.c.r.k.c.p.h.n.b.b.p.t.f.m.s.h.m.c.p.b.t.p.c.l.c.d.j.f.r.m.q.z.k.k.k.z.r.z.n.m.g.v.q.z.c.k.q.r.j.m.m.k.k.l.l.n.q.c.n.h.g.d.q.m"
},
{
"input": "VMBPMCmMDCLFELLIISUJDWQRXYRDGKMXJXJHXVZADRZWVWJRKFRRNSAWKKDPZZLFLNSGUNIVJFBEQsMDHSBJVDTOCSCgZWWKvZZN",
"output": ".v.m.b.p.m.c.m.m.d.c.l.f.l.l.s.j.d.w.q.r.x.r.d.g.k.m.x.j.x.j.h.x.v.z.d.r.z.w.v.w.j.r.k.f.r.r.n.s.w.k.k.d.p.z.z.l.f.l.n.s.g.n.v.j.f.b.q.s.m.d.h.s.b.j.v.d.t.c.s.c.g.z.w.w.k.v.z.z.n"
},
{
"input": "MCGFQQJNUKuAEXrLXibVjClSHjSxmlkQGTKZrRaDNDomIPOmtSgjJAjNVIVLeUGUAOHNkCBwNObVCHOWvNkLFQQbFnugYVMkJruJ",
"output": ".m.c.g.f.q.q.j.n.k.x.r.l.x.b.v.j.c.l.s.h.j.s.x.m.l.k.q.g.t.k.z.r.r.d.n.d.m.p.m.t.s.g.j.j.j.n.v.v.l.g.h.n.k.c.b.w.n.b.v.c.h.w.v.n.k.l.f.q.q.b.f.n.g.v.m.k.j.r.j"
},
{
"input": "iyaiuiwioOyzUaOtAeuEYcevvUyveuyioeeueoeiaoeiavizeeoeyYYaaAOuouueaUioueauayoiuuyiuovyOyiyoyioaoyuoyea",
"output": ".w.z.t.c.v.v.v.v.z.v"
},
{
"input": "yjnckpfyLtzwjsgpcrgCfpljnjwqzgVcufnOvhxplvflxJzqxnhrwgfJmPzifgubvspffmqrwbzivatlmdiBaddiaktdsfPwsevl",
"output": ".j.n.c.k.p.f.l.t.z.w.j.s.g.p.c.r.g.c.f.p.l.j.n.j.w.q.z.g.v.c.f.n.v.h.x.p.l.v.f.l.x.j.z.q.x.n.h.r.w.g.f.j.m.p.z.f.g.b.v.s.p.f.f.m.q.r.w.b.z.v.t.l.m.d.b.d.d.k.t.d.s.f.p.w.s.v.l"
},
{
"input": "RIIIUaAIYJOiuYIUWFPOOAIuaUEZeIooyUEUEAoIyIHYOEAlVAAIiLUAUAeiUIEiUMuuOiAgEUOIAoOUYYEYFEoOIIVeOOAOIIEg",
"output": ".r.j.w.f.p.z.h.l.v.l.m.g.f.v.g"
},
{
"input": "VBKQCFBMQHDMGNSGBQVJTGQCNHHRJMNKGKDPPSQRRVQTZNKBZGSXBPBRXPMVFTXCHZMSJVBRNFNTHBHGJLMDZJSVPZZBCCZNVLMQ",
"output": ".v.b.k.q.c.f.b.m.q.h.d.m.g.n.s.g.b.q.v.j.t.g.q.c.n.h.h.r.j.m.n.k.g.k.d.p.p.s.q.r.r.v.q.t.z.n.k.b.z.g.s.x.b.p.b.r.x.p.m.v.f.t.x.c.h.z.m.s.j.v.b.r.n.f.n.t.h.b.h.g.j.l.m.d.z.j.s.v.p.z.z.b.c.c.z.n.v.l.m.q"
},
{
"input": "iioyoaayeuyoolyiyoeuouiayiiuyTueyiaoiueyioiouyuauouayyiaeoeiiigmioiououeieeeyuyyaYyioiiooaiuouyoeoeg",
"output": ".l.t.g.m.g"
},
{
"input": "ueyiuiauuyyeueykeioouiiauzoyoeyeuyiaoaiiaaoaueyaeydaoauexuueafouiyioueeaaeyoeuaueiyiuiaeeayaioeouiuy",
"output": ".k.z.d.x.f"
},
{
"input": "FSNRBXLFQHZXGVMKLQDVHWLDSLKGKFMDRQWMWSSKPKKQBNDZRSCBLRSKCKKFFKRDMZFZGCNSMXNPMZVDLKXGNXGZQCLRTTDXLMXQ",
"output": ".f.s.n.r.b.x.l.f.q.h.z.x.g.v.m.k.l.q.d.v.h.w.l.d.s.l.k.g.k.f.m.d.r.q.w.m.w.s.s.k.p.k.k.q.b.n.d.z.r.s.c.b.l.r.s.k.c.k.k.f.f.k.r.d.m.z.f.z.g.c.n.s.m.x.n.p.m.z.v.d.l.k.x.g.n.x.g.z.q.c.l.r.t.t.d.x.l.m.x.q"
},
{
"input": "EYAYAYIOIOYOOAUOEUEUOUUYIYUUMOEOIIIAOIUOAAOIYOIOEUIERCEYYAOIOIGYUIAOYUEOEUAEAYPOYEYUUAUOAOEIYIEYUEEY",
"output": ".m.r.c.g.p"
},
{
"input": "jvvzcdcxjstbbksmqjsngxkgtttdxrljjxtwptgwwqzpvqchvgrkqlzxmptzblxhhsmrkmzzmgdfskhtmmnqzzflpmqdctvrfgtx",
"output": ".j.v.v.z.c.d.c.x.j.s.t.b.b.k.s.m.q.j.s.n.g.x.k.g.t.t.t.d.x.r.l.j.j.x.t.w.p.t.g.w.w.q.z.p.v.q.c.h.v.g.r.k.q.l.z.x.m.p.t.z.b.l.x.h.h.s.m.r.k.m.z.z.m.g.d.f.s.k.h.t.m.m.n.q.z.z.f.l.p.m.q.d.c.t.v.r.f.g.t.x"
},
{
"input": "YB",
"output": ".b"
},
{
"input": "fly",
"output": ".f.l"
},
{
"input": "YyyYYYyyYxdwdawdDAWDdaddYYYY",
"output": ".x.d.w.d.w.d.d.w.d.d.d.d"
}
] | 1,693,589,462
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 42
| 124
| 0
|
word = input().lower()
new_word = ""
for letter in word:
if letter in {"a", "i", "u", "e", "o", "y"}:
continue
else:
new_word += "." + letter
print(new_word)
|
Title: String Task
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
- deletes all the vowels, - inserts a character "." before each consonant, - replaces all uppercase consonants with corresponding lowercase ones.
Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
Input Specification:
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Specification:
Print the resulting string. It is guaranteed that this string is not empty.
Demo Input:
['tour\n', 'Codeforces\n', 'aBAcAba\n']
Demo Output:
['.t.r\n', '.c.d.f.r.c.s\n', '.b.c.b\n']
Note:
none
|
```python
word = input().lower()
new_word = ""
for letter in word:
if letter in {"a", "i", "u", "e", "o", "y"}:
continue
else:
new_word += "." + letter
print(new_word)
```
| 3
|
|
56
|
A
|
Bar
|
PROGRAMMING
| 1,000
|
[
"implementation"
] |
A. Bar
|
2
|
256
|
According to Berland laws it is only allowed to sell alcohol to people not younger than 18 years. Vasya's job is to monitor the law's enforcement. Tonight he entered a bar and saw *n* people sitting there. For every one of them Vasya happened to determine either the age or the drink the person is having. Vasya can check any person, i.e. learn his age and the drink he is having at the same time. What minimal number of people should Vasya check additionally to make sure that there are no clients under 18 having alcohol drinks?
The list of all alcohol drinks in Berland is: ABSINTH, BEER, BRANDY, CHAMPAGNE, GIN, RUM, SAKE, TEQUILA, VODKA, WHISKEY, WINE
|
The first line contains an integer *n* (1<=≤<=*n*<=≤<=100) which is the number of the bar's clients. Then follow *n* lines, each describing one visitor. A line either contains his age (an integer from 0 to 1000) or his drink (a string of capital Latin letters from 1 to 100 in length). It is guaranteed that the input data does not contain spaces and other unnecessary separators.
Only the drinks from the list given above should be considered alcohol.
|
Print a single number which is the number of people Vasya should check to guarantee the law enforcement.
|
[
"5\n18\nVODKA\nCOKE\n19\n17\n"
] |
[
"2\n"
] |
In the sample test the second and fifth clients should be checked.
| 500
|
[
{
"input": "5\n18\nVODKA\nCOKE\n19\n17",
"output": "2"
},
{
"input": "2\n2\nGIN",
"output": "2"
},
{
"input": "3\nWHISKEY\n3\nGIN",
"output": "3"
},
{
"input": "4\n813\nIORBQITQXMPTFAEMEQDQIKFGKGOTNKTOSZCBRPXJLUKVLVHJYNRUJXK\nRUM\nRHVRWGODYWWTYZFLFYKCVUFFRTQDINKNWPKFHZBFWBHWINWJW",
"output": "1"
},
{
"input": "4\nSAKE\nSAKE\n13\n2",
"output": "4"
},
{
"input": "2\n0\n17",
"output": "2"
},
{
"input": "1\n0",
"output": "1"
}
] | 1,620,644,860
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 28
| 124
| 6,758,400
|
n=int(input())
b = ['ABSINTH', 'BEER', 'BRANDY', 'CHAMPAGNE', 'GIN', 'RUM', 'SAKE', 'TEQUILA','VODKA', 'WHISKEY', 'WINE']
c=0
for i in range(n):
a=input()
if a.isdigit():
if int(a)<18:
c+=1
else:
if a in b:
c+=1
print(c)
|
Title: Bar
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
According to Berland laws it is only allowed to sell alcohol to people not younger than 18 years. Vasya's job is to monitor the law's enforcement. Tonight he entered a bar and saw *n* people sitting there. For every one of them Vasya happened to determine either the age or the drink the person is having. Vasya can check any person, i.e. learn his age and the drink he is having at the same time. What minimal number of people should Vasya check additionally to make sure that there are no clients under 18 having alcohol drinks?
The list of all alcohol drinks in Berland is: ABSINTH, BEER, BRANDY, CHAMPAGNE, GIN, RUM, SAKE, TEQUILA, VODKA, WHISKEY, WINE
Input Specification:
The first line contains an integer *n* (1<=≤<=*n*<=≤<=100) which is the number of the bar's clients. Then follow *n* lines, each describing one visitor. A line either contains his age (an integer from 0 to 1000) or his drink (a string of capital Latin letters from 1 to 100 in length). It is guaranteed that the input data does not contain spaces and other unnecessary separators.
Only the drinks from the list given above should be considered alcohol.
Output Specification:
Print a single number which is the number of people Vasya should check to guarantee the law enforcement.
Demo Input:
['5\n18\nVODKA\nCOKE\n19\n17\n']
Demo Output:
['2\n']
Note:
In the sample test the second and fifth clients should be checked.
|
```python
n=int(input())
b = ['ABSINTH', 'BEER', 'BRANDY', 'CHAMPAGNE', 'GIN', 'RUM', 'SAKE', 'TEQUILA','VODKA', 'WHISKEY', 'WINE']
c=0
for i in range(n):
a=input()
if a.isdigit():
if int(a)<18:
c+=1
else:
if a in b:
c+=1
print(c)
```
| 3.956411
|
323
|
A
|
Black-and-White Cube
|
PROGRAMMING
| 1,600
|
[
"combinatorics",
"constructive algorithms"
] | null | null |
You are given a cube of size *k*<=×<=*k*<=×<=*k*, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of *k*3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
- each white cube has exactly 2 neighbouring cubes of white color; - each black cube has exactly 2 neighbouring cubes of black color.
|
The first line contains integer *k* (1<=≤<=*k*<=≤<=100), which is size of the cube.
|
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a *k*<=×<=*k* matrix in the first *k* lines, showing how the first layer of the cube should be painted. In the following *k* lines print a *k*<=×<=*k* matrix — the way the second layer should be painted. And so on to the last *k*-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
|
[
"1\n",
"2\n"
] |
[
"-1\n",
"bb\nww\n\nbb\nww\n"
] |
none
| 500
|
[
{
"input": "1",
"output": "-1"
},
{
"input": "2",
"output": "bb\nww\n\nbb\nww"
},
{
"input": "3",
"output": "-1"
},
{
"input": "4",
"output": "bbbb\nbwwb\nbwwb\nbbbb\n\nwwww\nwbbw\nwbbw\nwwww\n\nbbbb\nbwwb\nbwwb\nbbbb\n\nwwww\nwbbw\nwbbw\nwwww"
},
{
"input": "5",
"output": "-1"
},
{
"input": "6",
"output": "bbbbbb\nbwwwwb\nbwbbwb\nbwbbwb\nbwwwwb\nbbbbbb\n\nwwwwww\nwbbbbw\nwbwwbw\nwbwwbw\nwbbbbw\nwwwwww\n\nbbbbbb\nbwwwwb\nbwbbwb\nbwbbwb\nbwwwwb\nbbbbbb\n\nwwwwww\nwbbbbw\nwbwwbw\nwbwwbw\nwbbbbw\nwwwwww\n\nbbbbbb\nbwwwwb\nbwbbwb\nbwbbwb\nbwwwwb\nbbbbbb\n\nwwwwww\nwbbbbw\nwbwwbw\nwbwwbw\nwbbbbw\nwwwwww"
},
{
"input": "7",
"output": "-1"
},
{
"input": "8",
"output": "bbbbbbbb\nbwwwwwwb\nbwbbbbwb\nbwbwwbwb\nbwbwwbwb\nbwbbbbwb\nbwwwwwwb\nbbbbbbbb\n\nwwwwwwww\nwbbbbbbw\nwbwwwwbw\nwbwbbwbw\nwbwbbwbw\nwbwwwwbw\nwbbbbbbw\nwwwwwwww\n\nbbbbbbbb\nbwwwwwwb\nbwbbbbwb\nbwbwwbwb\nbwbwwbwb\nbwbbbbwb\nbwwwwwwb\nbbbbbbbb\n\nwwwwwwww\nwbbbbbbw\nwbwwwwbw\nwbwbbwbw\nwbwbbwbw\nwbwwwwbw\nwbbbbbbw\nwwwwwwww\n\nbbbbbbbb\nbwwwwwwb\nbwbbbbwb\nbwbwwbwb\nbwbwwbwb\nbwbbbbwb\nbwwwwwwb\nbbbbbbbb\n\nwwwwwwww\nwbbbbbbw\nwbwwwwbw\nwbwbbwbw\nwbwbbwbw\nwbwwwwbw\nwbbbbbbw\nwwwwwwww\n\nbbbbbbbb\nbwwwwwwb\n..."
},
{
"input": "9",
"output": "-1"
},
{
"input": "10",
"output": "bbbbbbbbbb\nbwwwwwwwwb\nbwbbbbbbwb\nbwbwwwwbwb\nbwbwbbwbwb\nbwbwbbwbwb\nbwbwwwwbwb\nbwbbbbbbwb\nbwwwwwwwwb\nbbbbbbbbbb\n\nwwwwwwwwww\nwbbbbbbbbw\nwbwwwwwwbw\nwbwbbbbwbw\nwbwbwwbwbw\nwbwbwwbwbw\nwbwbbbbwbw\nwbwwwwwwbw\nwbbbbbbbbw\nwwwwwwwwww\n\nbbbbbbbbbb\nbwwwwwwwwb\nbwbbbbbbwb\nbwbwwwwbwb\nbwbwbbwbwb\nbwbwbbwbwb\nbwbwwwwbwb\nbwbbbbbbwb\nbwwwwwwwwb\nbbbbbbbbbb\n\nwwwwwwwwww\nwbbbbbbbbw\nwbwwwwwwbw\nwbwbbbbwbw\nwbwbwwbwbw\nwbwbwwbwbw\nwbwbbbbwbw\nwbwwwwwwbw\nwbbbbbbbbw\nwwwwwwwwww\n\nbbbbbbbbbb\nbwwwwwwwwb\n..."
},
{
"input": "11",
"output": "-1"
},
{
"input": "12",
"output": "bbbbbbbbbbbb\nbwwwwwwwwwwb\nbwbbbbbbbbwb\nbwbwwwwwwbwb\nbwbwbbbbwbwb\nbwbwbwwbwbwb\nbwbwbwwbwbwb\nbwbwbbbbwbwb\nbwbwwwwwwbwb\nbwbbbbbbbbwb\nbwwwwwwwwwwb\nbbbbbbbbbbbb\n\nwwwwwwwwwwww\nwbbbbbbbbbbw\nwbwwwwwwwwbw\nwbwbbbbbbwbw\nwbwbwwwwbwbw\nwbwbwbbwbwbw\nwbwbwbbwbwbw\nwbwbwwwwbwbw\nwbwbbbbbbwbw\nwbwwwwwwwwbw\nwbbbbbbbbbbw\nwwwwwwwwwwww\n\nbbbbbbbbbbbb\nbwwwwwwwwwwb\nbwbbbbbbbbwb\nbwbwwwwwwbwb\nbwbwbbbbwbwb\nbwbwbwwbwbwb\nbwbwbwwbwbwb\nbwbwbbbbwbwb\nbwbwwwwwwbwb\nbwbbbbbbbbwb\nbwwwwwwwwwwb\nbbbbbbbbbbbb\n\nw..."
},
{
"input": "13",
"output": "-1"
},
{
"input": "14",
"output": "bbbbbbbbbbbbbb\nbwwwwwwwwwwwwb\nbwbbbbbbbbbbwb\nbwbwwwwwwwwbwb\nbwbwbbbbbbwbwb\nbwbwbwwwwbwbwb\nbwbwbwbbwbwbwb\nbwbwbwbbwbwbwb\nbwbwbwwwwbwbwb\nbwbwbbbbbbwbwb\nbwbwwwwwwwwbwb\nbwbbbbbbbbbbwb\nbwwwwwwwwwwwwb\nbbbbbbbbbbbbbb\n\nwwwwwwwwwwwwww\nwbbbbbbbbbbbbw\nwbwwwwwwwwwwbw\nwbwbbbbbbbbwbw\nwbwbwwwwwwbwbw\nwbwbwbbbbwbwbw\nwbwbwbwwbwbwbw\nwbwbwbwwbwbwbw\nwbwbwbbbbwbwbw\nwbwbwwwwwwbwbw\nwbwbbbbbbbbwbw\nwbwwwwwwwwwwbw\nwbbbbbbbbbbbbw\nwwwwwwwwwwwwww\n\nbbbbbbbbbbbbbb\nbwwwwwwwwwwwwb\nbwbbbbbbbbbbwb\nbwbwwwwwwww..."
},
{
"input": "15",
"output": "-1"
},
{
"input": "16",
"output": "bbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbwb\nbwbwwwwwwwwwwbwb\nbwbwbbbbbbbbwbwb\nbwbwbwwwwwwbwbwb\nbwbwbwbbbbwbwbwb\nbwbwbwbwwbwbwbwb\nbwbwbwbwwbwbwbwb\nbwbwbwbbbbwbwbwb\nbwbwbwwwwwwbwbwb\nbwbwbbbbbbbbwbwb\nbwbwwwwwwwwwwbwb\nbwbbbbbbbbbbbbwb\nbwwwwwwwwwwwwwwb\nbbbbbbbbbbbbbbbb\n\nwwwwwwwwwwwwwwww\nwbbbbbbbbbbbbbbw\nwbwwwwwwwwwwwwbw\nwbwbbbbbbbbbbwbw\nwbwbwwwwwwwwbwbw\nwbwbwbbbbbbwbwbw\nwbwbwbwwwwbwbwbw\nwbwbwbwbbwbwbwbw\nwbwbwbwbbwbwbwbw\nwbwbwbwwwwbwbwbw\nwbwbwbbbbbbwbwbw\nwbwbwwwwwwwwbwbw\nwbwbb..."
},
{
"input": "17",
"output": "-1"
},
{
"input": "18",
"output": "bbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbwbwb\nbwbwbwwwwwwwwbwbwb\nbwbwbwbbbbbbwbwbwb\nbwbwbwbwwwwbwbwbwb\nbwbwbwbwbbwbwbwbwb\nbwbwbwbwbbwbwbwbwb\nbwbwbwbwwwwbwbwbwb\nbwbwbwbbbbbbwbwbwb\nbwbwbwwwwwwwwbwbwb\nbwbwbbbbbbbbbbwbwb\nbwbwwwwwwwwwwwwbwb\nbwbbbbbbbbbbbbbbwb\nbwwwwwwwwwwwwwwwwb\nbbbbbbbbbbbbbbbbbb\n\nwwwwwwwwwwwwwwwwww\nwbbbbbbbbbbbbbbbbw\nwbwwwwwwwwwwwwwwbw\nwbwbbbbbbbbbbbbwbw\nwbwbwwwwwwwwwwbwbw\nwbwbwbbbbbbbbwbwbw\nwbwbwbwwwwwwbwbwbw\nwbwbwbwbb..."
},
{
"input": "19",
"output": "-1"
},
{
"input": "20",
"output": "bbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbwbwbwb\nbwbwbwbwwwwwwbwbwbwb\nbwbwbwbwbbbbwbwbwbwb\nbwbwbwbwbwwbwbwbwbwb\nbwbwbwbwbwwbwbwbwbwb\nbwbwbwbwbbbbwbwbwbwb\nbwbwbwbwwwwwwbwbwbwb\nbwbwbwbbbbbbbbwbwbwb\nbwbwbwwwwwwwwwwbwbwb\nbwbwbbbbbbbbbbbbwbwb\nbwbwwwwwwwwwwwwwwbwb\nbwbbbbbbbbbbbbbbbbwb\nbwwwwwwwwwwwwwwwwwwb\nbbbbbbbbbbbbbbbbbbbb\n\nwwwwwwwwwwwwwwwwwwww\nwbbbbbbbbbbbbbbbbbbw\nwbwwwwwwwwwwwwwwwwbw\nwbw..."
},
{
"input": "21",
"output": "-1"
},
{
"input": "22",
"output": "bbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbwbwbwbwb\nbwbwbwbwbwwwwbwbwbwbwb\nbwbwbwbwbwbbwbwbwbwbwb\nbwbwbwbwbwbbwbwbwbwbwb\nbwbwbwbwbwwwwbwbwbwbwb\nbwbwbwbwbbbbbbwbwbwbwb\nbwbwbwbwwwwwwwwbwbwbwb\nbwbwbwbbbbbbbbbbwbwbwb\nbwbwbwwwwwwwwwwwwbwbwb\nbwbwbbbbbbbbbbbbbbwbwb\nbwbwwwwwwwwwwwwwwwwbwb\nbwbbbbbbbbbbbbbbbbbbwb\nbwwwwwwwwwwwwwwwwwwwwb\nbbbbbbb..."
},
{
"input": "23",
"output": "-1"
},
{
"input": "24",
"output": "bbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbwbwbwbwbwb\nbwbwbwbwbwbwwbwbwbwbwbwb\nbwbwbwbwbwbwwbwbwbwbwbwb\nbwbwbwbwbwbbbbwbwbwbwbwb\nbwbwbwbwbwwwwwwbwbwbwbwb\nbwbwbwbwbbbbbbbbwbwbwbwb\nbwbwbwbwwwwwwwwwwbwbwbwb\nbwbwbwbbbbbbbbbbbbwbwbwb\nbwbwbwwwwwwwwwwwwwwbwbwb\nbwbwbbbbbbbbbbbbb..."
},
{
"input": "25",
"output": "-1"
},
{
"input": "26",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwbwbwbwbwbwb\nbwbwbwbwbwbwbbwbwbwbwbwbwb\nbwbwbwbwbwbwbbwbwbwbwbwbwb\nbwbwbwbwbwbwwwwbwbwbwbwbwb\nbwbwbwbwbwbbbbbbwbwbwbwbwb\nbwbwbwbwbwwwwwwwwbwbwbwbwb\nbwbwbwbwbbbbbbbbbbwbwbwbwb\nbwbwbwb..."
},
{
"input": "27",
"output": "-1"
},
{
"input": "28",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwbwbwbwbwbwb\nbwbwbwbwbwbwbbbbwbwbwbwbwbwb\nbwbwbwbwbwbwbwwbwbwbwbwbwbwb\nbwbwbwbwbwbwbwwbwbwbwbwbwbwb\nbwbwbwbwbwbwbbbbwbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwbwbwbwbwbwb\nb..."
},
{
"input": "29",
"output": "-1"
},
{
"input": "30",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwbwbwbwbwbwb\nbwbwbwbwbwbwbbbbbbwbwbwbwbwbwb\nbwbwbwbwbwbwbwwwwbwbwbwbwbwbwb\nbwbwbwbwbwbwbwbbwbwbwbwbwbwbwb\nbwbwbwbwbwbwbwbbwbwbwbwbwbwbwb\n..."
},
{
"input": "31",
"output": "-1"
},
{
"input": "32",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwwwbwbwbwbwbwb\nbwbwbwbwbwbwbbbbbbbbwbwbwbwbwbwb\nbwbwbwbwbwbwbwwwwwwbwbwbwbwbwbwb\nbwbwbwbwbwbwbwbbbbwbwbwbwbwbwbwb\nb..."
},
{
"input": "33",
"output": "-1"
},
{
"input": "34",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwwwwwbwbwbwbwbwb\nbwbwbwbwbwbwbbbbbbbbbbwbwbwbwbwbwb\nbwbwbwbwbwbwbwwwwwwwwbwbwbwbwbwbwb\nbwbwbwb..."
},
{
"input": "35",
"output": "-1"
},
{
"input": "36",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwwwwwwwbwbwbwbwbwb\nbwbwbwbwbwbwbbbbbbbbbbbbwbwbwbwbwbwb\nbwbwbwbwbwbwbwwww..."
},
{
"input": "37",
"output": "-1"
},
{
"input": "38",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwwwwwwwwwbwbwbwbwbwb\nbwbwbwbwbwbwbbbbbbbbbbbbbbwbwbw..."
},
{
"input": "39",
"output": "-1"
},
{
"input": "40",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwwwwwwwwwwwbwbwbwbwbwb\nbwbwbwb..."
},
{
"input": "41",
"output": "-1"
},
{
"input": "42",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwwwwwwwww..."
},
{
"input": "43",
"output": "-1"
},
{
"input": "44",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwbwb\nbwbwb..."
},
{
"input": "45",
"output": "-1"
},
{
"input": "46",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbbbbbbbb..."
},
{
"input": "47",
"output": "-1"
},
{
"input": "48",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwb..."
},
{
"input": "49",
"output": "-1"
},
{
"input": "50",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbw..."
},
{
"input": "51",
"output": "-1"
},
{
"input": "52",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwww..."
},
{
"input": "53",
"output": "-1"
},
{
"input": "54",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwb..."
},
{
"input": "55",
"output": "-1"
},
{
"input": "56",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb..."
},
{
"input": "57",
"output": "-1"
},
{
"input": "58",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbb..."
},
{
"input": "59",
"output": "-1"
},
{
"input": "60",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbb..."
},
{
"input": "61",
"output": "-1"
},
{
"input": "62",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\n..."
},
{
"input": "63",
"output": "-1"
},
{
"input": "64",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww..."
},
{
"input": "65",
"output": "-1"
},
{
"input": "66",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwww..."
},
{
"input": "67",
"output": "-1"
},
{
"input": "68",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwww..."
},
{
"input": "69",
"output": "-1"
},
{
"input": "70",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwb..."
},
{
"input": "71",
"output": "-1"
},
{
"input": "72",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbw..."
},
{
"input": "73",
"output": "-1"
},
{
"input": "74",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb..."
},
{
"input": "75",
"output": "-1"
},
{
"input": "76",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb..."
},
{
"input": "77",
"output": "-1"
},
{
"input": "78",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbb..."
},
{
"input": "79",
"output": "-1"
},
{
"input": "80",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbb..."
},
{
"input": "81",
"output": "-1"
},
{
"input": "82",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwb..."
},
{
"input": "83",
"output": "-1"
},
{
"input": "84",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbw..."
},
{
"input": "85",
"output": "-1"
},
{
"input": "86",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww..."
},
{
"input": "87",
"output": "-1"
},
{
"input": "88",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww..."
},
{
"input": "89",
"output": "-1"
},
{
"input": "90",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww..."
},
{
"input": "91",
"output": "-1"
},
{
"input": "92",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww..."
},
{
"input": "93",
"output": "-1"
},
{
"input": "94",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwww..."
},
{
"input": "95",
"output": "-1"
},
{
"input": "96",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwww..."
},
{
"input": "97",
"output": "-1"
},
{
"input": "98",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwww..."
},
{
"input": "99",
"output": "-1"
},
{
"input": "100",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nb..."
},
{
"input": "40",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwb\nbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwb\nbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwb\nbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwb\nbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwb\nbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbbbbbwbwbwb\nbwbwbwbwwwwwwwwwwwwwwwwwwwwwwwwwwbwbwbwb\nbwbwbwbwbbbbbbbbbbbbbbbbbbbbbbbbwbwbwbwb\nbwbwbwbwbwwwwwwwwwwwwwwwwwwwwwwbwbwbwbwb\nbwbwbwbwbwbbbbbbbbbbbbbbbbbbbbwbwbwbwbwb\nbwbwbwbwbwbwwwwwwwwwwwwwwwwwwbwbwbwbwbwb\nbwbwbwb..."
}
] | 1,372,365,951
| 2,751
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 55
| 1,000
| 204,800
|
n = int(input())
if n % 2 == 1:
print(-1)
else:
for i in range(n):
for j in range(n):
for k in range(n):
print(('w', 'b')[(i + (j // 2) + (k // 2)) % 2], end='')
print()
print()
|
Title: Black-and-White Cube
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a cube of size *k*<=×<=*k*<=×<=*k*, which consists of unit cubes. Two unit cubes are considered neighbouring, if they have common face.
Your task is to paint each of *k*3 unit cubes one of two colours (black or white), so that the following conditions must be satisfied:
- each white cube has exactly 2 neighbouring cubes of white color; - each black cube has exactly 2 neighbouring cubes of black color.
Input Specification:
The first line contains integer *k* (1<=≤<=*k*<=≤<=100), which is size of the cube.
Output Specification:
Print -1 if there is no solution. Otherwise, print the required painting of the cube consequently by layers. Print a *k*<=×<=*k* matrix in the first *k* lines, showing how the first layer of the cube should be painted. In the following *k* lines print a *k*<=×<=*k* matrix — the way the second layer should be painted. And so on to the last *k*-th layer. Note that orientation of the cube in the space does not matter.
Mark a white unit cube with symbol "w" and a black one with "b". Use the format of output data, given in the test samples. You may print extra empty lines, they will be ignored.
Demo Input:
['1\n', '2\n']
Demo Output:
['-1\n', 'bb\nww\n\nbb\nww\n']
Note:
none
|
```python
n = int(input())
if n % 2 == 1:
print(-1)
else:
for i in range(n):
for j in range(n):
for k in range(n):
print(('w', 'b')[(i + (j // 2) + (k // 2)) % 2], end='')
print()
print()
```
| 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,628,380,931
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 92
| 7,065,600
|
# A. Little Elephant and Rozdil
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
mn = min(a)
if a.count(mn) == 1:
print(a.index(mn))
else:
print("Still Rozdil")
|
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
# A. Little Elephant and Rozdil
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
mn = min(a)
if a.count(mn) == 1:
print(a.index(mn))
else:
print("Still Rozdil")
```
| 0
|
|
499
|
B
|
Lecture
|
PROGRAMMING
| 1,000
|
[
"implementation",
"strings"
] | null | null |
You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.
You know two languages, and the professor is giving the lecture in the first one. The words in both languages consist of lowercase English characters, each language consists of several words. For each language, all words are distinct, i.e. they are spelled differently. Moreover, the words of these languages have a one-to-one correspondence, that is, for each word in each language, there exists exactly one word in the other language having has the same meaning.
You can write down every word the professor says in either the first language or the second language. Of course, during the lecture you write down each word in the language in which the word is shorter. In case of equal lengths of the corresponding words you prefer the word of the first language.
You are given the text of the lecture the professor is going to read. Find out how the lecture will be recorded in your notes.
|
The first line contains two integers, *n* and *m* (1<=≤<=*n*<=≤<=3000, 1<=≤<=*m*<=≤<=3000) — the number of words in the professor's lecture and the number of words in each of these languages.
The following *m* lines contain the words. The *i*-th line contains two strings *a**i*, *b**i* meaning that the word *a**i* belongs to the first language, the word *b**i* belongs to the second language, and these two words have the same meaning. It is guaranteed that no word occurs in both languages, and each word occurs in its language exactly once.
The next line contains *n* space-separated strings *c*1,<=*c*2,<=...,<=*c**n* — the text of the lecture. It is guaranteed that each of the strings *c**i* belongs to the set of strings {*a*1,<=*a*2,<=... *a**m*}.
All the strings in the input are non-empty, each consisting of no more than 10 lowercase English letters.
|
Output exactly *n* words: how you will record the lecture in your notebook. Output the words of the lecture in the same order as in the input.
|
[
"4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest\n",
"5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll\n"
] |
[
"codeforces round letter round\n",
"hbnyiyc joll joll un joll\n"
] |
none
| 500
|
[
{
"input": "4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest",
"output": "codeforces round letter round"
},
{
"input": "5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll",
"output": "hbnyiyc joll joll un joll"
},
{
"input": "5 5\nqueyqj f\nb vn\ntabzvk qpfzoqx\nytnyonoc hnxsd\njpggvr lchinjmt\nqueyqj jpggvr b ytnyonoc b",
"output": "f jpggvr b hnxsd b"
},
{
"input": "10 22\nazbrll oen\ngh vdyayei\njphveblohx vfglv\nmfyxib jepnvhcuwo\nrpikazqj uam\nl rx\nokjenof qpnyi\nj tixqrno\nod itozmfct\nikkdxmirx ev\nqexftojc p\nkdazb zjs\nmbk ykvqjrxaxu\nhbcwhouzq pwt\nmirpsz zfaegpl\nuhkkvcj rlvwj\nef iqnnwtolrc\npjzfcpmeag ecdayth\nsa qcthz\ncbfhfxi qrnbvdryz\nwqel tj\natx smkbid\nef hbcwhouzq cbfhfxi hbcwhouzq mirpsz cbfhfxi cbfhfxi okjenof pjzfcpmeag kdazb",
"output": "ef pwt cbfhfxi pwt mirpsz cbfhfxi cbfhfxi qpnyi ecdayth zjs"
},
{
"input": "1 1\namit am\namit",
"output": "am"
},
{
"input": "1 1\na c\na",
"output": "a"
}
] | 1,686,153,853
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 37
| 140
| 7,168,000
|
n,m = map(int,input().split())
import sys
wordDict = {}
for _ in range(m):
w1,w2 = input().split()
n1,n2 = len(w1),len(w2)
if n1 <= n2:
wordDict[w1] = w1
else:
wordDict[w1] = w2
c = input().split()
ans=""
for i in range(n):
ans+=wordDict[c[i]]+" "
sys.stdout.write(ans)
|
Title: Lecture
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.
You know two languages, and the professor is giving the lecture in the first one. The words in both languages consist of lowercase English characters, each language consists of several words. For each language, all words are distinct, i.e. they are spelled differently. Moreover, the words of these languages have a one-to-one correspondence, that is, for each word in each language, there exists exactly one word in the other language having has the same meaning.
You can write down every word the professor says in either the first language or the second language. Of course, during the lecture you write down each word in the language in which the word is shorter. In case of equal lengths of the corresponding words you prefer the word of the first language.
You are given the text of the lecture the professor is going to read. Find out how the lecture will be recorded in your notes.
Input Specification:
The first line contains two integers, *n* and *m* (1<=≤<=*n*<=≤<=3000, 1<=≤<=*m*<=≤<=3000) — the number of words in the professor's lecture and the number of words in each of these languages.
The following *m* lines contain the words. The *i*-th line contains two strings *a**i*, *b**i* meaning that the word *a**i* belongs to the first language, the word *b**i* belongs to the second language, and these two words have the same meaning. It is guaranteed that no word occurs in both languages, and each word occurs in its language exactly once.
The next line contains *n* space-separated strings *c*1,<=*c*2,<=...,<=*c**n* — the text of the lecture. It is guaranteed that each of the strings *c**i* belongs to the set of strings {*a*1,<=*a*2,<=... *a**m*}.
All the strings in the input are non-empty, each consisting of no more than 10 lowercase English letters.
Output Specification:
Output exactly *n* words: how you will record the lecture in your notebook. Output the words of the lecture in the same order as in the input.
Demo Input:
['4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest\n', '5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll\n']
Demo Output:
['codeforces round letter round\n', 'hbnyiyc joll joll un joll\n']
Note:
none
|
```python
n,m = map(int,input().split())
import sys
wordDict = {}
for _ in range(m):
w1,w2 = input().split()
n1,n2 = len(w1),len(w2)
if n1 <= n2:
wordDict[w1] = w1
else:
wordDict[w1] = w2
c = input().split()
ans=""
for i in range(n):
ans+=wordDict[c[i]]+" "
sys.stdout.write(ans)
```
| 3
|
|
25
|
A
|
IQ test
|
PROGRAMMING
| 1,300
|
[
"brute force"
] |
A. IQ test
|
2
|
256
|
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that is different in evenness.
|
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness.
|
Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order.
|
[
"5\n2 4 7 8 10\n",
"4\n1 2 1 1\n"
] |
[
"3\n",
"2\n"
] |
none
| 0
|
[
{
"input": "5\n2 4 7 8 10",
"output": "3"
},
{
"input": "4\n1 2 1 1",
"output": "2"
},
{
"input": "3\n1 2 2",
"output": "1"
},
{
"input": "3\n100 99 100",
"output": "2"
},
{
"input": "3\n5 3 2",
"output": "3"
},
{
"input": "4\n43 28 1 91",
"output": "2"
},
{
"input": "4\n75 13 94 77",
"output": "3"
},
{
"input": "4\n97 8 27 3",
"output": "2"
},
{
"input": "10\n95 51 12 91 85 3 1 31 25 7",
"output": "3"
},
{
"input": "20\n88 96 66 51 14 88 2 92 18 72 18 88 20 30 4 82 90 100 24 46",
"output": "4"
},
{
"input": "30\n20 94 56 50 10 98 52 32 14 22 24 60 4 8 98 46 34 68 82 82 98 90 50 20 78 49 52 94 64 36",
"output": "26"
},
{
"input": "50\n79 27 77 57 37 45 27 49 65 33 57 21 71 19 75 85 65 61 23 97 85 9 23 1 9 3 99 77 77 21 79 69 15 37 15 7 93 81 13 89 91 31 45 93 15 97 55 80 85 83",
"output": "48"
},
{
"input": "60\n46 11 73 65 3 69 3 53 43 53 97 47 55 93 31 75 35 3 9 73 23 31 3 81 91 79 61 21 15 11 11 11 81 7 83 75 39 87 83 59 89 55 93 27 49 67 67 29 1 93 11 17 9 19 35 21 63 31 31 25",
"output": "1"
},
{
"input": "70\n28 42 42 92 64 54 22 38 38 78 62 38 4 38 14 66 4 92 66 58 94 26 4 44 41 88 48 82 44 26 74 44 48 4 16 92 34 38 26 64 94 4 30 78 50 54 12 90 8 16 80 98 28 100 74 50 36 42 92 18 76 98 8 22 2 50 58 50 64 46",
"output": "25"
},
{
"input": "100\n43 35 79 53 13 91 91 45 65 83 57 9 42 39 85 45 71 51 61 59 31 13 63 39 25 21 79 39 91 67 21 61 97 75 93 83 29 79 59 97 11 37 63 51 39 55 91 23 21 17 47 23 35 75 49 5 69 99 5 7 41 17 25 89 15 79 21 63 53 81 43 91 59 91 69 99 85 15 91 51 49 37 65 7 89 81 21 93 61 63 97 93 45 17 13 69 57 25 75 73",
"output": "13"
},
{
"input": "100\n50 24 68 60 70 30 52 22 18 74 68 98 20 82 4 46 26 68 100 78 84 58 74 98 38 88 68 86 64 80 82 100 20 22 98 98 52 6 94 10 48 68 2 18 38 22 22 82 44 20 66 72 36 58 64 6 36 60 4 96 76 64 12 90 10 58 64 60 74 28 90 26 24 60 40 58 2 16 76 48 58 36 82 60 24 44 4 78 28 38 8 12 40 16 38 6 66 24 31 76",
"output": "99"
},
{
"input": "100\n47 48 94 48 14 18 94 36 96 22 12 30 94 20 48 98 40 58 2 94 8 36 98 18 98 68 2 60 76 38 18 100 8 72 100 68 2 86 92 72 58 16 48 14 6 58 72 76 6 88 80 66 20 28 74 62 86 68 90 86 2 56 34 38 56 90 4 8 76 44 32 86 12 98 38 34 54 92 70 94 10 24 82 66 90 58 62 2 32 58 100 22 58 72 2 22 68 72 42 14",
"output": "1"
},
{
"input": "99\n38 20 68 60 84 16 28 88 60 48 80 28 4 92 70 60 46 46 20 34 12 100 76 2 40 10 8 86 6 80 50 66 12 34 14 28 26 70 46 64 34 96 10 90 98 96 56 88 50 74 70 94 2 94 24 66 68 46 22 30 6 10 64 32 88 14 98 100 64 58 50 18 50 50 8 38 8 16 54 2 60 54 62 84 92 98 4 72 66 26 14 88 99 16 10 6 88 56 22",
"output": "93"
},
{
"input": "99\n50 83 43 89 53 47 69 1 5 37 63 87 95 15 55 95 75 89 33 53 89 75 93 75 11 85 49 29 11 97 49 67 87 11 25 37 97 73 67 49 87 43 53 97 43 29 53 33 45 91 37 73 39 49 59 5 21 43 87 35 5 63 89 57 63 47 29 99 19 85 13 13 3 13 43 19 5 9 61 51 51 57 15 89 13 97 41 13 99 79 13 27 97 95 73 33 99 27 23",
"output": "1"
},
{
"input": "98\n61 56 44 30 58 14 20 24 88 28 46 56 96 52 58 42 94 50 46 30 46 80 72 88 68 16 6 60 26 90 10 98 76 20 56 40 30 16 96 20 88 32 62 30 74 58 36 76 60 4 24 36 42 54 24 92 28 14 2 74 86 90 14 52 34 82 40 76 8 64 2 56 10 8 78 16 70 86 70 42 70 74 22 18 76 98 88 28 62 70 36 72 20 68 34 48 80 98",
"output": "1"
},
{
"input": "98\n66 26 46 42 78 32 76 42 26 82 8 12 4 10 24 26 64 44 100 46 94 64 30 18 88 28 8 66 30 82 82 28 74 52 62 80 80 60 94 86 64 32 44 88 92 20 12 74 94 28 34 58 4 22 16 10 94 76 82 58 40 66 22 6 30 32 92 54 16 76 74 98 18 48 48 30 92 2 16 42 84 74 30 60 64 52 50 26 16 86 58 96 79 60 20 62 82 94",
"output": "93"
},
{
"input": "95\n9 31 27 93 17 77 75 9 9 53 89 39 51 99 5 1 11 39 27 49 91 17 27 79 81 71 37 75 35 13 93 4 99 55 85 11 23 57 5 43 5 61 15 35 23 91 3 81 99 85 43 37 39 27 5 67 7 33 75 59 13 71 51 27 15 93 51 63 91 53 43 99 25 47 17 71 81 15 53 31 59 83 41 23 73 25 91 91 13 17 25 13 55 57 29",
"output": "32"
},
{
"input": "100\n91 89 81 45 53 1 41 3 77 93 55 97 55 97 87 27 69 95 73 41 93 21 75 35 53 56 5 51 87 59 91 67 33 3 99 45 83 17 97 47 75 97 7 89 17 99 23 23 81 25 55 97 27 35 69 5 77 35 93 19 55 59 37 21 31 37 49 41 91 53 73 69 7 37 37 39 17 71 7 97 55 17 47 23 15 73 31 39 57 37 9 5 61 41 65 57 77 79 35 47",
"output": "26"
},
{
"input": "99\n38 56 58 98 80 54 26 90 14 16 78 92 52 74 40 30 84 14 44 80 16 90 98 68 26 24 78 72 42 16 84 40 14 44 2 52 50 2 12 96 58 66 8 80 44 52 34 34 72 98 74 4 66 74 56 21 8 38 76 40 10 22 48 32 98 34 12 62 80 68 64 82 22 78 58 74 20 22 48 56 12 38 32 72 6 16 74 24 94 84 26 38 18 24 76 78 98 94 72",
"output": "56"
},
{
"input": "100\n44 40 6 40 56 90 98 8 36 64 76 86 98 76 36 92 6 30 98 70 24 98 96 60 24 82 88 68 86 96 34 42 58 10 40 26 56 10 88 58 70 32 24 28 14 82 52 12 62 36 70 60 52 34 74 30 78 76 10 16 42 94 66 90 70 38 52 12 58 22 98 96 14 68 24 70 4 30 84 98 8 50 14 52 66 34 100 10 28 100 56 48 38 12 38 14 91 80 70 86",
"output": "97"
},
{
"input": "100\n96 62 64 20 90 46 56 90 68 36 30 56 70 28 16 64 94 34 6 32 34 50 94 22 90 32 40 2 72 10 88 38 28 92 20 26 56 80 4 100 100 90 16 74 74 84 8 2 30 20 80 32 16 46 92 56 42 12 96 64 64 42 64 58 50 42 74 28 2 4 36 32 70 50 54 92 70 16 45 76 28 16 18 50 48 2 62 94 4 12 52 52 4 100 70 60 82 62 98 42",
"output": "79"
},
{
"input": "99\n14 26 34 68 90 58 50 36 8 16 18 6 2 74 54 20 36 84 32 50 52 2 26 24 3 64 20 10 54 26 66 44 28 72 4 96 78 90 96 86 68 28 94 4 12 46 100 32 22 36 84 32 44 94 76 94 4 52 12 30 74 4 34 64 58 72 44 16 70 56 54 8 14 74 8 6 58 62 98 54 14 40 80 20 36 72 28 98 20 58 40 52 90 64 22 48 54 70 52",
"output": "25"
},
{
"input": "95\n82 86 30 78 6 46 80 66 74 72 16 24 18 52 52 38 60 36 86 26 62 28 22 46 96 26 94 84 20 46 66 88 76 32 12 86 74 18 34 88 4 48 94 6 58 6 100 82 4 24 88 32 54 98 34 48 6 76 42 88 42 28 100 4 22 2 10 66 82 54 98 20 60 66 38 98 32 47 86 58 6 100 12 46 2 42 8 84 78 28 24 70 34 28 86",
"output": "78"
},
{
"input": "90\n40 50 8 42 76 24 58 42 26 68 20 48 54 12 34 84 14 36 32 88 6 50 96 56 20 92 48 16 40 34 96 46 20 84 30 50 20 98 8 44 96 42 8 76 70 38 84 30 40 88 84 72 2 22 52 58 16 62 100 66 80 40 50 32 14 62 88 72 22 99 76 50 84 82 8 82 98 46 26 40 2 98 18 78 30 72 70 18 34 68",
"output": "70"
},
{
"input": "80\n81 43 87 1 55 43 53 61 27 19 43 13 89 9 33 83 75 55 97 71 91 37 95 5 21 69 81 93 95 69 31 83 55 7 97 7 79 57 8 61 27 85 49 1 15 97 63 79 29 73 41 85 5 41 31 93 67 11 63 59 15 99 91 77 43 69 23 23 81 73 19 1 67 51 1 75 99 67 3 81",
"output": "39"
},
{
"input": "98\n13 83 61 27 35 1 85 95 97 73 95 65 73 45 5 43 27 83 91 19 11 3 85 59 9 39 69 23 45 7 51 85 5 71 5 95 1 51 75 3 43 57 3 11 33 71 21 99 47 41 87 39 71 87 31 85 91 49 83 5 49 85 47 91 55 99 33 23 31 23 23 73 29 77 55 31 25 5 81 49 91 15 15 39 87 5 9 40 69 47 29 33 11 21 49 79 51 83",
"output": "88"
},
{
"input": "3\n100 100 1",
"output": "3"
}
] | 1,586,915,795
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 186
| 0
|
n=int(input())
a=[int(i) for i in input().split()]
for i in range(n):
if(a[i]%2!=0):
print(i+1)
break
|
Title: IQ test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that is different in evenness.
Input Specification:
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness.
Output Specification:
Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order.
Demo Input:
['5\n2 4 7 8 10\n', '4\n1 2 1 1\n']
Demo Output:
['3\n', '2\n']
Note:
none
|
```python
n=int(input())
a=[int(i) for i in input().split()]
for i in range(n):
if(a[i]%2!=0):
print(i+1)
break
```
| 0
|
427
|
A
|
Police Recruits
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
The police department of your city has just started its journey. Initially, they don’t have any manpower. So, they started hiring new recruits in groups.
Meanwhile, crimes keeps occurring within the city. One member of the police force can investigate only one crime during his/her lifetime.
If there is no police officer free (isn't busy with crime) during the occurrence of a crime, it will go untreated.
Given the chronological order of crime occurrences and recruit hirings, find the number of crimes which will go untreated.
|
The first line of input will contain an integer *n* (1<=≤<=*n*<=≤<=105), the number of events. The next line will contain *n* space-separated integers.
If the integer is -1 then it means a crime has occurred. Otherwise, the integer will be positive, the number of officers recruited together at that time. No more than 10 officers will be recruited at a time.
|
Print a single integer, the number of crimes which will go untreated.
|
[
"3\n-1 -1 1\n",
"8\n1 -1 1 -1 -1 1 1 1\n",
"11\n-1 -1 2 -1 -1 -1 -1 -1 -1 -1 -1\n"
] |
[
"2\n",
"1\n",
"8\n"
] |
Lets consider the second example:
1. Firstly one person is hired. 1. Then crime appears, the last hired person will investigate this crime. 1. One more person is hired. 1. One more crime appears, the last hired person will investigate this crime. 1. Crime appears. There is no free policeman at the time, so this crime will go untreated. 1. One more person is hired. 1. One more person is hired. 1. One more person is hired.
The answer is one, as one crime (on step 5) will go untreated.
| 500
|
[
{
"input": "3\n-1 -1 1",
"output": "2"
},
{
"input": "8\n1 -1 1 -1 -1 1 1 1",
"output": "1"
},
{
"input": "11\n-1 -1 2 -1 -1 -1 -1 -1 -1 -1 -1",
"output": "8"
},
{
"input": "7\n-1 -1 1 1 -1 -1 1",
"output": "2"
},
{
"input": "21\n-1 -1 -1 -1 -1 3 2 -1 6 -1 -1 2 1 -1 2 2 1 6 5 -1 5",
"output": "5"
},
{
"input": "98\n-1 -1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1 1 -1 1 1 1 -1 1 1 1 1 1 -1 1 -1 -1 -1 -1 1 -1 -1 1 1 -1 1 1 1 -1 -1 -1 -1 -1 -1 1 -1 -1 -1 1 -1 1 -1 1 -1 1 1 1 1 1 1 1 -1 -1 1 1 -1 -1 -1 -1 -1 -1 -1 -1 -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": "13"
},
{
"input": "3\n-1 5 4",
"output": "1"
},
{
"input": "146\n4 -1 -1 -1 -1 -1 -1 -1 -1 -1 4 -1 3 -1 3 -1 -1 1 4 -1 2 -1 -1 3 -1 -1 -1 4 1 -1 -1 -1 4 -1 -1 -1 -1 -1 -1 3 2 -1 3 2 4 5 2 4 1 5 -1 -1 2 -1 -1 1 -1 5 3 -1 1 2 2 3 5 3 -1 -1 3 -1 -1 3 5 5 -1 -1 5 -1 4 4 1 -1 -1 -1 2 1 -1 -1 -1 2 5 3 -1 -1 -1 3 -1 5 4 -1 1 -1 -1 3 -1 -1 3 1 1 2 -1 -1 -1 1 3 1 -1 2 -1 -1 5 5 -1 -1 3 4 5 1 -1 2 -1 -1 -1 3 -1 5 3 2 -1 2 -1 -1 5 -1 3 -1",
"output": "5"
},
{
"input": "1\n2",
"output": "0"
},
{
"input": "1\n-1",
"output": "1"
},
{
"input": "2\n1 -1",
"output": "0"
},
{
"input": "2\n-1 1",
"output": "1"
},
{
"input": "2\n1 1",
"output": "0"
},
{
"input": "2\n-1 -1",
"output": "2"
},
{
"input": "4\n10 -1 -1 -1",
"output": "0"
},
{
"input": "1\n1",
"output": "0"
},
{
"input": "4\n-1 -1 1 1",
"output": "2"
}
] | 1,684,616,254
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 30
| 0
|
n = int(input())
groups = 1
previous_polarity = input()
for _ in range(n - 1):
current_polarity = input()
if current_polarity != previous_polarity:
groups += 1
previous_polarity = current_polarity
print(groups)
|
Title: Police Recruits
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The police department of your city has just started its journey. Initially, they don’t have any manpower. So, they started hiring new recruits in groups.
Meanwhile, crimes keeps occurring within the city. One member of the police force can investigate only one crime during his/her lifetime.
If there is no police officer free (isn't busy with crime) during the occurrence of a crime, it will go untreated.
Given the chronological order of crime occurrences and recruit hirings, find the number of crimes which will go untreated.
Input Specification:
The first line of input will contain an integer *n* (1<=≤<=*n*<=≤<=105), the number of events. The next line will contain *n* space-separated integers.
If the integer is -1 then it means a crime has occurred. Otherwise, the integer will be positive, the number of officers recruited together at that time. No more than 10 officers will be recruited at a time.
Output Specification:
Print a single integer, the number of crimes which will go untreated.
Demo Input:
['3\n-1 -1 1\n', '8\n1 -1 1 -1 -1 1 1 1\n', '11\n-1 -1 2 -1 -1 -1 -1 -1 -1 -1 -1\n']
Demo Output:
['2\n', '1\n', '8\n']
Note:
Lets consider the second example:
1. Firstly one person is hired. 1. Then crime appears, the last hired person will investigate this crime. 1. One more person is hired. 1. One more crime appears, the last hired person will investigate this crime. 1. Crime appears. There is no free policeman at the time, so this crime will go untreated. 1. One more person is hired. 1. One more person is hired. 1. One more person is hired.
The answer is one, as one crime (on step 5) will go untreated.
|
```python
n = int(input())
groups = 1
previous_polarity = input()
for _ in range(n - 1):
current_polarity = input()
if current_polarity != previous_polarity:
groups += 1
previous_polarity = current_polarity
print(groups)
```
| -1
|
|
567
|
A
|
Lineland Mail
|
PROGRAMMING
| 900
|
[
"greedy",
"implementation"
] | null | null |
All cities of Lineland are located on the *Ox* coordinate axis. Thus, each city is associated with its position *x**i* — a coordinate on the *Ox* axis. No two cities are located at a single point.
Lineland residents love to send letters to each other. A person may send a letter only if the recipient lives in another city (because if they live in the same city, then it is easier to drop in).
Strange but true, the cost of sending the letter is exactly equal to the distance between the sender's city and the recipient's city.
For each city calculate two values *min**i* and *max**i*, where *min**i* is the minimum cost of sending a letter from the *i*-th city to some other city, and *max**i* is the the maximum cost of sending a letter from the *i*-th city to some other city
|
The first line of the input contains integer *n* (2<=≤<=*n*<=≤<=105) — the number of cities in Lineland. The second line contains the sequence of *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=109<=≤<=*x**i*<=≤<=109), where *x**i* is the *x*-coordinate of the *i*-th city. All the *x**i*'s are distinct and follow in ascending order.
|
Print *n* lines, the *i*-th line must contain two integers *min**i*,<=*max**i*, separated by a space, where *min**i* is the minimum cost of sending a letter from the *i*-th city, and *max**i* is the maximum cost of sending a letter from the *i*-th city.
|
[
"4\n-5 -2 2 7\n",
"2\n-1 1\n"
] |
[
"3 12\n3 9\n4 7\n5 12\n",
"2 2\n2 2\n"
] |
none
| 500
|
[
{
"input": "4\n-5 -2 2 7",
"output": "3 12\n3 9\n4 7\n5 12"
},
{
"input": "2\n-1 1",
"output": "2 2\n2 2"
},
{
"input": "3\n-1 0 1",
"output": "1 2\n1 1\n1 2"
},
{
"input": "4\n-1 0 1 3",
"output": "1 4\n1 3\n1 2\n2 4"
},
{
"input": "3\n-1000000000 0 1000000000",
"output": "1000000000 2000000000\n1000000000 1000000000\n1000000000 2000000000"
},
{
"input": "2\n-1000000000 1000000000",
"output": "2000000000 2000000000\n2000000000 2000000000"
},
{
"input": "10\n1 10 12 15 59 68 130 912 1239 9123",
"output": "9 9122\n2 9113\n2 9111\n3 9108\n9 9064\n9 9055\n62 8993\n327 8211\n327 7884\n7884 9122"
},
{
"input": "5\n-2 -1 0 1 2",
"output": "1 4\n1 3\n1 2\n1 3\n1 4"
},
{
"input": "5\n-2 -1 0 1 3",
"output": "1 5\n1 4\n1 3\n1 3\n2 5"
},
{
"input": "3\n-10000 1 10000",
"output": "10001 20000\n9999 10001\n9999 20000"
},
{
"input": "5\n-1000000000 -999999999 -999999998 -999999997 -999999996",
"output": "1 4\n1 3\n1 2\n1 3\n1 4"
},
{
"input": "10\n-857422304 -529223472 82412729 145077145 188538640 265299215 527377039 588634631 592896147 702473706",
"output": "328198832 1559896010\n328198832 1231697178\n62664416 939835033\n43461495 1002499449\n43461495 1045960944\n76760575 1122721519\n61257592 1384799343\n4261516 1446056935\n4261516 1450318451\n109577559 1559896010"
},
{
"input": "10\n-876779400 -829849659 -781819137 -570920213 18428128 25280705 121178189 219147240 528386329 923854124",
"output": "46929741 1800633524\n46929741 1753703783\n48030522 1705673261\n210898924 1494774337\n6852577 905425996\n6852577 902060105\n95897484 997957589\n97969051 1095926640\n309239089 1405165729\n395467795 1800633524"
},
{
"input": "30\n-15 1 21 25 30 40 59 60 77 81 97 100 103 123 139 141 157 158 173 183 200 215 226 231 244 256 267 279 289 292",
"output": "16 307\n16 291\n4 271\n4 267\n5 262\n10 252\n1 233\n1 232\n4 215\n4 211\n3 195\n3 192\n3 189\n16 169\n2 154\n2 156\n1 172\n1 173\n10 188\n10 198\n15 215\n11 230\n5 241\n5 246\n12 259\n11 271\n11 282\n10 294\n3 304\n3 307"
},
{
"input": "10\n-1000000000 -999999999 -999999997 -999999996 -999999995 -999999994 -999999992 -999999990 -999999988 -999999986",
"output": "1 14\n1 13\n1 11\n1 10\n1 9\n1 8\n2 8\n2 10\n2 12\n2 14"
},
{
"input": "50\n-50000 -49459 -48875 -48456 -48411 -48096 -47901 -47500 -47150 -46808 -46687 -46679 -46337 -45747 -45604 -45194 -44752 -44242 -44231 -44122 -43636 -43274 -42916 -42881 -42386 -42095 -41830 -41618 -41145 -40897 -40534 -40007 -39761 -39389 -39104 -38909 -38630 -38561 -38364 -38255 -38214 -38084 -37959 -37607 -37202 -36890 -36681 -36136 -36123 -35886",
"output": "541 14114\n541 13573\n419 12989\n45 12570\n45 12525\n195 12210\n195 12015\n350 11614\n342 11264\n121 10922\n8 10801\n8 10793\n342 10451\n143 9861\n143 9718\n410 9308\n442 8866\n11 8356\n11 8345\n109 8236\n362 7750\n358 7388\n35 7084\n35 7119\n291 7614\n265 7905\n212 8170\n212 8382\n248 8855\n248 9103\n363 9466\n246 9993\n246 10239\n285 10611\n195 10896\n195 11091\n69 11370\n69 11439\n109 11636\n41 11745\n41 11786\n125 11916\n125 12041\n352 12393\n312 12798\n209 13110\n209 13319\n13 13864\n13 13877\n237 141..."
},
{
"input": "3\n-1000000000 999999999 1000000000",
"output": "1999999999 2000000000\n1 1999999999\n1 2000000000"
}
] | 1,678,665,006
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 54
| 436
| 8,089,600
|
x=int(input());y=list(map(int,input().split()))
print(y[1]-y[0],y[-1]-y[0])
for i in range(1,x-1):
print(min(y[i]-y[i-1],y[i+1]-y[i]),max(y[-1]-y[i],y[i]-y[0]))
print(y[-1]-y[-2],y[-1]-y[0])
|
Title: Lineland Mail
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
All cities of Lineland are located on the *Ox* coordinate axis. Thus, each city is associated with its position *x**i* — a coordinate on the *Ox* axis. No two cities are located at a single point.
Lineland residents love to send letters to each other. A person may send a letter only if the recipient lives in another city (because if they live in the same city, then it is easier to drop in).
Strange but true, the cost of sending the letter is exactly equal to the distance between the sender's city and the recipient's city.
For each city calculate two values *min**i* and *max**i*, where *min**i* is the minimum cost of sending a letter from the *i*-th city to some other city, and *max**i* is the the maximum cost of sending a letter from the *i*-th city to some other city
Input Specification:
The first line of the input contains integer *n* (2<=≤<=*n*<=≤<=105) — the number of cities in Lineland. The second line contains the sequence of *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=109<=≤<=*x**i*<=≤<=109), where *x**i* is the *x*-coordinate of the *i*-th city. All the *x**i*'s are distinct and follow in ascending order.
Output Specification:
Print *n* lines, the *i*-th line must contain two integers *min**i*,<=*max**i*, separated by a space, where *min**i* is the minimum cost of sending a letter from the *i*-th city, and *max**i* is the maximum cost of sending a letter from the *i*-th city.
Demo Input:
['4\n-5 -2 2 7\n', '2\n-1 1\n']
Demo Output:
['3 12\n3 9\n4 7\n5 12\n', '2 2\n2 2\n']
Note:
none
|
```python
x=int(input());y=list(map(int,input().split()))
print(y[1]-y[0],y[-1]-y[0])
for i in range(1,x-1):
print(min(y[i]-y[i-1],y[i+1]-y[i]),max(y[-1]-y[i],y[i]-y[0]))
print(y[-1]-y[-2],y[-1]-y[0])
```
| 3
|
|
23
|
B
|
Party
|
PROGRAMMING
| 1,600
|
[
"constructive algorithms",
"graphs",
"math"
] |
B. Party
|
2
|
256
|
*n* people came to a party. Then those, who had no friends among people at the party, left. Then those, who had exactly 1 friend among those who stayed, left as well. Then those, who had exactly 2,<=3,<=...,<=*n*<=-<=1 friends among those who stayed by the moment of their leaving, did the same.
What is the maximum amount of people that could stay at the party in the end?
|
The first input line contains one number *t* — amount of tests (1<=≤<=*t*<=≤<=105). Each of the following *t* lines contains one integer number *n* (1<=≤<=*n*<=≤<=105).
|
For each test output in a separate line one number — the maximum amount of people that could stay in the end.
|
[
"1\n3\n"
] |
[
"1\n"
] |
none
| 0
|
[
{
"input": "1\n3",
"output": "1"
}
] | 1,697,123,010
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 2
| 1,900
| 8,089,600
|
t = int(input())
while(t>0):
t-=1
n= int(input())
print(max(0,n-2))
|
Title: Party
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
*n* people came to a party. Then those, who had no friends among people at the party, left. Then those, who had exactly 1 friend among those who stayed, left as well. Then those, who had exactly 2,<=3,<=...,<=*n*<=-<=1 friends among those who stayed by the moment of their leaving, did the same.
What is the maximum amount of people that could stay at the party in the end?
Input Specification:
The first input line contains one number *t* — amount of tests (1<=≤<=*t*<=≤<=105). Each of the following *t* lines contains one integer number *n* (1<=≤<=*n*<=≤<=105).
Output Specification:
For each test output in a separate line one number — the maximum amount of people that could stay in the end.
Demo Input:
['1\n3\n']
Demo Output:
['1\n']
Note:
none
|
```python
t = int(input())
while(t>0):
t-=1
n= int(input())
print(max(0,n-2))
```
| 3.509932
|
0
|
none
|
none
|
none
| 0
|
[
"none"
] | null | null |
You are given several queries. Each query consists of three integers $p$, $q$ and $b$. You need to answer whether the result of $p/q$ in notation with base $b$ is a finite fraction.
A fraction in notation with base $b$ is finite if it contains finite number of numerals after the decimal point. It is also possible that a fraction has zero numerals after the decimal point.
|
The first line contains a single integer $n$ ($1 \le n \le 10^5$) — the number of queries.
Next $n$ lines contain queries, one per line. Each line contains three integers $p$, $q$, and $b$ ($0 \le p \le 10^{18}$, $1 \le q \le 10^{18}$, $2 \le b \le 10^{18}$). All numbers are given in notation with base $10$.
|
For each question, in a separate line, print Finite if the fraction is finite and Infinite otherwise.
|
[
"2\n6 12 10\n4 3 10\n",
"4\n1 1 2\n9 36 2\n4 12 3\n3 5 4\n"
] |
[
"Finite\nInfinite\n",
"Finite\nFinite\nFinite\nInfinite\n"
] |
$\frac{6}{12} = \frac{1}{2} = 0,5_{10}$
$\frac{4}{3} = 1,(3)_{10}$
$\frac{9}{36} = \frac{1}{4} = 0,01_2$
$\frac{4}{12} = \frac{1}{3} = 0,1_3$
| 0
|
[
{
"input": "2\n6 12 10\n4 3 10",
"output": "Finite\nInfinite"
},
{
"input": "4\n1 1 2\n9 36 2\n4 12 3\n3 5 4",
"output": "Finite\nFinite\nFinite\nInfinite"
},
{
"input": "10\n10 5 3\n1 7 10\n7 5 7\n4 4 9\n6 5 2\n6 7 5\n9 9 7\n7 5 5\n6 6 4\n10 8 2",
"output": "Finite\nInfinite\nInfinite\nFinite\nInfinite\nInfinite\nFinite\nFinite\nFinite\nFinite"
},
{
"input": "10\n1 3 10\n6 2 6\n2 3 9\n7 8 4\n5 6 10\n1 2 7\n0 3 6\n9 3 4\n4 4 9\n10 9 10",
"output": "Infinite\nFinite\nFinite\nFinite\nInfinite\nInfinite\nFinite\nFinite\nFinite\nInfinite"
},
{
"input": "10\n10 8 5\n0 6 9\n0 7 6\n5 7 3\n7 6 8\n0 4 8\n2 6 3\n10 2 9\n6 7 9\n9 1 4",
"output": "Infinite\nFinite\nFinite\nInfinite\nInfinite\nFinite\nFinite\nFinite\nInfinite\nFinite"
},
{
"input": "10\n5 8 2\n0 5 8\n5 9 7\n0 7 2\n6 7 2\n10 3 7\n8 1 10\n9 1 8\n0 7 10\n9 1 4",
"output": "Finite\nFinite\nInfinite\nFinite\nInfinite\nInfinite\nFinite\nFinite\nFinite\nFinite"
},
{
"input": "1\n1 864691128455135232 2",
"output": "Infinite"
},
{
"input": "11\n1 1000000000000000000 10000000\n2 999 9\n2 999 333111\n0 9 7\n17 128 2\n13 311992186885373952 18\n1971402979058461 750473176484995605 75\n14 19 23\n3 21914624432020321 23\n3 21914624432020321 46\n3 21914624432020321 47",
"output": "Finite\nInfinite\nFinite\nFinite\nFinite\nFinite\nFinite\nInfinite\nFinite\nFinite\nInfinite"
},
{
"input": "1\n1 100000000000000000 10000000000000000",
"output": "Finite"
},
{
"input": "1\n1 4294967297 4294967296",
"output": "Infinite"
},
{
"input": "1\n1 5244319080000 30030",
"output": "Finite"
}
] | 1,566,914,099
| 3,299
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 8
| 1,000
| 0
|
from math import gcd
t = int(input())
for _ in range(t):
p, q, b = map(int, input().split())
g = gcd(p, q)
p = p//g
q = q//g
g = gcd(q, b)
while(g != 1):
q = q//g
g = gcd(q, b)
if(q <= 1):
break
if(q == 1):
print("Finite")
else:
print("Infinite")
|
Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given several queries. Each query consists of three integers $p$, $q$ and $b$. You need to answer whether the result of $p/q$ in notation with base $b$ is a finite fraction.
A fraction in notation with base $b$ is finite if it contains finite number of numerals after the decimal point. It is also possible that a fraction has zero numerals after the decimal point.
Input Specification:
The first line contains a single integer $n$ ($1 \le n \le 10^5$) — the number of queries.
Next $n$ lines contain queries, one per line. Each line contains three integers $p$, $q$, and $b$ ($0 \le p \le 10^{18}$, $1 \le q \le 10^{18}$, $2 \le b \le 10^{18}$). All numbers are given in notation with base $10$.
Output Specification:
For each question, in a separate line, print Finite if the fraction is finite and Infinite otherwise.
Demo Input:
['2\n6 12 10\n4 3 10\n', '4\n1 1 2\n9 36 2\n4 12 3\n3 5 4\n']
Demo Output:
['Finite\nInfinite\n', 'Finite\nFinite\nFinite\nInfinite\n']
Note:
$\frac{6}{12} = \frac{1}{2} = 0,5_{10}$
$\frac{4}{3} = 1,(3)_{10}$
$\frac{9}{36} = \frac{1}{4} = 0,01_2$
$\frac{4}{12} = \frac{1}{3} = 0,1_3$
|
```python
from math import gcd
t = int(input())
for _ in range(t):
p, q, b = map(int, input().split())
g = gcd(p, q)
p = p//g
q = q//g
g = gcd(q, b)
while(g != 1):
q = q//g
g = gcd(q, b)
if(q <= 1):
break
if(q == 1):
print("Finite")
else:
print("Infinite")
```
| 0
|
|
810
|
A
|
Straight <<A>>
|
PROGRAMMING
| 900
|
[
"implementation",
"math"
] | null | null |
Noora is a student of one famous high school. It's her final year in school — she is going to study in university next year. However, she has to get an «A» graduation certificate in order to apply to a prestigious one.
In school, where Noora is studying, teachers are putting down marks to the online class register, which are integers from 1 to *k*. The worst mark is 1, the best is *k*. Mark that is going to the certificate, is calculated as an average of all the marks, rounded to the closest integer. If several answers are possible, rounding up is produced. For example, 7.3 is rounded to 7, but 7.5 and 7.8784 — to 8.
For instance, if Noora has marks [8,<=9], then the mark to the certificate is 9, because the average is equal to 8.5 and rounded to 9, but if the marks are [8,<=8,<=9], Noora will have graduation certificate with 8.
To graduate with «A» certificate, Noora has to have mark *k*.
Noora got *n* marks in register this year. However, she is afraid that her marks are not enough to get final mark *k*. Noora decided to ask for help in the internet, where hacker Leha immediately responded to her request. He is ready to hack class register for Noora and to add Noora any number of additional marks from 1 to *k*. At the same time, Leha want his hack be unseen to everyone, so he decided to add as less as possible additional marks. Please help Leha to calculate the minimal number of marks he has to add, so that final Noora's mark will become equal to *k*.
|
The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*k*<=≤<=100) denoting the number of marks, received by Noora and the value of highest possible mark.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=*k*) denoting marks received by Noora before Leha's hack.
|
Print a single integer — minimal number of additional marks, that Leha has to add in order to change Noora's final mark to *k*.
|
[
"2 10\n8 9\n",
"3 5\n4 4 4\n"
] |
[
"4",
"3"
] |
Consider the first example testcase.
Maximal mark is 10, Noora received two marks — 8 and 9, so current final mark is 9. To fix it, Leha can add marks [10, 10, 10, 10] (4 marks in total) to the registry, achieving Noora having average mark equal to <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/1b961585522f76271546da990a6228e7c666277f.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Consequently, new final mark is 10. Less number of marks won't fix the situation.
In the second example Leha can add [5, 5, 5] to the registry, so that making average mark equal to 4.5, which is enough to have 5 in the certificate.
| 500
|
[
{
"input": "2 10\n8 9",
"output": "4"
},
{
"input": "3 5\n4 4 4",
"output": "3"
},
{
"input": "3 10\n10 8 9",
"output": "3"
},
{
"input": "2 23\n21 23",
"output": "2"
},
{
"input": "5 10\n5 10 10 9 10",
"output": "7"
},
{
"input": "12 50\n18 10 26 22 22 23 14 21 27 18 25 12",
"output": "712"
},
{
"input": "38 12\n2 7 10 8 5 3 5 6 3 6 5 1 9 7 7 8 3 4 4 4 5 2 3 6 6 1 6 7 4 4 8 7 4 5 3 6 6 6",
"output": "482"
},
{
"input": "63 86\n32 31 36 29 36 26 28 38 39 32 29 26 33 38 36 38 36 28 43 48 28 33 25 39 39 27 34 25 37 28 40 26 30 31 42 32 36 44 29 36 30 35 48 40 26 34 30 33 33 46 42 24 36 38 33 51 33 41 38 29 29 32 28",
"output": "6469"
},
{
"input": "100 38\n30 24 38 31 31 33 32 32 29 34 29 22 27 23 34 25 32 30 30 26 16 27 38 33 38 38 37 34 32 27 33 23 33 32 24 24 30 36 29 30 33 30 29 30 36 33 33 35 28 24 30 32 38 29 30 36 31 30 27 38 31 36 15 37 32 27 29 24 38 33 28 29 34 21 37 35 32 31 27 25 27 28 31 31 36 38 35 35 36 29 35 22 38 31 38 28 31 27 34 31",
"output": "1340"
},
{
"input": "33 69\n60 69 68 69 69 60 64 60 62 59 54 47 60 62 69 69 69 58 67 69 62 69 68 53 69 69 66 66 57 58 65 69 61",
"output": "329"
},
{
"input": "39 92\n19 17 16 19 15 30 21 25 14 17 19 19 23 16 14 15 17 19 29 15 11 25 19 14 18 20 10 16 11 15 18 20 20 17 18 16 12 17 16",
"output": "5753"
},
{
"input": "68 29\n29 29 29 29 29 28 29 29 29 27 29 29 29 29 29 29 29 23 29 29 26 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 26 29 29 29 29 29 29 29 29 29 29 29 29 22 29 29 29 29 29 29 29 29 29 29 29 29 29 28 29 29 29 29",
"output": "0"
},
{
"input": "75 30\n22 18 21 26 23 18 28 30 24 24 19 25 28 30 23 29 18 23 23 30 26 30 17 30 18 19 25 26 26 15 27 23 30 21 19 26 25 30 25 28 20 22 22 21 26 17 23 23 24 15 25 19 18 22 30 30 29 21 30 28 28 30 27 25 24 15 22 19 30 21 20 30 18 20 25",
"output": "851"
},
{
"input": "78 43\n2 7 6 5 5 6 4 5 3 4 6 8 4 5 5 4 3 1 2 4 4 6 5 6 4 4 6 4 8 4 6 5 6 1 4 5 6 3 2 5 2 5 3 4 8 8 3 3 4 4 6 6 5 4 5 5 7 9 3 9 6 4 7 3 6 9 6 5 1 7 2 5 6 3 6 2 5 4",
"output": "5884"
},
{
"input": "82 88\n1 1 1 1 1 1 1 1 1 1 1 1 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 2 2 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 1 2 1 1 1 1 1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1",
"output": "14170"
},
{
"input": "84 77\n28 26 36 38 37 44 48 34 40 22 42 35 40 37 30 31 33 35 36 55 47 36 33 47 40 38 27 38 36 33 35 31 47 33 30 38 38 47 49 24 38 37 28 43 39 36 34 33 29 38 36 43 48 38 36 34 33 34 35 31 26 33 39 37 37 37 35 52 47 30 24 46 38 26 43 46 41 50 33 40 36 41 37 30",
"output": "6650"
},
{
"input": "94 80\n21 19 15 16 27 16 20 18 19 19 15 15 20 19 19 21 20 19 13 17 15 9 17 15 23 15 12 18 12 13 15 12 14 13 14 17 20 20 14 21 15 6 10 23 24 8 18 18 13 23 17 22 17 19 19 18 17 24 8 16 18 20 24 19 10 19 15 10 13 14 19 15 16 19 20 15 14 21 16 16 14 14 22 19 12 11 14 13 19 32 16 16 13 20",
"output": "11786"
},
{
"input": "96 41\n13 32 27 34 28 34 30 26 21 24 29 20 25 34 25 16 27 15 22 22 34 22 25 19 23 17 17 22 26 24 23 20 21 27 19 33 13 24 22 18 30 30 27 14 26 24 20 20 22 11 19 31 19 29 18 28 30 22 17 15 28 32 17 24 17 24 24 19 26 23 22 29 18 22 23 29 19 32 26 23 22 22 24 23 27 30 24 25 21 21 33 19 35 27 34 28",
"output": "3182"
},
{
"input": "1 26\n26",
"output": "0"
},
{
"input": "99 39\n25 28 30 28 32 34 31 28 29 28 29 30 33 19 33 31 27 33 29 24 27 30 25 38 28 34 35 31 34 37 30 22 21 24 34 27 34 33 34 33 26 26 36 19 30 22 35 30 21 28 23 35 33 29 21 22 36 31 34 32 34 32 30 32 27 33 38 25 35 26 39 27 29 29 19 33 28 29 34 38 26 30 36 26 29 30 26 34 22 32 29 38 25 27 24 17 25 28 26",
"output": "1807"
},
{
"input": "100 12\n7 6 6 3 5 5 9 8 7 7 4 7 12 6 9 5 6 3 4 7 9 10 7 7 5 3 9 6 9 9 6 7 4 10 4 8 8 6 9 8 6 5 7 4 10 7 5 6 8 9 3 4 8 5 4 8 6 10 5 8 7 5 9 8 5 8 5 6 9 11 4 9 5 5 11 4 6 6 7 3 8 9 6 7 10 4 7 6 9 4 8 11 5 4 10 8 5 10 11 4",
"output": "946"
},
{
"input": "100 18\n1 2 2 2 2 2 1 1 1 2 3 1 3 1 1 4 2 4 1 2 1 2 1 3 2 1 2 1 1 1 2 1 2 2 1 1 4 3 1 1 2 1 3 3 2 1 2 2 1 1 1 1 3 1 1 2 2 1 1 1 5 1 2 1 3 2 2 1 4 2 2 1 1 1 1 1 1 1 1 2 2 1 2 1 1 1 2 1 2 2 2 1 1 3 1 1 2 1 1 2",
"output": "3164"
},
{
"input": "100 27\n16 20 21 10 16 17 18 25 19 18 20 12 11 21 21 23 20 26 20 21 27 16 25 18 25 21 27 12 20 27 18 17 27 13 21 26 12 22 15 21 25 21 18 27 24 15 16 18 23 21 24 27 19 17 24 14 21 16 24 26 13 14 25 18 27 26 22 16 27 27 17 25 17 12 22 10 19 27 19 20 23 22 25 23 17 25 14 20 22 10 22 27 21 20 15 26 24 27 12 16",
"output": "1262"
},
{
"input": "100 29\n20 18 23 24 14 14 16 23 22 17 18 22 21 21 19 19 14 11 18 19 16 22 25 20 14 13 21 24 18 16 18 29 17 25 12 10 18 28 11 16 17 14 15 20 17 20 18 22 10 16 16 20 18 19 29 18 25 27 17 19 24 15 24 25 16 23 19 16 16 20 19 15 12 21 20 13 21 15 15 23 16 23 17 13 17 21 13 18 17 18 18 20 16 12 19 15 27 14 11 18",
"output": "2024"
},
{
"input": "100 30\n16 10 20 11 14 27 15 17 22 26 24 17 15 18 19 22 22 15 21 22 14 21 22 22 21 22 15 17 17 22 18 19 26 18 22 20 22 25 18 18 17 23 18 18 20 13 19 30 17 24 22 19 29 20 20 21 17 18 26 25 22 19 15 18 18 20 19 19 18 18 24 16 19 17 12 21 20 16 23 21 16 17 26 23 25 28 22 20 9 21 17 24 15 19 17 21 29 13 18 15",
"output": "1984"
},
{
"input": "100 59\n56 58 53 59 59 48 59 54 46 59 59 58 48 59 55 59 59 50 59 56 59 59 59 59 59 59 59 57 59 53 45 53 50 59 50 55 58 54 59 56 54 59 59 59 59 48 56 59 59 57 59 59 48 43 55 57 39 59 46 55 55 52 58 57 51 59 59 59 59 53 59 43 51 54 46 59 57 43 50 59 47 58 59 59 59 55 46 56 55 59 56 47 56 56 46 51 47 48 59 55",
"output": "740"
},
{
"input": "100 81\n6 7 6 6 7 6 6 6 3 9 4 5 4 3 4 6 6 6 1 3 9 5 2 3 8 5 6 9 6 6 6 5 4 4 7 7 3 6 11 7 6 4 8 7 12 6 4 10 2 4 9 11 7 4 7 7 8 8 6 7 9 8 4 5 8 13 6 6 6 8 6 2 5 6 7 5 4 4 4 4 2 6 4 8 3 4 7 7 6 7 7 10 5 10 6 7 4 11 8 4",
"output": "14888"
},
{
"input": "100 100\n30 35 23 43 28 49 31 32 30 44 32 37 33 34 38 28 43 32 33 32 50 32 41 38 33 20 40 36 29 21 42 25 23 34 43 32 37 31 30 27 36 32 45 37 33 29 38 34 35 33 28 19 37 33 28 41 31 29 41 27 32 39 30 34 37 40 33 38 35 32 32 34 35 34 28 39 28 34 40 45 31 25 42 28 29 31 33 21 36 33 34 37 40 42 39 30 36 34 34 40",
"output": "13118"
},
{
"input": "100 100\n71 87 100 85 89 98 90 90 71 65 76 75 85 100 81 100 91 80 73 89 86 78 82 89 77 92 78 90 100 81 85 89 73 100 66 60 72 88 91 73 93 76 88 81 86 78 83 77 74 93 97 94 85 78 82 78 91 91 100 78 89 76 78 82 81 78 83 88 87 83 78 98 85 97 98 89 88 75 76 86 74 81 70 76 86 84 99 100 89 94 72 84 82 88 83 89 78 99 87 76",
"output": "3030"
},
{
"input": "100 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": "19700"
},
{
"input": "100 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": "0"
},
{
"input": "100 100\n1 1 2 1 1 1 1 1 1 1 1 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",
"output": "19696"
},
{
"input": "100 100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 99",
"output": "0"
},
{
"input": "100 100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 98 100 100 100 100 98 100 100 100 100 100 100 99 98 100 100 93 100 100 98 100 100 100 100 93 100 96 100 100 100 94 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 95 88 100 100 100 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"
},
{
"input": "100 100\n95 100 100 100 100 100 100 100 100 100 100 100 100 100 87 100 100 100 94 100 100 100 100 100 100 100 100 100 100 100 100 99 100 100 100 100 100 100 100 100 100 100 90 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 97 100 100 100 96 100 98 100 100 100 100 100 96 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 97 100 100 100 100",
"output": "2"
},
{
"input": "100 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "100 2\n2 1 1 2 1 1 1 1 2 2 2 2 1 1 1 2 1 1 1 2 2 2 2 1 1 1 1 2 2 2 1 2 2 2 2 1 2 2 1 1 1 1 1 1 2 2 1 2 1 1 1 2 1 2 2 2 2 1 1 1 2 2 1 2 1 1 1 2 1 2 2 1 1 1 2 2 1 1 2 1 1 2 1 1 1 2 1 1 1 1 2 1 1 1 1 2 1 2 1 1",
"output": "16"
},
{
"input": "3 5\n5 5 5",
"output": "0"
},
{
"input": "7 7\n1 1 1 1 1 1 1",
"output": "77"
},
{
"input": "1 1\n1",
"output": "0"
},
{
"input": "100 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": "19700"
},
{
"input": "4 10\n10 10 10 10",
"output": "0"
},
{
"input": "1 10\n10",
"output": "0"
},
{
"input": "10 1\n1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "3 10\n10 10 10",
"output": "0"
},
{
"input": "2 4\n3 4",
"output": "0"
},
{
"input": "1 2\n2",
"output": "0"
},
{
"input": "3 4\n4 4 4",
"output": "0"
},
{
"input": "3 2\n2 2 1",
"output": "0"
},
{
"input": "5 5\n5 5 5 5 5",
"output": "0"
},
{
"input": "3 3\n3 3 3",
"output": "0"
},
{
"input": "2 9\n8 9",
"output": "0"
},
{
"input": "3 10\n9 10 10",
"output": "0"
},
{
"input": "1 3\n3",
"output": "0"
},
{
"input": "2 2\n1 2",
"output": "0"
},
{
"input": "2 10\n10 10",
"output": "0"
},
{
"input": "23 14\n7 11 13 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14",
"output": "0"
},
{
"input": "2 10\n9 10",
"output": "0"
},
{
"input": "2 2\n2 2",
"output": "0"
},
{
"input": "10 5\n5 5 5 5 5 5 5 5 5 4",
"output": "0"
},
{
"input": "3 5\n4 5 5",
"output": "0"
},
{
"input": "5 4\n4 4 4 4 4",
"output": "0"
},
{
"input": "2 10\n10 9",
"output": "0"
},
{
"input": "4 5\n3 5 5 5",
"output": "0"
},
{
"input": "10 5\n5 5 5 5 5 5 5 5 5 5",
"output": "0"
},
{
"input": "3 10\n10 10 9",
"output": "0"
},
{
"input": "5 1\n1 1 1 1 1",
"output": "0"
},
{
"input": "2 1\n1 1",
"output": "0"
},
{
"input": "4 10\n9 10 10 10",
"output": "0"
},
{
"input": "5 2\n2 2 2 2 2",
"output": "0"
},
{
"input": "2 5\n4 5",
"output": "0"
},
{
"input": "5 10\n10 10 10 10 10",
"output": "0"
},
{
"input": "2 6\n6 6",
"output": "0"
},
{
"input": "2 9\n9 9",
"output": "0"
},
{
"input": "3 10\n10 9 10",
"output": "0"
},
{
"input": "4 40\n39 40 40 40",
"output": "0"
},
{
"input": "3 4\n3 4 4",
"output": "0"
},
{
"input": "9 9\n9 9 9 9 9 9 9 9 9",
"output": "0"
},
{
"input": "1 4\n4",
"output": "0"
},
{
"input": "4 7\n1 1 1 1",
"output": "44"
},
{
"input": "1 5\n5",
"output": "0"
},
{
"input": "3 1\n1 1 1",
"output": "0"
},
{
"input": "1 100\n100",
"output": "0"
},
{
"input": "2 7\n3 5",
"output": "10"
},
{
"input": "3 6\n6 6 6",
"output": "0"
},
{
"input": "4 2\n1 2 2 2",
"output": "0"
},
{
"input": "4 5\n4 5 5 5",
"output": "0"
},
{
"input": "5 5\n1 1 1 1 1",
"output": "35"
},
{
"input": "66 2\n1 2 2 2 2 1 1 2 1 2 2 2 2 2 2 1 2 1 2 1 2 1 2 1 2 1 1 1 1 2 2 1 2 2 1 1 2 1 2 2 1 1 1 2 1 2 1 2 1 2 1 2 2 2 2 1 2 2 1 2 1 1 1 2 2 1",
"output": "0"
},
{
"input": "2 2\n2 1",
"output": "0"
},
{
"input": "5 5\n5 5 5 4 5",
"output": "0"
},
{
"input": "3 7\n1 1 1",
"output": "33"
},
{
"input": "2 5\n5 5",
"output": "0"
},
{
"input": "1 7\n1",
"output": "11"
},
{
"input": "6 7\n1 1 1 1 1 1",
"output": "66"
},
{
"input": "99 97\n15 80 78 69 12 84 36 51 89 77 88 10 1 19 67 85 6 36 8 70 14 45 88 97 22 13 75 57 83 27 13 97 9 90 68 51 76 37 5 2 16 92 11 48 13 77 35 19 15 74 22 29 21 12 28 42 56 5 32 41 62 75 71 71 68 72 24 77 11 28 78 27 53 88 74 66 1 42 18 16 18 39 75 38 81 5 13 39 40 75 13 36 53 83 9 54 57 63 64",
"output": "10077"
},
{
"input": "8 7\n1 1 1 1 1 1 1 1",
"output": "88"
},
{
"input": "3 2\n2 2 2",
"output": "0"
},
{
"input": "6 5\n5 5 5 5 5 5",
"output": "0"
},
{
"input": "10 5\n5 5 5 5 5 5 5 4 1 1",
"output": "8"
},
{
"input": "1 5\n1",
"output": "7"
},
{
"input": "10 10\n10 10 10 10 10 10 10 10 10 10",
"output": "0"
},
{
"input": "2 3\n2 3",
"output": "0"
},
{
"input": "1 9\n9",
"output": "0"
},
{
"input": "74 2\n2 2 2 2 1 2 2 1 1 1 2 2 1 2 2 2 2 1 2 1 1 1 2 1 1 2 2 1 2 1 1 2 1 1 2 2 2 2 2 2 2 2 1 2 2 2 1 2 2 1 1 2 1 1 1 1 1 1 2 2 2 1 1 1 1 1 2 2 2 2 2 2 1 2",
"output": "0"
},
{
"input": "5 5\n5 5 5 5 4",
"output": "0"
}
] | 1,506,185,133
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 106
| 62
| 0
|
n,k=map(int,input().split(' '))
m=list(map(int,input().split(' ')))
print(max(int((n*k-sum(m))*2-n),0))
|
Title: Straight <<A>>
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Noora is a student of one famous high school. It's her final year in school — she is going to study in university next year. However, she has to get an «A» graduation certificate in order to apply to a prestigious one.
In school, where Noora is studying, teachers are putting down marks to the online class register, which are integers from 1 to *k*. The worst mark is 1, the best is *k*. Mark that is going to the certificate, is calculated as an average of all the marks, rounded to the closest integer. If several answers are possible, rounding up is produced. For example, 7.3 is rounded to 7, but 7.5 and 7.8784 — to 8.
For instance, if Noora has marks [8,<=9], then the mark to the certificate is 9, because the average is equal to 8.5 and rounded to 9, but if the marks are [8,<=8,<=9], Noora will have graduation certificate with 8.
To graduate with «A» certificate, Noora has to have mark *k*.
Noora got *n* marks in register this year. However, she is afraid that her marks are not enough to get final mark *k*. Noora decided to ask for help in the internet, where hacker Leha immediately responded to her request. He is ready to hack class register for Noora and to add Noora any number of additional marks from 1 to *k*. At the same time, Leha want his hack be unseen to everyone, so he decided to add as less as possible additional marks. Please help Leha to calculate the minimal number of marks he has to add, so that final Noora's mark will become equal to *k*.
Input Specification:
The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*k*<=≤<=100) denoting the number of marks, received by Noora and the value of highest possible mark.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=*k*) denoting marks received by Noora before Leha's hack.
Output Specification:
Print a single integer — minimal number of additional marks, that Leha has to add in order to change Noora's final mark to *k*.
Demo Input:
['2 10\n8 9\n', '3 5\n4 4 4\n']
Demo Output:
['4', '3']
Note:
Consider the first example testcase.
Maximal mark is 10, Noora received two marks — 8 and 9, so current final mark is 9. To fix it, Leha can add marks [10, 10, 10, 10] (4 marks in total) to the registry, achieving Noora having average mark equal to <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/1b961585522f76271546da990a6228e7c666277f.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Consequently, new final mark is 10. Less number of marks won't fix the situation.
In the second example Leha can add [5, 5, 5] to the registry, so that making average mark equal to 4.5, which is enough to have 5 in the certificate.
|
```python
n,k=map(int,input().split(' '))
m=list(map(int,input().split(' ')))
print(max(int((n*k-sum(m))*2-n),0))
```
| 3
|
|
4
|
A
|
Watermelon
|
PROGRAMMING
| 800
|
[
"brute force",
"math"
] |
A. Watermelon
|
1
|
64
|
One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem.
Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight.
|
The first (and the only) input line contains integer number *w* (1<=≤<=*w*<=≤<=100) — the weight of the watermelon bought by the boys.
|
Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.
|
[
"8\n"
] |
[
"YES\n"
] |
For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).
| 0
|
[
{
"input": "8",
"output": "YES"
},
{
"input": "5",
"output": "NO"
},
{
"input": "4",
"output": "YES"
},
{
"input": "3",
"output": "NO"
},
{
"input": "2",
"output": "NO"
},
{
"input": "1",
"output": "NO"
},
{
"input": "7",
"output": "NO"
},
{
"input": "6",
"output": "YES"
},
{
"input": "10",
"output": "YES"
},
{
"input": "9",
"output": "NO"
},
{
"input": "53",
"output": "NO"
},
{
"input": "77",
"output": "NO"
},
{
"input": "32",
"output": "YES"
},
{
"input": "44",
"output": "YES"
},
{
"input": "98",
"output": "YES"
},
{
"input": "99",
"output": "NO"
},
{
"input": "90",
"output": "YES"
},
{
"input": "67",
"output": "NO"
},
{
"input": "100",
"output": "YES"
},
{
"input": "88",
"output": "YES"
}
] | 1,691,061,041
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 30
| 0
|
w = int(input("Enter the weight of watermelon with range 1 to 100: \n "))
if (w%2 == 1 or w == 2):
print("No")
else:
print("Yes")
|
Title: Watermelon
Time Limit: 1 seconds
Memory Limit: 64 megabytes
Problem Description:
One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem.
Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight.
Input Specification:
The first (and the only) input line contains integer number *w* (1<=≤<=*w*<=≤<=100) — the weight of the watermelon bought by the boys.
Output Specification:
Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.
Demo Input:
['8\n']
Demo Output:
['YES\n']
Note:
For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).
|
```python
w = int(input("Enter the weight of watermelon with range 1 to 100: \n "))
if (w%2 == 1 or w == 2):
print("No")
else:
print("Yes")
```
| 0
|
707
|
C
|
Pythagorean Triples
|
PROGRAMMING
| 1,500
|
[
"math",
"number theory"
] | null | null |
Katya studies in a fifth grade. Recently her class studied right triangles and the Pythagorean theorem. It appeared, that there are triples of positive integers such that you can construct a right triangle with segments of lengths corresponding to triple. Such triples are called Pythagorean triples.
For example, triples (3,<=4,<=5), (5,<=12,<=13) and (6,<=8,<=10) are Pythagorean triples.
Here Katya wondered if she can specify the length of some side of right triangle and find any Pythagorean triple corresponding to such length? Note that the side which length is specified can be a cathetus as well as hypotenuse.
Katya had no problems with completing this task. Will you do the same?
|
The only line of the input contains single integer *n* (1<=≤<=*n*<=≤<=109) — the length of some side of a right triangle.
|
Print two integers *m* and *k* (1<=≤<=*m*,<=*k*<=≤<=1018), such that *n*, *m* and *k* form a Pythagorean triple, in the only line.
In case if there is no any Pythagorean triple containing integer *n*, print <=-<=1 in the only line. If there are many answers, print any of them.
|
[
"3\n",
"6\n",
"1\n",
"17\n",
"67\n"
] |
[
"4 5",
"8 10",
"-1",
"144 145",
"2244 2245"
] |
Illustration for the first sample.
| 1,500
|
[
{
"input": "3",
"output": "4 5"
},
{
"input": "6",
"output": "8 10"
},
{
"input": "1",
"output": "-1"
},
{
"input": "17",
"output": "144 145"
},
{
"input": "67",
"output": "2244 2245"
},
{
"input": "10",
"output": "24 26"
},
{
"input": "14",
"output": "48 50"
},
{
"input": "22",
"output": "120 122"
},
{
"input": "23",
"output": "264 265"
},
{
"input": "246",
"output": "15128 15130"
},
{
"input": "902",
"output": "203400 203402"
},
{
"input": "1000000000",
"output": "1250000000 750000000"
},
{
"input": "1998",
"output": "998000 998002"
},
{
"input": "2222222",
"output": "1234567654320 1234567654322"
},
{
"input": "2222226",
"output": "1234572098768 1234572098770"
},
{
"input": "1111110",
"output": "308641358024 308641358026"
},
{
"input": "9999998",
"output": "24999990000000 24999990000002"
},
{
"input": "1024",
"output": "1280 768"
},
{
"input": "8388608",
"output": "10485760 6291456"
},
{
"input": "4",
"output": "5 3"
},
{
"input": "8",
"output": "10 6"
},
{
"input": "16",
"output": "20 12"
},
{
"input": "492",
"output": "615 369"
},
{
"input": "493824",
"output": "617280 370368"
},
{
"input": "493804",
"output": "617255 370353"
},
{
"input": "493800",
"output": "617250 370350"
},
{
"input": "2048",
"output": "2560 1536"
},
{
"input": "8388612",
"output": "10485765 6291459"
},
{
"input": "44",
"output": "55 33"
},
{
"input": "444",
"output": "555 333"
},
{
"input": "4444",
"output": "5555 3333"
},
{
"input": "44444",
"output": "55555 33333"
},
{
"input": "444444",
"output": "555555 333333"
},
{
"input": "4444444",
"output": "5555555 3333333"
},
{
"input": "100000000",
"output": "125000000 75000000"
},
{
"input": "2",
"output": "-1"
},
{
"input": "3",
"output": "4 5"
},
{
"input": "5",
"output": "12 13"
},
{
"input": "7",
"output": "24 25"
},
{
"input": "9",
"output": "40 41"
},
{
"input": "11",
"output": "60 61"
},
{
"input": "13",
"output": "84 85"
},
{
"input": "15",
"output": "112 113"
},
{
"input": "19",
"output": "180 181"
},
{
"input": "111",
"output": "6160 6161"
},
{
"input": "113",
"output": "6384 6385"
},
{
"input": "115",
"output": "6612 6613"
},
{
"input": "117",
"output": "6844 6845"
},
{
"input": "119",
"output": "7080 7081"
},
{
"input": "111111",
"output": "6172827160 6172827161"
},
{
"input": "111113",
"output": "6173049384 6173049385"
},
{
"input": "111115",
"output": "6173271612 6173271613"
},
{
"input": "111117",
"output": "6173493844 6173493845"
},
{
"input": "111119",
"output": "6173716080 6173716081"
},
{
"input": "9999993",
"output": "49999930000024 49999930000025"
},
{
"input": "9999979",
"output": "49999790000220 49999790000221"
},
{
"input": "9999990",
"output": "24999950000024 24999950000026"
},
{
"input": "9999991",
"output": "49999910000040 49999910000041"
},
{
"input": "9999992",
"output": "12499990 7499994"
},
{
"input": "9999973",
"output": "49999730000364 49999730000365"
},
{
"input": "9999994",
"output": "24999970000008 24999970000010"
},
{
"input": "9999995",
"output": "49999950000012 49999950000013"
},
{
"input": "9999996",
"output": "12499995 7499997"
},
{
"input": "9999997",
"output": "49999970000004 49999970000005"
},
{
"input": "9999978",
"output": "24999890000120 24999890000122"
},
{
"input": "99999993",
"output": "4999999300000024 4999999300000025"
},
{
"input": "99999979",
"output": "4999997900000220 4999997900000221"
},
{
"input": "99999990",
"output": "2499999500000024 2499999500000026"
},
{
"input": "99999991",
"output": "4999999100000040 4999999100000041"
},
{
"input": "99999992",
"output": "124999990 74999994"
},
{
"input": "99999973",
"output": "4999997300000364 4999997300000365"
},
{
"input": "99999994",
"output": "2499999700000008 2499999700000010"
},
{
"input": "99999995",
"output": "4999999500000012 4999999500000013"
},
{
"input": "99999996",
"output": "124999995 74999997"
},
{
"input": "99999997",
"output": "4999999700000004 4999999700000005"
},
{
"input": "99999978",
"output": "2499998900000120 2499998900000122"
},
{
"input": "987654323",
"output": "487730530870294164 487730530870294165"
},
{
"input": "2",
"output": "-1"
},
{
"input": "4",
"output": "5 3"
},
{
"input": "8",
"output": "10 6"
},
{
"input": "64",
"output": "80 48"
},
{
"input": "999999999",
"output": "499999999000000000 499999999000000001"
},
{
"input": "16",
"output": "20 12"
},
{
"input": "999999937",
"output": "499999937000001984 499999937000001985"
},
{
"input": "999999998",
"output": "249999999000000000 249999999000000002"
},
{
"input": "433494437",
"output": "93958713454973484 93958713454973485"
},
{
"input": "484916147",
"output": "117571834810662804 117571834810662805"
},
{
"input": "999999929",
"output": "499999929000002520 499999929000002521"
},
{
"input": "982451653",
"output": "482605625241216204 482605625241216205"
},
{
"input": "2048",
"output": "2560 1536"
}
] | 1,661,415,890
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 90
| 62
| 0
|
import sys
input = sys.stdin.readline
n = int(input())
x = n * n
if x % 2:
a = (x+1)//2
b = a-1
else:
a = (x+4)//4
b = a-2
if n in [2, 1]:
print(-1)
exit(0)
print(b, a)
|
Title: Pythagorean Triples
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Katya studies in a fifth grade. Recently her class studied right triangles and the Pythagorean theorem. It appeared, that there are triples of positive integers such that you can construct a right triangle with segments of lengths corresponding to triple. Such triples are called Pythagorean triples.
For example, triples (3,<=4,<=5), (5,<=12,<=13) and (6,<=8,<=10) are Pythagorean triples.
Here Katya wondered if she can specify the length of some side of right triangle and find any Pythagorean triple corresponding to such length? Note that the side which length is specified can be a cathetus as well as hypotenuse.
Katya had no problems with completing this task. Will you do the same?
Input Specification:
The only line of the input contains single integer *n* (1<=≤<=*n*<=≤<=109) — the length of some side of a right triangle.
Output Specification:
Print two integers *m* and *k* (1<=≤<=*m*,<=*k*<=≤<=1018), such that *n*, *m* and *k* form a Pythagorean triple, in the only line.
In case if there is no any Pythagorean triple containing integer *n*, print <=-<=1 in the only line. If there are many answers, print any of them.
Demo Input:
['3\n', '6\n', '1\n', '17\n', '67\n']
Demo Output:
['4 5', '8 10', '-1', '144 145', '2244 2245']
Note:
Illustration for the first sample.
|
```python
import sys
input = sys.stdin.readline
n = int(input())
x = n * n
if x % 2:
a = (x+1)//2
b = a-1
else:
a = (x+4)//4
b = a-2
if n in [2, 1]:
print(-1)
exit(0)
print(b, a)
```
| 3
|
|
644
|
B
|
Processing Queries
|
PROGRAMMING
| 1,700
|
[
"*special",
"constructive algorithms",
"data structures",
"two pointers"
] | null | null |
In this problem you have to simulate the workflow of one-thread server. There are *n* queries to process, the *i*-th will be received at moment *t**i* and needs to be processed for *d**i* units of time. All *t**i* are guaranteed to be distinct.
When a query appears server may react in three possible ways:
1. If server is free and query queue is empty, then server immediately starts to process this query. 1. If server is busy and there are less than *b* queries in the queue, then new query is added to the end of the queue. 1. If server is busy and there are already *b* queries pending in the queue, then new query is just rejected and will never be processed.
As soon as server finished to process some query, it picks new one from the queue (if it's not empty, of course). If a new query comes at some moment *x*, and the server finishes to process another query at exactly the same moment, we consider that first query is picked from the queue and only then new query appears.
For each query find the moment when the server will finish to process it or print -1 if this query will be rejected.
|
The first line of the input contains two integers *n* and *b* (1<=≤<=*n*,<=*b*<=≤<=200<=000) — the number of queries and the maximum possible size of the query queue.
Then follow *n* lines with queries descriptions (in chronological order). Each description consists of two integers *t**i* and *d**i* (1<=≤<=*t**i*,<=*d**i*<=≤<=109), where *t**i* is the moment of time when the *i*-th query appears and *d**i* is the time server needs to process it. It is guaranteed that *t**i*<=-<=1<=<<=*t**i* for all *i*<=><=1.
|
Print the sequence of *n* integers *e*1,<=*e*2,<=...,<=*e**n*, where *e**i* is the moment the server will finish to process the *i*-th query (queries are numbered in the order they appear in the input) or <=-<=1 if the corresponding query will be rejected.
|
[
"5 1\n2 9\n4 8\n10 9\n15 2\n19 1\n",
"4 1\n2 8\n4 8\n10 9\n15 2\n"
] |
[
"11 19 -1 21 22 \n",
"10 18 27 -1 \n"
] |
Consider the first sample.
1. The server will start to process first query at the moment 2 and will finish to process it at the moment 11. 1. At the moment 4 second query appears and proceeds to the queue. 1. At the moment 10 third query appears. However, the server is still busy with query 1, *b* = 1 and there is already query 2 pending in the queue, so third query is just rejected. 1. At the moment 11 server will finish to process first query and will take the second query from the queue. 1. At the moment 15 fourth query appears. As the server is currently busy it proceeds to the queue. 1. At the moment 19 two events occur simultaneously: server finishes to proceed the second query and the fifth query appears. As was said in the statement above, first server will finish to process the second query, then it will pick the fourth query from the queue and only then will the fifth query appear. As the queue is empty fifth query is proceed there. 1. Server finishes to process query number 4 at the moment 21. Query number 5 is picked from the queue. 1. Server finishes to process query number 5 at the moment 22.
| 1,000
|
[
{
"input": "5 1\n2 9\n4 8\n10 9\n15 2\n19 1",
"output": "11 19 -1 21 22 "
},
{
"input": "4 1\n2 8\n4 8\n10 9\n15 2",
"output": "10 18 27 -1 "
},
{
"input": "1 1\n1000000000 1000000000",
"output": "2000000000 "
},
{
"input": "4 3\n999999996 1000000000\n999999997 1000000000\n999999998 1000000000\n999999999 1000000000",
"output": "1999999996 2999999996 3999999996 4999999996 "
},
{
"input": "5 1\n2 1\n3 6\n4 5\n6 4\n7 2",
"output": "3 9 14 -1 -1 "
},
{
"input": "10 2\n4 14\n5 2\n6 6\n7 11\n8 6\n9 5\n10 13\n11 8\n13 2\n20 2",
"output": "18 20 26 -1 -1 -1 -1 -1 -1 28 "
},
{
"input": "6 4\n2 4\n4 2\n5 2\n6 2\n7 2\n9 2",
"output": "6 8 10 12 14 16 "
},
{
"input": "8 3\n1 2\n3 1\n4 3\n5 3\n6 1\n7 2\n8 8\n9 7",
"output": "3 4 7 10 11 13 21 -1 "
},
{
"input": "10 3\n1 14\n3 2\n5 4\n6 9\n9 1\n12 22\n15 11\n18 8\n28 2\n29 4",
"output": "15 17 21 30 -1 -1 41 49 51 -1 "
},
{
"input": "5 2\n2 7\n3 3\n7 4\n9 1\n10 2",
"output": "9 12 16 17 -1 "
},
{
"input": "4 1\n2 1\n6 5\n9 2\n10 3",
"output": "3 11 13 -1 "
},
{
"input": "4 1\n1 2\n2 1\n3 1\n4 3",
"output": "3 4 5 8 "
},
{
"input": "6 3\n1 2\n2 3\n100 200\n200 300\n10000 20000\n20000 30000",
"output": "3 6 300 600 30000 60000 "
}
] | 1,458,465,016
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 71
| 654
| 29,286,400
|
import sys
import collections
n, queue_size = map(int, input().split())
results = [-1 for _ in range(n)]
next_server_free_time = 1
queue = collections.deque()
for idx, line in enumerate(sys.stdin):
t, d = map(int, line.split())
while queue and next_server_free_time <= t:
idx1, d1 = queue.popleft()
next_server_free_time += d1
results[idx1] = next_server_free_time
if next_server_free_time <= t:
results[idx] = t + d
next_server_free_time = t + d
else:
if len(queue) < queue_size:
queue.append((idx, d))
while queue:
idx, d = queue.popleft()
next_server_free_time += d
results[idx] = next_server_free_time
print(' '.join(map(str, results)))
|
Title: Processing Queries
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In this problem you have to simulate the workflow of one-thread server. There are *n* queries to process, the *i*-th will be received at moment *t**i* and needs to be processed for *d**i* units of time. All *t**i* are guaranteed to be distinct.
When a query appears server may react in three possible ways:
1. If server is free and query queue is empty, then server immediately starts to process this query. 1. If server is busy and there are less than *b* queries in the queue, then new query is added to the end of the queue. 1. If server is busy and there are already *b* queries pending in the queue, then new query is just rejected and will never be processed.
As soon as server finished to process some query, it picks new one from the queue (if it's not empty, of course). If a new query comes at some moment *x*, and the server finishes to process another query at exactly the same moment, we consider that first query is picked from the queue and only then new query appears.
For each query find the moment when the server will finish to process it or print -1 if this query will be rejected.
Input Specification:
The first line of the input contains two integers *n* and *b* (1<=≤<=*n*,<=*b*<=≤<=200<=000) — the number of queries and the maximum possible size of the query queue.
Then follow *n* lines with queries descriptions (in chronological order). Each description consists of two integers *t**i* and *d**i* (1<=≤<=*t**i*,<=*d**i*<=≤<=109), where *t**i* is the moment of time when the *i*-th query appears and *d**i* is the time server needs to process it. It is guaranteed that *t**i*<=-<=1<=<<=*t**i* for all *i*<=><=1.
Output Specification:
Print the sequence of *n* integers *e*1,<=*e*2,<=...,<=*e**n*, where *e**i* is the moment the server will finish to process the *i*-th query (queries are numbered in the order they appear in the input) or <=-<=1 if the corresponding query will be rejected.
Demo Input:
['5 1\n2 9\n4 8\n10 9\n15 2\n19 1\n', '4 1\n2 8\n4 8\n10 9\n15 2\n']
Demo Output:
['11 19 -1 21 22 \n', '10 18 27 -1 \n']
Note:
Consider the first sample.
1. The server will start to process first query at the moment 2 and will finish to process it at the moment 11. 1. At the moment 4 second query appears and proceeds to the queue. 1. At the moment 10 third query appears. However, the server is still busy with query 1, *b* = 1 and there is already query 2 pending in the queue, so third query is just rejected. 1. At the moment 11 server will finish to process first query and will take the second query from the queue. 1. At the moment 15 fourth query appears. As the server is currently busy it proceeds to the queue. 1. At the moment 19 two events occur simultaneously: server finishes to proceed the second query and the fifth query appears. As was said in the statement above, first server will finish to process the second query, then it will pick the fourth query from the queue and only then will the fifth query appear. As the queue is empty fifth query is proceed there. 1. Server finishes to process query number 4 at the moment 21. Query number 5 is picked from the queue. 1. Server finishes to process query number 5 at the moment 22.
|
```python
import sys
import collections
n, queue_size = map(int, input().split())
results = [-1 for _ in range(n)]
next_server_free_time = 1
queue = collections.deque()
for idx, line in enumerate(sys.stdin):
t, d = map(int, line.split())
while queue and next_server_free_time <= t:
idx1, d1 = queue.popleft()
next_server_free_time += d1
results[idx1] = next_server_free_time
if next_server_free_time <= t:
results[idx] = t + d
next_server_free_time = t + d
else:
if len(queue) < queue_size:
queue.append((idx, d))
while queue:
idx, d = queue.popleft()
next_server_free_time += d
results[idx] = next_server_free_time
print(' '.join(map(str, results)))
```
| 3
|
|
274
|
B
|
Zero Tree
|
PROGRAMMING
| 1,800
|
[
"dfs and similar",
"dp",
"greedy",
"trees"
] | null | null |
A tree is a graph with *n* vertices and exactly *n*<=-<=1 edges; this graph should meet the following condition: there exists exactly one shortest (by number of edges) path between any pair of its vertices.
A subtree of a tree *T* is a tree with both vertices and edges as subsets of vertices and edges of *T*.
You're given a tree with *n* vertices. Consider its vertices numbered with integers from 1 to *n*. Additionally an integer is written on every vertex of this tree. Initially the integer written on the *i*-th vertex is equal to *v**i*. In one move you can apply the following operation:
1. Select the subtree of the given tree that includes the vertex with number 1. 1. Increase (or decrease) by one all the integers which are written on the vertices of that subtree.
Calculate the minimum number of moves that is required to make all the integers written on the vertices of the given tree equal to zero.
|
The first line of the input contains *n* (1<=≤<=*n*<=≤<=105). Each of the next *n*<=-<=1 lines contains two integers *a**i* and *b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*; *a**i*<=≠<=*b**i*) indicating there's an edge between vertices *a**i* and *b**i*. It's guaranteed that the input graph is a tree.
The last line of the input contains a list of *n* space-separated integers *v*1,<=*v*2,<=...,<=*v**n* (|*v**i*|<=≤<=109).
|
Print the minimum number of operations needed to solve the task.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
|
[
"3\n1 2\n1 3\n1 -1 1\n"
] |
[
"3\n"
] |
none
| 1,000
|
[
{
"input": "3\n1 2\n1 3\n1 -1 1",
"output": "3"
},
{
"input": "5\n2 3\n4 5\n2 5\n1 3\n0 2 1 4 3",
"output": "8"
},
{
"input": "10\n5 6\n8 2\n9 3\n4 1\n6 10\n9 8\n7 10\n7 4\n5 2\n0 -6 -9 -1 -5 -4 -2 -7 -8 -3",
"output": "18"
},
{
"input": "5\n3 1\n2 4\n3 4\n2 5\n0 -3 -1 2 4",
"output": "20"
},
{
"input": "12\n1 6\n10 1\n4 1\n7 1\n1 2\n5 1\n1 8\n1 11\n3 1\n12 1\n9 1\n580660007 861441526 -264928594 488291045 253254575 -974301934 709266786 926718320 87511873 514836444 -702876508 848928657",
"output": "2529263875"
}
] | 1,601,913,953
| 2,147,483,647
|
PyPy 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 5
| 2,000
| 21,299,200
|
from math import ceil,sqrt
from collections import defaultdict
def dfs(n,l):
boo[n] = True
for i in hash[n]:
if not boo[i]:
dfs(i,l)
dp1[n] = max(dp1[i],dp1[n])
dp2[n] = max(dp2[i],dp2[n])
l[n]+=dp1[n]
l[n]-=dp2[n]
if l[n]<0:dp1[n]+=-l[n]
else:dp2[n]+=l[n]
def solve():
n = int(input())
for i in range(n-1):
a,b = map(int,input().split())
hash[a].append(b)
hash[b].append(a)
l = [0]+list(map(int,input().split()))
dfs(1,l)
print(dp1[1]+dp2[1])
# for i in range(1,n+1):
# l[i]+=z
# t = int(input())
# for _ in range(t):
hash= defaultdict(list)
boo = defaultdict(int)
dp1 = defaultdict(int)
dp2 = defaultdict(int)
solve()
|
Title: Zero Tree
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A tree is a graph with *n* vertices and exactly *n*<=-<=1 edges; this graph should meet the following condition: there exists exactly one shortest (by number of edges) path between any pair of its vertices.
A subtree of a tree *T* is a tree with both vertices and edges as subsets of vertices and edges of *T*.
You're given a tree with *n* vertices. Consider its vertices numbered with integers from 1 to *n*. Additionally an integer is written on every vertex of this tree. Initially the integer written on the *i*-th vertex is equal to *v**i*. In one move you can apply the following operation:
1. Select the subtree of the given tree that includes the vertex with number 1. 1. Increase (or decrease) by one all the integers which are written on the vertices of that subtree.
Calculate the minimum number of moves that is required to make all the integers written on the vertices of the given tree equal to zero.
Input Specification:
The first line of the input contains *n* (1<=≤<=*n*<=≤<=105). Each of the next *n*<=-<=1 lines contains two integers *a**i* and *b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*; *a**i*<=≠<=*b**i*) indicating there's an edge between vertices *a**i* and *b**i*. It's guaranteed that the input graph is a tree.
The last line of the input contains a list of *n* space-separated integers *v*1,<=*v*2,<=...,<=*v**n* (|*v**i*|<=≤<=109).
Output Specification:
Print the minimum number of operations needed to solve the task.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Demo Input:
['3\n1 2\n1 3\n1 -1 1\n']
Demo Output:
['3\n']
Note:
none
|
```python
from math import ceil,sqrt
from collections import defaultdict
def dfs(n,l):
boo[n] = True
for i in hash[n]:
if not boo[i]:
dfs(i,l)
dp1[n] = max(dp1[i],dp1[n])
dp2[n] = max(dp2[i],dp2[n])
l[n]+=dp1[n]
l[n]-=dp2[n]
if l[n]<0:dp1[n]+=-l[n]
else:dp2[n]+=l[n]
def solve():
n = int(input())
for i in range(n-1):
a,b = map(int,input().split())
hash[a].append(b)
hash[b].append(a)
l = [0]+list(map(int,input().split()))
dfs(1,l)
print(dp1[1]+dp2[1])
# for i in range(1,n+1):
# l[i]+=z
# t = int(input())
# for _ in range(t):
hash= defaultdict(list)
boo = defaultdict(int)
dp1 = defaultdict(int)
dp2 = defaultdict(int)
solve()
```
| 0
|
|
609
|
A
|
USB Flash Drives
|
PROGRAMMING
| 800
|
[
"greedy",
"implementation",
"sortings"
] | null | null |
Sean is trying to save a large file to a USB flash drive. He has *n* USB flash drives with capacities equal to *a*1,<=*a*2,<=...,<=*a**n* megabytes. The file size is equal to *m* megabytes.
Find the minimum number of USB flash drives needed to write Sean's file, if he can split the file between drives.
|
The first line contains positive integer *n* (1<=≤<=*n*<=≤<=100) — the number of USB flash drives.
The second line contains positive integer *m* (1<=≤<=*m*<=≤<=105) — the size of Sean's file.
Each of the next *n* lines contains positive integer *a**i* (1<=≤<=*a**i*<=≤<=1000) — the sizes of USB flash drives in megabytes.
It is guaranteed that the answer exists, i. e. the sum of all *a**i* is not less than *m*.
|
Print the minimum number of USB flash drives to write Sean's file, if he can split the file between drives.
|
[
"3\n5\n2\n1\n3\n",
"3\n6\n2\n3\n2\n",
"2\n5\n5\n10\n"
] |
[
"2\n",
"3\n",
"1\n"
] |
In the first example Sean needs only two USB flash drives — the first and the third.
In the second example Sean needs all three USB flash drives.
In the third example Sean needs only one USB flash drive and he can use any available USB flash drive — the first or the second.
| 0
|
[
{
"input": "3\n5\n2\n1\n3",
"output": "2"
},
{
"input": "3\n6\n2\n3\n2",
"output": "3"
},
{
"input": "2\n5\n5\n10",
"output": "1"
},
{
"input": "5\n16\n8\n1\n3\n4\n9",
"output": "2"
},
{
"input": "10\n121\n10\n37\n74\n56\n42\n39\n6\n68\n8\n100",
"output": "2"
},
{
"input": "12\n4773\n325\n377\n192\n780\n881\n816\n839\n223\n215\n125\n952\n8",
"output": "7"
},
{
"input": "15\n7758\n182\n272\n763\n910\n24\n359\n583\n890\n735\n819\n66\n992\n440\n496\n227",
"output": "15"
},
{
"input": "30\n70\n6\n2\n10\n4\n7\n10\n5\n1\n8\n10\n4\n3\n5\n9\n3\n6\n6\n4\n2\n6\n5\n10\n1\n9\n7\n2\n1\n10\n7\n5",
"output": "8"
},
{
"input": "40\n15705\n702\n722\n105\n873\n417\n477\n794\n300\n869\n496\n572\n232\n456\n298\n473\n584\n486\n713\n934\n121\n303\n956\n934\n840\n358\n201\n861\n497\n131\n312\n957\n96\n914\n509\n60\n300\n722\n658\n820\n103",
"output": "21"
},
{
"input": "50\n18239\n300\n151\n770\n9\n200\n52\n247\n753\n523\n263\n744\n463\n540\n244\n608\n569\n771\n32\n425\n777\n624\n761\n628\n124\n405\n396\n726\n626\n679\n237\n229\n49\n512\n18\n671\n290\n768\n632\n739\n18\n136\n413\n117\n83\n413\n452\n767\n664\n203\n404",
"output": "31"
},
{
"input": "70\n149\n5\n3\n3\n4\n6\n1\n2\n9\n8\n3\n1\n8\n4\n4\n3\n6\n10\n7\n1\n10\n8\n4\n9\n3\n8\n3\n2\n5\n1\n8\n6\n9\n10\n4\n8\n6\n9\n9\n9\n3\n4\n2\n2\n5\n8\n9\n1\n10\n3\n4\n3\n1\n9\n3\n5\n1\n3\n7\n6\n9\n8\n9\n1\n7\n4\n4\n2\n3\n5\n7",
"output": "17"
},
{
"input": "70\n2731\n26\n75\n86\n94\n37\n25\n32\n35\n92\n1\n51\n73\n53\n66\n16\n80\n15\n81\n100\n87\n55\n48\n30\n71\n39\n87\n77\n25\n70\n22\n75\n23\n97\n16\n75\n95\n61\n61\n28\n10\n78\n54\n80\n51\n25\n24\n90\n58\n4\n77\n40\n54\n53\n47\n62\n30\n38\n71\n97\n71\n60\n58\n1\n21\n15\n55\n99\n34\n88\n99",
"output": "35"
},
{
"input": "70\n28625\n34\n132\n181\n232\n593\n413\n862\n887\n808\n18\n35\n89\n356\n640\n339\n280\n975\n82\n345\n398\n948\n372\n91\n755\n75\n153\n948\n603\n35\n694\n722\n293\n363\n884\n264\n813\n175\n169\n646\n138\n449\n488\n828\n417\n134\n84\n763\n288\n845\n801\n556\n972\n332\n564\n934\n699\n842\n942\n644\n203\n406\n140\n37\n9\n423\n546\n675\n491\n113\n587",
"output": "45"
},
{
"input": "80\n248\n3\n9\n4\n5\n10\n7\n2\n6\n2\n2\n8\n2\n1\n3\n7\n9\n2\n8\n4\n4\n8\n5\n4\n4\n10\n2\n1\n4\n8\n4\n10\n1\n2\n10\n2\n3\n3\n1\n1\n8\n9\n5\n10\n2\n8\n10\n5\n3\n6\n1\n7\n8\n9\n10\n5\n10\n10\n2\n10\n1\n2\n4\n1\n9\n4\n7\n10\n8\n5\n8\n1\n4\n2\n2\n3\n9\n9\n9\n10\n6",
"output": "27"
},
{
"input": "80\n2993\n18\n14\n73\n38\n14\n73\n77\n18\n81\n6\n96\n65\n77\n86\n76\n8\n16\n81\n83\n83\n34\n69\n58\n15\n19\n1\n16\n57\n95\n35\n5\n49\n8\n15\n47\n84\n99\n94\n93\n55\n43\n47\n51\n61\n57\n13\n7\n92\n14\n4\n83\n100\n60\n75\n41\n95\n74\n40\n1\n4\n95\n68\n59\n65\n15\n15\n75\n85\n46\n77\n26\n30\n51\n64\n75\n40\n22\n88\n68\n24",
"output": "38"
},
{
"input": "80\n37947\n117\n569\n702\n272\n573\n629\n90\n337\n673\n589\n576\n205\n11\n284\n645\n719\n777\n271\n567\n466\n251\n402\n3\n97\n288\n699\n208\n173\n530\n782\n266\n395\n957\n159\n463\n43\n316\n603\n197\n386\n132\n799\n778\n905\n784\n71\n851\n963\n883\n705\n454\n275\n425\n727\n223\n4\n870\n833\n431\n463\n85\n505\n800\n41\n954\n981\n242\n578\n336\n48\n858\n702\n349\n929\n646\n528\n993\n506\n274\n227",
"output": "70"
},
{
"input": "90\n413\n5\n8\n10\n7\n5\n7\n5\n7\n1\n7\n8\n4\n3\n9\n4\n1\n10\n3\n1\n10\n9\n3\n1\n8\n4\n7\n5\n2\n9\n3\n10\n10\n3\n6\n3\n3\n10\n7\n5\n1\n1\n2\n4\n8\n2\n5\n5\n3\n9\n5\n5\n3\n10\n2\n3\n8\n5\n9\n1\n3\n6\n5\n9\n2\n3\n7\n10\n3\n4\n4\n1\n5\n9\n2\n6\n9\n1\n1\n9\n9\n7\n7\n7\n8\n4\n5\n3\n4\n6\n9",
"output": "59"
},
{
"input": "90\n4226\n33\n43\n83\n46\n75\n14\n88\n36\n8\n25\n47\n4\n96\n19\n33\n49\n65\n17\n59\n72\n1\n55\n94\n92\n27\n33\n39\n14\n62\n79\n12\n89\n22\n86\n13\n19\n77\n53\n96\n74\n24\n25\n17\n64\n71\n81\n87\n52\n72\n55\n49\n74\n36\n65\n86\n91\n33\n61\n97\n38\n87\n61\n14\n73\n95\n43\n67\n42\n67\n22\n12\n62\n32\n96\n24\n49\n82\n46\n89\n36\n75\n91\n11\n10\n9\n33\n86\n28\n75\n39",
"output": "64"
},
{
"input": "90\n40579\n448\n977\n607\n745\n268\n826\n479\n59\n330\n609\n43\n301\n970\n726\n172\n632\n600\n181\n712\n195\n491\n312\n849\n722\n679\n682\n780\n131\n404\n293\n387\n567\n660\n54\n339\n111\n833\n612\n911\n869\n356\n884\n635\n126\n639\n712\n473\n663\n773\n435\n32\n973\n484\n662\n464\n699\n274\n919\n95\n904\n253\n589\n543\n454\n250\n349\n237\n829\n511\n536\n36\n45\n152\n626\n384\n199\n877\n941\n84\n781\n115\n20\n52\n726\n751\n920\n291\n571\n6\n199",
"output": "64"
},
{
"input": "100\n66\n7\n9\n10\n5\n2\n8\n6\n5\n4\n10\n10\n6\n5\n2\n2\n1\n1\n5\n8\n7\n8\n10\n5\n6\n6\n5\n9\n9\n6\n3\n8\n7\n10\n5\n9\n6\n7\n3\n5\n8\n6\n8\n9\n1\n1\n1\n2\n4\n5\n5\n1\n1\n2\n6\n7\n1\n5\n8\n7\n2\n1\n7\n10\n9\n10\n2\n4\n10\n4\n10\n10\n5\n3\n9\n1\n2\n1\n10\n5\n1\n7\n4\n4\n5\n7\n6\n10\n4\n7\n3\n4\n3\n6\n2\n5\n2\n4\n9\n5\n3",
"output": "7"
},
{
"input": "100\n4862\n20\n47\n85\n47\n76\n38\n48\n93\n91\n81\n31\n51\n23\n60\n59\n3\n73\n72\n57\n67\n54\n9\n42\n5\n32\n46\n72\n79\n95\n61\n79\n88\n33\n52\n97\n10\n3\n20\n79\n82\n93\n90\n38\n80\n18\n21\n43\n60\n73\n34\n75\n65\n10\n84\n100\n29\n94\n56\n22\n59\n95\n46\n22\n57\n69\n67\n90\n11\n10\n61\n27\n2\n48\n69\n86\n91\n69\n76\n36\n71\n18\n54\n90\n74\n69\n50\n46\n8\n5\n41\n96\n5\n14\n55\n85\n39\n6\n79\n75\n87",
"output": "70"
},
{
"input": "100\n45570\n14\n881\n678\n687\n993\n413\n760\n451\n426\n787\n503\n343\n234\n530\n294\n725\n941\n524\n574\n441\n798\n399\n360\n609\n376\n525\n229\n995\n478\n347\n47\n23\n468\n525\n749\n601\n235\n89\n995\n489\n1\n239\n415\n122\n671\n128\n357\n886\n401\n964\n212\n968\n210\n130\n871\n360\n661\n844\n414\n187\n21\n824\n266\n713\n126\n496\n916\n37\n193\n755\n894\n641\n300\n170\n176\n383\n488\n627\n61\n897\n33\n242\n419\n881\n698\n107\n391\n418\n774\n905\n87\n5\n896\n835\n318\n373\n916\n393\n91\n460",
"output": "78"
},
{
"input": "100\n522\n1\n5\n2\n4\n2\n6\n3\n4\n2\n10\n10\n6\n7\n9\n7\n1\n7\n2\n5\n3\n1\n5\n2\n3\n5\n1\n7\n10\n10\n4\n4\n10\n9\n10\n6\n2\n8\n2\n6\n10\n9\n2\n7\n5\n9\n4\n6\n10\n7\n3\n1\n1\n9\n5\n10\n9\n2\n8\n3\n7\n5\n4\n7\n5\n9\n10\n6\n2\n9\n2\n5\n10\n1\n7\n7\n10\n5\n6\n2\n9\n4\n7\n10\n10\n8\n3\n4\n9\n3\n6\n9\n10\n2\n9\n9\n3\n4\n1\n10\n2",
"output": "74"
},
{
"input": "100\n32294\n414\n116\n131\n649\n130\n476\n630\n605\n213\n117\n757\n42\n109\n85\n127\n635\n629\n994\n410\n764\n204\n161\n231\n577\n116\n936\n537\n565\n571\n317\n722\n819\n229\n284\n487\n649\n304\n628\n727\n816\n854\n91\n111\n549\n87\n374\n417\n3\n868\n882\n168\n743\n77\n534\n781\n75\n956\n910\n734\n507\n568\n802\n946\n891\n659\n116\n678\n375\n380\n430\n627\n873\n350\n930\n285\n6\n183\n96\n517\n81\n794\n235\n360\n551\n6\n28\n799\n226\n996\n894\n981\n551\n60\n40\n460\n479\n161\n318\n952\n433",
"output": "42"
},
{
"input": "100\n178\n71\n23\n84\n98\n8\n14\n4\n42\n56\n83\n87\n28\n22\n32\n50\n5\n96\n90\n1\n59\n74\n56\n96\n77\n88\n71\n38\n62\n36\n85\n1\n97\n98\n98\n32\n99\n42\n6\n81\n20\n49\n57\n71\n66\n9\n45\n41\n29\n28\n32\n68\n38\n29\n35\n29\n19\n27\n76\n85\n68\n68\n41\n32\n78\n72\n38\n19\n55\n83\n83\n25\n46\n62\n48\n26\n53\n14\n39\n31\n94\n84\n22\n39\n34\n96\n63\n37\n42\n6\n78\n76\n64\n16\n26\n6\n79\n53\n24\n29\n63",
"output": "2"
},
{
"input": "100\n885\n226\n266\n321\n72\n719\n29\n121\n533\n85\n672\n225\n830\n783\n822\n30\n791\n618\n166\n487\n922\n434\n814\n473\n5\n741\n947\n910\n305\n998\n49\n945\n588\n868\n809\n803\n168\n280\n614\n434\n634\n538\n591\n437\n540\n445\n313\n177\n171\n799\n778\n55\n617\n554\n583\n611\n12\n94\n599\n182\n765\n556\n965\n542\n35\n460\n177\n313\n485\n744\n384\n21\n52\n879\n792\n411\n614\n811\n565\n695\n428\n587\n631\n794\n461\n258\n193\n696\n936\n646\n756\n267\n55\n690\n730\n742\n734\n988\n235\n762\n440",
"output": "1"
},
{
"input": "100\n29\n9\n2\n10\n8\n6\n7\n7\n3\n3\n10\n4\n5\n2\n5\n1\n6\n3\n2\n5\n10\n10\n9\n1\n4\n5\n2\n2\n3\n1\n2\n2\n9\n6\n9\n7\n8\n8\n1\n5\n5\n3\n1\n5\n6\n1\n9\n2\n3\n8\n10\n8\n3\n2\n7\n1\n2\n1\n2\n8\n10\n5\n2\n3\n1\n10\n7\n1\n7\n4\n9\n6\n6\n4\n7\n1\n2\n7\n7\n9\n9\n7\n10\n4\n10\n8\n2\n1\n5\n5\n10\n5\n8\n1\n5\n6\n5\n1\n5\n6\n8",
"output": "3"
},
{
"input": "100\n644\n94\n69\n43\n36\n54\n93\n30\n74\n56\n95\n70\n49\n11\n36\n57\n30\n59\n3\n52\n59\n90\n82\n39\n67\n32\n8\n80\n64\n8\n65\n51\n48\n89\n90\n35\n4\n54\n66\n96\n68\n90\n30\n4\n13\n97\n41\n90\n85\n17\n45\n94\n31\n58\n4\n39\n76\n95\n92\n59\n67\n46\n96\n55\n82\n64\n20\n20\n83\n46\n37\n15\n60\n37\n79\n45\n47\n63\n73\n76\n31\n52\n36\n32\n49\n26\n61\n91\n31\n25\n62\n90\n65\n65\n5\n94\n7\n15\n97\n88\n68",
"output": "7"
},
{
"input": "100\n1756\n98\n229\n158\n281\n16\n169\n149\n239\n235\n182\n147\n215\n49\n270\n194\n242\n295\n289\n249\n19\n12\n144\n157\n92\n270\n122\n212\n97\n152\n14\n42\n12\n198\n98\n295\n154\n229\n191\n294\n5\n156\n43\n185\n184\n20\n125\n23\n10\n257\n244\n264\n79\n46\n277\n13\n22\n97\n212\n77\n293\n20\n51\n17\n109\n37\n68\n117\n51\n248\n10\n149\n179\n192\n239\n161\n13\n173\n297\n73\n43\n109\n288\n198\n81\n70\n254\n187\n277\n1\n295\n113\n95\n291\n293\n119\n205\n191\n37\n34\n116",
"output": "6"
},
{
"input": "100\n20562\n721\n452\n11\n703\n376\n183\n197\n203\n406\n642\n346\n446\n256\n760\n201\n360\n702\n707\n388\n779\n653\n610\n497\n768\n670\n134\n780\n306\n661\n180\n259\n256\n362\n6\n121\n415\n747\n170\n67\n439\n728\n193\n622\n481\n38\n225\n343\n303\n253\n436\n305\n68\n794\n247\n291\n600\n750\n188\n199\n757\n28\n776\n749\n253\n351\n53\n629\n129\n578\n209\n89\n651\n262\n638\n353\n469\n31\n144\n460\n176\n535\n562\n366\n639\n234\n577\n364\n761\n617\n303\n450\n778\n311\n289\n221\n274\n239\n626\n194\n36",
"output": "30"
},
{
"input": "100\n32630\n548\n21\n756\n138\n56\n719\n97\n86\n599\n531\n464\n137\n737\n239\n626\n179\n170\n271\n335\n178\n298\n597\n616\n104\n190\n216\n333\n606\n621\n310\n70\n286\n593\n655\n472\n556\n77\n625\n744\n395\n487\n762\n316\n469\n258\n475\n596\n651\n180\n737\n101\n511\n708\n163\n713\n475\n557\n649\n705\n583\n97\n447\n119\n91\n372\n194\n394\n667\n384\n635\n611\n746\n758\n613\n54\n508\n405\n188\n570\n254\n28\n599\n767\n115\n737\n194\n148\n686\n705\n236\n762\n613\n770\n633\n401\n773\n448\n274\n141\n718",
"output": "52"
},
{
"input": "1\n1\n1",
"output": "1"
}
] | 1,659,718,016
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 34
| 46
| 0
|
n = int(input())
m = int(input())
lis = []
for i in range(n):
weight = int(input())
lis.append(weight)
lis.sort(reverse = True)
for j in range(len(lis)):
if m <= lis[j]:
print(j + 1)
break
else:
m -= lis[j]
|
Title: USB Flash Drives
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Sean is trying to save a large file to a USB flash drive. He has *n* USB flash drives with capacities equal to *a*1,<=*a*2,<=...,<=*a**n* megabytes. The file size is equal to *m* megabytes.
Find the minimum number of USB flash drives needed to write Sean's file, if he can split the file between drives.
Input Specification:
The first line contains positive integer *n* (1<=≤<=*n*<=≤<=100) — the number of USB flash drives.
The second line contains positive integer *m* (1<=≤<=*m*<=≤<=105) — the size of Sean's file.
Each of the next *n* lines contains positive integer *a**i* (1<=≤<=*a**i*<=≤<=1000) — the sizes of USB flash drives in megabytes.
It is guaranteed that the answer exists, i. e. the sum of all *a**i* is not less than *m*.
Output Specification:
Print the minimum number of USB flash drives to write Sean's file, if he can split the file between drives.
Demo Input:
['3\n5\n2\n1\n3\n', '3\n6\n2\n3\n2\n', '2\n5\n5\n10\n']
Demo Output:
['2\n', '3\n', '1\n']
Note:
In the first example Sean needs only two USB flash drives — the first and the third.
In the second example Sean needs all three USB flash drives.
In the third example Sean needs only one USB flash drive and he can use any available USB flash drive — the first or the second.
|
```python
n = int(input())
m = int(input())
lis = []
for i in range(n):
weight = int(input())
lis.append(weight)
lis.sort(reverse = True)
for j in range(len(lis)):
if m <= lis[j]:
print(j + 1)
break
else:
m -= lis[j]
```
| 3
|
|
746
|
A
|
Compote
|
PROGRAMMING
| 800
|
[
"implementation",
"math"
] | null | null |
Nikolay has *a* lemons, *b* apples and *c* pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1:<=2:<=4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
|
The first line contains the positive integer *a* (1<=≤<=*a*<=≤<=1000) — the number of lemons Nikolay has.
The second line contains the positive integer *b* (1<=≤<=*b*<=≤<=1000) — the number of apples Nikolay has.
The third line contains the positive integer *c* (1<=≤<=*c*<=≤<=1000) — the number of pears Nikolay has.
|
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
|
[
"2\n5\n7\n",
"4\n7\n13\n",
"2\n3\n2\n"
] |
[
"7\n",
"21\n",
"0\n"
] |
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
| 500
|
[
{
"input": "2\n5\n7",
"output": "7"
},
{
"input": "4\n7\n13",
"output": "21"
},
{
"input": "2\n3\n2",
"output": "0"
},
{
"input": "1\n1\n1",
"output": "0"
},
{
"input": "1\n2\n4",
"output": "7"
},
{
"input": "1000\n1000\n1000",
"output": "1750"
},
{
"input": "1\n1\n4",
"output": "0"
},
{
"input": "1\n2\n3",
"output": "0"
},
{
"input": "1\n1000\n1000",
"output": "7"
},
{
"input": "1000\n1\n1000",
"output": "0"
},
{
"input": "1000\n2\n1000",
"output": "7"
},
{
"input": "1000\n500\n1000",
"output": "1750"
},
{
"input": "1000\n1000\n4",
"output": "7"
},
{
"input": "1000\n1000\n3",
"output": "0"
},
{
"input": "4\n8\n12",
"output": "21"
},
{
"input": "10\n20\n40",
"output": "70"
},
{
"input": "100\n200\n399",
"output": "693"
},
{
"input": "200\n400\n800",
"output": "1400"
},
{
"input": "199\n400\n800",
"output": "1393"
},
{
"input": "201\n400\n800",
"output": "1400"
},
{
"input": "200\n399\n800",
"output": "1393"
},
{
"input": "200\n401\n800",
"output": "1400"
},
{
"input": "200\n400\n799",
"output": "1393"
},
{
"input": "200\n400\n801",
"output": "1400"
},
{
"input": "139\n252\n871",
"output": "882"
},
{
"input": "109\n346\n811",
"output": "763"
},
{
"input": "237\n487\n517",
"output": "903"
},
{
"input": "161\n331\n725",
"output": "1127"
},
{
"input": "39\n471\n665",
"output": "273"
},
{
"input": "9\n270\n879",
"output": "63"
},
{
"input": "137\n422\n812",
"output": "959"
},
{
"input": "15\n313\n525",
"output": "105"
},
{
"input": "189\n407\n966",
"output": "1323"
},
{
"input": "18\n268\n538",
"output": "126"
},
{
"input": "146\n421\n978",
"output": "1022"
},
{
"input": "70\n311\n685",
"output": "490"
},
{
"input": "244\n405\n625",
"output": "1092"
},
{
"input": "168\n454\n832",
"output": "1176"
},
{
"input": "46\n344\n772",
"output": "322"
},
{
"input": "174\n438\n987",
"output": "1218"
},
{
"input": "144\n387\n693",
"output": "1008"
},
{
"input": "22\n481\n633",
"output": "154"
},
{
"input": "196\n280\n848",
"output": "980"
},
{
"input": "190\n454\n699",
"output": "1218"
},
{
"input": "231\n464\n928",
"output": "1617"
},
{
"input": "151\n308\n616",
"output": "1057"
},
{
"input": "88\n182\n364",
"output": "616"
},
{
"input": "12\n26\n52",
"output": "84"
},
{
"input": "204\n412\n824",
"output": "1428"
},
{
"input": "127\n256\n512",
"output": "889"
},
{
"input": "224\n446\n896",
"output": "1561"
},
{
"input": "146\n291\n584",
"output": "1015"
},
{
"input": "83\n164\n332",
"output": "574"
},
{
"input": "20\n38\n80",
"output": "133"
},
{
"input": "198\n393\n792",
"output": "1372"
},
{
"input": "120\n239\n480",
"output": "833"
},
{
"input": "208\n416\n831",
"output": "1449"
},
{
"input": "130\n260\n517",
"output": "903"
},
{
"input": "67\n134\n267",
"output": "462"
},
{
"input": "245\n490\n979",
"output": "1708"
},
{
"input": "182\n364\n727",
"output": "1267"
},
{
"input": "104\n208\n413",
"output": "721"
},
{
"input": "10\n2\n100",
"output": "7"
},
{
"input": "2\n100\n100",
"output": "14"
},
{
"input": "2\n3\n8",
"output": "7"
},
{
"input": "1\n2\n8",
"output": "7"
},
{
"input": "1\n2\n200",
"output": "7"
},
{
"input": "5\n4\n16",
"output": "14"
},
{
"input": "1\n10\n10",
"output": "7"
},
{
"input": "1\n4\n8",
"output": "7"
},
{
"input": "100\n4\n1000",
"output": "14"
},
{
"input": "2\n6\n12",
"output": "14"
},
{
"input": "10\n7\n4",
"output": "7"
},
{
"input": "2\n10\n100",
"output": "14"
},
{
"input": "2\n3\n4",
"output": "7"
},
{
"input": "1\n2\n999",
"output": "7"
},
{
"input": "1\n10\n20",
"output": "7"
},
{
"input": "100\n18\n20",
"output": "35"
},
{
"input": "100\n1\n100",
"output": "0"
},
{
"input": "3\n7\n80",
"output": "21"
},
{
"input": "2\n8\n24",
"output": "14"
},
{
"input": "1\n100\n100",
"output": "7"
},
{
"input": "2\n1\n8",
"output": "0"
},
{
"input": "10\n5\n23",
"output": "14"
}
] | 1,690,741,351
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 84
| 61
| 0
|
a,b,c,ans=int(input()),int(input()),int(input()),0
while a>0 and b>0 and c>0:
a-=1
b-=2
c-=4
if a>=0 and b>=0 and c>=0:
ans+=7
print(ans)
|
Title: Compote
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Nikolay has *a* lemons, *b* apples and *c* pears. He decided to cook a compote. According to the recipe the fruits should be in the ratio 1:<=2:<=4. It means that for each lemon in the compote should be exactly 2 apples and exactly 4 pears. You can't crumble up, break up or cut these fruits into pieces. These fruits — lemons, apples and pears — should be put in the compote as whole fruits.
Your task is to determine the maximum total number of lemons, apples and pears from which Nikolay can cook the compote. It is possible that Nikolay can't use any fruits, in this case print 0.
Input Specification:
The first line contains the positive integer *a* (1<=≤<=*a*<=≤<=1000) — the number of lemons Nikolay has.
The second line contains the positive integer *b* (1<=≤<=*b*<=≤<=1000) — the number of apples Nikolay has.
The third line contains the positive integer *c* (1<=≤<=*c*<=≤<=1000) — the number of pears Nikolay has.
Output Specification:
Print the maximum total number of lemons, apples and pears from which Nikolay can cook the compote.
Demo Input:
['2\n5\n7\n', '4\n7\n13\n', '2\n3\n2\n']
Demo Output:
['7\n', '21\n', '0\n']
Note:
In the first example Nikolay can use 1 lemon, 2 apples and 4 pears, so the answer is 1 + 2 + 4 = 7.
In the second example Nikolay can use 3 lemons, 6 apples and 12 pears, so the answer is 3 + 6 + 12 = 21.
In the third example Nikolay don't have enough pears to cook any compote, so the answer is 0.
|
```python
a,b,c,ans=int(input()),int(input()),int(input()),0
while a>0 and b>0 and c>0:
a-=1
b-=2
c-=4
if a>=0 and b>=0 and c>=0:
ans+=7
print(ans)
```
| 3
|
|
333
|
A
|
Secrets
|
PROGRAMMING
| 1,600
|
[
"greedy"
] | null | null |
Gerald has been selling state secrets at leisure. All the secrets cost the same: *n* marks. The state which secrets Gerald is selling, has no paper money, only coins. But there are coins of all positive integer denominations that are powers of three: 1 mark, 3 marks, 9 marks, 27 marks and so on. There are no coins of other denominations. Of course, Gerald likes it when he gets money without the change. And all buyers respect him and try to give the desired sum without change, if possible. But this does not always happen.
One day an unlucky buyer came. He did not have the desired sum without change. Then he took out all his coins and tried to give Gerald a larger than necessary sum with as few coins as possible. What is the maximum number of coins he could get?
The formal explanation of the previous paragraph: we consider all the possible combinations of coins for which the buyer can not give Gerald the sum of *n* marks without change. For each such combination calculate the minimum number of coins that can bring the buyer at least *n* marks. Among all combinations choose the maximum of the minimum number of coins. This is the number we want.
|
The single line contains a single integer *n* (1<=≤<=*n*<=≤<=1017).
Please, do not use the %lld specifier to read or write 64 bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
|
In a single line print an integer: the maximum number of coins the unlucky buyer could have paid with.
|
[
"1\n",
"4\n"
] |
[
"1\n",
"2\n"
] |
In the first test case, if a buyer has exactly one coin of at least 3 marks, then, to give Gerald one mark, he will have to give this coin. In this sample, the customer can not have a coin of one mark, as in this case, he will be able to give the money to Gerald without any change.
In the second test case, if the buyer had exactly three coins of 3 marks, then, to give Gerald 4 marks, he will have to give two of these coins. The buyer cannot give three coins as he wants to minimize the number of coins that he gives.
| 500
|
[
{
"input": "1",
"output": "1"
},
{
"input": "4",
"output": "2"
},
{
"input": "3",
"output": "1"
},
{
"input": "8",
"output": "3"
},
{
"input": "10",
"output": "4"
},
{
"input": "100000000000000000",
"output": "33333333333333334"
},
{
"input": "99999999999999999",
"output": "3703703703703704"
},
{
"input": "50031545098999707",
"output": "1"
},
{
"input": "16677181699666569",
"output": "1"
},
{
"input": "72900000000000",
"output": "33333333334"
},
{
"input": "99999999999999997",
"output": "33333333333333333"
},
{
"input": "58061299250691018",
"output": "32"
},
{
"input": "49664023559436051",
"output": "128191526"
},
{
"input": "66708726798666276",
"output": "2"
},
{
"input": "29442431889534807",
"output": "48"
},
{
"input": "70414767176369958",
"output": "13"
},
{
"input": "93886356235159944",
"output": "51"
},
{
"input": "97626528902553453",
"output": "551104613133"
},
{
"input": "52013157885656046",
"output": "880847395988"
},
{
"input": "37586570003500923",
"output": "548"
},
{
"input": "34391854792828422",
"output": "582429080812"
},
{
"input": "205891132094649",
"output": "1"
},
{
"input": "243",
"output": "1"
},
{
"input": "5559060566555523",
"output": "1"
},
{
"input": "81",
"output": "1"
},
{
"input": "108",
"output": "2"
},
{
"input": "2",
"output": "1"
},
{
"input": "1129718145924",
"output": "2"
}
] | 1,423,522,587
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 28
| 122
| 0
|
n, f = int(input()), 3
while n % f == 0:
f *= 3
print(n // f + 1)
|
Title: Secrets
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Gerald has been selling state secrets at leisure. All the secrets cost the same: *n* marks. The state which secrets Gerald is selling, has no paper money, only coins. But there are coins of all positive integer denominations that are powers of three: 1 mark, 3 marks, 9 marks, 27 marks and so on. There are no coins of other denominations. Of course, Gerald likes it when he gets money without the change. And all buyers respect him and try to give the desired sum without change, if possible. But this does not always happen.
One day an unlucky buyer came. He did not have the desired sum without change. Then he took out all his coins and tried to give Gerald a larger than necessary sum with as few coins as possible. What is the maximum number of coins he could get?
The formal explanation of the previous paragraph: we consider all the possible combinations of coins for which the buyer can not give Gerald the sum of *n* marks without change. For each such combination calculate the minimum number of coins that can bring the buyer at least *n* marks. Among all combinations choose the maximum of the minimum number of coins. This is the number we want.
Input Specification:
The single line contains a single integer *n* (1<=≤<=*n*<=≤<=1017).
Please, do not use the %lld specifier to read or write 64 bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output Specification:
In a single line print an integer: the maximum number of coins the unlucky buyer could have paid with.
Demo Input:
['1\n', '4\n']
Demo Output:
['1\n', '2\n']
Note:
In the first test case, if a buyer has exactly one coin of at least 3 marks, then, to give Gerald one mark, he will have to give this coin. In this sample, the customer can not have a coin of one mark, as in this case, he will be able to give the money to Gerald without any change.
In the second test case, if the buyer had exactly three coins of 3 marks, then, to give Gerald 4 marks, he will have to give two of these coins. The buyer cannot give three coins as he wants to minimize the number of coins that he gives.
|
```python
n, f = int(input()), 3
while n % f == 0:
f *= 3
print(n // f + 1)
```
| 3
|
|
918
|
A
|
Eleven
|
PROGRAMMING
| 800
|
[
"brute force",
"implementation"
] | null | null |
Eleven wants to choose a new name for herself. As a bunch of geeks, her friends suggested an algorithm to choose a name for her. Eleven wants her name to have exactly *n* characters.
Her friend suggested that her name should only consist of uppercase and lowercase letters 'O'. More precisely, they suggested that the *i*-th letter of her name should be 'O' (uppercase) if *i* is a member of Fibonacci sequence, and 'o' (lowercase) otherwise. The letters in the name are numbered from 1 to *n*. Fibonacci sequence is the sequence *f* where
- *f*1<==<=1, - *f*2<==<=1, - *f**n*<==<=*f**n*<=-<=2<=+<=*f**n*<=-<=1 (*n*<=><=2).
As her friends are too young to know what Fibonacci sequence is, they asked you to help Eleven determine her new name.
|
The first and only line of input contains an integer *n* (1<=≤<=*n*<=≤<=1000).
|
Print Eleven's new name on the first and only line of output.
|
[
"8\n",
"15\n"
] |
[
"OOOoOooO\n",
"OOOoOooOooooOoo\n"
] |
none
| 500
|
[
{
"input": "8",
"output": "OOOoOooO"
},
{
"input": "15",
"output": "OOOoOooOooooOoo"
},
{
"input": "85",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooo"
},
{
"input": "381",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooo"
},
{
"input": "805",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1000",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "1",
"output": "O"
},
{
"input": "2",
"output": "OO"
},
{
"input": "3",
"output": "OOO"
},
{
"input": "5",
"output": "OOOoO"
},
{
"input": "17",
"output": "OOOoOooOooooOoooo"
},
{
"input": "49",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooo"
},
{
"input": "256",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooo"
},
{
"input": "512",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "933",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "61",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooo"
},
{
"input": "781",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
},
{
"input": "999",
"output": "OOOoOooOooooOoooooooOooooooooooooOooooooooooooooooooooOoooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooOooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooOoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo..."
}
] | 1,564,727,773
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 1
| 124
| 0
|
print("OOOoOooO")
|
Title: Eleven
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Eleven wants to choose a new name for herself. As a bunch of geeks, her friends suggested an algorithm to choose a name for her. Eleven wants her name to have exactly *n* characters.
Her friend suggested that her name should only consist of uppercase and lowercase letters 'O'. More precisely, they suggested that the *i*-th letter of her name should be 'O' (uppercase) if *i* is a member of Fibonacci sequence, and 'o' (lowercase) otherwise. The letters in the name are numbered from 1 to *n*. Fibonacci sequence is the sequence *f* where
- *f*1<==<=1, - *f*2<==<=1, - *f**n*<==<=*f**n*<=-<=2<=+<=*f**n*<=-<=1 (*n*<=><=2).
As her friends are too young to know what Fibonacci sequence is, they asked you to help Eleven determine her new name.
Input Specification:
The first and only line of input contains an integer *n* (1<=≤<=*n*<=≤<=1000).
Output Specification:
Print Eleven's new name on the first and only line of output.
Demo Input:
['8\n', '15\n']
Demo Output:
['OOOoOooO\n', 'OOOoOooOooooOoo\n']
Note:
none
|
```python
print("OOOoOooO")
```
| 0
|
|
907
|
A
|
Masha and Bears
|
PROGRAMMING
| 1,300
|
[
"brute force",
"implementation"
] | null | null |
A family consisting of father bear, mother bear and son bear owns three cars. Father bear can climb into the largest car and he likes it. Also, mother bear can climb into the middle car and she likes it. Moreover, son bear can climb into the smallest car and he likes it. It's known that the largest car is strictly larger than the middle car, and the middle car is strictly larger than the smallest car.
Masha came to test these cars. She could climb into all cars, but she liked only the smallest car.
It's known that a character with size *a* can climb into some car with size *b* if and only if *a*<=≤<=*b*, he or she likes it if and only if he can climb into this car and 2*a*<=≥<=*b*.
You are given sizes of bears and Masha. Find out some possible integer non-negative sizes of cars.
|
You are given four integers *V*1, *V*2, *V*3, *V**m*(1<=≤<=*V**i*<=≤<=100) — sizes of father bear, mother bear, son bear and Masha, respectively. It's guaranteed that *V*1<=><=*V*2<=><=*V*3.
|
Output three integers — sizes of father bear's car, mother bear's car and son bear's car, respectively.
If there are multiple possible solutions, print any.
If there is no solution, print "-1" (without quotes).
|
[
"50 30 10 10\n",
"100 50 10 21\n"
] |
[
"50\n30\n10\n",
"-1\n"
] |
In first test case all conditions for cars' sizes are satisfied.
In second test case there is no answer, because Masha should be able to climb into smallest car (so size of smallest car in not less than 21), but son bear should like it, so maximum possible size of it is 20.
| 500
|
[
{
"input": "50 30 10 10",
"output": "50\n30\n10"
},
{
"input": "100 50 10 21",
"output": "-1"
},
{
"input": "100 50 19 10",
"output": "100\n50\n19"
},
{
"input": "99 50 25 49",
"output": "100\n99\n49"
},
{
"input": "3 2 1 1",
"output": "4\n3\n1"
},
{
"input": "100 99 98 100",
"output": "-1"
},
{
"input": "100 40 30 40",
"output": "-1"
},
{
"input": "100 50 19 25",
"output": "100\n51\n25"
},
{
"input": "100 50 19 30",
"output": "100\n61\n30"
},
{
"input": "49 48 25 49",
"output": "-1"
},
{
"input": "48 47 23 46",
"output": "94\n93\n46"
},
{
"input": "37 23 16 20",
"output": "42\n41\n20"
},
{
"input": "98 2 1 1",
"output": "98\n3\n1"
},
{
"input": "99 22 13 14",
"output": "99\n29\n14"
},
{
"input": "97 95 3 2",
"output": "97\n95\n3"
},
{
"input": "27 3 2 3",
"output": "-1"
},
{
"input": "13 7 6 2",
"output": "-1"
},
{
"input": "19 17 11 6",
"output": "19\n17\n11"
},
{
"input": "15 6 4 5",
"output": "15\n11\n5"
},
{
"input": "21 3 1 3",
"output": "-1"
},
{
"input": "100 99 98 97",
"output": "196\n195\n98"
},
{
"input": "99 32 13 5",
"output": "-1"
},
{
"input": "5 4 3 1",
"output": "-1"
},
{
"input": "50 20 4 8",
"output": "50\n20\n8"
},
{
"input": "60 30 10 1",
"output": "-1"
},
{
"input": "100 50 10 1",
"output": "-1"
},
{
"input": "40 30 20 10",
"output": "40\n30\n20"
},
{
"input": "50 49 5 10",
"output": "50\n49\n10"
},
{
"input": "99 98 50 97",
"output": "196\n195\n97"
},
{
"input": "50 30 10 5",
"output": "50\n30\n10"
},
{
"input": "4 3 2 1",
"output": "4\n3\n2"
},
{
"input": "100 50 3 1",
"output": "-1"
}
] | 1,514,038,522
| 622
|
Python 3
|
WRONG_ANSWER
|
PRETESTS
| 3
| 46
| 5,529,600
|
a,b,c,d=map(int,input().split())
if c*2 >= d:
print(a)
print(b)
print(c)
else:
print(-1)
|
Title: Masha and Bears
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A family consisting of father bear, mother bear and son bear owns three cars. Father bear can climb into the largest car and he likes it. Also, mother bear can climb into the middle car and she likes it. Moreover, son bear can climb into the smallest car and he likes it. It's known that the largest car is strictly larger than the middle car, and the middle car is strictly larger than the smallest car.
Masha came to test these cars. She could climb into all cars, but she liked only the smallest car.
It's known that a character with size *a* can climb into some car with size *b* if and only if *a*<=≤<=*b*, he or she likes it if and only if he can climb into this car and 2*a*<=≥<=*b*.
You are given sizes of bears and Masha. Find out some possible integer non-negative sizes of cars.
Input Specification:
You are given four integers *V*1, *V*2, *V*3, *V**m*(1<=≤<=*V**i*<=≤<=100) — sizes of father bear, mother bear, son bear and Masha, respectively. It's guaranteed that *V*1<=><=*V*2<=><=*V*3.
Output Specification:
Output three integers — sizes of father bear's car, mother bear's car and son bear's car, respectively.
If there are multiple possible solutions, print any.
If there is no solution, print "-1" (without quotes).
Demo Input:
['50 30 10 10\n', '100 50 10 21\n']
Demo Output:
['50\n30\n10\n', '-1\n']
Note:
In first test case all conditions for cars' sizes are satisfied.
In second test case there is no answer, because Masha should be able to climb into smallest car (so size of smallest car in not less than 21), but son bear should like it, so maximum possible size of it is 20.
|
```python
a,b,c,d=map(int,input().split())
if c*2 >= d:
print(a)
print(b)
print(c)
else:
print(-1)
```
| 0
|
|
570
|
A
|
Elections
|
PROGRAMMING
| 1,100
|
[
"implementation"
] | null | null |
The country of Byalechinsk is running elections involving *n* candidates. The country consists of *m* cities. We know how many people in each city voted for each candidate.
The electoral system in the country is pretty unusual. At the first stage of elections the votes are counted for each city: it is assumed that in each city won the candidate who got the highest number of votes in this city, and if several candidates got the maximum number of votes, then the winner is the one with a smaller index.
At the second stage of elections the winner is determined by the same principle over the cities: the winner of the elections is the candidate who won in the maximum number of cities, and among those who got the maximum number of cities the winner is the one with a smaller index.
Determine who will win the elections.
|
The first line of the input contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of candidates and of cities, respectively.
Each of the next *m* lines contains *n* non-negative integers, the *j*-th number in the *i*-th line *a**ij* (1<=≤<=*j*<=≤<=*n*, 1<=≤<=*i*<=≤<=*m*, 0<=≤<=*a**ij*<=≤<=109) denotes the number of votes for candidate *j* in city *i*.
It is guaranteed that the total number of people in all the cities does not exceed 109.
|
Print a single number — the index of the candidate who won the elections. The candidates are indexed starting from one.
|
[
"3 3\n1 2 3\n2 3 1\n1 2 1\n",
"3 4\n10 10 3\n5 1 6\n2 2 2\n1 5 7\n"
] |
[
"2",
"1"
] |
Note to the first sample test. At the first stage city 1 chosen candidate 3, city 2 chosen candidate 2, city 3 chosen candidate 2. The winner is candidate 2, he gained 2 votes.
Note to the second sample test. At the first stage in city 1 candidates 1 and 2 got the same maximum number of votes, but candidate 1 has a smaller index, so the city chose candidate 1. City 2 chosen candidate 3. City 3 chosen candidate 1, due to the fact that everyone has the same number of votes, and 1 has the smallest index. City 4 chosen the candidate 3. On the second stage the same number of cities chose candidates 1 and 3. The winner is candidate 1, the one with the smaller index.
| 500
|
[
{
"input": "3 3\n1 2 3\n2 3 1\n1 2 1",
"output": "2"
},
{
"input": "3 4\n10 10 3\n5 1 6\n2 2 2\n1 5 7",
"output": "1"
},
{
"input": "1 3\n5\n3\n2",
"output": "1"
},
{
"input": "3 1\n1 2 3",
"output": "3"
},
{
"input": "3 1\n100 100 100",
"output": "1"
},
{
"input": "2 2\n1 2\n2 1",
"output": "1"
},
{
"input": "2 2\n2 1\n2 1",
"output": "1"
},
{
"input": "2 2\n1 2\n1 2",
"output": "2"
},
{
"input": "3 3\n0 0 0\n1 1 1\n2 2 2",
"output": "1"
},
{
"input": "1 1\n1000000000",
"output": "1"
},
{
"input": "5 5\n1 2 3 4 5\n2 3 4 5 6\n3 4 5 6 7\n4 5 6 7 8\n5 6 7 8 9",
"output": "5"
},
{
"input": "4 4\n1 3 1 3\n3 1 3 1\n2 0 0 2\n0 1 1 0",
"output": "1"
},
{
"input": "4 4\n1 4 1 3\n3 1 2 1\n1 0 0 2\n0 1 10 0",
"output": "1"
},
{
"input": "4 4\n1 4 1 300\n3 1 2 1\n5 0 0 2\n0 1 10 100",
"output": "1"
},
{
"input": "5 5\n15 45 15 300 10\n53 15 25 51 10\n5 50 50 2 10\n1000 1 10 100 10\n10 10 10 10 10",
"output": "1"
},
{
"input": "1 100\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1",
"output": "1"
},
{
"input": "100 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "1"
},
{
"input": "1 100\n859\n441\n272\n47\n355\n345\n612\n569\n545\n599\n410\n31\n720\n303\n58\n537\n561\n730\n288\n275\n446\n955\n195\n282\n153\n455\n996\n121\n267\n702\n769\n560\n353\n89\n990\n282\n801\n335\n573\n258\n722\n768\n324\n41\n249\n125\n557\n303\n664\n945\n156\n884\n985\n816\n433\n65\n976\n963\n85\n647\n46\n877\n665\n523\n714\n182\n377\n549\n994\n385\n184\n724\n447\n99\n766\n353\n494\n747\n324\n436\n915\n472\n879\n582\n928\n84\n627\n156\n972\n651\n159\n372\n70\n903\n590\n480\n184\n540\n270\n892",
"output": "1"
},
{
"input": "100 1\n439 158 619 538 187 153 973 781 610 475 94 947 449 531 220 51 788 118 189 501 54 434 465 902 280 635 688 214 737 327 682 690 683 519 261 923 254 388 529 659 662 276 376 735 976 664 521 285 42 147 187 259 407 977 879 465 522 17 550 701 114 921 577 265 668 812 232 267 135 371 586 201 608 373 771 358 101 412 195 582 199 758 507 882 16 484 11 712 916 699 783 618 405 124 904 257 606 610 230 718",
"output": "54"
},
{
"input": "1 99\n511\n642\n251\n30\n494\n128\n189\n324\n884\n656\n120\n616\n959\n328\n411\n933\n895\n350\n1\n838\n996\n761\n619\n131\n824\n751\n707\n688\n915\n115\n244\n476\n293\n986\n29\n787\n607\n259\n756\n864\n394\n465\n303\n387\n521\n582\n485\n355\n299\n997\n683\n472\n424\n948\n339\n383\n285\n957\n591\n203\n866\n79\n835\n980\n344\n493\n361\n159\n160\n947\n46\n362\n63\n553\n793\n754\n429\n494\n523\n227\n805\n313\n409\n243\n927\n350\n479\n971\n825\n460\n544\n235\n660\n327\n216\n729\n147\n671\n738",
"output": "1"
},
{
"input": "99 1\n50 287 266 159 551 198 689 418 809 43 691 367 160 664 86 805 461 55 127 950 576 351 721 493 972 560 934 885 492 92 321 759 767 989 883 7 127 413 404 604 80 645 666 874 371 718 893 158 722 198 563 293 134 255 742 913 252 378 859 721 502 251 839 284 133 209 962 514 773 124 205 903 785 859 911 93 861 786 747 213 690 69 942 697 211 203 284 961 351 137 962 952 408 249 238 850 944 40 346",
"output": "34"
},
{
"input": "100 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2",
"output": "100"
},
{
"input": "1 1\n0",
"output": "1"
},
{
"input": "2 1\n0 0",
"output": "1"
},
{
"input": "2 2\n0 0\n0 0",
"output": "1"
},
{
"input": "2 2\n1 2\n0 0",
"output": "1"
},
{
"input": "3 3\n0 0 0\n0 0 0\n0 0 0",
"output": "1"
},
{
"input": "2 3\n0 0\n0 0\n0 1",
"output": "1"
},
{
"input": "3 2\n1 1 3\n0 0 0",
"output": "1"
},
{
"input": "3 4\n1 10 3\n0 0 0\n0 0 0\n0 0 0",
"output": "1"
},
{
"input": "2 4\n2 1\n1 2\n0 0\n1 2",
"output": "1"
},
{
"input": "2 2\n0 1\n0 1",
"output": "2"
},
{
"input": "2 3\n1 2\n0 0\n2 1",
"output": "1"
},
{
"input": "2 2\n0 0\n4 5",
"output": "1"
},
{
"input": "3 2\n10 15 20\n0 0 0",
"output": "1"
},
{
"input": "3 4\n0 0 0\n0 0 0\n0 0 0\n1 2 3",
"output": "1"
},
{
"input": "3 3\n0 0 0\n0 0 0\n0 0 1",
"output": "1"
},
{
"input": "3 3\n0 0 0\n1 2 3\n1 3 2",
"output": "1"
},
{
"input": "3 1\n0 0 0",
"output": "1"
},
{
"input": "3 3\n0 0 1\n0 0 0\n0 0 0",
"output": "1"
}
] | 1,589,379,013
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 30
| 155
| 21,811,200
|
n,m = map(int,input().split())
ct = [0 for i in range(n)]
a = []
for i in range(m):
a.append(list(map(int,input().split())))
for i in range(m):
w = -1
maxx = 0
for j in range(n):
if(a[i][j] > maxx):
maxx = a[i][j]
w = j
ct[w] += 1
w = -1
maxx = 0
for i in range(n):
if(ct[i] > maxx):
maxx = ct[i]
w = i
print(w+1)
|
Title: Elections
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The country of Byalechinsk is running elections involving *n* candidates. The country consists of *m* cities. We know how many people in each city voted for each candidate.
The electoral system in the country is pretty unusual. At the first stage of elections the votes are counted for each city: it is assumed that in each city won the candidate who got the highest number of votes in this city, and if several candidates got the maximum number of votes, then the winner is the one with a smaller index.
At the second stage of elections the winner is determined by the same principle over the cities: the winner of the elections is the candidate who won in the maximum number of cities, and among those who got the maximum number of cities the winner is the one with a smaller index.
Determine who will win the elections.
Input Specification:
The first line of the input contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of candidates and of cities, respectively.
Each of the next *m* lines contains *n* non-negative integers, the *j*-th number in the *i*-th line *a**ij* (1<=≤<=*j*<=≤<=*n*, 1<=≤<=*i*<=≤<=*m*, 0<=≤<=*a**ij*<=≤<=109) denotes the number of votes for candidate *j* in city *i*.
It is guaranteed that the total number of people in all the cities does not exceed 109.
Output Specification:
Print a single number — the index of the candidate who won the elections. The candidates are indexed starting from one.
Demo Input:
['3 3\n1 2 3\n2 3 1\n1 2 1\n', '3 4\n10 10 3\n5 1 6\n2 2 2\n1 5 7\n']
Demo Output:
['2', '1']
Note:
Note to the first sample test. At the first stage city 1 chosen candidate 3, city 2 chosen candidate 2, city 3 chosen candidate 2. The winner is candidate 2, he gained 2 votes.
Note to the second sample test. At the first stage in city 1 candidates 1 and 2 got the same maximum number of votes, but candidate 1 has a smaller index, so the city chose candidate 1. City 2 chosen candidate 3. City 3 chosen candidate 1, due to the fact that everyone has the same number of votes, and 1 has the smallest index. City 4 chosen the candidate 3. On the second stage the same number of cities chose candidates 1 and 3. The winner is candidate 1, the one with the smaller index.
|
```python
n,m = map(int,input().split())
ct = [0 for i in range(n)]
a = []
for i in range(m):
a.append(list(map(int,input().split())))
for i in range(m):
w = -1
maxx = 0
for j in range(n):
if(a[i][j] > maxx):
maxx = a[i][j]
w = j
ct[w] += 1
w = -1
maxx = 0
for i in range(n):
if(ct[i] > maxx):
maxx = ct[i]
w = i
print(w+1)
```
| 0
|
|
41
|
A
|
Translation
|
PROGRAMMING
| 800
|
[
"implementation",
"strings"
] |
A. Translation
|
2
|
256
|
The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc. However, it's easy to make a mistake during the «translation». Vasya translated word *s* from Berlandish into Birlandish as *t*. Help him: find out if he translated the word correctly.
|
The first line contains word *s*, the second line contains word *t*. The words consist of lowercase Latin letters. The input data do not consist unnecessary spaces. The words are not empty and their lengths do not exceed 100 symbols.
|
If the word *t* is a word *s*, written reversely, print YES, otherwise print NO.
|
[
"code\nedoc\n",
"abb\naba\n",
"code\ncode\n"
] |
[
"YES\n",
"NO\n",
"NO\n"
] |
none
| 500
|
[
{
"input": "code\nedoc",
"output": "YES"
},
{
"input": "abb\naba",
"output": "NO"
},
{
"input": "code\ncode",
"output": "NO"
},
{
"input": "abacaba\nabacaba",
"output": "YES"
},
{
"input": "q\nq",
"output": "YES"
},
{
"input": "asrgdfngfnmfgnhweratgjkk\nasrgdfngfnmfgnhweratgjkk",
"output": "NO"
},
{
"input": "z\na",
"output": "NO"
},
{
"input": "asd\ndsa",
"output": "YES"
},
{
"input": "abcdef\nfecdba",
"output": "NO"
},
{
"input": "ywjjbirapvskozubvxoemscfwl\ngnduubaogtfaiowjizlvjcu",
"output": "NO"
},
{
"input": "mfrmqxtzvgaeuleubcmcxcfqyruwzenguhgrmkuhdgnhgtgkdszwqyd\nmfxufheiperjnhyczclkmzyhcxntdfskzkzdwzzujdinf",
"output": "NO"
},
{
"input": "bnbnemvybqizywlnghlykniaxxxlkhftppbdeqpesrtgkcpoeqowjwhrylpsziiwcldodcoonpimudvrxejjo\ntiynnekmlalogyvrgptbinkoqdwzuiyjlrldxhzjmmp",
"output": "NO"
},
{
"input": "pwlpubwyhzqvcitemnhvvwkmwcaawjvdiwtoxyhbhbxerlypelevasmelpfqwjk\nstruuzebbcenziscuoecywugxncdwzyfozhljjyizpqcgkyonyetarcpwkqhuugsqjuixsxptmbnlfupdcfigacdhhrzb",
"output": "NO"
},
{
"input": "gdvqjoyxnkypfvdxssgrihnwxkeojmnpdeobpecytkbdwujqfjtxsqspxvxpqioyfagzjxupqqzpgnpnpxcuipweunqch\nkkqkiwwasbhezqcfeceyngcyuogrkhqecwsyerdniqiocjehrpkljiljophqhyaiefjpavoom",
"output": "NO"
},
{
"input": "umeszdawsvgkjhlqwzents\nhxqhdungbylhnikwviuh",
"output": "NO"
},
{
"input": "juotpscvyfmgntshcealgbsrwwksgrwnrrbyaqqsxdlzhkbugdyx\nibqvffmfktyipgiopznsqtrtxiijntdbgyy",
"output": "NO"
},
{
"input": "zbwueheveouatecaglziqmudxemhrsozmaujrwlqmppzoumxhamwugedikvkblvmxwuofmpafdprbcftew\nulczwrqhctbtbxrhhodwbcxwimncnexosksujlisgclllxokrsbnozthajnnlilyffmsyko",
"output": "NO"
},
{
"input": "nkgwuugukzcv\nqktnpxedwxpxkrxdvgmfgoxkdfpbzvwsduyiybynbkouonhvmzakeiruhfmvrktghadbfkmwxduoqv",
"output": "NO"
},
{
"input": "incenvizhqpcenhjhehvjvgbsnfixbatrrjstxjzhlmdmxijztphxbrldlqwdfimweepkggzcxsrwelodpnryntepioqpvk\ndhjbjjftlvnxibkklxquwmzhjfvnmwpapdrslioxisbyhhfymyiaqhlgecpxamqnocizwxniubrmpyubvpenoukhcobkdojlybxd",
"output": "NO"
},
{
"input": "w\nw",
"output": "YES"
},
{
"input": "vz\nzv",
"output": "YES"
},
{
"input": "ry\nyr",
"output": "YES"
},
{
"input": "xou\nuox",
"output": "YES"
},
{
"input": "axg\ngax",
"output": "NO"
},
{
"input": "zdsl\nlsdz",
"output": "YES"
},
{
"input": "kudl\nldku",
"output": "NO"
},
{
"input": "zzlzwnqlcl\nlclqnwzlzz",
"output": "YES"
},
{
"input": "vzzgicnzqooejpjzads\nsdazjpjeooqzncigzzv",
"output": "YES"
},
{
"input": "raqhmvmzuwaykjpyxsykr\nxkysrypjkyawuzmvmhqar",
"output": "NO"
},
{
"input": "ngedczubzdcqbxksnxuavdjaqtmdwncjnoaicvmodcqvhfezew\nwezefhvqcdomvciaonjcnwdmtqajdvauxnskxbqcdzbuzcdegn",
"output": "YES"
},
{
"input": "muooqttvrrljcxbroizkymuidvfmhhsjtumksdkcbwwpfqdyvxtrlymofendqvznzlmim\nmimlznzvqdnefomylrtxvydqfpwwbckdskmutjshhmfvdiumykziorbxcjlrrvttqooum",
"output": "YES"
},
{
"input": "vxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaivg\ngviayyikkitmuomcpiakhbxszgbnhvwyzkftwoagzixaearxpjacrnvpvbuzenvovehkmmxvblqyxvctroddksdsgebcmlluqpxv",
"output": "YES"
},
{
"input": "mnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfdc\ncdfmkdgrdptkpewbsqvszipgxvgvuiuzbkkwuowbafkikgvnqdkxnayzdjygvezmtsgywnupocdntipiyiorblqkrzjpzatxahnm",
"output": "NO"
},
{
"input": "dgxmzbqofstzcdgthbaewbwocowvhqpinehpjatnnbrijcolvsatbblsrxabzrpszoiecpwhfjmwuhqrapvtcgvikuxtzbftydkw\nwkdytfbztxukivgctvparqhuwmjfhwpceiozsprzbaxrslbbqasvlocjirbnntajphenipthvwocowbweabhtgdcztsfoqbzmxgd",
"output": "NO"
},
{
"input": "gxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwgeh\nhegwxvocotmzstqfbmpjvijgkcyodlxyjawrpkczpmdspsuhoiruavnnnuwvtwohglkdxjetshkboalvzqbgjgthoteceixioxg",
"output": "YES"
},
{
"input": "sihxuwvmaambplxvjfoskinghzicyfqebjtkysotattkahssumfcgrkheotdxwjckpvapbkaepqrxseyfrwtyaycmrzsrsngkh\nhkgnsrszrmcyaytwrfyesxrqpeakbpavpkcjwxdtoehkrgcfmusshakttatosyktjbeqfycizhgniksofjvxlpbmaamvwuxhis",
"output": "YES"
},
{
"input": "ycnahksbughnonldzrhkysujmylcgcfuludjvjiahtkyzqvkopzqcnwhltbzfugzojqkjjlggmvnultascmygelkiktmfieok\nkoeifmtkiklegkmcsatlunvmggkjjlqjozgufzbtlhwncqzpokvqzykthaijvjdulufcgclymjusyyhrzdlnonhgubskhancy",
"output": "NO"
},
{
"input": "wbqasaehtkfojruzyhrlgwmtyiovmzyfifslvlemhqheyaelzwnthrenjsbmntwaoryzwfbxmscmypvxlfmzpnkkjlvwvmtz\nztmvwvljkknpzmflxvpymcsmxbfwzyroawtnmbsjnerhtnwzleayehqhmelvlsfifyzmvoiytmwglrhyzurjofktheasaqbw",
"output": "YES"
},
{
"input": "imippqurprbhfugngtgifelytadegwrgaefnfhbjjnmzikvjaccotqzemufqieqldgnbmviisgkynzeldlhqxuqphjfmyij\njiymfjhpquxqhldleznykgsiivmbngdlqeiqfumezqtoccajvkizmnjjbhfnfeagrwgedatylefigtgngufhbrpruqppimi",
"output": "YES"
},
{
"input": "bikydffiuisckpvzqlteqfhegsagimodb\nbdomigasgehfqetlqzvpkcsiuiffdykib",
"output": "YES"
}
] | 1,610,535,185
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 40
| 186
| 0
|
s = input()
t = input()
print(["NO", "YES"][s == t[::-1]])
|
Title: Translation
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc. However, it's easy to make a mistake during the «translation». Vasya translated word *s* from Berlandish into Birlandish as *t*. Help him: find out if he translated the word correctly.
Input Specification:
The first line contains word *s*, the second line contains word *t*. The words consist of lowercase Latin letters. The input data do not consist unnecessary spaces. The words are not empty and their lengths do not exceed 100 symbols.
Output Specification:
If the word *t* is a word *s*, written reversely, print YES, otherwise print NO.
Demo Input:
['code\nedoc\n', 'abb\naba\n', 'code\ncode\n']
Demo Output:
['YES\n', 'NO\n', 'NO\n']
Note:
none
|
```python
s = input()
t = input()
print(["NO", "YES"][s == t[::-1]])
```
| 3.9535
|
870
|
A
|
Search for Pretty Integers
|
PROGRAMMING
| 900
|
[
"brute force",
"implementation"
] | null | null |
You are given two lists of non-zero digits.
Let's call an integer pretty if its (base 10) representation has at least one digit from the first list and at least one digit from the second list. What is the smallest positive pretty integer?
|
The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=9) — the lengths of the first and the second lists, respectively.
The second line contains *n* distinct digits *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=9) — the elements of the first list.
The third line contains *m* distinct digits *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**i*<=≤<=9) — the elements of the second list.
|
Print the smallest pretty integer.
|
[
"2 3\n4 2\n5 7 6\n",
"8 8\n1 2 3 4 5 6 7 8\n8 7 6 5 4 3 2 1\n"
] |
[
"25\n",
"1\n"
] |
In the first example 25, 46, 24567 are pretty, as well as many other integers. The smallest among them is 25. 42 and 24 are not pretty because they don't have digits from the second list.
In the second example all integers that have at least one digit different from 9 are pretty. It's obvious that the smallest among them is 1, because it's the smallest positive integer.
| 500
|
[
{
"input": "2 3\n4 2\n5 7 6",
"output": "25"
},
{
"input": "8 8\n1 2 3 4 5 6 7 8\n8 7 6 5 4 3 2 1",
"output": "1"
},
{
"input": "1 1\n9\n1",
"output": "19"
},
{
"input": "9 1\n5 4 2 3 6 1 7 9 8\n9",
"output": "9"
},
{
"input": "5 3\n7 2 5 8 6\n3 1 9",
"output": "12"
},
{
"input": "4 5\n5 2 6 4\n8 9 1 3 7",
"output": "12"
},
{
"input": "5 9\n4 2 1 6 7\n2 3 4 5 6 7 8 9 1",
"output": "1"
},
{
"input": "9 9\n5 4 3 2 1 6 7 8 9\n3 2 1 5 4 7 8 9 6",
"output": "1"
},
{
"input": "9 5\n2 3 4 5 6 7 8 9 1\n4 2 1 6 7",
"output": "1"
},
{
"input": "9 9\n1 2 3 4 5 6 7 8 9\n1 2 3 4 5 6 7 8 9",
"output": "1"
},
{
"input": "9 9\n1 2 3 4 5 6 7 8 9\n9 8 7 6 5 4 3 2 1",
"output": "1"
},
{
"input": "9 9\n9 8 7 6 5 4 3 2 1\n1 2 3 4 5 6 7 8 9",
"output": "1"
},
{
"input": "9 9\n9 8 7 6 5 4 3 2 1\n9 8 7 6 5 4 3 2 1",
"output": "1"
},
{
"input": "1 1\n8\n9",
"output": "89"
},
{
"input": "1 1\n9\n8",
"output": "89"
},
{
"input": "1 1\n1\n2",
"output": "12"
},
{
"input": "1 1\n2\n1",
"output": "12"
},
{
"input": "1 1\n9\n9",
"output": "9"
},
{
"input": "1 1\n1\n1",
"output": "1"
},
{
"input": "4 5\n3 2 4 5\n1 6 5 9 8",
"output": "5"
},
{
"input": "3 2\n4 5 6\n1 5",
"output": "5"
},
{
"input": "5 4\n1 3 5 6 7\n2 4 3 9",
"output": "3"
},
{
"input": "5 5\n1 3 5 7 9\n2 4 6 8 9",
"output": "9"
},
{
"input": "2 2\n1 8\n2 8",
"output": "8"
},
{
"input": "5 5\n5 6 7 8 9\n1 2 3 4 5",
"output": "5"
},
{
"input": "5 5\n1 2 3 4 5\n1 2 3 4 5",
"output": "1"
},
{
"input": "5 5\n1 2 3 4 5\n2 3 4 5 6",
"output": "2"
},
{
"input": "2 2\n1 5\n2 5",
"output": "5"
},
{
"input": "4 4\n1 3 5 8\n2 4 6 8",
"output": "8"
},
{
"input": "3 3\n1 5 3\n2 5 7",
"output": "5"
},
{
"input": "3 3\n3 6 8\n2 6 9",
"output": "6"
},
{
"input": "2 2\n1 4\n2 4",
"output": "4"
},
{
"input": "5 3\n3 4 5 6 7\n1 5 9",
"output": "5"
},
{
"input": "4 4\n1 2 3 4\n2 5 6 7",
"output": "2"
},
{
"input": "5 5\n1 2 3 4 5\n9 2 1 7 5",
"output": "1"
},
{
"input": "2 2\n1 3\n2 3",
"output": "3"
},
{
"input": "3 3\n3 2 1\n3 2 1",
"output": "1"
},
{
"input": "3 3\n1 3 5\n2 3 6",
"output": "3"
},
{
"input": "3 3\n5 6 7\n5 6 7",
"output": "5"
},
{
"input": "1 2\n5\n2 5",
"output": "5"
},
{
"input": "3 3\n2 4 9\n7 8 9",
"output": "9"
},
{
"input": "3 3\n1 2 4\n3 4 5",
"output": "4"
},
{
"input": "3 2\n1 4 9\n2 4",
"output": "4"
},
{
"input": "3 3\n3 5 6\n1 5 9",
"output": "5"
},
{
"input": "3 2\n1 2 4\n3 4",
"output": "4"
},
{
"input": "2 4\n8 9\n1 2 3 9",
"output": "9"
},
{
"input": "1 2\n9\n8 9",
"output": "9"
},
{
"input": "3 2\n1 2 4\n4 2",
"output": "2"
},
{
"input": "2 3\n4 5\n1 3 5",
"output": "5"
},
{
"input": "3 2\n1 2 3\n2 3",
"output": "2"
},
{
"input": "4 3\n1 3 5 9\n2 8 9",
"output": "9"
},
{
"input": "2 2\n1 9\n9 2",
"output": "9"
}
] | 1,690,508,641
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 52
| 140
| 0
|
n, m = map(int, input().split())
lista_1 = list(map(int, input().split()))
lista_2 = list(map(int, input().split()))
lista = lista_1 + lista_2
lista.sort()
igual = False
dic = {}
for elemento in lista:
if elemento in dic:
dic[elemento] += 1
print(elemento)
igual = True
break
else:
dic[elemento] = 1
if not igual:
print(f"{min(min(lista_1), min(lista_2))}{max(min(lista_1), min(lista_2))}")
|
Title: Search for Pretty Integers
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given two lists of non-zero digits.
Let's call an integer pretty if its (base 10) representation has at least one digit from the first list and at least one digit from the second list. What is the smallest positive pretty integer?
Input Specification:
The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=9) — the lengths of the first and the second lists, respectively.
The second line contains *n* distinct digits *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=9) — the elements of the first list.
The third line contains *m* distinct digits *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**i*<=≤<=9) — the elements of the second list.
Output Specification:
Print the smallest pretty integer.
Demo Input:
['2 3\n4 2\n5 7 6\n', '8 8\n1 2 3 4 5 6 7 8\n8 7 6 5 4 3 2 1\n']
Demo Output:
['25\n', '1\n']
Note:
In the first example 25, 46, 24567 are pretty, as well as many other integers. The smallest among them is 25. 42 and 24 are not pretty because they don't have digits from the second list.
In the second example all integers that have at least one digit different from 9 are pretty. It's obvious that the smallest among them is 1, because it's the smallest positive integer.
|
```python
n, m = map(int, input().split())
lista_1 = list(map(int, input().split()))
lista_2 = list(map(int, input().split()))
lista = lista_1 + lista_2
lista.sort()
igual = False
dic = {}
for elemento in lista:
if elemento in dic:
dic[elemento] += 1
print(elemento)
igual = True
break
else:
dic[elemento] = 1
if not igual:
print(f"{min(min(lista_1), min(lista_2))}{max(min(lista_1), min(lista_2))}")
```
| 3
|
|
69
|
A
|
Young Physicist
|
PROGRAMMING
| 1,000
|
[
"implementation",
"math"
] |
A. Young Physicist
|
2
|
256
|
A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. "Piece of cake" — thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces.
|
The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100), then follow *n* lines containing three integers each: the *x**i* coordinate, the *y**i* coordinate and the *z**i* coordinate of the force vector, applied to the body (<=-<=100<=≤<=*x**i*,<=*y**i*,<=*z**i*<=≤<=100).
|
Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not.
|
[
"3\n4 1 7\n-2 4 -1\n1 -5 -3\n",
"3\n3 -1 7\n-5 2 -4\n2 -1 -3\n"
] |
[
"NO",
"YES"
] |
none
| 500
|
[
{
"input": "3\n4 1 7\n-2 4 -1\n1 -5 -3",
"output": "NO"
},
{
"input": "3\n3 -1 7\n-5 2 -4\n2 -1 -3",
"output": "YES"
},
{
"input": "10\n21 32 -46\n43 -35 21\n42 2 -50\n22 40 20\n-27 -9 38\n-4 1 1\n-40 6 -31\n-13 -2 34\n-21 34 -12\n-32 -29 41",
"output": "NO"
},
{
"input": "10\n25 -33 43\n-27 -42 28\n-35 -20 19\n41 -42 -1\n49 -39 -4\n-49 -22 7\n-19 29 41\n8 -27 -43\n8 34 9\n-11 -3 33",
"output": "NO"
},
{
"input": "10\n-6 21 18\n20 -11 -8\n37 -11 41\n-5 8 33\n29 23 32\n30 -33 -11\n39 -49 -36\n28 34 -49\n22 29 -34\n-18 -6 7",
"output": "NO"
},
{
"input": "10\n47 -2 -27\n0 26 -14\n5 -12 33\n2 18 3\n45 -30 -49\n4 -18 8\n-46 -44 -41\n-22 -10 -40\n-35 -21 26\n33 20 38",
"output": "NO"
},
{
"input": "13\n-3 -36 -46\n-11 -50 37\n42 -11 -15\n9 42 44\n-29 -12 24\n3 9 -40\n-35 13 50\n14 43 18\n-13 8 24\n-48 -15 10\n50 9 -50\n21 0 -50\n0 0 -6",
"output": "YES"
},
{
"input": "14\n43 23 17\n4 17 44\n5 -5 -16\n-43 -7 -6\n47 -48 12\n50 47 -45\n2 14 43\n37 -30 15\n4 -17 -11\n17 9 -45\n-50 -3 -8\n-50 0 0\n-50 0 0\n-16 0 0",
"output": "YES"
},
{
"input": "13\n29 49 -11\n38 -11 -20\n25 1 -40\n-11 28 11\n23 -19 1\n45 -41 -17\n-3 0 -19\n-13 -33 49\n-30 0 28\n34 17 45\n-50 9 -27\n-50 0 0\n-37 0 0",
"output": "YES"
},
{
"input": "12\n3 28 -35\n-32 -44 -17\n9 -25 -6\n-42 -22 20\n-19 15 38\n-21 38 48\n-1 -37 -28\n-10 -13 -50\n-5 21 29\n34 28 50\n50 11 -49\n34 0 0",
"output": "YES"
},
{
"input": "37\n-64 -79 26\n-22 59 93\n-5 39 -12\n77 -9 76\n55 -86 57\n83 100 -97\n-70 94 84\n-14 46 -94\n26 72 35\n14 78 -62\n17 82 92\n-57 11 91\n23 15 92\n-80 -1 1\n12 39 18\n-23 -99 -75\n-34 50 19\n-39 84 -7\n45 -30 -39\n-60 49 37\n45 -16 -72\n33 -51 -56\n-48 28 5\n97 91 88\n45 -82 -11\n-21 -15 -90\n-53 73 -26\n-74 85 -90\n-40 23 38\n100 -13 49\n32 -100 -100\n0 -100 -70\n0 -100 0\n0 -100 0\n0 -100 0\n0 -100 0\n0 -37 0",
"output": "YES"
},
{
"input": "4\n68 3 100\n68 21 -100\n-100 -24 0\n-36 0 0",
"output": "YES"
},
{
"input": "33\n-1 -46 -12\n45 -16 -21\n-11 45 -21\n-60 -42 -93\n-22 -45 93\n37 96 85\n-76 26 83\n-4 9 55\n7 -52 -9\n66 8 -85\n-100 -54 11\n-29 59 74\n-24 12 2\n-56 81 85\n-92 69 -52\n-26 -97 91\n54 59 -51\n58 21 -57\n7 68 56\n-47 -20 -51\n-59 77 -13\n-85 27 91\n79 60 -56\n66 -80 5\n21 -99 42\n-31 -29 98\n66 93 76\n-49 45 61\n100 -100 -100\n100 -100 -100\n66 -75 -100\n0 0 -100\n0 0 -87",
"output": "YES"
},
{
"input": "3\n1 2 3\n3 2 1\n0 0 0",
"output": "NO"
},
{
"input": "2\n5 -23 12\n0 0 0",
"output": "NO"
},
{
"input": "1\n0 0 0",
"output": "YES"
},
{
"input": "1\n1 -2 0",
"output": "NO"
},
{
"input": "2\n-23 77 -86\n23 -77 86",
"output": "YES"
},
{
"input": "26\n86 7 20\n-57 -64 39\n-45 6 -93\n-44 -21 100\n-11 -49 21\n73 -71 -80\n-2 -89 56\n-65 -2 7\n5 14 84\n57 41 13\n-12 69 54\n40 -25 27\n-17 -59 0\n64 -91 -30\n-53 9 42\n-54 -8 14\n-35 82 27\n-48 -59 -80\n88 70 79\n94 57 97\n44 63 25\n84 -90 -40\n-100 100 -100\n-92 100 -100\n0 10 -100\n0 0 -82",
"output": "YES"
},
{
"input": "42\n11 27 92\n-18 -56 -57\n1 71 81\n33 -92 30\n82 83 49\n-87 -61 -1\n-49 45 49\n73 26 15\n-22 22 -77\n29 -93 87\n-68 44 -90\n-4 -84 20\n85 67 -6\n-39 26 77\n-28 -64 20\n65 -97 24\n-72 -39 51\n35 -75 -91\n39 -44 -8\n-25 -27 -57\n91 8 -46\n-98 -94 56\n94 -60 59\n-9 -95 18\n-53 -37 98\n-8 -94 -84\n-52 55 60\n15 -14 37\n65 -43 -25\n94 12 66\n-8 -19 -83\n29 81 -78\n-58 57 33\n24 86 -84\n-53 32 -88\n-14 7 3\n89 97 -53\n-5 -28 -91\n-100 100 -6\n-84 100 0\n0 100 0\n0 70 0",
"output": "YES"
},
{
"input": "3\n96 49 -12\n2 -66 28\n-98 17 -16",
"output": "YES"
},
{
"input": "5\n70 -46 86\n-100 94 24\n-27 63 -63\n57 -100 -47\n0 -11 0",
"output": "YES"
},
{
"input": "18\n-86 -28 70\n-31 -89 42\n31 -48 -55\n95 -17 -43\n24 -95 -85\n-21 -14 31\n68 -18 81\n13 31 60\n-15 28 99\n-42 15 9\n28 -61 -62\n-16 71 29\n-28 75 -48\n-77 -67 36\n-100 83 89\n100 100 -100\n57 34 -100\n0 0 -53",
"output": "YES"
},
{
"input": "44\n52 -54 -29\n-82 -5 -94\n-54 43 43\n91 16 71\n7 80 -91\n3 15 29\n-99 -6 -77\n-3 -77 -64\n73 67 34\n25 -10 -18\n-29 91 63\n-72 86 -16\n-68 85 -81\n-3 36 44\n-74 -14 -80\n34 -96 -97\n-76 -78 -33\n-24 44 -58\n98 12 77\n95 -63 -6\n-51 3 -90\n-92 -10 72\n7 3 -68\n57 -53 71\n29 57 -48\n35 -60 10\n79 -70 -61\n-20 77 55\n-86 -15 -35\n84 -88 -18\n100 -42 77\n-20 46 8\n-41 -43 -65\n38 -98 -23\n-100 65 45\n-7 -91 -63\n46 88 -85\n48 59 100\n0 0 100\n0 0 100\n0 0 100\n0 0 100\n0 0 100\n0 0 1",
"output": "YES"
},
{
"input": "18\n-14 -64 -91\n-8 -66 -86\n-23 92 -40\n6 -3 -53\n57 41 78\n-79 42 -22\n-88 -17 45\n4 -45 44\n83 -18 -25\n34 86 -92\n75 -30 12\n44 99 11\n-67 -13 72\n22 83 -56\n-37 71 72\n-9 -100 100\n0 -100 31\n0 -58 0",
"output": "YES"
},
{
"input": "23\n-70 37 78\n42 84 6\n28 -94 -24\n-49 76 95\n-67 18 84\n-53 78 -5\n65 -63 -64\n-66 -64 -69\n81 -93 95\n10 52 -79\n-89 -61 -64\n-64 -47 43\n-81 -35 55\n80 82 73\n-60 -81 -18\n49 -10 -19\n-58 70 12\n-24 -15 -93\n98 -93 -54\n-28 -75 11\n100 100 -63\n100 100 0\n56 34 0",
"output": "YES"
},
{
"input": "3\n0 2 -2\n1 -1 3\n-3 0 0",
"output": "NO"
}
] | 1,680,002,453
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 80
| 92
| 0
|
n=int(input())
x,y,z = 0,0,0
for i in range(n):
a,b,c = map(int, input().split())
x+=a;y+=b;z+=c
if (x+y+z == 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())
x,y,z = 0,0,0
for i in range(n):
a,b,c = map(int, input().split())
x+=a;y+=b;z+=c
if (x+y+z == 0):
print("YES")
else:
print("NO")
```
| 0
|
617
|
A
|
Elephant
|
PROGRAMMING
| 800
|
[
"math"
] | null | null |
An elephant decided to visit his friend. It turned out that the elephant's house is located at point 0 and his friend's house is located at point *x*(*x*<=><=0) of the coordinate line. In one step the elephant can move 1, 2, 3, 4 or 5 positions forward. Determine, what is the minimum number of steps he need to make in order to get to his friend's house.
|
The first line of the input contains an integer *x* (1<=≤<=*x*<=≤<=1<=000<=000) — The coordinate of the friend's house.
|
Print the minimum number of steps that elephant needs to make to get from point 0 to point *x*.
|
[
"5\n",
"12\n"
] |
[
"1\n",
"3\n"
] |
In the first sample the elephant needs to make one step of length 5 to reach the point *x*.
In the second sample the elephant can get to point *x* if he moves by 3, 5 and 4. There are other ways to get the optimal answer but the elephant cannot reach *x* in less than three moves.
| 500
|
[
{
"input": "5",
"output": "1"
},
{
"input": "12",
"output": "3"
},
{
"input": "999999",
"output": "200000"
},
{
"input": "41",
"output": "9"
},
{
"input": "1000000",
"output": "200000"
},
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "1"
},
{
"input": "3",
"output": "1"
},
{
"input": "4",
"output": "1"
},
{
"input": "534204",
"output": "106841"
},
{
"input": "469569",
"output": "93914"
},
{
"input": "502877",
"output": "100576"
},
{
"input": "942212",
"output": "188443"
},
{
"input": "97",
"output": "20"
},
{
"input": "53",
"output": "11"
},
{
"input": "89",
"output": "18"
},
{
"input": "574",
"output": "115"
},
{
"input": "716",
"output": "144"
},
{
"input": "729",
"output": "146"
},
{
"input": "8901",
"output": "1781"
},
{
"input": "3645",
"output": "729"
},
{
"input": "4426",
"output": "886"
},
{
"input": "46573",
"output": "9315"
},
{
"input": "86380",
"output": "17276"
},
{
"input": "94190",
"output": "18838"
},
{
"input": "999990",
"output": "199998"
},
{
"input": "999991",
"output": "199999"
},
{
"input": "999992",
"output": "199999"
},
{
"input": "999993",
"output": "199999"
},
{
"input": "999994",
"output": "199999"
},
{
"input": "999995",
"output": "199999"
},
{
"input": "999996",
"output": "200000"
},
{
"input": "999997",
"output": "200000"
},
{
"input": "999998",
"output": "200000"
}
] | 1,694,243,393
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 4
| 30
| 0
|
x = int(input())
if x <= 5:
print(1)
else:
print((x // 5) + 1)
|
Title: Elephant
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
An elephant decided to visit his friend. It turned out that the elephant's house is located at point 0 and his friend's house is located at point *x*(*x*<=><=0) of the coordinate line. In one step the elephant can move 1, 2, 3, 4 or 5 positions forward. Determine, what is the minimum number of steps he need to make in order to get to his friend's house.
Input Specification:
The first line of the input contains an integer *x* (1<=≤<=*x*<=≤<=1<=000<=000) — The coordinate of the friend's house.
Output Specification:
Print the minimum number of steps that elephant needs to make to get from point 0 to point *x*.
Demo Input:
['5\n', '12\n']
Demo Output:
['1\n', '3\n']
Note:
In the first sample the elephant needs to make one step of length 5 to reach the point *x*.
In the second sample the elephant can get to point *x* if he moves by 3, 5 and 4. There are other ways to get the optimal answer but the elephant cannot reach *x* in less than three moves.
|
```python
x = int(input())
if x <= 5:
print(1)
else:
print((x // 5) + 1)
```
| 0
|
|
258
|
A
|
Little Elephant and Bits
|
PROGRAMMING
| 1,100
|
[
"greedy",
"math"
] | null | null |
The Little Elephant has an integer *a*, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number *a* fits on the piece of paper, the Little Elephant ought to delete exactly one any digit from number *a* in the binary record. At that a new number appears. It consists of the remaining binary digits, written in the corresponding order (possible, with leading zeroes).
The Little Elephant wants the number he is going to write on the paper to be as large as possible. Help him find the maximum number that he can obtain after deleting exactly one binary digit and print it in the binary notation.
|
The single line contains integer *a*, written in the binary notation without leading zeroes. This number contains more than 1 and at most 105 digits.
|
In the single line print the number that is written without leading zeroes in the binary notation — the answer to the problem.
|
[
"101\n",
"110010\n"
] |
[
"11\n",
"11010\n"
] |
In the first sample the best strategy is to delete the second digit. That results in number 11<sub class="lower-index">2</sub> = 3<sub class="lower-index">10</sub>.
In the second sample the best strategy is to delete the third or fourth digits — that results in number 11010<sub class="lower-index">2</sub> = 26<sub class="lower-index">10</sub>.
| 500
|
[
{
"input": "101",
"output": "11"
},
{
"input": "110010",
"output": "11010"
},
{
"input": "10000",
"output": "1000"
},
{
"input": "1111111110",
"output": "111111111"
},
{
"input": "10100101011110101",
"output": "1100101011110101"
},
{
"input": "111010010111",
"output": "11110010111"
},
{
"input": "11110111011100000000",
"output": "1111111011100000000"
},
{
"input": "11110010010100001110110101110011110110100111101",
"output": "1111010010100001110110101110011110110100111101"
},
{
"input": "1001011111010010100111111",
"output": "101011111010010100111111"
},
{
"input": "1111111111",
"output": "111111111"
},
{
"input": "1111111111111111111100111101001110110111111000001111110101001101001110011000001011001111111000110101",
"output": "111111111111111111110111101001110110111111000001111110101001101001110011000001011001111111000110101"
},
{
"input": "11010110000100100101111110111001001010011000011011000010010100111010101000111010011101101111110001111000101000001100011101110100",
"output": "1110110000100100101111110111001001010011000011011000010010100111010101000111010011101101111110001111000101000001100011101110100"
},
{
"input": "11111111111111111111111110110111001101100111010010101101101001011100011011000111010011110010101100010001011101011010010100001000011100001101101001100010100001001010010100100001111110100110011000101100001111111011010111001011111110111101000100101001001011",
"output": "1111111111111111111111111110111001101100111010010101101101001011100011011000111010011110010101100010001011101011010010100001000011100001101101001100010100001001010010100100001111110100110011000101100001111111011010111001011111110111101000100101001001011"
},
{
"input": "11100010010010000110101101101100111111001010001101101001001111010110010111001011010000001100110101000101111000001111101111110010000010101110011110101101010110001100011101111011100010011101100111110010111111100110101000000111101000000000110100100101111101000110101010101101001110001110000101011010101100011100100111100010001011010010001100011111110010011010011000111000100111100010110100011010010101011011011111110100001110000011011",
"output": "1110010010010000110101101101100111111001010001101101001001111010110010111001011010000001100110101000101111000001111101111110010000010101110011110101101010110001100011101111011100010011101100111110010111111100110101000000111101000000000110100100101111101000110101010101101001110001110000101011010101100011100100111100010001011010010001100011111110010011010011000111000100111100010110100011010010101011011011111110100001110000011011"
},
{
"input": "11",
"output": "1"
},
{
"input": "111",
"output": "11"
},
{
"input": "111111",
"output": "11111"
},
{
"input": "11111",
"output": "1111"
},
{
"input": "1111",
"output": "111"
}
] | 1,585,985,337
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 37
| 404
| 1,843,200
|
a=input()
a=list(a)
if '0' in a:
i=a.index('0')
a.pop(i)
else:
a.pop(1)
print(*a,sep="")
|
Title: Little Elephant and Bits
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Little Elephant has an integer *a*, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number *a* fits on the piece of paper, the Little Elephant ought to delete exactly one any digit from number *a* in the binary record. At that a new number appears. It consists of the remaining binary digits, written in the corresponding order (possible, with leading zeroes).
The Little Elephant wants the number he is going to write on the paper to be as large as possible. Help him find the maximum number that he can obtain after deleting exactly one binary digit and print it in the binary notation.
Input Specification:
The single line contains integer *a*, written in the binary notation without leading zeroes. This number contains more than 1 and at most 105 digits.
Output Specification:
In the single line print the number that is written without leading zeroes in the binary notation — the answer to the problem.
Demo Input:
['101\n', '110010\n']
Demo Output:
['11\n', '11010\n']
Note:
In the first sample the best strategy is to delete the second digit. That results in number 11<sub class="lower-index">2</sub> = 3<sub class="lower-index">10</sub>.
In the second sample the best strategy is to delete the third or fourth digits — that results in number 11010<sub class="lower-index">2</sub> = 26<sub class="lower-index">10</sub>.
|
```python
a=input()
a=list(a)
if '0' in a:
i=a.index('0')
a.pop(i)
else:
a.pop(1)
print(*a,sep="")
```
| 3
|
|
319
|
C
|
Kalila and Dimna in the Logging Industry
|
PROGRAMMING
| 2,100
|
[
"dp",
"geometry"
] | null | null |
Kalila and Dimna are two jackals living in a huge jungle. One day they decided to join a logging factory in order to make money.
The manager of logging factory wants them to go to the jungle and cut *n* trees with heights *a*1,<=*a*2,<=...,<=*a**n*. They bought a chain saw from a shop. Each time they use the chain saw on the tree number *i*, they can decrease the height of this tree by one unit. Each time that Kalila and Dimna use the chain saw, they need to recharge it. Cost of charging depends on the id of the trees which have been cut completely (a tree is cut completely if its height equal to 0). If the maximum id of a tree which has been cut completely is *i* (the tree that have height *a**i* in the beginning), then the cost of charging the chain saw would be *b**i*. If no tree is cut completely, Kalila and Dimna cannot charge the chain saw. The chainsaw is charged in the beginning. We know that for each *i* < *j*, *a**i*<=<<=*a**j* and *b**i*<=><=*b**j* and also *b**n*<==<=0 and *a*1<==<=1. Kalila and Dimna want to cut all the trees completely, with minimum cost.
They want you to help them! Will you?
|
The first line of input contains an integer *n* (1<=≤<=*n*<=≤<=105). The second line of input contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109). The third line of input contains *n* integers *b*1,<=*b*2,<=...,<=*b**n* (0<=≤<=*b**i*<=≤<=109).
It's guaranteed that *a*1<==<=1, *b**n*<==<=0, *a*1<=<<=*a*2<=<<=...<=<<=*a**n* and *b*1<=><=*b*2<=><=...<=><=*b**n*.
|
The only line of output must contain the minimum cost of cutting all the trees completely.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
|
[
"5\n1 2 3 4 5\n5 4 3 2 0\n",
"6\n1 2 3 10 20 30\n6 5 4 3 2 0\n"
] |
[
"25\n",
"138\n"
] |
none
| 1,500
|
[
{
"input": "5\n1 2 3 4 5\n5 4 3 2 0",
"output": "25"
},
{
"input": "6\n1 2 3 10 20 30\n6 5 4 3 2 0",
"output": "138"
}
] | 1,582,848,827
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 4
| 358
| 14,950,400
|
def cross(i, j, k, b, cost):
return (cost[i] - cost[j]) * (b[i] - b[k]) - (b[i] - b[j]) * (cost[i] - cost[k])
def dot(i, j, a, b, cost):
return cost[j] + a[i] * b[j]
def CF319C():
N = int(input())
a = tuple(map(int, input().split()))
b = tuple(map(int, input().split()))
cost = [0] * N
hull = [0] * N # Make hull considering total minimum cost and charge of individual trees
left = 0
right = 0 # Index of items in hull
for i in range(1, N):
# Find the last cut tree which incurs minimum cost for ith tree
while left + 1 <= right and dot(i, hull[left], a, b, cost) >= dot(i, hull[left + 1], a, b, cost):
# Only increase left when it decreases cutting cost
left += 1
cost[i] = dot(i, hull[left], a, b, cost)
# print("Before ", hull[:right+1])
while right >= 2 and cross(hull[right], hull[right - 1], i, b, cost) >= 0:
# print("removed ", i, hull[right])
right -= 1
right += 1
hull[right] = i
return cost[-1]
if __name__ == '__main__':
res = CF319C()
print(res)
|
Title: Kalila and Dimna in the Logging Industry
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Kalila and Dimna are two jackals living in a huge jungle. One day they decided to join a logging factory in order to make money.
The manager of logging factory wants them to go to the jungle and cut *n* trees with heights *a*1,<=*a*2,<=...,<=*a**n*. They bought a chain saw from a shop. Each time they use the chain saw on the tree number *i*, they can decrease the height of this tree by one unit. Each time that Kalila and Dimna use the chain saw, they need to recharge it. Cost of charging depends on the id of the trees which have been cut completely (a tree is cut completely if its height equal to 0). If the maximum id of a tree which has been cut completely is *i* (the tree that have height *a**i* in the beginning), then the cost of charging the chain saw would be *b**i*. If no tree is cut completely, Kalila and Dimna cannot charge the chain saw. The chainsaw is charged in the beginning. We know that for each *i* < *j*, *a**i*<=<<=*a**j* and *b**i*<=><=*b**j* and also *b**n*<==<=0 and *a*1<==<=1. Kalila and Dimna want to cut all the trees completely, with minimum cost.
They want you to help them! Will you?
Input Specification:
The first line of input contains an integer *n* (1<=≤<=*n*<=≤<=105). The second line of input contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109). The third line of input contains *n* integers *b*1,<=*b*2,<=...,<=*b**n* (0<=≤<=*b**i*<=≤<=109).
It's guaranteed that *a*1<==<=1, *b**n*<==<=0, *a*1<=<<=*a*2<=<<=...<=<<=*a**n* and *b*1<=><=*b*2<=><=...<=><=*b**n*.
Output Specification:
The only line of output must contain the minimum cost of cutting all the trees completely.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Demo Input:
['5\n1 2 3 4 5\n5 4 3 2 0\n', '6\n1 2 3 10 20 30\n6 5 4 3 2 0\n']
Demo Output:
['25\n', '138\n']
Note:
none
|
```python
def cross(i, j, k, b, cost):
return (cost[i] - cost[j]) * (b[i] - b[k]) - (b[i] - b[j]) * (cost[i] - cost[k])
def dot(i, j, a, b, cost):
return cost[j] + a[i] * b[j]
def CF319C():
N = int(input())
a = tuple(map(int, input().split()))
b = tuple(map(int, input().split()))
cost = [0] * N
hull = [0] * N # Make hull considering total minimum cost and charge of individual trees
left = 0
right = 0 # Index of items in hull
for i in range(1, N):
# Find the last cut tree which incurs minimum cost for ith tree
while left + 1 <= right and dot(i, hull[left], a, b, cost) >= dot(i, hull[left + 1], a, b, cost):
# Only increase left when it decreases cutting cost
left += 1
cost[i] = dot(i, hull[left], a, b, cost)
# print("Before ", hull[:right+1])
while right >= 2 and cross(hull[right], hull[right - 1], i, b, cost) >= 0:
# print("removed ", i, hull[right])
right -= 1
right += 1
hull[right] = i
return cost[-1]
if __name__ == '__main__':
res = CF319C()
print(res)
```
| 0
|
|
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,618,459,868
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 19
| 124
| 0
|
p=int(input())
ls=list(map(int,input().split()))
if(sum(ls)>=p):
for i in range(len(ls)):
p=p-ls[i]
if(p<=0):
print(i+1)
break
else:
p=p%sum(ls)
for i in range(len(ls)):
p=p-ls[i]
if(p<=0):
print(i+1)
break
|
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
p=int(input())
ls=list(map(int,input().split()))
if(sum(ls)>=p):
for i in range(len(ls)):
p=p-ls[i]
if(p<=0):
print(i+1)
break
else:
p=p%sum(ls)
for i in range(len(ls)):
p=p-ls[i]
if(p<=0):
print(i+1)
break
```
| 0
|
|
281
|
A
|
Word Capitalization
|
PROGRAMMING
| 800
|
[
"implementation",
"strings"
] | null | null |
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
|
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
|
Output the given word after capitalization.
|
[
"ApPLe\n",
"konjac\n"
] |
[
"ApPLe\n",
"Konjac\n"
] |
none
| 500
|
[
{
"input": "ApPLe",
"output": "ApPLe"
},
{
"input": "konjac",
"output": "Konjac"
},
{
"input": "a",
"output": "A"
},
{
"input": "A",
"output": "A"
},
{
"input": "z",
"output": "Z"
},
{
"input": "ABACABA",
"output": "ABACABA"
},
{
"input": "xYaPxPxHxGePfGtQySlNrLxSjDtNnTaRaEpAhPaQpWnDzMqGgRgEwJxGiBdZnMtHxFbObCaGiCeZkUqIgBhHtNvAqAlHpMnQhNeQbMyZrCdElVwHtKrPpJjIaHuIlYwHaRkAkUpPlOhNlBtXwDsKzPyHrPiUwNlXtTaPuMwTqYtJySgFoXvLiHbQwMjSvXsQfKhVlOxGdQkWjBhEyQvBjPoFkThNeRhTuIzFjInJtEfPjOlOsJpJuLgLzFnZmKvFgFrNsOnVqFcNiMfCqTpKnVyLwNqFiTySpWeTdFnWuTwDkRjVxNyQvTrOoEiExYiFaIrLoFmJfZcDkHuWjYfCeEqCvEsZiWnJaEmFbMjDvYwEeJeGcKbVbChGsIzNlExHzHiTlHcSaKxLuZxX",
"output": "XYaPxPxHxGePfGtQySlNrLxSjDtNnTaRaEpAhPaQpWnDzMqGgRgEwJxGiBdZnMtHxFbObCaGiCeZkUqIgBhHtNvAqAlHpMnQhNeQbMyZrCdElVwHtKrPpJjIaHuIlYwHaRkAkUpPlOhNlBtXwDsKzPyHrPiUwNlXtTaPuMwTqYtJySgFoXvLiHbQwMjSvXsQfKhVlOxGdQkWjBhEyQvBjPoFkThNeRhTuIzFjInJtEfPjOlOsJpJuLgLzFnZmKvFgFrNsOnVqFcNiMfCqTpKnVyLwNqFiTySpWeTdFnWuTwDkRjVxNyQvTrOoEiExYiFaIrLoFmJfZcDkHuWjYfCeEqCvEsZiWnJaEmFbMjDvYwEeJeGcKbVbChGsIzNlExHzHiTlHcSaKxLuZxX"
},
{
"input": "rZhIcQlXpNcPgXrOjTiOlMoTgXgIhCfMwZfWoFzGhEkQlOoMjIuShPlZfWkNnMyQfYdUhVgQuSmYoElEtZpDyHtOxXgCpWbZqSbYnPqBcNqRtPgCnJnAyIvNsAhRbNeVlMwZyRyJnFgIsCnSbOdLvUyIeOzQvRpMoMoHfNhHwKvTcHuYnYySfPmAiNwAiWdZnWlLvGfBbRbRrCrBqIgIdWkWiBsNyYkKdNxZdGaToSsDnXpRaGrKxBpQsCzBdQgZzBkGeHgGxNrIyQlSzWsTmSnZwOcHqQpNcQvJlPvKaPiQaMaYsQjUeCqQdCjPgUbDmWiJmNiXgExLqOcCtSwSePnUxIuZfIfBeWbEiVbXnUsPwWyAiXyRbZgKwOqFfCtQuKxEmVeRlAkOeXkO",
"output": "RZhIcQlXpNcPgXrOjTiOlMoTgXgIhCfMwZfWoFzGhEkQlOoMjIuShPlZfWkNnMyQfYdUhVgQuSmYoElEtZpDyHtOxXgCpWbZqSbYnPqBcNqRtPgCnJnAyIvNsAhRbNeVlMwZyRyJnFgIsCnSbOdLvUyIeOzQvRpMoMoHfNhHwKvTcHuYnYySfPmAiNwAiWdZnWlLvGfBbRbRrCrBqIgIdWkWiBsNyYkKdNxZdGaToSsDnXpRaGrKxBpQsCzBdQgZzBkGeHgGxNrIyQlSzWsTmSnZwOcHqQpNcQvJlPvKaPiQaMaYsQjUeCqQdCjPgUbDmWiJmNiXgExLqOcCtSwSePnUxIuZfIfBeWbEiVbXnUsPwWyAiXyRbZgKwOqFfCtQuKxEmVeRlAkOeXkO"
},
{
"input": "hDgZlUmLhYbLkLcNcKeOwJwTePbOvLaRvNzQbSbLsPeHqLhUqWtUbNdQfQqFfXeJqJwWuOrFnDdZiPxIkDyVmHbHvXfIlFqSgAcSyWbOlSlRuPhWdEpEzEeLnXwCtWuVcHaUeRgCiYsIvOaIgDnFuDbRnMoCmPrZfLeFpSjQaTfHgZwZvAzDuSeNwSoWuJvLqKqAuUxFaCxFfRcEjEsJpOfCtDiVrBqNsNwPuGoRgPzRpLpYnNyQxKaNnDnYiJrCrVcHlOxPiPcDbEgKfLwBjLhKcNeMgJhJmOiJvPfOaPaEuGqWvRbErKrIpDkEoQnKwJnTlStLyNsHyOjZfKoIjXwUvRrWpSyYhRpQdLqGmErAiNcGqAqIrTeTiMuPmCrEkHdBrLyCxPtYpRqD",
"output": "HDgZlUmLhYbLkLcNcKeOwJwTePbOvLaRvNzQbSbLsPeHqLhUqWtUbNdQfQqFfXeJqJwWuOrFnDdZiPxIkDyVmHbHvXfIlFqSgAcSyWbOlSlRuPhWdEpEzEeLnXwCtWuVcHaUeRgCiYsIvOaIgDnFuDbRnMoCmPrZfLeFpSjQaTfHgZwZvAzDuSeNwSoWuJvLqKqAuUxFaCxFfRcEjEsJpOfCtDiVrBqNsNwPuGoRgPzRpLpYnNyQxKaNnDnYiJrCrVcHlOxPiPcDbEgKfLwBjLhKcNeMgJhJmOiJvPfOaPaEuGqWvRbErKrIpDkEoQnKwJnTlStLyNsHyOjZfKoIjXwUvRrWpSyYhRpQdLqGmErAiNcGqAqIrTeTiMuPmCrEkHdBrLyCxPtYpRqD"
},
{
"input": "qUdLgGrJeGmIzIeZrCjUtBpYfRvNdXdRpGsThIsEmJjTiMqEwRxBeBaSxEuWrNvExKePjPnXhPzBpWnHiDhTvZhBuIjDnZpTcEkCvRkAcTmMuXhGgErWgFyGyToOyVwYlCuQpTfJkVdWmFyBqQhJjYtXrBbFdHzDlGsFbHmHbFgXgFhIyDhZyEqEiEwNxSeByBwLiVeSnCxIdHbGjOjJrZeVkOzGeMmQrJkVyGhDtCzOlPeAzGrBlWwEnAdUfVaIjNrRyJjCnHkUvFuKuKeKbLzSbEmUcXtVkZzXzKlOrPgQiDmCcCvIyAdBwOeUuLbRmScNcWxIkOkJuIsBxTrIqXhDzLcYdVtPgZdZfAxTmUtByGiTsJkSySjXdJvEwNmSmNoWsChPdAzJrBoW",
"output": "QUdLgGrJeGmIzIeZrCjUtBpYfRvNdXdRpGsThIsEmJjTiMqEwRxBeBaSxEuWrNvExKePjPnXhPzBpWnHiDhTvZhBuIjDnZpTcEkCvRkAcTmMuXhGgErWgFyGyToOyVwYlCuQpTfJkVdWmFyBqQhJjYtXrBbFdHzDlGsFbHmHbFgXgFhIyDhZyEqEiEwNxSeByBwLiVeSnCxIdHbGjOjJrZeVkOzGeMmQrJkVyGhDtCzOlPeAzGrBlWwEnAdUfVaIjNrRyJjCnHkUvFuKuKeKbLzSbEmUcXtVkZzXzKlOrPgQiDmCcCvIyAdBwOeUuLbRmScNcWxIkOkJuIsBxTrIqXhDzLcYdVtPgZdZfAxTmUtByGiTsJkSySjXdJvEwNmSmNoWsChPdAzJrBoW"
},
{
"input": "kHbApGoBcLmIwUlXkVgUmWzYeLoDbGaOkWbIuXoRwMfKuOoMzAoXrBoTvYxGrMbRjDuRxAbGsTnErIiHnHoLeRnTbFiRfDdOkNlWiAcOsChLdLqFqXlDpDoDtPxXqAmSvYgPvOcCpOlWtOjYwFkGkHuCaHwZcFdOfHjBmIxTeSiHkWjXyFcCtOlSuJsZkDxUgPeZkJwMmNpErUlBcGuMlJwKkWnOzFeFiSiPsEvMmQiCsYeHlLuHoMgBjFoZkXlObDkSoQcVyReTmRsFzRhTuIvCeBqVsQdQyTyZjStGrTyDcEcAgTgMiIcVkLbZbGvWeHtXwEqWkXfTcPyHhHjYwIeVxLyVmHmMkUsGiHmNnQuMsXaFyPpVqNrBhOiWmNkBbQuHvQdOjPjKiZcL",
"output": "KHbApGoBcLmIwUlXkVgUmWzYeLoDbGaOkWbIuXoRwMfKuOoMzAoXrBoTvYxGrMbRjDuRxAbGsTnErIiHnHoLeRnTbFiRfDdOkNlWiAcOsChLdLqFqXlDpDoDtPxXqAmSvYgPvOcCpOlWtOjYwFkGkHuCaHwZcFdOfHjBmIxTeSiHkWjXyFcCtOlSuJsZkDxUgPeZkJwMmNpErUlBcGuMlJwKkWnOzFeFiSiPsEvMmQiCsYeHlLuHoMgBjFoZkXlObDkSoQcVyReTmRsFzRhTuIvCeBqVsQdQyTyZjStGrTyDcEcAgTgMiIcVkLbZbGvWeHtXwEqWkXfTcPyHhHjYwIeVxLyVmHmMkUsGiHmNnQuMsXaFyPpVqNrBhOiWmNkBbQuHvQdOjPjKiZcL"
},
{
"input": "aHmRbLgNuWkLxLnWvUbYwTeZeYiOlLhTuOvKfLnVmCiPcMkSgVrYjZiLuRjCiXhAnVzVcTlVeJdBvPdDfFvHkTuIhCdBjEsXbVmGcLrPfNvRdFsZkSdNpYsJeIhIcNqSoLkOjUlYlDmXsOxPbQtIoUxFjGnRtBhFaJvBeEzHsAtVoQbAfYjJqReBiKeUwRqYrUjPjBoHkOkPzDwEwUgTxQxAvKzUpMhKyOhPmEhYhItQwPeKsKaKlUhGuMcTtSwFtXfJsDsFlTtOjVvVfGtBtFlQyIcBaMsPaJlPqUcUvLmReZiFbXxVtRhTzJkLkAjVqTyVuFeKlTyQgUzMsXjOxQnVfTaWmThEnEoIhZeZdStBkKeLpAhJnFoJvQyGwDiStLjEwGfZwBuWsEfC",
"output": "AHmRbLgNuWkLxLnWvUbYwTeZeYiOlLhTuOvKfLnVmCiPcMkSgVrYjZiLuRjCiXhAnVzVcTlVeJdBvPdDfFvHkTuIhCdBjEsXbVmGcLrPfNvRdFsZkSdNpYsJeIhIcNqSoLkOjUlYlDmXsOxPbQtIoUxFjGnRtBhFaJvBeEzHsAtVoQbAfYjJqReBiKeUwRqYrUjPjBoHkOkPzDwEwUgTxQxAvKzUpMhKyOhPmEhYhItQwPeKsKaKlUhGuMcTtSwFtXfJsDsFlTtOjVvVfGtBtFlQyIcBaMsPaJlPqUcUvLmReZiFbXxVtRhTzJkLkAjVqTyVuFeKlTyQgUzMsXjOxQnVfTaWmThEnEoIhZeZdStBkKeLpAhJnFoJvQyGwDiStLjEwGfZwBuWsEfC"
},
{
"input": "sLlZkDiDmEdNaXuUuJwHqYvRtOdGfTiTpEpAoSqAbJaChOiCvHgSwZwEuPkMmXiLcKdXqSsEyViEbZpZsHeZpTuXoGcRmOiQfBfApPjDqSqElWeSeOhUyWjLyNoRuYeGfGwNqUsQoTyVvWeNgNdZfDxGwGfLsDjIdInSqDlMuNvFaHbScZkTlVwNcJpEjMaPaOtFgJjBjOcLlLmDnQrShIrJhOcUmPnZhTxNeClQsZaEaVaReLyQpLwEqJpUwYhLiRzCzKfOoFeTiXzPiNbOsZaZaLgCiNnMkBcFwGgAwPeNyTxJcCtBgXcToKlWaWcBaIvBpNxPeClQlWeQqRyEtAkJdBtSrFdDvAbUlKyLdCuTtXxFvRcKnYnWzVdYqDeCmOqPxUaFjQdTdCtN",
"output": "SLlZkDiDmEdNaXuUuJwHqYvRtOdGfTiTpEpAoSqAbJaChOiCvHgSwZwEuPkMmXiLcKdXqSsEyViEbZpZsHeZpTuXoGcRmOiQfBfApPjDqSqElWeSeOhUyWjLyNoRuYeGfGwNqUsQoTyVvWeNgNdZfDxGwGfLsDjIdInSqDlMuNvFaHbScZkTlVwNcJpEjMaPaOtFgJjBjOcLlLmDnQrShIrJhOcUmPnZhTxNeClQsZaEaVaReLyQpLwEqJpUwYhLiRzCzKfOoFeTiXzPiNbOsZaZaLgCiNnMkBcFwGgAwPeNyTxJcCtBgXcToKlWaWcBaIvBpNxPeClQlWeQqRyEtAkJdBtSrFdDvAbUlKyLdCuTtXxFvRcKnYnWzVdYqDeCmOqPxUaFjQdTdCtN"
},
{
"input": "iRuStKvVhJdJbQwRoIuLiVdTpKaOqKfYlYwAzIpPtUwUtMeKyCaOlXmVrKwWeImYmVuXdLkRlHwFxKqZbZtTzNgOzDbGqTfZnKmUzAcIjDcEmQgYyFbEfWzRpKvCkDmAqDiIiRcLvMxWaJqCgYqXgIcLdNaZlBnXtJyKaMnEaWfXfXwTbDnAiYnWqKbAtDpYdUbZrCzWgRnHzYxFgCdDbOkAgTqBuLqMeStHcDxGnVhSgMzVeTaZoTfLjMxQfRuPcFqVlRyYdHyOdJsDoCeWrUuJyIiAqHwHyVpEeEoMaJwAoUfPtBeJqGhMaHiBjKwAlXoZpUsDhHgMxBkVbLcEvNtJbGnPsUwAvXrAkTlXwYvEnOpNeWyIkRnEnTrIyAcLkRgMyYcKrGiDaAyE",
"output": "IRuStKvVhJdJbQwRoIuLiVdTpKaOqKfYlYwAzIpPtUwUtMeKyCaOlXmVrKwWeImYmVuXdLkRlHwFxKqZbZtTzNgOzDbGqTfZnKmUzAcIjDcEmQgYyFbEfWzRpKvCkDmAqDiIiRcLvMxWaJqCgYqXgIcLdNaZlBnXtJyKaMnEaWfXfXwTbDnAiYnWqKbAtDpYdUbZrCzWgRnHzYxFgCdDbOkAgTqBuLqMeStHcDxGnVhSgMzVeTaZoTfLjMxQfRuPcFqVlRyYdHyOdJsDoCeWrUuJyIiAqHwHyVpEeEoMaJwAoUfPtBeJqGhMaHiBjKwAlXoZpUsDhHgMxBkVbLcEvNtJbGnPsUwAvXrAkTlXwYvEnOpNeWyIkRnEnTrIyAcLkRgMyYcKrGiDaAyE"
},
{
"input": "cRtJkOxHzUbJcDdHzJtLbVmSoWuHoTkVrPqQaVmXeBrHxJbQfNrQbAaMrEhVdQnPxNyCjErKxPoEdWkVrBbDeNmEgBxYiBtWdAfHiLuSwIxJuHpSkAxPoYdNkGoLySsNhUmGoZhDzAfWhJdPlJzQkZbOnMtTkClIoCqOlIcJcMlGjUyOiEmHdYfIcPtTgQhLlLcPqQjAnQnUzHpCaQsCnYgQsBcJrQwBnWsIwFfSfGuYgTzQmShFpKqEeRlRkVfMuZbUsDoFoPrNuNwTtJqFkRiXxPvKyElDzLoUnIwAaBaOiNxMpEvPzSpGpFhMtGhGdJrFnZmNiMcUfMtBnDuUnXqDcMsNyGoLwLeNnLfRsIwRfBtXkHrFcPsLdXaAoYaDzYnZuQeVcZrElWmP",
"output": "CRtJkOxHzUbJcDdHzJtLbVmSoWuHoTkVrPqQaVmXeBrHxJbQfNrQbAaMrEhVdQnPxNyCjErKxPoEdWkVrBbDeNmEgBxYiBtWdAfHiLuSwIxJuHpSkAxPoYdNkGoLySsNhUmGoZhDzAfWhJdPlJzQkZbOnMtTkClIoCqOlIcJcMlGjUyOiEmHdYfIcPtTgQhLlLcPqQjAnQnUzHpCaQsCnYgQsBcJrQwBnWsIwFfSfGuYgTzQmShFpKqEeRlRkVfMuZbUsDoFoPrNuNwTtJqFkRiXxPvKyElDzLoUnIwAaBaOiNxMpEvPzSpGpFhMtGhGdJrFnZmNiMcUfMtBnDuUnXqDcMsNyGoLwLeNnLfRsIwRfBtXkHrFcPsLdXaAoYaDzYnZuQeVcZrElWmP"
},
{
"input": "wVaCsGxZrBbFnTbKsCoYlAvUkIpBaYpYmJkMlPwCaFvUkDxAiJgIqWsFqZlFvTtAnGzEwXbYiBdFfFxRiDoUkLmRfAwOlKeOlKgXdUnVqLkTuXtNdQpBpXtLvZxWoBeNePyHcWmZyRiUkPlRqYiQdGeXwOhHbCqVjDcEvJmBkRwWnMqPjXpUsIyXqGjHsEsDwZiFpIbTkQaUlUeFxMwJzSaHdHnDhLaLdTuYgFuJsEcMmDvXyPjKsSeBaRwNtPuOuBtNeOhQdVgKzPzOdYtPjPfDzQzHoWcYjFbSvRgGdGsCmGnQsErToBkCwGeQaCbBpYkLhHxTbUvRnJpZtXjKrHdRiUmUbSlJyGaLnWsCrJbBnSjFaZrIzIrThCmGhQcMsTtOxCuUcRaEyPaG",
"output": "WVaCsGxZrBbFnTbKsCoYlAvUkIpBaYpYmJkMlPwCaFvUkDxAiJgIqWsFqZlFvTtAnGzEwXbYiBdFfFxRiDoUkLmRfAwOlKeOlKgXdUnVqLkTuXtNdQpBpXtLvZxWoBeNePyHcWmZyRiUkPlRqYiQdGeXwOhHbCqVjDcEvJmBkRwWnMqPjXpUsIyXqGjHsEsDwZiFpIbTkQaUlUeFxMwJzSaHdHnDhLaLdTuYgFuJsEcMmDvXyPjKsSeBaRwNtPuOuBtNeOhQdVgKzPzOdYtPjPfDzQzHoWcYjFbSvRgGdGsCmGnQsErToBkCwGeQaCbBpYkLhHxTbUvRnJpZtXjKrHdRiUmUbSlJyGaLnWsCrJbBnSjFaZrIzIrThCmGhQcMsTtOxCuUcRaEyPaG"
},
{
"input": "kEiLxLmPjGzNoGkJdBlAfXhThYhMsHmZoZbGyCvNiUoLoZdAxUbGyQiEfXvPzZzJrPbEcMpHsMjIkRrVvDvQtHuKmXvGpQtXbPzJpFjJdUgWcPdFxLjLtXgVpEiFhImHnKkGiWnZbJqRjCyEwHsNbYfYfTyBaEuKlCtWnOqHmIgGrFmQiYrBnLiFcGuZxXlMfEuVoCxPkVrQvZoIpEhKsYtXrPxLcSfQqXsWaDgVlOnAzUvAhOhMrJfGtWcOwQfRjPmGhDyAeXrNqBvEiDfCiIvWxPjTwPlXpVsMjVjUnCkXgBuWnZaDyJpWkCfBrWnHxMhJgItHdRqNrQaEeRjAuUwRkUdRhEeGlSqVqGmOjNcUhFfXjCmWzBrGvIuZpRyWkWiLyUwFpYjNmNfV",
"output": "KEiLxLmPjGzNoGkJdBlAfXhThYhMsHmZoZbGyCvNiUoLoZdAxUbGyQiEfXvPzZzJrPbEcMpHsMjIkRrVvDvQtHuKmXvGpQtXbPzJpFjJdUgWcPdFxLjLtXgVpEiFhImHnKkGiWnZbJqRjCyEwHsNbYfYfTyBaEuKlCtWnOqHmIgGrFmQiYrBnLiFcGuZxXlMfEuVoCxPkVrQvZoIpEhKsYtXrPxLcSfQqXsWaDgVlOnAzUvAhOhMrJfGtWcOwQfRjPmGhDyAeXrNqBvEiDfCiIvWxPjTwPlXpVsMjVjUnCkXgBuWnZaDyJpWkCfBrWnHxMhJgItHdRqNrQaEeRjAuUwRkUdRhEeGlSqVqGmOjNcUhFfXjCmWzBrGvIuZpRyWkWiLyUwFpYjNmNfV"
},
{
"input": "eIhDoLmDeReKqXsHcVgFxUqNfScAiQnFrTlCgSuTtXiYvBxKaPaGvUeYfSgHqEaWcHxKpFaSlCxGqAmNeFcIzFcZsBiVoZhUjXaDaIcKoBzYdIlEnKfScRqSkYpPtVsVhXsBwUsUfAqRoCkBxWbHgDiCkRtPvUwVgDjOzObYwNiQwXlGnAqEkHdSqLgUkOdZiWaHqQnOhUnDhIzCiQtVcJlGoRfLuVlFjWqSuMsLgLwOdZvKtWdRuRqDoBoInKqPbJdXpIqLtFlMlDaWgSiKbFpCxOnQeNeQzXeKsBzIjCyPxCmBnYuHzQoYxZgGzSgGtZiTeQmUeWlNzZeKiJbQmEjIiDhPeSyZlNdHpZnIkPdJzSeJpPiXxToKyBjJfPwNzZpWzIzGySqPxLtI",
"output": "EIhDoLmDeReKqXsHcVgFxUqNfScAiQnFrTlCgSuTtXiYvBxKaPaGvUeYfSgHqEaWcHxKpFaSlCxGqAmNeFcIzFcZsBiVoZhUjXaDaIcKoBzYdIlEnKfScRqSkYpPtVsVhXsBwUsUfAqRoCkBxWbHgDiCkRtPvUwVgDjOzObYwNiQwXlGnAqEkHdSqLgUkOdZiWaHqQnOhUnDhIzCiQtVcJlGoRfLuVlFjWqSuMsLgLwOdZvKtWdRuRqDoBoInKqPbJdXpIqLtFlMlDaWgSiKbFpCxOnQeNeQzXeKsBzIjCyPxCmBnYuHzQoYxZgGzSgGtZiTeQmUeWlNzZeKiJbQmEjIiDhPeSyZlNdHpZnIkPdJzSeJpPiXxToKyBjJfPwNzZpWzIzGySqPxLtI"
},
{
"input": "uOoQzIeTwYeKpJtGoUdNiXbPgEwVsZkAnJcArHxIpEnEhZwQhZvAiOuLeMkVqLeDsAyKeYgFxGmRoLaRsZjAeXgNfYhBkHeDrHdPuTuYhKmDlAvYzYxCdYgYfVaYlGeVqTeSfBxQePbQrKsTaIkGzMjFrQlJuYaMxWpQkLdEcDsIiMnHnDtThRvAcKyGwBsHqKdXpJfIeTeZtYjFbMeUoXoXzGrShTwSwBpQlKeDrZdCjRqNtXoTsIzBkWbMsObTtDvYaPhUeLeHqHeMpZmTaCcIqXzAmGnPfNdDaFhOqWqDrWuFiBpRjZrQmAdViOuMbFfRyXyWfHgRkGpPnDrEqQcEmHcKpEvWlBrOtJbUaXbThJaSxCbVoGvTmHvZrHvXpCvLaYbRiHzYuQyX",
"output": "UOoQzIeTwYeKpJtGoUdNiXbPgEwVsZkAnJcArHxIpEnEhZwQhZvAiOuLeMkVqLeDsAyKeYgFxGmRoLaRsZjAeXgNfYhBkHeDrHdPuTuYhKmDlAvYzYxCdYgYfVaYlGeVqTeSfBxQePbQrKsTaIkGzMjFrQlJuYaMxWpQkLdEcDsIiMnHnDtThRvAcKyGwBsHqKdXpJfIeTeZtYjFbMeUoXoXzGrShTwSwBpQlKeDrZdCjRqNtXoTsIzBkWbMsObTtDvYaPhUeLeHqHeMpZmTaCcIqXzAmGnPfNdDaFhOqWqDrWuFiBpRjZrQmAdViOuMbFfRyXyWfHgRkGpPnDrEqQcEmHcKpEvWlBrOtJbUaXbThJaSxCbVoGvTmHvZrHvXpCvLaYbRiHzYuQyX"
},
{
"input": "lZqBqKeGvNdSeYuWxRiVnFtYbKuJwQtUcKnVtQhAlOeUzMaAuTaEnDdPfDcNyHgEoBmYjZyFePeJrRiKyAzFnBfAuGiUyLrIeLrNhBeBdVcEeKgCcBrQzDsPwGcNnZvTsEaYmFfMeOmMdNuZbUtDoQoNcGwDqEkEjIdQaPwAxJbXeNxOgKgXoEbZiIsVkRrNpNyAkLeHkNfEpLuQvEcMbIoGaDzXbEtNsLgGfOkZaFiUsOvEjVeCaMcZqMzKeAdXxJsVeCrZaFpJtZxInQxFaSmGgSsVyGeLlFgFqTpIbAvPkIfJrVcJeBxSdEvPyVwIjHpYrLrKqLnAmCuGmPoZrSbOtGaLaTmBmSuUyAmAsRiMqOtRjJhPhAfXaJnTpLbFqPmJgFcBxImTqIiJ",
"output": "LZqBqKeGvNdSeYuWxRiVnFtYbKuJwQtUcKnVtQhAlOeUzMaAuTaEnDdPfDcNyHgEoBmYjZyFePeJrRiKyAzFnBfAuGiUyLrIeLrNhBeBdVcEeKgCcBrQzDsPwGcNnZvTsEaYmFfMeOmMdNuZbUtDoQoNcGwDqEkEjIdQaPwAxJbXeNxOgKgXoEbZiIsVkRrNpNyAkLeHkNfEpLuQvEcMbIoGaDzXbEtNsLgGfOkZaFiUsOvEjVeCaMcZqMzKeAdXxJsVeCrZaFpJtZxInQxFaSmGgSsVyGeLlFgFqTpIbAvPkIfJrVcJeBxSdEvPyVwIjHpYrLrKqLnAmCuGmPoZrSbOtGaLaTmBmSuUyAmAsRiMqOtRjJhPhAfXaJnTpLbFqPmJgFcBxImTqIiJ"
},
{
"input": "P",
"output": "P"
},
{
"input": "Xyzzy",
"output": "Xyzzy"
},
{
"input": "Zzz",
"output": "Zzz"
},
{
"input": "Zp",
"output": "Zp"
}
] | 1,695,329,296
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 25
| 92
| 0
|
def uppr(string):
return string[0].upper()+string[1:]
string = input()
print(uppr(string))
|
Title: Word Capitalization
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input Specification:
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output Specification:
Output the given word after capitalization.
Demo Input:
['ApPLe\n', 'konjac\n']
Demo Output:
['ApPLe\n', 'Konjac\n']
Note:
none
|
```python
def uppr(string):
return string[0].upper()+string[1:]
string = input()
print(uppr(string))
```
| 3
|
|
922
|
A
|
Cloning Toys
|
PROGRAMMING
| 1,300
|
[
"implementation"
] | null | null |
Imp likes his plush toy a lot.
Recently, he found a machine that can clone plush toys. Imp knows that if he applies the machine to an original toy, he additionally gets one more original toy and one copy, and if he applies the machine to a copied toy, he gets two additional copies.
Initially, Imp has only one original toy. He wants to know if it is possible to use machine to get exactly *x* copied toys and *y* original toys? He can't throw toys away, and he can't apply the machine to a copy if he doesn't currently have any copies.
|
The only line contains two integers *x* and *y* (0<=≤<=*x*,<=*y*<=≤<=109) — the number of copies and the number of original toys Imp wants to get (including the initial one).
|
Print "Yes", if the desired configuration is possible, and "No" otherwise.
You can print each letter in arbitrary case (upper or lower).
|
[
"6 3\n",
"4 2\n",
"1000 1001\n"
] |
[
"Yes\n",
"No\n",
"Yes\n"
] |
In the first example, Imp has to apply the machine twice to original toys and then twice to copies.
| 500
|
[
{
"input": "6 3",
"output": "Yes"
},
{
"input": "4 2",
"output": "No"
},
{
"input": "1000 1001",
"output": "Yes"
},
{
"input": "1000000000 999999999",
"output": "Yes"
},
{
"input": "81452244 81452247",
"output": "No"
},
{
"input": "188032448 86524683",
"output": "Yes"
},
{
"input": "365289629 223844571",
"output": "No"
},
{
"input": "247579518 361164458",
"output": "No"
},
{
"input": "424836699 793451637",
"output": "No"
},
{
"input": "602093880 930771525",
"output": "No"
},
{
"input": "779351061 773124120",
"output": "Yes"
},
{
"input": "661640950 836815080",
"output": "No"
},
{
"input": "543930839 974134967",
"output": "No"
},
{
"input": "16155311 406422145",
"output": "No"
},
{
"input": "81601559 445618240",
"output": "No"
},
{
"input": "963891449 582938127",
"output": "No"
},
{
"input": "141148629 351661795",
"output": "No"
},
{
"input": "318405810 783948974",
"output": "No"
},
{
"input": "495662991 921268861",
"output": "No"
},
{
"input": "1 0",
"output": "No"
},
{
"input": "0 1",
"output": "Yes"
},
{
"input": "0 0",
"output": "No"
},
{
"input": "453462237 167520068",
"output": "Yes"
},
{
"input": "630719418 9872663",
"output": "Yes"
},
{
"input": "807976599 442159843",
"output": "No"
},
{
"input": "690266488 579479730",
"output": "No"
},
{
"input": "771581370 589752968",
"output": "No"
},
{
"input": "948838551 727072855",
"output": "No"
},
{
"input": "831128440 790763814",
"output": "No"
},
{
"input": "303352912 928083702",
"output": "No"
},
{
"input": "185642801 65403588",
"output": "Yes"
},
{
"input": "67932690 202723476",
"output": "No"
},
{
"input": "540157163 340043363",
"output": "No"
},
{
"input": "422447052 772330542",
"output": "No"
},
{
"input": "599704233 541054210",
"output": "Yes"
},
{
"input": "481994122 678374097",
"output": "No"
},
{
"input": "48564714 743566477",
"output": "No"
},
{
"input": "225821895 880886365",
"output": "No"
},
{
"input": "403079076 313173543",
"output": "Yes"
},
{
"input": "1000000000 1000000000",
"output": "No"
},
{
"input": "1 1",
"output": "No"
},
{
"input": "1 2",
"output": "Yes"
},
{
"input": "2 1",
"output": "No"
},
{
"input": "2 2",
"output": "No"
},
{
"input": "2 0",
"output": "No"
},
{
"input": "0 2",
"output": "No"
},
{
"input": "1000000000 1",
"output": "No"
},
{
"input": "777777 0",
"output": "No"
},
{
"input": "10 1",
"output": "No"
},
{
"input": "7 0",
"output": "No"
},
{
"input": "3 0",
"output": "No"
},
{
"input": "3 2",
"output": "Yes"
}
] | 1,608,828,105
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 78
| 0
|
x,y=map(int,input().split())
if (y==0)or(y==1 and x>0)or(x%2==y%2):
print(NO)
else:
print(YES)
|
Title: Cloning Toys
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Imp likes his plush toy a lot.
Recently, he found a machine that can clone plush toys. Imp knows that if he applies the machine to an original toy, he additionally gets one more original toy and one copy, and if he applies the machine to a copied toy, he gets two additional copies.
Initially, Imp has only one original toy. He wants to know if it is possible to use machine to get exactly *x* copied toys and *y* original toys? He can't throw toys away, and he can't apply the machine to a copy if he doesn't currently have any copies.
Input Specification:
The only line contains two integers *x* and *y* (0<=≤<=*x*,<=*y*<=≤<=109) — the number of copies and the number of original toys Imp wants to get (including the initial one).
Output Specification:
Print "Yes", if the desired configuration is possible, and "No" otherwise.
You can print each letter in arbitrary case (upper or lower).
Demo Input:
['6 3\n', '4 2\n', '1000 1001\n']
Demo Output:
['Yes\n', 'No\n', 'Yes\n']
Note:
In the first example, Imp has to apply the machine twice to original toys and then twice to copies.
|
```python
x,y=map(int,input().split())
if (y==0)or(y==1 and x>0)or(x%2==y%2):
print(NO)
else:
print(YES)
```
| -1
|
|
682
|
B
|
Alyona and Mex
|
PROGRAMMING
| 1,200
|
[
"sortings"
] | null | null |
Someone gave Alyona an array containing *n* positive integers *a*1,<=*a*2,<=...,<=*a**n*. In one operation, Alyona can choose any element of the array and decrease it, i.e. replace with any positive integer that is smaller than the current one. Alyona can repeat this operation as many times as she wants. In particular, she may not apply any operation to the array at all.
Formally, after applying some operations Alyona will get an array of *n* positive integers *b*1,<=*b*2,<=...,<=*b**n* such that 1<=≤<=*b**i*<=≤<=*a**i* for every 1<=≤<=*i*<=≤<=*n*. Your task is to determine the maximum possible value of mex of this array.
Mex of an array in this problem is the minimum positive integer that doesn't appear in this array. For example, mex of the array containing 1, 3 and 4 is equal to 2, while mex of the array containing 2, 3 and 2 is equal to 1.
|
The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of elements in the Alyona's array.
The second line of the input contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the elements of the array.
|
Print one positive integer — the maximum possible value of mex of the array after Alyona applies some (possibly none) operations.
|
[
"5\n1 3 3 3 6\n",
"2\n2 1\n"
] |
[
"5\n",
"3\n"
] |
In the first sample case if one will decrease the second element value to 2 and the fifth element value to 4 then the mex value of resulting array 1 2 3 3 4 will be equal to 5.
To reach the answer to the second sample case one must not decrease any of the array elements.
| 1,000
|
[
{
"input": "5\n1 3 3 3 6",
"output": "5"
},
{
"input": "2\n2 1",
"output": "3"
},
{
"input": "1\n1",
"output": "2"
},
{
"input": "1\n1000000000",
"output": "2"
},
{
"input": "1\n2",
"output": "2"
},
{
"input": "2\n1 1",
"output": "2"
},
{
"input": "2\n1 3",
"output": "3"
},
{
"input": "2\n2 2",
"output": "3"
},
{
"input": "2\n2 3",
"output": "3"
},
{
"input": "2\n3 3",
"output": "3"
},
{
"input": "3\n1 1 1",
"output": "2"
},
{
"input": "3\n2 1 1",
"output": "3"
},
{
"input": "3\n3 1 1",
"output": "3"
},
{
"input": "3\n1 1 4",
"output": "3"
},
{
"input": "3\n2 1 2",
"output": "3"
},
{
"input": "3\n3 2 1",
"output": "4"
},
{
"input": "3\n2 4 1",
"output": "4"
},
{
"input": "3\n3 3 1",
"output": "4"
},
{
"input": "3\n1 3 4",
"output": "4"
},
{
"input": "3\n4 1 4",
"output": "4"
},
{
"input": "3\n2 2 2",
"output": "3"
},
{
"input": "3\n3 2 2",
"output": "4"
},
{
"input": "3\n4 2 2",
"output": "4"
},
{
"input": "3\n2 3 3",
"output": "4"
},
{
"input": "3\n4 2 3",
"output": "4"
},
{
"input": "3\n4 4 2",
"output": "4"
},
{
"input": "3\n3 3 3",
"output": "4"
},
{
"input": "3\n4 3 3",
"output": "4"
},
{
"input": "3\n4 3 4",
"output": "4"
},
{
"input": "3\n4 4 4",
"output": "4"
},
{
"input": "4\n1 1 1 1",
"output": "2"
},
{
"input": "4\n1 1 2 1",
"output": "3"
},
{
"input": "4\n1 1 3 1",
"output": "3"
},
{
"input": "4\n1 4 1 1",
"output": "3"
},
{
"input": "4\n1 2 1 2",
"output": "3"
},
{
"input": "4\n1 3 2 1",
"output": "4"
},
{
"input": "4\n2 1 4 1",
"output": "4"
},
{
"input": "4\n3 3 1 1",
"output": "4"
},
{
"input": "4\n1 3 4 1",
"output": "4"
},
{
"input": "4\n1 1 4 4",
"output": "4"
},
{
"input": "4\n2 2 2 1",
"output": "3"
},
{
"input": "4\n1 2 2 3",
"output": "4"
},
{
"input": "4\n2 4 1 2",
"output": "4"
},
{
"input": "4\n3 3 1 2",
"output": "4"
},
{
"input": "4\n2 3 4 1",
"output": "5"
},
{
"input": "4\n1 4 2 4",
"output": "5"
},
{
"input": "4\n3 1 3 3",
"output": "4"
},
{
"input": "4\n3 4 3 1",
"output": "5"
},
{
"input": "4\n1 4 4 3",
"output": "5"
},
{
"input": "4\n4 1 4 4",
"output": "5"
},
{
"input": "4\n2 2 2 2",
"output": "3"
},
{
"input": "4\n2 2 3 2",
"output": "4"
},
{
"input": "4\n2 2 2 4",
"output": "4"
},
{
"input": "4\n2 2 3 3",
"output": "4"
},
{
"input": "4\n2 2 3 4",
"output": "5"
},
{
"input": "4\n2 4 4 2",
"output": "5"
},
{
"input": "4\n2 3 3 3",
"output": "4"
},
{
"input": "4\n2 4 3 3",
"output": "5"
},
{
"input": "4\n4 4 2 3",
"output": "5"
},
{
"input": "4\n4 4 4 2",
"output": "5"
},
{
"input": "4\n3 3 3 3",
"output": "4"
},
{
"input": "4\n3 3 3 4",
"output": "5"
},
{
"input": "4\n4 3 3 4",
"output": "5"
},
{
"input": "4\n4 4 3 4",
"output": "5"
},
{
"input": "4\n4 4 4 4",
"output": "5"
},
{
"input": "11\n1 1 1 1 1 1 1 1 1 3 3",
"output": "4"
},
{
"input": "20\n1 1 1 1 1 1 1 1 1 1 8 8 8 8 8 8 8 8 8 8",
"output": "9"
},
{
"input": "4\n2 2 2 3",
"output": "4"
},
{
"input": "3\n1 1 2",
"output": "3"
},
{
"input": "15\n1 2 2 20 23 25 28 60 66 71 76 77 79 99 100",
"output": "15"
},
{
"input": "7\n1 2 2 2 5 5 1",
"output": "5"
},
{
"input": "4\n1 1 1 2",
"output": "3"
},
{
"input": "5\n1 1 1 1 10000",
"output": "3"
},
{
"input": "5\n1 1 1 1 2",
"output": "3"
},
{
"input": "7\n1 3 3 3 3 3 6",
"output": "5"
},
{
"input": "4\n1 1 1 3",
"output": "3"
},
{
"input": "10\n1 1 1 1 1 1 1 1 1 100",
"output": "3"
},
{
"input": "4\n1 1 2 2",
"output": "3"
},
{
"input": "5\n1 1 1 3 4",
"output": "4"
},
{
"input": "8\n1 1 1 1 2 2 3 40",
"output": "5"
},
{
"input": "5\n1 1 1 1 1",
"output": "2"
},
{
"input": "7\n1 2 2 2 2 2 4",
"output": "4"
},
{
"input": "10\n1 1 1 10000000 10000000 10000000 10000000 10000000 10000000 10000000",
"output": "9"
},
{
"input": "10\n1 1 1 1 1 1 1 1 2 3",
"output": "4"
},
{
"input": "4\n8 8 8 8",
"output": "5"
},
{
"input": "5\n5 6 6 6 7",
"output": "6"
}
] | 1,546,149,585
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 127
| 234
| 8,806,400
|
n=int(input())
a=sorted([int(x) for x in input().split()])
flag=True
a[0]=1
for i in range(1,n):
if a[i]>a[i-1]:
a[i]=a[i-1]+1
for i in range(1,n):
if a[i]-a[i-1]>1:
print(a[i-1]+1)
flag=False
break
if flag:
print(a[n-1]+1)
|
Title: Alyona and Mex
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Someone gave Alyona an array containing *n* positive integers *a*1,<=*a*2,<=...,<=*a**n*. In one operation, Alyona can choose any element of the array and decrease it, i.e. replace with any positive integer that is smaller than the current one. Alyona can repeat this operation as many times as she wants. In particular, she may not apply any operation to the array at all.
Formally, after applying some operations Alyona will get an array of *n* positive integers *b*1,<=*b*2,<=...,<=*b**n* such that 1<=≤<=*b**i*<=≤<=*a**i* for every 1<=≤<=*i*<=≤<=*n*. Your task is to determine the maximum possible value of mex of this array.
Mex of an array in this problem is the minimum positive integer that doesn't appear in this array. For example, mex of the array containing 1, 3 and 4 is equal to 2, while mex of the array containing 2, 3 and 2 is equal to 1.
Input Specification:
The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of elements in the Alyona's array.
The second line of the input contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the elements of the array.
Output Specification:
Print one positive integer — the maximum possible value of mex of the array after Alyona applies some (possibly none) operations.
Demo Input:
['5\n1 3 3 3 6\n', '2\n2 1\n']
Demo Output:
['5\n', '3\n']
Note:
In the first sample case if one will decrease the second element value to 2 and the fifth element value to 4 then the mex value of resulting array 1 2 3 3 4 will be equal to 5.
To reach the answer to the second sample case one must not decrease any of the array elements.
|
```python
n=int(input())
a=sorted([int(x) for x in input().split()])
flag=True
a[0]=1
for i in range(1,n):
if a[i]>a[i-1]:
a[i]=a[i-1]+1
for i in range(1,n):
if a[i]-a[i-1]>1:
print(a[i-1]+1)
flag=False
break
if flag:
print(a[n-1]+1)
```
| 3
|
|
490
|
A
|
Team Olympiad
|
PROGRAMMING
| 800
|
[
"greedy",
"implementation",
"sortings"
] | null | null |
The School №0 of the capital of Berland has *n* children studying in it. All the children in this school are gifted: some of them are good at programming, some are good at maths, others are good at PE (Physical Education). Hence, for each child we know value *t**i*:
- *t**i*<==<=1, if the *i*-th child is good at programming, - *t**i*<==<=2, if the *i*-th child is good at maths, - *t**i*<==<=3, if the *i*-th child is good at PE
Each child happens to be good at exactly one of these three subjects.
The Team Scientific Decathlon Olympias requires teams of three students. The school teachers decided that the teams will be composed of three children that are good at different subjects. That is, each team must have one mathematician, one programmer and one sportsman. Of course, each child can be a member of no more than one team.
What is the maximum number of teams that the school will be able to present at the Olympiad? How should the teams be formed for that?
|
The first line contains integer *n* (1<=≤<=*n*<=≤<=5000) — the number of children in the school. The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=3), where *t**i* describes the skill of the *i*-th child.
|
In the first line output integer *w* — the largest possible number of teams.
Then print *w* lines, containing three numbers in each line. Each triple represents the indexes of the children forming the team. You can print both the teams, and the numbers in the triplets in any order. The children are numbered from 1 to *n* in the order of their appearance in the input. Each child must participate in no more than one team. If there are several solutions, print any of them.
If no teams can be compiled, print the only line with value *w* equal to 0.
|
[
"7\n1 3 1 3 2 1 2\n",
"4\n2 1 1 2\n"
] |
[
"2\n3 5 2\n6 7 4\n",
"0\n"
] |
none
| 500
|
[
{
"input": "7\n1 3 1 3 2 1 2",
"output": "2\n3 5 2\n6 7 4"
},
{
"input": "4\n2 1 1 2",
"output": "0"
},
{
"input": "1\n2",
"output": "0"
},
{
"input": "2\n3 1",
"output": "0"
},
{
"input": "3\n2 1 2",
"output": "0"
},
{
"input": "3\n1 2 3",
"output": "1\n1 2 3"
},
{
"input": "12\n3 3 3 3 3 3 3 3 1 3 3 2",
"output": "1\n9 12 2"
},
{
"input": "60\n3 3 1 2 2 1 3 1 1 1 3 2 2 2 3 3 1 3 2 3 2 2 1 3 3 2 3 1 2 2 2 1 3 2 1 1 3 3 1 1 1 3 1 2 1 1 3 3 3 2 3 2 3 2 2 2 1 1 1 2",
"output": "20\n6 60 1\n17 44 20\n3 5 33\n36 21 42\n59 14 2\n58 26 49\n9 29 48\n23 19 24\n10 30 37\n41 54 15\n45 31 27\n57 55 38\n39 12 25\n35 34 11\n32 52 7\n8 50 18\n43 4 53\n46 56 51\n40 22 16\n28 13 47"
},
{
"input": "12\n3 1 1 1 1 1 1 2 1 1 1 1",
"output": "1\n3 8 1"
},
{
"input": "22\n2 2 2 2 2 2 2 2 2 2 3 2 2 2 2 2 2 1 2 2 2 2",
"output": "1\n18 2 11"
},
{
"input": "138\n2 3 2 2 2 2 2 2 2 2 1 2 1 2 2 2 1 2 1 2 2 1 2 2 2 2 2 2 2 2 2 2 2 1 2 3 2 2 2 1 2 3 2 2 2 3 1 3 2 3 2 3 2 2 2 2 3 2 2 2 2 2 1 2 2 3 2 2 3 2 1 2 2 2 2 2 3 1 2 2 2 2 2 3 2 2 3 2 2 2 2 2 1 1 2 3 2 2 2 2 3 2 2 2 2 2 1 2 1 2 2 2 2 2 1 2 3 2 3 2 2 2 1 2 2 2 1 2 2 2 2 1 2 2 2 2 1 3",
"output": "18\n13 91 84\n34 90 48\n11 39 77\n78 129 50\n137 68 119\n132 122 138\n19 12 96\n40 7 2\n22 88 69\n107 73 46\n115 15 52\n127 106 87\n93 92 66\n71 112 117\n63 124 42\n17 70 101\n109 121 57\n123 25 36"
},
{
"input": "203\n2 2 1 2 1 2 2 2 1 2 2 1 1 3 1 2 1 2 1 1 2 3 1 1 2 3 3 2 2 2 1 2 1 1 1 1 1 3 1 1 2 1 1 2 2 2 1 2 2 2 1 2 3 2 1 1 2 2 1 2 1 2 2 1 1 2 2 2 1 1 2 2 1 2 1 2 2 3 2 1 2 1 1 1 1 1 1 1 1 1 1 2 2 1 1 2 2 2 2 1 1 1 1 1 1 1 2 2 2 2 2 1 1 1 2 2 2 1 2 2 1 3 2 1 1 1 2 1 1 2 1 1 2 2 2 1 1 2 2 2 1 2 1 3 2 1 2 2 2 1 1 1 2 2 2 1 2 1 1 2 2 2 2 2 1 1 2 1 2 2 1 1 1 1 1 1 2 2 3 1 1 2 3 1 1 1 1 1 1 2 2 1 1 1 2 2 3 2 1 3 1 1 1",
"output": "13\n188 72 14\n137 4 197\n158 76 122\n152 142 26\n104 119 179\n40 63 38\n12 1 78\n17 30 27\n189 60 53\n166 190 144\n129 7 183\n83 41 22\n121 81 200"
},
{
"input": "220\n1 1 3 1 3 1 1 3 1 3 3 3 3 1 3 3 1 3 3 3 3 3 1 1 1 3 1 1 1 3 2 3 3 3 1 1 3 3 1 1 3 3 3 3 1 3 3 1 1 1 2 3 1 1 1 2 3 3 3 2 3 1 1 3 1 1 1 3 2 1 3 2 3 1 1 3 3 3 1 3 1 1 1 3 3 2 1 3 2 1 1 3 3 1 1 1 2 1 1 3 2 1 2 1 1 1 3 1 3 3 1 2 3 3 3 3 1 3 1 1 1 1 2 3 1 1 1 1 1 1 3 2 3 1 3 1 3 1 1 3 1 3 1 3 1 3 1 3 3 2 3 1 3 3 1 3 3 3 3 1 1 3 3 3 3 1 1 3 3 3 2 1 1 1 3 3 1 3 3 3 1 1 1 3 1 3 3 1 1 1 2 3 1 1 3 1 1 1 1 2 3 1 1 2 3 3 1 3 1 3 3 3 3 1 3 2 3 1 1 3",
"output": "20\n198 89 20\n141 56 131\n166 204 19\n160 132 142\n111 112 195\n45 216 92\n6 31 109\n14 150 170\n199 60 18\n173 123 140\n134 69 156\n82 191 85\n126 200 80\n24 97 46\n62 86 149\n214 101 26\n79 171 78\n125 72 118\n172 103 162\n219 51 64"
},
{
"input": "61\n2 3 1 3 2 2 2 3 1 3 2 3 1 2 1 1 2 2 2 2 3 2 3 1 2 1 3 1 3 2 1 1 3 2 1 3 3 3 1 3 3 1 1 3 1 3 2 2 1 2 2 2 1 3 2 3 1 3 3 1 1",
"output": "20\n9 55 2\n24 34 27\n3 5 37\n35 17 41\n61 11 4\n60 19 54\n15 20 59\n26 14 29\n16 22 38\n43 50 12\n49 25 36\n57 51 40\n39 6 33\n32 30 10\n31 48 8\n13 47 23\n45 1 58\n53 52 56\n42 18 21\n28 7 44"
},
{
"input": "5\n1 2 2 3 3",
"output": "1\n1 3 4"
}
] | 1,684,578,713
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 5
| 61
| 307,200
|
#Q28 Team Olympiad
import collections as col
n = int(input())
lst = list(map(int,input().split(' ')))
if (1 in lst) and (2 in lst) and (3 in lst):
c = dict(col.Counter(lst))
teams = min(c.values())
print(teams)
t_lst = []
for i in range(2):
y = [1,2,3]
l = [0,0,0]
for j in range(len(lst)):
if lst[j] in y:
if len(y) == 0:
break
#1
if lst[j] == 1:
l[0] = lst.index(lst[j])+1
lst[j] = 'X'
y.pop(y.index(1))
#2
elif lst[j] == 2:
l[1] = lst.index(lst[j])+1
lst[j] = 'X'
y.pop(y.index(2))
#3
elif lst[j] == 3:
l[2] = lst.index(lst[j])+1
lst[j] = 'X'
y.pop(y.index(3))
t_lst.append(l)
for i in range(len(t_lst)):
print(*t_lst[i])
else:
print(0)
|
Title: Team Olympiad
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The School №0 of the capital of Berland has *n* children studying in it. All the children in this school are gifted: some of them are good at programming, some are good at maths, others are good at PE (Physical Education). Hence, for each child we know value *t**i*:
- *t**i*<==<=1, if the *i*-th child is good at programming, - *t**i*<==<=2, if the *i*-th child is good at maths, - *t**i*<==<=3, if the *i*-th child is good at PE
Each child happens to be good at exactly one of these three subjects.
The Team Scientific Decathlon Olympias requires teams of three students. The school teachers decided that the teams will be composed of three children that are good at different subjects. That is, each team must have one mathematician, one programmer and one sportsman. Of course, each child can be a member of no more than one team.
What is the maximum number of teams that the school will be able to present at the Olympiad? How should the teams be formed for that?
Input Specification:
The first line contains integer *n* (1<=≤<=*n*<=≤<=5000) — the number of children in the school. The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=3), where *t**i* describes the skill of the *i*-th child.
Output Specification:
In the first line output integer *w* — the largest possible number of teams.
Then print *w* lines, containing three numbers in each line. Each triple represents the indexes of the children forming the team. You can print both the teams, and the numbers in the triplets in any order. The children are numbered from 1 to *n* in the order of their appearance in the input. Each child must participate in no more than one team. If there are several solutions, print any of them.
If no teams can be compiled, print the only line with value *w* equal to 0.
Demo Input:
['7\n1 3 1 3 2 1 2\n', '4\n2 1 1 2\n']
Demo Output:
['2\n3 5 2\n6 7 4\n', '0\n']
Note:
none
|
```python
#Q28 Team Olympiad
import collections as col
n = int(input())
lst = list(map(int,input().split(' ')))
if (1 in lst) and (2 in lst) and (3 in lst):
c = dict(col.Counter(lst))
teams = min(c.values())
print(teams)
t_lst = []
for i in range(2):
y = [1,2,3]
l = [0,0,0]
for j in range(len(lst)):
if lst[j] in y:
if len(y) == 0:
break
#1
if lst[j] == 1:
l[0] = lst.index(lst[j])+1
lst[j] = 'X'
y.pop(y.index(1))
#2
elif lst[j] == 2:
l[1] = lst.index(lst[j])+1
lst[j] = 'X'
y.pop(y.index(2))
#3
elif lst[j] == 3:
l[2] = lst.index(lst[j])+1
lst[j] = 'X'
y.pop(y.index(3))
t_lst.append(l)
for i in range(len(t_lst)):
print(*t_lst[i])
else:
print(0)
```
| 0
|
|
148
|
A
|
Insomnia cure
|
PROGRAMMING
| 800
|
[
"constructive algorithms",
"implementation",
"math"
] | null | null |
«One dragon. Two dragon. Three dragon», — the princess was counting. She had trouble falling asleep, and she got bored of counting lambs when she was nine.
However, just counting dragons was boring as well, so she entertained herself at best she could. Tonight she imagined that all dragons were here to steal her, and she was fighting them off. Every *k*-th dragon got punched in the face with a frying pan. Every *l*-th dragon got his tail shut into the balcony door. Every *m*-th dragon got his paws trampled with sharp heels. Finally, she threatened every *n*-th dragon to call her mom, and he withdrew in panic.
How many imaginary dragons suffered moral or physical damage tonight, if the princess counted a total of *d* dragons?
|
Input data contains integer numbers *k*,<=*l*,<=*m*,<=*n* and *d*, each number in a separate line (1<=≤<=*k*,<=*l*,<=*m*,<=*n*<=≤<=10, 1<=≤<=*d*<=≤<=105).
|
Output the number of damaged dragons.
|
[
"1\n2\n3\n4\n12\n",
"2\n3\n4\n5\n24\n"
] |
[
"12\n",
"17\n"
] |
In the first case every first dragon got punched with a frying pan. Some of the dragons suffered from other reasons as well, but the pan alone would be enough.
In the second case dragons 1, 7, 11, 13, 17, 19 and 23 escaped unharmed.
| 1,000
|
[
{
"input": "1\n2\n3\n4\n12",
"output": "12"
},
{
"input": "2\n3\n4\n5\n24",
"output": "17"
},
{
"input": "1\n1\n1\n1\n100000",
"output": "100000"
},
{
"input": "10\n9\n8\n7\n6",
"output": "0"
},
{
"input": "8\n4\n4\n3\n65437",
"output": "32718"
},
{
"input": "8\n4\n1\n10\n59392",
"output": "59392"
},
{
"input": "4\n1\n8\n7\n44835",
"output": "44835"
},
{
"input": "6\n1\n7\n2\n62982",
"output": "62982"
},
{
"input": "2\n7\n4\n9\n56937",
"output": "35246"
},
{
"input": "2\n9\n8\n1\n75083",
"output": "75083"
},
{
"input": "8\n7\n7\n6\n69038",
"output": "24656"
},
{
"input": "4\n4\n2\n3\n54481",
"output": "36320"
},
{
"input": "6\n4\n9\n8\n72628",
"output": "28244"
},
{
"input": "9\n7\n8\n10\n42357",
"output": "16540"
},
{
"input": "5\n6\n4\n3\n60504",
"output": "36302"
},
{
"input": "7\n2\n3\n8\n21754",
"output": "15539"
},
{
"input": "1\n2\n10\n4\n39901",
"output": "39901"
},
{
"input": "3\n4\n7\n1\n58048",
"output": "58048"
},
{
"input": "9\n10\n4\n6\n52003",
"output": "21956"
},
{
"input": "5\n10\n9\n3\n70149",
"output": "32736"
},
{
"input": "5\n5\n5\n10\n55592",
"output": "11118"
},
{
"input": "1\n5\n2\n6\n49547",
"output": "49547"
},
{
"input": "3\n7\n7\n7\n84046",
"output": "36019"
},
{
"input": "10\n2\n1\n8\n63537",
"output": "63537"
},
{
"input": "7\n2\n10\n5\n81684",
"output": "53678"
},
{
"input": "7\n1\n6\n8\n99831",
"output": "99831"
},
{
"input": "3\n9\n3\n3\n61082",
"output": "20360"
},
{
"input": "5\n5\n8\n9\n79228",
"output": "29931"
},
{
"input": "1\n5\n5\n6\n89535",
"output": "89535"
},
{
"input": "5\n5\n2\n1\n7682",
"output": "7682"
},
{
"input": "7\n4\n8\n8\n25829",
"output": "9224"
},
{
"input": "3\n4\n3\n3\n87079",
"output": "43539"
},
{
"input": "5\n8\n4\n9\n5226",
"output": "2438"
},
{
"input": "4\n9\n6\n6\n1070",
"output": "415"
},
{
"input": "10\n10\n10\n10\n100000",
"output": "10000"
},
{
"input": "1\n1\n1\n1\n1",
"output": "1"
},
{
"input": "10\n10\n10\n10\n1",
"output": "0"
},
{
"input": "10\n10\n1\n10\n10",
"output": "10"
},
{
"input": "10\n10\n1\n10\n100",
"output": "100"
},
{
"input": "2\n2\n2\n2\n1",
"output": "0"
}
] | 1,685,620,014
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 92
| 0
|
a = eval(input())
b = eval(input())
c = eval(input())
d = eval(input())
total = eval(input())
res = 0
for i in range(total):
if i % a ==0 or i % b ==0 or i % c ==0 or i % d ==0:
res+=1
print(res)
|
Title: Insomnia cure
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
«One dragon. Two dragon. Three dragon», — the princess was counting. She had trouble falling asleep, and she got bored of counting lambs when she was nine.
However, just counting dragons was boring as well, so she entertained herself at best she could. Tonight she imagined that all dragons were here to steal her, and she was fighting them off. Every *k*-th dragon got punched in the face with a frying pan. Every *l*-th dragon got his tail shut into the balcony door. Every *m*-th dragon got his paws trampled with sharp heels. Finally, she threatened every *n*-th dragon to call her mom, and he withdrew in panic.
How many imaginary dragons suffered moral or physical damage tonight, if the princess counted a total of *d* dragons?
Input Specification:
Input data contains integer numbers *k*,<=*l*,<=*m*,<=*n* and *d*, each number in a separate line (1<=≤<=*k*,<=*l*,<=*m*,<=*n*<=≤<=10, 1<=≤<=*d*<=≤<=105).
Output Specification:
Output the number of damaged dragons.
Demo Input:
['1\n2\n3\n4\n12\n', '2\n3\n4\n5\n24\n']
Demo Output:
['12\n', '17\n']
Note:
In the first case every first dragon got punched with a frying pan. Some of the dragons suffered from other reasons as well, but the pan alone would be enough.
In the second case dragons 1, 7, 11, 13, 17, 19 and 23 escaped unharmed.
|
```python
a = eval(input())
b = eval(input())
c = eval(input())
d = eval(input())
total = eval(input())
res = 0
for i in range(total):
if i % a ==0 or i % b ==0 or i % c ==0 or i % d ==0:
res+=1
print(res)
```
| 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,594,664,377
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 30
| 280
| 20,172,800
|
[print(sum([1 if (sum(a)+i) % n else 0 for i in range(5)])) for n, a in [(int(input())+1, list(map(int,input().split())))]]
|
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
[print(sum([1 if (sum(a)+i) % n else 0 for i in range(5)])) for n, a in [(int(input())+1, list(map(int,input().split())))]]
```
| 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,757,930
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 4
| 2,000
| 5,632,000
|
def f(n):
k=len(str(n))
x=str(n);
c=1
for i in range(0,k):
if(x[i]!='0'):
c=c*int(x[i]);
return c;
def g(n):
if(len(str(n))==1):
return int(n);
else:
return g(f(n))
q=int(input())
for t in range(1,q+1):
b=0
l,r,s=map(int,input().split())
for j in range(l,r+1):
if(g(j)==s):
b=b+1;
print(b)
|
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
def f(n):
k=len(str(n))
x=str(n);
c=1
for i in range(0,k):
if(x[i]!='0'):
c=c*int(x[i]);
return c;
def g(n):
if(len(str(n))==1):
return int(n);
else:
return g(f(n))
q=int(input())
for t in range(1,q+1):
b=0
l,r,s=map(int,input().split())
for j in range(l,r+1):
if(g(j)==s):
b=b+1;
print(b)
```
| 0
|
|
703
|
A
|
Mishka and Game
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds *n* is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
|
The first line of the input contains single integer *n* *n* (1<=≤<=*n*<=≤<=100) — the number of game rounds.
The next *n* lines contains rounds description. *i*-th of them contains pair of integers *m**i* and *c**i* (1<=≤<=*m**i*,<=<=*c**i*<=≤<=6) — values on dice upper face after Mishka's and Chris' throws in *i*-th round respectively.
|
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
|
[
"3\n3 5\n2 1\n4 2\n",
"2\n6 1\n1 6\n",
"3\n1 5\n3 3\n2 2\n"
] |
[
"Mishka",
"Friendship is magic!^^",
"Chris"
] |
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
| 500
|
[
{
"input": "3\n3 5\n2 1\n4 2",
"output": "Mishka"
},
{
"input": "2\n6 1\n1 6",
"output": "Friendship is magic!^^"
},
{
"input": "3\n1 5\n3 3\n2 2",
"output": "Chris"
},
{
"input": "6\n4 1\n4 2\n5 3\n5 1\n5 3\n4 1",
"output": "Mishka"
},
{
"input": "8\n2 4\n1 4\n1 5\n2 6\n2 5\n2 5\n2 4\n2 5",
"output": "Chris"
},
{
"input": "8\n4 1\n2 6\n4 2\n2 5\n5 2\n3 5\n5 2\n1 5",
"output": "Friendship is magic!^^"
},
{
"input": "9\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n1 3",
"output": "Mishka"
},
{
"input": "9\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "9\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1",
"output": "Chris"
},
{
"input": "9\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "10\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n1 4",
"output": "Mishka"
},
{
"input": "10\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "10\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1",
"output": "Chris"
},
{
"input": "10\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "100\n2 4\n6 6\n3 2\n1 5\n5 2\n1 5\n1 5\n3 1\n6 5\n4 3\n1 1\n5 1\n3 3\n2 4\n1 5\n3 4\n5 1\n5 5\n2 5\n2 1\n4 3\n6 5\n1 1\n2 1\n1 3\n1 1\n6 4\n4 6\n6 4\n2 1\n2 5\n6 2\n3 4\n5 5\n1 4\n4 6\n3 4\n1 6\n5 1\n4 3\n3 4\n2 2\n1 2\n2 3\n1 3\n4 4\n5 5\n4 5\n4 4\n3 1\n4 5\n2 3\n2 6\n6 5\n6 1\n6 6\n2 3\n6 4\n3 3\n2 5\n4 4\n3 1\n2 4\n6 1\n3 2\n1 3\n5 4\n6 6\n2 5\n5 1\n1 1\n2 5\n6 5\n3 6\n5 6\n4 3\n3 4\n3 4\n6 5\n5 2\n4 2\n1 1\n3 1\n2 6\n1 6\n1 2\n6 1\n3 4\n1 6\n3 1\n5 3\n1 3\n5 6\n2 1\n6 4\n3 1\n1 6\n6 3\n3 3\n4 3",
"output": "Chris"
},
{
"input": "100\n4 1\n3 4\n4 6\n4 5\n6 5\n5 3\n6 2\n6 3\n5 2\n4 5\n1 5\n5 4\n1 4\n4 5\n4 6\n1 6\n4 4\n5 1\n6 4\n6 4\n4 6\n2 3\n6 2\n4 6\n1 4\n2 3\n4 3\n1 3\n6 2\n3 1\n3 4\n2 6\n4 5\n5 4\n2 2\n2 5\n4 1\n2 2\n3 3\n1 4\n5 6\n6 4\n4 2\n6 1\n5 5\n4 1\n2 1\n6 4\n4 4\n4 3\n5 3\n4 5\n5 3\n3 5\n6 3\n1 1\n3 4\n6 3\n6 1\n5 1\n2 4\n4 3\n2 2\n5 5\n1 5\n5 3\n4 6\n1 4\n6 3\n4 3\n2 4\n3 2\n2 4\n3 4\n6 2\n5 6\n1 2\n1 5\n5 5\n2 6\n5 1\n1 6\n5 3\n3 5\n2 6\n4 6\n6 2\n3 1\n5 5\n6 1\n3 6\n4 4\n1 1\n4 6\n5 3\n4 2\n5 1\n3 3\n2 1\n1 4",
"output": "Mishka"
},
{
"input": "100\n6 3\n4 5\n4 3\n5 4\n5 1\n6 3\n4 2\n4 6\n3 1\n2 4\n2 2\n4 6\n5 3\n5 5\n4 2\n6 2\n2 3\n4 4\n6 4\n3 5\n2 4\n2 2\n5 2\n3 5\n2 4\n4 4\n3 5\n6 5\n1 3\n1 6\n2 2\n2 4\n3 2\n5 4\n1 6\n3 4\n4 1\n1 5\n1 4\n5 3\n2 2\n4 5\n6 3\n4 4\n1 1\n4 1\n2 4\n4 1\n4 5\n5 3\n1 1\n1 6\n5 6\n6 6\n4 2\n4 3\n3 4\n3 6\n3 4\n6 5\n3 4\n5 4\n5 1\n5 3\n5 1\n1 2\n2 6\n3 4\n6 5\n4 3\n1 1\n5 5\n5 1\n3 3\n5 2\n1 3\n6 6\n5 6\n1 4\n4 4\n1 4\n3 6\n6 5\n3 3\n3 6\n1 5\n1 2\n3 6\n3 6\n4 1\n5 2\n1 2\n5 2\n3 3\n4 4\n4 2\n6 2\n5 4\n6 1\n6 3",
"output": "Mishka"
},
{
"input": "8\n4 1\n6 2\n4 1\n5 3\n4 1\n5 3\n6 2\n5 3",
"output": "Mishka"
},
{
"input": "5\n3 6\n3 5\n3 5\n1 6\n3 5",
"output": "Chris"
},
{
"input": "4\n4 1\n2 4\n5 3\n3 6",
"output": "Friendship is magic!^^"
},
{
"input": "6\n6 3\n5 1\n6 3\n4 3\n4 3\n5 2",
"output": "Mishka"
},
{
"input": "7\n3 4\n1 4\n2 5\n1 6\n1 6\n1 5\n3 4",
"output": "Chris"
},
{
"input": "6\n6 2\n2 5\n5 2\n3 6\n4 3\n1 6",
"output": "Friendship is magic!^^"
},
{
"input": "8\n6 1\n5 3\n4 3\n4 1\n5 1\n4 2\n4 2\n4 1",
"output": "Mishka"
},
{
"input": "9\n2 5\n2 5\n1 4\n2 6\n2 4\n2 5\n2 6\n1 5\n2 5",
"output": "Chris"
},
{
"input": "4\n6 2\n2 4\n4 2\n3 6",
"output": "Friendship is magic!^^"
},
{
"input": "9\n5 2\n4 1\n4 1\n5 1\n6 2\n6 1\n5 3\n6 1\n6 2",
"output": "Mishka"
},
{
"input": "8\n2 4\n3 6\n1 6\n1 6\n2 4\n3 4\n3 6\n3 4",
"output": "Chris"
},
{
"input": "6\n5 3\n3 6\n6 2\n1 6\n5 1\n3 5",
"output": "Friendship is magic!^^"
},
{
"input": "6\n5 2\n5 1\n6 1\n5 2\n4 2\n5 1",
"output": "Mishka"
},
{
"input": "5\n1 4\n2 5\n3 4\n2 6\n3 4",
"output": "Chris"
},
{
"input": "4\n6 2\n3 4\n5 1\n1 6",
"output": "Friendship is magic!^^"
},
{
"input": "93\n4 3\n4 1\n4 2\n5 2\n5 3\n6 3\n4 3\n6 2\n6 3\n5 1\n4 2\n4 2\n5 1\n6 2\n6 3\n6 1\n4 1\n6 2\n5 3\n4 3\n4 1\n4 2\n5 2\n6 3\n5 2\n5 2\n6 3\n5 1\n6 2\n5 2\n4 1\n5 2\n5 1\n4 1\n6 1\n5 2\n4 3\n5 3\n5 3\n5 1\n4 3\n4 3\n4 2\n4 1\n6 2\n6 1\n4 1\n5 2\n5 2\n6 2\n5 3\n5 1\n6 2\n5 1\n6 3\n5 2\n6 2\n6 2\n4 2\n5 2\n6 1\n6 3\n6 3\n5 1\n5 1\n4 1\n5 1\n4 3\n5 3\n6 3\n4 1\n4 3\n6 1\n6 1\n4 2\n6 2\n4 2\n5 2\n4 1\n5 2\n4 1\n5 1\n5 2\n5 1\n4 1\n6 3\n6 2\n4 3\n4 1\n5 2\n4 3\n5 2\n5 1",
"output": "Mishka"
},
{
"input": "11\n1 6\n1 6\n2 4\n2 5\n3 4\n1 5\n1 6\n1 5\n1 6\n2 6\n3 4",
"output": "Chris"
},
{
"input": "70\n6 1\n3 6\n4 3\n2 5\n5 2\n1 4\n6 2\n1 6\n4 3\n1 4\n5 3\n2 4\n5 3\n1 6\n5 1\n3 5\n4 2\n2 4\n5 1\n3 5\n6 2\n1 5\n4 2\n2 5\n5 3\n1 5\n4 2\n1 4\n5 2\n2 6\n4 3\n1 5\n6 2\n3 4\n4 2\n3 5\n6 3\n3 4\n5 1\n1 4\n4 2\n1 4\n6 3\n2 6\n5 2\n1 6\n6 1\n2 6\n5 3\n1 5\n5 1\n1 6\n4 1\n1 5\n4 2\n2 4\n5 1\n2 5\n6 3\n1 4\n6 3\n3 6\n5 1\n1 4\n5 3\n3 5\n4 2\n3 4\n6 2\n1 4",
"output": "Friendship is magic!^^"
},
{
"input": "59\n4 1\n5 3\n6 1\n4 2\n5 1\n4 3\n6 1\n5 1\n4 3\n4 3\n5 2\n5 3\n4 1\n6 2\n5 1\n6 3\n6 3\n5 2\n5 2\n6 1\n4 1\n6 1\n4 3\n5 3\n5 3\n4 3\n4 2\n4 2\n6 3\n6 3\n6 1\n4 3\n5 1\n6 2\n6 1\n4 1\n6 1\n5 3\n4 2\n5 1\n6 2\n6 2\n4 3\n5 3\n4 3\n6 3\n5 2\n5 2\n4 3\n5 1\n5 3\n6 1\n6 3\n6 3\n4 3\n5 2\n5 2\n5 2\n4 3",
"output": "Mishka"
},
{
"input": "42\n1 5\n1 6\n1 6\n1 4\n2 5\n3 6\n1 6\n3 4\n2 5\n2 5\n2 4\n1 4\n3 4\n2 4\n2 6\n1 5\n3 6\n2 6\n2 6\n3 5\n1 4\n1 5\n2 6\n3 6\n1 4\n3 4\n2 4\n1 6\n3 4\n2 4\n2 6\n1 6\n1 4\n1 6\n1 6\n2 4\n1 5\n1 6\n2 5\n3 6\n3 5\n3 4",
"output": "Chris"
},
{
"input": "78\n4 3\n3 5\n4 3\n1 5\n5 1\n1 5\n4 3\n1 4\n6 3\n1 5\n4 1\n2 4\n4 3\n2 4\n5 1\n3 6\n4 2\n3 6\n6 3\n3 4\n4 3\n3 6\n5 3\n1 5\n4 1\n2 6\n4 2\n2 4\n4 1\n3 5\n5 2\n3 6\n4 3\n2 4\n6 3\n1 6\n4 3\n3 5\n6 3\n2 6\n4 1\n2 4\n6 2\n1 6\n4 2\n1 4\n4 3\n1 4\n4 3\n2 4\n6 2\n3 5\n6 1\n3 6\n5 3\n1 6\n6 1\n2 6\n4 2\n1 5\n6 2\n2 6\n6 3\n2 4\n4 2\n3 5\n6 1\n2 5\n5 3\n2 6\n5 1\n3 6\n4 3\n3 6\n6 3\n2 5\n6 1\n2 6",
"output": "Friendship is magic!^^"
},
{
"input": "76\n4 1\n5 2\n4 3\n5 2\n5 3\n5 2\n6 1\n4 2\n6 2\n5 3\n4 2\n6 2\n4 1\n4 2\n5 1\n5 1\n6 2\n5 2\n5 3\n6 3\n5 2\n4 3\n6 3\n6 1\n4 3\n6 2\n6 1\n4 1\n6 1\n5 3\n4 1\n5 3\n4 2\n5 2\n4 3\n6 1\n6 2\n5 2\n6 1\n5 3\n4 3\n5 1\n5 3\n4 3\n5 1\n5 1\n4 1\n4 1\n4 1\n4 3\n5 3\n6 3\n6 3\n5 2\n6 2\n6 3\n5 1\n6 3\n5 3\n6 1\n5 3\n4 1\n5 3\n6 1\n4 2\n6 2\n4 3\n4 1\n6 2\n4 3\n5 3\n5 2\n5 3\n5 1\n6 3\n5 2",
"output": "Mishka"
},
{
"input": "84\n3 6\n3 4\n2 5\n2 4\n1 6\n3 4\n1 5\n1 6\n3 5\n1 6\n2 4\n2 6\n2 6\n2 4\n3 5\n1 5\n3 6\n3 6\n3 4\n3 4\n2 6\n1 6\n1 6\n3 5\n3 4\n1 6\n3 4\n3 5\n2 4\n2 5\n2 5\n3 5\n1 6\n3 4\n2 6\n2 6\n3 4\n3 4\n2 5\n2 5\n2 4\n3 4\n2 5\n3 4\n3 4\n2 6\n2 6\n1 6\n2 4\n1 5\n3 4\n2 5\n2 5\n3 4\n2 4\n2 6\n2 6\n1 4\n3 5\n3 5\n2 4\n2 5\n3 4\n1 5\n1 5\n2 6\n1 5\n3 5\n2 4\n2 5\n3 4\n2 6\n1 6\n2 5\n3 5\n3 5\n3 4\n2 5\n2 6\n3 4\n1 6\n2 5\n2 6\n1 4",
"output": "Chris"
},
{
"input": "44\n6 1\n1 6\n5 2\n1 4\n6 2\n2 5\n5 3\n3 6\n5 2\n1 6\n4 1\n2 4\n6 1\n3 4\n6 3\n3 6\n4 3\n2 4\n6 1\n3 4\n6 1\n1 6\n4 1\n3 5\n6 1\n3 6\n4 1\n1 4\n4 2\n2 6\n6 1\n2 4\n6 2\n1 4\n6 2\n2 4\n5 2\n3 6\n6 3\n2 6\n5 3\n3 4\n5 3\n2 4",
"output": "Friendship is magic!^^"
},
{
"input": "42\n5 3\n5 1\n5 2\n4 1\n6 3\n6 1\n6 2\n4 1\n4 3\n4 1\n5 1\n5 3\n5 1\n4 1\n4 2\n6 1\n6 3\n5 1\n4 1\n4 1\n6 3\n4 3\n6 3\n5 2\n6 1\n4 1\n5 3\n4 3\n5 2\n6 3\n6 1\n5 1\n4 2\n4 3\n5 2\n5 3\n6 3\n5 2\n5 1\n5 3\n6 2\n6 1",
"output": "Mishka"
},
{
"input": "50\n3 6\n2 6\n1 4\n1 4\n1 4\n2 5\n3 4\n3 5\n2 6\n1 6\n3 5\n1 5\n2 6\n2 4\n2 4\n3 5\n1 6\n1 5\n1 5\n1 4\n3 5\n1 6\n3 5\n1 4\n1 5\n1 4\n3 6\n1 6\n1 4\n1 4\n1 4\n1 5\n3 6\n1 6\n1 6\n2 4\n1 5\n2 6\n2 5\n3 5\n3 6\n3 4\n2 4\n2 6\n3 4\n2 5\n3 6\n3 5\n2 4\n2 4",
"output": "Chris"
},
{
"input": "86\n6 3\n2 4\n6 3\n3 5\n6 3\n1 5\n5 2\n2 4\n4 3\n2 6\n4 1\n2 6\n5 2\n1 4\n5 1\n2 4\n4 1\n1 4\n6 2\n3 5\n4 2\n2 4\n6 2\n1 5\n5 3\n2 5\n5 1\n1 6\n6 1\n1 4\n4 3\n3 4\n5 2\n2 4\n5 3\n2 5\n4 3\n3 4\n4 1\n1 5\n6 3\n3 4\n4 3\n3 4\n4 1\n3 4\n5 1\n1 6\n4 2\n1 6\n5 1\n2 4\n5 1\n3 6\n4 1\n1 5\n5 2\n1 4\n4 3\n2 5\n5 1\n1 5\n6 2\n2 6\n4 2\n2 4\n4 1\n2 5\n5 3\n3 4\n5 1\n3 4\n6 3\n3 4\n4 3\n2 6\n6 2\n2 5\n5 2\n3 5\n4 2\n3 6\n6 2\n3 4\n4 2\n2 4",
"output": "Friendship is magic!^^"
},
{
"input": "84\n6 1\n6 3\n6 3\n4 1\n4 3\n4 2\n6 3\n5 3\n6 1\n6 3\n4 3\n5 2\n5 3\n5 1\n6 2\n6 2\n6 1\n4 1\n6 3\n5 2\n4 1\n5 3\n6 3\n4 2\n6 2\n6 3\n4 3\n4 1\n4 3\n5 1\n5 1\n5 1\n4 1\n6 1\n4 3\n6 2\n5 1\n5 1\n6 2\n5 2\n4 1\n6 1\n6 1\n6 3\n6 2\n4 3\n6 3\n6 2\n5 2\n5 1\n4 3\n6 2\n4 1\n6 2\n6 1\n5 2\n5 1\n6 2\n6 1\n5 3\n5 2\n6 1\n6 3\n5 2\n6 1\n6 3\n4 3\n5 1\n6 3\n6 1\n5 3\n4 3\n5 2\n5 1\n6 2\n5 3\n6 1\n5 1\n4 1\n5 1\n5 1\n5 2\n5 2\n5 1",
"output": "Mishka"
},
{
"input": "92\n1 5\n2 4\n3 5\n1 6\n2 5\n1 6\n3 6\n1 6\n2 4\n3 4\n3 4\n3 6\n1 5\n2 5\n1 5\n1 5\n2 6\n2 4\n3 6\n1 4\n1 6\n2 6\n3 4\n2 6\n2 6\n1 4\n3 5\n2 5\n2 6\n1 5\n1 4\n1 5\n3 6\n3 5\n2 5\n1 5\n3 5\n3 6\n2 6\n2 6\n1 5\n3 4\n2 4\n3 6\n2 5\n1 5\n2 4\n1 4\n2 6\n2 6\n2 6\n1 5\n3 6\n3 6\n2 5\n1 4\n2 4\n3 4\n1 5\n2 5\n2 4\n2 5\n3 5\n3 4\n3 6\n2 6\n3 5\n1 4\n3 4\n1 6\n3 6\n2 6\n1 4\n3 6\n3 6\n2 5\n2 6\n1 6\n2 6\n3 5\n2 5\n3 6\n2 5\n2 6\n1 5\n2 4\n1 4\n2 4\n1 5\n2 5\n2 5\n2 6",
"output": "Chris"
},
{
"input": "20\n5 1\n1 4\n4 3\n1 5\n4 2\n3 6\n6 2\n1 6\n4 1\n1 4\n5 2\n3 4\n5 1\n1 6\n5 1\n2 6\n6 3\n2 5\n6 2\n2 4",
"output": "Friendship is magic!^^"
},
{
"input": "100\n4 3\n4 3\n4 2\n4 3\n4 1\n4 3\n5 2\n5 2\n6 2\n4 2\n5 1\n4 2\n5 2\n6 1\n4 1\n6 3\n5 3\n5 1\n5 1\n5 1\n5 3\n6 1\n6 1\n4 1\n5 2\n5 2\n6 1\n6 3\n4 2\n4 1\n5 3\n4 1\n5 3\n5 1\n6 3\n6 3\n6 1\n5 2\n5 3\n5 3\n6 1\n4 1\n6 2\n6 1\n6 2\n6 3\n4 3\n4 3\n6 3\n4 2\n4 2\n5 3\n5 2\n5 2\n4 3\n5 3\n5 2\n4 2\n5 1\n4 2\n5 1\n5 3\n6 3\n5 3\n5 3\n4 2\n4 1\n4 2\n4 3\n6 3\n4 3\n6 2\n6 1\n5 3\n5 2\n4 1\n6 1\n5 2\n6 2\n4 2\n6 3\n4 3\n5 1\n6 3\n5 2\n4 3\n5 3\n5 3\n4 3\n6 3\n4 3\n4 1\n5 1\n6 2\n6 3\n5 3\n6 1\n6 3\n5 3\n6 1",
"output": "Mishka"
},
{
"input": "100\n1 5\n1 4\n1 5\n2 4\n2 6\n3 6\n3 5\n1 5\n2 5\n3 6\n3 5\n1 6\n1 4\n1 5\n1 6\n2 6\n1 5\n3 5\n3 4\n2 6\n2 6\n2 5\n3 4\n1 6\n1 4\n2 4\n1 5\n1 6\n3 5\n1 6\n2 6\n3 5\n1 6\n3 4\n3 5\n1 6\n3 6\n2 4\n2 4\n3 5\n2 6\n1 5\n3 5\n3 6\n2 4\n2 4\n2 6\n3 4\n3 4\n1 5\n1 4\n2 5\n3 4\n1 4\n2 6\n2 5\n2 4\n2 4\n2 5\n1 5\n1 6\n1 5\n1 5\n1 5\n1 6\n3 4\n2 4\n3 5\n3 5\n1 6\n3 5\n1 5\n1 6\n3 6\n3 4\n1 5\n3 5\n3 6\n1 4\n3 6\n1 5\n3 5\n3 6\n3 5\n1 4\n3 4\n2 4\n2 4\n2 5\n3 6\n3 5\n1 5\n2 4\n1 4\n3 4\n1 5\n3 4\n3 6\n3 5\n3 4",
"output": "Chris"
},
{
"input": "100\n4 3\n3 4\n5 1\n2 5\n5 3\n1 5\n6 3\n2 4\n5 2\n2 6\n5 2\n1 5\n6 3\n1 5\n6 3\n3 4\n5 2\n1 5\n6 1\n1 5\n4 2\n3 5\n6 3\n2 6\n6 3\n1 4\n6 2\n3 4\n4 1\n3 6\n5 1\n2 4\n5 1\n3 4\n6 2\n3 5\n4 1\n2 6\n4 3\n2 6\n5 2\n3 6\n6 2\n3 5\n4 3\n1 5\n5 3\n3 6\n4 2\n3 4\n6 1\n3 4\n5 2\n2 6\n5 2\n2 4\n6 2\n3 6\n4 3\n2 4\n4 3\n2 6\n4 2\n3 4\n6 3\n2 4\n6 3\n3 5\n5 2\n1 5\n6 3\n3 6\n4 3\n1 4\n5 2\n1 6\n4 1\n2 5\n4 1\n2 4\n4 2\n2 5\n6 1\n2 4\n6 3\n1 5\n4 3\n2 6\n6 3\n2 6\n5 3\n1 5\n4 1\n1 5\n6 2\n2 5\n5 1\n3 6\n4 3\n3 4",
"output": "Friendship is magic!^^"
},
{
"input": "99\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n1 3",
"output": "Mishka"
},
{
"input": "99\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "99\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1",
"output": "Chris"
},
{
"input": "99\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "100\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n1 4",
"output": "Mishka"
},
{
"input": "100\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "100\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1",
"output": "Chris"
},
{
"input": "100\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6",
"output": "Mishka"
},
{
"input": "84\n6 2\n1 5\n6 2\n2 3\n5 5\n1 2\n3 4\n3 4\n6 5\n6 4\n2 5\n4 1\n1 2\n1 1\n1 4\n2 5\n5 6\n6 3\n2 4\n5 5\n2 6\n3 4\n5 1\n3 3\n5 5\n4 6\n4 6\n2 4\n4 1\n5 2\n2 2\n3 6\n3 3\n4 6\n1 1\n2 4\n6 5\n5 2\n6 5\n5 5\n2 5\n6 4\n1 1\n6 2\n3 6\n6 5\n4 4\n1 5\n5 6\n4 4\n3 5\n6 1\n3 4\n1 5\n4 6\n4 6\n4 1\n3 6\n6 2\n1 1\n4 5\n5 4\n5 3\n3 4\n6 4\n1 1\n5 2\n6 5\n6 1\n2 2\n2 4\n3 3\n4 6\n1 3\n6 6\n5 2\n1 6\n6 2\n6 6\n4 1\n3 6\n6 4\n2 3\n3 4",
"output": "Chris"
},
{
"input": "70\n3 4\n2 3\n2 3\n6 5\n6 6\n4 3\n2 3\n3 1\n3 5\n5 6\n1 6\n2 5\n5 3\n2 5\n4 6\n5 1\n6 1\n3 1\n3 3\n5 3\n2 1\n3 3\n6 4\n6 3\n4 3\n4 5\n3 5\n5 5\n5 2\n1 6\n3 4\n5 2\n2 4\n1 6\n4 3\n4 3\n6 2\n1 3\n1 5\n6 1\n3 1\n1 1\n1 3\n2 2\n3 2\n6 4\n1 1\n4 4\n3 1\n4 5\n4 2\n6 3\n4 4\n3 2\n1 2\n2 6\n3 3\n1 5\n1 1\n6 5\n2 2\n3 1\n5 4\n5 2\n6 4\n6 3\n6 6\n6 3\n3 3\n5 4",
"output": "Mishka"
},
{
"input": "56\n6 4\n3 4\n6 1\n3 3\n1 4\n2 3\n1 5\n2 5\n1 5\n5 5\n2 3\n1 1\n3 2\n3 5\n4 6\n4 4\n5 2\n4 3\n3 1\n3 6\n2 3\n3 4\n5 6\n5 2\n5 6\n1 5\n1 5\n4 1\n6 3\n2 2\n2 1\n5 5\n2 1\n4 1\n5 4\n2 5\n4 1\n6 2\n3 4\n4 2\n6 4\n5 4\n4 2\n4 3\n6 2\n6 2\n3 1\n1 4\n3 6\n5 1\n5 5\n3 6\n6 4\n2 3\n6 5\n3 3",
"output": "Mishka"
},
{
"input": "94\n2 4\n6 4\n1 6\n1 4\n5 1\n3 3\n4 3\n6 1\n6 5\n3 2\n2 3\n5 1\n5 3\n1 2\n4 3\n3 2\n2 3\n4 6\n1 3\n6 3\n1 1\n3 2\n4 3\n1 5\n4 6\n3 2\n6 3\n1 6\n1 1\n1 2\n3 5\n1 3\n3 5\n4 4\n4 2\n1 4\n4 5\n1 3\n1 2\n1 1\n5 4\n5 5\n6 1\n2 1\n2 6\n6 6\n4 2\n3 6\n1 6\n6 6\n1 5\n3 2\n1 2\n4 4\n6 4\n4 1\n1 5\n3 3\n1 3\n3 4\n4 4\n1 1\n2 5\n4 5\n3 1\n3 1\n3 6\n3 2\n1 4\n1 6\n6 3\n2 4\n1 1\n2 2\n2 2\n2 1\n5 4\n1 2\n6 6\n2 2\n3 3\n6 3\n6 3\n1 6\n2 3\n2 4\n2 3\n6 6\n2 6\n6 3\n3 5\n1 4\n1 1\n3 5",
"output": "Chris"
},
{
"input": "81\n4 2\n1 2\n2 3\n4 5\n6 2\n1 6\n3 6\n3 4\n4 6\n4 4\n3 5\n4 6\n3 6\n3 5\n3 1\n1 3\n5 3\n3 4\n1 1\n4 1\n1 2\n6 1\n1 3\n6 5\n4 5\n4 2\n4 5\n6 2\n1 2\n2 6\n5 2\n1 5\n2 4\n4 3\n5 4\n1 2\n5 3\n2 6\n6 4\n1 1\n1 3\n3 1\n3 1\n6 5\n5 5\n6 1\n6 6\n5 2\n1 3\n1 4\n2 3\n5 5\n3 1\n3 1\n4 4\n1 6\n6 4\n2 2\n4 6\n4 4\n2 6\n2 4\n2 4\n4 1\n1 6\n1 4\n1 3\n6 5\n5 1\n1 3\n5 1\n1 4\n3 5\n2 6\n1 3\n5 6\n3 5\n4 4\n5 5\n5 6\n4 3",
"output": "Chris"
},
{
"input": "67\n6 5\n3 6\n1 6\n5 3\n5 4\n5 1\n1 6\n1 1\n3 2\n4 4\n3 1\n4 1\n1 5\n5 3\n3 3\n6 4\n2 4\n2 2\n4 3\n1 4\n1 4\n6 1\n1 2\n2 2\n5 1\n6 2\n3 5\n5 5\n2 2\n6 5\n6 2\n4 4\n3 1\n4 2\n6 6\n6 4\n5 1\n2 2\n4 5\n5 5\n4 6\n1 5\n6 3\n4 4\n1 5\n6 4\n3 6\n3 4\n1 6\n2 4\n2 1\n2 5\n6 5\n6 4\n4 1\n3 2\n1 2\n5 1\n5 6\n1 5\n3 5\n3 1\n5 3\n3 2\n5 1\n4 6\n6 6",
"output": "Mishka"
},
{
"input": "55\n6 6\n6 5\n2 2\n2 2\n6 4\n5 5\n6 5\n5 3\n1 3\n2 2\n5 6\n3 3\n3 3\n6 5\n3 5\n5 5\n1 2\n1 1\n4 6\n1 2\n5 5\n6 2\n6 3\n1 2\n5 1\n1 3\n3 3\n4 4\n2 5\n1 1\n5 3\n4 3\n2 2\n4 5\n5 6\n4 5\n6 3\n1 6\n6 4\n3 6\n1 6\n5 2\n6 3\n2 3\n5 5\n4 3\n3 1\n4 2\n1 1\n2 5\n5 3\n2 2\n6 3\n4 5\n2 2",
"output": "Mishka"
},
{
"input": "92\n2 3\n1 3\n2 6\n5 1\n5 5\n3 2\n5 6\n2 5\n3 1\n3 6\n4 5\n2 5\n1 2\n2 3\n6 5\n3 6\n4 4\n6 2\n4 5\n4 4\n5 1\n6 1\n3 4\n3 5\n6 6\n3 2\n6 4\n2 2\n3 5\n6 4\n6 3\n6 6\n3 4\n3 3\n6 1\n5 4\n6 2\n2 6\n5 6\n1 4\n4 6\n6 3\n3 1\n4 1\n6 6\n3 5\n6 3\n6 1\n1 6\n3 2\n6 6\n4 3\n3 4\n1 3\n3 5\n5 3\n6 5\n4 3\n5 5\n4 1\n1 5\n6 4\n2 3\n2 3\n1 5\n1 2\n5 2\n4 3\n3 6\n5 5\n5 4\n1 4\n3 3\n1 6\n5 6\n5 4\n5 3\n1 1\n6 2\n5 5\n2 5\n4 3\n6 6\n5 1\n1 1\n4 6\n4 6\n3 1\n6 4\n2 4\n2 2\n2 1",
"output": "Chris"
},
{
"input": "79\n5 3\n4 6\n3 6\n2 1\n5 2\n2 3\n4 4\n6 2\n2 5\n1 6\n6 6\n2 6\n3 3\n4 5\n6 2\n2 1\n1 5\n5 1\n2 1\n2 6\n5 3\n6 2\n2 6\n2 3\n1 5\n4 4\n6 3\n5 2\n3 2\n1 3\n1 3\n6 3\n2 6\n3 6\n5 3\n4 5\n6 1\n3 5\n3 5\n6 5\n1 5\n4 2\n6 2\n2 3\n4 6\n3 6\n2 5\n4 4\n1 1\n4 6\n2 6\n6 4\n3 2\n4 1\n1 2\n6 4\n5 6\n1 4\n2 2\n5 4\n3 2\n1 2\n2 4\n2 5\n2 1\n3 6\n3 3\n1 1\n2 2\n4 4\n4 5\n3 3\n5 3\n6 2\n4 5\n6 5\n2 5\n5 6\n2 2",
"output": "Chris"
},
{
"input": "65\n1 1\n5 1\n2 2\n5 4\n4 5\n2 5\n3 2\n5 6\n6 3\n1 1\n6 1\n1 5\n1 1\n5 2\n6 4\n1 6\n1 1\n4 3\n2 3\n5 6\n4 4\n6 2\n1 3\n4 3\n1 3\n6 3\n3 5\n4 2\n4 1\n6 1\n3 2\n2 6\n3 2\n3 5\n6 3\n4 3\n1 5\n2 6\n1 3\n4 1\n4 1\n2 5\n2 5\n6 2\n5 3\n3 1\n3 3\n5 1\n2 4\n5 3\n3 3\n1 1\n6 3\n3 3\n5 1\n1 6\n4 5\n6 6\n5 5\n2 5\n4 1\n2 2\n1 4\n1 6\n6 5",
"output": "Mishka"
},
{
"input": "1\n1 1",
"output": "Friendship is magic!^^"
}
] | 1,674,570,558
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 30
| 0
|
q=q1=0
for i in range(int(input())):
a,b=map(int,input().split())
if a>b:q+=1
else:q1+=1
if q>q1:
print('Mishka')
elif q<q1:print('Friendship is magic!^^')
else:print('Chris')
|
Title: Mishka and Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds *n* is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input Specification:
The first line of the input contains single integer *n* *n* (1<=≤<=*n*<=≤<=100) — the number of game rounds.
The next *n* lines contains rounds description. *i*-th of them contains pair of integers *m**i* and *c**i* (1<=≤<=*m**i*,<=<=*c**i*<=≤<=6) — values on dice upper face after Mishka's and Chris' throws in *i*-th round respectively.
Output Specification:
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Demo Input:
['3\n3 5\n2 1\n4 2\n', '2\n6 1\n1 6\n', '3\n1 5\n3 3\n2 2\n']
Demo Output:
['Mishka', 'Friendship is magic!^^', 'Chris']
Note:
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
|
```python
q=q1=0
for i in range(int(input())):
a,b=map(int,input().split())
if a>b:q+=1
else:q1+=1
if q>q1:
print('Mishka')
elif q<q1:print('Friendship is magic!^^')
else:print('Chris')
```
| 0
|
|
935
|
A
|
Fafa and his Company
|
PROGRAMMING
| 800
|
[
"brute force",
"implementation"
] | null | null |
Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees.
Fafa finds doing this every time is very tiring for him. So, he decided to choose the best *l* employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader.
Given the number of employees *n*, find in how many ways Fafa could choose the number of team leaders *l* in such a way that it is possible to divide employees between them evenly.
|
The input consists of a single line containing a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of employees in Fafa's company.
|
Print a single integer representing the answer to the problem.
|
[
"2\n",
"10\n"
] |
[
"1\n",
"3\n"
] |
In the second sample Fafa has 3 ways:
- choose only 1 employee as a team leader with 9 employees under his responsibility. - choose 2 employees as team leaders with 4 employees under the responsibility of each of them. - choose 5 employees as team leaders with 1 employee under the responsibility of each of them.
| 500
|
[
{
"input": "2",
"output": "1"
},
{
"input": "10",
"output": "3"
},
{
"input": "3",
"output": "1"
},
{
"input": "4",
"output": "2"
},
{
"input": "6",
"output": "3"
},
{
"input": "13",
"output": "1"
},
{
"input": "100000",
"output": "35"
},
{
"input": "1024",
"output": "10"
},
{
"input": "99999",
"output": "11"
},
{
"input": "10007",
"output": "1"
},
{
"input": "4096",
"output": "12"
},
{
"input": "65536",
"output": "16"
},
{
"input": "40320",
"output": "95"
},
{
"input": "30030",
"output": "63"
},
{
"input": "161",
"output": "3"
},
{
"input": "1000",
"output": "15"
},
{
"input": "10000",
"output": "24"
},
{
"input": "777",
"output": "7"
},
{
"input": "121",
"output": "2"
},
{
"input": "25",
"output": "2"
},
{
"input": "40000",
"output": "34"
},
{
"input": "99990",
"output": "47"
},
{
"input": "98765",
"output": "3"
},
{
"input": "56789",
"output": "3"
},
{
"input": "13579",
"output": "3"
},
{
"input": "97531",
"output": "3"
},
{
"input": "12345",
"output": "7"
},
{
"input": "54321",
"output": "7"
},
{
"input": "83160",
"output": "127"
},
{
"input": "9",
"output": "2"
},
{
"input": "21",
"output": "3"
},
{
"input": "11",
"output": "1"
},
{
"input": "15",
"output": "3"
}
] | 1,688,380,926
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 33
| 62
| 1,331,200
|
n = int(input())
c = 0
for i in range(1, n+1):
if (n-i)%i==0:
c+=1
print(c-1)
|
Title: Fafa and his Company
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees.
Fafa finds doing this every time is very tiring for him. So, he decided to choose the best *l* employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader.
Given the number of employees *n*, find in how many ways Fafa could choose the number of team leaders *l* in such a way that it is possible to divide employees between them evenly.
Input Specification:
The input consists of a single line containing a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of employees in Fafa's company.
Output Specification:
Print a single integer representing the answer to the problem.
Demo Input:
['2\n', '10\n']
Demo Output:
['1\n', '3\n']
Note:
In the second sample Fafa has 3 ways:
- choose only 1 employee as a team leader with 9 employees under his responsibility. - choose 2 employees as team leaders with 4 employees under the responsibility of each of them. - choose 5 employees as team leaders with 1 employee under the responsibility of each of them.
|
```python
n = int(input())
c = 0
for i in range(1, n+1):
if (n-i)%i==0:
c+=1
print(c-1)
```
| 3
|
|
25
|
A
|
IQ test
|
PROGRAMMING
| 1,300
|
[
"brute force"
] |
A. IQ test
|
2
|
256
|
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that is different in evenness.
|
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness.
|
Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order.
|
[
"5\n2 4 7 8 10\n",
"4\n1 2 1 1\n"
] |
[
"3\n",
"2\n"
] |
none
| 0
|
[
{
"input": "5\n2 4 7 8 10",
"output": "3"
},
{
"input": "4\n1 2 1 1",
"output": "2"
},
{
"input": "3\n1 2 2",
"output": "1"
},
{
"input": "3\n100 99 100",
"output": "2"
},
{
"input": "3\n5 3 2",
"output": "3"
},
{
"input": "4\n43 28 1 91",
"output": "2"
},
{
"input": "4\n75 13 94 77",
"output": "3"
},
{
"input": "4\n97 8 27 3",
"output": "2"
},
{
"input": "10\n95 51 12 91 85 3 1 31 25 7",
"output": "3"
},
{
"input": "20\n88 96 66 51 14 88 2 92 18 72 18 88 20 30 4 82 90 100 24 46",
"output": "4"
},
{
"input": "30\n20 94 56 50 10 98 52 32 14 22 24 60 4 8 98 46 34 68 82 82 98 90 50 20 78 49 52 94 64 36",
"output": "26"
},
{
"input": "50\n79 27 77 57 37 45 27 49 65 33 57 21 71 19 75 85 65 61 23 97 85 9 23 1 9 3 99 77 77 21 79 69 15 37 15 7 93 81 13 89 91 31 45 93 15 97 55 80 85 83",
"output": "48"
},
{
"input": "60\n46 11 73 65 3 69 3 53 43 53 97 47 55 93 31 75 35 3 9 73 23 31 3 81 91 79 61 21 15 11 11 11 81 7 83 75 39 87 83 59 89 55 93 27 49 67 67 29 1 93 11 17 9 19 35 21 63 31 31 25",
"output": "1"
},
{
"input": "70\n28 42 42 92 64 54 22 38 38 78 62 38 4 38 14 66 4 92 66 58 94 26 4 44 41 88 48 82 44 26 74 44 48 4 16 92 34 38 26 64 94 4 30 78 50 54 12 90 8 16 80 98 28 100 74 50 36 42 92 18 76 98 8 22 2 50 58 50 64 46",
"output": "25"
},
{
"input": "100\n43 35 79 53 13 91 91 45 65 83 57 9 42 39 85 45 71 51 61 59 31 13 63 39 25 21 79 39 91 67 21 61 97 75 93 83 29 79 59 97 11 37 63 51 39 55 91 23 21 17 47 23 35 75 49 5 69 99 5 7 41 17 25 89 15 79 21 63 53 81 43 91 59 91 69 99 85 15 91 51 49 37 65 7 89 81 21 93 61 63 97 93 45 17 13 69 57 25 75 73",
"output": "13"
},
{
"input": "100\n50 24 68 60 70 30 52 22 18 74 68 98 20 82 4 46 26 68 100 78 84 58 74 98 38 88 68 86 64 80 82 100 20 22 98 98 52 6 94 10 48 68 2 18 38 22 22 82 44 20 66 72 36 58 64 6 36 60 4 96 76 64 12 90 10 58 64 60 74 28 90 26 24 60 40 58 2 16 76 48 58 36 82 60 24 44 4 78 28 38 8 12 40 16 38 6 66 24 31 76",
"output": "99"
},
{
"input": "100\n47 48 94 48 14 18 94 36 96 22 12 30 94 20 48 98 40 58 2 94 8 36 98 18 98 68 2 60 76 38 18 100 8 72 100 68 2 86 92 72 58 16 48 14 6 58 72 76 6 88 80 66 20 28 74 62 86 68 90 86 2 56 34 38 56 90 4 8 76 44 32 86 12 98 38 34 54 92 70 94 10 24 82 66 90 58 62 2 32 58 100 22 58 72 2 22 68 72 42 14",
"output": "1"
},
{
"input": "99\n38 20 68 60 84 16 28 88 60 48 80 28 4 92 70 60 46 46 20 34 12 100 76 2 40 10 8 86 6 80 50 66 12 34 14 28 26 70 46 64 34 96 10 90 98 96 56 88 50 74 70 94 2 94 24 66 68 46 22 30 6 10 64 32 88 14 98 100 64 58 50 18 50 50 8 38 8 16 54 2 60 54 62 84 92 98 4 72 66 26 14 88 99 16 10 6 88 56 22",
"output": "93"
},
{
"input": "99\n50 83 43 89 53 47 69 1 5 37 63 87 95 15 55 95 75 89 33 53 89 75 93 75 11 85 49 29 11 97 49 67 87 11 25 37 97 73 67 49 87 43 53 97 43 29 53 33 45 91 37 73 39 49 59 5 21 43 87 35 5 63 89 57 63 47 29 99 19 85 13 13 3 13 43 19 5 9 61 51 51 57 15 89 13 97 41 13 99 79 13 27 97 95 73 33 99 27 23",
"output": "1"
},
{
"input": "98\n61 56 44 30 58 14 20 24 88 28 46 56 96 52 58 42 94 50 46 30 46 80 72 88 68 16 6 60 26 90 10 98 76 20 56 40 30 16 96 20 88 32 62 30 74 58 36 76 60 4 24 36 42 54 24 92 28 14 2 74 86 90 14 52 34 82 40 76 8 64 2 56 10 8 78 16 70 86 70 42 70 74 22 18 76 98 88 28 62 70 36 72 20 68 34 48 80 98",
"output": "1"
},
{
"input": "98\n66 26 46 42 78 32 76 42 26 82 8 12 4 10 24 26 64 44 100 46 94 64 30 18 88 28 8 66 30 82 82 28 74 52 62 80 80 60 94 86 64 32 44 88 92 20 12 74 94 28 34 58 4 22 16 10 94 76 82 58 40 66 22 6 30 32 92 54 16 76 74 98 18 48 48 30 92 2 16 42 84 74 30 60 64 52 50 26 16 86 58 96 79 60 20 62 82 94",
"output": "93"
},
{
"input": "95\n9 31 27 93 17 77 75 9 9 53 89 39 51 99 5 1 11 39 27 49 91 17 27 79 81 71 37 75 35 13 93 4 99 55 85 11 23 57 5 43 5 61 15 35 23 91 3 81 99 85 43 37 39 27 5 67 7 33 75 59 13 71 51 27 15 93 51 63 91 53 43 99 25 47 17 71 81 15 53 31 59 83 41 23 73 25 91 91 13 17 25 13 55 57 29",
"output": "32"
},
{
"input": "100\n91 89 81 45 53 1 41 3 77 93 55 97 55 97 87 27 69 95 73 41 93 21 75 35 53 56 5 51 87 59 91 67 33 3 99 45 83 17 97 47 75 97 7 89 17 99 23 23 81 25 55 97 27 35 69 5 77 35 93 19 55 59 37 21 31 37 49 41 91 53 73 69 7 37 37 39 17 71 7 97 55 17 47 23 15 73 31 39 57 37 9 5 61 41 65 57 77 79 35 47",
"output": "26"
},
{
"input": "99\n38 56 58 98 80 54 26 90 14 16 78 92 52 74 40 30 84 14 44 80 16 90 98 68 26 24 78 72 42 16 84 40 14 44 2 52 50 2 12 96 58 66 8 80 44 52 34 34 72 98 74 4 66 74 56 21 8 38 76 40 10 22 48 32 98 34 12 62 80 68 64 82 22 78 58 74 20 22 48 56 12 38 32 72 6 16 74 24 94 84 26 38 18 24 76 78 98 94 72",
"output": "56"
},
{
"input": "100\n44 40 6 40 56 90 98 8 36 64 76 86 98 76 36 92 6 30 98 70 24 98 96 60 24 82 88 68 86 96 34 42 58 10 40 26 56 10 88 58 70 32 24 28 14 82 52 12 62 36 70 60 52 34 74 30 78 76 10 16 42 94 66 90 70 38 52 12 58 22 98 96 14 68 24 70 4 30 84 98 8 50 14 52 66 34 100 10 28 100 56 48 38 12 38 14 91 80 70 86",
"output": "97"
},
{
"input": "100\n96 62 64 20 90 46 56 90 68 36 30 56 70 28 16 64 94 34 6 32 34 50 94 22 90 32 40 2 72 10 88 38 28 92 20 26 56 80 4 100 100 90 16 74 74 84 8 2 30 20 80 32 16 46 92 56 42 12 96 64 64 42 64 58 50 42 74 28 2 4 36 32 70 50 54 92 70 16 45 76 28 16 18 50 48 2 62 94 4 12 52 52 4 100 70 60 82 62 98 42",
"output": "79"
},
{
"input": "99\n14 26 34 68 90 58 50 36 8 16 18 6 2 74 54 20 36 84 32 50 52 2 26 24 3 64 20 10 54 26 66 44 28 72 4 96 78 90 96 86 68 28 94 4 12 46 100 32 22 36 84 32 44 94 76 94 4 52 12 30 74 4 34 64 58 72 44 16 70 56 54 8 14 74 8 6 58 62 98 54 14 40 80 20 36 72 28 98 20 58 40 52 90 64 22 48 54 70 52",
"output": "25"
},
{
"input": "95\n82 86 30 78 6 46 80 66 74 72 16 24 18 52 52 38 60 36 86 26 62 28 22 46 96 26 94 84 20 46 66 88 76 32 12 86 74 18 34 88 4 48 94 6 58 6 100 82 4 24 88 32 54 98 34 48 6 76 42 88 42 28 100 4 22 2 10 66 82 54 98 20 60 66 38 98 32 47 86 58 6 100 12 46 2 42 8 84 78 28 24 70 34 28 86",
"output": "78"
},
{
"input": "90\n40 50 8 42 76 24 58 42 26 68 20 48 54 12 34 84 14 36 32 88 6 50 96 56 20 92 48 16 40 34 96 46 20 84 30 50 20 98 8 44 96 42 8 76 70 38 84 30 40 88 84 72 2 22 52 58 16 62 100 66 80 40 50 32 14 62 88 72 22 99 76 50 84 82 8 82 98 46 26 40 2 98 18 78 30 72 70 18 34 68",
"output": "70"
},
{
"input": "80\n81 43 87 1 55 43 53 61 27 19 43 13 89 9 33 83 75 55 97 71 91 37 95 5 21 69 81 93 95 69 31 83 55 7 97 7 79 57 8 61 27 85 49 1 15 97 63 79 29 73 41 85 5 41 31 93 67 11 63 59 15 99 91 77 43 69 23 23 81 73 19 1 67 51 1 75 99 67 3 81",
"output": "39"
},
{
"input": "98\n13 83 61 27 35 1 85 95 97 73 95 65 73 45 5 43 27 83 91 19 11 3 85 59 9 39 69 23 45 7 51 85 5 71 5 95 1 51 75 3 43 57 3 11 33 71 21 99 47 41 87 39 71 87 31 85 91 49 83 5 49 85 47 91 55 99 33 23 31 23 23 73 29 77 55 31 25 5 81 49 91 15 15 39 87 5 9 40 69 47 29 33 11 21 49 79 51 83",
"output": "88"
},
{
"input": "3\n100 100 1",
"output": "3"
}
] | 1,673,202,581
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 62
| 0
|
# -*- coding: utf-8 -*-
"""
username: fefe_montete
problem:IQ test
language:Python 3
"""
n = int(input())
s = list(map(int,input().split()))
pares = 0
impares = 0
i = 0
while pares<2 and impares<2:
if s[i]%2==0:
pares+=1
else:
impares+=1
if pares<impares:
for j in range(n):
if s[j]%2==0:
print(j+1)
break
else:
for j in range(n):
if s[j]%2!=0:
print(j+1)
break
|
Title: IQ test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that is different in evenness.
Input Specification:
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness.
Output Specification:
Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order.
Demo Input:
['5\n2 4 7 8 10\n', '4\n1 2 1 1\n']
Demo Output:
['3\n', '2\n']
Note:
none
|
```python
# -*- coding: utf-8 -*-
"""
username: fefe_montete
problem:IQ test
language:Python 3
"""
n = int(input())
s = list(map(int,input().split()))
pares = 0
impares = 0
i = 0
while pares<2 and impares<2:
if s[i]%2==0:
pares+=1
else:
impares+=1
if pares<impares:
for j in range(n):
if s[j]%2==0:
print(j+1)
break
else:
for j in range(n):
if s[j]%2!=0:
print(j+1)
break
```
| 0
|
126
|
B
|
Password
|
PROGRAMMING
| 1,700
|
[
"binary search",
"dp",
"hashing",
"string suffix structures",
"strings"
] | null | null |
Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them.
A little later they found a string *s*, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring *t* of the string *s*.
Prefix supposed that the substring *t* is the beginning of the string *s*; Suffix supposed that the substring *t* should be the end of the string *s*; and Obelix supposed that *t* should be located somewhere inside the string *s*, that is, *t* is neither its beginning, nor its end.
Asterix chose the substring *t* so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring *t* aloud, the temple doors opened.
You know the string *s*. Find the substring *t* or determine that such substring does not exist and all that's been written above is just a nice legend.
|
You are given the string *s* whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters.
|
Print the string *t*. If a suitable *t* string does not exist, then print "Just a legend" without the quotes.
|
[
"fixprefixsuffix\n",
"abcdabc\n"
] |
[
"fix",
"Just a legend"
] |
none
| 1,000
|
[
{
"input": "fixprefixsuffix",
"output": "fix"
},
{
"input": "abcdabc",
"output": "Just a legend"
},
{
"input": "qwertyqwertyqwerty",
"output": "qwerty"
},
{
"input": "papapapap",
"output": "papap"
},
{
"input": "aaaaaaaaaa",
"output": "aaaaaaaa"
},
{
"input": "ghbdtn",
"output": "Just a legend"
},
{
"input": "a",
"output": "Just a legend"
},
{
"input": "aa",
"output": "Just a legend"
},
{
"input": "ab",
"output": "Just a legend"
},
{
"input": "aaa",
"output": "a"
},
{
"input": "aba",
"output": "Just a legend"
},
{
"input": "aab",
"output": "Just a legend"
},
{
"input": "abb",
"output": "Just a legend"
},
{
"input": "abc",
"output": "Just a legend"
},
{
"input": "aaabaabaaaaab",
"output": "Just a legend"
},
{
"input": "aabaaabaaaaab",
"output": "aab"
},
{
"input": "aaabaaaabab",
"output": "Just a legend"
},
{
"input": "abcabcabcabcabc",
"output": "abcabcabc"
},
{
"input": "aaaaabaaaa",
"output": "aaaa"
},
{
"input": "aaaabaaaaaaa",
"output": "aaaa"
},
{
"input": "ghghghgxghghghg",
"output": "ghghg"
},
{
"input": "kincenvizh",
"output": "Just a legend"
},
{
"input": "amcksgurlgqzqizdauqminfzshiweejkevbazyzylrrghumnvqeqqdedyopgtvxakqwpvxntxgrkrcxabhrgoxngrwrxrvcguuyw",
"output": "Just a legend"
},
{
"input": "kwuaizneqxfflhmyruotjlkqksinoanvkyvqptkkntnpjdyzicceelgooajdgpkneuhyvhdtmasiglplajxolxovlhkwuaizneqx",
"output": "Just a legend"
},
{
"input": "nfbdzgdlbjhrlvfryyjbvtsmzacxglcvukmyexdgpuiwvqbnfbdzgdlbjhrlvfryyjbtuomcwbwvlhefnfbdzgdlbjhrlvfryyjb",
"output": "nfbdzgdlbjhrlvfryyjb"
},
{
"input": "btbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgpmvbxbyszdugvmoyjeeqsywcvuqskcjotyhvdijyslgfvyujxthngnonasgnbzzygyikheelirdfsvuicbiazfdeqecbtbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgpccdtdteohtjjuicfjfcbzpynlqhecyqqrjpmexgfqywnfmusldgzvgnzdmuuujtkdfnlytzgstquwqpuccxbtbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgp",
"output": "btbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgp"
},
{
"input": "abcazabca",
"output": "a"
}
] | 1,618,009,450
| 2,147,483,647
|
PyPy 3
|
MEMORY_LIMIT_EXCEEDED
|
TESTS
| 24
| 560
| 268,390,400
|
def bs(s,arr, x):
low = 0
high = len(arr) - 1
mid = 0
while low <= high:
mid=(high+low)//2
sraux=s[arr[mid]+1:len(s)-1]
if x==sraux[0:len(x)]:
return True
elif sraux < x:
low = mid + 1
elif sraux > x:
high = mid - 1
return False
def main():
s=input()
if len(s)<3:
print("Just a legend")
return
saux=s[1:len(s)-1]
r=sorted(range(len(saux)), key=lambda i: saux[i:])
c1=len(s)
while(c1>0):
if s[0:c1]==s[len(s)-c1:len(s)]:
if bs(s,r,s[0:c1]):
print(s[0:c1])
return
c1-=1
print("Just a legend")
return
main()
|
Title: Password
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them.
A little later they found a string *s*, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring *t* of the string *s*.
Prefix supposed that the substring *t* is the beginning of the string *s*; Suffix supposed that the substring *t* should be the end of the string *s*; and Obelix supposed that *t* should be located somewhere inside the string *s*, that is, *t* is neither its beginning, nor its end.
Asterix chose the substring *t* so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring *t* aloud, the temple doors opened.
You know the string *s*. Find the substring *t* or determine that such substring does not exist and all that's been written above is just a nice legend.
Input Specification:
You are given the string *s* whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters.
Output Specification:
Print the string *t*. If a suitable *t* string does not exist, then print "Just a legend" without the quotes.
Demo Input:
['fixprefixsuffix\n', 'abcdabc\n']
Demo Output:
['fix', 'Just a legend']
Note:
none
|
```python
def bs(s,arr, x):
low = 0
high = len(arr) - 1
mid = 0
while low <= high:
mid=(high+low)//2
sraux=s[arr[mid]+1:len(s)-1]
if x==sraux[0:len(x)]:
return True
elif sraux < x:
low = mid + 1
elif sraux > x:
high = mid - 1
return False
def main():
s=input()
if len(s)<3:
print("Just a legend")
return
saux=s[1:len(s)-1]
r=sorted(range(len(saux)), key=lambda i: saux[i:])
c1=len(s)
while(c1>0):
if s[0:c1]==s[len(s)-c1:len(s)]:
if bs(s,r,s[0:c1]):
print(s[0:c1])
return
c1-=1
print("Just a legend")
return
main()
```
| 0
|
|
595
|
A
|
Vitaly and Night
|
PROGRAMMING
| 800
|
[
"constructive algorithms",
"implementation"
] | null | null |
One day Vitaly was going home late at night and wondering: how many people aren't sleeping at that moment? To estimate, Vitaly decided to look which windows are lit in the house he was passing by at that moment.
Vitaly sees a building of *n* floors and 2·*m* windows on each floor. On each floor there are *m* flats numbered from 1 to *m*, and two consecutive windows correspond to each flat. If we number the windows from 1 to 2·*m* from left to right, then the *j*-th flat of the *i*-th floor has windows 2·*j*<=-<=1 and 2·*j* in the corresponding row of windows (as usual, floors are enumerated from the bottom). Vitaly thinks that people in the flat aren't sleeping at that moment if at least one of the windows corresponding to this flat has lights on.
Given the information about the windows of the given house, your task is to calculate the number of flats where, according to Vitaly, people aren't sleeping.
|
The first line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of floors in the house and the number of flats on each floor respectively.
Next *n* lines describe the floors from top to bottom and contain 2·*m* characters each. If the *i*-th window of the given floor has lights on, then the *i*-th character of this line is '1', otherwise it is '0'.
|
Print a single integer — the number of flats that have lights on in at least one window, that is, the flats where, according to Vitaly, people aren't sleeping.
|
[
"2 2\n0 0 0 1\n1 0 1 1\n",
"1 3\n1 1 0 1 0 0\n"
] |
[
"3\n",
"2\n"
] |
In the first test case the house has two floors, two flats on each floor. That is, in total there are 4 flats. The light isn't on only on the second floor in the left flat. That is, in both rooms of the flat the light is off.
In the second test case the house has one floor and the first floor has three flats. The light is on in the leftmost flat (in both windows) and in the middle flat (in one window). In the right flat the light is off.
| 500
|
[
{
"input": "2 2\n0 0 0 1\n1 0 1 1",
"output": "3"
},
{
"input": "1 3\n1 1 0 1 0 0",
"output": "2"
},
{
"input": "3 3\n1 1 1 1 1 1\n1 1 0 1 1 0\n1 0 0 0 1 1",
"output": "8"
},
{
"input": "1 5\n1 0 1 1 1 0 1 1 1 1",
"output": "5"
},
{
"input": "1 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 0 1 1 1 1 0 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 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 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "99"
},
{
"input": "1 100\n0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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 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 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 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 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
"output": "6"
},
{
"input": "1 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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": "0"
},
{
"input": "100 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 0\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n0 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 0\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 0\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n0 1\n1 1\n1 1\n1 0\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1",
"output": "100"
},
{
"input": "100 1\n0 0\n0 0\n0 1\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\n1 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 1\n0 0\n0 0\n0 0\n1 0\n0 0\n0 0\n0 0\n1 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 1\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 1\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\n1 0",
"output": "8"
},
{
"input": "100 1\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": "1 1\n0 0",
"output": "0"
},
{
"input": "1 1\n0 1",
"output": "1"
},
{
"input": "1 1\n1 0",
"output": "1"
},
{
"input": "1 1\n1 1",
"output": "1"
}
] | 1,574,547,174
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 108
| 0
|
n,m=input().split()
n=int(n)
m=int(m)
c=0
for x in range (n):
a=list(map(int,input().split()))[:2*m]
for y in range(m):
for z in range (y,y+2):
if a[z]==1:
c+=1
break
print(c+1)
|
Title: Vitaly and Night
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Vitaly was going home late at night and wondering: how many people aren't sleeping at that moment? To estimate, Vitaly decided to look which windows are lit in the house he was passing by at that moment.
Vitaly sees a building of *n* floors and 2·*m* windows on each floor. On each floor there are *m* flats numbered from 1 to *m*, and two consecutive windows correspond to each flat. If we number the windows from 1 to 2·*m* from left to right, then the *j*-th flat of the *i*-th floor has windows 2·*j*<=-<=1 and 2·*j* in the corresponding row of windows (as usual, floors are enumerated from the bottom). Vitaly thinks that people in the flat aren't sleeping at that moment if at least one of the windows corresponding to this flat has lights on.
Given the information about the windows of the given house, your task is to calculate the number of flats where, according to Vitaly, people aren't sleeping.
Input Specification:
The first line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of floors in the house and the number of flats on each floor respectively.
Next *n* lines describe the floors from top to bottom and contain 2·*m* characters each. If the *i*-th window of the given floor has lights on, then the *i*-th character of this line is '1', otherwise it is '0'.
Output Specification:
Print a single integer — the number of flats that have lights on in at least one window, that is, the flats where, according to Vitaly, people aren't sleeping.
Demo Input:
['2 2\n0 0 0 1\n1 0 1 1\n', '1 3\n1 1 0 1 0 0\n']
Demo Output:
['3\n', '2\n']
Note:
In the first test case the house has two floors, two flats on each floor. That is, in total there are 4 flats. The light isn't on only on the second floor in the left flat. That is, in both rooms of the flat the light is off.
In the second test case the house has one floor and the first floor has three flats. The light is on in the leftmost flat (in both windows) and in the middle flat (in one window). In the right flat the light is off.
|
```python
n,m=input().split()
n=int(n)
m=int(m)
c=0
for x in range (n):
a=list(map(int,input().split()))[:2*m]
for y in range(m):
for z in range (y,y+2):
if a[z]==1:
c+=1
break
print(c+1)
```
| 0
|
|
794
|
A
|
Bank Robbery
|
PROGRAMMING
| 800
|
[
"brute force",
"implementation"
] | null | null |
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the *i*-th safe from the left is called safe *i*. There are *n* banknotes left in all the safes in total. The *i*-th banknote is in safe *x**i*. Oleg is now at safe *a*. There are two security guards, one of which guards the safe *b* such that *b*<=<<=*a*, i.e. the first guard is to the left of Oleg. The other guard guards the safe *c* so that *c*<=><=*a*, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
|
The first line of input contains three space-separated integers, *a*, *b* and *c* (1<=≤<=*b*<=<<=*a*<=<<=*c*<=≤<=109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer *n* (1<=≤<=*n*<=≤<=105), denoting the number of banknotes.
The next line of input contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (1<=≤<=*x**i*<=≤<=109), denoting that the *i*-th banknote is located in the *x**i*-th safe. Note that *x**i* are not guaranteed to be distinct.
|
Output a single integer: the maximum number of banknotes Oleg can take.
|
[
"5 3 7\n8\n4 7 5 5 3 6 2 8\n",
"6 5 7\n5\n1 5 7 92 3\n"
] |
[
"4\n",
"0\n"
] |
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
| 500
|
[
{
"input": "5 3 7\n8\n4 7 5 5 3 6 2 8",
"output": "4"
},
{
"input": "6 5 7\n5\n1 5 7 92 3",
"output": "0"
},
{
"input": "3 2 4\n1\n3",
"output": "1"
},
{
"input": "5 3 8\n12\n8 3 4 5 7 6 8 3 5 4 7 6",
"output": "8"
},
{
"input": "7 3 10\n5\n3 3 3 3 3",
"output": "0"
},
{
"input": "3 2 5\n4\n1 3 4 5",
"output": "2"
},
{
"input": "3 2 4\n1\n1",
"output": "0"
},
{
"input": "6 4 8\n1\n4",
"output": "0"
},
{
"input": "2 1 3\n1\n3",
"output": "0"
}
] | 1,497,461,509
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 46
| 155
| 8,601,600
|
a,b,c=[int(i) for i in input().split()]
n=int(input())
x=[int(i) for i in input().split()]
t=0
for i in range(n):
if b==c:
if a<b:
if x[i]<b:
t+=1
elif a>b:
if x[i]>b:
t+=1
else:
if x[i]>b and x[i]<c:
t+=1
print(t)
|
Title: Bank Robbery
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the *i*-th safe from the left is called safe *i*. There are *n* banknotes left in all the safes in total. The *i*-th banknote is in safe *x**i*. Oleg is now at safe *a*. There are two security guards, one of which guards the safe *b* such that *b*<=<<=*a*, i.e. the first guard is to the left of Oleg. The other guard guards the safe *c* so that *c*<=><=*a*, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input Specification:
The first line of input contains three space-separated integers, *a*, *b* and *c* (1<=≤<=*b*<=<<=*a*<=<<=*c*<=≤<=109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer *n* (1<=≤<=*n*<=≤<=105), denoting the number of banknotes.
The next line of input contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (1<=≤<=*x**i*<=≤<=109), denoting that the *i*-th banknote is located in the *x**i*-th safe. Note that *x**i* are not guaranteed to be distinct.
Output Specification:
Output a single integer: the maximum number of banknotes Oleg can take.
Demo Input:
['5 3 7\n8\n4 7 5 5 3 6 2 8\n', '6 5 7\n5\n1 5 7 92 3\n']
Demo Output:
['4\n', '0\n']
Note:
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
|
```python
a,b,c=[int(i) for i in input().split()]
n=int(input())
x=[int(i) for i in input().split()]
t=0
for i in range(n):
if b==c:
if a<b:
if x[i]<b:
t+=1
elif a>b:
if x[i]>b:
t+=1
else:
if x[i]>b and x[i]<c:
t+=1
print(t)
```
| 3
|
|
716
|
B
|
Complete the Word
|
PROGRAMMING
| 1,300
|
[
"greedy",
"two pointers"
] | null | null |
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
|
The first and only line of the input contains a single string *s* (1<=≤<=|*s*|<=≤<=50<=000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
|
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print <=-<=1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
|
[
"ABC??FGHIJK???OPQR?TUVWXY?\n",
"WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO\n",
"??????????????????????????\n",
"AABCDEFGHIJKLMNOPQRSTUVW??M\n"
] |
[
"ABCDEFGHIJKLMNOPQRZTUVWXYS",
"-1",
"MNBVCXZLKJHGFDSAQPWOEIRUYT",
"-1"
] |
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
| 1,000
|
[
{
"input": "ABC??FGHIJK???OPQR?TUVWXY?",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO",
"output": "-1"
},
{
"input": "??????????????????????????",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "AABCDEFGHIJKLMNOPQRSTUVW??M",
"output": "-1"
},
{
"input": "QWERTYUIOPASDFGHJKL???????",
"output": "QWERTYUIOPASDFGHJKLBCMNVXZ"
},
{
"input": "ABABABBAB????????????ABABABABA???????????ABABABABA?????????KLCSJB?????????Z",
"output": "ABABABBABAAAAAAAAAAAAABABABABAAAAAAAAAAAAABABABABADEFGHIMNOKLCSJBPQRTUVWXYZ"
},
{
"input": "Q?E?T?U?O?A?D?G?J?L?X?V?MMQ?E?T?U?O?A?D?G?J?L?X?V?N",
"output": "QAEATAUAOAAADAGAJALAXAVAMMQBECTFUHOIAKDPGRJSLWXYVZN"
},
{
"input": "???????????????????????????",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZA"
},
{
"input": "EJMGJAXCHXYIKZSQKUGRCLSTWDLNCVZIGXGWILAVFBEIGOHWGVEPRJTHWEDQRPOVZUQOSRVTIHFFHJMCLOWGHCIGJBCAAVBJFMJEFTEGFXZFVRZOXAFOFVXRAIZEWIKILFLYDZVDADYWYWYJXAGDFGNZBQKKKTGWPINLCDBZVULROGAKEKXXTWNYKQBMLQMQRUYOWUTWMNTJVGUXENHXWMFWMSBKVNGXSNFFTRTTGEGBBHMFZTKNJQDYUQOXVDWTDHZCCQNYYIOFPMKYQIGEEYBCKBAYVCTWARVMHIENKXKFXNXEFUHUNRQPEDFUBMKNQOYCQHGTLRHLWUAVZJDRBRTSVQHBKRDJFKKYEZAJWJKATRFZLNELPYGFUIWBXLIWVTHUILJHTQKDGRNCFTFELCOQPJDBYSPYJOUDKIFRCKEMJPUXTTAMHVENEVMNTZLUYSUALQOUPPRLZHCYICXAQFFRQZAAJNFKVRJDMDXFTBRJSAAHTSVG",
"output": "-1"
},
{
"input": "SVBWLLLPMPJUQVIGVXPCKMPEBPWMYORVTYELJOQGKEOJVCRBUJOOKQZQBYJIBCSHGSDBTIIMNGAXAQJRHHKQFAJSOJLAYRKWBASMLBQVUPPQWDGAVKDLFHEHVVWGSYQHYCPDIECHBTOIFYUFGKWIIMCKEBLECHCETBQMJPBPPGDHRLJIIMVJBZDRSDWWEJASQFRSCLOBAOLZQDPEZWDLMYTGDLUHCJMTXVURWQFCFDIGSUADTFMNGVHRYHQKWBGWWLQJQSFSWXGWIYUTSBUNZFDONBCFTGWTTQIISXJZUWSZWXXFMNB?UWPOWVWIWMBAPXYMGTRSGWMQRXULCMDTUKZS?CNMBRIYDZCUQWAKYQLLJLTXSVMUAYZHVBZFYBABBECIADQPUPZVVYHTGKOWKDNEUYPBTNUSQLLQRODUXFMSYUYIQGERINAPZWL?VKBVQJQLUJGDPFHNVXXSNOWHBZPMLOXVC?IEUMVLIBYLEATFUTILPPTP",
"output": "-1"
},
{
"input": "DMWSBHPGSJJD?EEV?CYAXQCCGNNQWNN?OMEDD?VC?CTKNQQPYXKKJFAYMJ?FMPXXCLKOL?OTRCE",
"output": "-1"
},
{
"input": "EOYJRKFABJIUOZILSHHCXIFQTXAVXJOVTQCDHXPNYPW?RVRKTB?OVXEL?NQHMZZXJLGSA?OTFSZQBV?SBHGKPJPCIQMLRSYDCFPYMEMXUEVHANXELHKSKNLGHGDCYMURXQRWMHEYXXCMGMUFZIPVOZQQBJGVKESTCDZCWFUCSGGIRWMXYXJLFLGUXQAWLZIKFUTVYDGKBVKBKXTICIKHXWFVJRHNMYRJZYNNYXMUOFERZPY?AJKSMUCTLOFH?LV?EHHCHKBHOJZAHFKJHHZJKZIEYAOAPDQRIUWDBMJGOOSNWN?CBKUXJCTEWVTRBDCNFMGBJUAODCCZVPZBQJNIRJVVF?QBWBV?AXOVOYNAWSKUVPHWJK?YPYOKTVFBWAGCC?JOWPPCAZDOYETAYYECWWURYHY?SJHMSJXDIMXFOTUWJLYDKCHOAPLFYPMFYFRNRKWY?CBPLQJJJ?BJYGBJT?FV?VDQEQAUFWZSOJHZFBVEALMMT?XP",
"output": "-1"
},
{
"input": "E?BIVQUPQQEJNMINFD?NKV?IROHPTGUIPMEVYPII?LZJMRI?FTKKKBHPOVQZZSAPDDWVSPVHOBT",
"output": "-1"
},
{
"input": "FDQHJSNDDXHJLWVZVXJZUGKVHWCZVRWVZTIURLMJNGAMCUBDGVSIDEYRJZOLDISDNTOEKLSNLBSOQZLJVPAMLEBAVUNBXNKMLZBGJJQCGCSKBFSEEDXEVSWGZHFJIZJESPZIKIONJWTFFYYZKIDBSDNPJVAUHQMRFKIJWCEGTBVZHWZEKLPHGZVKZFAFAQRNKHGACNRTSXQKKCYBMEMKNKKSURKHOSMEVUXNGOCVCLVVSKULGBKFPCEKVRAJMBWCFFFSCCNDOSEKXEFFZETTUZHMQETWCVZASTTULYOPBNMOMXMVUEEEYZHSMRPAEIHUKNPNJTARJKQKIOXDJASSQPQQHEQIQJQLVPIJRCFVOVECHBOCRYWQEDXZLJXUDZUBFTRWEWNYTSKGDBEBWFFLMUYWELNVAAXSMKYEZXQFKKHJTZKMKMYOBTVXAOVBRMAMHTBDDYMDGQYEEBYZUBMUCKLKXCZGTWVZAYJOXZVGUYNXOVAPXQVE",
"output": "-1"
},
{
"input": "KMNTIOJTLEKZW?JALAZYWYMKWRXTLAKNMDJLICZMETAKHVPTDOLAPCGHOEYSNIUJZVLPBTZ?YSR",
"output": "-1"
},
{
"input": "?MNURVAKIVSOGITVJZEZCAOZEFVNZERAHVNCVCYKTJVEHK?ZMDL?CROLIDFSG?EIFHYKELMQRBVLE?CERELHDVFODJ?LBGJVFPO?CVMPBW?DPGZMVA?BKPXQQCRMKHJWDNAJSGOTGLBNSWMXMKAQ?MWMXCNRSGHTL?LGLAHSDHAGZRGTNDFI?KJ?GSAWOEPOENXTJCVJGMYOFIQKKDWOCIKPGCMFEKNEUPFGBCBYQCM?EQSAX?HZ?MFKAUHOHRKZZSIVZCAKYIKBDJYOCZJRYNLSOKGAEGQRQ?TBURXXLHAFCNVGAUVWBXZILMHWSBYJTIMWPNEGATPURPTJYFWKHRL?QPYUQ?HKDDHWAHOWUSONQKSZFIYFMFUJAMIYAMPNBGVPJSDFDFSAHDWWGEAKXLHBURNTIMCUZIAFAOCVNKPJRNLNGSJVMGKQ?IFQSRHTZGKHGXFJBDGPLCUUMEWNOSCONIVCLAOAPPSFFLCPRIXTKNBSSOVM",
"output": "-1"
},
{
"input": "MRHKVVRBFEIFWIZGWCATJPBSZWNYANEWSSEVFQUUVNJKQOKVIGYBPFSZFTBUCNQEJEYVOWSPYER",
"output": "-1"
},
{
"input": "CNRFBWKRTQTDFOMIGPPGDBHPRNRXFASDDBCZXHORGXDRSIORLJEROJBLLEHLNBILBPX?KHQLCOUPTKUADCDNHNBWMVNUUVUFPIRXSPNUCCRLJTDSUIUDLBKNKMXSAVBJDUGWIMNBIUWJX?TCBDEBNDYUGPS?MQSSEIIUGEE?XXKW?CMFQMWUAEXTSZNNOCPHBAEAKWALYBBMUMQZXUKTQPWNMZKIDECWIZFHKQIUJZRSBZPQFUQNVKQZMYJDHXZWXFHIZ?HWPIPIWV?JMIYKEJDNPMKTTOY?NTOMZZXTNMWQENYRWFYM?WLJJFCIJSETZSJORBZZHAFWYKGQJAPYQQXUWROOZUDOJJLNCDRSGUKYAZLLENGUICGOYPLJQ?POSKHPMOFJMAOXCITWWL?LOEDKHZPQFZZCTB?JYZNXZSDREAMGGXHMCFTQNOUALEYHULSDQVOXZIWFHNNHHG?FYUOCQNKBLFGGZ?YNFNVLRMENYBDWMDSP",
"output": "-1"
},
{
"input": "KSRVTPFVRJWNPYUZMXBRLKVXIQPPBYVSYKRQPNGKTKRPFMKLIYFACFKBIQGPAXLEUESVGPBBXLY",
"output": "-1"
},
{
"input": "LLVYUOXHBHUZSAPUMQEKWSQAFRKSMEENXDQYOPQFXNNFXSRBGXFUIRBFJDSDKQIDMCPPTWRJOZCRHZYZPBVUJPQXHNALAOCJDTTBDZWYDBVPMNSQNVMLHHUJAOIWFSEJEJSRBYREOZKHEXTBAXPTISPGIPOYBFFEJNAKKXAEPNGKWYGEJTNEZIXAWRSCEIRTKNEWSKSGKNIKDEOVXGYVEVFRGTNDFNWIFDRZQEJQZYIWNZXCONVZAKKKETPTPPXZMIVDWPGXOFODRNJZBATKGXAPXYHTUUFFASCHOLSMVSWBIJBAENEGNQTWKKOJUYQNXWDCDXBXBJOOWETWLQMGKHAJEMGXMYNVEHRAEGZOJJQPZGYRHXRNKMSWFYDIZLIBUTSKIKGQJZLGZQFJVIMNOHNZJKWVVPFMFACVXKJKTBZRXRZDJKSWSXBBKWIKEICSZEIPTOJCKJQYYPNUPRNPQNNCVITNXPLAKQBYAIQGNAHXDUQWQLYN",
"output": "-1"
},
{
"input": "PVCKCT?KLTFPIBBIHODCAABEQLJKQECRUJUSHSXPMBEVBKHQTIKQLBLTIRQZPOGPWMMNWWCUKAD",
"output": "-1"
},
{
"input": "BRTYNUVBBWMFDSRXAMLNSBIN???WDDQVPCSWGJTHLRAKTPFKGVLHAKNRIEYIDDRDZLLTBRKXRVRSPBSLXIZRRBEVMHJSAFPLZAIHFVTTEKDO?DYWKILEYRM?VHSEQCBYZZRZMICVZRYA?ONCSZOPGZUMIHJQJPIFX?YJMIERCMKTSFTDZIKEZPLDEOOCJLQIZ?RPHUEQHPNNSBRQRTDGLWNSCZ?WQVIZPTOETEXYI?DRQUOMREPUTOAJKFNBGYNWMGCAOELXEPLLZEYHTVLT?ETJJXLHJMAUDQESNQ?ZCGNDGI?JSGUXQV?QAWQIYKXBKCCSWNRTGHPZF?CSWDQSAZIWQNHOWHYAEZNXRMPAZEQQPPIBQQJEDHJEDHVXNEDETEN?ZHEPJJ?VVDYGPJUWGCBMB?ANFJHJXQVAJWCAZEZXZX?BACPPXORNENMCRMQPIYKNPHX?NSKGEABWWVLHQ?ESWLJUPQJSFIUEGMGHEYVLYEDWJG?L",
"output": "-1"
},
{
"input": "TESTEIGHTYFOUR",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRSTUVWXY",
"output": "-1"
},
{
"input": "?????????????????????????",
"output": "-1"
},
{
"input": "Q?RYJPGLNQ",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRZTUVWXYS",
"output": "ABCDEFGHIJKLMNOPQRZTUVWXYS"
},
{
"input": "AACDEFGHIJKLMNOPQRZTUVWXYS",
"output": "-1"
},
{
"input": "ZA?ABCDEFGHIJKLMNOPQRSTUVWXY",
"output": "ZAZABCDEFGHIJKLMNOPQRSTUVWXY"
},
{
"input": "AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRSTUVWXYYYZABC",
"output": "-1"
},
{
"input": "????",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRZTUVWXYS??",
"output": "ABCDEFGHIJKLMNOPQRZTUVWXYSAA"
},
{
"input": "A",
"output": "-1"
},
{
"input": "NKBDABACEFGGGIJLLLLMMMOMPQWZSSRHHTTUWUWVXYY",
"output": "-1"
},
{
"input": "AA",
"output": "-1"
},
{
"input": "BAAAAAAAAAAAAAAAAAAAAAAAAAAAXA?CDEFGHIJKLMNOPQRSTUVWXYZ",
"output": "BAAAAAAAAAAAAAAAAAAAAAAAAAAAXABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "???DEFGHIJKL??L?PQRSTUVW???",
"output": "-1"
},
{
"input": "?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A?A",
"output": "-1"
},
{
"input": "A?AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA?????????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA???????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA??????????",
"output": "-1"
},
{
"input": "ZXXCVBNMLKJHGFDSAQWWERTYUIOP",
"output": "-1"
},
{
"input": "ABCA???????????????????????",
"output": "ABCADEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "AB",
"output": "-1"
},
{
"input": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
"output": "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "BCDEFGHIAJKLMNOPQARSTUVWXYZ",
"output": "-1"
},
{
"input": "AABBCDEFGHIJKLMNOPQRSTUVWXYZ",
"output": "-1"
},
{
"input": "???AA????????????????????BB???",
"output": "-1"
},
{
"input": "ABC??FGAHIJ??MNOPQRST??WXYZ",
"output": "ABCDEFGAHIJKLMNOPQRSTUVWXYZ"
},
{
"input": "QWERTYUIOPASDFGHJKLZXCVBN",
"output": "-1"
},
{
"input": "??????AAAAAAAAAAAAAAAAAAAABBBBB??????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBB????????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA??????????AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASSSSSSSSFFFFFFF?????????DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD??????WWWWWWWWWWEEEEEEEEEEERRRRRRRRRRRRRRRRRRRRRRRRRHHHHHHHHHH?????",
"output": "-1"
}
] | 1,598,928,485
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 93
| 204,800
|
a=input()
b=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
'P','Q','R','S','T','U','V','W','X','Y','Z']
c=set(a)
if(len(a)>26):
print(-1)
elif(len(a)==26):
for i in a:
if(i in b):
b.remove(i)
else:
continue
c.remove('?')
for i in b:
c.add(i)
# print(c)
r=list(c)
print(''.join(r))
# c=input()
# b=0
# a=set(c)
# d=[]
# if 'A' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','A')
# if 'B' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','B')
# if 'C' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','C')
# if 'D' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','D')
# if 'E' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','E')
# if 'F' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','F')
# if 'G' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','G')
# if 'H' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','H')
# if 'I' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','I')
# if 'J' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','J')
# if 'K' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','K')
# if 'L' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','L')
# if 'M' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','M')
# if 'N' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','N')
# if 'O' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','O')
# if 'P' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','P')
# if 'Q' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','Q')
# # #d.append('Q')
# if 'R' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','R')
# # #d.append('R')
# if 'S' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','S')
# # #d.append('S')
# if 'T' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','T')
# # #d.append('T')
# if 'U' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','U')
# # #d.append('U')
# if 'V' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','V')
# # #d.append('V')
# if 'W' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','W')
# # #d.append('W')
# if 'X' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','X')
# # #d.append('X')
# if 'Y' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','Y')
# # #d.append('Y')
# if 'Z' in a:
# b+=1
#
# if('?' in c):
# x=c.count('?')
#
# if(x==len(c)-b):
# print(1)
|
Title: Complete the Word
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input Specification:
The first and only line of the input contains a single string *s* (1<=≤<=|*s*|<=≤<=50<=000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output Specification:
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print <=-<=1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Demo Input:
['ABC??FGHIJK???OPQR?TUVWXY?\n', 'WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO\n', '??????????????????????????\n', 'AABCDEFGHIJKLMNOPQRSTUVW??M\n']
Demo Output:
['ABCDEFGHIJKLMNOPQRZTUVWXYS', '-1', 'MNBVCXZLKJHGFDSAQPWOEIRUYT', '-1']
Note:
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
|
```python
a=input()
b=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
'P','Q','R','S','T','U','V','W','X','Y','Z']
c=set(a)
if(len(a)>26):
print(-1)
elif(len(a)==26):
for i in a:
if(i in b):
b.remove(i)
else:
continue
c.remove('?')
for i in b:
c.add(i)
# print(c)
r=list(c)
print(''.join(r))
# c=input()
# b=0
# a=set(c)
# d=[]
# if 'A' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','A')
# if 'B' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','B')
# if 'C' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','C')
# if 'D' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','D')
# if 'E' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','E')
# if 'F' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','F')
# if 'G' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','G')
# if 'H' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','H')
# if 'I' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','I')
# if 'J' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','J')
# if 'K' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','K')
# if 'L' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','L')
# if 'M' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','M')
# if 'N' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','N')
# if 'O' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','O')
# if 'P' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','P')
# if 'Q' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','Q')
# # #d.append('Q')
# if 'R' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','R')
# # #d.append('R')
# if 'S' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','S')
# # #d.append('S')
# if 'T' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','T')
# # #d.append('T')
# if 'U' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','U')
# # #d.append('U')
# if 'V' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','V')
# # #d.append('V')
# if 'W' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','W')
# # #d.append('W')
# if 'X' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','X')
# # #d.append('X')
# if 'Y' in a:
# b+=1
# # else:
# # if('?' in a):
# # c.replace('?','Y')
# # #d.append('Y')
# if 'Z' in a:
# b+=1
#
# if('?' in c):
# x=c.count('?')
#
# if(x==len(c)-b):
# print(1)
```
| 0
|
|
113
|
A
|
Grammar Lessons
|
PROGRAMMING
| 1,600
|
[
"implementation",
"strings"
] |
A. Grammar Lessons
|
5
|
256
|
Petya got interested in grammar on his third year in school. He invented his own language called Petya's. Petya wanted to create a maximally simple language that would be enough to chat with friends, that's why all the language's grammar can be described with the following set of rules:
- There are three parts of speech: the adjective, the noun, the verb. Each word in his language is an adjective, noun or verb. - There are two genders: masculine and feminine. Each word in his language has gender either masculine or feminine. - Masculine adjectives end with -lios, and feminine adjectives end with -liala. - Masculine nouns end with -etr, and feminime nouns end with -etra. - Masculine verbs end with -initis, and feminime verbs end with -inites. - Thus, each word in the Petya's language has one of the six endings, given above. There are no other endings in Petya's language. - It is accepted that the whole word consists of an ending. That is, words "lios", "liala", "etr" and so on belong to the Petya's language. - There aren't any punctuation marks, grammatical tenses, singular/plural forms or other language complications. - A sentence is either exactly one valid language word or exactly one statement.
Statement is any sequence of the Petya's language, that satisfy both conditions:
- Words in statement follow in the following order (from the left to the right): zero or more adjectives followed by exactly one noun followed by zero or more verbs. - All words in the statement should have the same gender.
After Petya's friend Vasya wrote instant messenger (an instant messaging program) that supported the Petya's language, Petya wanted to add spelling and grammar checking to the program. As Vasya was in the country and Petya didn't feel like waiting, he asked you to help him with this problem. Your task is to define by a given sequence of words, whether it is true that the given text represents exactly one sentence in Petya's language.
|
The first line contains one or more words consisting of lowercase Latin letters. The overall number of characters (including letters and spaces) does not exceed 105.
It is guaranteed that any two consecutive words are separated by exactly one space and the input data do not contain any other spaces. It is possible that given words do not belong to the Petya's language.
|
If some word of the given text does not belong to the Petya's language or if the text contains more that one sentence, print "NO" (without the quotes). Otherwise, print "YES" (without the quotes).
|
[
"petr\n",
"etis atis animatis etis atis amatis\n",
"nataliala kataliala vetra feinites\n"
] |
[
"YES\n",
"NO\n",
"YES\n"
] |
none
| 500
|
[
{
"input": "petr",
"output": "YES"
},
{
"input": "etis atis animatis etis atis amatis",
"output": "NO"
},
{
"input": "nataliala kataliala vetra feinites",
"output": "YES"
},
{
"input": "qweasbvflios",
"output": "YES"
},
{
"input": "lios lios petr initis qwe",
"output": "NO"
},
{
"input": "lios initis",
"output": "NO"
},
{
"input": "petr initis lios",
"output": "NO"
},
{
"input": "petra petra petra",
"output": "NO"
},
{
"input": "in",
"output": "NO"
},
{
"input": "liala petra initis",
"output": "NO"
},
{
"input": "liala petra inites",
"output": "YES"
},
{
"input": "liala initis",
"output": "NO"
},
{
"input": "liala petra petr inites",
"output": "NO"
},
{
"input": "liala petr inites",
"output": "NO"
},
{
"input": "llilitos",
"output": "NO"
},
{
"input": "umeszdawsvgkjhlqwzentsphxqhdungbylhnikwviuhccbstghhxlmvcjznnkjqkugsdysjbedwpmsmxmgxlrlxctnebtbwrsvgjktkrosffwymovxvsgfmmqwfflpvbumozikroxrdgwjrnstngstxbiyyuxehrhviteptedlmyetr",
"output": "YES"
},
{
"input": "i i i i i i i i i i i i i i i a a a a a a v v v v v v v v v v v",
"output": "NO"
},
{
"input": "fbvzqonvdlqdanwliolaqfj sbauorbinites xkbfnfinitespjy phbexglblzpobtqpisyijycmtliola aosinites lbpjiwcjoqyuhglthloiniteswb mjtxhoofohzzgefvhsywojcuxtetxmojrlktodhbgyrkeejgjzxkzyvrxwmyaqkeoqnvusnlrsfffrzeoqjdfumolhksqkrtzwhnforgpenziokrxlnhcapbbupctlmuetrani pigxerwetupjbkvlmgnjhdfjliolanz tqhaidxbqmdaeincxjuliola",
"output": "NO"
},
{
"input": "mfrmqetr",
"output": "YES"
},
{
"input": "hnwvfllholxfialiola cknjtxpliola daliola gqfapnhmmworliola qhetra qrisbexsrefcwzoxqwxrevinites wwldqkqhvrgwplqinites nqdpoauitczttxoinites fgbmdfpxkhahkinites",
"output": "NO"
},
{
"input": "kcymcpgqdxkudadewddualeemhixhsdazudnjdmuvxvrlrbrpsdpxpagmrogplltnifrtomdtahxwadguvetxaqkvsvnoyhowirnluhmyewzapirnpfdisvhtbenxmfezahqoflkjrfqjubwdfktnpeirodwubftzlcczzavfiooihzvnqincndisudihvbcaxptrwovekmhiiwsgzgbxydvuldlnktxtltrlajjzietkxbnhetra",
"output": "YES"
},
{
"input": "dosiydnwxemojaavfdvlwsyhzqywqjutovygtlcleklhybczhjqfzxwdmlwqwcqqyfjkzhsizlmdarrfronxqkcknwpkvhdlgatdyjisjoopvngpjggldxjfxaauoxmqirkuphydyweoixftstlozaoywnxgriscudwlokncbmaebpssccmmmfjennyjaryqlzjknnklqketra",
"output": "YES"
},
{
"input": "etretra linites",
"output": "YES"
},
{
"input": "petretra petr",
"output": "NO"
},
{
"input": "lialalios petraveryfunnypetr",
"output": "YES"
},
{
"input": "petropetrapetr petra",
"output": "NO"
},
{
"input": "lios petrnonono",
"output": "NO"
},
{
"input": "lios petr initisandinitisandliala petrainitis",
"output": "NO"
},
{
"input": "petro",
"output": "NO"
},
{
"input": "petr initesinitis",
"output": "YES"
},
{
"input": "lios initis",
"output": "NO"
},
{
"input": "liala initespetra",
"output": "YES"
},
{
"input": "lios petrapetr",
"output": "YES"
},
{
"input": "initis petr",
"output": "NO"
},
{
"input": "lioslialapetrpetrainitisinitesliosliala initesinitislioslialapetrpetrainitisinitetra",
"output": "YES"
},
{
"input": "veryfunnyprefixpetr",
"output": "YES"
},
{
"input": "veryfunnyprefixpetra",
"output": "YES"
},
{
"input": "veryfunnyprefixinitis",
"output": "YES"
},
{
"input": "veryfunnyprefixinites",
"output": "YES"
},
{
"input": "veryfunnyprefixliala",
"output": "YES"
},
{
"input": "veryfunnyprefixlios",
"output": "YES"
},
{
"input": "veryfunnyprefixlialas",
"output": "NO"
},
{
"input": "veryfunnyprefixliala veryfunnyprefixpetretra",
"output": "YES"
},
{
"input": "veryfunnyprefixlios veryfunnyprefixinitisetr",
"output": "YES"
},
{
"input": "veryfunnyprefixlios aabbinitis",
"output": "NO"
},
{
"input": "veryfunnyprefixlios inites",
"output": "NO"
},
{
"input": "lios petr initis",
"output": "YES"
},
{
"input": "liala etra inites",
"output": "YES"
},
{
"input": "lios",
"output": "YES"
},
{
"input": "liala",
"output": "YES"
},
{
"input": "initis",
"output": "YES"
},
{
"input": "inites",
"output": "YES"
},
{
"input": "tes",
"output": "NO"
},
{
"input": "tr",
"output": "NO"
},
{
"input": "a",
"output": "NO"
},
{
"input": "lios lios",
"output": "NO"
},
{
"input": "lios",
"output": "YES"
},
{
"input": "liala",
"output": "YES"
},
{
"input": "petr",
"output": "YES"
},
{
"input": "petra",
"output": "YES"
},
{
"input": "pinitis",
"output": "YES"
},
{
"input": "pinites",
"output": "YES"
},
{
"input": "plios pliala",
"output": "NO"
},
{
"input": "plios petr",
"output": "YES"
},
{
"input": "plios petra",
"output": "NO"
},
{
"input": "plios plios",
"output": "NO"
},
{
"input": "plios initis",
"output": "NO"
},
{
"input": "plios pinites",
"output": "NO"
},
{
"input": "pliala plios",
"output": "NO"
},
{
"input": "pliala ppliala",
"output": "NO"
},
{
"input": "pliala petr",
"output": "NO"
},
{
"input": "pliala petra",
"output": "YES"
},
{
"input": "pliala pinitis",
"output": "NO"
},
{
"input": "pliala pinites",
"output": "NO"
},
{
"input": "petr plios",
"output": "NO"
},
{
"input": "petr pliala",
"output": "NO"
},
{
"input": "petr petr",
"output": "NO"
},
{
"input": "petr petra",
"output": "NO"
},
{
"input": "petr pinitis",
"output": "YES"
},
{
"input": "petr pinites",
"output": "NO"
},
{
"input": "petra lios",
"output": "NO"
},
{
"input": "petra liala",
"output": "NO"
},
{
"input": "petra petr",
"output": "NO"
},
{
"input": "petra petra",
"output": "NO"
},
{
"input": "petra initis",
"output": "NO"
},
{
"input": "petra inites",
"output": "YES"
},
{
"input": "initis lios",
"output": "NO"
},
{
"input": "initis liala",
"output": "NO"
},
{
"input": "initis petr",
"output": "NO"
},
{
"input": "initis petra",
"output": "NO"
},
{
"input": "initis initis",
"output": "NO"
},
{
"input": "initis inites",
"output": "NO"
},
{
"input": "inites lios",
"output": "NO"
},
{
"input": "inites liala",
"output": "NO"
},
{
"input": "inites petr",
"output": "NO"
},
{
"input": "inites petra",
"output": "NO"
},
{
"input": "inites initis",
"output": "NO"
},
{
"input": "inites inites",
"output": "NO"
},
{
"input": "lios lios lios",
"output": "NO"
},
{
"input": "lios lios liala",
"output": "NO"
},
{
"input": "lios lios etr",
"output": "YES"
},
{
"input": "lios lios etra",
"output": "NO"
},
{
"input": "lios lios initis",
"output": "NO"
},
{
"input": "lios lios inites",
"output": "NO"
},
{
"input": "lios liala lios",
"output": "NO"
},
{
"input": "lios liala liala",
"output": "NO"
},
{
"input": "lios liala etr",
"output": "NO"
},
{
"input": "lios liala etra",
"output": "NO"
},
{
"input": "lios liala initis",
"output": "NO"
},
{
"input": "lios liala inites",
"output": "NO"
},
{
"input": "lios etr lios",
"output": "NO"
},
{
"input": "lios etr liala",
"output": "NO"
},
{
"input": "lios etr etr",
"output": "NO"
},
{
"input": "lios etr etra",
"output": "NO"
},
{
"input": "lios etr initis",
"output": "YES"
},
{
"input": "lios etr inites",
"output": "NO"
},
{
"input": "lios etra lios",
"output": "NO"
},
{
"input": "lios etra liala",
"output": "NO"
},
{
"input": "lios etra etr",
"output": "NO"
},
{
"input": "lios etra etra",
"output": "NO"
},
{
"input": "lios etra initis",
"output": "NO"
},
{
"input": "lios etra inites",
"output": "NO"
},
{
"input": "lios initis lios",
"output": "NO"
},
{
"input": "lios initis liala",
"output": "NO"
},
{
"input": "lios initis etr",
"output": "NO"
},
{
"input": "lios initis etra",
"output": "NO"
},
{
"input": "lios initis initis",
"output": "NO"
},
{
"input": "lios initis inites",
"output": "NO"
},
{
"input": "lios inites lios",
"output": "NO"
},
{
"input": "lios inites liala",
"output": "NO"
},
{
"input": "lios inites etr",
"output": "NO"
},
{
"input": "lios inites etra",
"output": "NO"
},
{
"input": "lios inites initis",
"output": "NO"
},
{
"input": "lios inites inites",
"output": "NO"
},
{
"input": "liala lios lios",
"output": "NO"
},
{
"input": "liala lios liala",
"output": "NO"
},
{
"input": "liala lios etr",
"output": "NO"
},
{
"input": "liala lios etra",
"output": "NO"
},
{
"input": "liala lios initis",
"output": "NO"
},
{
"input": "liala lios inites",
"output": "NO"
},
{
"input": "liala liala lios",
"output": "NO"
},
{
"input": "liala liala liala",
"output": "NO"
},
{
"input": "liala liala etr",
"output": "NO"
},
{
"input": "liala liala etra",
"output": "YES"
},
{
"input": "liala liala initis",
"output": "NO"
},
{
"input": "liala liala inites",
"output": "NO"
},
{
"input": "liala etr lios",
"output": "NO"
},
{
"input": "liala etr liala",
"output": "NO"
},
{
"input": "liala etr etr",
"output": "NO"
},
{
"input": "liala etr etra",
"output": "NO"
},
{
"input": "liala etr initis",
"output": "NO"
},
{
"input": "liala etr inites",
"output": "NO"
},
{
"input": "liala etra lios",
"output": "NO"
},
{
"input": "liala etra liala",
"output": "NO"
},
{
"input": "liala etra etr",
"output": "NO"
},
{
"input": "liala etra etra",
"output": "NO"
},
{
"input": "liala etra initis",
"output": "NO"
},
{
"input": "liala etra inites",
"output": "YES"
},
{
"input": "liala initis lios",
"output": "NO"
},
{
"input": "liala initis liala",
"output": "NO"
},
{
"input": "liala initis etr",
"output": "NO"
},
{
"input": "liala initis etra",
"output": "NO"
},
{
"input": "liala initis initis",
"output": "NO"
},
{
"input": "liala initis inites",
"output": "NO"
},
{
"input": "liala inites lios",
"output": "NO"
},
{
"input": "liala inites liala",
"output": "NO"
},
{
"input": "liala inites etr",
"output": "NO"
},
{
"input": "liala inites etra",
"output": "NO"
},
{
"input": "liala inites initis",
"output": "NO"
},
{
"input": "liala inites inites",
"output": "NO"
},
{
"input": "etr lios lios",
"output": "NO"
},
{
"input": "etr lios liala",
"output": "NO"
},
{
"input": "etr lios etr",
"output": "NO"
},
{
"input": "etr lios etra",
"output": "NO"
},
{
"input": "etr lios initis",
"output": "NO"
},
{
"input": "etr lios inites",
"output": "NO"
},
{
"input": "etr liala lios",
"output": "NO"
},
{
"input": "etr liala liala",
"output": "NO"
},
{
"input": "etr liala etr",
"output": "NO"
},
{
"input": "etr liala etra",
"output": "NO"
},
{
"input": "etr liala initis",
"output": "NO"
},
{
"input": "etr liala inites",
"output": "NO"
},
{
"input": "etr etr lios",
"output": "NO"
},
{
"input": "etr etr liala",
"output": "NO"
},
{
"input": "etr etr etr",
"output": "NO"
},
{
"input": "etr etr etra",
"output": "NO"
},
{
"input": "etr etr initis",
"output": "NO"
},
{
"input": "etr etr inites",
"output": "NO"
},
{
"input": "etr etra lios",
"output": "NO"
},
{
"input": "etr etra liala",
"output": "NO"
},
{
"input": "etr etra etr",
"output": "NO"
},
{
"input": "etr etra etra",
"output": "NO"
},
{
"input": "etr etra initis",
"output": "NO"
},
{
"input": "etr etra inites",
"output": "NO"
},
{
"input": "etr initis lios",
"output": "NO"
},
{
"input": "etr initis liala",
"output": "NO"
},
{
"input": "etr initis etr",
"output": "NO"
},
{
"input": "etr initis etra",
"output": "NO"
},
{
"input": "etr initis initis",
"output": "YES"
},
{
"input": "etr initis inites",
"output": "NO"
},
{
"input": "etr inites lios",
"output": "NO"
},
{
"input": "etr inites liala",
"output": "NO"
},
{
"input": "etr inites etr",
"output": "NO"
},
{
"input": "etr inites etra",
"output": "NO"
},
{
"input": "etr inites initis",
"output": "NO"
},
{
"input": "etr inites inites",
"output": "NO"
},
{
"input": "etra lios lios",
"output": "NO"
},
{
"input": "etra lios liala",
"output": "NO"
},
{
"input": "etra lios etr",
"output": "NO"
},
{
"input": "etra lios etra",
"output": "NO"
},
{
"input": "etra lios initis",
"output": "NO"
},
{
"input": "etra lios inites",
"output": "NO"
},
{
"input": "etra liala lios",
"output": "NO"
},
{
"input": "etra liala liala",
"output": "NO"
},
{
"input": "etra liala etr",
"output": "NO"
},
{
"input": "etra liala etra",
"output": "NO"
},
{
"input": "etra liala initis",
"output": "NO"
},
{
"input": "etra liala inites",
"output": "NO"
},
{
"input": "etra etr lios",
"output": "NO"
},
{
"input": "etra etr liala",
"output": "NO"
},
{
"input": "etra etr etr",
"output": "NO"
},
{
"input": "etra etr etra",
"output": "NO"
},
{
"input": "etra etr initis",
"output": "NO"
},
{
"input": "etra etr inites",
"output": "NO"
},
{
"input": "etra etra lios",
"output": "NO"
},
{
"input": "etra etra liala",
"output": "NO"
},
{
"input": "etra etra etr",
"output": "NO"
},
{
"input": "etra etra etra",
"output": "NO"
},
{
"input": "etra etra initis",
"output": "NO"
},
{
"input": "etra etra inites",
"output": "NO"
},
{
"input": "etra initis lios",
"output": "NO"
},
{
"input": "etra initis liala",
"output": "NO"
},
{
"input": "etra initis etr",
"output": "NO"
},
{
"input": "etra initis etra",
"output": "NO"
},
{
"input": "etra initis initis",
"output": "NO"
},
{
"input": "etra initis inites",
"output": "NO"
},
{
"input": "etra inites lios",
"output": "NO"
},
{
"input": "etra inites liala",
"output": "NO"
},
{
"input": "etra inites etr",
"output": "NO"
},
{
"input": "etra inites etra",
"output": "NO"
},
{
"input": "etra inites initis",
"output": "NO"
},
{
"input": "etra inites inites",
"output": "YES"
},
{
"input": "initis lios lios",
"output": "NO"
},
{
"input": "initis lios liala",
"output": "NO"
},
{
"input": "initis lios etr",
"output": "NO"
},
{
"input": "initis lios etra",
"output": "NO"
},
{
"input": "initis lios initis",
"output": "NO"
},
{
"input": "initis lios inites",
"output": "NO"
},
{
"input": "initis liala lios",
"output": "NO"
},
{
"input": "initis liala liala",
"output": "NO"
},
{
"input": "initis liala etr",
"output": "NO"
},
{
"input": "initis liala etra",
"output": "NO"
},
{
"input": "initis liala initis",
"output": "NO"
},
{
"input": "initis liala inites",
"output": "NO"
},
{
"input": "initis etr lios",
"output": "NO"
},
{
"input": "initis etr liala",
"output": "NO"
},
{
"input": "initis etr etr",
"output": "NO"
},
{
"input": "initis etr etra",
"output": "NO"
},
{
"input": "initis etr initis",
"output": "NO"
},
{
"input": "initis etr inites",
"output": "NO"
},
{
"input": "initis etra lios",
"output": "NO"
},
{
"input": "initis etra liala",
"output": "NO"
},
{
"input": "initis etra etr",
"output": "NO"
},
{
"input": "initis etra etra",
"output": "NO"
},
{
"input": "initis etra initis",
"output": "NO"
},
{
"input": "initis etra inites",
"output": "NO"
},
{
"input": "initis initis lios",
"output": "NO"
},
{
"input": "initis initis liala",
"output": "NO"
},
{
"input": "initis initis etr",
"output": "NO"
},
{
"input": "initis initis etra",
"output": "NO"
},
{
"input": "initis initis initis",
"output": "NO"
},
{
"input": "initis initis inites",
"output": "NO"
},
{
"input": "initis inites lios",
"output": "NO"
},
{
"input": "initis inites liala",
"output": "NO"
},
{
"input": "initis inites etr",
"output": "NO"
},
{
"input": "initis inites etra",
"output": "NO"
},
{
"input": "initis inites initis",
"output": "NO"
},
{
"input": "initis inites inites",
"output": "NO"
},
{
"input": "inites lios lios",
"output": "NO"
},
{
"input": "inites lios liala",
"output": "NO"
},
{
"input": "inites lios etr",
"output": "NO"
},
{
"input": "inites lios etra",
"output": "NO"
},
{
"input": "inites lios initis",
"output": "NO"
},
{
"input": "inites lios inites",
"output": "NO"
},
{
"input": "inites liala lios",
"output": "NO"
},
{
"input": "inites liala liala",
"output": "NO"
},
{
"input": "inites liala etr",
"output": "NO"
},
{
"input": "inites liala etra",
"output": "NO"
},
{
"input": "inites liala initis",
"output": "NO"
},
{
"input": "inites liala inites",
"output": "NO"
},
{
"input": "inites etr lios",
"output": "NO"
},
{
"input": "inites etr liala",
"output": "NO"
},
{
"input": "inites etr etr",
"output": "NO"
},
{
"input": "inites etr etra",
"output": "NO"
},
{
"input": "inites etr initis",
"output": "NO"
},
{
"input": "inites etr inites",
"output": "NO"
},
{
"input": "inites etra lios",
"output": "NO"
},
{
"input": "inites etra liala",
"output": "NO"
},
{
"input": "inites etra etr",
"output": "NO"
},
{
"input": "inites etra etra",
"output": "NO"
},
{
"input": "inites etra initis",
"output": "NO"
},
{
"input": "inites etra inites",
"output": "NO"
},
{
"input": "inites initis lios",
"output": "NO"
},
{
"input": "inites initis liala",
"output": "NO"
},
{
"input": "inites initis etr",
"output": "NO"
},
{
"input": "inites initis etra",
"output": "NO"
},
{
"input": "inites initis initis",
"output": "NO"
},
{
"input": "inites initis inites",
"output": "NO"
},
{
"input": "inites inites lios",
"output": "NO"
},
{
"input": "inites inites liala",
"output": "NO"
},
{
"input": "inites inites etr",
"output": "NO"
},
{
"input": "inites inites etra",
"output": "NO"
},
{
"input": "inites inites initis",
"output": "NO"
},
{
"input": "inites inites inites",
"output": "NO"
}
] | 1,648,612,900
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 65
| 92
| 102,400
|
def isPetyaLanguage():
read = input().split()
if len(read) == 1:
if read[0].endswith('lios') or read[0].endswith('lialia') or read[0].endswith('etr') or read[0].endswith('etra') or read[0].endswith('initis') or read[0].endswith('inites'):
print('YES')
return
else:
print('NO')
return
else:
if read[0].endswith('lios') or read[0].endswith('etr') or read[0].endswith('initis'):
for i in range(1,len(read)):
if (read[i].endswith('lios') or read[i].endswith('etr') or read[i].endswith('initis')) == False:
print('NO')
return
elif read[0].endswith('liala') or read[0].endswith('etra') or read[0].endswith('inites'):
for i in range(1,len(read)):
if (read[i].endswith('liala') or read[i].endswith('etra') or read[i].endswith('inites')) == False:
print('NO')
return
else:
print('NO')
return
index = -1
for i in range(len(read)):
if read[i].endswith('etr') or read[i].endswith('etra'):
index = i
if index == -1:
print('NO')
return
for i in range(0,index):
if (read[i].endswith('lios') or read[i].endswith('liala')) == False:
print('NO')
return
if index == len(read)-1:
print('YES')
return
for i in range(index+1,len(read)):
if (read[i].endswith('initis') or read[i].endswith('inites')) == False:
print('NO')
return
print('YES')
return
isPetyaLanguage()
|
Title: Grammar Lessons
Time Limit: 5 seconds
Memory Limit: 256 megabytes
Problem Description:
Petya got interested in grammar on his third year in school. He invented his own language called Petya's. Petya wanted to create a maximally simple language that would be enough to chat with friends, that's why all the language's grammar can be described with the following set of rules:
- There are three parts of speech: the adjective, the noun, the verb. Each word in his language is an adjective, noun or verb. - There are two genders: masculine and feminine. Each word in his language has gender either masculine or feminine. - Masculine adjectives end with -lios, and feminine adjectives end with -liala. - Masculine nouns end with -etr, and feminime nouns end with -etra. - Masculine verbs end with -initis, and feminime verbs end with -inites. - Thus, each word in the Petya's language has one of the six endings, given above. There are no other endings in Petya's language. - It is accepted that the whole word consists of an ending. That is, words "lios", "liala", "etr" and so on belong to the Petya's language. - There aren't any punctuation marks, grammatical tenses, singular/plural forms or other language complications. - A sentence is either exactly one valid language word or exactly one statement.
Statement is any sequence of the Petya's language, that satisfy both conditions:
- Words in statement follow in the following order (from the left to the right): zero or more adjectives followed by exactly one noun followed by zero or more verbs. - All words in the statement should have the same gender.
After Petya's friend Vasya wrote instant messenger (an instant messaging program) that supported the Petya's language, Petya wanted to add spelling and grammar checking to the program. As Vasya was in the country and Petya didn't feel like waiting, he asked you to help him with this problem. Your task is to define by a given sequence of words, whether it is true that the given text represents exactly one sentence in Petya's language.
Input Specification:
The first line contains one or more words consisting of lowercase Latin letters. The overall number of characters (including letters and spaces) does not exceed 105.
It is guaranteed that any two consecutive words are separated by exactly one space and the input data do not contain any other spaces. It is possible that given words do not belong to the Petya's language.
Output Specification:
If some word of the given text does not belong to the Petya's language or if the text contains more that one sentence, print "NO" (without the quotes). Otherwise, print "YES" (without the quotes).
Demo Input:
['petr\n', 'etis atis animatis etis atis amatis\n', 'nataliala kataliala vetra feinites\n']
Demo Output:
['YES\n', 'NO\n', 'YES\n']
Note:
none
|
```python
def isPetyaLanguage():
read = input().split()
if len(read) == 1:
if read[0].endswith('lios') or read[0].endswith('lialia') or read[0].endswith('etr') or read[0].endswith('etra') or read[0].endswith('initis') or read[0].endswith('inites'):
print('YES')
return
else:
print('NO')
return
else:
if read[0].endswith('lios') or read[0].endswith('etr') or read[0].endswith('initis'):
for i in range(1,len(read)):
if (read[i].endswith('lios') or read[i].endswith('etr') or read[i].endswith('initis')) == False:
print('NO')
return
elif read[0].endswith('liala') or read[0].endswith('etra') or read[0].endswith('inites'):
for i in range(1,len(read)):
if (read[i].endswith('liala') or read[i].endswith('etra') or read[i].endswith('inites')) == False:
print('NO')
return
else:
print('NO')
return
index = -1
for i in range(len(read)):
if read[i].endswith('etr') or read[i].endswith('etra'):
index = i
if index == -1:
print('NO')
return
for i in range(0,index):
if (read[i].endswith('lios') or read[i].endswith('liala')) == False:
print('NO')
return
if index == len(read)-1:
print('YES')
return
for i in range(index+1,len(read)):
if (read[i].endswith('initis') or read[i].endswith('inites')) == False:
print('NO')
return
print('YES')
return
isPetyaLanguage()
```
| 0
|
9
|
A
|
Die Roll
|
PROGRAMMING
| 800
|
[
"math",
"probabilities"
] |
A. Die Roll
|
1
|
64
|
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
|
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
|
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
|
[
"4 2\n"
] |
[
"1/2\n"
] |
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
| 0
|
[
{
"input": "4 2",
"output": "1/2"
},
{
"input": "1 1",
"output": "1/1"
},
{
"input": "1 2",
"output": "5/6"
},
{
"input": "1 3",
"output": "2/3"
},
{
"input": "1 4",
"output": "1/2"
},
{
"input": "1 5",
"output": "1/3"
},
{
"input": "1 6",
"output": "1/6"
},
{
"input": "2 1",
"output": "5/6"
},
{
"input": "2 2",
"output": "5/6"
},
{
"input": "2 3",
"output": "2/3"
},
{
"input": "2 4",
"output": "1/2"
},
{
"input": "2 5",
"output": "1/3"
},
{
"input": "2 6",
"output": "1/6"
},
{
"input": "3 1",
"output": "2/3"
},
{
"input": "3 2",
"output": "2/3"
},
{
"input": "3 3",
"output": "2/3"
},
{
"input": "3 4",
"output": "1/2"
},
{
"input": "3 5",
"output": "1/3"
},
{
"input": "3 6",
"output": "1/6"
},
{
"input": "4 1",
"output": "1/2"
},
{
"input": "4 3",
"output": "1/2"
},
{
"input": "4 4",
"output": "1/2"
},
{
"input": "4 5",
"output": "1/3"
},
{
"input": "4 6",
"output": "1/6"
},
{
"input": "5 1",
"output": "1/3"
},
{
"input": "5 2",
"output": "1/3"
},
{
"input": "5 3",
"output": "1/3"
},
{
"input": "5 4",
"output": "1/3"
},
{
"input": "5 5",
"output": "1/3"
},
{
"input": "5 6",
"output": "1/6"
},
{
"input": "6 1",
"output": "1/6"
},
{
"input": "6 2",
"output": "1/6"
},
{
"input": "6 3",
"output": "1/6"
},
{
"input": "6 4",
"output": "1/6"
},
{
"input": "6 5",
"output": "1/6"
},
{
"input": "6 6",
"output": "1/6"
}
] | 1,677,150,894
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 92
| 409,600
|
from fractions import Fraction
a,b=map(int,input().split())
if a==b: print(a)
else: print(Fraction(b,a))
|
Title: Die Roll
Time Limit: 1 seconds
Memory Limit: 64 megabytes
Problem Description:
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input Specification:
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output Specification:
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Demo Input:
['4 2\n']
Demo Output:
['1/2\n']
Note:
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
|
```python
from fractions import Fraction
a,b=map(int,input().split())
if a==b: print(a)
else: print(Fraction(b,a))
```
| 0
|
765
|
A
|
Neverending competitions
|
PROGRAMMING
| 900
|
[
"implementation",
"math"
] | null | null |
There are literally dozens of snooker competitions held each year, and team Jinotega tries to attend them all (for some reason they prefer name "snookah")! When a competition takes place somewhere far from their hometown, Ivan, Artsem and Konstantin take a flight to the contest and back.
Jinotega's best friends, team Base have found a list of their itinerary receipts with information about departure and arrival airports. Now they wonder, where is Jinotega now: at home or at some competition far away? They know that:
- this list contains all Jinotega's flights in this year (in arbitrary order), - Jinotega has only flown from his hometown to a snooker contest and back, - after each competition Jinotega flies back home (though they may attend a competition in one place several times), - and finally, at the beginning of the year Jinotega was at home.
Please help them to determine Jinotega's location!
|
In the first line of input there is a single integer *n*: the number of Jinotega's flights (1<=≤<=*n*<=≤<=100). In the second line there is a string of 3 capital Latin letters: the name of Jinotega's home airport. In the next *n* lines there is flight information, one flight per line, in form "XXX->YYY", where "XXX" is the name of departure airport "YYY" is the name of arrival airport. Exactly one of these airports is Jinotega's home airport.
It is guaranteed that flights information is consistent with the knowledge of Jinotega's friends, which is described in the main part of the statement.
|
If Jinotega is now at home, print "home" (without quotes), otherwise print "contest".
|
[
"4\nSVO\nSVO->CDG\nLHR->SVO\nSVO->LHR\nCDG->SVO\n",
"3\nSVO\nSVO->HKT\nHKT->SVO\nSVO->RAP\n"
] |
[
"home\n",
"contest\n"
] |
In the first sample Jinotega might first fly from SVO to CDG and back, and then from SVO to LHR and back, so now they should be at home. In the second sample Jinotega must now be at RAP because a flight from RAP back to SVO is not on the list.
| 500
|
[
{
"input": "4\nSVO\nSVO->CDG\nLHR->SVO\nSVO->LHR\nCDG->SVO",
"output": "home"
},
{
"input": "3\nSVO\nSVO->HKT\nHKT->SVO\nSVO->RAP",
"output": "contest"
},
{
"input": "1\nESJ\nESJ->TSJ",
"output": "contest"
},
{
"input": "2\nXMR\nFAJ->XMR\nXMR->FAJ",
"output": "home"
},
{
"input": "3\nZIZ\nDWJ->ZIZ\nZIZ->DWJ\nZIZ->DWJ",
"output": "contest"
},
{
"input": "10\nPVO\nDMN->PVO\nDMN->PVO\nPVO->DMN\nDMN->PVO\nPVO->DMN\nPVO->DMN\nPVO->DMN\nDMN->PVO\nPVO->DMN\nDMN->PVO",
"output": "home"
},
{
"input": "11\nIAU\nIAU->RUQ\nIAU->RUQ\nRUQ->IAU\nRUQ->IAU\nIAU->RUQ\nRUQ->IAU\nIAU->RUQ\nRUQ->IAU\nIAU->RUQ\nIAU->RUQ\nRUQ->IAU",
"output": "contest"
},
{
"input": "10\nHPN\nDFI->HPN\nHPN->KAB\nHPN->DFI\nVSO->HPN\nHPN->KZX\nHPN->VSO\nKZX->HPN\nLDW->HPN\nKAB->HPN\nHPN->LDW",
"output": "home"
},
{
"input": "11\nFGH\nFGH->BRZ\nUBK->FGH\nQRE->FGH\nFGH->KQK\nFGH->QRE\nKQK->FGH\nFGH->UBK\nBRZ->FGH\nFGH->ALX\nALX->FGH\nFGH->KQK",
"output": "contest"
},
{
"input": "50\nPFH\nJFV->PFH\nBVP->PFH\nPFH->BVP\nPFH->JFV\nPFH->ETQ\nPFH->LQJ\nZTO->PFH\nPFH->BVP\nPFH->RXO\nPFH->ZTO\nHWL->PFH\nPFH->HIV\nPFH->AFP\nPFH->HWL\nOBB->PFH\nHIV->PFH\nPFH->LSR\nAFP->PFH\nLQJ->PFH\nHWL->PFH\nETQ->PFH\nPFH->HWL\nLSR->PFH\nWBR->PFH\nBNZ->PFH\nHQR->PFH\nZTO->PFH\nPFH->WBR\nPFH->BYJ\nRXO->PFH\nFHZ->PFH\nFHZ->PFH\nPFN->PFH\nPFH->GMB\nPFH->JFV\nJFV->PFH\nGNZ->PFH\nPFH->BNZ\nPFH->GNZ\nPFH->HQR\nBYJ->PFH\nGMB->PFH\nPFH->FHZ\nPFH->FHZ\nPFH->ZTO\nPFH->UGD\nBVP->PFH\nUGD->PFH\nPFH->PFN\nPFH->OBB",
"output": "home"
},
{
"input": "1\nAAK\nAAK->ABA",
"output": "contest"
},
{
"input": "1\nXYZ\nXYZ->XYR",
"output": "contest"
}
] | 1,684,740,834
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 46
| 0
|
number_flies = int(input())
local_airport = input()
complete_data = []
for fly in range(number_flies):
sequence = input().split('->')
complete_data.append(sequence)
if complete_data[number_flies - 1:][0][1] == local_airport:
print("home")
else:
print("contest")
|
Title: Neverending competitions
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There are literally dozens of snooker competitions held each year, and team Jinotega tries to attend them all (for some reason they prefer name "snookah")! When a competition takes place somewhere far from their hometown, Ivan, Artsem and Konstantin take a flight to the contest and back.
Jinotega's best friends, team Base have found a list of their itinerary receipts with information about departure and arrival airports. Now they wonder, where is Jinotega now: at home or at some competition far away? They know that:
- this list contains all Jinotega's flights in this year (in arbitrary order), - Jinotega has only flown from his hometown to a snooker contest and back, - after each competition Jinotega flies back home (though they may attend a competition in one place several times), - and finally, at the beginning of the year Jinotega was at home.
Please help them to determine Jinotega's location!
Input Specification:
In the first line of input there is a single integer *n*: the number of Jinotega's flights (1<=≤<=*n*<=≤<=100). In the second line there is a string of 3 capital Latin letters: the name of Jinotega's home airport. In the next *n* lines there is flight information, one flight per line, in form "XXX->YYY", where "XXX" is the name of departure airport "YYY" is the name of arrival airport. Exactly one of these airports is Jinotega's home airport.
It is guaranteed that flights information is consistent with the knowledge of Jinotega's friends, which is described in the main part of the statement.
Output Specification:
If Jinotega is now at home, print "home" (without quotes), otherwise print "contest".
Demo Input:
['4\nSVO\nSVO->CDG\nLHR->SVO\nSVO->LHR\nCDG->SVO\n', '3\nSVO\nSVO->HKT\nHKT->SVO\nSVO->RAP\n']
Demo Output:
['home\n', 'contest\n']
Note:
In the first sample Jinotega might first fly from SVO to CDG and back, and then from SVO to LHR and back, so now they should be at home. In the second sample Jinotega must now be at RAP because a flight from RAP back to SVO is not on the list.
|
```python
number_flies = int(input())
local_airport = input()
complete_data = []
for fly in range(number_flies):
sequence = input().split('->')
complete_data.append(sequence)
if complete_data[number_flies - 1:][0][1] == local_airport:
print("home")
else:
print("contest")
```
| 0
|
|
0
|
none
|
none
|
none
| 0
|
[
"none"
] | null | null |
Vasya the programmer lives in the middle of the Programming subway branch. He has two girlfriends: Dasha and Masha, who live at the different ends of the branch, each one is unaware of the other one's existence.
When Vasya has some free time, he goes to one of his girlfriends. He descends into the subway at some time, waits the first train to come and rides on it to the end of the branch to the corresponding girl. However, the trains run with different frequencies: a train goes to Dasha's direction every *a* minutes, but a train goes to Masha's direction every *b* minutes. If two trains approach at the same time, Vasya goes toward the direction with the lower frequency of going trains, that is, to the girl, to whose directions the trains go less frequently (see the note to the third sample).
We know that the trains begin to go simultaneously before Vasya appears. That is the train schedule is such that there exists a moment of time when the two trains arrive simultaneously.
Help Vasya count to which girlfriend he will go more often.
|
The first line contains two integers *a* and *b* (*a*<=≠<=*b*,<=1<=≤<=*a*,<=*b*<=≤<=106).
|
Print "Dasha" if Vasya will go to Dasha more frequently, "Masha" if he will go to Masha more frequently, or "Equal" if he will go to both girlfriends with the same frequency.
|
[
"3 7\n",
"5 3\n",
"2 3\n"
] |
[
"Dasha\n",
"Masha\n",
"Equal\n"
] |
Let's take a look at the third sample. Let the trains start to go at the zero moment of time. It is clear that the moments of the trains' arrival will be periodic with period 6. That's why it is enough to show that if Vasya descends to the subway at a moment of time inside the interval (0, 6], he will go to both girls equally often.
If he descends to the subway at a moment of time from 0 to 2, he leaves for Dasha on the train that arrives by the second minute.
If he descends to the subway at a moment of time from 2 to 3, he leaves for Masha on the train that arrives by the third minute.
If he descends to the subway at a moment of time from 3 to 4, he leaves for Dasha on the train that arrives by the fourth minute.
If he descends to the subway at a moment of time from 4 to 6, he waits for both trains to arrive by the sixth minute and goes to Masha as trains go less often in Masha's direction.
In sum Masha and Dasha get equal time — three minutes for each one, thus, Vasya will go to both girlfriends equally often.
| 0
|
[
{
"input": "3 7",
"output": "Dasha"
},
{
"input": "5 3",
"output": "Masha"
},
{
"input": "2 3",
"output": "Equal"
},
{
"input": "31 88",
"output": "Dasha"
},
{
"input": "8 75",
"output": "Dasha"
},
{
"input": "32 99",
"output": "Dasha"
},
{
"input": "77 4",
"output": "Masha"
},
{
"input": "27 1",
"output": "Masha"
},
{
"input": "84 11",
"output": "Masha"
},
{
"input": "4 6",
"output": "Equal"
},
{
"input": "52 53",
"output": "Equal"
},
{
"input": "397 568",
"output": "Dasha"
},
{
"input": "22 332",
"output": "Dasha"
},
{
"input": "419 430",
"output": "Dasha"
},
{
"input": "638 619",
"output": "Masha"
},
{
"input": "393 325",
"output": "Masha"
},
{
"input": "876 218",
"output": "Masha"
},
{
"input": "552 551",
"output": "Equal"
},
{
"input": "906 912",
"output": "Equal"
},
{
"input": "999 996",
"output": "Equal"
},
{
"input": "652 653",
"output": "Equal"
},
{
"input": "3647 7698",
"output": "Dasha"
},
{
"input": "2661 8975",
"output": "Dasha"
},
{
"input": "251 9731",
"output": "Dasha"
},
{
"input": "9886 8671",
"output": "Masha"
},
{
"input": "8545 7312",
"output": "Masha"
},
{
"input": "4982 2927",
"output": "Masha"
},
{
"input": "7660 7658",
"output": "Equal"
},
{
"input": "9846 9844",
"output": "Equal"
},
{
"input": "9632 9640",
"output": "Equal"
},
{
"input": "5036 5037",
"output": "Equal"
},
{
"input": "64854 77725",
"output": "Dasha"
},
{
"input": "4965 85708",
"output": "Dasha"
},
{
"input": "20393 86640",
"output": "Dasha"
},
{
"input": "99207 30728",
"output": "Masha"
},
{
"input": "77545 13842",
"output": "Masha"
},
{
"input": "30362 10712",
"output": "Masha"
},
{
"input": "51291 51292",
"output": "Equal"
},
{
"input": "55381 55382",
"output": "Equal"
},
{
"input": "91560 91550",
"output": "Equal"
},
{
"input": "99087 99090",
"output": "Equal"
},
{
"input": "983794 986389",
"output": "Dasha"
},
{
"input": "779183 786727",
"output": "Dasha"
},
{
"input": "450766 610961",
"output": "Dasha"
},
{
"input": "664690 630787",
"output": "Masha"
},
{
"input": "461363 256765",
"output": "Masha"
},
{
"input": "638067 409048",
"output": "Masha"
},
{
"input": "929061 929052",
"output": "Equal"
},
{
"input": "996219 996216",
"output": "Equal"
},
{
"input": "716249 716248",
"output": "Equal"
},
{
"input": "782250 782252",
"output": "Equal"
},
{
"input": "1 2",
"output": "Equal"
},
{
"input": "2 1",
"output": "Equal"
},
{
"input": "999999 1000000",
"output": "Equal"
},
{
"input": "999997 1000000",
"output": "Dasha"
},
{
"input": "1000000 999993",
"output": "Masha"
},
{
"input": "999983 999979",
"output": "Masha"
}
] | 1,590,189,991
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 57
| 218
| 0
|
from math import gcd
a, b = (int(x) for x in input().split())
upper = a * b / gcd(a,b)
m, d = upper/b, upper/a
if a < b: d -= 1
else: m -= 1
if d > m: print("Dasha")
elif m > d: print("Masha")
else: print("Equal")
|
Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya the programmer lives in the middle of the Programming subway branch. He has two girlfriends: Dasha and Masha, who live at the different ends of the branch, each one is unaware of the other one's existence.
When Vasya has some free time, he goes to one of his girlfriends. He descends into the subway at some time, waits the first train to come and rides on it to the end of the branch to the corresponding girl. However, the trains run with different frequencies: a train goes to Dasha's direction every *a* minutes, but a train goes to Masha's direction every *b* minutes. If two trains approach at the same time, Vasya goes toward the direction with the lower frequency of going trains, that is, to the girl, to whose directions the trains go less frequently (see the note to the third sample).
We know that the trains begin to go simultaneously before Vasya appears. That is the train schedule is such that there exists a moment of time when the two trains arrive simultaneously.
Help Vasya count to which girlfriend he will go more often.
Input Specification:
The first line contains two integers *a* and *b* (*a*<=≠<=*b*,<=1<=≤<=*a*,<=*b*<=≤<=106).
Output Specification:
Print "Dasha" if Vasya will go to Dasha more frequently, "Masha" if he will go to Masha more frequently, or "Equal" if he will go to both girlfriends with the same frequency.
Demo Input:
['3 7\n', '5 3\n', '2 3\n']
Demo Output:
['Dasha\n', 'Masha\n', 'Equal\n']
Note:
Let's take a look at the third sample. Let the trains start to go at the zero moment of time. It is clear that the moments of the trains' arrival will be periodic with period 6. That's why it is enough to show that if Vasya descends to the subway at a moment of time inside the interval (0, 6], he will go to both girls equally often.
If he descends to the subway at a moment of time from 0 to 2, he leaves for Dasha on the train that arrives by the second minute.
If he descends to the subway at a moment of time from 2 to 3, he leaves for Masha on the train that arrives by the third minute.
If he descends to the subway at a moment of time from 3 to 4, he leaves for Dasha on the train that arrives by the fourth minute.
If he descends to the subway at a moment of time from 4 to 6, he waits for both trains to arrive by the sixth minute and goes to Masha as trains go less often in Masha's direction.
In sum Masha and Dasha get equal time — three minutes for each one, thus, Vasya will go to both girlfriends equally often.
|
```python
from math import gcd
a, b = (int(x) for x in input().split())
upper = a * b / gcd(a,b)
m, d = upper/b, upper/a
if a < b: d -= 1
else: m -= 1
if d > m: print("Dasha")
elif m > d: print("Masha")
else: print("Equal")
```
| 3
|
|
26
|
A
|
Almost Prime
|
PROGRAMMING
| 900
|
[
"number theory"
] |
A. Almost Prime
|
2
|
256
|
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, inclusive.
|
Input contains one integer number *n* (1<=≤<=*n*<=≤<=3000).
|
Output the amount of almost prime numbers between 1 and *n*, inclusive.
|
[
"10\n",
"21\n"
] |
[
"2\n",
"8\n"
] |
none
| 500
|
[
{
"input": "10",
"output": "2"
},
{
"input": "21",
"output": "8"
},
{
"input": "1",
"output": "0"
},
{
"input": "2",
"output": "0"
},
{
"input": "4",
"output": "0"
},
{
"input": "3",
"output": "0"
},
{
"input": "8",
"output": "1"
},
{
"input": "19",
"output": "6"
},
{
"input": "40",
"output": "19"
},
{
"input": "77",
"output": "41"
},
{
"input": "222",
"output": "125"
},
{
"input": "987",
"output": "501"
},
{
"input": "1000",
"output": "508"
},
{
"input": "2000",
"output": "958"
},
{
"input": "3000",
"output": "1375"
},
{
"input": "2999",
"output": "1375"
},
{
"input": "2998",
"output": "1375"
},
{
"input": "2997",
"output": "1374"
},
{
"input": "1429",
"output": "706"
},
{
"input": "1673",
"output": "808"
},
{
"input": "1500",
"output": "732"
},
{
"input": "500",
"output": "266"
},
{
"input": "856",
"output": "439"
}
] | 1,680,277,123
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 1
| 92
| 0
|
inp = int(input())
ans = set()
for i in range(inp):
d=2
while d*d <= i:
while i%d == 0:
ans.add(d)
i//=d
d+=1
print(len(ans))
|
Title: Almost Prime
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, inclusive.
Input Specification:
Input contains one integer number *n* (1<=≤<=*n*<=≤<=3000).
Output Specification:
Output the amount of almost prime numbers between 1 and *n*, inclusive.
Demo Input:
['10\n', '21\n']
Demo Output:
['2\n', '8\n']
Note:
none
|
```python
inp = int(input())
ans = set()
for i in range(inp):
d=2
while d*d <= i:
while i%d == 0:
ans.add(d)
i//=d
d+=1
print(len(ans))
```
| 0
|
929
|
B
|
Места в самолёте
|
PROGRAMMING
| 1,300
|
[
"*special",
"implementation"
] | null | null |
В самолёте есть *n* рядов мест. Если смотреть на ряды сверху, то в каждом ряду есть 3 места слева, затем проход между рядами, затем 4 центральных места, затем ещё один проход между рядами, а затем ещё 3 места справа.
Известно, что некоторые места уже заняты пассажирами. Всего есть два вида пассажиров — статусные (те, которые часто летают) и обычные.
Перед вами стоит задача рассадить ещё *k* обычных пассажиров так, чтобы суммарное число соседей у статусных пассажиров было минимально возможным. Два пассажира считаются соседями, если они сидят в одном ряду и между ними нет других мест и прохода между рядами. Если пассажир является соседним пассажиром для двух статусных пассажиров, то его следует учитывать в сумме соседей дважды.
|
В первой строке следуют два целых числа *n* и *k* (1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=10·*n*) — количество рядов мест в самолёте и количество пассажиров, которых нужно рассадить.
Далее следует описание рядов мест самолёта по одному ряду в строке. Если очередной символ равен '-', то это проход между рядами. Если очередной символ равен '.', то это свободное место. Если очередной символ равен 'S', то на текущем месте будет сидеть статусный пассажир. Если очередной символ равен 'P', то на текущем месте будет сидеть обычный пассажир.
Гарантируется, что количество свободных мест не меньше *k*. Гарантируется, что все ряды удовлетворяют описанному в условии формату.
|
В первую строку выведите минимальное суммарное число соседей у статусных пассажиров.
Далее выведите план рассадки пассажиров, который минимизирует суммарное количество соседей у статусных пассажиров, в том же формате, что и во входных данных. Если в свободное место нужно посадить одного из *k* пассажиров, выведите строчную букву 'x' вместо символа '.'.
|
[
"1 2\nSP.-SS.S-S.S\n",
"4 9\nPP.-PPPS-S.S\nPSP-PPSP-.S.\n.S.-S..P-SS.\nP.S-P.PP-PSP\n"
] |
[
"5\nSPx-SSxS-S.S\n",
"15\nPPx-PPPS-S.S\nPSP-PPSP-xSx\nxSx-SxxP-SSx\nP.S-PxPP-PSP\n"
] |
В первом примере нужно посадить ещё двух обычных пассажиров. Для минимизации соседей у статусных пассажиров, нужно посадить первого из них на третье слева место, а второго на любое из оставшихся двух мест, так как независимо от выбора места он станет соседом двух статусных пассажиров.
Изначально, у статусного пассажира, который сидит на самом левом месте уже есть сосед. Также на четвёртом и пятом местах слева сидят статусные пассажиры, являющиеся соседями друг для друга (что добавляет к сумме 2).
Таким образом, после посадки ещё двух обычных пассажиров, итоговое суммарное количество соседей у статусных пассажиров станет равно пяти.
| 1,000
|
[
{
"input": "1 2\nSP.-SS.S-S.S",
"output": "5\nSPx-SSxS-S.S"
},
{
"input": "4 9\nPP.-PPPS-S.S\nPSP-PPSP-.S.\n.S.-S..P-SS.\nP.S-P.PP-PSP",
"output": "15\nPPx-PPPS-S.S\nPSP-PPSP-xSx\nxSx-SxxP-SSx\nP.S-PxPP-PSP"
},
{
"input": "3 7\n.S.-SSSP-..S\nS..-.SPP-S.P\n.S.-PPPP-PSP",
"output": "13\nxSx-SSSP-xxS\nSxx-xSPP-S.P\n.S.-PPPP-PSP"
},
{
"input": "5 6\nPP.-PS.P-P..\nPPS-SP..-P.P\nP.P-....-S..\nSPP-.P.S-.S.\nSP.-S.PS-PPP",
"output": "6\nPPx-PS.P-Pxx\nPPS-SPxx-PxP\nP.P-....-S..\nSPP-.P.S-.S.\nSP.-S.PS-PPP"
},
{
"input": "1 1\n..S-PS..-.PP",
"output": "1\nx.S-PS..-.PP"
},
{
"input": "2 2\nPP.-S.SS-.S.\nSSP-SSSS-S.S",
"output": "12\nPPx-S.SS-xS.\nSSP-SSSS-S.S"
},
{
"input": "30 1\nPPP-PPP.-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP",
"output": "0\nPPP-PPPx-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP"
},
{
"input": "1 1\nSPS-....-P.P",
"output": "2\nSPS-x...-P.P"
},
{
"input": "2 1\nSSS-S.S.-SSS\nSSP-.PP.-S.S",
"output": "11\nSSS-S.S.-SSS\nSSP-xPP.-S.S"
},
{
"input": "30 1\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPP.-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP",
"output": "0\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPx-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP\nPPP-PPPP-PPP"
}
] | 1,520,039,327
| 34,427
|
Python 3
|
WRONG_ANSWER
|
PRETESTS
| 3
| 62
| 5,836,800
|
def Count(a, n):
count = 0
for i in range(n):
for j in range(12):
if (j == 0 and a[i][j] == 'S'):
if a[i][j + 1] == 'P' or a[i][j + 1] == 'x' or a[i][j + 1] == 'S':
count += 1
elif (j == 11 and a[i][j] == 'S'):
if a[i][j - 1] == 'P' or a[i][j - 1] == 'x' or a[i][j - 1] == 'S':
count += 1
elif (j > 0 and j < 11 and a[i][j] == 'S'):
if a[i][j - 1] == 'P' or a[i][j - 1] == 'x' or a[i][j - 1] == 'S':
count += 1
if a[i][j + 1] == 'P' or a[i][j + 1] == 'x' or a[i][j + 1] == 'S':
count += 1
return (count)
s = input().split()
n = int(s[0])
k = int(s[1])
a = []
for i in range(n):
s = input()
res = []
for i in s:
res.append(i)
a.append(res)
# first
for i in range(n):
# 0
if k > 0 and a[i][0] == '.' and a[i][1] != 'S':
k -= 1
a[i][0] = 'x'
# 1
if k > 0 and a[i][1] == '.' and a[i][0] != 'S' and a[i][2] != 'S':
k -= 1
a[i][1] = 'x'
# 2
if k > 0 and a[i][2] == '.' and a[i][1] != 'S':
k -= 1
a[i][2] = 'x'
# 4
if k > 0 and a[i][4] == '.' and a[i][5] != 'S':
k -= 1
a[i][4] = 'x'
# 5
if k > 0 and a[i][5] == '.' and a[i][6] != 'S' and a[i][4] != 'S':
k -= 1
a[i][5] = 'x'
# 6
if k > 0 and a[i][6] == '.' and a[i][7] != 'S' and a[i][5] != 'S':
k -= 1
a[i][6] = 'x'
# 7
if k > 0 and a[i][7] == '.' and a[i][6] != 'S':
k -= 1
a[i][7] = 'x'
# 9
if k > 0 and a[i][9] == '.' and a[i][10] != 'S':
k -= 1
a[i][9] = 'x'
# 10
if k > 0 and a[i][10] == '.' and a[i][11] != 'S' and a[i][9] != 'S':
k -= 1
a[i][9] = 'x'
# 11
if k > 0 and a[i][11] == '.' and a[i][10] != 'S':
k -= 1
a[i][11] = 'x'
# second
for i in range(n):
# 0
if k > 0 and a[i][0] == '.' and a[i][1] == 'S':
k -= 1
a[i][0] = 'x'
# 1
if k > 0 and a[i][1] == '.' and a[i][2] != 'S' and a[i][0] == 'S':
k -= 1
a[i][1] = 'x'
# 1 extra
if k > 0 and a[i][1] == '.' and a[i][2] == 'S' and a[i][0] != 'S':
k -= 1
a[i][1] = 'x'
# 2
if k > 0 and a[i][2] == '.' and a[i][1] == 'S':
k -= 1
a[i][2] = 'x'
# 4
if k > 0 and a[i][4] == '.' and a[i][5] == 'S':
k -= 1
a[i][4] = 'x'
# 5
if k > 0 and a[i][5] == '.' and a[i][6] != 'S' and a[i][4] == 'S':
k -= 1
a[i][5] = 'x'
# 5 extra
if k > 0 and a[i][5] == '.' and a[i][6] == 'S' and a[i][4] != 'S':
k -= 1
a[i][5] = 'x'
# 6
if k > 0 and a[i][6] == '.' and a[i][7] != 'S' and a[i][5] == 'S':
k -= 1
a[i][6] = 'x'
# 6 extra
if k > 0 and a[i][6] == '.' and a[i][7] == 'S' and a[i][5] != 'S':
k -= 1
a[i][6] = 'x'
# 7
if k > 0 and a[i][7] == '.' and a[i][6] == 'S':
k -= 1
a[i][7] = 'x'
# 9
if k > 0 and a[i][9] == '.' and a[i][10] == 'S':
k -= 1
a[i][9] = 'x'
# 10
if k > 0 and a[i][10] == '.' and a[i][11] != 'S' and a[i][9] == 'S':
k -= 1
a[i][10] = 'x'
# 10 extra
if k > 0 and a[i][10] == '.' and a[i][11] == 'S' and a[i][9] != 'S':
k -= 1
a[i][10] = 'x'
# 11
if k > 0 and a[i][11] == '.' and a[i][10] == 'S':
k -= 1
a[i][11] = 'x'
if k == 0:
break
# third
for i in range(n):
for j in 1, 5, 6, 10:
if k > 0 and a[i][j] == '.' and a[i][j - 1] == 'S' and a[i][j + 1] == 'S':
k -= 1
a[i][j] = 'x'
if k == 0:
break
print(Count(a, n))
for i in range(n):
for j in range(12):
print(a[i][j], end='')
print()
|
Title: Места в самолёте
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
В самолёте есть *n* рядов мест. Если смотреть на ряды сверху, то в каждом ряду есть 3 места слева, затем проход между рядами, затем 4 центральных места, затем ещё один проход между рядами, а затем ещё 3 места справа.
Известно, что некоторые места уже заняты пассажирами. Всего есть два вида пассажиров — статусные (те, которые часто летают) и обычные.
Перед вами стоит задача рассадить ещё *k* обычных пассажиров так, чтобы суммарное число соседей у статусных пассажиров было минимально возможным. Два пассажира считаются соседями, если они сидят в одном ряду и между ними нет других мест и прохода между рядами. Если пассажир является соседним пассажиром для двух статусных пассажиров, то его следует учитывать в сумме соседей дважды.
Input Specification:
В первой строке следуют два целых числа *n* и *k* (1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=10·*n*) — количество рядов мест в самолёте и количество пассажиров, которых нужно рассадить.
Далее следует описание рядов мест самолёта по одному ряду в строке. Если очередной символ равен '-', то это проход между рядами. Если очередной символ равен '.', то это свободное место. Если очередной символ равен 'S', то на текущем месте будет сидеть статусный пассажир. Если очередной символ равен 'P', то на текущем месте будет сидеть обычный пассажир.
Гарантируется, что количество свободных мест не меньше *k*. Гарантируется, что все ряды удовлетворяют описанному в условии формату.
Output Specification:
В первую строку выведите минимальное суммарное число соседей у статусных пассажиров.
Далее выведите план рассадки пассажиров, который минимизирует суммарное количество соседей у статусных пассажиров, в том же формате, что и во входных данных. Если в свободное место нужно посадить одного из *k* пассажиров, выведите строчную букву 'x' вместо символа '.'.
Demo Input:
['1 2\nSP.-SS.S-S.S\n', '4 9\nPP.-PPPS-S.S\nPSP-PPSP-.S.\n.S.-S..P-SS.\nP.S-P.PP-PSP\n']
Demo Output:
['5\nSPx-SSxS-S.S\n', '15\nPPx-PPPS-S.S\nPSP-PPSP-xSx\nxSx-SxxP-SSx\nP.S-PxPP-PSP\n']
Note:
В первом примере нужно посадить ещё двух обычных пассажиров. Для минимизации соседей у статусных пассажиров, нужно посадить первого из них на третье слева место, а второго на любое из оставшихся двух мест, так как независимо от выбора места он станет соседом двух статусных пассажиров.
Изначально, у статусного пассажира, который сидит на самом левом месте уже есть сосед. Также на четвёртом и пятом местах слева сидят статусные пассажиры, являющиеся соседями друг для друга (что добавляет к сумме 2).
Таким образом, после посадки ещё двух обычных пассажиров, итоговое суммарное количество соседей у статусных пассажиров станет равно пяти.
|
```python
def Count(a, n):
count = 0
for i in range(n):
for j in range(12):
if (j == 0 and a[i][j] == 'S'):
if a[i][j + 1] == 'P' or a[i][j + 1] == 'x' or a[i][j + 1] == 'S':
count += 1
elif (j == 11 and a[i][j] == 'S'):
if a[i][j - 1] == 'P' or a[i][j - 1] == 'x' or a[i][j - 1] == 'S':
count += 1
elif (j > 0 and j < 11 and a[i][j] == 'S'):
if a[i][j - 1] == 'P' or a[i][j - 1] == 'x' or a[i][j - 1] == 'S':
count += 1
if a[i][j + 1] == 'P' or a[i][j + 1] == 'x' or a[i][j + 1] == 'S':
count += 1
return (count)
s = input().split()
n = int(s[0])
k = int(s[1])
a = []
for i in range(n):
s = input()
res = []
for i in s:
res.append(i)
a.append(res)
# first
for i in range(n):
# 0
if k > 0 and a[i][0] == '.' and a[i][1] != 'S':
k -= 1
a[i][0] = 'x'
# 1
if k > 0 and a[i][1] == '.' and a[i][0] != 'S' and a[i][2] != 'S':
k -= 1
a[i][1] = 'x'
# 2
if k > 0 and a[i][2] == '.' and a[i][1] != 'S':
k -= 1
a[i][2] = 'x'
# 4
if k > 0 and a[i][4] == '.' and a[i][5] != 'S':
k -= 1
a[i][4] = 'x'
# 5
if k > 0 and a[i][5] == '.' and a[i][6] != 'S' and a[i][4] != 'S':
k -= 1
a[i][5] = 'x'
# 6
if k > 0 and a[i][6] == '.' and a[i][7] != 'S' and a[i][5] != 'S':
k -= 1
a[i][6] = 'x'
# 7
if k > 0 and a[i][7] == '.' and a[i][6] != 'S':
k -= 1
a[i][7] = 'x'
# 9
if k > 0 and a[i][9] == '.' and a[i][10] != 'S':
k -= 1
a[i][9] = 'x'
# 10
if k > 0 and a[i][10] == '.' and a[i][11] != 'S' and a[i][9] != 'S':
k -= 1
a[i][9] = 'x'
# 11
if k > 0 and a[i][11] == '.' and a[i][10] != 'S':
k -= 1
a[i][11] = 'x'
# second
for i in range(n):
# 0
if k > 0 and a[i][0] == '.' and a[i][1] == 'S':
k -= 1
a[i][0] = 'x'
# 1
if k > 0 and a[i][1] == '.' and a[i][2] != 'S' and a[i][0] == 'S':
k -= 1
a[i][1] = 'x'
# 1 extra
if k > 0 and a[i][1] == '.' and a[i][2] == 'S' and a[i][0] != 'S':
k -= 1
a[i][1] = 'x'
# 2
if k > 0 and a[i][2] == '.' and a[i][1] == 'S':
k -= 1
a[i][2] = 'x'
# 4
if k > 0 and a[i][4] == '.' and a[i][5] == 'S':
k -= 1
a[i][4] = 'x'
# 5
if k > 0 and a[i][5] == '.' and a[i][6] != 'S' and a[i][4] == 'S':
k -= 1
a[i][5] = 'x'
# 5 extra
if k > 0 and a[i][5] == '.' and a[i][6] == 'S' and a[i][4] != 'S':
k -= 1
a[i][5] = 'x'
# 6
if k > 0 and a[i][6] == '.' and a[i][7] != 'S' and a[i][5] == 'S':
k -= 1
a[i][6] = 'x'
# 6 extra
if k > 0 and a[i][6] == '.' and a[i][7] == 'S' and a[i][5] != 'S':
k -= 1
a[i][6] = 'x'
# 7
if k > 0 and a[i][7] == '.' and a[i][6] == 'S':
k -= 1
a[i][7] = 'x'
# 9
if k > 0 and a[i][9] == '.' and a[i][10] == 'S':
k -= 1
a[i][9] = 'x'
# 10
if k > 0 and a[i][10] == '.' and a[i][11] != 'S' and a[i][9] == 'S':
k -= 1
a[i][10] = 'x'
# 10 extra
if k > 0 and a[i][10] == '.' and a[i][11] == 'S' and a[i][9] != 'S':
k -= 1
a[i][10] = 'x'
# 11
if k > 0 and a[i][11] == '.' and a[i][10] == 'S':
k -= 1
a[i][11] = 'x'
if k == 0:
break
# third
for i in range(n):
for j in 1, 5, 6, 10:
if k > 0 and a[i][j] == '.' and a[i][j - 1] == 'S' and a[i][j + 1] == 'S':
k -= 1
a[i][j] = 'x'
if k == 0:
break
print(Count(a, n))
for i in range(n):
for j in range(12):
print(a[i][j], end='')
print()
```
| 0
|
|
474
|
D
|
Flowers
|
PROGRAMMING
| 1,700
|
[
"dp"
] | null | null |
We saw the little game Marmot made for Mole's lunch. Now it's Marmot's dinner time and, as we all know, Marmot eats flowers. At every dinner he eats some red and white flowers. Therefore a dinner can be represented as a sequence of several flowers, some of them white and some of them red.
But, for a dinner to be tasty, there is a rule: Marmot wants to eat white flowers only in groups of size *k*.
Now Marmot wonders in how many ways he can eat between *a* and *b* flowers. As the number of ways could be very large, print it modulo 1000000007 (109<=+<=7).
|
Input contains several test cases.
The first line contains two integers *t* and *k* (1<=≤<=*t*,<=*k*<=≤<=105), where *t* represents the number of test cases.
The next *t* lines contain two integers *a**i* and *b**i* (1<=≤<=*a**i*<=≤<=*b**i*<=≤<=105), describing the *i*-th test.
|
Print *t* lines to the standard output. The *i*-th line should contain the number of ways in which Marmot can eat between *a**i* and *b**i* flowers at dinner modulo 1000000007 (109<=+<=7).
|
[
"3 2\n1 3\n2 3\n4 4\n"
] |
[
"6\n5\n5\n"
] |
- For *K* = 2 and length 1 Marmot can eat (*R*). - For *K* = 2 and length 2 Marmot can eat (*RR*) and (*WW*). - For *K* = 2 and length 3 Marmot can eat (*RRR*), (*RWW*) and (*WWR*). - For *K* = 2 and length 4 Marmot can eat, for example, (*WWWW*) or (*RWWR*), but for example he can't eat (*WWWR*).
| 2,000
|
[
{
"input": "3 2\n1 3\n2 3\n4 4",
"output": "6\n5\n5"
},
{
"input": "1 1\n1 3",
"output": "14"
},
{
"input": "1 2\n64329 79425",
"output": "0"
}
] | 1,690,882,819
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 1
| 1,500
| 3,788,800
|
fa = [1] * 100001
for i in range(1, 100001):
fa[i] = (fa[i - 1] * i) % 1000000007
t, k = map(int, input().split())
for _ in range(t):
a, b = map(int, input().split())
s = 0
for x in range(a, b + 1):
for w in range(0, x // k + 1):
c = x - k * w
s += fa[w + c] // (fa[w] * fa[c])
print(s)
|
Title: Flowers
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
We saw the little game Marmot made for Mole's lunch. Now it's Marmot's dinner time and, as we all know, Marmot eats flowers. At every dinner he eats some red and white flowers. Therefore a dinner can be represented as a sequence of several flowers, some of them white and some of them red.
But, for a dinner to be tasty, there is a rule: Marmot wants to eat white flowers only in groups of size *k*.
Now Marmot wonders in how many ways he can eat between *a* and *b* flowers. As the number of ways could be very large, print it modulo 1000000007 (109<=+<=7).
Input Specification:
Input contains several test cases.
The first line contains two integers *t* and *k* (1<=≤<=*t*,<=*k*<=≤<=105), where *t* represents the number of test cases.
The next *t* lines contain two integers *a**i* and *b**i* (1<=≤<=*a**i*<=≤<=*b**i*<=≤<=105), describing the *i*-th test.
Output Specification:
Print *t* lines to the standard output. The *i*-th line should contain the number of ways in which Marmot can eat between *a**i* and *b**i* flowers at dinner modulo 1000000007 (109<=+<=7).
Demo Input:
['3 2\n1 3\n2 3\n4 4\n']
Demo Output:
['6\n5\n5\n']
Note:
- For *K* = 2 and length 1 Marmot can eat (*R*). - For *K* = 2 and length 2 Marmot can eat (*RR*) and (*WW*). - For *K* = 2 and length 3 Marmot can eat (*RRR*), (*RWW*) and (*WWR*). - For *K* = 2 and length 4 Marmot can eat, for example, (*WWWW*) or (*RWWR*), but for example he can't eat (*WWWR*).
|
```python
fa = [1] * 100001
for i in range(1, 100001):
fa[i] = (fa[i - 1] * i) % 1000000007
t, k = map(int, input().split())
for _ in range(t):
a, b = map(int, input().split())
s = 0
for x in range(a, b + 1):
for w in range(0, x // k + 1):
c = x - k * w
s += fa[w + c] // (fa[w] * fa[c])
print(s)
```
| 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,698,849,991
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 29
| 46
| 0
|
nandh=input().split()
manh=input().split()
manhights=[]
wall_h=int(nandh[1])
wideroad=0
for i in manh:
manhights.append(int(i))
for x in manhights:
if x>wall_h:wideroad+=2
else:wideroad+=1
print(wideroad)
|
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
nandh=input().split()
manh=input().split()
manhights=[]
wall_h=int(nandh[1])
wideroad=0
for i in manh:
manhights.append(int(i))
for x in manhights:
if x>wall_h:wideroad+=2
else:wideroad+=1
print(wideroad)
```
| 3
|
|
34
|
B
|
Sale
|
PROGRAMMING
| 900
|
[
"greedy",
"sortings"
] |
B. Sale
|
2
|
256
|
Once Bob got to a sale of old TV sets. There were *n* TV sets at that sale. TV set with index *i* costs *a**i* bellars. Some TV sets have a negative price — their owners are ready to pay Bob if he buys their useless apparatus. Bob can «buy» any TV sets he wants. Though he's very strong, Bob can carry at most *m* TV sets, and he has no desire to go to the sale for the second time. Please, help Bob find out the maximum sum of money that he can earn.
|
The first line contains two space-separated integers *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=100) — amount of TV sets at the sale, and amount of TV sets that Bob can carry. The following line contains *n* space-separated integers *a**i* (<=-<=1000<=≤<=*a**i*<=≤<=1000) — prices of the TV sets.
|
Output the only number — the maximum sum of money that Bob can earn, given that he can carry at most *m* TV sets.
|
[
"5 3\n-6 0 35 -2 4\n",
"4 2\n7 0 0 -7\n"
] |
[
"8\n",
"7\n"
] |
none
| 1,000
|
[
{
"input": "5 3\n-6 0 35 -2 4",
"output": "8"
},
{
"input": "4 2\n7 0 0 -7",
"output": "7"
},
{
"input": "6 6\n756 -611 251 -66 572 -818",
"output": "1495"
},
{
"input": "5 5\n976 437 937 788 518",
"output": "0"
},
{
"input": "5 3\n-2 -2 -2 -2 -2",
"output": "6"
},
{
"input": "5 1\n998 997 985 937 998",
"output": "0"
},
{
"input": "2 2\n-742 -187",
"output": "929"
},
{
"input": "3 3\n522 597 384",
"output": "0"
},
{
"input": "4 2\n-215 -620 192 647",
"output": "835"
},
{
"input": "10 6\n557 605 685 231 910 633 130 838 -564 -85",
"output": "649"
},
{
"input": "20 14\n932 442 960 943 624 624 955 998 631 910 850 517 715 123 1000 155 -10 961 966 59",
"output": "10"
},
{
"input": "30 5\n991 997 996 967 977 999 991 986 1000 965 984 997 998 1000 958 983 974 1000 991 999 1000 978 961 992 990 998 998 978 998 1000",
"output": "0"
},
{
"input": "50 20\n-815 -947 -946 -993 -992 -846 -884 -954 -963 -733 -940 -746 -766 -930 -821 -937 -937 -999 -914 -938 -936 -975 -939 -981 -977 -952 -925 -901 -952 -978 -994 -957 -946 -896 -905 -836 -994 -951 -887 -939 -859 -953 -985 -988 -946 -829 -956 -842 -799 -886",
"output": "19441"
},
{
"input": "88 64\n999 999 1000 1000 999 996 995 1000 1000 999 1000 997 998 1000 999 1000 997 1000 993 998 994 999 998 996 1000 997 1000 1000 1000 997 1000 998 997 1000 1000 998 1000 998 999 1000 996 999 999 999 996 995 999 1000 998 999 1000 999 999 1000 1000 1000 996 1000 1000 1000 997 1000 1000 997 999 1000 1000 1000 1000 1000 999 999 1000 1000 996 999 1000 1000 995 999 1000 996 1000 998 999 999 1000 999",
"output": "0"
},
{
"input": "99 17\n-993 -994 -959 -989 -991 -995 -976 -997 -990 -1000 -996 -994 -999 -995 -1000 -983 -979 -1000 -989 -968 -994 -992 -962 -993 -999 -983 -991 -979 -995 -993 -973 -999 -995 -995 -999 -993 -995 -992 -947 -1000 -999 -998 -982 -988 -979 -993 -963 -988 -980 -990 -979 -976 -995 -999 -981 -988 -998 -999 -970 -1000 -983 -994 -943 -975 -998 -977 -973 -997 -959 -999 -983 -985 -950 -977 -977 -991 -998 -973 -987 -985 -985 -986 -984 -994 -978 -998 -989 -989 -988 -970 -985 -974 -997 -981 -962 -972 -995 -988 -993",
"output": "16984"
},
{
"input": "100 37\n205 19 -501 404 912 -435 -322 -469 -655 880 -804 -470 793 312 -108 586 -642 -928 906 605 -353 -800 745 -440 -207 752 -50 -28 498 -800 -62 -195 602 -833 489 352 536 404 -775 23 145 -512 524 759 651 -461 -427 -557 684 -366 62 592 -563 -811 64 418 -881 -308 591 -318 -145 -261 -321 -216 -18 595 -202 960 -4 219 226 -238 -882 -963 425 970 -434 -160 243 -672 -4 873 8 -633 904 -298 -151 -377 -61 -72 -677 -66 197 -716 3 -870 -30 152 -469 981",
"output": "21743"
},
{
"input": "100 99\n-931 -806 -830 -828 -916 -962 -660 -867 -952 -966 -820 -906 -724 -982 -680 -717 -488 -741 -897 -613 -986 -797 -964 -939 -808 -932 -810 -860 -641 -916 -858 -628 -821 -929 -917 -976 -664 -985 -778 -665 -624 -928 -940 -958 -884 -757 -878 -896 -634 -526 -514 -873 -990 -919 -988 -878 -650 -973 -774 -783 -733 -648 -756 -895 -833 -974 -832 -725 -841 -748 -806 -613 -924 -867 -881 -943 -864 -991 -809 -926 -777 -817 -998 -682 -910 -996 -241 -722 -964 -904 -821 -920 -835 -699 -805 -632 -779 -317 -915 -654",
"output": "81283"
},
{
"input": "100 14\n995 994 745 684 510 737 984 690 979 977 542 933 871 603 758 653 962 997 747 974 773 766 975 770 527 960 841 989 963 865 974 967 950 984 757 685 986 809 982 959 931 880 978 867 805 562 970 900 834 782 616 885 910 608 974 918 576 700 871 980 656 941 978 759 767 840 573 859 841 928 693 853 716 927 976 851 962 962 627 797 707 873 869 988 993 533 665 887 962 880 929 980 877 887 572 790 721 883 848 782",
"output": "0"
},
{
"input": "100 84\n768 946 998 752 931 912 826 1000 991 910 875 962 901 952 958 733 959 908 872 840 923 826 952 980 974 980 947 955 959 822 997 963 966 933 829 923 971 999 926 932 865 984 974 858 994 855 949 941 992 861 951 949 991 711 763 728 935 485 716 907 869 952 960 859 909 963 978 942 968 933 923 909 997 962 687 764 924 774 875 1000 961 951 987 974 848 921 966 859 995 997 974 931 886 941 974 986 906 978 998 823",
"output": "0"
},
{
"input": "100 80\n-795 -994 -833 -930 -974 -980 -950 -940 -788 -927 -583 -956 -945 -949 -809 -974 -957 -736 -967 -908 -975 -961 -986 -983 -963 -771 -952 -847 -751 -741 -982 -959 -925 -931 -839 -937 -880 -914 -858 -998 -812 -911 -862 -965 -943 -984 -738 -920 -950 -998 -909 -998 -781 -901 -677 -940 -985 -951 -675 -952 -967 -949 -882 -641 -969 -937 -975 -993 -913 -941 -807 -851 -832 -960 -939 -943 -895 -929 -528 -880 -823 -930 -888 -862 -948 -966 -962 -857 -799 -969 -833 -998 -952 -878 -946 -971 -976 -974 -723 -992",
"output": "75068"
},
{
"input": "1 1\n0",
"output": "0"
},
{
"input": "1 1\n1",
"output": "0"
},
{
"input": "1 1\n555",
"output": "0"
},
{
"input": "1 1\n-1",
"output": "1"
},
{
"input": "1 1\n-24",
"output": "24"
}
] | 1,685,719,569
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 4
| 62
| 0
|
n,d=map(int, input().split(" "))
ls=list(map(int, input().split(" ")))
ls2=[]
for x in ls:
if x<0:
ls2.append(x*-1)
ls2.sort(reverse=True)
dc=0
sm=0
for x in range(len(ls2)):
if dc>d:
break
sm+=ls2[x]
dc+=1
print(sm)
|
Title: Sale
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Once Bob got to a sale of old TV sets. There were *n* TV sets at that sale. TV set with index *i* costs *a**i* bellars. Some TV sets have a negative price — their owners are ready to pay Bob if he buys their useless apparatus. Bob can «buy» any TV sets he wants. Though he's very strong, Bob can carry at most *m* TV sets, and he has no desire to go to the sale for the second time. Please, help Bob find out the maximum sum of money that he can earn.
Input Specification:
The first line contains two space-separated integers *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=100) — amount of TV sets at the sale, and amount of TV sets that Bob can carry. The following line contains *n* space-separated integers *a**i* (<=-<=1000<=≤<=*a**i*<=≤<=1000) — prices of the TV sets.
Output Specification:
Output the only number — the maximum sum of money that Bob can earn, given that he can carry at most *m* TV sets.
Demo Input:
['5 3\n-6 0 35 -2 4\n', '4 2\n7 0 0 -7\n']
Demo Output:
['8\n', '7\n']
Note:
none
|
```python
n,d=map(int, input().split(" "))
ls=list(map(int, input().split(" ")))
ls2=[]
for x in ls:
if x<0:
ls2.append(x*-1)
ls2.sort(reverse=True)
dc=0
sm=0
for x in range(len(ls2)):
if dc>d:
break
sm+=ls2[x]
dc+=1
print(sm)
```
| 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,694,049,906
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 3
| 31
| 0
|
rangos = str(input())
amigos = str(input())
salida = 0
contador = 0
lista = amigos.split(" ")
for i in range(len(lista)):
if(int(lista[contador]) > int(rangos[2])):
salida += 2
else:
salida += 1
contador += 1
print(salida)
|
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
rangos = str(input())
amigos = str(input())
salida = 0
contador = 0
lista = amigos.split(" ")
for i in range(len(lista)):
if(int(lista[contador]) > int(rangos[2])):
salida += 2
else:
salida += 1
contador += 1
print(salida)
```
| -1
|
|
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,698,042,004
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 15
| 62
| 9,625,600
|
arr = list(map(int,input().split()))
k,n,w = arr[0],arr[1],arr[2]
price = sum(list(range(1,w+1))*k)
print("0") if price<n else print(price-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
arr = list(map(int,input().split()))
k,n,w = arr[0],arr[1],arr[2]
price = sum(list(range(1,w+1))*k)
print("0") if price<n else print(price-n)
```
| 3
|
|
1,007
|
A
|
Reorder the Array
|
PROGRAMMING
| 1,300
|
[
"combinatorics",
"data structures",
"math",
"sortings",
"two pointers"
] | null | null |
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array $[10, 20, 30, 40]$, we can permute it so that it becomes $[20, 40, 10, 30]$. Then on the first and the second positions the integers became larger ($20>10$, $40>20$) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals $2$. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
|
The first line contains a single integer $n$ ($1 \leq n \leq 10^5$) — the length of the array.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the elements of the array.
|
Print a single integer — the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
|
[
"7\n10 1 1 1 5 5 3\n",
"5\n1 1 1 1 1\n"
] |
[
"4\n",
"0\n"
] |
In the first sample, one of the best permutations is $[1, 5, 5, 3, 10, 1, 1]$. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
| 500
|
[
{
"input": "7\n10 1 1 1 5 5 3",
"output": "4"
},
{
"input": "5\n1 1 1 1 1",
"output": "0"
},
{
"input": "6\n300000000 200000000 300000000 200000000 1000000000 300000000",
"output": "3"
},
{
"input": "10\n1 2 3 4 5 6 7 8 9 10",
"output": "9"
},
{
"input": "1\n1",
"output": "0"
},
{
"input": "7\n3 5 2 2 5 2 4",
"output": "4"
},
{
"input": "5\n1 5 4 2 3",
"output": "4"
}
] | 1,533,261,656
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 7
| 2,000
| 819,200
|
n=int(input())
l=[int(i) for i in input().split()]
print(n-max(l.count(i) for i in l))
|
Title: Reorder the Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array $[10, 20, 30, 40]$, we can permute it so that it becomes $[20, 40, 10, 30]$. Then on the first and the second positions the integers became larger ($20>10$, $40>20$) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals $2$. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input Specification:
The first line contains a single integer $n$ ($1 \leq n \leq 10^5$) — the length of the array.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the elements of the array.
Output Specification:
Print a single integer — the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Demo Input:
['7\n10 1 1 1 5 5 3\n', '5\n1 1 1 1 1\n']
Demo Output:
['4\n', '0\n']
Note:
In the first sample, one of the best permutations is $[1, 5, 5, 3, 10, 1, 1]$. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
|
```python
n=int(input())
l=[int(i) for i in input().split()]
print(n-max(l.count(i) for i in l))
```
| 0
|
|
766
|
B
|
Mahmoud and a Triangle
|
PROGRAMMING
| 1,000
|
[
"constructive algorithms",
"geometry",
"greedy",
"math",
"number theory",
"sortings"
] | null | null |
Mahmoud has *n* line segments, the *i*-th of them has length *a**i*. Ehab challenged him to use exactly 3 line segments to form a non-degenerate triangle. Mahmoud doesn't accept challenges unless he is sure he can win, so he asked you to tell him if he should accept the challenge. Given the lengths of the line segments, check if he can choose exactly 3 of them to form a non-degenerate triangle.
Mahmoud should use exactly 3 line segments, he can't concatenate two line segments or change any length. A non-degenerate triangle is a triangle with positive area.
|
The first line contains single integer *n* (3<=≤<=*n*<=≤<=105) — the number of line segments Mahmoud has.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the lengths of line segments Mahmoud has.
|
In the only line print "YES" if he can choose exactly three line segments and form a non-degenerate triangle with them, and "NO" otherwise.
|
[
"5\n1 5 3 2 4\n",
"3\n4 1 2\n"
] |
[
"YES\n",
"NO\n"
] |
For the first example, he can use line segments with lengths 2, 4 and 5 to form a non-degenerate triangle.
| 1,000
|
[
{
"input": "5\n1 5 3 2 4",
"output": "YES"
},
{
"input": "3\n4 1 2",
"output": "NO"
},
{
"input": "30\n197 75 517 39724 7906061 1153471 3 15166 168284 3019844 272293 316 16 24548 42 118 5792 5 9373 1866366 4886214 24 2206 712886 104005 1363 836 64273 440585 3576",
"output": "NO"
},
{
"input": "30\n229017064 335281886 247217656 670601882 743442492 615491486 544941439 911270108 474843964 803323771 177115397 62179276 390270885 754889875 881720571 902691435 154083299 328505383 761264351 182674686 94104683 357622370 573909964 320060691 33548810 247029007 812823597 946798893 813659359 710111761",
"output": "YES"
},
{
"input": "40\n740553458 532562042 138583675 75471987 487348843 476240280 972115023 103690894 546736371 915774563 35356828 819948191 138721993 24257926 761587264 767176616 608310208 78275645 386063134 227581756 672567198 177797611 87579917 941781518 274774331 843623616 981221615 630282032 118843963 749160513 354134861 132333165 405839062 522698334 29698277 541005920 856214146 167344951 398332403 68622974",
"output": "YES"
},
{
"input": "40\n155 1470176 7384 765965701 1075 4 561554 6227772 93 16304522 1744 662 3 292572860 19335 908613 42685804 347058 20 132560 3848974 69067081 58 2819 111752888 408 81925 30 11951 4564 251 26381275 473392832 50628 180819969 2378797 10076746 9 214492 31291",
"output": "NO"
},
{
"input": "3\n1 1000000000 1000000000",
"output": "YES"
},
{
"input": "4\n1 1000000000 1000000000 1000000000",
"output": "YES"
},
{
"input": "3\n1 1000000000 1",
"output": "NO"
},
{
"input": "5\n1 2 3 5 2",
"output": "YES"
},
{
"input": "41\n19 161 4090221 118757367 2 45361275 1562319 596751 140871 97 1844 310910829 10708344 6618115 698 1 87059 33 2527892 12703 73396090 17326460 3 368811 20550 813975131 10 53804 28034805 7847 2992 33254 1139 227930 965568 261 4846 503064297 192153458 57 431",
"output": "NO"
},
{
"input": "42\n4317083 530966905 202811311 104 389267 35 1203 18287479 125344279 21690 859122498 65 859122508 56790 1951 148683 457 1 22 2668100 8283 2 77467028 13405 11302280 47877251 328155592 35095 29589769 240574 4 10 1019123 6985189 629846 5118 169 1648973 91891 741 282 3159",
"output": "YES"
},
{
"input": "43\n729551585 11379 5931704 330557 1653 15529406 729551578 278663905 1 729551584 2683 40656510 29802 147 1400284 2 126260 865419 51 17 172223763 86 1 534861 450887671 32 234 25127103 9597697 48226 7034 389 204294 2265706 65783617 4343 3665990 626 78034 106440137 5 18421 1023",
"output": "YES"
},
{
"input": "44\n719528276 2 235 444692918 24781885 169857576 18164 47558 15316043 9465834 64879816 2234575 1631 853530 8 1001 621 719528259 84 6933 31 1 3615623 719528266 40097928 274835337 1381044 11225 2642 5850203 6 527506 18 104977753 76959 29393 49 4283 141 201482 380 1 124523 326015",
"output": "YES"
},
{
"input": "45\n28237 82 62327732 506757 691225170 5 970 4118 264024506 313192 367 14713577 73933 691225154 6660 599 691225145 3473403 51 427200630 1326718 2146678 100848386 1569 27 163176119 193562 10784 45687 819951 38520653 225 119620 1 3 691225169 691225164 17445 23807072 1 9093493 5620082 2542 139 14",
"output": "YES"
},
{
"input": "44\n165580141 21 34 55 1 89 144 17711 2 377 610 987 2584 13 5 4181 6765 10946 1597 8 28657 3 233 75025 121393 196418 317811 9227465 832040 1346269 2178309 3524578 5702887 1 14930352 102334155 24157817 39088169 63245986 701408733 267914296 433494437 514229 46368",
"output": "NO"
},
{
"input": "3\n1 1000000000 999999999",
"output": "NO"
},
{
"input": "5\n1 1 1 1 1",
"output": "YES"
},
{
"input": "10\n1 10 100 1000 10000 100000 1000000 10000000 100000000 1000000000",
"output": "NO"
},
{
"input": "5\n2 3 4 10 20",
"output": "YES"
},
{
"input": "6\n18 23 40 80 160 161",
"output": "YES"
},
{
"input": "4\n5 6 7 888",
"output": "YES"
},
{
"input": "9\n1 1 2 2 4 5 10 10 20",
"output": "YES"
},
{
"input": "7\n3 150 900 4 500 1500 5",
"output": "YES"
},
{
"input": "3\n2 2 3",
"output": "YES"
},
{
"input": "7\n1 2 100 200 250 1000000 2000000",
"output": "YES"
},
{
"input": "8\n2 3 5 5 5 6 6 13",
"output": "YES"
},
{
"input": "3\n2 3 4",
"output": "YES"
},
{
"input": "6\n1 1 1 4 5 100",
"output": "YES"
},
{
"input": "13\n1 2 3 5 8 13 22 34 55 89 144 233 377",
"output": "YES"
},
{
"input": "4\n2 3 4 8",
"output": "YES"
},
{
"input": "3\n5 6 7",
"output": "YES"
},
{
"input": "5\n1 4 5 6 1000000",
"output": "YES"
},
{
"input": "4\n5 6 7 20",
"output": "YES"
},
{
"input": "6\n1 1 1 1 1 65",
"output": "YES"
},
{
"input": "4\n3 4 5 100",
"output": "YES"
},
{
"input": "3\n2 4 5",
"output": "YES"
},
{
"input": "7\n1 1 1 1 1 10 1000",
"output": "YES"
},
{
"input": "4\n1 1 2 3",
"output": "NO"
},
{
"input": "11\n1 2 5 6 7 8 9 17 18 19 100",
"output": "YES"
},
{
"input": "4\n5 16 20 200",
"output": "YES"
},
{
"input": "5\n17 6 3 3 1",
"output": "YES"
},
{
"input": "3\n1 1 1",
"output": "YES"
},
{
"input": "6\n1 1 1 2 3 5",
"output": "YES"
},
{
"input": "4\n2 4 6 6",
"output": "YES"
},
{
"input": "9\n1 2 4 4 4 4 7 8 20",
"output": "YES"
},
{
"input": "9\n1 1 2 5 5 5 10 10 20",
"output": "YES"
},
{
"input": "7\n3 150 600 4 1700 6000 5",
"output": "YES"
},
{
"input": "5\n5761 20966 27841 28800 29399",
"output": "YES"
},
{
"input": "9\n1 2 3 6 7 10 11 12 24",
"output": "YES"
},
{
"input": "4\n1 2 1 1",
"output": "YES"
},
{
"input": "5\n1 1 2 3 4",
"output": "YES"
}
] | 1,652,526,394
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 46
| 7,884,800
|
a = int(input())
n = list(map(int ,input() .split()))
q = n.index(max(n))
p = n.pop(q)
if min(n) + max(n) == p:
print('YES')
else:
print('NO')
|
Title: Mahmoud and a Triangle
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mahmoud has *n* line segments, the *i*-th of them has length *a**i*. Ehab challenged him to use exactly 3 line segments to form a non-degenerate triangle. Mahmoud doesn't accept challenges unless he is sure he can win, so he asked you to tell him if he should accept the challenge. Given the lengths of the line segments, check if he can choose exactly 3 of them to form a non-degenerate triangle.
Mahmoud should use exactly 3 line segments, he can't concatenate two line segments or change any length. A non-degenerate triangle is a triangle with positive area.
Input Specification:
The first line contains single integer *n* (3<=≤<=*n*<=≤<=105) — the number of line segments Mahmoud has.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the lengths of line segments Mahmoud has.
Output Specification:
In the only line print "YES" if he can choose exactly three line segments and form a non-degenerate triangle with them, and "NO" otherwise.
Demo Input:
['5\n1 5 3 2 4\n', '3\n4 1 2\n']
Demo Output:
['YES\n', 'NO\n']
Note:
For the first example, he can use line segments with lengths 2, 4 and 5 to form a non-degenerate triangle.
|
```python
a = int(input())
n = list(map(int ,input() .split()))
q = n.index(max(n))
p = n.pop(q)
if min(n) + max(n) == p:
print('YES')
else:
print('NO')
```
| 0
|
|
569
|
B
|
Inventory
|
PROGRAMMING
| 1,200
|
[
"greedy",
"math"
] | null | null |
Companies always have a lot of equipment, furniture and other things. All of them should be tracked. To do this, there is an inventory number assigned with each item. It is much easier to create a database by using those numbers and keep the track of everything.
During an audit, you were surprised to find out that the items are not numbered sequentially, and some items even share the same inventory number! There is an urgent need to fix it. You have chosen to make the numbers of the items sequential, starting with 1. Changing a number is quite a time-consuming process, and you would like to make maximum use of the current numbering.
You have been given information on current inventory numbers for *n* items in the company. Renumber items so that their inventory numbers form a permutation of numbers from 1 to *n* by changing the number of as few items as possible. Let us remind you that a set of *n* numbers forms a permutation if all the numbers are in the range from 1 to *n*, and no two numbers are equal.
|
The first line contains a single integer *n* — the number of items (1<=≤<=*n*<=≤<=105).
The second line contains *n* numbers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=105) — the initial inventory numbers of the items.
|
Print *n* numbers — the final inventory numbers of the items in the order they occur in the input. If there are multiple possible answers, you may print any of them.
|
[
"3\n1 3 2\n",
"4\n2 2 3 3\n",
"1\n2\n"
] |
[
"1 3 2 \n",
"2 1 3 4 \n",
"1 \n"
] |
In the first test the numeration is already a permutation, so there is no need to change anything.
In the second test there are two pairs of equal numbers, in each pair you need to replace one number.
In the third test you need to replace 2 by 1, as the numbering should start from one.
| 1,000
|
[
{
"input": "3\n1 3 2",
"output": "1 3 2 "
},
{
"input": "4\n2 2 3 3",
"output": "2 1 3 4 "
},
{
"input": "1\n2",
"output": "1 "
},
{
"input": "3\n3 3 1",
"output": "3 2 1 "
},
{
"input": "5\n1 1 1 1 1",
"output": "1 2 3 4 5 "
},
{
"input": "5\n5 3 4 4 2",
"output": "5 3 4 1 2 "
},
{
"input": "5\n19 11 8 8 10",
"output": "1 2 3 4 5 "
},
{
"input": "15\n2 2 1 2 1 2 3 3 1 3 2 1 2 3 2",
"output": "2 4 1 5 6 7 3 8 9 10 11 12 13 14 15 "
},
{
"input": "18\n3 11 5 9 5 4 6 4 5 7 5 1 8 11 11 2 1 9",
"output": "3 11 5 9 10 4 6 12 13 7 14 1 8 15 16 2 17 18 "
},
{
"input": "42\n999 863 440 1036 1186 908 330 265 382 417 858 286 834 922 42 569 79 158 312 1175 1069 188 21 1207 985 375 59 417 256 595 732 742 629 737 25 699 484 517 37 1134 472 720",
"output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 42 15 16 17 18 19 20 22 21 23 24 26 27 28 29 30 31 32 33 34 25 35 36 38 37 39 40 41 "
},
{
"input": "111\n15 45 14 65 49 25 102 86 14 80 54 73 43 78 42 32 47 60 55 66 84 69 49 22 26 72 89 52 26 80 71 35 56 2 88 23 23 53 65 92 46 73 29 65 88 99 19 99 87 10 47 96 109 20 60 89 63 105 29 92 109 20 95 65 31 89 107 3 3 50 58 9 28 39 104 42 41 36 70 49 59 96 16 9 3 108 38 42 2 67 32 86 20 6 101 70 101 91 38 10 74 3 27 15 103 63 51 60 62 10 70",
"output": "15 45 14 65 49 25 102 86 1 80 54 73 43 78 42 32 47 60 55 66 84 69 4 22 26 72 89 52 5 7 71 35 56 2 88 23 8 53 11 92 46 12 29 13 17 99 19 18 87 10 21 96 109 20 24 30 63 105 33 34 37 40 95 44 31 48 107 3 57 50 58 9 28 39 104 61 41 36 70 64 59 68 16 75 76 108 38 77 79 67 81 82 83 6 101 85 90 91 93 94 74 97 27 98 103 100 51 106 62 110 111 "
},
{
"input": "7\n45301 14370 61599 42695 46301 24556 26812",
"output": "1 2 3 4 5 6 7 "
},
{
"input": "22\n70150 17718 11731 6488 72633 41249 12141 71465 88562 6167 71659 34151 60508 24942 77343 35882 80424 67225 92746 55412 79 53642",
"output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 "
},
{
"input": "2\n1 4",
"output": "1 2 "
}
] | 1,590,553,326
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 29
| 217
| 10,854,400
|
n = int(input())
a = [int(x) for x in input().split()]
s = set(a)
exist = set(s)
next = 1
for i in range(n):
if a[i] <= n and a[i] in s:
s.remove(a[i])
else:
while next in exist:
next += 1
a[i] = next
next += 1
print(' '.join(str(x) for x in a))
|
Title: Inventory
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Companies always have a lot of equipment, furniture and other things. All of them should be tracked. To do this, there is an inventory number assigned with each item. It is much easier to create a database by using those numbers and keep the track of everything.
During an audit, you were surprised to find out that the items are not numbered sequentially, and some items even share the same inventory number! There is an urgent need to fix it. You have chosen to make the numbers of the items sequential, starting with 1. Changing a number is quite a time-consuming process, and you would like to make maximum use of the current numbering.
You have been given information on current inventory numbers for *n* items in the company. Renumber items so that their inventory numbers form a permutation of numbers from 1 to *n* by changing the number of as few items as possible. Let us remind you that a set of *n* numbers forms a permutation if all the numbers are in the range from 1 to *n*, and no two numbers are equal.
Input Specification:
The first line contains a single integer *n* — the number of items (1<=≤<=*n*<=≤<=105).
The second line contains *n* numbers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=105) — the initial inventory numbers of the items.
Output Specification:
Print *n* numbers — the final inventory numbers of the items in the order they occur in the input. If there are multiple possible answers, you may print any of them.
Demo Input:
['3\n1 3 2\n', '4\n2 2 3 3\n', '1\n2\n']
Demo Output:
['1 3 2 \n', '2 1 3 4 \n', '1 \n']
Note:
In the first test the numeration is already a permutation, so there is no need to change anything.
In the second test there are two pairs of equal numbers, in each pair you need to replace one number.
In the third test you need to replace 2 by 1, as the numbering should start from one.
|
```python
n = int(input())
a = [int(x) for x in input().split()]
s = set(a)
exist = set(s)
next = 1
for i in range(n):
if a[i] <= n and a[i] in s:
s.remove(a[i])
else:
while next in exist:
next += 1
a[i] = next
next += 1
print(' '.join(str(x) for x in a))
```
| 3
|
|
239
|
A
|
Two Bags of Potatoes
|
PROGRAMMING
| 1,200
|
[
"greedy",
"implementation",
"math"
] | null | null |
Valera had two bags of potatoes, the first of these bags contains *x* (*x*<=≥<=1) potatoes, and the second — *y* (*y*<=≥<=1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains *x* potatoes) Valera lost. Valera remembers that the total amount of potatoes (*x*<=+<=*y*) in the two bags, firstly, was not gerater than *n*, and, secondly, was divisible by *k*.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
|
The first line of input contains three integers *y*, *k*, *n* (1<=≤<=*y*,<=*k*,<=*n*<=≤<=109; <=≤<=105).
|
Print the list of whitespace-separated integers — all possible values of *x* in ascending order. You should print each possible value of *x* exactly once.
If there are no such values of *x* print a single integer -1.
|
[
"10 1 10\n",
"10 6 40\n"
] |
[
"-1\n",
"2 8 14 20 26 \n"
] |
none
| 500
|
[
{
"input": "10 1 10",
"output": "-1"
},
{
"input": "10 6 40",
"output": "2 8 14 20 26 "
},
{
"input": "10 1 20",
"output": "1 2 3 4 5 6 7 8 9 10 "
},
{
"input": "1 10000 1000000000",
"output": "9999 19999 29999 39999 49999 59999 69999 79999 89999 99999 109999 119999 129999 139999 149999 159999 169999 179999 189999 199999 209999 219999 229999 239999 249999 259999 269999 279999 289999 299999 309999 319999 329999 339999 349999 359999 369999 379999 389999 399999 409999 419999 429999 439999 449999 459999 469999 479999 489999 499999 509999 519999 529999 539999 549999 559999 569999 579999 589999 599999 609999 619999 629999 639999 649999 659999 669999 679999 689999 699999 709999 719999 729999 739999 7499..."
},
{
"input": "84817 1 33457",
"output": "-1"
},
{
"input": "21 37 99",
"output": "16 53 "
},
{
"input": "78 7 15",
"output": "-1"
},
{
"input": "74 17 27",
"output": "-1"
},
{
"input": "79 23 43",
"output": "-1"
},
{
"input": "32 33 3",
"output": "-1"
},
{
"input": "55 49 44",
"output": "-1"
},
{
"input": "64 59 404",
"output": "54 113 172 231 290 "
},
{
"input": "61 69 820",
"output": "8 77 146 215 284 353 422 491 560 629 698 "
},
{
"input": "17 28 532",
"output": "11 39 67 95 123 151 179 207 235 263 291 319 347 375 403 431 459 487 515 "
},
{
"input": "46592 52 232",
"output": "-1"
},
{
"input": "1541 58 648",
"output": "-1"
},
{
"input": "15946 76 360",
"output": "-1"
},
{
"input": "30351 86 424",
"output": "-1"
},
{
"input": "1 2 37493",
"output": "1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 101 103 105 107 109 111 113 115 117 119 121 123 125 127 129 131 133 135 137 139 141 143 145 147 149 151 153 155 157 159 161 163 165 167 169 171 173 175 177 179 181 183 185 187 189 191 193 195 197 199 201 203 205 207 209 211 213 215 217 219 221 223 225 227 229 231 233 235 237 239 241 243 245 247 249 251 253 255 257 259 261 263 265 267 269 271 273 275 277 279 281 28..."
},
{
"input": "1 3 27764",
"output": "2 5 8 11 14 17 20 23 26 29 32 35 38 41 44 47 50 53 56 59 62 65 68 71 74 77 80 83 86 89 92 95 98 101 104 107 110 113 116 119 122 125 128 131 134 137 140 143 146 149 152 155 158 161 164 167 170 173 176 179 182 185 188 191 194 197 200 203 206 209 212 215 218 221 224 227 230 233 236 239 242 245 248 251 254 257 260 263 266 269 272 275 278 281 284 287 290 293 296 299 302 305 308 311 314 317 320 323 326 329 332 335 338 341 344 347 350 353 356 359 362 365 368 371 374 377 380 383 386 389 392 395 398 401 404 407 410..."
},
{
"input": "10 4 9174",
"output": "2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62 66 70 74 78 82 86 90 94 98 102 106 110 114 118 122 126 130 134 138 142 146 150 154 158 162 166 170 174 178 182 186 190 194 198 202 206 210 214 218 222 226 230 234 238 242 246 250 254 258 262 266 270 274 278 282 286 290 294 298 302 306 310 314 318 322 326 330 334 338 342 346 350 354 358 362 366 370 374 378 382 386 390 394 398 402 406 410 414 418 422 426 430 434 438 442 446 450 454 458 462 466 470 474 478 482 486 490 494 498 502 506 510 514 518 522 526 530 534 53..."
},
{
"input": "33 7 4971",
"output": "2 9 16 23 30 37 44 51 58 65 72 79 86 93 100 107 114 121 128 135 142 149 156 163 170 177 184 191 198 205 212 219 226 233 240 247 254 261 268 275 282 289 296 303 310 317 324 331 338 345 352 359 366 373 380 387 394 401 408 415 422 429 436 443 450 457 464 471 478 485 492 499 506 513 520 527 534 541 548 555 562 569 576 583 590 597 604 611 618 625 632 639 646 653 660 667 674 681 688 695 702 709 716 723 730 737 744 751 758 765 772 779 786 793 800 807 814 821 828 835 842 849 856 863 870 877 884 891 898 905 912 919..."
},
{
"input": "981 1 3387",
"output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..."
},
{
"input": "386 1 2747",
"output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..."
},
{
"input": "123 2 50000",
"output": "1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 101 103 105 107 109 111 113 115 117 119 121 123 125 127 129 131 133 135 137 139 141 143 145 147 149 151 153 155 157 159 161 163 165 167 169 171 173 175 177 179 181 183 185 187 189 191 193 195 197 199 201 203 205 207 209 211 213 215 217 219 221 223 225 227 229 231 233 235 237 239 241 243 245 247 249 251 253 255 257 259 261 263 265 267 269 271 273 275 277 279 281 28..."
},
{
"input": "3123 100 10000000",
"output": "77 177 277 377 477 577 677 777 877 977 1077 1177 1277 1377 1477 1577 1677 1777 1877 1977 2077 2177 2277 2377 2477 2577 2677 2777 2877 2977 3077 3177 3277 3377 3477 3577 3677 3777 3877 3977 4077 4177 4277 4377 4477 4577 4677 4777 4877 4977 5077 5177 5277 5377 5477 5577 5677 5777 5877 5977 6077 6177 6277 6377 6477 6577 6677 6777 6877 6977 7077 7177 7277 7377 7477 7577 7677 7777 7877 7977 8077 8177 8277 8377 8477 8577 8677 8777 8877 8977 9077 9177 9277 9377 9477 9577 9677 9777 9877 9977 10077 10177 10277 1037..."
},
{
"input": "2 10000 1000000000",
"output": "9998 19998 29998 39998 49998 59998 69998 79998 89998 99998 109998 119998 129998 139998 149998 159998 169998 179998 189998 199998 209998 219998 229998 239998 249998 259998 269998 279998 289998 299998 309998 319998 329998 339998 349998 359998 369998 379998 389998 399998 409998 419998 429998 439998 449998 459998 469998 479998 489998 499998 509998 519998 529998 539998 549998 559998 569998 579998 589998 599998 609998 619998 629998 639998 649998 659998 669998 679998 689998 699998 709998 719998 729998 739998 7499..."
},
{
"input": "3 10000 1000000000",
"output": "9997 19997 29997 39997 49997 59997 69997 79997 89997 99997 109997 119997 129997 139997 149997 159997 169997 179997 189997 199997 209997 219997 229997 239997 249997 259997 269997 279997 289997 299997 309997 319997 329997 339997 349997 359997 369997 379997 389997 399997 409997 419997 429997 439997 449997 459997 469997 479997 489997 499997 509997 519997 529997 539997 549997 559997 569997 579997 589997 599997 609997 619997 629997 639997 649997 659997 669997 679997 689997 699997 709997 719997 729997 739997 7499..."
},
{
"input": "12312223 10000 1000000000",
"output": "7777 17777 27777 37777 47777 57777 67777 77777 87777 97777 107777 117777 127777 137777 147777 157777 167777 177777 187777 197777 207777 217777 227777 237777 247777 257777 267777 277777 287777 297777 307777 317777 327777 337777 347777 357777 367777 377777 387777 397777 407777 417777 427777 437777 447777 457777 467777 477777 487777 497777 507777 517777 527777 537777 547777 557777 567777 577777 587777 597777 607777 617777 627777 637777 647777 657777 667777 677777 687777 697777 707777 717777 727777 737777 7477..."
},
{
"input": "500000000 1000000000 1000000000",
"output": "500000000 "
},
{
"input": "1 1000000000 1000000000",
"output": "999999999 "
},
{
"input": "10 6 11",
"output": "-1"
},
{
"input": "2 100 10",
"output": "-1"
},
{
"input": "1 100000007 1000000000",
"output": "100000006 200000013 300000020 400000027 500000034 600000041 700000048 800000055 900000062 "
},
{
"input": "1 999999999 1000000000",
"output": "999999998 "
},
{
"input": "100000000 1000000000 1000000000",
"output": "900000000 "
},
{
"input": "11 2 12",
"output": "1 "
},
{
"input": "31 10 39",
"output": "-1"
},
{
"input": "48 6 50",
"output": "-1"
},
{
"input": "500000000 500000000 1000000000",
"output": "500000000 "
},
{
"input": "1 1000000000 999999999",
"output": "-1"
},
{
"input": "4 2 10",
"output": "2 4 6 "
},
{
"input": "1000000000 1 1",
"output": "-1"
},
{
"input": "1000000000 1 100000",
"output": "-1"
},
{
"input": "1000000000 1 10",
"output": "-1"
},
{
"input": "10 5 14",
"output": "-1"
},
{
"input": "500000000 499999999 1000000000",
"output": "499999998 "
},
{
"input": "1 999999997 1000000000",
"output": "999999996 "
}
] | 1,676,912,641
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 2
| 122
| 0
|
from math import ceil; y, k, n = map(int,input().split()); ans = [ ]; i = (ceil(y/k) * k) - y
while i < n - y and i > 0:ans.append(i); i += k
if ans :print(*ans)
else : print(-1)
|
Title: Two Bags of Potatoes
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Valera had two bags of potatoes, the first of these bags contains *x* (*x*<=≥<=1) potatoes, and the second — *y* (*y*<=≥<=1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains *x* potatoes) Valera lost. Valera remembers that the total amount of potatoes (*x*<=+<=*y*) in the two bags, firstly, was not gerater than *n*, and, secondly, was divisible by *k*.
Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.
Input Specification:
The first line of input contains three integers *y*, *k*, *n* (1<=≤<=*y*,<=*k*,<=*n*<=≤<=109; <=≤<=105).
Output Specification:
Print the list of whitespace-separated integers — all possible values of *x* in ascending order. You should print each possible value of *x* exactly once.
If there are no such values of *x* print a single integer -1.
Demo Input:
['10 1 10\n', '10 6 40\n']
Demo Output:
['-1\n', '2 8 14 20 26 \n']
Note:
none
|
```python
from math import ceil; y, k, n = map(int,input().split()); ans = [ ]; i = (ceil(y/k) * k) - y
while i < n - y and i > 0:ans.append(i); i += k
if ans :print(*ans)
else : print(-1)
```
| 0
|
|
369
|
A
|
Valera and Plates
|
PROGRAMMING
| 900
|
[
"greedy",
"implementation"
] | null | null |
Valera is a lazy student. He has *m* clean bowls and *k* clean plates.
Valera has made an eating plan for the next *n* days. As Valera is lazy, he will eat exactly one dish per day. At that, in order to eat a dish, he needs exactly one clean plate or bowl. We know that Valera can cook only two types of dishes. He can eat dishes of the first type from bowls and dishes of the second type from either bowls or plates.
When Valera finishes eating, he leaves a dirty plate/bowl behind. His life philosophy doesn't let him eat from dirty kitchenware. So sometimes he needs to wash his plate/bowl before eating. Find the minimum number of times Valera will need to wash a plate/bowl, if he acts optimally.
|
The first line of the input contains three integers *n*, *m*, *k* (1<=≤<=*n*,<=*m*,<=*k*<=≤<=1000) — the number of the planned days, the number of clean bowls and the number of clean plates.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=2). If *a**i* equals one, then on day *i* Valera will eat a first type dish. If *a**i* equals two, then on day *i* Valera will eat a second type dish.
|
Print a single integer — the minimum number of times Valera will need to wash a plate/bowl.
|
[
"3 1 1\n1 2 1\n",
"4 3 1\n1 1 1 1\n",
"3 1 2\n2 2 2\n",
"8 2 2\n1 2 1 2 1 2 1 2\n"
] |
[
"1\n",
"1\n",
"0\n",
"4\n"
] |
In the first sample Valera will wash a bowl only on the third day, so the answer is one.
In the second sample, Valera will have the first type of the dish during all four days, and since there are only three bowls, he will wash a bowl exactly once.
In the third sample, Valera will have the second type of dish for all three days, and as they can be eaten from either a plate or a bowl, he will never need to wash a plate/bowl.
| 500
|
[
{
"input": "3 1 1\n1 2 1",
"output": "1"
},
{
"input": "4 3 1\n1 1 1 1",
"output": "1"
},
{
"input": "3 1 2\n2 2 2",
"output": "0"
},
{
"input": "8 2 2\n1 2 1 2 1 2 1 2",
"output": "4"
},
{
"input": "2 100 100\n2 2",
"output": "0"
},
{
"input": "1 1 1\n2",
"output": "0"
},
{
"input": "233 100 1\n2 2 1 1 1 2 2 2 2 1 1 2 2 2 1 2 2 1 1 1 2 2 1 1 1 1 2 1 2 2 1 1 2 2 1 2 2 1 2 1 2 1 2 2 2 1 1 1 1 2 1 2 1 1 2 1 1 2 2 1 2 1 2 1 1 1 1 1 1 1 1 1 2 1 2 2 2 1 1 2 2 1 1 1 1 2 1 1 2 1 2 2 2 1 1 1 2 2 2 1 1 1 1 2 1 2 1 1 1 1 2 2 2 1 1 2 1 2 1 1 1 1 1 2 1 1 1 1 1 2 1 1 2 2 1 2 1 1 2 2 1 1 2 2 1 1 1 2 2 1 1 2 1 2 1 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 2 2 1 2 2 1 1 1 2 2 1 1 2 2 1 1 2 1 1 2 2 1 2 2 2 2 2 2 1 2 2 2 2 2 1 1 2 2 2 2 2 2 1 1 1 2 1 2 2 2 2 2 2 2 2 1 1 2 1 2 1 2 2",
"output": "132"
},
{
"input": "123 100 1\n2 2 2 1 1 2 2 2 2 1 1 2 2 2 1 2 2 2 2 1 2 2 2 1 1 1 2 2 2 2 1 2 2 2 2 2 2 1 2 1 2 1 2 2 2 1 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 2 1 1 1 1 1 1 1 1 1 2 2 2 2 2 1 1 2 2 1 1 1 1 2 1 2 2 1 2 2 2 1 1 1 2 2 2 1 2 2 2 2 1 2 2 2 2 1 2 2 2 1 1 2 1 2 1 2 1 1 1",
"output": "22"
},
{
"input": "188 100 1\n2 2 1 1 1 2 2 2 2 1 1 2 2 2 1 2 2 1 1 1 2 2 1 1 1 1 2 1 2 2 1 1 2 2 1 2 2 1 2 1 2 1 2 2 2 1 1 1 1 2 1 2 1 1 2 1 1 2 2 1 2 1 2 1 1 1 1 1 1 1 1 1 2 1 2 2 2 1 1 2 2 1 1 1 1 2 1 1 2 1 2 2 2 1 1 1 2 2 2 1 1 1 1 2 1 2 1 1 1 1 2 2 2 1 1 2 1 2 1 1 1 1 1 2 1 1 1 1 1 2 1 1 2 2 1 2 1 1 2 2 1 1 2 2 1 1 1 2 2 1 1 2 1 2 1 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 2 2 1 2 2 1 1 1 2 2 1 1 2 2 1 1 2 1",
"output": "87"
},
{
"input": "3 1 2\n1 1 1",
"output": "2"
},
{
"input": "3 2 2\n1 1 1",
"output": "1"
},
{
"input": "3 2 1\n1 1 1",
"output": "1"
},
{
"input": "3 1 1\n1 1 1",
"output": "2"
},
{
"input": "5 1 2\n2 2 2 2 2",
"output": "2"
},
{
"input": "5 2 2\n2 2 2 2 2",
"output": "1"
},
{
"input": "5 2 1\n2 2 2 2 2",
"output": "2"
},
{
"input": "5 1 1\n2 2 2 2 2",
"output": "3"
},
{
"input": "1 1 2\n2",
"output": "0"
},
{
"input": "1 2 2\n2",
"output": "0"
},
{
"input": "1 2 1\n2",
"output": "0"
},
{
"input": "1 1 1\n2",
"output": "0"
},
{
"input": "6 3 1\n1 1 2 2 2 2",
"output": "2"
},
{
"input": "100 40 20\n2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 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",
"output": "40"
},
{
"input": "7 5 2\n2 2 1 1 1 1 1",
"output": "0"
},
{
"input": "10 4 4\n2 2 2 2 2 2 1 1 1 1",
"output": "2"
},
{
"input": "3 2 1\n2 1 1",
"output": "0"
},
{
"input": "7 6 1\n2 1 1 1 1 1 1",
"output": "0"
},
{
"input": "7 5 1\n1 1 1 2 2 2 2",
"output": "1"
},
{
"input": "5 3 1\n1 1 2 2 2",
"output": "1"
},
{
"input": "3 1 1\n2 2 2",
"output": "1"
},
{
"input": "5 2 2\n2 2 2 2 2",
"output": "1"
},
{
"input": "3 1 3\n1 1 1",
"output": "2"
},
{
"input": "5 2 1\n1 1 2 2 2",
"output": "2"
},
{
"input": "4 3 2\n2 1 1 1",
"output": "0"
},
{
"input": "4 2 1\n1 2 2 2",
"output": "1"
},
{
"input": "14 4 7\n1 1 1 2 2 2 2 2 2 2 2 2 2 2",
"output": "3"
},
{
"input": "12 10 4\n2 2 2 2 2 2 1 1 1 1 1 1",
"output": "0"
},
{
"input": "5 3 2\n2 2 1 1 1",
"output": "0"
}
] | 1,673,789,168
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 63
| 46
| 0
|
number, plates_1, plates_2 = (int(i) for i in input().split())
dishes = tuple(input().split())
total = 0
for i in dishes:
if i == '1':
if plates_1 > 0:
plates_1 -= 1
else:
total += 1
else:
if plates_2 > 0:
plates_2 -= 1
elif plates_1 > 0:
plates_1 -= 1
else:
total += 1
print(total)
|
Title: Valera and Plates
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Valera is a lazy student. He has *m* clean bowls and *k* clean plates.
Valera has made an eating plan for the next *n* days. As Valera is lazy, he will eat exactly one dish per day. At that, in order to eat a dish, he needs exactly one clean plate or bowl. We know that Valera can cook only two types of dishes. He can eat dishes of the first type from bowls and dishes of the second type from either bowls or plates.
When Valera finishes eating, he leaves a dirty plate/bowl behind. His life philosophy doesn't let him eat from dirty kitchenware. So sometimes he needs to wash his plate/bowl before eating. Find the minimum number of times Valera will need to wash a plate/bowl, if he acts optimally.
Input Specification:
The first line of the input contains three integers *n*, *m*, *k* (1<=≤<=*n*,<=*m*,<=*k*<=≤<=1000) — the number of the planned days, the number of clean bowls and the number of clean plates.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=2). If *a**i* equals one, then on day *i* Valera will eat a first type dish. If *a**i* equals two, then on day *i* Valera will eat a second type dish.
Output Specification:
Print a single integer — the minimum number of times Valera will need to wash a plate/bowl.
Demo Input:
['3 1 1\n1 2 1\n', '4 3 1\n1 1 1 1\n', '3 1 2\n2 2 2\n', '8 2 2\n1 2 1 2 1 2 1 2\n']
Demo Output:
['1\n', '1\n', '0\n', '4\n']
Note:
In the first sample Valera will wash a bowl only on the third day, so the answer is one.
In the second sample, Valera will have the first type of the dish during all four days, and since there are only three bowls, he will wash a bowl exactly once.
In the third sample, Valera will have the second type of dish for all three days, and as they can be eaten from either a plate or a bowl, he will never need to wash a plate/bowl.
|
```python
number, plates_1, plates_2 = (int(i) for i in input().split())
dishes = tuple(input().split())
total = 0
for i in dishes:
if i == '1':
if plates_1 > 0:
plates_1 -= 1
else:
total += 1
else:
if plates_2 > 0:
plates_2 -= 1
elif plates_1 > 0:
plates_1 -= 1
else:
total += 1
print(total)
```
| 3
|
|
919
|
D
|
Substring
|
PROGRAMMING
| 1,700
|
[
"dfs and similar",
"dp",
"graphs"
] | null | null |
You are given a graph with $n$ nodes and $m$ directed edges. One lowercase letter is assigned to each node. We define a path's value as the number of the most frequently occurring letter. For example, if letters on a path are "abaca", then the value of that path is $3$. Your task is find a path whose value is the largest.
|
The first line contains two positive integers $n, m$ ($1 \leq n, m \leq 300\,000$), denoting that the graph has $n$ nodes and $m$ directed edges.
The second line contains a string $s$ with only lowercase English letters. The $i$-th character is the letter assigned to the $i$-th node.
Then $m$ lines follow. Each line contains two integers $x, y$ ($1 \leq x, y \leq n$), describing a directed edge from $x$ to $y$. Note that $x$ can be equal to $y$ and there can be multiple edges between $x$ and $y$. Also the graph can be not connected.
|
Output a single line with a single integer denoting the largest value. If the value can be arbitrarily large, output -1 instead.
|
[
"5 4\nabaca\n1 2\n1 3\n3 4\n4 5\n",
"6 6\nxzyabc\n1 2\n3 1\n2 3\n5 4\n4 3\n6 4\n",
"10 14\nxzyzyzyzqx\n1 2\n2 4\n3 5\n4 5\n2 6\n6 8\n6 5\n2 10\n3 9\n10 9\n4 6\n1 10\n2 8\n3 7\n"
] |
[
"3\n",
"-1\n",
"4\n"
] |
In the first sample, the path with largest value is $1 \to 3 \to 4 \to 5$. The value is $3$ because the letter 'a' appears $3$ times.
| 1,500
|
[
{
"input": "5 4\nabaca\n1 2\n1 3\n3 4\n4 5",
"output": "3"
},
{
"input": "6 6\nxzyabc\n1 2\n3 1\n2 3\n5 4\n4 3\n6 4",
"output": "-1"
},
{
"input": "10 14\nxzyzyzyzqx\n1 2\n2 4\n3 5\n4 5\n2 6\n6 8\n6 5\n2 10\n3 9\n10 9\n4 6\n1 10\n2 8\n3 7",
"output": "4"
},
{
"input": "1 1\nf\n1 1",
"output": "-1"
},
{
"input": "10 50\nebibwbjihv\n1 10\n1 2\n5 4\n1 8\n9 7\n5 6\n1 8\n8 7\n2 6\n5 4\n1 9\n3 2\n8 3\n5 6\n5 9\n2 4\n2 7\n3 9\n1 2\n1 7\n1 10\n3 7\n1 8\n3 10\n8 6\n1 7\n10 6\n1 6\n5 8\n1 5\n2 10\n3 9\n5 8\n8 3\n3 7\n5 2\n1 10\n1 4\n5 3\n3 2\n1 2\n5 8\n10 4\n2 10\n8 2\n1 9\n1 8\n1 2\n3 4\n1 8",
"output": "2"
},
{
"input": "13 37\ndwpzcppjmhkmz\n2 6\n3 6\n6 7\n6 7\n6 7\n6 7\n6 8\n6 8\n6 8\n6 8\n4 6\n4 6\n5 6\n4 6\n4 6\n6 9\n6 9\n6 10\n6 10\n6 10\n6 10\n4 6\n1 6\n1 6\n10 11\n6 11\n1 6\n6 12\n6 12\n6 12\n6 13\n6 13\n6 13\n6 13\n3 6\n2 6\n2 6",
"output": "3"
},
{
"input": "5 8\ntetqw\n2 1\n4 4\n5 5\n5 2\n4 5\n1 5\n1 5\n1 1",
"output": "-1"
},
{
"input": "5 8\nreeet\n4 3\n2 5\n4 2\n2 4\n4 2\n5 2\n3 3\n3 4",
"output": "-1"
}
] | 1,621,602,013
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 2
| 93
| 1,228,800
|
def dfs(node):
vis[node] = True
char = {chr(i):0 for i in range(97+26)}
char[s[node-1]] += 1
for child in adj[node]:
if not vis[child]:
c = dfs(child)
for ele in c:
char[ele] += c[ele]
return char
def toposort(n,indg,adj):
q = [];res =[]
for i in range(1,n+1):
if indg[i] == 0:
q.append(i)
while q:
curr = q.pop(0)
res.append(curr)
for child in adj[curr]:
indg[child] -= 1
if indg[child] == 0:
q.append(child)
return len(res)
n,m = map(int,input().split())
s = input()
adj = {i:[] for i in range(1,n+1)}
indg = {node:0 for node in range(1,n+1)}
for edge in range(m):
u,v = map(int,input().split())
indg[v]+=1
adj[u].append(v)
## checking for cycles as answer will become infinite
#print(adj)
if toposort(n,indg,adj) != n:
print(-1)
else:
vis = [False]*(n+1);ans = -1
for node in range(1,n+1):
if not vis[node]:
c1 = dfs(node)
ans = max(ans,max(c1.values()))
print(ans)
|
Title: Substring
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a graph with $n$ nodes and $m$ directed edges. One lowercase letter is assigned to each node. We define a path's value as the number of the most frequently occurring letter. For example, if letters on a path are "abaca", then the value of that path is $3$. Your task is find a path whose value is the largest.
Input Specification:
The first line contains two positive integers $n, m$ ($1 \leq n, m \leq 300\,000$), denoting that the graph has $n$ nodes and $m$ directed edges.
The second line contains a string $s$ with only lowercase English letters. The $i$-th character is the letter assigned to the $i$-th node.
Then $m$ lines follow. Each line contains two integers $x, y$ ($1 \leq x, y \leq n$), describing a directed edge from $x$ to $y$. Note that $x$ can be equal to $y$ and there can be multiple edges between $x$ and $y$. Also the graph can be not connected.
Output Specification:
Output a single line with a single integer denoting the largest value. If the value can be arbitrarily large, output -1 instead.
Demo Input:
['5 4\nabaca\n1 2\n1 3\n3 4\n4 5\n', '6 6\nxzyabc\n1 2\n3 1\n2 3\n5 4\n4 3\n6 4\n', '10 14\nxzyzyzyzqx\n1 2\n2 4\n3 5\n4 5\n2 6\n6 8\n6 5\n2 10\n3 9\n10 9\n4 6\n1 10\n2 8\n3 7\n']
Demo Output:
['3\n', '-1\n', '4\n']
Note:
In the first sample, the path with largest value is $1 \to 3 \to 4 \to 5$. The value is $3$ because the letter 'a' appears $3$ times.
|
```python
def dfs(node):
vis[node] = True
char = {chr(i):0 for i in range(97+26)}
char[s[node-1]] += 1
for child in adj[node]:
if not vis[child]:
c = dfs(child)
for ele in c:
char[ele] += c[ele]
return char
def toposort(n,indg,adj):
q = [];res =[]
for i in range(1,n+1):
if indg[i] == 0:
q.append(i)
while q:
curr = q.pop(0)
res.append(curr)
for child in adj[curr]:
indg[child] -= 1
if indg[child] == 0:
q.append(child)
return len(res)
n,m = map(int,input().split())
s = input()
adj = {i:[] for i in range(1,n+1)}
indg = {node:0 for node in range(1,n+1)}
for edge in range(m):
u,v = map(int,input().split())
indg[v]+=1
adj[u].append(v)
## checking for cycles as answer will become infinite
#print(adj)
if toposort(n,indg,adj) != n:
print(-1)
else:
vis = [False]*(n+1);ans = -1
for node in range(1,n+1):
if not vis[node]:
c1 = dfs(node)
ans = max(ans,max(c1.values()))
print(ans)
```
| 0
|
|
13
|
A
|
Numbers
|
PROGRAMMING
| 1,000
|
[
"implementation",
"math"
] |
A. Numbers
|
1
|
64
|
Little Petya likes numbers a lot. He found that number 123 in base 16 consists of two digits: the first is 7 and the second is 11. So the sum of digits of 123 in base 16 is equal to 18.
Now he wonders what is an average value of sum of digits of the number *A* written in all bases from 2 to *A*<=-<=1.
Note that all computations should be done in base 10. You should find the result as an irreducible fraction, written in base 10.
|
Input contains one integer number *A* (3<=≤<=*A*<=≤<=1000).
|
Output should contain required average value in format «X/Y», where X is the numerator and Y is the denominator.
|
[
"5\n",
"3\n"
] |
[
"7/3\n",
"2/1\n"
] |
In the first sample number 5 written in all bases from 2 to 4 looks so: 101, 12, 11. Sums of digits are 2, 3 and 2, respectively.
| 0
|
[
{
"input": "5",
"output": "7/3"
},
{
"input": "3",
"output": "2/1"
},
{
"input": "1000",
"output": "90132/499"
},
{
"input": "927",
"output": "155449/925"
},
{
"input": "260",
"output": "6265/129"
},
{
"input": "131",
"output": "3370/129"
},
{
"input": "386",
"output": "857/12"
},
{
"input": "277",
"output": "2864/55"
},
{
"input": "766",
"output": "53217/382"
},
{
"input": "28",
"output": "85/13"
},
{
"input": "406",
"output": "7560/101"
},
{
"input": "757",
"output": "103847/755"
},
{
"input": "6",
"output": "9/4"
},
{
"input": "239",
"output": "10885/237"
},
{
"input": "322",
"output": "2399/40"
},
{
"input": "98",
"output": "317/16"
},
{
"input": "208",
"output": "4063/103"
},
{
"input": "786",
"output": "55777/392"
},
{
"input": "879",
"output": "140290/877"
},
{
"input": "702",
"output": "89217/700"
},
{
"input": "948",
"output": "7369/43"
},
{
"input": "537",
"output": "52753/535"
},
{
"input": "984",
"output": "174589/982"
},
{
"input": "934",
"output": "157951/932"
},
{
"input": "726",
"output": "95491/724"
},
{
"input": "127",
"output": "3154/125"
},
{
"input": "504",
"output": "23086/251"
},
{
"input": "125",
"output": "3080/123"
},
{
"input": "604",
"output": "33178/301"
},
{
"input": "115",
"output": "2600/113"
},
{
"input": "27",
"output": "167/25"
},
{
"input": "687",
"output": "85854/685"
},
{
"input": "880",
"output": "69915/439"
},
{
"input": "173",
"output": "640/19"
},
{
"input": "264",
"output": "6438/131"
},
{
"input": "785",
"output": "111560/783"
},
{
"input": "399",
"output": "29399/397"
},
{
"input": "514",
"output": "6031/64"
},
{
"input": "381",
"output": "26717/379"
},
{
"input": "592",
"output": "63769/590"
},
{
"input": "417",
"output": "32002/415"
},
{
"input": "588",
"output": "62723/586"
},
{
"input": "852",
"output": "131069/850"
},
{
"input": "959",
"output": "5059/29"
},
{
"input": "841",
"output": "127737/839"
},
{
"input": "733",
"output": "97598/731"
},
{
"input": "692",
"output": "87017/690"
},
{
"input": "69",
"output": "983/67"
},
{
"input": "223",
"output": "556/13"
},
{
"input": "93",
"output": "246/13"
},
{
"input": "643",
"output": "75503/641"
},
{
"input": "119",
"output": "2833/117"
},
{
"input": "498",
"output": "1459/16"
},
{
"input": "155",
"output": "4637/153"
},
{
"input": "305",
"output": "17350/303"
},
{
"input": "454",
"output": "37893/452"
},
{
"input": "88",
"output": "1529/86"
},
{
"input": "850",
"output": "32645/212"
},
{
"input": "474",
"output": "20581/236"
},
{
"input": "309",
"output": "17731/307"
},
{
"input": "762",
"output": "105083/760"
},
{
"input": "591",
"output": "63761/589"
},
{
"input": "457",
"output": "38317/455"
},
{
"input": "141",
"output": "3832/139"
},
{
"input": "385",
"output": "27232/383"
},
{
"input": "387",
"output": "27628/385"
},
{
"input": "469",
"output": "40306/467"
},
{
"input": "624",
"output": "35285/311"
},
{
"input": "330",
"output": "487/8"
},
{
"input": "31",
"output": "222/29"
},
{
"input": "975",
"output": "171679/973"
},
{
"input": "584",
"output": "62183/582"
},
{
"input": "668",
"output": "81127/666"
},
{
"input": "331",
"output": "20297/329"
},
{
"input": "189",
"output": "6789/187"
},
{
"input": "251",
"output": "11939/249"
},
{
"input": "876",
"output": "69196/437"
},
{
"input": "615",
"output": "68987/613"
},
{
"input": "451",
"output": "37258/449"
},
{
"input": "499",
"output": "45727/497"
},
{
"input": "699",
"output": "89117/697"
},
{
"input": "619",
"output": "70019/617"
},
{
"input": "413",
"output": "10515/137"
},
{
"input": "197",
"output": "7399/195"
},
{
"input": "794",
"output": "14281/99"
},
{
"input": "659",
"output": "79403/657"
},
{
"input": "653",
"output": "77695/651"
},
{
"input": "23",
"output": "45/7"
},
{
"input": "430",
"output": "16985/214"
},
{
"input": "249",
"output": "11659/247"
},
{
"input": "837",
"output": "126869/835"
},
{
"input": "258",
"output": "12373/256"
},
{
"input": "995",
"output": "59665/331"
},
{
"input": "102",
"output": "504/25"
},
{
"input": "989",
"output": "177124/987"
},
{
"input": "376",
"output": "13008/187"
},
{
"input": "657",
"output": "15715/131"
},
{
"input": "746",
"output": "50509/372"
},
{
"input": "602",
"output": "13177/120"
}
] | 1,631,927,807
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 99
| 216
| 21,401,600
|
from abc import ABCMeta
import math
A = int(input())
sum = 0
for i in range(2, A):
d = A
while (d >= i) :
sum += d%i
d //= i
sum += d
A -= 2
gcd = math.gcd(A, sum)
print(f'{sum//gcd}/{A//gcd}')
|
Title: Numbers
Time Limit: 1 seconds
Memory Limit: 64 megabytes
Problem Description:
Little Petya likes numbers a lot. He found that number 123 in base 16 consists of two digits: the first is 7 and the second is 11. So the sum of digits of 123 in base 16 is equal to 18.
Now he wonders what is an average value of sum of digits of the number *A* written in all bases from 2 to *A*<=-<=1.
Note that all computations should be done in base 10. You should find the result as an irreducible fraction, written in base 10.
Input Specification:
Input contains one integer number *A* (3<=≤<=*A*<=≤<=1000).
Output Specification:
Output should contain required average value in format «X/Y», where X is the numerator and Y is the denominator.
Demo Input:
['5\n', '3\n']
Demo Output:
['7/3\n', '2/1\n']
Note:
In the first sample number 5 written in all bases from 2 to 4 looks so: 101, 12, 11. Sums of digits are 2, 3 and 2, respectively.
|
```python
from abc import ABCMeta
import math
A = int(input())
sum = 0
for i in range(2, A):
d = A
while (d >= i) :
sum += d%i
d //= i
sum += d
A -= 2
gcd = math.gcd(A, sum)
print(f'{sum//gcd}/{A//gcd}')
```
| 3.732546
|
119
|
A
|
Epic Game
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Simon and Antisimon play a game. Initially each player receives one fixed positive integer that doesn't change throughout the game. Simon receives number *a* and Antisimon receives number *b*. They also have a heap of *n* stones. The players take turns to make a move and Simon starts. During a move a player should take from the heap the number of stones equal to the greatest common divisor of the fixed number he has received and the number of stones left in the heap. A player loses when he cannot take the required number of stones (i. e. the heap has strictly less stones left than one needs to take).
Your task is to determine by the given *a*, *b* and *n* who wins the game.
|
The only string contains space-separated integers *a*, *b* and *n* (1<=≤<=*a*,<=*b*,<=*n*<=≤<=100) — the fixed numbers Simon and Antisimon have received correspondingly and the initial number of stones in the pile.
|
If Simon wins, print "0" (without the quotes), otherwise print "1" (without the quotes).
|
[
"3 5 9\n",
"1 1 100\n"
] |
[
"0",
"1"
] |
The greatest common divisor of two non-negative integers *a* and *b* is such maximum positive integer *k*, that *a* is divisible by *k* without remainder and similarly, *b* is divisible by *k* without remainder. Let *gcd*(*a*, *b*) represent the operation of calculating the greatest common divisor of numbers *a* and *b*. Specifically, *gcd*(*x*, 0) = *gcd*(0, *x*) = *x*.
In the first sample the game will go like that:
- Simon should take *gcd*(3, 9) = 3 stones from the heap. After his move the heap has 6 stones left.- Antisimon should take *gcd*(5, 6) = 1 stone from the heap. After his move the heap has 5 stones left.- Simon should take *gcd*(3, 5) = 1 stone from the heap. After his move the heap has 4 stones left.- Antisimon should take *gcd*(5, 4) = 1 stone from the heap. After his move the heap has 3 stones left.- Simon should take *gcd*(3, 3) = 3 stones from the heap. After his move the heap has 0 stones left.- Antisimon should take *gcd*(5, 0) = 5 stones from the heap. As 0 < 5, it is impossible and Antisimon loses.
In the second sample each player during each move takes one stone from the heap. As *n* is even, Antisimon takes the last stone and Simon can't make a move after that.
| 500
|
[
{
"input": "3 5 9",
"output": "0"
},
{
"input": "1 1 100",
"output": "1"
},
{
"input": "23 12 16",
"output": "1"
},
{
"input": "95 26 29",
"output": "1"
},
{
"input": "73 32 99",
"output": "1"
},
{
"input": "1 1 1",
"output": "0"
},
{
"input": "41 12 65",
"output": "1"
},
{
"input": "13 61 100",
"output": "1"
},
{
"input": "100 100 10",
"output": "0"
},
{
"input": "12 24 26",
"output": "1"
},
{
"input": "73 21 96",
"output": "1"
},
{
"input": "17 22 81",
"output": "1"
},
{
"input": "14 88 97",
"output": "1"
},
{
"input": "42 81 17",
"output": "0"
},
{
"input": "34 36 19",
"output": "1"
},
{
"input": "21 87 12",
"output": "1"
},
{
"input": "97 92 98",
"output": "1"
},
{
"input": "49 25 62",
"output": "1"
},
{
"input": "29 17 44",
"output": "1"
},
{
"input": "10 1 10",
"output": "0"
},
{
"input": "99 98 100",
"output": "1"
},
{
"input": "100 100 1",
"output": "0"
},
{
"input": "11 99 55",
"output": "0"
},
{
"input": "8 13 21",
"output": "0"
},
{
"input": "34 55 89",
"output": "0"
},
{
"input": "21 34 55",
"output": "1"
},
{
"input": "13 21 34",
"output": "1"
},
{
"input": "34 21 55",
"output": "0"
},
{
"input": "10 20 84",
"output": "1"
},
{
"input": "4 2 5",
"output": "0"
},
{
"input": "3 2 3",
"output": "0"
},
{
"input": "31 23 1",
"output": "0"
},
{
"input": "100 100 100",
"output": "0"
},
{
"input": "100 1 100",
"output": "0"
},
{
"input": "1 100 100",
"output": "1"
},
{
"input": "1 1 100",
"output": "1"
},
{
"input": "17 23 100",
"output": "1"
},
{
"input": "99 98 100",
"output": "1"
},
{
"input": "1 1 2",
"output": "1"
},
{
"input": "2 1 1",
"output": "0"
},
{
"input": "1 2 1",
"output": "0"
},
{
"input": "2 1 2",
"output": "0"
},
{
"input": "10 10 3",
"output": "1"
},
{
"input": "2 2 1",
"output": "0"
},
{
"input": "9 5 1",
"output": "0"
}
] | 1,674,723,734
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 45
| 92
| 0
|
from math import gcd
a, b, n = map(int, input().split())
ans = 1
while n > 0:
ans = (ans + 1) % 2
if ans:
n -= gcd(n, b)
else:
n -= gcd(n, a)
print(ans)
|
Title: Epic Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Simon and Antisimon play a game. Initially each player receives one fixed positive integer that doesn't change throughout the game. Simon receives number *a* and Antisimon receives number *b*. They also have a heap of *n* stones. The players take turns to make a move and Simon starts. During a move a player should take from the heap the number of stones equal to the greatest common divisor of the fixed number he has received and the number of stones left in the heap. A player loses when he cannot take the required number of stones (i. e. the heap has strictly less stones left than one needs to take).
Your task is to determine by the given *a*, *b* and *n* who wins the game.
Input Specification:
The only string contains space-separated integers *a*, *b* and *n* (1<=≤<=*a*,<=*b*,<=*n*<=≤<=100) — the fixed numbers Simon and Antisimon have received correspondingly and the initial number of stones in the pile.
Output Specification:
If Simon wins, print "0" (without the quotes), otherwise print "1" (without the quotes).
Demo Input:
['3 5 9\n', '1 1 100\n']
Demo Output:
['0', '1']
Note:
The greatest common divisor of two non-negative integers *a* and *b* is such maximum positive integer *k*, that *a* is divisible by *k* without remainder and similarly, *b* is divisible by *k* without remainder. Let *gcd*(*a*, *b*) represent the operation of calculating the greatest common divisor of numbers *a* and *b*. Specifically, *gcd*(*x*, 0) = *gcd*(0, *x*) = *x*.
In the first sample the game will go like that:
- Simon should take *gcd*(3, 9) = 3 stones from the heap. After his move the heap has 6 stones left.- Antisimon should take *gcd*(5, 6) = 1 stone from the heap. After his move the heap has 5 stones left.- Simon should take *gcd*(3, 5) = 1 stone from the heap. After his move the heap has 4 stones left.- Antisimon should take *gcd*(5, 4) = 1 stone from the heap. After his move the heap has 3 stones left.- Simon should take *gcd*(3, 3) = 3 stones from the heap. After his move the heap has 0 stones left.- Antisimon should take *gcd*(5, 0) = 5 stones from the heap. As 0 < 5, it is impossible and Antisimon loses.
In the second sample each player during each move takes one stone from the heap. As *n* is even, Antisimon takes the last stone and Simon can't make a move after that.
|
```python
from math import gcd
a, b, n = map(int, input().split())
ans = 1
while n > 0:
ans = (ans + 1) % 2
if ans:
n -= gcd(n, b)
else:
n -= gcd(n, a)
print(ans)
```
| 3
|
|
501
|
A
|
Contest
|
PROGRAMMING
| 900
|
[
"implementation"
] | null | null |
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs *a* points and Vasya solved the problem that costs *b* points. Besides, Misha submitted the problem *c* minutes after the contest started and Vasya submitted the problem *d* minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs *p* points *t* minutes after the contest started, you get points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
|
The first line contains four integers *a*, *b*, *c*, *d* (250<=≤<=*a*,<=*b*<=≤<=3500, 0<=≤<=*c*,<=*d*<=≤<=180).
It is guaranteed that numbers *a* and *b* are divisible by 250 (just like on any real Codeforces round).
|
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
|
[
"500 1000 20 30\n",
"1000 1000 1 1\n",
"1500 1000 176 177\n"
] |
[
"Vasya\n",
"Tie\n",
"Misha\n"
] |
none
| 500
|
[
{
"input": "500 1000 20 30",
"output": "Vasya"
},
{
"input": "1000 1000 1 1",
"output": "Tie"
},
{
"input": "1500 1000 176 177",
"output": "Misha"
},
{
"input": "1500 1000 74 177",
"output": "Misha"
},
{
"input": "750 2500 175 178",
"output": "Vasya"
},
{
"input": "750 1000 54 103",
"output": "Tie"
},
{
"input": "2000 1250 176 130",
"output": "Tie"
},
{
"input": "1250 1750 145 179",
"output": "Tie"
},
{
"input": "2000 2000 176 179",
"output": "Tie"
},
{
"input": "1500 1500 148 148",
"output": "Tie"
},
{
"input": "2750 1750 134 147",
"output": "Misha"
},
{
"input": "3250 250 175 173",
"output": "Misha"
},
{
"input": "500 500 170 176",
"output": "Misha"
},
{
"input": "250 1000 179 178",
"output": "Vasya"
},
{
"input": "3250 1000 160 138",
"output": "Misha"
},
{
"input": "3000 2000 162 118",
"output": "Tie"
},
{
"input": "1500 1250 180 160",
"output": "Tie"
},
{
"input": "1250 2500 100 176",
"output": "Tie"
},
{
"input": "3500 3500 177 178",
"output": "Tie"
},
{
"input": "3000 3250 16 34",
"output": "Tie"
},
{
"input": "1750 3000 137 49",
"output": "Vasya"
},
{
"input": "500 1500 179 71",
"output": "Vasya"
},
{
"input": "1250 2000 101 180",
"output": "Misha"
},
{
"input": "250 750 180 176",
"output": "Vasya"
},
{
"input": "2250 2250 163 145",
"output": "Vasya"
},
{
"input": "3000 3000 176 78",
"output": "Vasya"
},
{
"input": "250 3500 8 178",
"output": "Vasya"
},
{
"input": "1750 1250 179 180",
"output": "Misha"
},
{
"input": "2750 1750 13 164",
"output": "Misha"
},
{
"input": "1750 2250 178 53",
"output": "Vasya"
},
{
"input": "2500 2750 73 179",
"output": "Misha"
},
{
"input": "1000 3500 178 175",
"output": "Vasya"
},
{
"input": "1000 500 7 162",
"output": "Misha"
},
{
"input": "1000 250 175 48",
"output": "Misha"
},
{
"input": "1750 500 166 177",
"output": "Misha"
},
{
"input": "250 250 0 0",
"output": "Tie"
},
{
"input": "250 3500 0 0",
"output": "Vasya"
},
{
"input": "250 3500 0 180",
"output": "Vasya"
},
{
"input": "3500 3500 180 180",
"output": "Tie"
},
{
"input": "3500 250 0 180",
"output": "Misha"
}
] | 1,511,522,255
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 46
| 0
|
a,b,c,d=map(int,input().split())
max1=max((3*c)/10,(c-(c/250)*a))
max2=max((3*d)/10,(d-(d/250)*b))
if max1>max2:
print('Misha')
elif max1<max2:
print('Vasya')
else:
print('Tie')
|
Title: Contest
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs *a* points and Vasya solved the problem that costs *b* points. Besides, Misha submitted the problem *c* minutes after the contest started and Vasya submitted the problem *d* minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs *p* points *t* minutes after the contest started, you get points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input Specification:
The first line contains four integers *a*, *b*, *c*, *d* (250<=≤<=*a*,<=*b*<=≤<=3500, 0<=≤<=*c*,<=*d*<=≤<=180).
It is guaranteed that numbers *a* and *b* are divisible by 250 (just like on any real Codeforces round).
Output Specification:
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Demo Input:
['500 1000 20 30\n', '1000 1000 1 1\n', '1500 1000 176 177\n']
Demo Output:
['Vasya\n', 'Tie\n', 'Misha\n']
Note:
none
|
```python
a,b,c,d=map(int,input().split())
max1=max((3*c)/10,(c-(c/250)*a))
max2=max((3*d)/10,(d-(d/250)*b))
if max1>max2:
print('Misha')
elif max1<max2:
print('Vasya')
else:
print('Tie')
```
| 0
|
|
513
|
G3
|
Inversions problem
|
PROGRAMMING
| 3,100
|
[
"dp"
] | null | null |
You are given a permutation of *n* numbers *p*1,<=*p*2,<=...,<=*p**n*. We perform *k* operations of the following type: choose uniformly at random two indices *l* and *r* (*l*<=≤<=*r*) and reverse the order of the elements *p**l*,<=*p**l*<=+<=1,<=...,<=*p**r*. Your task is to find the expected value of the number of inversions in the resulting permutation.
|
The first line of input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=109). The next line contains *n* integers *p*1,<=*p*2,<=...,<=*p**n* — the given permutation. All *p**i* are different and in range from 1 to *n*.
The problem consists of three 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 G1 (3 points), the constraints 1<=≤<=*n*<=≤<=6, 1<=≤<=*k*<=≤<=4 will hold. - In subproblem G2 (5 points), the constraints 1<=≤<=*n*<=≤<=30, 1<=≤<=*k*<=≤<=200 will hold. - In subproblem G3 (16 points), the constraints 1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=109 will hold.
|
Output the answer with absolute or relative error no more than 1*e*<=-<=9.
|
[
"3 1\n1 2 3\n",
"3 4\n1 3 2\n"
] |
[
"0.833333333333333\n",
"1.458333333333334\n"
] |
Consider the first sample test. We will randomly pick an interval of the permutation (1, 2, 3) (which has no inversions) and reverse the order of its elements. With probability <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/eb946338365d9781f7d2e9ec692c26702d0ae3a7.png" style="max-width: 100.0%;max-height: 100.0%;"/>, the interval will consist of a single element and the permutation will not be altered. With probability <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a063853bdfd761520e06382373fe270b6078994b.png" style="max-width: 100.0%;max-height: 100.0%;"/> we will inverse the first two elements' order and obtain the permutation (2, 1, 3) which has one inversion. With the same probability we might pick the interval consisting of the last two elements which will lead to the permutation (1, 3, 2) with one inversion. Finally, with probability <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a063853bdfd761520e06382373fe270b6078994b.png" style="max-width: 100.0%;max-height: 100.0%;"/> the randomly picked interval will contain all elements, leading to the permutation (3, 2, 1) with 3 inversions. Hence, the expected number of inversions is equal to <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/cc9273ddc69be58e22251bdf070c83670617a9a2.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
| 16
|
[
{
"input": "3 1\n1 2 3",
"output": "0.833333333333333"
},
{
"input": "3 4\n1 3 2",
"output": "1.458333333333334"
},
{
"input": "6 1\n4 2 5 1 3 6",
"output": "6.380952380952381"
},
{
"input": "6 2\n1 4 6 5 2 3",
"output": "6.954648526077097"
},
{
"input": "4 4\n2 3 1 4",
"output": "2.818400000000000"
},
{
"input": "4 1\n3 4 2 1",
"output": "4.100000000000000"
},
{
"input": "4 3\n3 1 2 4",
"output": "2.824000000000000"
},
{
"input": "4 4\n4 2 3 1",
"output": "3.285600000000000"
},
{
"input": "4 1\n1 2 4 3",
"output": "1.900000000000000"
},
{
"input": "5 4\n4 3 2 5 1",
"output": "5.435950617283950"
},
{
"input": "5 2\n3 1 2 5 4",
"output": "4.342222222222222"
},
{
"input": "5 1\n3 5 1 2 4",
"output": "5.066666666666666"
},
{
"input": "6 1\n5 2 3 4 1 6",
"output": "7.285714285714286"
},
{
"input": "5 2\n4 3 2 1 5",
"output": "4.862222222222222"
},
{
"input": "6 1\n5 3 4 6 2 1",
"output": "10.142857142857142"
},
{
"input": "6 4\n1 2 3 4 5 6",
"output": "6.280675233056186"
},
{
"input": "6 4\n6 5 4 3 2 1",
"output": "8.719324766943814"
},
{
"input": "1 1\n1",
"output": "0.000000000000000"
},
{
"input": "1 4\n1",
"output": "0.000000000000000"
},
{
"input": "2 4\n1 2",
"output": "0.493827160493827"
},
{
"input": "2 4\n2 1",
"output": "0.506172839506173"
},
{
"input": "3 4\n1 2 3",
"output": "1.416666666666667"
},
{
"input": "29 124\n25 17 19 13 18 10 4 15 27 26 23 12 3 7 29 9 22 6 5 20 24 28 11 14 8 16 2 1 21",
"output": "203.000744214151180"
},
{
"input": "29 121\n1 25 15 18 29 26 3 9 16 8 7 5 12 11 24 28 10 13 27 14 21 17 22 20 6 23 19 4 2",
"output": "202.999772441209390"
},
{
"input": "30 136\n1 29 20 25 15 2 3 16 24 30 17 14 7 10 11 22 6 8 23 18 12 5 19 9 26 21 28 13 27 4",
"output": "217.499666343988110"
},
{
"input": "30 153\n18 5 24 7 12 6 25 14 21 20 27 4 30 8 23 19 11 13 17 1 29 28 15 22 16 9 2 10 26 3",
"output": "217.500536909325260"
},
{
"input": "29 118\n2 15 14 28 8 16 5 25 12 11 23 13 22 26 21 7 20 18 29 4 27 19 6 9 3 10 24 17 1",
"output": "203.000281073131700"
},
{
"input": "30 189\n11 10 2 27 30 7 23 29 25 26 5 15 19 13 28 4 18 1 21 9 3 22 6 14 12 8 20 24 17 16",
"output": "217.499983777789450"
},
{
"input": "30 59\n7 12 26 21 9 29 15 14 28 19 20 25 27 2 18 30 5 24 10 23 16 1 3 8 22 6 17 13 4 11",
"output": "217.427219047091630"
},
{
"input": "28 64\n17 12 16 11 1 6 19 21 15 10 8 27 25 18 23 2 14 20 13 28 22 5 7 3 26 9 24 4",
"output": "189.128262226032550"
},
{
"input": "29 137\n1 11 25 3 27 29 18 9 8 20 4 13 15 28 14 17 23 21 22 7 12 10 5 2 19 16 6 26 24",
"output": "202.998255996069960"
},
{
"input": "29 139\n19 10 21 29 8 18 22 15 26 6 4 17 23 27 14 2 20 5 3 13 7 12 16 24 28 9 1 11 25",
"output": "202.999603697519690"
},
{
"input": "29 140\n2 9 26 20 25 4 21 5 23 15 12 16 10 1 13 22 19 24 28 14 11 29 8 27 18 3 7 6 17",
"output": "202.999075312274670"
},
{
"input": "29 142\n5 28 18 22 23 6 27 25 13 10 20 24 14 11 7 4 19 3 9 29 12 17 15 26 2 21 8 1 16",
"output": "202.999409366418920"
},
{
"input": "30 187\n4 18 2 8 5 9 15 14 25 16 30 12 7 24 13 27 29 26 6 3 20 1 10 28 17 21 22 19 23 11",
"output": "217.499974048363410"
},
{
"input": "29 137\n21 15 22 14 20 7 29 24 16 25 19 5 23 26 3 1 10 11 8 2 18 4 17 6 9 27 12 13 28",
"output": "202.999469255107530"
},
{
"input": "30 71\n17 28 11 29 12 8 26 19 23 3 1 5 25 6 13 10 18 7 16 14 4 20 9 30 22 21 2 24 15 27",
"output": "217.416011546137580"
},
{
"input": "90 371\n61 9 64 71 89 17 53 50 12 54 21 55 75 25 3 63 86 34 14 31 81 74 29 32 68 8 40 56 1 73 82 10 27 42 87 16 20 58 46 36 60 6 43 84 4 22 72 51 57 59 49 83 70 2 79 44 19 45 37 77 7 62 76 26 5 41 65 15 47 33 13 78 66 39 67 85 23 30 28 52 35 48 24 90 18 11 80 69 88 38",
"output": "2002.505967958907800"
},
{
"input": "90 448\n23 45 51 14 89 32 33 75 61 49 17 52 55 80 36 59 27 79 41 88 5 34 28 37 83 39 8 60 70 66 56 85 3 63 2 24 26 78 73 31 1 9 48 35 13 82 54 71 64 62 7 65 57 87 47 4 69 30 38 90 15 43 42 72 40 25 50 67 58 18 21 86 20 77 11 29 16 53 12 10 76 6 68 81 74 22 46 84 19 44",
"output": "2002.499014807391600"
},
{
"input": "96 1803\n21 96 78 94 16 9 60 95 51 72 77 4 54 23 17 10 56 70 61 49 22 48 35 1 37 80 65 8 85 64 42 12 68 81 90 31 67 53 46 5 62 74 41 3 50 47 11 13 32 92 24 71 30 76 55 28 52 34 57 6 82 93 29 73 38 39 40 7 45 26 33 69 14 87 36 18 15 75 2 84 83 58 25 27 66 91 19 79 44 88 63 86 59 89 43 20",
"output": "2280.000000000000000"
},
{
"input": "98 1164\n1 12 77 41 45 25 46 66 47 62 58 53 17 10 23 98 50 67 27 80 29 4 60 42 59 21 88 85 87 28 54 64 83 9 96 6 63 14 55 15 18 76 37 97 73 5 26 69 71 51 7 35 33 11 89 84 78 72 20 40 3 8 44 39 2 70 19 52 68 81 79 24 56 43 13 38 65 92 95 34 31 16 74 75 48 86 93 91 49 30 57 94 36 32 22 90 61 82",
"output": "2376.499999996136500"
},
{
"input": "100 83\n6 98 18 72 51 83 66 40 32 60 90 53 91 10 92 47 94 1 77 8 19 78 9 52 85 2 26 12 97 100 82 84 46 79 38 39 50 35 55 99 37 88 74 4 20 23 43 11 87 59 75 61 71 73 34 86 21 17 44 62 42 95 30 54 5 25 64 81 58 65 7 3 45 70 76 24 89 28 80 41 14 31 49 56 22 63 68 13 29 33 67 96 27 36 15 57 16 93 48 69",
"output": "2464.472192612607200"
},
{
"input": "93 1628\n52 81 47 48 50 10 66 29 63 25 80 93 46 44 7 59 16 14 65 30 72 45 85 26 67 71 55 91 20 1 70 24 77 86 56 28 8 32 39 19 43 31 53 17 92 37 4 6 68 36 62 79 84 40 9 23 58 64 49 61 15 11 83 60 57 78 3 87 38 75 12 34 2 27 13 90 76 35 74 88 18 42 73 69 41 21 22 51 54 89 5 82 33",
"output": "2139.000000000000000"
},
{
"input": "93 1974\n6 35 78 39 10 69 88 70 7 40 86 38 16 90 79 81 34 58 42 8 56 93 5 13 63 24 55 2 84 71 45 43 31 44 17 83 67 72 46 64 59 51 29 91 12 22 77 11 28 14 9 30 21 54 49 3 68 18 65 82 57 74 85 62 75 32 76 15 66 80 52 19 41 92 89 60 33 23 73 1 48 47 4 36 50 25 87 61 20 37 26 27 53",
"output": "2138.999999999999500"
},
{
"input": "97 757\n45 80 71 41 96 66 52 56 83 35 57 92 26 95 61 13 42 14 87 32 64 38 73 76 22 25 7 21 93 81 62 79 65 44 40 54 24 58 5 28 9 49 63 50 2 88 3 47 51 67 36 39 34 18 43 72 30 68 10 91 55 11 33 53 8 17 70 23 4 48 59 74 12 82 94 60 29 15 90 20 97 6 75 31 77 19 46 78 86 27 85 16 69 89 1 84 37",
"output": "2328.000001317569500"
},
{
"input": "99 1846\n94 64 22 75 66 26 82 48 20 65 69 13 21 50 57 33 42 4 62 40 12 91 17 99 61 19 14 59 5 3 47 98 25 41 28 52 24 23 93 1 92 34 70 39 81 7 37 73 15 30 49 35 86 32 90 38 58 85 63 74 96 80 31 54 83 97 9 55 60 16 11 8 6 89 79 77 68 18 51 67 44 71 45 36 76 53 46 78 56 10 29 43 87 72 95 88 84 27 2",
"output": "2425.500000000000500"
},
{
"input": "92 1646\n3 84 7 57 66 19 67 24 11 62 29 35 85 49 42 76 25 72 48 17 34 82 54 43 30 78 22 36 14 90 21 70 69 8 27 1 40 91 83 20 6 33 81 13 15 31 64 46 39 65 71 5 50 59 32 41 73 87 68 37 28 51 52 38 60 4 23 56 61 74 92 58 80 89 75 88 63 10 77 12 9 2 18 26 79 44 45 55 53 86 47 16",
"output": "2093.000000000000000"
},
{
"input": "92 1293\n15 50 55 21 54 90 44 92 73 38 85 83 42 6 41 51 39 75 67 59 26 40 8 2 49 65 88 64 13 14 63 5 4 33 1 82 58 60 34 27 61 52 35 46 22 43 9 32 76 24 36 18 91 12 79 69 16 81 19 10 62 84 53 20 28 30 68 17 56 78 23 3 89 66 25 47 87 29 71 48 31 72 7 11 37 57 45 77 70 74 80 86",
"output": "2092.999999999956300"
},
{
"input": "92 1484\n65 14 55 41 7 66 78 85 87 53 20 42 32 75 74 13 60 73 52 28 50 51 12 46 54 8 29 24 2 26 67 5 47 90 34 45 38 92 1 77 36 88 56 40 59 15 63 10 61 25 82 62 57 17 31 58 39 48 71 30 16 4 43 86 80 3 70 83 91 68 27 89 79 6 35 44 49 76 33 19 64 23 11 18 21 22 69 37 81 9 72 84",
"output": "2092.999999999999500"
},
{
"input": "98 999999637\n19 49 28 60 81 97 48 5 90 94 59 10 39 27 72 43 15 58 47 3 6 25 20 21 74 67 92 87 2 95 96 75 22 41 12 79 36 35 50 65 86 26 73 80 54 56 33 52 85 78 37 13 23 64 46 77 88 34 84 55 57 98 63 32 62 8 82 68 40 45 69 89 11 93 71 53 9 17 4 70 66 18 76 14 91 83 51 61 7 38 1 44 31 42 24 29 16 30",
"output": "2376.500000000000000"
},
{
"input": "92 999999561\n56 32 42 92 6 38 67 73 90 58 17 50 19 35 11 74 65 51 23 60 82 70 68 61 81 52 39 13 76 69 26 16 3 25 36 53 37 80 45 43 4 21 57 12 10 15 85 77 88 66 46 63 5 59 78 89 64 2 28 14 7 75 18 22 40 34 29 27 41 8 55 79 83 44 84 71 86 48 87 1 54 49 24 20 72 47 91 33 31 62 30 9",
"output": "2093.000000000000500"
},
{
"input": "92 999999856\n37 45 52 56 63 9 60 28 30 79 84 91 25 11 53 44 38 18 67 59 35 36 68 51 10 74 2 4 14 55 57 61 92 32 26 47 82 64 12 81 48 7 39 46 85 54 86 13 66 80 31 69 3 34 89 65 75 16 1 22 49 77 27 88 72 20 41 8 42 78 21 29 71 90 50 62 76 15 19 43 24 58 33 70 40 83 6 5 23 17 87 73",
"output": "2092.999999999999500"
},
{
"input": "96 999999657\n75 37 8 51 69 71 19 41 1 36 2 54 21 53 88 26 96 46 64 83 15 63 68 93 86 72 9 91 80 55 87 67 65 39 78 74 28 11 17 61 73 85 94 3 59 45 60 24 66 90 48 79 43 81 89 58 70 49 5 56 12 42 92 40 20 29 52 47 95 7 84 22 13 44 50 77 30 57 4 6 34 62 76 38 10 14 27 31 32 82 35 16 33 25 23 18",
"output": "2280.000000000000500"
},
{
"input": "96 999999966\n30 86 3 40 2 4 65 15 52 71 59 44 77 13 18 48 25 58 50 29 17 24 57 68 33 45 67 12 10 88 19 38 27 93 9 21 16 41 43 63 80 22 72 91 5 74 84 66 47 87 26 95 32 89 37 36 69 55 20 56 54 94 42 64 82 73 8 81 35 79 75 1 96 70 51 83 28 90 53 62 7 31 85 11 34 6 14 23 76 78 46 92 60 39 49 61",
"output": "2280.000000000000000"
},
{
"input": "91 567\n21 73 6 19 38 91 27 28 1 69 76 34 22 75 78 51 47 55 49 23 60 43 70 46 53 13 57 48 77 62 15 68 79 30 45 56 59 52 67 42 35 31 36 9 88 33 65 66 83 14 24 26 90 71 25 74 32 17 58 5 72 41 61 4 3 86 81 84 87 16 18 8 39 63 54 11 40 2 44 85 82 50 37 12 20 10 29 64 80 89 7",
"output": "2047.500053595948200"
},
{
"input": "91 963\n87 11 61 47 43 72 29 50 63 75 70 82 20 40 52 34 27 28 55 18 91 19 83 65 35 64 73 2 90 23 38 80 69 14 54 1 33 42 26 48 25 77 15 86 76 13 66 12 37 79 67 30 89 49 41 58 17 71 78 60 59 31 32 4 74 46 5 44 68 24 51 7 8 53 36 39 6 85 10 57 81 16 56 88 3 84 22 45 9 21 62",
"output": "2047.500000015885500"
},
{
"input": "95 613\n74 19 53 95 75 55 64 41 62 4 88 34 87 79 81 2 58 12 13 84 86 25 72 78 18 94 63 82 51 46 43 11 85 31 27 73 91 26 35 22 1 37 40 80 49 29 66 9 92 30 20 89 6 8 69 77 38 70 93 21 47 71 76 45 33 60 65 36 10 54 44 32 42 28 24 67 50 23 83 52 15 59 17 57 68 16 3 61 5 48 39 14 7 56 90",
"output": "2232.499960678047000"
},
{
"input": "95 949\n39 15 5 46 32 30 55 69 34 18 74 56 2 43 14 48 21 19 61 76 36 22 28 80 27 13 24 35 81 38 85 87 25 53 71 58 54 41 78 65 82 33 26 63 94 66 70 52 88 31 89 83 91 37 49 8 29 6 4 51 73 62 17 45 1 50 3 9 93 90 60 68 16 10 57 7 40 92 12 75 84 95 64 44 86 79 11 20 42 77 59 23 67 47 72",
"output": "2232.499999931316800"
},
{
"input": "97 953\n40 7 3 96 47 28 90 97 77 2 9 57 34 65 59 92 84 16 75 23 74 18 70 4 83 31 61 85 33 46 22 14 64 53 80 26 1 32 5 71 51 68 81 43 25 66 44 17 55 37 89 45 29 76 86 58 82 72 56 69 11 24 20 94 60 41 13 95 91 73 8 19 79 67 38 39 93 54 21 35 12 15 52 49 48 30 62 42 87 6 63 50 36 88 10 78 27",
"output": "2328.000000037624900"
},
{
"input": "90 630\n60 56 72 10 21 73 14 39 74 46 29 79 71 64 80 57 37 40 41 7 6 77 1 22 58 25 4 33 17 35 43 86 67 12 28 30 61 75 48 62 24 81 42 8 66 11 78 47 45 89 38 32 9 65 49 52 23 3 54 2 27 59 19 15 31 36 50 16 85 87 69 82 90 34 18 70 84 51 88 63 68 83 26 5 53 20 13 76 55 44",
"output": "2002.500013149054700"
},
{
"input": "91 870\n61 63 49 54 14 50 2 80 71 62 69 43 48 13 77 21 64 9 11 26 1 74 31 85 37 82 38 59 30 65 22 33 55 87 89 20 51 6 44 53 35 36 57 29 28 42 79 24 15 10 3 72 84 16 52 12 68 23 5 73 86 27 4 67 56 46 75 41 40 58 88 19 90 39 60 25 76 81 18 32 66 7 45 34 78 47 91 17 8 70 83",
"output": "2047.499999892056400"
},
{
"input": "91 519\n33 13 16 60 65 8 83 1 67 52 81 91 71 31 44 56 18 63 21 80 55 2 32 66 50 39 20 77 84 11 14 74 6 89 47 58 70 86 53 19 37 82 51 38 12 41 57 90 76 48 45 30 23 87 17 9 34 29 26 46 62 64 25 85 68 54 78 28 72 22 49 24 36 15 73 59 40 61 75 27 79 5 35 7 4 88 42 43 69 10 3",
"output": "2047.500329839691200"
},
{
"input": "95 641\n24 16 56 21 37 84 45 1 29 14 34 2 40 35 72 86 61 53 25 73 67 18 66 90 81 70 91 79 26 46 5 78 89 41 36 93 88 17 52 92 74 30 64 77 50 65 42 32 94 20 57 62 39 31 82 69 71 43 44 15 6 85 83 47 9 68 76 51 27 38 8 59 87 11 54 55 60 19 22 80 10 58 3 75 12 28 7 48 33 49 95 13 63 4 23",
"output": "2232.500001363028300"
},
{
"input": "95 702\n48 75 22 43 87 56 34 8 35 69 80 11 50 17 52 16 58 1 42 25 65 55 66 81 18 84 54 31 74 26 60 72 89 3 44 83 9 40 49 62 59 32 10 93 73 28 6 78 23 13 47 88 63 29 39 37 20 77 85 21 19 71 5 12 15 68 27 94 46 92 82 24 38 95 70 64 53 33 30 91 76 57 4 61 36 2 14 45 90 67 86 79 7 41 51",
"output": "2232.499998867935100"
},
{
"input": "90 538\n49 84 5 82 64 63 59 9 79 83 44 41 78 21 85 35 10 60 42 75 28 66 40 87 39 25 90 14 62 43 17 89 50 27 51 61 47 81 74 19 30 1 4 57 67 34 54 56 53 72 8 36 32 73 3 22 86 76 12 65 70 18 2 15 23 71 88 26 7 58 80 77 24 38 31 46 20 48 55 37 29 11 13 33 16 52 45 68 69 6",
"output": "2002.500273005500500"
},
{
"input": "90 687\n22 90 80 41 4 73 68 77 20 55 49 85 8 69 30 76 42 88 21 62 52 66 47 63 25 2 53 39 54 12 89 59 45 15 86 6 70 29 71 40 51 26 87 61 3 14 37 13 74 64 79 27 81 23 58 78 67 46 57 24 35 7 84 10 16 83 72 34 38 65 1 60 17 44 32 75 5 28 56 33 19 11 9 48 43 36 31 82 18 50",
"output": "2002.499993516592700"
}
] | 1,512,119,586
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS3
| 66
| 1,512
| 32,870,400
|
f = lambda: map(int, input().split())
n, k = f()
p = list(f())
r = range
u = [l * l + l >> 1 for l in r(n + 1)]
v = [(i, j) for i in r(n) for j in r(i + 1, n)]
t = [[p[i] > p[j] for j in r(n)] for i in r(n)]
a = [[0] * n for i in r(n)]
b = [[0] * n for i in r(n)]
c = [[0] * n for i in r(n)]
for l in r(min(k, 1000)):
for j in r(1, n):
s, x = 0, a[j]
for i in r(j):
s += t[i][j]
x[i + 1] = x[i] + s
for i in r(n):
s, y = 0, b[i]
for j in r(n - 1, i, -1):
s += t[i][j]
y[j - 1] = y[j] + s
for d in r(1, n):
s, z = 0, c[d]
for i in r(n - d):
s += t[i][i + d]
z[i + 1] = z[i] + s
for i, j in v:
d = j - i
x, y, z = a[j], b[i], c[d]
s = t[i][j] * (u[i] + u[d - 1] + u[n - j - 1])
s += x[j] - x[i] - x[d - 1]
s += y[i] - y[j] - y[n - d]
s += (i + 1) * (n - j) - z[n - d] + z[n - j - 1] + z[i]
t[i][j] = s / u[n]
print(sum(t[i][j] for i, j in v))
|
Title: Inversions problem
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a permutation of *n* numbers *p*1,<=*p*2,<=...,<=*p**n*. We perform *k* operations of the following type: choose uniformly at random two indices *l* and *r* (*l*<=≤<=*r*) and reverse the order of the elements *p**l*,<=*p**l*<=+<=1,<=...,<=*p**r*. Your task is to find the expected value of the number of inversions in the resulting permutation.
Input Specification:
The first line of input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=109). The next line contains *n* integers *p*1,<=*p*2,<=...,<=*p**n* — the given permutation. All *p**i* are different and in range from 1 to *n*.
The problem consists of three 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 G1 (3 points), the constraints 1<=≤<=*n*<=≤<=6, 1<=≤<=*k*<=≤<=4 will hold. - In subproblem G2 (5 points), the constraints 1<=≤<=*n*<=≤<=30, 1<=≤<=*k*<=≤<=200 will hold. - In subproblem G3 (16 points), the constraints 1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=109 will hold.
Output Specification:
Output the answer with absolute or relative error no more than 1*e*<=-<=9.
Demo Input:
['3 1\n1 2 3\n', '3 4\n1 3 2\n']
Demo Output:
['0.833333333333333\n', '1.458333333333334\n']
Note:
Consider the first sample test. We will randomly pick an interval of the permutation (1, 2, 3) (which has no inversions) and reverse the order of its elements. With probability <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/eb946338365d9781f7d2e9ec692c26702d0ae3a7.png" style="max-width: 100.0%;max-height: 100.0%;"/>, the interval will consist of a single element and the permutation will not be altered. With probability <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a063853bdfd761520e06382373fe270b6078994b.png" style="max-width: 100.0%;max-height: 100.0%;"/> we will inverse the first two elements' order and obtain the permutation (2, 1, 3) which has one inversion. With the same probability we might pick the interval consisting of the last two elements which will lead to the permutation (1, 3, 2) with one inversion. Finally, with probability <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a063853bdfd761520e06382373fe270b6078994b.png" style="max-width: 100.0%;max-height: 100.0%;"/> the randomly picked interval will contain all elements, leading to the permutation (3, 2, 1) with 3 inversions. Hence, the expected number of inversions is equal to <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/cc9273ddc69be58e22251bdf070c83670617a9a2.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
|
```python
f = lambda: map(int, input().split())
n, k = f()
p = list(f())
r = range
u = [l * l + l >> 1 for l in r(n + 1)]
v = [(i, j) for i in r(n) for j in r(i + 1, n)]
t = [[p[i] > p[j] for j in r(n)] for i in r(n)]
a = [[0] * n for i in r(n)]
b = [[0] * n for i in r(n)]
c = [[0] * n for i in r(n)]
for l in r(min(k, 1000)):
for j in r(1, n):
s, x = 0, a[j]
for i in r(j):
s += t[i][j]
x[i + 1] = x[i] + s
for i in r(n):
s, y = 0, b[i]
for j in r(n - 1, i, -1):
s += t[i][j]
y[j - 1] = y[j] + s
for d in r(1, n):
s, z = 0, c[d]
for i in r(n - d):
s += t[i][i + d]
z[i + 1] = z[i] + s
for i, j in v:
d = j - i
x, y, z = a[j], b[i], c[d]
s = t[i][j] * (u[i] + u[d - 1] + u[n - j - 1])
s += x[j] - x[i] - x[d - 1]
s += y[i] - y[j] - y[n - d]
s += (i + 1) * (n - j) - z[n - d] + z[n - j - 1] + z[i]
t[i][j] = s / u[n]
print(sum(t[i][j] for i, j in v))
```
| 3
|
|
71
|
A
|
Way Too Long Words
|
PROGRAMMING
| 800
|
[
"strings"
] |
A. Way Too Long Words
|
1
|
256
|
Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome.
Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation.
This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes.
Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n".
You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.
|
The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.
|
Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data.
|
[
"4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n"
] |
[
"word\nl10n\ni18n\np43s\n"
] |
none
| 500
|
[
{
"input": "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis",
"output": "word\nl10n\ni18n\np43s"
},
{
"input": "5\nabcdefgh\nabcdefghi\nabcdefghij\nabcdefghijk\nabcdefghijklm",
"output": "abcdefgh\nabcdefghi\nabcdefghij\na9k\na11m"
},
{
"input": "3\nnjfngnrurunrgunrunvurn\njfvnjfdnvjdbfvsbdubruvbubvkdb\nksdnvidnviudbvibd",
"output": "n20n\nj27b\nk15d"
},
{
"input": "1\ntcyctkktcctrcyvbyiuhihhhgyvyvyvyvjvytchjckt",
"output": "t41t"
},
{
"input": "24\nyou\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nunofficially\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings",
"output": "you\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nu10y\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings"
},
{
"input": "1\na",
"output": "a"
},
{
"input": "26\na\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz",
"output": "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz"
},
{
"input": "1\nabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij",
"output": "a98j"
},
{
"input": "10\ngyartjdxxlcl\nfzsck\nuidwu\nxbymclornemdmtj\nilppyoapitawgje\ncibzc\ndrgbeu\nhezplmsdekhhbo\nfeuzlrimbqbytdu\nkgdco",
"output": "g10l\nfzsck\nuidwu\nx13j\ni13e\ncibzc\ndrgbeu\nh12o\nf13u\nkgdco"
},
{
"input": "20\nlkpmx\nkovxmxorlgwaomlswjxlpnbvltfv\nhykasjxqyjrmybejnmeumzha\ntuevlumpqbbhbww\nqgqsphvrmupxxc\ntrissbaf\nqfgrlinkzvzqdryckaizutd\nzzqtoaxkvwoscyx\noswytrlnhpjvvnwookx\nlpuzqgec\ngyzqfwxggtvpjhzmzmdw\nrlxjgmvdftvrmvbdwudra\nvsntnjpepnvdaxiporggmglhagv\nxlvcqkqgcrbgtgglj\nlyxwxbiszyhlsrgzeedzprbmcpduvq\nyrmqqvrkqskqukzqrwukpsifgtdc\nxpuohcsjhhuhvr\nvvlfrlxpvqejngwrbfbpmqeirxlw\nsvmasocxdvadmaxtrpakysmeaympy\nyuflqboqfdt",
"output": "lkpmx\nk26v\nh22a\nt13w\nq12c\ntrissbaf\nq21d\nz13x\no17x\nlpuzqgec\ng18w\nr19a\nv25v\nx15j\nl28q\ny26c\nx12r\nv26w\ns27y\ny9t"
},
{
"input": "100\nm\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr",
"output": "m\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr"
}
] | 1,693,390,130
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 31
| 0
|
num = int(input())
while num != 0 :
word = input()
lenght = (len(word))
if lenght <= 10 :
print (word)
else :
print (word[0] + (lenght-2) + word[-1])
num -= 1
|
Title: Way Too Long Words
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome.
Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation.
This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes.
Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n".
You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.
Input Specification:
The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.
Output Specification:
Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data.
Demo Input:
['4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n']
Demo Output:
['word\nl10n\ni18n\np43s\n']
Note:
none
|
```python
num = int(input())
while num != 0 :
word = input()
lenght = (len(word))
if lenght <= 10 :
print (word)
else :
print (word[0] + (lenght-2) + word[-1])
num -= 1
```
| -1
|
129
|
A
|
Cookies
|
PROGRAMMING
| 900
|
[
"implementation"
] | null | null |
Olga came to visit the twins Anna and Maria and saw that they have many cookies. The cookies are distributed into bags. As there are many cookies, Olga decided that it's no big deal if she steals a bag. However, she doesn't want the sisters to quarrel because of nothing when they divide the cookies. That's why Olga wants to steal a bag with cookies so that the number of cookies in the remaining bags was even, that is, so that Anna and Maria could evenly divide it into two (even 0 remaining cookies will do, just as any other even number). How many ways there are to steal exactly one cookie bag so that the total number of cookies in the remaining bags was even?
|
The first line contains the only integer *n* (1<=≤<=*n*<=≤<=100) — the number of cookie bags Anna and Maria have. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=100) — the number of cookies in the *i*-th bag.
|
Print in the only line the only number — the sought number of ways. If there are no such ways print 0.
|
[
"1\n1\n",
"10\n1 2 2 3 4 4 4 2 2 2\n",
"11\n2 2 2 2 2 2 2 2 2 2 99\n"
] |
[
"1\n",
"8\n",
"1\n"
] |
In the first sample Olga should take the only bag so that the twins ended up with the even number of cookies.
In the second sample Olga can take any of five bags with two cookies or any of three bags with four cookies — 5 + 3 = 8 ways in total.
In the third sample, no matter which bag with two cookies Olga chooses, the twins are left with 2 * 9 + 99 = 117 cookies. Thus, Olga has only one option: to take the bag with 99 cookies.
| 500
|
[
{
"input": "1\n1",
"output": "1"
},
{
"input": "10\n1 2 2 3 4 4 4 2 2 2",
"output": "8"
},
{
"input": "11\n2 2 2 2 2 2 2 2 2 2 99",
"output": "1"
},
{
"input": "2\n1 1",
"output": "0"
},
{
"input": "2\n2 2",
"output": "2"
},
{
"input": "2\n1 2",
"output": "1"
},
{
"input": "7\n7 7 7 7 7 7 7",
"output": "7"
},
{
"input": "8\n1 2 3 4 5 6 7 8",
"output": "4"
},
{
"input": "100\n1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2",
"output": "50"
},
{
"input": "99\n99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99",
"output": "49"
},
{
"input": "82\n43 44 96 33 23 42 33 66 53 87 8 90 43 91 40 88 51 18 48 62 59 10 22 20 54 6 13 63 2 56 31 52 98 42 54 32 26 77 9 24 33 91 16 30 39 34 78 82 73 90 12 15 67 76 30 18 44 86 84 98 65 54 100 79 28 34 40 56 11 43 72 35 86 59 89 40 30 33 7 19 44 15",
"output": "50"
},
{
"input": "17\n50 14 17 77 74 74 38 76 41 27 45 29 66 98 38 73 38",
"output": "7"
},
{
"input": "94\n81 19 90 99 26 11 86 44 78 36 80 59 99 90 78 72 71 20 94 56 42 40 71 84 10 85 10 70 52 27 39 55 90 16 48 25 7 79 99 100 38 10 99 56 3 4 78 9 16 57 14 40 52 54 57 70 30 86 56 84 97 60 59 69 49 66 23 92 90 46 86 73 53 47 1 83 14 20 24 66 13 45 41 14 86 75 55 88 48 95 82 24 47 87",
"output": "39"
},
{
"input": "88\n64 95 12 90 40 65 98 45 52 54 79 7 81 25 98 19 68 82 41 53 35 50 5 22 32 21 8 39 8 6 72 27 81 30 12 79 21 42 60 2 66 87 46 93 62 78 52 71 76 32 78 94 86 85 55 15 34 76 41 20 32 26 94 81 89 45 74 49 11 40 40 39 49 46 80 85 90 23 80 40 86 58 70 26 48 93 23 53",
"output": "37"
},
{
"input": "84\n95 9 43 43 13 84 60 90 1 8 97 99 54 34 59 83 33 15 51 26 40 12 66 65 19 30 29 78 92 60 25 13 19 84 71 73 12 24 54 49 16 41 11 40 57 59 34 40 39 9 71 83 1 77 79 53 94 47 78 55 77 85 29 52 80 90 53 77 97 97 27 79 28 23 83 25 26 22 49 86 63 56 3 32",
"output": "51"
},
{
"input": "47\n61 97 76 94 91 22 2 68 62 73 90 47 16 79 44 71 98 68 43 6 53 52 40 27 68 67 43 96 14 91 60 61 96 24 97 13 32 65 85 96 81 77 34 18 23 14 80",
"output": "21"
},
{
"input": "69\n71 1 78 74 58 89 30 6 100 90 22 61 11 59 14 74 27 25 78 61 45 19 25 33 37 4 52 43 53 38 9 100 56 67 69 38 76 91 63 60 93 52 28 61 9 98 8 14 57 63 89 64 98 51 36 66 36 86 13 82 50 91 52 64 86 78 78 83 81",
"output": "37"
},
{
"input": "52\n38 78 36 75 19 3 56 1 39 97 24 79 84 16 93 55 96 64 12 24 1 86 80 29 12 32 36 36 73 39 76 65 53 98 30 20 28 8 86 43 70 22 75 69 62 65 81 25 53 40 71 59",
"output": "28"
},
{
"input": "74\n81 31 67 97 26 75 69 81 11 13 13 74 77 88 52 20 52 64 66 75 72 28 41 54 26 75 41 91 75 15 18 36 13 83 63 61 14 48 53 63 19 67 35 48 23 65 73 100 44 55 92 88 99 17 73 25 83 7 31 89 12 80 98 39 42 75 14 29 81 35 77 87 33 94",
"output": "47"
},
{
"input": "44\n46 56 31 31 37 71 94 2 14 100 45 72 36 72 80 3 38 54 42 98 50 32 31 42 62 31 45 50 95 100 18 17 64 22 18 25 52 56 70 57 43 40 81 28",
"output": "15"
},
{
"input": "22\n28 57 40 74 51 4 45 84 99 12 95 14 92 60 47 81 84 51 31 91 59 42",
"output": "11"
},
{
"input": "59\n73 45 94 76 41 49 65 13 74 66 36 25 47 75 40 23 92 72 11 32 32 8 81 26 68 56 41 8 76 47 96 55 70 11 84 14 83 18 70 22 30 39 28 100 48 11 92 45 78 69 86 1 54 90 98 91 13 17 35",
"output": "33"
},
{
"input": "63\n20 18 44 94 68 57 16 43 74 55 68 24 21 95 76 84 50 50 47 86 86 12 58 55 28 72 86 18 34 45 81 88 3 72 41 9 60 90 81 93 12 6 9 6 2 41 1 7 9 29 81 14 64 80 20 36 67 54 7 5 35 81 22",
"output": "37"
},
{
"input": "28\n49 84 48 19 44 91 11 82 96 95 88 90 71 82 87 25 31 23 18 13 98 45 26 65 35 12 31 14",
"output": "15"
},
{
"input": "61\n34 18 28 64 28 45 9 77 77 20 63 92 79 16 16 100 86 2 91 91 57 15 31 95 10 88 84 5 82 83 53 98 59 17 97 80 76 80 81 3 91 81 87 93 61 46 10 49 6 22 21 75 63 89 21 81 30 19 67 38 77",
"output": "35"
},
{
"input": "90\n41 90 43 1 28 75 90 50 3 70 76 64 81 63 25 69 83 82 29 91 59 66 21 61 7 55 72 49 38 69 72 20 64 58 30 81 61 29 96 14 39 5 100 20 29 98 75 29 44 78 97 45 26 77 73 59 22 99 41 6 3 96 71 20 9 18 96 18 90 62 34 78 54 5 41 6 73 33 2 54 26 21 18 6 45 57 43 73 95 75",
"output": "42"
},
{
"input": "45\n93 69 4 27 20 14 71 48 79 3 32 26 49 30 57 88 13 56 49 61 37 32 47 41 41 70 45 68 82 18 8 6 25 20 15 13 71 99 28 6 52 34 19 59 26",
"output": "23"
},
{
"input": "33\n29 95 48 49 91 10 83 71 47 25 66 36 51 12 34 10 54 74 41 96 89 26 89 1 42 33 1 62 9 32 49 65 78",
"output": "15"
},
{
"input": "34\n98 24 42 36 41 82 28 58 89 34 77 70 76 44 74 54 66 100 13 79 4 88 21 1 11 45 91 29 87 100 29 54 82 78",
"output": "13"
},
{
"input": "29\n91 84 26 84 9 63 52 9 65 56 90 2 36 7 67 33 91 14 65 38 53 36 81 83 85 14 33 95 51",
"output": "17"
},
{
"input": "100\n2 88 92 82 87 100 78 28 84 43 78 32 43 33 97 19 15 52 29 84 57 72 54 13 99 28 82 79 40 70 34 92 91 53 9 88 27 43 14 92 72 37 26 37 20 95 19 34 49 64 33 37 34 27 80 79 9 54 99 68 25 4 68 73 46 66 24 78 3 87 26 52 50 84 4 95 23 83 39 58 86 36 33 16 98 2 84 19 53 12 69 60 10 11 78 17 79 92 77 59",
"output": "45"
},
{
"input": "100\n2 95 45 73 9 54 20 97 57 82 88 26 18 71 25 27 75 54 31 11 58 85 69 75 72 91 76 5 25 80 45 49 4 73 8 81 81 38 5 12 53 77 7 96 90 35 28 80 73 94 19 69 96 17 94 49 69 9 32 19 5 12 46 29 26 40 59 59 6 95 82 50 72 2 45 69 12 5 72 29 39 72 23 96 81 28 28 56 68 58 37 41 30 1 90 84 15 24 96 43",
"output": "53"
},
{
"input": "100\n27 72 35 91 13 10 35 45 24 55 83 84 63 96 29 79 34 67 63 92 48 83 18 77 28 27 49 66 29 88 55 15 6 58 14 67 94 36 77 7 7 64 61 52 71 18 36 99 76 6 50 67 16 13 41 7 89 73 61 51 78 22 78 32 76 100 3 31 89 71 63 53 15 85 77 54 89 33 68 74 3 23 57 5 43 89 75 35 9 86 90 11 31 46 48 37 74 17 77 8",
"output": "40"
},
{
"input": "100\n69 98 69 88 11 49 55 8 25 91 17 81 47 26 15 73 96 71 18 42 42 61 48 14 92 78 35 72 4 27 62 75 83 79 17 16 46 80 96 90 82 54 37 69 85 21 67 70 96 10 46 63 21 59 56 92 54 88 77 30 75 45 44 29 86 100 51 11 65 69 66 56 82 63 27 1 51 51 13 10 3 55 26 85 34 16 87 72 13 100 81 71 90 95 86 50 83 55 55 54",
"output": "53"
},
{
"input": "100\n34 35 99 64 2 66 78 93 20 48 12 79 19 10 87 7 42 92 60 79 5 2 24 89 57 48 63 92 74 4 16 51 7 12 90 48 87 17 18 73 51 58 97 97 25 38 15 97 96 73 67 91 6 75 14 13 87 79 75 3 15 55 35 95 71 45 10 13 20 37 82 26 2 22 13 83 97 84 39 79 43 100 54 59 98 8 61 34 7 65 75 44 24 77 73 88 34 95 44 77",
"output": "55"
},
{
"input": "100\n15 86 3 1 51 26 74 85 37 87 64 58 10 6 57 26 30 47 85 65 24 72 50 40 12 35 91 47 91 60 47 87 95 34 80 91 26 3 36 39 14 86 28 70 51 44 28 21 72 79 57 61 16 71 100 94 57 67 36 74 24 21 89 85 25 2 97 67 76 53 76 80 97 64 35 13 8 32 21 52 62 61 67 14 74 73 66 44 55 76 24 3 43 42 99 61 36 80 38 66",
"output": "52"
},
{
"input": "100\n45 16 54 54 80 94 74 93 75 85 58 95 79 30 81 2 84 4 57 23 92 64 78 1 50 36 13 27 56 54 10 77 87 1 5 38 85 74 94 82 30 45 72 83 82 30 81 82 82 3 69 82 7 92 39 60 94 42 41 5 3 17 67 21 79 44 79 96 28 3 53 68 79 89 63 83 1 44 4 31 84 15 73 77 19 66 54 6 73 1 67 24 91 11 86 45 96 82 20 89",
"output": "51"
},
{
"input": "100\n84 23 50 32 90 71 92 43 58 70 6 82 7 55 85 19 70 89 12 26 29 56 74 30 2 27 4 39 63 67 91 81 11 33 75 10 82 88 39 43 43 80 68 35 55 67 53 62 73 65 86 74 43 51 14 48 42 92 83 57 22 33 24 99 5 27 78 96 7 28 11 15 8 38 85 67 5 92 24 96 57 59 14 95 91 4 9 18 45 33 74 83 64 85 14 51 51 94 29 2",
"output": "53"
},
{
"input": "100\n77 56 56 45 73 55 32 37 39 50 30 95 79 21 44 34 51 43 86 91 39 30 85 15 35 93 100 14 57 31 80 79 38 40 88 4 91 54 7 95 76 26 62 84 17 33 67 47 6 82 69 51 17 2 59 24 11 12 31 90 12 11 55 38 72 49 30 50 42 46 5 97 9 9 30 45 86 23 19 82 40 42 5 40 35 98 35 32 60 60 5 28 84 35 21 49 68 53 68 23",
"output": "48"
},
{
"input": "100\n78 38 79 61 45 86 83 83 86 90 74 69 2 84 73 39 2 5 20 71 24 80 54 89 58 34 77 40 39 62 2 47 28 53 97 75 88 98 94 96 33 71 44 90 47 36 19 89 87 98 90 87 5 85 34 79 82 3 42 88 89 63 35 7 89 30 40 48 12 41 56 76 83 60 80 80 39 56 77 4 72 96 30 55 57 51 7 19 11 1 66 1 91 87 11 62 95 85 79 25",
"output": "48"
},
{
"input": "100\n5 34 23 20 76 75 19 51 17 82 60 13 83 6 65 16 20 43 66 54 87 10 87 73 50 24 16 98 33 28 80 52 54 82 26 92 14 13 84 92 94 29 61 21 60 20 48 94 24 20 75 70 58 27 68 45 86 89 29 8 67 38 83 48 18 100 11 22 46 84 52 97 70 19 50 75 3 7 52 53 72 41 18 31 1 38 49 53 11 64 99 76 9 87 48 12 100 32 44 71",
"output": "58"
},
{
"input": "100\n76 89 68 78 24 72 73 95 98 72 58 15 2 5 56 32 9 65 50 70 94 31 29 54 89 52 31 93 43 56 26 35 72 95 51 55 78 70 11 92 17 5 54 94 81 31 78 95 73 91 95 37 59 9 53 48 65 55 84 8 45 97 64 37 96 34 36 53 66 17 72 48 99 23 27 18 92 84 44 73 60 78 53 29 68 99 19 39 61 40 69 6 77 12 47 29 15 4 8 45",
"output": "53"
},
{
"input": "100\n82 40 31 53 8 50 85 93 3 84 54 17 96 59 51 42 18 19 35 84 79 31 17 46 54 82 72 49 35 73 26 89 61 73 3 50 12 29 25 77 88 21 58 24 22 89 96 54 82 29 96 56 77 16 1 68 90 93 20 23 57 22 31 18 92 90 51 14 50 72 31 54 12 50 66 62 2 34 17 45 68 50 87 97 23 71 1 72 17 82 42 15 20 78 4 49 66 59 10 17",
"output": "54"
},
{
"input": "100\n32 82 82 24 39 53 48 5 29 24 9 37 91 37 91 95 1 97 84 52 12 56 93 47 22 20 14 17 40 22 79 34 24 2 69 30 69 29 3 89 21 46 60 92 39 29 18 24 49 18 40 22 60 13 77 50 39 64 50 70 99 8 66 31 90 38 20 54 7 21 5 56 41 68 69 20 54 89 69 62 9 53 43 89 81 97 15 2 52 78 89 65 16 61 59 42 56 25 32 52",
"output": "49"
},
{
"input": "100\n72 54 23 24 97 14 99 87 15 25 7 23 17 87 72 31 71 87 34 82 51 77 74 85 62 38 24 7 84 48 98 21 29 71 70 84 25 58 67 92 18 44 32 9 81 15 53 29 63 18 86 16 7 31 38 99 70 32 89 16 23 11 66 96 69 82 97 59 6 9 49 80 85 19 6 9 52 51 85 74 53 46 73 55 31 63 78 61 34 80 77 65 87 77 92 52 89 8 52 31",
"output": "44"
},
{
"input": "100\n56 88 8 19 7 15 11 54 35 50 19 57 63 72 51 43 50 19 57 90 40 100 8 92 11 96 30 32 59 65 93 47 62 3 50 41 30 50 72 83 61 46 83 60 20 46 33 1 5 18 83 22 34 16 41 95 63 63 7 59 55 95 91 29 64 60 64 81 45 45 10 9 88 37 69 85 21 82 41 76 42 34 47 78 51 83 65 100 13 22 59 76 63 1 26 86 36 94 99 74",
"output": "46"
},
{
"input": "100\n27 89 67 60 62 80 43 50 28 88 72 5 94 11 63 91 18 78 99 3 71 26 12 97 74 62 23 24 22 3 100 72 98 7 94 32 12 75 61 88 42 48 10 14 45 9 48 56 73 76 70 70 79 90 35 39 96 37 81 11 19 65 99 39 23 79 34 61 35 74 90 37 73 23 46 21 94 84 73 58 11 89 13 9 10 85 42 78 73 32 53 39 49 90 43 5 28 31 97 75",
"output": "53"
},
{
"input": "100\n33 24 97 96 1 14 99 51 13 65 67 20 46 88 42 44 20 49 5 89 98 83 15 40 74 83 58 3 10 79 34 2 69 28 37 100 55 52 14 8 44 94 97 89 6 42 11 28 30 33 55 56 20 57 52 25 75 1 87 42 62 41 37 12 54 85 95 80 42 36 94 96 28 76 54 36 4 17 26 24 62 15 17 79 84 36 92 78 74 91 96 77 54 92 81 91 62 98 37 37",
"output": "43"
},
{
"input": "100\n86 24 61 15 11 85 1 31 47 36 23 36 59 34 3 27 16 29 82 28 58 52 52 66 71 61 98 39 60 20 67 41 67 90 73 29 92 17 70 95 58 98 58 32 21 73 46 56 87 72 80 75 40 27 94 31 59 92 93 37 14 99 96 21 97 23 81 91 52 52 96 94 92 28 38 29 52 16 57 27 17 24 91 21 79 55 96 98 95 94 23 78 79 12 77 35 32 75 100 82",
"output": "51"
},
{
"input": "100\n88 85 41 37 69 21 7 69 36 5 92 26 64 75 22 46 67 20 70 22 62 66 38 24 47 49 68 30 90 31 67 86 86 82 9 51 43 45 48 42 73 44 31 94 45 60 54 66 20 87 11 94 34 32 87 66 56 28 75 39 37 90 72 93 55 72 31 42 30 71 87 61 4 12 12 81 23 61 56 98 71 32 30 33 96 63 92 16 8 78 47 91 47 54 49 3 81 82 41 5",
"output": "47"
},
{
"input": "1\n2",
"output": "1"
},
{
"input": "5\n1 1 3 2 2",
"output": "3"
}
] | 1,585,169,109
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 52
| 310
| 0
|
n=int(input())
l=list(map(int,input().split()))
s=0
k=0
m=0
for i in l:
s=s+i
if i%2==0:
k+=1
else:
m+=1
if s%2==0:
print(k)
else:
print(m)
|
Title: Cookies
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Olga came to visit the twins Anna and Maria and saw that they have many cookies. The cookies are distributed into bags. As there are many cookies, Olga decided that it's no big deal if she steals a bag. However, she doesn't want the sisters to quarrel because of nothing when they divide the cookies. That's why Olga wants to steal a bag with cookies so that the number of cookies in the remaining bags was even, that is, so that Anna and Maria could evenly divide it into two (even 0 remaining cookies will do, just as any other even number). How many ways there are to steal exactly one cookie bag so that the total number of cookies in the remaining bags was even?
Input Specification:
The first line contains the only integer *n* (1<=≤<=*n*<=≤<=100) — the number of cookie bags Anna and Maria have. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=100) — the number of cookies in the *i*-th bag.
Output Specification:
Print in the only line the only number — the sought number of ways. If there are no such ways print 0.
Demo Input:
['1\n1\n', '10\n1 2 2 3 4 4 4 2 2 2\n', '11\n2 2 2 2 2 2 2 2 2 2 99\n']
Demo Output:
['1\n', '8\n', '1\n']
Note:
In the first sample Olga should take the only bag so that the twins ended up with the even number of cookies.
In the second sample Olga can take any of five bags with two cookies or any of three bags with four cookies — 5 + 3 = 8 ways in total.
In the third sample, no matter which bag with two cookies Olga chooses, the twins are left with 2 * 9 + 99 = 117 cookies. Thus, Olga has only one option: to take the bag with 99 cookies.
|
```python
n=int(input())
l=list(map(int,input().split()))
s=0
k=0
m=0
for i in l:
s=s+i
if i%2==0:
k+=1
else:
m+=1
if s%2==0:
print(k)
else:
print(m)
```
| 3
|
|
126
|
B
|
Password
|
PROGRAMMING
| 1,700
|
[
"binary search",
"dp",
"hashing",
"string suffix structures",
"strings"
] | null | null |
Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them.
A little later they found a string *s*, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring *t* of the string *s*.
Prefix supposed that the substring *t* is the beginning of the string *s*; Suffix supposed that the substring *t* should be the end of the string *s*; and Obelix supposed that *t* should be located somewhere inside the string *s*, that is, *t* is neither its beginning, nor its end.
Asterix chose the substring *t* so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring *t* aloud, the temple doors opened.
You know the string *s*. Find the substring *t* or determine that such substring does not exist and all that's been written above is just a nice legend.
|
You are given the string *s* whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters.
|
Print the string *t*. If a suitable *t* string does not exist, then print "Just a legend" without the quotes.
|
[
"fixprefixsuffix\n",
"abcdabc\n"
] |
[
"fix",
"Just a legend"
] |
none
| 1,000
|
[
{
"input": "fixprefixsuffix",
"output": "fix"
},
{
"input": "abcdabc",
"output": "Just a legend"
},
{
"input": "qwertyqwertyqwerty",
"output": "qwerty"
},
{
"input": "papapapap",
"output": "papap"
},
{
"input": "aaaaaaaaaa",
"output": "aaaaaaaa"
},
{
"input": "ghbdtn",
"output": "Just a legend"
},
{
"input": "a",
"output": "Just a legend"
},
{
"input": "aa",
"output": "Just a legend"
},
{
"input": "ab",
"output": "Just a legend"
},
{
"input": "aaa",
"output": "a"
},
{
"input": "aba",
"output": "Just a legend"
},
{
"input": "aab",
"output": "Just a legend"
},
{
"input": "abb",
"output": "Just a legend"
},
{
"input": "abc",
"output": "Just a legend"
},
{
"input": "aaabaabaaaaab",
"output": "Just a legend"
},
{
"input": "aabaaabaaaaab",
"output": "aab"
},
{
"input": "aaabaaaabab",
"output": "Just a legend"
},
{
"input": "abcabcabcabcabc",
"output": "abcabcabc"
},
{
"input": "aaaaabaaaa",
"output": "aaaa"
},
{
"input": "aaaabaaaaaaa",
"output": "aaaa"
},
{
"input": "ghghghgxghghghg",
"output": "ghghg"
},
{
"input": "kincenvizh",
"output": "Just a legend"
},
{
"input": "amcksgurlgqzqizdauqminfzshiweejkevbazyzylrrghumnvqeqqdedyopgtvxakqwpvxntxgrkrcxabhrgoxngrwrxrvcguuyw",
"output": "Just a legend"
},
{
"input": "kwuaizneqxfflhmyruotjlkqksinoanvkyvqptkkntnpjdyzicceelgooajdgpkneuhyvhdtmasiglplajxolxovlhkwuaizneqx",
"output": "Just a legend"
},
{
"input": "nfbdzgdlbjhrlvfryyjbvtsmzacxglcvukmyexdgpuiwvqbnfbdzgdlbjhrlvfryyjbtuomcwbwvlhefnfbdzgdlbjhrlvfryyjb",
"output": "nfbdzgdlbjhrlvfryyjb"
},
{
"input": "btbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgpmvbxbyszdugvmoyjeeqsywcvuqskcjotyhvdijyslgfvyujxthngnonasgnbzzygyikheelirdfsvuicbiazfdeqecbtbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgpccdtdteohtjjuicfjfcbzpynlqhecyqqrjpmexgfqywnfmusldgzvgnzdmuuujtkdfnlytzgstquwqpuccxbtbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgp",
"output": "btbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgp"
},
{
"input": "abcazabca",
"output": "a"
}
] | 1,671,894,781
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 30
| 0
|
t=int(input())
for i in range(t):
x=list(map(int,input().split()))
for j in x:
m=j%14
if m>=1 and m<=6:
print("YES")
else:
print("NO")
|
Title: Password
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them.
A little later they found a string *s*, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring *t* of the string *s*.
Prefix supposed that the substring *t* is the beginning of the string *s*; Suffix supposed that the substring *t* should be the end of the string *s*; and Obelix supposed that *t* should be located somewhere inside the string *s*, that is, *t* is neither its beginning, nor its end.
Asterix chose the substring *t* so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring *t* aloud, the temple doors opened.
You know the string *s*. Find the substring *t* or determine that such substring does not exist and all that's been written above is just a nice legend.
Input Specification:
You are given the string *s* whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters.
Output Specification:
Print the string *t*. If a suitable *t* string does not exist, then print "Just a legend" without the quotes.
Demo Input:
['fixprefixsuffix\n', 'abcdabc\n']
Demo Output:
['fix', 'Just a legend']
Note:
none
|
```python
t=int(input())
for i in range(t):
x=list(map(int,input().split()))
for j in x:
m=j%14
if m>=1 and m<=6:
print("YES")
else:
print("NO")
```
| -1
|
|
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,697,823,470
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 12
| 92
| 0
|
n=int(input())
nums=list(map(int,input().split()))
tot=sum(nums)
if tot<n:
if n%tot==0:
for i in range(5,-1,-1):
if nums[i]>0:
print(i+1)
break
else:
n=n%tot
sm=0
for i in range(6):
sm+=nums[i]
if sm>=n:
print(i+1)
break
else:
sm=0
for i in range(6):
sm+=nums[i]
if sm>=n:
print(i+1)
break
|
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
n=int(input())
nums=list(map(int,input().split()))
tot=sum(nums)
if tot<n:
if n%tot==0:
for i in range(5,-1,-1):
if nums[i]>0:
print(i+1)
break
else:
n=n%tot
sm=0
for i in range(6):
sm+=nums[i]
if sm>=n:
print(i+1)
break
else:
sm=0
for i in range(6):
sm+=nums[i]
if sm>=n:
print(i+1)
break
```
| 0
|
|
415
|
A
|
Mashmokh and Lights
|
PROGRAMMING
| 900
|
[
"implementation"
] | null | null |
Mashmokh works in a factory. At the end of each day he must turn off all of the lights.
The lights on the factory are indexed from 1 to *n*. There are *n* buttons in Mashmokh's room indexed from 1 to *n* as well. If Mashmokh pushes button with index *i*, then each light with index not less than *i* that is still turned on turns off.
Mashmokh is not very clever. So instead of pushing the first button he pushes some of the buttons randomly each night. He pushed *m* distinct buttons *b*1,<=*b*2,<=...,<=*b**m* (the buttons were pushed consecutively in the given order) this night. Now he wants to know for each light the index of the button that turned this light off. Please note that the index of button *b**i* is actually *b**i*, not *i*.
Please, help Mashmokh, print these indices.
|
The first line of the input contains two space-separated integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100), the number of the factory lights and the pushed buttons respectively. The next line contains *m* distinct space-separated integers *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**i*<=≤<=*n*).
It is guaranteed that all lights will be turned off after pushing all buttons.
|
Output *n* space-separated integers where the *i*-th number is index of the button that turns the *i*-th light off.
|
[
"5 4\n4 3 1 2\n",
"5 5\n5 4 3 2 1\n"
] |
[
"1 1 3 4 4 \n",
"1 2 3 4 5 \n"
] |
In the first sample, after pressing button number 4, lights 4 and 5 are turned off and lights 1, 2 and 3 are still on. Then after pressing button number 3, light number 3 is turned off as well. Pressing button number 1 turns off lights number 1 and 2 as well so pressing button number 2 in the end has no effect. Thus button number 4 turned lights 4 and 5 off, button number 3 turned light 3 off and button number 1 turned light 1 and 2 off.
| 500
|
[
{
"input": "5 4\n4 3 1 2",
"output": "1 1 3 4 4 "
},
{
"input": "5 5\n5 4 3 2 1",
"output": "1 2 3 4 5 "
},
{
"input": "16 11\n8 5 12 10 14 2 6 3 15 9 1",
"output": "1 2 2 2 5 5 5 8 8 8 8 8 8 8 8 8 "
},
{
"input": "79 22\n76 32 48 28 33 44 58 59 1 51 77 13 15 64 49 72 74 21 61 12 60 57",
"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 28 28 28 28 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 76 76 76 76 "
},
{
"input": "25 19\n3 12 21 11 19 6 5 15 4 16 20 8 9 1 22 23 25 18 13",
"output": "1 1 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 "
},
{
"input": "48 8\n42 27 40 1 18 3 19 2",
"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 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 42 42 42 42 42 42 42 "
},
{
"input": "44 19\n13 20 7 10 9 14 43 17 18 39 21 42 37 1 33 8 35 4 6",
"output": "1 1 1 1 1 1 7 7 7 7 7 7 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 "
},
{
"input": "80 29\n79 51 28 73 65 39 10 1 59 29 7 70 64 3 35 17 24 71 74 2 6 49 66 80 13 18 60 15 12",
"output": "1 1 1 1 1 1 1 1 1 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 79 79 "
},
{
"input": "31 4\n8 18 30 1",
"output": "1 1 1 1 1 1 1 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 "
},
{
"input": "62 29\n61 55 35 13 51 56 23 6 8 26 27 40 48 11 18 12 19 50 54 14 24 21 32 17 43 33 1 2 3",
"output": "1 1 1 1 1 6 6 6 6 6 6 6 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 55 55 55 55 55 55 61 61 "
},
{
"input": "5 4\n2 3 4 1",
"output": "1 2 2 2 2 "
},
{
"input": "39 37\n2 5 17 24 19 33 35 16 20 3 1 34 10 36 15 37 14 8 28 21 13 31 30 29 7 25 32 12 6 27 22 4 11 39 18 9 26",
"output": "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 "
},
{
"input": "100 100\n100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1",
"output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 "
},
{
"input": "1 1\n1",
"output": "1 "
},
{
"input": "18 3\n18 1 11",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 18 "
},
{
"input": "67 20\n66 23 40 49 3 39 60 43 52 47 16 36 22 5 41 10 55 34 64 1",
"output": "1 1 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 66 66 "
},
{
"input": "92 52\n9 85 44 13 27 61 8 1 28 41 6 14 70 67 39 71 56 80 34 21 5 10 40 73 63 38 90 57 37 36 82 86 65 46 7 54 81 12 45 49 83 59 64 26 62 25 60 24 91 47 53 55",
"output": "1 1 1 1 1 1 1 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 "
},
{
"input": "66 36\n44 62 32 29 3 15 47 30 50 42 35 2 33 65 10 13 56 12 1 16 7 36 39 11 25 28 20 52 46 38 37 8 61 49 48 14",
"output": "1 2 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 29 29 29 32 32 32 32 32 32 32 32 32 32 32 32 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 44 "
},
{
"input": "32 8\n27 23 1 13 18 24 17 26",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 23 23 23 23 27 27 27 27 27 27 "
},
{
"input": "26 13\n1 14 13 2 4 24 21 22 16 3 10 12 6",
"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 "
},
{
"input": "31 20\n10 11 20 2 4 26 31 7 13 12 28 1 30 18 21 8 3 16 15 19",
"output": "1 2 2 2 2 2 2 2 2 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 "
},
{
"input": "86 25\n22 62 8 23 53 77 9 31 43 1 58 16 72 11 15 35 60 39 79 4 82 64 76 63 59",
"output": "1 1 1 1 1 1 1 8 8 8 8 8 8 8 8 8 8 8 8 8 8 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 "
},
{
"input": "62 54\n2 5 4 47 40 61 37 31 41 16 44 42 48 32 10 6 62 38 52 49 11 20 55 22 3 36 25 21 50 8 28 14 18 39 34 54 53 19 46 27 15 23 12 24 60 17 33 57 58 1 35 29 51 7",
"output": "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 2 2 2 2 2 2 2 2 2 2 2 2 "
},
{
"input": "57 19\n43 45 37 40 42 55 16 33 47 32 34 35 9 41 1 6 8 15 5",
"output": "1 1 1 1 1 1 1 1 9 9 9 9 9 9 9 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 37 37 37 37 37 37 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 "
},
{
"input": "32 14\n4 7 13 1 25 22 9 27 6 28 30 2 14 21",
"output": "1 1 1 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 "
},
{
"input": "57 12\n8 53 51 38 1 6 16 33 13 46 28 35",
"output": "1 1 1 1 1 1 1 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 "
},
{
"input": "87 9\n57 34 78 1 52 67 56 6 54",
"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 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 "
},
{
"input": "88 42\n85 45 52 14 63 53 70 71 16 86 66 47 12 22 10 72 4 31 3 69 11 77 17 25 46 75 23 1 21 84 44 20 18 33 48 88 41 83 67 61 73 34",
"output": "1 1 3 4 4 4 4 4 4 10 10 12 12 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 85 85 85 85 "
},
{
"input": "27 25\n9 21 17 5 16 3 23 7 12 4 14 11 13 1 15 19 27 8 20 10 22 25 6 18 26",
"output": "1 1 3 3 5 5 5 5 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 "
},
{
"input": "89 28\n5 22 79 42 16 35 66 48 57 55 1 37 29 31 40 38 45 62 41 87 64 89 81 13 60 44 71 82",
"output": "1 1 1 1 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 "
},
{
"input": "17 4\n4 3 1 2",
"output": "1 1 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 "
}
] | 1,578,691,299
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 31
| 109
| 307,200
|
a,b=map(int,input().split())
l=list(map(int,input().split()))
k,c=[],a
for x in l:
if x<=c:
for y in range(c-x+1):k.append(x)
c=x-1
k.reverse()
print(*k)
|
Title: Mashmokh and Lights
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mashmokh works in a factory. At the end of each day he must turn off all of the lights.
The lights on the factory are indexed from 1 to *n*. There are *n* buttons in Mashmokh's room indexed from 1 to *n* as well. If Mashmokh pushes button with index *i*, then each light with index not less than *i* that is still turned on turns off.
Mashmokh is not very clever. So instead of pushing the first button he pushes some of the buttons randomly each night. He pushed *m* distinct buttons *b*1,<=*b*2,<=...,<=*b**m* (the buttons were pushed consecutively in the given order) this night. Now he wants to know for each light the index of the button that turned this light off. Please note that the index of button *b**i* is actually *b**i*, not *i*.
Please, help Mashmokh, print these indices.
Input Specification:
The first line of the input contains two space-separated integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100), the number of the factory lights and the pushed buttons respectively. The next line contains *m* distinct space-separated integers *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**i*<=≤<=*n*).
It is guaranteed that all lights will be turned off after pushing all buttons.
Output Specification:
Output *n* space-separated integers where the *i*-th number is index of the button that turns the *i*-th light off.
Demo Input:
['5 4\n4 3 1 2\n', '5 5\n5 4 3 2 1\n']
Demo Output:
['1 1 3 4 4 \n', '1 2 3 4 5 \n']
Note:
In the first sample, after pressing button number 4, lights 4 and 5 are turned off and lights 1, 2 and 3 are still on. Then after pressing button number 3, light number 3 is turned off as well. Pressing button number 1 turns off lights number 1 and 2 as well so pressing button number 2 in the end has no effect. Thus button number 4 turned lights 4 and 5 off, button number 3 turned light 3 off and button number 1 turned light 1 and 2 off.
|
```python
a,b=map(int,input().split())
l=list(map(int,input().split()))
k,c=[],a
for x in l:
if x<=c:
for y in range(c-x+1):k.append(x)
c=x-1
k.reverse()
print(*k)
```
| 3
|
|
48
|
A
|
Rock-paper-scissors
|
PROGRAMMING
| 900
|
[
"implementation",
"schedules"
] |
A. Rock-paper-scissors
|
2
|
256
|
Uncle Fyodor, Matroskin the Cat and Sharic the Dog live their simple but happy lives in Prostokvashino. Sometimes they receive parcels from Uncle Fyodor’s parents and sometimes from anonymous benefactors, in which case it is hard to determine to which one of them the package has been sent. A photographic rifle is obviously for Sharic who loves hunting and fish is for Matroskin, but for whom was a new video game console meant? Every one of the three friends claimed that the present is for him and nearly quarreled. Uncle Fyodor had an idea how to solve the problem justly: they should suppose that the console was sent to all three of them and play it in turns. Everybody got relieved but then yet another burning problem popped up — who will play first? This time Matroskin came up with a brilliant solution, suggesting the most fair way to find it out: play rock-paper-scissors together. The rules of the game are very simple. On the count of three every player shows a combination with his hand (or paw). The combination corresponds to one of three things: a rock, scissors or paper. Some of the gestures win over some other ones according to well-known rules: the rock breaks the scissors, the scissors cut the paper, and the paper gets wrapped over the stone. Usually there are two players. Yet there are three friends, that’s why they decided to choose the winner like that: If someone shows the gesture that wins over the other two players, then that player wins. Otherwise, another game round is required. Write a program that will determine the winner by the gestures they have shown.
|
The first input line contains the name of the gesture that Uncle Fyodor showed, the second line shows which gesture Matroskin showed and the third line shows Sharic’s gesture.
|
Print "F" (without quotes) if Uncle Fyodor wins. Print "M" if Matroskin wins and "S" if Sharic wins. If it is impossible to find the winner, print "?".
|
[
"rock\nrock\nrock\n",
"paper\nrock\nrock\n",
"scissors\nrock\nrock\n",
"scissors\npaper\nrock\n"
] |
[
"?\n",
"F\n",
"?\n",
"?\n"
] |
none
| 0
|
[
{
"input": "rock\nrock\nrock",
"output": "?"
},
{
"input": "paper\nrock\nrock",
"output": "F"
},
{
"input": "scissors\nrock\nrock",
"output": "?"
},
{
"input": "scissors\npaper\nrock",
"output": "?"
},
{
"input": "paper\npaper\nrock",
"output": "?"
},
{
"input": "rock\npaper\nrock",
"output": "M"
},
{
"input": "rock\nscissors\nrock",
"output": "?"
},
{
"input": "paper\nscissors\nrock",
"output": "?"
},
{
"input": "scissors\nscissors\nrock",
"output": "S"
},
{
"input": "rock\nrock\npaper",
"output": "S"
},
{
"input": "paper\nrock\npaper",
"output": "?"
},
{
"input": "scissors\nrock\npaper",
"output": "?"
},
{
"input": "rock\npaper\npaper",
"output": "?"
},
{
"input": "paper\npaper\npaper",
"output": "?"
},
{
"input": "scissors\npaper\npaper",
"output": "F"
},
{
"input": "rock\nscissors\npaper",
"output": "?"
},
{
"input": "paper\nscissors\npaper",
"output": "M"
},
{
"input": "scissors\nscissors\npaper",
"output": "?"
},
{
"input": "rock\nrock\nscissors",
"output": "?"
},
{
"input": "paper\nrock\nscissors",
"output": "?"
},
{
"input": "scissors\nrock\nscissors",
"output": "M"
},
{
"input": "rock\npaper\nscissors",
"output": "?"
},
{
"input": "paper\npaper\nscissors",
"output": "S"
},
{
"input": "scissors\npaper\nscissors",
"output": "?"
},
{
"input": "rock\nscissors\nscissors",
"output": "F"
},
{
"input": "paper\nscissors\nscissors",
"output": "?"
},
{
"input": "scissors\nscissors\nscissors",
"output": "?"
}
] | 1,618,754,066
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 122
| 0
|
a=['l']*3
a[0],a[1],a[2]=input(),input(),input()
c=['F','M','S']
b=['scissors','paper','rock']
for i, j,k in [0,1,2],[0,2,1],[1,2,0],[1,0,2],[2,0,1],[2,1,0]:
if a[i]==a[j]:
if b.index(a[i])-b.index(a[k]) in [1,-2]:
break
else:
print('?')
|
Title: Rock-paper-scissors
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Uncle Fyodor, Matroskin the Cat and Sharic the Dog live their simple but happy lives in Prostokvashino. Sometimes they receive parcels from Uncle Fyodor’s parents and sometimes from anonymous benefactors, in which case it is hard to determine to which one of them the package has been sent. A photographic rifle is obviously for Sharic who loves hunting and fish is for Matroskin, but for whom was a new video game console meant? Every one of the three friends claimed that the present is for him and nearly quarreled. Uncle Fyodor had an idea how to solve the problem justly: they should suppose that the console was sent to all three of them and play it in turns. Everybody got relieved but then yet another burning problem popped up — who will play first? This time Matroskin came up with a brilliant solution, suggesting the most fair way to find it out: play rock-paper-scissors together. The rules of the game are very simple. On the count of three every player shows a combination with his hand (or paw). The combination corresponds to one of three things: a rock, scissors or paper. Some of the gestures win over some other ones according to well-known rules: the rock breaks the scissors, the scissors cut the paper, and the paper gets wrapped over the stone. Usually there are two players. Yet there are three friends, that’s why they decided to choose the winner like that: If someone shows the gesture that wins over the other two players, then that player wins. Otherwise, another game round is required. Write a program that will determine the winner by the gestures they have shown.
Input Specification:
The first input line contains the name of the gesture that Uncle Fyodor showed, the second line shows which gesture Matroskin showed and the third line shows Sharic’s gesture.
Output Specification:
Print "F" (without quotes) if Uncle Fyodor wins. Print "M" if Matroskin wins and "S" if Sharic wins. If it is impossible to find the winner, print "?".
Demo Input:
['rock\nrock\nrock\n', 'paper\nrock\nrock\n', 'scissors\nrock\nrock\n', 'scissors\npaper\nrock\n']
Demo Output:
['?\n', 'F\n', '?\n', '?\n']
Note:
none
|
```python
a=['l']*3
a[0],a[1],a[2]=input(),input(),input()
c=['F','M','S']
b=['scissors','paper','rock']
for i, j,k in [0,1,2],[0,2,1],[1,2,0],[1,0,2],[2,0,1],[2,1,0]:
if a[i]==a[j]:
if b.index(a[i])-b.index(a[k]) in [1,-2]:
break
else:
print('?')
```
| 0
|
18
|
C
|
Stripe
|
PROGRAMMING
| 1,200
|
[
"data structures",
"implementation"
] |
C. Stripe
|
2
|
64
|
Once Bob took a paper stripe of *n* squares (the height of the stripe is 1 square). In each square he wrote an integer number, possibly negative. He became interested in how many ways exist to cut this stripe into two pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece, and each piece contains positive integer amount of squares. Would you help Bob solve this problem?
|
The first input line contains integer *n* (1<=≤<=*n*<=≤<=105) — amount of squares in the stripe. The second line contains *n* space-separated numbers — they are the numbers written in the squares of the stripe. These numbers are integer and do not exceed 10000 in absolute value.
|
Output the amount of ways to cut the stripe into two non-empty pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece. Don't forget that it's allowed to cut the stripe along the squares' borders only.
|
[
"9\n1 5 -6 7 9 -16 0 -2 2\n",
"3\n1 1 1\n",
"2\n0 0\n"
] |
[
"3\n",
"0\n",
"1\n"
] |
none
| 0
|
[
{
"input": "9\n1 5 -6 7 9 -16 0 -2 2",
"output": "3"
},
{
"input": "3\n1 1 1",
"output": "0"
},
{
"input": "2\n0 0",
"output": "1"
},
{
"input": "4\n100 1 10 111",
"output": "1"
},
{
"input": "10\n0 4 -3 0 -2 2 -3 -3 2 5",
"output": "3"
},
{
"input": "10\n0 -1 2 2 -1 1 0 0 0 2",
"output": "0"
},
{
"input": "10\n-1 -1 1 -1 0 1 0 1 1 1",
"output": "1"
},
{
"input": "10\n0 0 0 0 0 0 0 0 0 0",
"output": "9"
},
{
"input": "50\n-4 -3 3 4 -1 0 2 -4 -3 -4 1 4 3 0 4 1 0 -3 4 -3 -2 2 2 1 0 -4 -4 -5 3 2 -1 4 5 -3 -3 4 4 -5 2 -3 4 -5 2 5 -4 4 1 -2 -4 3",
"output": "3"
},
{
"input": "15\n0 4 0 3 -1 4 -2 -2 -4 -4 3 2 4 -1 -3",
"output": "0"
},
{
"input": "10\n3 -1 -3 -1 3 -2 0 3 1 -2",
"output": "0"
},
{
"input": "100\n-4 2 4 4 1 3 -3 -3 2 1 -4 0 0 2 3 -1 -4 -3 4 -2 -3 -3 -3 -1 -2 -3 -1 -4 0 4 0 -1 4 0 -4 -4 4 -4 -2 1 -4 1 -3 -2 3 -4 4 0 -1 3 -1 4 -1 4 -1 3 -3 -3 -2 -2 4 -3 -3 4 -3 -2 -1 0 -2 4 0 -3 -1 -2 -3 1 -4 1 -3 -3 -3 -2 -3 0 1 -2 -2 -4 -3 -1 2 3 -1 1 1 0 3 -3 -1 -2",
"output": "1"
},
{
"input": "100\n-2 -1 1 0 -2 -1 2 2 0 0 2 1 0 2 0 2 1 0 -1 -1 -1 0 -2 -1 2 -1 -2 2 -2 2 -2 -2 2 1 1 1 -2 2 0 0 2 -1 2 2 2 0 -1 -1 -1 1 -2 2 2 2 -2 0 0 -2 0 -2 -2 0 -1 -1 -2 -1 1 2 -2 -1 1 -2 -1 0 -2 2 2 -1 -2 2 0 0 0 1 0 1 2 1 -2 -2 -1 -1 -2 -2 -2 -1 2 2 2 -2",
"output": "6"
},
{
"input": "100\n2 7 6 0 8 -2 0 1 8 -1 7 -4 -1 1 0 3 4 -4 3 7 8 -4 -6 6 4 -2 -5 7 4 6 1 6 3 8 -2 6 -6 -3 0 -1 -7 -8 -2 5 8 6 -2 -2 -5 -4 -7 -3 -5 -3 -3 -1 5 8 4 0 -7 -6 8 -4 -1 7 2 6 6 4 -5 -4 -5 -2 2 -2 -7 -1 5 -8 -6 -2 -5 4 2 8 -6 7 -8 -1 -5 8 6 -3 -1 7 -1 2 -8 -8",
"output": "0"
},
{
"input": "1\n0",
"output": "0"
},
{
"input": "1\n10000",
"output": "0"
},
{
"input": "1\n-10000",
"output": "0"
}
] | 1,671,022,688
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 0
| 92
| 0
|
n=int(input())
array=[int(num) for num in input().split()]
bucketA=sum(array)
bucketB = 0
count=0
for i in array:
A=bucketA-i
B=bucketB+i
if A==B:
count+=1
print(count)
|
Title: Stripe
Time Limit: 2 seconds
Memory Limit: 64 megabytes
Problem Description:
Once Bob took a paper stripe of *n* squares (the height of the stripe is 1 square). In each square he wrote an integer number, possibly negative. He became interested in how many ways exist to cut this stripe into two pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece, and each piece contains positive integer amount of squares. Would you help Bob solve this problem?
Input Specification:
The first input line contains integer *n* (1<=≤<=*n*<=≤<=105) — amount of squares in the stripe. The second line contains *n* space-separated numbers — they are the numbers written in the squares of the stripe. These numbers are integer and do not exceed 10000 in absolute value.
Output Specification:
Output the amount of ways to cut the stripe into two non-empty pieces so that the sum of numbers from one piece is equal to the sum of numbers from the other piece. Don't forget that it's allowed to cut the stripe along the squares' borders only.
Demo Input:
['9\n1 5 -6 7 9 -16 0 -2 2\n', '3\n1 1 1\n', '2\n0 0\n']
Demo Output:
['3\n', '0\n', '1\n']
Note:
none
|
```python
n=int(input())
array=[int(num) for num in input().split()]
bucketA=sum(array)
bucketB = 0
count=0
for i in array:
A=bucketA-i
B=bucketB+i
if A==B:
count+=1
print(count)
```
| 0
|
0
|
none
|
none
|
none
| 0
|
[
"none"
] | null | null |
A *k*-multiple free set is a set of integers where there is no pair of integers where one is equal to another integer multiplied by *k*. That is, there are no two integers *x* and *y* (*x*<=<<=*y*) from the set, such that *y*<==<=*x*·*k*.
You're given a set of *n* distinct positive integers. Your task is to find the size of it's largest *k*-multiple free subset.
|
The first line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=105,<=1<=≤<=*k*<=≤<=109). The next line contains a list of *n* distinct positive integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109).
All the numbers in the lines are separated by single spaces.
|
On the only line of the output print the size of the largest *k*-multiple free subset of {*a*1,<=*a*2,<=...,<=*a**n*}.
|
[
"6 2\n2 3 6 5 4 10\n"
] |
[
"3\n"
] |
In the sample input one of the possible maximum 2-multiple free subsets is {4, 5, 6}.
| 0
|
[
{
"input": "6 2\n2 3 6 5 4 10",
"output": "3"
},
{
"input": "10 2\n1 2 3 4 5 6 7 8 9 10",
"output": "6"
},
{
"input": "1 1\n1",
"output": "1"
},
{
"input": "100 2\n191 17 61 40 77 95 128 88 26 69 79 10 131 106 142 152 68 39 182 53 83 81 6 89 65 148 33 22 5 47 107 121 52 163 150 158 189 118 75 180 177 176 112 167 140 184 29 166 25 46 169 145 187 123 196 18 115 126 155 100 63 58 159 19 173 113 133 60 130 161 76 157 93 199 50 97 15 67 109 164 99 149 3 137 153 136 56 43 103 170 13 183 194 72 9 181 86 30 91 36",
"output": "79"
},
{
"input": "100 3\n13 38 137 24 46 192 33 8 170 141 118 57 198 133 112 176 40 36 91 130 166 72 123 28 82 180 134 52 64 107 97 79 199 184 158 22 181 163 98 7 88 41 73 87 167 109 15 173 153 70 50 119 139 56 17 152 84 161 11 116 31 187 143 196 27 102 132 126 149 63 146 168 67 48 53 120 20 105 155 10 128 47 23 6 94 3 113 65 44 179 189 99 75 34 111 193 60 145 171 77",
"output": "87"
},
{
"input": "12 400000000\n1 400000000 800000000 2 3 4 5 6 7 8 9 10",
"output": "10"
},
{
"input": "3 1\n1 2 3",
"output": "3"
},
{
"input": "1 1\n1000000000",
"output": "1"
},
{
"input": "10 1\n1 100 300 400 500 500000 1000000 10000000 100000000 1000000000",
"output": "10"
},
{
"input": "2 1\n2 1",
"output": "2"
},
{
"input": "2 1000000000\n1 1000000000",
"output": "1"
},
{
"input": "4 1000\n1 1000 1000000 1000000000",
"output": "2"
},
{
"input": "2 2\n1 3",
"output": "2"
},
{
"input": "2 2\n16 8",
"output": "1"
},
{
"input": "3 2\n8 4 2",
"output": "2"
},
{
"input": "5 1\n1 2 3 4 5",
"output": "5"
},
{
"input": "2 2\n500000000 1000000000",
"output": "1"
},
{
"input": "2 2\n4 2",
"output": "1"
},
{
"input": "10 100000000\n1 2 3 4 5 6 7 8 82000 907431936",
"output": "10"
},
{
"input": "8 65538\n65535 65536 65537 65538 65539 131072 262144 196608",
"output": "8"
},
{
"input": "5 2\n10 8 6 4 2",
"output": "4"
},
{
"input": "2 1000000000\n276447232 100000",
"output": "2"
}
] | 1,680,565,618
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 60
| 0
|
if __name__ == "__main__":
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
discharged = set()
for x in a:
if x not in discharged:
y = x * k
discharged.add(y)
print(len(a) - len(discharged))
|
Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A *k*-multiple free set is a set of integers where there is no pair of integers where one is equal to another integer multiplied by *k*. That is, there are no two integers *x* and *y* (*x*<=<<=*y*) from the set, such that *y*<==<=*x*·*k*.
You're given a set of *n* distinct positive integers. Your task is to find the size of it's largest *k*-multiple free subset.
Input Specification:
The first line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=105,<=1<=≤<=*k*<=≤<=109). The next line contains a list of *n* distinct positive integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109).
All the numbers in the lines are separated by single spaces.
Output Specification:
On the only line of the output print the size of the largest *k*-multiple free subset of {*a*1,<=*a*2,<=...,<=*a**n*}.
Demo Input:
['6 2\n2 3 6 5 4 10\n']
Demo Output:
['3\n']
Note:
In the sample input one of the possible maximum 2-multiple free subsets is {4, 5, 6}.
|
```python
if __name__ == "__main__":
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
discharged = set()
for x in a:
if x not in discharged:
y = x * k
discharged.add(y)
print(len(a) - len(discharged))
```
| 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.