contestId int64 0 1.01k | index stringclasses 40
values | name stringlengths 2 54 | type stringclasses 2
values | rating int64 0 3.4k | tags listlengths 0 7 | title stringclasses 393
values | time-limit stringclasses 7
values | memory-limit stringclasses 6
values | problem-description stringlengths 0 2.97k | input-specification stringlengths 4 1.87k | output-specification stringlengths 4 1.12k | demo-input listlengths 0 7 | demo-output listlengths 0 7 | note stringlengths 0 5.24k | points float64 0 3.5k | test_cases listlengths 0 402 | creationTimeSeconds int64 1.37B 1.7B | relativeTimeSeconds int64 8 2.15B | programmingLanguage stringclasses 3
values | verdict stringclasses 1
value | testset stringclasses 9
values | passedTestCount int64 1 402 | timeConsumedMillis int64 15 8.06k | memoryConsumedBytes int64 0 514M | code stringlengths 11 61.4k | prompt stringlengths 297 7.35k | response stringlengths 25 61.4k | score float64 2.82 3.99 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
915 | A | Garden | PROGRAMMING | 900 | [
"implementation"
] | null | null | Luba thinks about watering her garden. The garden can be represented as a segment of length *k*. Luba has got *n* buckets, the *i*-th bucket allows her to water some continuous subsegment of garden of length exactly *a**i* each hour. Luba can't water any parts of the garden that were already watered, also she can't wat... | The first line of input contains two integer numbers *n* and *k* (1<=β€<=*n*,<=*k*<=β€<=100) β the number of buckets and the length of the garden, respectively.
The second line of input contains *n* integer numbers *a**i* (1<=β€<=*a**i*<=β€<=100) β the length of the segment that can be watered by the *i*-th bucket in one ... | Print one integer number β the minimum number of hours required to water the garden. | [
"3 6\n2 3 5\n",
"6 7\n1 2 3 4 5 6\n"
] | [
"2\n",
"7\n"
] | In the first test the best option is to choose the bucket that allows to water the segment of length 3. We can't choose the bucket that allows to water the segment of length 5 because then we can't water the whole garden.
In the second test we can choose only the bucket that allows us to water the segment of length 1. | 0 | [
{
"input": "3 6\n2 3 5",
"output": "2"
},
{
"input": "6 7\n1 2 3 4 5 6",
"output": "7"
},
{
"input": "5 97\n1 10 50 97 2",
"output": "1"
},
{
"input": "5 97\n1 10 50 100 2",
"output": "97"
},
{
"input": "100 100\n2 46 24 18 86 90 31 38 84 49 58 28 15 80 14 24 87 5... | 1,580,227,044 | 2,147,483,647 | Python 3 | OK | TESTS | 83 | 124 | 307,200 | a=lambda:map(int,input().split());b,c=a();print(min(c//i for i in sorted(list(a()),reverse=True) if c%i==0)) | Title: Garden
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Luba thinks about watering her garden. The garden can be represented as a segment of length *k*. Luba has got *n* buckets, the *i*-th bucket allows her to water some continuous subsegment of garden of length exactly *a**i* each ... | ```python
a=lambda:map(int,input().split());b,c=a();print(min(c//i for i in sorted(list(a()),reverse=True) if c%i==0))
``` | 3 | |
58 | A | Chat room | PROGRAMMING | 1,000 | [
"greedy",
"strings"
] | A. Chat room | 1 | 256 | Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, ... | The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters. | If Vasya managed to say hello, print "YES", otherwise print "NO". | [
"ahhellllloou\n",
"hlelo\n"
] | [
"YES\n",
"NO\n"
] | none | 500 | [
{
"input": "ahhellllloou",
"output": "YES"
},
{
"input": "hlelo",
"output": "NO"
},
{
"input": "helhcludoo",
"output": "YES"
},
{
"input": "hehwelloho",
"output": "YES"
},
{
"input": "pnnepelqomhhheollvlo",
"output": "YES"
},
{
"input": "tymbzjyqhymeda... | 1,665,252,046 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 40 | 62 | 0 | s=input()
x=list(s)
y=["h","e","l","l","o"]
for i in range(len(x)):
if x[i]==y[0]:
y.pop(0)
if len(y)==0:
break
if len(y)==0:
print("YES")
else:
print("NO") | Title: Chat room
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letter... | ```python
s=input()
x=list(s)
y=["h","e","l","l","o"]
for i in range(len(x)):
if x[i]==y[0]:
y.pop(0)
if len(y)==0:
break
if len(y)==0:
print("YES")
else:
print("NO")
``` | 3.969 |
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.... | 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... | 1,548,855,963 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 248 | 0 | inp=input()
inp1=input()
inp2=inp[::-1]
if inp1==inp2:
print('YES')
else:
print('NO')
| 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 pron... | ```python
inp=input()
inp1=input()
inp2=inp[::-1]
if inp1==inp2:
print('YES')
else:
print('NO')
``` | 3.938 |
748 | A | Santa Claus and a Place in a Class | PROGRAMMING | 800 | [
"implementation",
"math"
] | null | null | Santa Claus is the first who came to the Christmas Olympiad, and he is going to be the first to take his place at a desk! In the classroom there are *n* lanes of *m* desks each, and there are two working places at each of the desks. The lanes are numbered from 1 to *n* from the left to the right, the desks in a lane ar... | The only line contains three integers *n*, *m* and *k* (1<=β€<=*n*,<=*m*<=β€<=10<=000, 1<=β€<=*k*<=β€<=2*nm*)Β β the number of lanes, the number of desks in each lane and the number of Santa Claus' place. | Print two integers: the number of lane *r*, the number of desk *d*, and a character *s*, which stands for the side of the desk Santa Claus. The character *s* should be "L", if Santa Clause should sit on the left, and "R" if his place is on the right. | [
"4 3 9\n",
"4 3 24\n",
"2 4 4\n"
] | [
"2 2 L\n",
"4 3 R\n",
"1 2 R\n"
] | The first and the second samples are shown on the picture. The green place corresponds to Santa Claus' place in the first example, the blue place corresponds to Santa Claus' place in the second example.
In the third sample there are two lanes with four desks in each, and Santa Claus has the fourth place. Thus, his pla... | 500 | [
{
"input": "4 3 9",
"output": "2 2 L"
},
{
"input": "4 3 24",
"output": "4 3 R"
},
{
"input": "2 4 4",
"output": "1 2 R"
},
{
"input": "3 10 24",
"output": "2 2 R"
},
{
"input": "10 3 59",
"output": "10 3 L"
},
{
"input": "10000 10000 160845880",
"... | 1,640,761,240 | 2,147,483,647 | Python 3 | OK | TESTS | 46 | 46 | 0 | n,m,k = map(int,input().split())
a,b,c = 0,0,0
if(k%2==1):
c = 'L'
if(k%2==0):
c = 'R'
for i in range(1,n+1):
if(2*i*m>=k):
a = i
break
tot = a*m*2
b = m - int((tot - k)//2)
print(a,b,c)
"""
k = 24
a = 4
b = ((24-6)%(3*3*2))+1 = 18%18
""" | Title: Santa Claus and a Place in a Class
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Santa Claus is the first who came to the Christmas Olympiad, and he is going to be the first to take his place at a desk! In the classroom there are *n* lanes of *m* desks each, and there are two work... | ```python
n,m,k = map(int,input().split())
a,b,c = 0,0,0
if(k%2==1):
c = 'L'
if(k%2==0):
c = 'R'
for i in range(1,n+1):
if(2*i*m>=k):
a = i
break
tot = a*m*2
b = m - int((tot - k)//2)
print(a,b,c)
"""
k = 24
a = 4
b = ((24-6)%(3*3*2))+1 = 18%18
"""
``` | 3 | |
593 | A | 2Char | PROGRAMMING | 1,200 | [
"brute force",
"implementation"
] | null | null | Andrew often reads articles in his favorite magazine 2Char. The main feature of these articles is that each of them uses at most two distinct letters. Andrew decided to send an article to the magazine, but as he hasn't written any article, he just decided to take a random one from magazine 26Char. However, before sendi... | The first line of the input contains number *n* (1<=β€<=*n*<=β€<=100)Β β the number of words in the article chosen by Andrew. Following are *n* lines, each of them contains one word. All the words consist only of small English letters and their total length doesn't exceed 1000. The words are not guaranteed to be distinct,... | Print a single integerΒ β the maximum possible total length of words in Andrew's article. | [
"4\nabb\ncacc\naaa\nbbb\n",
"5\na\na\nbcbcb\ncdecdecdecdecdecde\naaaa\n"
] | [
"9",
"6"
] | In the first sample the optimal way to choose words is {'abb', 'aaa', 'bbb'}.
In the second sample the word 'cdecdecdecdecdecde' consists of three distinct letters, and thus cannot be used in the article. The optimal answer is {'a', 'a', 'aaaa'}. | 250 | [
{
"input": "4\nabb\ncacc\naaa\nbbb",
"output": "9"
},
{
"input": "5\na\na\nbcbcb\ncdecdecdecdecdecde\naaaa",
"output": "6"
},
{
"input": "1\na",
"output": "1"
},
{
"input": "2\nz\nz",
"output": "2"
},
{
"input": "5\nabcde\nfghij\nklmno\npqrst\nuvwxy",
"output"... | 1,698,785,173 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 49 | 77 | 3,276,800 | n = int(input())
words = [input().strip() for _ in range(n)]
max_length = 0
for char1 in 'abcdefghijklmnopqrstuvwxyz':
for char2 in 'abcdefghijklmnopqrstuvwxyz':
current_length = 0
for word in words:
valid = True
for letter in word:
if letter != c... | Title: 2Char
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Andrew often reads articles in his favorite magazine 2Char. The main feature of these articles is that each of them uses at most two distinct letters. Andrew decided to send an article to the magazine, but as he hasn't written an... | ```python
n = int(input())
words = [input().strip() for _ in range(n)]
max_length = 0
for char1 in 'abcdefghijklmnopqrstuvwxyz':
for char2 in 'abcdefghijklmnopqrstuvwxyz':
current_length = 0
for word in words:
valid = True
for letter in word:
if l... | 3 | |
143 | A | Help Vasilisa the Wise 2 | PROGRAMMING | 1,000 | [
"brute force",
"math"
] | null | null | Vasilisa the Wise from the Kingdom of Far Far Away got a magic box with a secret as a present from her friend Hellawisa the Wise from the Kingdom of A Little Closer. However, Vasilisa the Wise does not know what the box's secret is, since she cannot open it again. She hopes that you will help her one more time with tha... | The input contains numbers written on the edges of the lock of the box. The first line contains space-separated integers *r*1 and *r*2 that define the required sums of numbers in the rows of the square. The second line contains space-separated integers *c*1 and *c*2 that define the required sums of numbers in the colum... | Print the scheme of decorating the box with stones: two lines containing two space-separated integers from 1 to 9. The numbers should be pairwise different. If there is no solution for the given lock, then print the single number "-1" (without the quotes).
If there are several solutions, output any. | [
"3 7\n4 6\n5 5\n",
"11 10\n13 8\n5 16\n",
"1 2\n3 4\n5 6\n",
"10 10\n10 10\n10 10\n"
] | [
"1 2\n3 4\n",
"4 7\n9 1\n",
"-1\n",
"-1\n"
] | Pay attention to the last test from the statement: it is impossible to open the box because for that Vasilisa the Wise would need 4 identical gems containing number "5". However, Vasilisa only has one gem with each number from 1 to 9. | 500 | [
{
"input": "3 7\n4 6\n5 5",
"output": "1 2\n3 4"
},
{
"input": "11 10\n13 8\n5 16",
"output": "4 7\n9 1"
},
{
"input": "1 2\n3 4\n5 6",
"output": "-1"
},
{
"input": "10 10\n10 10\n10 10",
"output": "-1"
},
{
"input": "5 13\n8 10\n11 7",
"output": "3 2\n5 8"
... | 1,674,554,530 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 52 | 124 | 1,945,600 | r1,r2 = map(int,input().split())
c1,c2 = map(int,input().split())
d1,d2 = map(int,input().split())
for i in range(1,10):
for j in range(1,10):
for k in range(1,10):
for z in range(1,10):
if i+j==r1 and i+k==c1 and i+z==d1 and j+k==d2 and j+z==c2 and k+z==r2:
... | Title: Help Vasilisa the Wise 2
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasilisa the Wise from the Kingdom of Far Far Away got a magic box with a secret as a present from her friend Hellawisa the Wise from the Kingdom of A Little Closer. However, Vasilisa the Wise does not know wha... | ```python
r1,r2 = map(int,input().split())
c1,c2 = map(int,input().split())
d1,d2 = map(int,input().split())
for i in range(1,10):
for j in range(1,10):
for k in range(1,10):
for z in range(1,10):
if i+j==r1 and i+k==c1 and i+z==d1 and j+k==d2 and j+z==c2 and k+z==r2:
... | 3 | |
954 | B | String Typing | PROGRAMMING | 1,400 | [
"implementation",
"strings"
] | null | null | You are given a string *s* consisting of *n* lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
- add a character to the end of the string.
Besides, at most once you may perform one... | The first line of the input containing only one integer number *n* (1<=β€<=*n*<=β€<=100)Β β the length of the string you have to type. The second line containing the string *s* consisting of *n* lowercase Latin letters. | Print one integer numberΒ β the minimum number of operations you need to type the given string. | [
"7\nabcabca\n",
"8\nabcdefgh\n"
] | [
"5\n",
"8\n"
] | The first test described in the problem statement.
In the second test you can only type all the characters one by one. | 0 | [
{
"input": "7\nabcabca",
"output": "5"
},
{
"input": "8\nabcdefgh",
"output": "8"
},
{
"input": "100\nmhnzadklojbuumkrxjayikjhwuxihgkinllackcavhjpxlydxcmhnzadklojbuumkrxjayikjhwuxihgkinllackcavhjpxlydxc",
"output": "51"
},
{
"input": "99\ntrolnjmzxxrfxuexcqpjvefndwuxwsukxwmjh... | 1,659,649,618 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 148 | 77 | 0 | import sys
input = sys.stdin.readline
n = int(input())
s = input()[:-1]
c = 1
for i in range(1, n//2+1):
if s[:i] == s[i:i+i]:
c = i
print(n-c+1) | Title: String Typing
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a string *s* consisting of *n* lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following ... | ```python
import sys
input = sys.stdin.readline
n = int(input())
s = input()[:-1]
c = 1
for i in range(1, n//2+1):
if s[:i] == s[i:i+i]:
c = i
print(n-c+1)
``` | 3 | |
583 | A | Asphalting Roads | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | City X consists of *n* vertical and *n* horizontal infinite roads, forming *n*<=Γ<=*n* intersections. Roads (both vertical and horizontal) are numbered from 1 to *n*, and the intersections are indicated by the numbers of the roads that form them.
Sand roads have long been recognized out of date, so the decision was ma... | The first line contains integer *n* (1<=β€<=*n*<=β€<=50) β the number of vertical and horizontal roads in the city.
Next *n*2 lines contain the order of intersections in the schedule. The *i*-th of them contains two numbers *h**i*,<=*v**i* (1<=β€<=*h**i*,<=*v**i*<=β€<=*n*), separated by a space, and meaning that the inte... | In the single line print the numbers of the days when road works will be in progress in ascending order. The days are numbered starting from 1. | [
"2\n1 1\n1 2\n2 1\n2 2\n",
"1\n1 1\n"
] | [
"1 4 \n",
"1 \n"
] | In the sample the brigade acts like that:
1. On the first day the brigade comes to the intersection of the 1-st horizontal and the 1-st vertical road. As none of them has been asphalted, the workers asphalt the 1-st vertical and the 1-st horizontal road; 1. On the second day the brigade of the workers comes to the i... | 500 | [
{
"input": "2\n1 1\n1 2\n2 1\n2 2",
"output": "1 4 "
},
{
"input": "1\n1 1",
"output": "1 "
},
{
"input": "2\n1 1\n2 2\n1 2\n2 1",
"output": "1 2 "
},
{
"input": "2\n1 2\n2 2\n2 1\n1 1",
"output": "1 3 "
},
{
"input": "3\n2 2\n1 2\n3 2\n3 3\n1 1\n2 3\n1 3\n3 1\n2 ... | 1,523,093,671 | 2,147,483,647 | PyPy 3 | OK | TESTS | 39 | 202 | 23,142,400 | n = int(input())
r = [False]*n
l = [False]*n
c = ''
for i in range(n*n):
k, m= [int(i) for i in input().split()]
if not r[k - 1] and not l[m - 1]:
r[k - 1] = True
l[m - 1] = True
c += str(i + 1) + ' '
print(c) | Title: Asphalting Roads
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
City X consists of *n* vertical and *n* horizontal infinite roads, forming *n*<=Γ<=*n* intersections. Roads (both vertical and horizontal) are numbered from 1 to *n*, and the intersections are indicated by the numbers ... | ```python
n = int(input())
r = [False]*n
l = [False]*n
c = ''
for i in range(n*n):
k, m= [int(i) for i in input().split()]
if not r[k - 1] and not l[m - 1]:
r[k - 1] = True
l[m - 1] = True
c += str(i + 1) + ' '
print(c)
``` | 3 | |
958 | E1 | Guard Duty (easy) | PROGRAMMING | 1,600 | [
"brute force",
"geometry",
"greedy",
"math"
] | null | null | The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign *R* Rebel spaceships to guard *B* bases so that every base has exactly one guardian and each spaceship has exactly one assigned base (in other words, the assignment is a perfect matching).... | The first line contains two space-separated integers *R*,<=*B*(1<=β€<=*R*,<=*B*<=β€<=10). For 1<=β€<=*i*<=β€<=*R*, the *i*<=+<=1-th line contains two space-separated integers *x**i* and *y**i* (|*x**i*|,<=|*y**i*|<=β€<=10000) denoting the coordinates of the *i*-th Rebel spaceship. The following *B* lines have the same forma... | If it is possible to connect Rebel spaceships and bases so as satisfy the constraint, output Yes, otherwise output No (without quote). | [
"3 3\n0 0\n2 0\n3 1\n-2 1\n0 3\n2 2\n",
"2 1\n1 0\n2 2\n3 1\n"
] | [
"Yes\n",
"No\n"
] | For the first example, one possible way is to connect the Rebels and bases in order.
For the second example, there is no perfect matching between Rebels and bases. | 0 | [
{
"input": "3 3\n0 0\n2 0\n3 1\n-2 1\n0 3\n2 2",
"output": "Yes"
},
{
"input": "2 1\n1 0\n2 2\n3 1",
"output": "No"
},
{
"input": "1 1\n3686 4362\n-7485 5112",
"output": "Yes"
},
{
"input": "1 2\n1152 -7324\n-5137 -35\n-6045 -5271",
"output": "No"
},
{
"input": "1... | 1,523,693,135 | 3,635 | PyPy 3 | OK | TESTS | 51 | 233 | 26,009,600 | def ccw(A, B, C):
return (C[1] - A[1]) * (B[0] - A[0]) > (B[1] - A[1]) * (C[0] - A[0])
def intersect(A, B, C, D):
return ccw(A, C, D) != ccw(B, C, D) and ccw(A, B, C) != ccw(A, B, D)
R, B = map(int, input().split())
rs = []
bs = []
for r in range(R):
rs.append(list(map(int, input().split())))
for r in ... | Title: Guard Duty (easy)
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Rebel fleet is afraid that the Empire might want to strike back again. Princess Heidi needs to know if it is possible to assign *R* Rebel spaceships to guard *B* bases so that every base has exactly one guardian a... | ```python
def ccw(A, B, C):
return (C[1] - A[1]) * (B[0] - A[0]) > (B[1] - A[1]) * (C[0] - A[0])
def intersect(A, B, C, D):
return ccw(A, C, D) != ccw(B, C, D) and ccw(A, B, C) != ccw(A, B, D)
R, B = map(int, input().split())
rs = []
bs = []
for r in range(R):
rs.append(list(map(int, input().split())))... | 3 | |
965 | A | Paper Airplanes | PROGRAMMING | 800 | [
"math"
] | null | null | To make a paper airplane, one has to use a rectangular piece of paper. From a sheet of standard size you can make $s$ airplanes.
A group of $k$ people decided to make $n$ airplanes each. They are going to buy several packs of paper, each of them containing $p$ sheets, and then distribute the sheets between the people.... | The only line contains four integers $k$, $n$, $s$, $p$ ($1 \le k, n, s, p \le 10^4$)Β β the number of people, the number of airplanes each should make, the number of airplanes that can be made using one sheet and the number of sheets in one pack, respectively. | Print a single integerΒ β the minimum number of packs they should buy. | [
"5 3 2 3\n",
"5 3 100 1\n"
] | [
"4\n",
"5\n"
] | In the first sample they have to buy $4$ packs of paper: there will be $12$ sheets in total, and giving $2$ sheets to each person is enough to suit everyone's needs.
In the second sample they have to buy a pack for each person as they can't share sheets. | 500 | [
{
"input": "5 3 2 3",
"output": "4"
},
{
"input": "5 3 100 1",
"output": "5"
},
{
"input": "10000 10000 1 1",
"output": "100000000"
},
{
"input": "1 1 10000 10000",
"output": "1"
},
{
"input": "300 300 21 23",
"output": "196"
},
{
"input": "300 2 37 51... | 1,548,683,957 | 2,147,483,647 | Python 3 | OK | TESTS | 18 | 108 | 0 | from math import ceil
X = list(map(int, input().split()))
Math = ceil(X[1] / X[2])
Math = ceil(Math * X[0])
print(ceil(Math / X[3]))
| Title: Paper Airplanes
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
To make a paper airplane, one has to use a rectangular piece of paper. From a sheet of standard size you can make $s$ airplanes.
A group of $k$ people decided to make $n$ airplanes each. They are going to buy several p... | ```python
from math import ceil
X = list(map(int, input().split()))
Math = ceil(X[1] / X[2])
Math = ceil(Math * X[0])
print(ceil(Math / X[3]))
``` | 3 | |
767 | A | Snacktower | PROGRAMMING | 1,100 | [
"data structures",
"implementation"
] | null | null | According to an old legeng, a long time ago Ankh-Morpork residents did something wrong to miss Fortune, and she cursed them. She said that at some time *n* snacks of distinct sizes will fall on the city, and the residents should build a Snacktower of them by placing snacks one on another. Of course, big snacks should b... | The first line contains single integer *n* (1<=β€<=*n*<=β€<=100<=000)Β β the total number of snacks.
The second line contains *n* integers, the *i*-th of them equals the size of the snack which fell on the *i*-th day. Sizes are distinct integers from 1 to *n*. | Print *n* lines. On the *i*-th of them print the sizes of the snacks which the residents placed on the top of the Snacktower on the *i*-th day in the order they will do that. If no snack is placed on some day, leave the corresponding line empty. | [
"3\n3 1 2\n",
"5\n4 5 1 2 3\n"
] | [
"3\nΒ \n2 1",
"5 4\nΒ \nΒ \n3 2 1\n"
] | In the example a snack of size 3 fell on the first day, and the residents immediately placed it. On the second day a snack of size 1 fell, and the residents weren't able to place it because they were missing the snack of size 2. On the third day a snack of size 2 fell, and the residents immediately placed it. Right aft... | 500 | [
{
"input": "3\n3 1 2",
"output": "3 \n\n2 1 "
},
{
"input": "5\n4 5 1 2 3",
"output": "5 4 \n\n\n3 2 1 "
},
{
"input": "1\n1",
"output": "1 "
},
{
"input": "2\n1 2",
"output": "2 1 "
},
{
"input": "10\n5 1 6 2 8 3 4 10 9 7",
"output": "10 \n9 8 \n7 6 5 4 3 2 1... | 1,595,654,506 | 2,147,483,647 | Python 3 | OK | TESTS | 25 | 389 | 17,817,600 | import sys
import heapq
def main(arr):
visited = [False] * len(arr)
last = len(visited) - 1
for n in arr:
visited[n - 1] = True
doing = []
while last >= 0 and visited[last]:
doing.append(last + 1)
last -= 1
print(" ".join(str(d) for d in doing))
if... | Title: Snacktower
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
According to an old legeng, a long time ago Ankh-Morpork residents did something wrong to miss Fortune, and she cursed them. She said that at some time *n* snacks of distinct sizes will fall on the city, and the residents sh... | ```python
import sys
import heapq
def main(arr):
visited = [False] * len(arr)
last = len(visited) - 1
for n in arr:
visited[n - 1] = True
doing = []
while last >= 0 and visited[last]:
doing.append(last + 1)
last -= 1
print(" ".join(str(d) for d in d... | 3 | |
466 | A | Cheap Travel | PROGRAMMING | 1,200 | [
"implementation"
] | null | null | Ann has recently started commuting by subway. We know that a one ride subway ticket costs *a* rubles. Besides, Ann found out that she can buy a special ticket for *m* rides (she can buy it several times). It costs *b* rubles. Ann did the math; she will need to use subway *n* times. Help Ann, tell her what is the minimu... | The single line contains four space-separated integers *n*, *m*, *a*, *b* (1<=β€<=*n*,<=*m*,<=*a*,<=*b*<=β€<=1000) β the number of rides Ann has planned, the number of rides covered by the *m* ride ticket, the price of a one ride ticket and the price of an *m* ride ticket. | Print a single integer β the minimum sum in rubles that Ann will need to spend. | [
"6 2 1 2\n",
"5 2 2 3\n"
] | [
"6\n",
"8\n"
] | In the first sample one of the optimal solutions is: each time buy a one ride ticket. There are other optimal solutions. For example, buy three *m* ride tickets. | 500 | [
{
"input": "6 2 1 2",
"output": "6"
},
{
"input": "5 2 2 3",
"output": "8"
},
{
"input": "10 3 5 1",
"output": "4"
},
{
"input": "1000 1 1000 1000",
"output": "1000000"
},
{
"input": "1000 3 1000 1000",
"output": "334000"
},
{
"input": "1 1 1 1",
"... | 1,693,628,928 | 2,147,483,647 | Python 3 | OK | TESTS | 19 | 46 | 0 | import math
numbers = input('')
numbers = numbers.split(' ')
numbers = [int(i) for i in numbers]
n = numbers[0]
m = numbers[1]
a = numbers[2]
b = numbers[3]
without_special = n * a
with_special = ((math.ceil(n / m) * m) / m) * b
hybrid = (math.floor(n / m) * b) + ((n % m) * a)
print(int(min(without_s... | Title: Cheap Travel
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Ann has recently started commuting by subway. We know that a one ride subway ticket costs *a* rubles. Besides, Ann found out that she can buy a special ticket for *m* rides (she can buy it several times). It costs *b* rubl... | ```python
import math
numbers = input('')
numbers = numbers.split(' ')
numbers = [int(i) for i in numbers]
n = numbers[0]
m = numbers[1]
a = numbers[2]
b = numbers[3]
without_special = n * a
with_special = ((math.ceil(n / m) * m) / m) * b
hybrid = (math.floor(n / m) * b) + ((n % m) * a)
print(int(min... | 3 | |
985 | B | Switches and Lamps | PROGRAMMING | 1,200 | [
"implementation"
] | null | null | You are given *n* switches and *m* lamps. The *i*-th switch turns on some subset of the lamps. This information is given as the matrix *a* consisting of *n* rows and *m* columns where *a**i*,<=*j*<==<=1 if the *i*-th switch turns on the *j*-th lamp and *a**i*,<=*j*<==<=0 if the *i*-th switch is not connected to the *j*... | The first line of the input contains two integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=2000) β the number of the switches and the number of the lamps.
The following *n* lines contain *m* characters each. The character *a**i*,<=*j* is equal to '1' if the *i*-th switch turns on the *j*-th lamp and '0' otherwise.
It is guar... | Print "YES" if there is a switch that if you will ignore it and press all the other *n*<=-<=1 switches then all *m* lamps will be turned on. Print "NO" if there is no such switch. | [
"4 5\n10101\n01000\n00111\n10000\n",
"4 5\n10100\n01000\n00110\n00101\n"
] | [
"YES\n",
"NO\n"
] | none | 0 | [
{
"input": "4 5\n10101\n01000\n00111\n10000",
"output": "YES"
},
{
"input": "4 5\n10100\n01000\n00110\n00101",
"output": "NO"
},
{
"input": "1 5\n11111",
"output": "NO"
},
{
"input": "10 1\n1\n0\n0\n0\n0\n0\n0\n0\n0\n1",
"output": "YES"
},
{
"input": "1 1\n1",
... | 1,526,985,800 | 2,147,483,647 | Python 3 | OK | TESTS | 67 | 2,698 | 18,636,800 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon May 21 22:31:07 2018
@author: thomas
"""
integers=input()
[n,m]=[int(x) for x in integers.split()]
a=[]
for i in range(n):
row_i=input()
a_i=[]
for j in range(m):
a_i.append(int(row_i[j]))
a.append(a_i)
indicator=False
#all_... | Title: Switches and Lamps
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given *n* switches and *m* lamps. The *i*-th switch turns on some subset of the lamps. This information is given as the matrix *a* consisting of *n* rows and *m* columns where *a**i*,<=*j*<==<=1 if the *i*-th... | ```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon May 21 22:31:07 2018
@author: thomas
"""
integers=input()
[n,m]=[int(x) for x in integers.split()]
a=[]
for i in range(n):
row_i=input()
a_i=[]
for j in range(m):
a_i.append(int(row_i[j]))
a.append(a_i)
indicator=F... | 3 | |
940 | B | Our Tanya is Crying Out Loud | PROGRAMMING | 1,400 | [
"dp",
"greedy"
] | null | null | Right now she actually isn't. But she will be, if you don't solve this problem.
You are given integers *n*, *k*, *A* and *B*. There is a number *x*, which is initially equal to *n*. You are allowed to perform two types of operations:
1. Subtract 1 from *x*. This operation costs you *A* coins. 1. Divide *x* by *k*.... | The first line contains a single integer *n* (1<=β€<=*n*<=β€<=2Β·109).
The second line contains a single integer *k* (1<=β€<=*k*<=β€<=2Β·109).
The third line contains a single integer *A* (1<=β€<=*A*<=β€<=2Β·109).
The fourth line contains a single integer *B* (1<=β€<=*B*<=β€<=2Β·109). | Output a single integerΒ β the minimum amount of coins you have to pay to make *x* equal to 1. | [
"9\n2\n3\n1\n",
"5\n5\n2\n20\n",
"19\n3\n4\n2\n"
] | [
"6\n",
"8\n",
"12\n"
] | In the first testcase, the optimal strategy is as follows:
- Subtract 1 from *x* (9βββ8) paying 3 coins. - Divide *x* by 2 (8βββ4) paying 1 coin. - Divide *x* by 2 (4βββ2) paying 1 coin. - Divide *x* by 2 (2βββ1) paying 1 coin.
The total cost is 6 coins.
In the second test case the optimal strategy is to subtra... | 1,250 | [
{
"input": "9\n2\n3\n1",
"output": "6"
},
{
"input": "5\n5\n2\n20",
"output": "8"
},
{
"input": "19\n3\n4\n2",
"output": "12"
},
{
"input": "1845999546\n999435865\n1234234\n2323423",
"output": "1044857680578777"
},
{
"input": "1604353664\n1604353665\n9993432\n1",
... | 1,618,682,481 | 2,147,483,647 | PyPy 3 | OK | TESTS | 58 | 93 | 102,400 | n=int(input())
k=int(input())
a=int(input())
b=int(input())
if(k==1):
print ((n-1)*a)
else:
t=(b*k)/(a*(k-1))
ans=n
c=0
while(ans>1):
if(ans>=t and ans%k==0):
c+=b
ans=ans//k
else:
if(ans>=t and ans>k):
h=ans%k
... | Title: Our Tanya is Crying Out Loud
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Right now she actually isn't. But she will be, if you don't solve this problem.
You are given integers *n*, *k*, *A* and *B*. There is a number *x*, which is initially equal to *n*. You are allowed to perf... | ```python
n=int(input())
k=int(input())
a=int(input())
b=int(input())
if(k==1):
print ((n-1)*a)
else:
t=(b*k)/(a*(k-1))
ans=n
c=0
while(ans>1):
if(ans>=t and ans%k==0):
c+=b
ans=ans//k
else:
if(ans>=t and ans>k):
h=a... | 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"
},
... | 1,521,676,691 | 2,147,483,647 | PyPy 3 | OK | TESTS | 23 | 278 | 23,142,400 | a,p = [],[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439... | 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*, in... | ```python
a,p = [],[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,4... | 3.887394 |
614 | A | Link/Cut Tree | PROGRAMMING | 1,500 | [
"brute force",
"implementation"
] | null | null | Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the *expose* procedure.
Unfortunately, Rostislav is unable to understand the definition of this procedure, so he decided to ask programmer Serezha to help him. Serezha agre... | The first line of the input contains three space-separated integers *l*, *r* and *k* (1<=β€<=*l*<=β€<=*r*<=β€<=1018, 2<=β€<=*k*<=β€<=109). | Print all powers of number *k*, that lie within range from *l* to *r* in the increasing order. If there are no such numbers, print "-1" (without the quotes). | [
"1 10 2\n",
"2 4 5\n"
] | [
"1 2 4 8 ",
"-1"
] | Note to the first sample: numbers 2<sup class="upper-index">0</sup>β=β1, 2<sup class="upper-index">1</sup>β=β2, 2<sup class="upper-index">2</sup>β=β4, 2<sup class="upper-index">3</sup>β=β8 lie within the specified range. The number 2<sup class="upper-index">4</sup>β=β16 is greater then 10, thus it shouldn't be printed. | 500 | [
{
"input": "1 10 2",
"output": "1 2 4 8 "
},
{
"input": "2 4 5",
"output": "-1"
},
{
"input": "18102 43332383920 28554",
"output": "28554 815330916 "
},
{
"input": "19562 31702689720 17701",
"output": "313325401 "
},
{
"input": "11729 55221128400 313",
"output... | 1,453,543,279 | 2,147,483,647 | PyPy 3 | OK | TESTS | 44 | 140 | 0 | def x():
l, r, k = [int(s) for s in input().split()]
res = k
if l == 1:
yield 1
while k<=r:
if l <= k <= r:
yield k
k*=res
if k>r:
break
d = [i for i in x()]
if len(d):
print(*d)
else:
print(-1)
| Title: Link/Cut Tree
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the *expose* procedure.
Unfortunately, Rostislav is unable to understand ... | ```python
def x():
l, r, k = [int(s) for s in input().split()]
res = k
if l == 1:
yield 1
while k<=r:
if l <= k <= r:
yield k
k*=res
if k>r:
break
d = [i for i in x()]
if len(d):
print(*d)
else:
print(-1)
``` | 3 | |
747 | A | Display Size | PROGRAMMING | 800 | [
"brute force",
"math"
] | null | null | A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly *n* pixels.
Your task is to determine the size of the rectangular display β the number of lines (rows) of pixels *a* and the number of columns of pixels *b*, so that:
- there are exactly *n* pixels o... | The first line contains the positive integer *n* (1<=β€<=*n*<=β€<=106)Β β the number of pixels display should have. | Print two integersΒ β the number of rows and columns on the display. | [
"8\n",
"64\n",
"5\n",
"999999\n"
] | [
"2 4\n",
"8 8\n",
"1 5\n",
"999 1001\n"
] | In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 ro... | 500 | [
{
"input": "8",
"output": "2 4"
},
{
"input": "64",
"output": "8 8"
},
{
"input": "5",
"output": "1 5"
},
{
"input": "999999",
"output": "999 1001"
},
{
"input": "716539",
"output": "97 7387"
},
{
"input": "1",
"output": "1 1"
},
{
"input":... | 1,482,300,745 | 2,147,483,647 | Python 3 | OK | TESTS | 43 | 62 | 4,608,000 | n = int(input())
i = 1
ans = 1
while i*i<=n:
if n%i==0 : ans = i
i+=1
print (ans, n//ans)
| Title: Display Size
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly *n* pixels.
Your task is to determine the size of the rectangular display β the number of lines (rows) ... | ```python
n = int(input())
i = 1
ans = 1
while i*i<=n:
if n%i==0 : ans = i
i+=1
print (ans, n//ans)
``` | 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... | 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"... | 1,673,424,413 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 20 | 62 | 0 | n, m, a = map(int, input().split())
row, col = (n//a) + 1 if n % a else (n//a), (m//a) + 1 if m % a else (m//a)
print(row*col)
| 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 ... | ```python
n, m, a = map(int, input().split())
row, col = (n//a) + 1 if n % a else (n//a), (m//a) + 1 if m % a else (m//a)
print(row*col)
``` | 3.969 |
887 | B | Cubes for Masha | PROGRAMMING | 1,300 | [
"brute force",
"implementation"
] | null | null | Absent-minded Masha got set of *n* cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural *x* such she can make using her new cubes all integers from 1 to *x*.
To make a number Masha can rotate her cubes and put them in a ro... | In first line integer *n* is given (1<=β€<=*n*<=β€<=3)Β β the number of cubes, Masha got for her birthday.
Each of next *n* lines contains 6 integers *a**i**j* (0<=β€<=*a**i**j*<=β€<=9)Β β number on *j*-th face of *i*-th cube. | Print single integerΒ β maximum number *x* such Masha can make any integers from 1 to *x* using her cubes or 0 if Masha can't make even 1. | [
"3\n0 1 2 3 4 5\n6 7 8 9 0 1\n2 3 4 5 6 7\n",
"3\n0 1 3 5 6 8\n1 2 4 5 7 8\n2 3 4 6 7 9\n"
] | [
"87",
"98"
] | In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8. | 1,000 | [
{
"input": "3\n0 1 2 3 4 5\n6 7 8 9 0 1\n2 3 4 5 6 7",
"output": "87"
},
{
"input": "3\n0 1 3 5 6 8\n1 2 4 5 7 8\n2 3 4 6 7 9",
"output": "98"
},
{
"input": "3\n0 1 2 3 4 5\n0 1 2 3 4 5\n0 1 2 3 4 5",
"output": "5"
},
{
"input": "3\n1 2 3 7 8 9\n9 8 7 1 2 3\n7 9 2 3 1 8",
... | 1,559,871,883 | 2,147,483,647 | Python 3 | OK | TESTS | 96 | 124 | 307,200 | ##a = list(map(int, input().split()))
##print(' '.join(map(str, res)))
def list_input():
return list(map(int, input().split()))
n = int(input())
c = list()
for i in range(n):
c.append(list_input())
s = set()
for i in range(n):
for x in c[i]:
s.add(x)
if n >= 2:
for i in range(... | Title: Cubes for Masha
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Absent-minded Masha got set of *n* cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural *x* such she can make using her ne... | ```python
##a = list(map(int, input().split()))
##print(' '.join(map(str, res)))
def list_input():
return list(map(int, input().split()))
n = int(input())
c = list()
for i in range(n):
c.append(list_input())
s = set()
for i in range(n):
for x in c[i]:
s.add(x)
if n >= 2:
for i... | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | A new innovative ticketing systems for public transport is introduced in Bytesburg. Now there is a single travel card for all transport. To make a trip a passenger scan his card and then he is charged according to the fare.
The fare is constructed in the following manner. There are three types of tickets:
1. a tick... | The first line of input contains integer number *n* (1<=β€<=*n*<=β€<=105)Β β the number of trips made by passenger.
Each of the following *n* lines contains the time of trip *t**i* (0<=β€<=*t**i*<=β€<=109), measured in minutes from the time of starting the system. All *t**i* are different, given in ascending order, i.Β e. *... | Output *n* integers. For each trip, print the sum the passenger is charged after it. | [
"3\n10\n20\n30\n",
"10\n13\n45\n46\n60\n103\n115\n126\n150\n256\n516\n"
] | [
"20\n20\n10\n",
"20\n20\n10\n0\n20\n0\n0\n20\n20\n10\n"
] | In the first example, the system works as follows: for the first and second trips it is cheaper to pay for two one-trip tickets, so each time 20 rubles is charged, after the third trip the system understands that it would be cheaper to buy a ticket for 90 minutes. This ticket costs 50 rubles, and the passenger had alre... | 0 | [
{
"input": "3\n10\n20\n30",
"output": "20\n20\n10"
},
{
"input": "10\n13\n45\n46\n60\n103\n115\n126\n150\n256\n516",
"output": "20\n20\n10\n0\n20\n0\n0\n20\n20\n10"
},
{
"input": "7\n100\n138\n279\n308\n396\n412\n821",
"output": "20\n20\n20\n20\n20\n20\n0"
},
{
"input": "8\n0... | 1,608,823,111 | 2,147,483,647 | PyPy 3 | OK | TESTS | 31 | 358 | 14,950,400 | from sys import stdin
from bisect import *
rint = lambda: int(stdin.readline())
rint_2d = lambda n: [rint() for _ in range(n)]
n = int(input())
a, mem, out = rint_2d(n), [0] * (n + 1), []
for i in range(n):
vals = [mem[i] + 20]
ix1 = max(bisect_left(a, a[i] - 90 + 1), 0)
vals.append(mem[ix1] + ... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A new innovative ticketing systems for public transport is introduced in Bytesburg. Now there is a single travel card for all transport. To make a trip a passenger scan his card and then he is charged according to the fare.
The f... | ```python
from sys import stdin
from bisect import *
rint = lambda: int(stdin.readline())
rint_2d = lambda n: [rint() for _ in range(n)]
n = int(input())
a, mem, out = rint_2d(n), [0] * (n + 1), []
for i in range(n):
vals = [mem[i] + 20]
ix1 = max(bisect_left(a, a[i] - 90 + 1), 0)
vals.append(m... | 3 | |
92 | A | Chips | PROGRAMMING | 800 | [
"implementation",
"math"
] | A. Chips | 2 | 256 | There are *n* walruses sitting in a circle. All of them are numbered in the clockwise order: the walrus number 2 sits to the left of the walrus number 1, the walrus number 3 sits to the left of the walrus number 2, ..., the walrus number 1 sits to the left of the walrus number *n*.
The presenter has *m* chips. The pre... | The first line contains two integers *n* and *m* (1<=β€<=*n*<=β€<=50, 1<=β€<=*m*<=β€<=104) β the number of walruses and the number of chips correspondingly. | Print the number of chips the presenter ended up with. | [
"4 11\n",
"17 107\n",
"3 8\n"
] | [
"0\n",
"2\n",
"1\n"
] | In the first sample the presenter gives one chip to the walrus number 1, two chips to the walrus number 2, three chips to the walrus number 3, four chips to the walrus number 4, then again one chip to the walrus number 1. After that the presenter runs out of chips. He can't give anything to the walrus number 2 and the ... | 500 | [
{
"input": "4 11",
"output": "0"
},
{
"input": "17 107",
"output": "2"
},
{
"input": "3 8",
"output": "1"
},
{
"input": "46 7262",
"output": "35"
},
{
"input": "32 6864",
"output": "0"
},
{
"input": "36 6218",
"output": "14"
},
{
"input": "... | 1,439,355,268 | 2,147,483,647 | Python 3 | OK | TESTS | 25 | 124 | 0 | s = list(map(int, input().split()))
ind = 0
while(s[1] > 0):
if(s[1] < ind+1):
break
s[1] -= ind+1
ind = (ind+1)%s[0]
print(s[1]) | Title: Chips
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
There are *n* walruses sitting in a circle. All of them are numbered in the clockwise order: the walrus number 2 sits to the left of the walrus number 1, the walrus number 3 sits to the left of the walrus number 2, ..., the walrus nu... | ```python
s = list(map(int, input().split()))
ind = 0
while(s[1] > 0):
if(s[1] < ind+1):
break
s[1] -= ind+1
ind = (ind+1)%s[0]
print(s[1])
``` | 3.969 |
209 | A | Multicolored Marbles | PROGRAMMING | 1,600 | [
"dp",
"math"
] | null | null | Polycarpus plays with red and blue marbles. He put *n* marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are ze... | The first line contains a single integer *n* (1<=β€<=*n*<=β€<=106) β the number of marbles in Polycarpus's sequence. | Print a single number β the answer to the problem modulo 1000000007 (109<=+<=7). | [
"3\n",
"4\n"
] | [
"6\n",
"11\n"
] | Let's consider the first test sample. Let's assume that Polycarpus initially had sequence (red; blue; red), so there are six ways to pick a zebroid:
- pick the first marble; - pick the second marble; - pick the third marble; - pick the first and second marbles; - pick the second and third marbles; - pick the fi... | 500 | [
{
"input": "3",
"output": "6"
},
{
"input": "4",
"output": "11"
},
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "3"
},
{
"input": "5",
"output": "19"
},
{
"input": "6",
"output": "32"
},
{
"input": "7",
"output": "53"
},... | 1,687,893,962 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 50 | 904 | 100,044,800 | import sys
input = lambda: sys.stdin.readline().rstrip()
MOD = 10**9+7
N = int(input())
dp = [[0,0] for _ in range(N+1)]
for i in range(N):
dp[i+1][0]=dp[i][0]
dp[i+1][1]=dp[i][1]
if i%2:
dp[i+1][1]+=dp[i][0]+1
else:
dp[i+1][0]+=dp[i][1]+1
dp[i+1][0]%=MOD
dp[i+1]... | Title: Multicolored Marbles
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarpus plays with red and blue marbles. He put *n* marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the c... | ```python
import sys
input = lambda: sys.stdin.readline().rstrip()
MOD = 10**9+7
N = int(input())
dp = [[0,0] for _ in range(N+1)]
for i in range(N):
dp[i+1][0]=dp[i][0]
dp[i+1][1]=dp[i][1]
if i%2:
dp[i+1][1]+=dp[i][0]+1
else:
dp[i+1][0]+=dp[i][1]+1
dp[i+1][0]%=MOD
... | 3 | |
224 | A | Parallelepiped | PROGRAMMING | 1,100 | [
"brute force",
"geometry",
"math"
] | null | null | You've got a rectangular parallelepiped with integer edge lengths. You know the areas of its three faces that have a common vertex. Your task is to find the sum of lengths of all 12 edges of this parallelepiped. | The first and the single line contains three space-separated integers β the areas of the parallelepiped's faces. The area's values are positive (<=><=0) and do not exceed 104. It is guaranteed that there exists at least one parallelepiped that satisfies the problem statement. | Print a single number β the sum of all edges of the parallelepiped. | [
"1 1 1\n",
"4 6 6\n"
] | [
"12\n",
"28\n"
] | In the first sample the parallelepiped has sizes 1βΓβ1βΓβ1, in the second oneΒ β 2βΓβ2βΓβ3. | 500 | [
{
"input": "1 1 1",
"output": "12"
},
{
"input": "4 6 6",
"output": "28"
},
{
"input": "20 10 50",
"output": "68"
},
{
"input": "9 4 36",
"output": "56"
},
{
"input": "324 9 36",
"output": "184"
},
{
"input": "1333 93 129",
"output": "308"
},
{... | 1,605,953,178 | 2,147,483,647 | PyPy 3 | OK | TESTS | 27 | 468 | 2,355,200 | import sys,os,io,time,copy
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
import math
def is_int(n):
if n//1==n/1:
return True
else:
return False
def main():
# start=time.time()
a,b,c=map(int,input().split... | Title: Parallelepiped
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You've got a rectangular parallelepiped with integer edge lengths. You know the areas of its three faces that have a common vertex. Your task is to find the sum of lengths of all 12 edges of this parallelepiped.
Input S... | ```python
import sys,os,io,time,copy
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
import math
def is_int(n):
if n//1==n/1:
return True
else:
return False
def main():
# start=time.time()
a,b,c=map(int,inp... | 3 | |
772 | B | Volatile Kite | PROGRAMMING | 1,800 | [
"geometry"
] | null | null | You are given a convex polygon *P* with *n* distinct vertices *p*1,<=*p*2,<=...,<=*p**n*. Vertex *p**i* has coordinates (*x**i*,<=*y**i*) in the 2D plane. These vertices are listed in clockwise order.
You can choose a real number *D* and move each vertex of the polygon a distance of at most *D* from their original pos... | The first line has one integer *n* (4<=β€<=*n*<=β€<=1<=000)Β β the number of vertices.
The next *n* lines contain the coordinates of the vertices. Line *i* contains two integers *x**i* and *y**i* (<=-<=109<=β€<=*x**i*,<=*y**i*<=β€<=109)Β β the coordinates of the *i*-th vertex. These points are guaranteed to be given in cloc... | Print one real number *D*, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10<=-<=6.
Namely, let's assume that your answer is *a* and the answer of the jury is *b*. The ch... | [
"4\n0 0\n0 1\n1 1\n1 0\n",
"6\n5 0\n10 0\n12 -4\n10 -8\n5 -8\n3 -4\n"
] | [
"0.3535533906\n",
"1.0000000000\n"
] | Here is a picture of the first sample
<img class="tex-graphics" src="https://espresso.codeforces.com/f83aa076d2f437f9bb785cae769c3ae310eff351.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Here is an example of making the polygon non-convex.
<img class="tex-graphics" src="https://espresso.codeforces.com/fbadb8... | 1,000 | [
{
"input": "4\n0 0\n0 1\n1 1\n1 0",
"output": "0.3535533906"
},
{
"input": "6\n5 0\n10 0\n12 -4\n10 -8\n5 -8\n3 -4",
"output": "1.0000000000"
},
{
"input": "19\n449447997 711296339\n530233434 692216537\n535464528 613140435\n535533467 100893188\n530498867 -265063956\n519107979 -271820709\... | 1,492,381,510 | 2,147,483,647 | Python 3 | OK | TESTS | 36 | 62 | 5,632,000 | from math import inf
def vect(x, y):
return abs(sum([x[i]*(y[(i+1)%3]-y[(i+2)%3]) for i in range(3)]))
def l(x, y):
return ((x[0]-x[2])**2 + (y[0]-y[2])**2)**0.5
def h(x, y):
return vect(x, y) / l(x, y)
n = int(input())
x = []
y = []
for i in range(n):
a, b = [int(x) for x in input().spli... | Title: Volatile Kite
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a convex polygon *P* with *n* distinct vertices *p*1,<=*p*2,<=...,<=*p**n*. Vertex *p**i* has coordinates (*x**i*,<=*y**i*) in the 2D plane. These vertices are listed in clockwise order.
You can choose a re... | ```python
from math import inf
def vect(x, y):
return abs(sum([x[i]*(y[(i+1)%3]-y[(i+2)%3]) for i in range(3)]))
def l(x, y):
return ((x[0]-x[2])**2 + (y[0]-y[2])**2)**0.5
def h(x, y):
return vect(x, y) / l(x, y)
n = int(input())
x = []
y = []
for i in range(n):
a, b = [int(x) for x in in... | 3 | |
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... | 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* Val... | 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... | 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\... | 1,642,666,918 | 2,147,483,647 | Python 3 | OK | TESTS | 63 | 46 | 0 | n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
def solve(n, m, k, a):
cnt = 0
for dish in a:
if dish == 1:
if m > 0:
m -= 1
else:
cnt += 1
else:
if m == 0 and k == 0:
cnt += 1
... | 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, ... | ```python
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
def solve(n, m, k, a):
cnt = 0
for dish in a:
if dish == 1:
if m > 0:
m -= 1
else:
cnt += 1
else:
if m == 0 and k == 0:
c... | 3 | |
96 | A | Football | PROGRAMMING | 900 | [
"implementation",
"strings"
] | A. Football | 2 | 256 | Petya loves football very much. One day, as he was watching a football match, he was writing the players' current positions on a piece of paper. To simplify the situation he depicted it as a string consisting of zeroes and ones. A zero corresponds to players of one team; a one corresponds to players of another team. If... | The first input line contains a non-empty string consisting of characters "0" and "1", which represents players. The length of the string does not exceed 100 characters. There's at least one player from each team present on the field. | Print "YES" if the situation is dangerous. Otherwise, print "NO". | [
"001001\n",
"1000000001\n"
] | [
"NO\n",
"YES\n"
] | none | 500 | [
{
"input": "001001",
"output": "NO"
},
{
"input": "1000000001",
"output": "YES"
},
{
"input": "00100110111111101",
"output": "YES"
},
{
"input": "11110111111111111",
"output": "YES"
},
{
"input": "01",
"output": "NO"
},
{
"input": "10100101",
"outp... | 1,688,282,538 | 2,147,483,647 | Python 3 | OK | TESTS | 44 | 92 | 0 | s = input()
dangerous = False
if '0000000' in s or '1111111' in s:
dangerous = True
if dangerous:
print("YES")
else:
print("NO")
| Title: Football
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Petya loves football very much. One day, as he was watching a football match, he was writing the players' current positions on a piece of paper. To simplify the situation he depicted it as a string consisting of zeroes and ones. A... | ```python
s = input()
dangerous = False
if '0000000' in s or '1111111' in s:
dangerous = True
if dangerous:
print("YES")
else:
print("NO")
``` | 3.977 |
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 ... | 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"... | 1,692,929,643 | 2,147,483,647 | Python 3 | OK | TESTS | 20 | 92 | 0 | def can_divide_watermelon(w):
# If the weight is less than 4, it's not possible to divide it into even parts
if w < 4:
return "NO"
# If the weight is even, it can be divided into two even parts
if w % 2 == 0:
return "YES"
return "NO"
# Read the input
w = int(in... | 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, dyin... | ```python
def can_divide_watermelon(w):
# If the weight is less than 4, it's not possible to divide it into even parts
if w < 4:
return "NO"
# If the weight is even, it can be divided into two even parts
if w % 2 == 0:
return "YES"
return "NO"
# Read the input
... | 3.954 |
573 | A | Bear and Poker | PROGRAMMING | 1,300 | [
"implementation",
"math",
"number theory"
] | null | null | Limak is an old brown bear. He often plays poker with his friends. Today they went to a casino. There are *n* players (including Limak himself) and right now all of them have bids on the table. *i*-th of them has bid with size *a**i* dollars.
Each player can double his bid any number of times and triple his bid any nu... | First line of input contains an integer *n* (2<=β€<=*n*<=β€<=105), the number of players.
The second line contains *n* integer numbers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=109) β the bids of players. | Print "Yes" (without the quotes) if players can make their bids become equal, or "No" otherwise. | [
"4\n75 150 75 50\n",
"3\n100 150 250\n"
] | [
"Yes\n",
"No\n"
] | In the first sample test first and third players should double their bids twice, second player should double his bid once and fourth player should both double and triple his bid.
It can be shown that in the second sample test there is no way to make all bids equal. | 500 | [
{
"input": "4\n75 150 75 50",
"output": "Yes"
},
{
"input": "3\n100 150 250",
"output": "No"
},
{
"input": "7\n34 34 68 34 34 68 34",
"output": "Yes"
},
{
"input": "10\n72 96 12 18 81 20 6 2 54 1",
"output": "No"
},
{
"input": "20\n958692492 954966768 77387000 724... | 1,668,173,679 | 2,147,483,647 | Python 3 | OK | TESTS | 70 | 639 | 8,806,400 | n = int(input())
l = list(map(int, input().split()))
for i in range(n):
while(l[i]%2 == 0):
l[i] //= 2
for i in range(n):
while(l[i]%3 == 0):
l[i] //= 3
c = l.count(l[0])
if(c == n):
print("YES")
else:
print("NO") | Title: Bear and Poker
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Limak is an old brown bear. He often plays poker with his friends. Today they went to a casino. There are *n* players (including Limak himself) and right now all of them have bids on the table. *i*-th of them has bid wit... | ```python
n = int(input())
l = list(map(int, input().split()))
for i in range(n):
while(l[i]%2 == 0):
l[i] //= 2
for i in range(n):
while(l[i]%3 == 0):
l[i] //= 3
c = l.count(l[0])
if(c == n):
print("YES")
else:
print("NO")
``` | 3 | |
43 | A | Football | PROGRAMMING | 1,000 | [
"strings"
] | A. Football | 2 | 256 | One day Vasya decided to have a look at the results of Berland 1910 Football Championshipβs finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are *n* lines in that description each of which described one goal. E... | The first line contains an integer *n* (1<=β€<=*n*<=β€<=100) β the number of lines in the description. Then follow *n* lines β for each goal the names of the teams that scored it. The names are non-empty lines consisting of uppercase Latin letters whose lengths do not exceed 10 symbols. It is guaranteed that the match di... | Print the name of the winning team. We remind you that in football the team that scores more goals is considered the winner. | [
"1\nABC\n",
"5\nA\nABA\nABA\nA\nA\n"
] | [
"ABC\n",
"A\n"
] | none | 500 | [
{
"input": "1\nABC",
"output": "ABC"
},
{
"input": "5\nA\nABA\nABA\nA\nA",
"output": "A"
},
{
"input": "2\nXTSJEP\nXTSJEP",
"output": "XTSJEP"
},
{
"input": "3\nXZYDJAEDZ\nXZYDJAEDZ\nXZYDJAEDZ",
"output": "XZYDJAEDZ"
},
{
"input": "3\nQCCYXL\nQCCYXL\nAXGLFQDD",
... | 1,662,417,972 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 92 | 0 | '''
One day Vasya decided to have a look at the results of Berland 1910 Football Championshipβs finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are n lines in that description each of which described one goal.... | Title: Football
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
One day Vasya decided to have a look at the results of Berland 1910 Football Championshipβs finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process... | ```python
'''
One day Vasya decided to have a look at the results of Berland 1910 Football Championshipβs finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are n lines in that description each of which described... | 3.977 |
387 | B | George and Round | PROGRAMMING | 1,200 | [
"brute force",
"greedy",
"two pointers"
] | null | null | George decided to prepare a Codesecrof round, so he has prepared *m* problems for the round. Let's number the problems with integers 1 through *m*. George estimates the *i*-th problem's complexity by integer *b**i*.
To make the round good, he needs to put at least *n* problems there. Besides, he needs to have at least... | The first line contains two integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=3000) β the minimal number of problems in a good round and the number of problems George's prepared. The second line contains space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a*1<=<<=*a*2<=<<=...<=<<=*a**n*<=β€<=106) β the requirem... | Print a single integer β the answer to the problem. | [
"3 5\n1 2 3\n1 2 2 3 3\n",
"3 5\n1 2 3\n1 1 1 1 1\n",
"3 1\n2 3 4\n1\n"
] | [
"0\n",
"2\n",
"3\n"
] | In the first sample the set of the prepared problems meets the requirements for a good round.
In the second sample, it is enough to come up with and prepare two problems with complexities 2 and 3 to get a good round.
In the third sample it is very easy to get a good round if come up with and prepare extra problems wi... | 1,000 | [
{
"input": "3 5\n1 2 3\n1 2 2 3 3",
"output": "0"
},
{
"input": "3 5\n1 2 3\n1 1 1 1 1",
"output": "2"
},
{
"input": "3 1\n2 3 4\n1",
"output": "3"
},
{
"input": "29 100\n20 32 41 67 72 155 331 382 399 412 465 470 484 511 515 529 616 637 679 715 733 763 826 843 862 903 925 97... | 1,573,355,547 | 2,147,483,647 | Python 3 | OK | TESTS | 41 | 124 | 819,200 | def main():
nm=input().split(' ')
s1=input().split(' ')
s2=input().split(' ')
n=int(nm[0])
m=int(nm[1])
j=0
for i in range(len(s1)):
while j<m and int(s2[j])<int(s1[i]):
j+=1
if j<m:
n-=1
j+=1
else:
break
... | Title: George and Round
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
George decided to prepare a Codesecrof round, so he has prepared *m* problems for the round. Let's number the problems with integers 1 through *m*. George estimates the *i*-th problem's complexity by integer *b**i*.
T... | ```python
def main():
nm=input().split(' ')
s1=input().split(' ')
s2=input().split(' ')
n=int(nm[0])
m=int(nm[1])
j=0
for i in range(len(s1)):
while j<m and int(s2[j])<int(s1[i]):
j+=1
if j<m:
n-=1
j+=1
else:
... | 3 | |
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 th... | 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": "chn... | 1,617,198,805 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 154 | 0 | #word codeforces
# if lower > upper = use lower
# if equal use lower
n =input()
up = 0 ; low = 0
for i in n:
if i.isupper():
up+=1
else:
low+=1
if up > low:
print(n.upper())
elif up < low:
print(n.lower())
else: print(n.lower())
| Title: Word
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it ei... | ```python
#word codeforces
# if lower > upper = use lower
# if equal use lower
n =input()
up = 0 ; low = 0
for i in n:
if i.isupper():
up+=1
else:
low+=1
if up > low:
print(n.upper())
elif up < low:
print(n.lower())
else: print(n.lower())
``` | 3.9615 |
231 | A | Team | PROGRAMMING | 800 | [
"brute force",
"greedy"
] | null | null | One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decided that they will implement a problem if at least two of them are sure about the solution.... | The first input line contains a single integer *n* (1<=β€<=*n*<=β€<=1000) β the number of problems in the contest. Then *n* lines contain three integers each, each integer is either 0 or 1. If the first number in the line equals 1, then Petya is sure about the problem's solution, otherwise he isn't sure. The second numbe... | Print a single integer β the number of problems the friends will implement on the contest. | [
"3\n1 1 0\n1 1 1\n1 0 0\n",
"2\n1 0 0\n0 1 1\n"
] | [
"2\n",
"1\n"
] | In the first sample Petya and Vasya are sure that they know how to solve the first problem and all three of them know how to solve the second problem. That means that they will write solutions for these problems. Only Petya is sure about the solution for the third problem, but that isn't enough, so the friends won't ta... | 500 | [
{
"input": "3\n1 1 0\n1 1 1\n1 0 0",
"output": "2"
},
{
"input": "2\n1 0 0\n0 1 1",
"output": "1"
},
{
"input": "1\n1 0 0",
"output": "0"
},
{
"input": "2\n1 0 0\n1 1 1",
"output": "1"
},
{
"input": "5\n1 0 0\n0 1 0\n1 1 1\n0 0 1\n0 0 0",
"output": "1"
},
... | 1,696,587,043 | 2,147,483,647 | Python 3 | OK | TESTS | 21 | 92 | 102,400 | n=int(input())
L=[]
for i in range(n):
ss=input()
W=ss.split()
L.append(W)
maincount=0
for i in L:
count=0
for j in i:
if int(j)==1:
count+=1
if count>=2:
maincount+=1
print(maincount) | Title: Team
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decid... | ```python
n=int(input())
L=[]
for i in range(n):
ss=input()
W=ss.split()
L.append(W)
maincount=0
for i in L:
count=0
for j in i:
if int(j)==1:
count+=1
if count>=2:
maincount+=1
print(maincount)
``` | 3 | |
964 | A | Splits | PROGRAMMING | 800 | [
"math"
] | null | null | Let's define a split of $n$ as a nonincreasing sequence of positive integers, the sum of which is $n$.
For example, the following sequences are splits of $8$: $[4, 4]$, $[3, 3, 2]$, $[2, 2, 1, 1, 1, 1]$, $[5, 2, 1]$.
The following sequences aren't splits of $8$: $[1, 7]$, $[5, 4]$, $[11, -3]$, $[1, 1, 4, 1, 1]$.
Th... | The first line contains one integer $n$ ($1 \leq n \leq 10^9$). | Output one integerΒ β the answer to the problem. | [
"7\n",
"8\n",
"9\n"
] | [
"4\n",
"5\n",
"5\n"
] | In the first sample, there are following possible weights of splits of $7$:
Weight 1: [$\textbf 7$]
Weight 2: [$\textbf 3$, $\textbf 3$, 1]
Weight 3: [$\textbf 2$, $\textbf 2$, $\textbf 2$, 1]
Weight 7: [$\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$, $\textbf 1$] | 500 | [
{
"input": "7",
"output": "4"
},
{
"input": "8",
"output": "5"
},
{
"input": "9",
"output": "5"
},
{
"input": "1",
"output": "1"
},
{
"input": "286",
"output": "144"
},
{
"input": "48",
"output": "25"
},
{
"input": "941",
"output": "471... | 1,524,242,036 | 2,147,483,647 | Python 3 | OK | TESTS | 63 | 93 | 7,065,600 | # from dust i have come, dust i will be
n=int(input())
print(n//2+1) | Title: Splits
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Let's define a split of $n$ as a nonincreasing sequence of positive integers, the sum of which is $n$.
For example, the following sequences are splits of $8$: $[4, 4]$, $[3, 3, 2]$, $[2, 2, 1, 1, 1, 1]$, $[5, 2, 1]$.
The foll... | ```python
# from dust i have come, dust i will be
n=int(input())
print(n//2+1)
``` | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Squirrel Liss lived in a forest peacefully, but unexpected trouble happens. Stones fall from a mountain. Initially Squirrel Liss occupies an interval [0,<=1]. Next, *n* stones will fall and Liss will escape from the stones. The stones are numbered from 1 to *n* in order.
The stones always fall to the center of Liss's ... | The input consists of only one line. The only line contains the string *s* (1<=β€<=|*s*|<=β€<=106). Each character in *s* will be either "l" or "r". | Output *n* lines β on the *i*-th line you should print the *i*-th stone's number from the left. | [
"llrlr\n",
"rrlll\n",
"lrlrr\n"
] | [
"3\n5\n4\n2\n1\n",
"1\n2\n5\n4\n3\n",
"2\n4\n5\n3\n1\n"
] | In the first example, the positions of stones 1, 2, 3, 4, 5 will be <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/58fdb5684df807bfcb705a9da9ce175613362b7d.png" style="max-width: 100.0%;max-height: 100.0%;"/>, respectively. So you should print the sequence: 3, 5, 4, 2, 1. | 0 | [
{
"input": "llrlr",
"output": "3\n5\n4\n2\n1"
},
{
"input": "rrlll",
"output": "1\n2\n5\n4\n3"
},
{
"input": "lrlrr",
"output": "2\n4\n5\n3\n1"
},
{
"input": "lllrlrllrl",
"output": "4\n6\n9\n10\n8\n7\n5\n3\n2\n1"
},
{
"input": "llrlrrrlrr",
"output": "3\n5\n6... | 1,642,745,741 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 57 | 1,107 | 29,388,800 | s=str(input())
n=len(s)
lstl=[]
lstr=[]
for i in range(0,n):
if(s[i]=='l'):
lstl.append(i+1)
else:
lstr.append(i+1)
lstl.reverse()
for i in lstr:
print(i)
for i in lstl:
print(i)
| Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Squirrel Liss lived in a forest peacefully, but unexpected trouble happens. Stones fall from a mountain. Initially Squirrel Liss occupies an interval [0,<=1]. Next, *n* stones will fall and Liss will escape from the stones. The st... | ```python
s=str(input())
n=len(s)
lstl=[]
lstr=[]
for i in range(0,n):
if(s[i]=='l'):
lstl.append(i+1)
else:
lstr.append(i+1)
lstl.reverse()
for i in lstr:
print(i)
for i in lstl:
print(i)
``` | 3 | |
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 c... | 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 follo... | 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",
... | 1,605,716,903 | 2,147,483,647 | Python 3 | OK | TESTS | 54 | 639 | 9,523,200 | n = int(input())
cities = list(map(int, input().split()))
mins = []
maxs = []
for i in range(n):
comm = 0
if i == 0:
var = abs(cities[i] - cities[i+1])
mins.append(var)
comm = abs(cities[i]-cities[n-1])
maxs.append(comm)
elif i == n-1:
comm = abs(cities[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... | ```python
n = int(input())
cities = list(map(int, input().split()))
mins = []
maxs = []
for i in range(n):
comm = 0
if i == 0:
var = abs(cities[i] - cities[i+1])
mins.append(var)
comm = abs(cities[i]-cities[n-1])
maxs.append(comm)
elif i == n-1:
comm = abs... | 3 | |
811 | A | Vladik and Courtesy | PROGRAMMING | 800 | [
"brute force",
"implementation"
] | null | null | At regular competition Vladik and Valera won *a* and *b* candies respectively. Vladik offered 1 his candy to Valera. After that Valera gave Vladik 2 his candies, so that no one thought that he was less generous. Vladik for same reason gave 3 candies to Valera in next turn.
More formally, the guys take turns giving eac... | Single line of input data contains two space-separated integers *a*, *b* (1<=β€<=*a*,<=*b*<=β€<=109) β number of Vladik and Valera candies respectively. | Pring a single line "Vladikββ in case, if Vladik first who canβt give right amount of candy, or "Valeraββ otherwise. | [
"1 1\n",
"7 6\n"
] | [
"Valera\n",
"Vladik\n"
] | Illustration for first test case:
<img class="tex-graphics" src="https://espresso.codeforces.com/ad9b7d0e481208de8e3a585aa1d96b9e1dda4fd7.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Illustration for second test case:
<img class="tex-graphics" src="https://espresso.codeforces.com/9f4836d2ccdffaee5a63898e5d4e... | 500 | [
{
"input": "1 1",
"output": "Valera"
},
{
"input": "7 6",
"output": "Vladik"
},
{
"input": "25 38",
"output": "Vladik"
},
{
"input": "8311 2468",
"output": "Valera"
},
{
"input": "250708 857756",
"output": "Vladik"
},
{
"input": "957985574 24997558",
... | 1,657,724,458 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 42 | 62 | 1,536,000 | def main():
a , b = map(int,input().split())
i = 1
while 1:
if(i&1):
if(a >= i):
a -= i
else :
print("Vladik")
break
else :
if( b >= i):
b -= i
else :
print("Valera")
break
i +=1
if __name__ == '__main__':
main() | Title: Vladik and Courtesy
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
At regular competition Vladik and Valera won *a* and *b* candies respectively. Vladik offered 1 his candy to Valera. After that Valera gave Vladik 2 his candies, so that no one thought that he was less generous. Vla... | ```python
def main():
a , b = map(int,input().split())
i = 1
while 1:
if(i&1):
if(a >= i):
a -= i
else :
print("Vladik")
break
else :
if( b >= i):
b -= i
else :
print("Valera")
break
i +=1
if __name__ == '__main__':
main()
``` | 3 | |
892 | A | Greed | PROGRAMMING | 900 | [
"greedy",
"implementation"
] | null | null | Jafar has *n* cans of cola. Each can is described by two integers: remaining volume of cola *a**i* and can's capacity *b**i* (*a**i* <=β€<= *b**i*).
Jafar has decided to pour all remaining cola into just 2 cans, determine if he can do this or not! | The first line of the input contains one integer *n* (2<=β€<=*n*<=β€<=100<=000)Β β number of cola cans.
The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (0<=β€<=*a**i*<=β€<=109) β volume of remaining cola in cans.
The third line contains *n* space-separated integers that *b*1,<=*b*2,<=...,<... | Print "YES" (without quotes) if it is possible to pour all remaining cola in 2 cans. Otherwise print "NO" (without quotes).
You can print each letter in any case (upper or lower). | [
"2\n3 5\n3 6\n",
"3\n6 8 9\n6 10 12\n",
"5\n0 0 5 0 0\n1 1 8 10 5\n",
"4\n4 1 0 3\n5 2 2 3\n"
] | [
"YES\n",
"NO\n",
"YES\n",
"YES\n"
] | In the first sample, there are already 2 cans, so the answer is "YES". | 500 | [
{
"input": "2\n3 5\n3 6",
"output": "YES"
},
{
"input": "3\n6 8 9\n6 10 12",
"output": "NO"
},
{
"input": "5\n0 0 5 0 0\n1 1 8 10 5",
"output": "YES"
},
{
"input": "4\n4 1 0 3\n5 2 2 3",
"output": "YES"
},
{
"input": "10\n9 10 24 11 1 7 8 3 28 14\n86 20 34 11 22 9... | 1,644,507,796 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 39 | 249 | 17,305,600 | n=int(input())
left=[int(x) for x in input().split()]
cap=[int(x) for x in input().split()]
m1=max(cap)
l=cap;l.remove(m1);
m2=max(l)
if m1+m2>=sum(left):
print("YES")
else:
print('NO')
| Title: Greed
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Jafar has *n* cans of cola. Each can is described by two integers: remaining volume of cola *a**i* and can's capacity *b**i* (*a**i* <=β€<= *b**i*).
Jafar has decided to pour all remaining cola into just 2 cans, determine if he c... | ```python
n=int(input())
left=[int(x) for x in input().split()]
cap=[int(x) for x in input().split()]
m1=max(cap)
l=cap;l.remove(m1);
m2=max(l)
if m1+m2>=sum(left):
print("YES")
else:
print('NO')
``` | 3 | |
615 | A | Bulbs | PROGRAMMING | 800 | [
"implementation"
] | null | null | Vasya wants to turn on Christmas lights consisting of *m* bulbs. Initially, all bulbs are turned off. There are *n* buttons, each of them is connected to some set of bulbs. Vasya can press any of these buttons. When the button is pressed, it turns on all the bulbs it's connected to. Can Vasya light up all the bulbs?
I... | The first line of the input contains integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=100)Β β the number of buttons and the number of bulbs respectively.
Each of the next *n* lines contains *x**i* (0<=β€<=*x**i*<=β€<=*m*)Β β the number of bulbs that are turned on by the *i*-th button, and then *x**i* numbers *y**ij* (1<=β€<=*y**... | If it's possible to turn on all *m* bulbs print "YES", otherwise print "NO". | [
"3 4\n2 1 4\n3 1 3 1\n1 2\n",
"3 3\n1 1\n1 2\n1 1\n"
] | [
"YES\n",
"NO\n"
] | In the first sample you can press each button once and turn on all the bulbs. In the 2 sample it is impossible to turn on the 3-rd lamp. | 500 | [
{
"input": "3 4\n2 1 4\n3 1 3 1\n1 2",
"output": "YES"
},
{
"input": "3 3\n1 1\n1 2\n1 1",
"output": "NO"
},
{
"input": "3 4\n1 1\n1 2\n1 3",
"output": "NO"
},
{
"input": "1 5\n5 1 2 3 4 5",
"output": "YES"
},
{
"input": "1 5\n5 4 4 1 2 3",
"output": "NO"
},... | 1,665,845,310 | 2,147,483,647 | Python 3 | OK | TESTS | 45 | 46 | 0 | n,m=map(int,input().split())
p=[]
po=[]
for i in range(m):
p.append('0')
po.append('1')
for i in range(1,n+1):
q=input().split()
um=q[0]
for ui in range(1,int(um)+1):
p[int(q[ui])-1]='1'
if p==po:
print('YES')
else:print('NO') | Title: Bulbs
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya wants to turn on Christmas lights consisting of *m* bulbs. Initially, all bulbs are turned off. There are *n* buttons, each of them is connected to some set of bulbs. Vasya can press any of these buttons. When the button is... | ```python
n,m=map(int,input().split())
p=[]
po=[]
for i in range(m):
p.append('0')
po.append('1')
for i in range(1,n+1):
q=input().split()
um=q[0]
for ui in range(1,int(um)+1):
p[int(q[ui])-1]='1'
if p==po:
print('YES')
else:print('NO')
``` | 3 | |
1,003 | A | Polycarp's Pockets | PROGRAMMING | 800 | [
"implementation"
] | null | null | Polycarp has $n$ coins, the value of the $i$-th coin is $a_i$. Polycarp wants to distribute all the coins between his pockets, but he cannot put two coins with the same value into the same pocket.
For example, if Polycarp has got six coins represented as an array $a = [1, 2, 4, 3, 3, 2]$, he can distribute the coins i... | The first line of the input contains one integer $n$ ($1 \le n \le 100$) β the number of coins.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$) β values of coins. | Print only one integer β the minimum number of pockets Polycarp needs to distribute all the coins so no two coins with the same value are put into the same pocket. | [
"6\n1 2 4 3 3 2\n",
"1\n100\n"
] | [
"2\n",
"1\n"
] | none | 0 | [
{
"input": "6\n1 2 4 3 3 2",
"output": "2"
},
{
"input": "1\n100",
"output": "1"
},
{
"input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100... | 1,621,411,997 | 2,147,483,647 | Python 3 | OK | TESTS | 37 | 77 | 102,400 | import collections
n = int(input())
c = collections.Counter(int(x) for x in input().split())
print(max(c.values())) | Title: Polycarp's Pockets
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarp has $n$ coins, the value of the $i$-th coin is $a_i$. Polycarp wants to distribute all the coins between his pockets, but he cannot put two coins with the same value into the same pocket.
For example, if Po... | ```python
import collections
n = int(input())
c = collections.Counter(int(x) for x in input().split())
print(max(c.values()))
``` | 3 | |
432 | A | Choosing Teams | PROGRAMMING | 800 | [
"greedy",
"implementation",
"sortings"
] | null | null | The Saratov State University Olympiad Programmers Training Center (SSU OPTC) has *n* students. For each student you know the number of times he/she has participated in the ACM ICPC world programming championship. According to the ACM ICPC rules, each person can participate in the world championship at most 5 times.
Th... | The first line contains two integers, *n* and *k* (1<=β€<=*n*<=β€<=2000;Β 1<=β€<=*k*<=β€<=5). The next line contains *n* integers: *y*1,<=*y*2,<=...,<=*y**n* (0<=β€<=*y**i*<=β€<=5), where *y**i* shows the number of times the *i*-th person participated in the ACM ICPC world championship. | Print a single number β the answer to the problem. | [
"5 2\n0 4 5 1 0\n",
"6 4\n0 1 2 3 4 5\n",
"6 5\n0 0 0 0 0 0\n"
] | [
"1\n",
"0\n",
"2\n"
] | In the first sample only one team could be made: the first, the fourth and the fifth participants.
In the second sample no teams could be created.
In the third sample two teams could be created. Any partition into two teams fits. | 500 | [
{
"input": "5 2\n0 4 5 1 0",
"output": "1"
},
{
"input": "6 4\n0 1 2 3 4 5",
"output": "0"
},
{
"input": "6 5\n0 0 0 0 0 0",
"output": "2"
},
{
"input": "3 4\n0 1 0",
"output": "1"
},
{
"input": "3 4\n0 2 0",
"output": "0"
},
{
"input": "6 5\n0 0 0 0 0... | 1,684,596,500 | 2,147,483,647 | Python 3 | OK | TESTS | 35 | 46 | 0 | n,k=map(int,input().split())
l=list(map(int,input().split()))
re=5-k
c=0
for i in l:
if(i <= re):
c+=1
print(c//3) | Title: Choosing Teams
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Saratov State University Olympiad Programmers Training Center (SSU OPTC) has *n* students. For each student you know the number of times he/she has participated in the ACM ICPC world programming championship. Accordi... | ```python
n,k=map(int,input().split())
l=list(map(int,input().split()))
re=5-k
c=0
for i in l:
if(i <= re):
c+=1
print(c//3)
``` | 3 | |
22 | A | Second Order Statistics | PROGRAMMING | 800 | [
"brute force"
] | A. Second Order Statistics | 2 | 256 | Once Bob needed to find the second order statistics of a sequence of integer numbers. Lets choose each number from the sequence exactly once and sort them. The value on the second position is the second order statistics of the given sequence. In other words it is the smallest element strictly greater than the minimum. ... | The first input line contains integer *n* (1<=β€<=*n*<=β€<=100) β amount of numbers in the sequence. The second line contains *n* space-separated integer numbers β elements of the sequence. These numbers don't exceed 100 in absolute value. | If the given sequence has the second order statistics, output this order statistics, otherwise output NO. | [
"4\n1 2 2 -4\n",
"5\n1 2 3 1 1\n"
] | [
"1\n",
"2\n"
] | none | 0 | [
{
"input": "4\n1 2 2 -4",
"output": "1"
},
{
"input": "5\n1 2 3 1 1",
"output": "2"
},
{
"input": "1\n28",
"output": "NO"
},
{
"input": "2\n-28 12",
"output": "12"
},
{
"input": "3\n-83 40 -80",
"output": "-80"
},
{
"input": "8\n93 77 -92 26 21 -48 53 ... | 1,618,557,570 | 2,147,483,647 | Python 3 | OK | TESTS | 31 | 154 | 0 | n=int(input())
a=[int(x) for x in input().split()]
a=list(set(a))
a.sort()
if(len(a)==1):
print("NO")
else:
print(a[1])
| Title: Second Order Statistics
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Once Bob needed to find the second order statistics of a sequence of integer numbers. Lets choose each number from the sequence exactly once and sort them. The value on the second position is the second order statis... | ```python
n=int(input())
a=[int(x) for x in input().split()]
a=list(set(a))
a.sort()
if(len(a)==1):
print("NO")
else:
print(a[1])
``` | 3.9615 |
471 | A | MUH and Sticks | PROGRAMMING | 1,100 | [
"implementation"
] | null | null | Two polar bears Menshykov and Uslada from the St.Petersburg zoo and elephant Horace from the Kiev zoo got six sticks to play with and assess the animals' creativity. Menshykov, Uslada and Horace decided to make either an elephant or a bear from those sticks. They can make an animal from sticks in the following way:
-... | The single line contains six space-separated integers *l**i* (1<=β€<=*l**i*<=β€<=9) β the lengths of the six sticks. It is guaranteed that the input is such that you cannot make both animals from the sticks. | If you can make a bear from the given set, print string "Bear" (without the quotes). If you can make an elephant, print string "Elephant" (wΔ±thout the quotes). If you can make neither a bear nor an elephant, print string "Alien" (without the quotes). | [
"4 2 5 4 4 4\n",
"4 4 5 4 4 5\n",
"1 2 3 4 5 6\n"
] | [
"Bear",
"Elephant",
"Alien"
] | If you're out of creative ideas, see instructions below which show how to make a bear and an elephant in the first two samples. The stick of length 2 is in red, the sticks of length 4 are in green, the sticks of length 5 are in blue. | 500 | [
{
"input": "4 2 5 4 4 4",
"output": "Bear"
},
{
"input": "4 4 5 4 4 5",
"output": "Elephant"
},
{
"input": "1 2 3 4 5 6",
"output": "Alien"
},
{
"input": "5 5 5 5 5 5",
"output": "Elephant"
},
{
"input": "1 1 1 2 3 5",
"output": "Alien"
},
{
"input": "... | 1,584,956,751 | 2,147,483,647 | Python 3 | OK | TESTS | 29 | 109 | 204,800 | a = list(map(int, input().split()))
h = {}
for n in a:
if n not in h:
h[n] = 1
else:
h[n] += 1
k = 4
if len(h)==1:
print('Elephant')
elif k+1 in h.values():
print('Bear')
elif k in h.values():
if len(h)==2:
print('Elephant')
elif len(h)==3:
p... | Title: MUH and Sticks
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Two polar bears Menshykov and Uslada from the St.Petersburg zoo and elephant Horace from the Kiev zoo got six sticks to play with and assess the animals' creativity. Menshykov, Uslada and Horace decided to make either an... | ```python
a = list(map(int, input().split()))
h = {}
for n in a:
if n not in h:
h[n] = 1
else:
h[n] += 1
k = 4
if len(h)==1:
print('Elephant')
elif k+1 in h.values():
print('Bear')
elif k in h.values():
if len(h)==2:
print('Elephant')
elif len(h)==3:
... | 3 | |
285 | C | Building Permutation | PROGRAMMING | 1,200 | [
"greedy",
"implementation",
"sortings"
] | null | null | Permutation *p* is an ordered set of integers *p*1,<=<=*p*2,<=<=...,<=<=*p**n*, consisting of *n* distinct positive integers, each of them doesn't exceed *n*. We'll denote the *i*-th element of permutation *p* as *p**i*. We'll call number *n* the size or the length of permutation *p*1,<=<=*p*2,<=<=...,<=<=*p**n*.
You ... | The first line contains integer *n* (1<=β€<=*n*<=β€<=3Β·105) β the size of the sought permutation. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=109<=β€<=*a**i*<=β€<=109). | Print a single number β the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. | [
"2\n3 0\n",
"3\n-1 -1 2\n"
] | [
"2\n",
"6\n"
] | In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2,β1).
In the second sample you need 6 moves to build permutation (1,β3,β2). | 1,500 | [
{
"input": "2\n3 0",
"output": "2"
},
{
"input": "3\n-1 -1 2",
"output": "6"
},
{
"input": "5\n-3 5 -3 3 3",
"output": "10"
},
{
"input": "10\n9 6 -2 4 1 1 1 9 6 2",
"output": "18"
},
{
"input": "9\n2 0 0 6 5 4 1 9 3",
"output": "15"
},
{
"input": "100... | 1,621,090,760 | 2,147,483,647 | PyPy 3 | OK | TESTS | 33 | 436 | 25,907,200 | n = int(input())
lista = [int(item) for item in input().split()]
lista.sort()
count = 0
for i in range(n):
count += abs(lista[i]-(i+1))
print(count)
| Title: Building Permutation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Permutation *p* is an ordered set of integers *p*1,<=<=*p*2,<=<=...,<=<=*p**n*, consisting of *n* distinct positive integers, each of them doesn't exceed *n*. We'll denote the *i*-th element of permutation *p* as *... | ```python
n = int(input())
lista = [int(item) for item in input().split()]
lista.sort()
count = 0
for i in range(n):
count += abs(lista[i]-(i+1))
print(count)
``` | 3 | |
25 | B | Phone numbers | PROGRAMMING | 1,100 | [
"implementation"
] | B. Phone numbers | 2 | 256 | Phone number in Berland is a sequence of *n* digits. Often, to make it easier to memorize the number, it is divided into groups of two or three digits. For example, the phone number 1198733 is easier to remember as 11-987-33. Your task is to find for a given phone number any of its divisions into groups of two or three... | The first line contains integer *n* (2<=β€<=*n*<=β€<=100) β amount of digits in the phone number. The second line contains *n* digits β the phone number to divide into groups. | Output any of divisions of the given phone number into groups of two or three digits. Separate groups by single character -. If the answer is not unique, output any. | [
"6\n549871\n",
"7\n1198733\n"
] | [
"54-98-71",
"11-987-33\n"
] | none | 0 | [
{
"input": "6\n549871",
"output": "54-98-71"
},
{
"input": "7\n1198733",
"output": "119-87-33"
},
{
"input": "2\n74",
"output": "74"
},
{
"input": "2\n33",
"output": "33"
},
{
"input": "3\n074",
"output": "074"
},
{
"input": "3\n081",
"output": "08... | 1,550,318,510 | 2,147,483,647 | Python 3 | OK | TESTS | 20 | 342 | 0 | n = int(input())
s = input()
l = []
if n > 3:
if n % 2 == 0:
for i in range(0, n, 2):
l.append(s[i:i + 2])
else:
l.append(s[:3])
for i in range(3, n, 2):
l.append(s[i:i + 2])
print(*l, sep='-')
else:
print(s)
| Title: Phone numbers
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Phone number in Berland is a sequence of *n* digits. Often, to make it easier to memorize the number, it is divided into groups of two or three digits. For example, the phone number 1198733 is easier to remember as 11-987-33.... | ```python
n = int(input())
s = input()
l = []
if n > 3:
if n % 2 == 0:
for i in range(0, n, 2):
l.append(s[i:i + 2])
else:
l.append(s[:3])
for i in range(3, n, 2):
l.append(s[i:i + 2])
print(*l, sep='-')
else:
print(s)
``` | 3.9145 |
747 | A | Display Size | PROGRAMMING | 800 | [
"brute force",
"math"
] | null | null | A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly *n* pixels.
Your task is to determine the size of the rectangular display β the number of lines (rows) of pixels *a* and the number of columns of pixels *b*, so that:
- there are exactly *n* pixels o... | The first line contains the positive integer *n* (1<=β€<=*n*<=β€<=106)Β β the number of pixels display should have. | Print two integersΒ β the number of rows and columns on the display. | [
"8\n",
"64\n",
"5\n",
"999999\n"
] | [
"2 4\n",
"8 8\n",
"1 5\n",
"999 1001\n"
] | In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 ro... | 500 | [
{
"input": "8",
"output": "2 4"
},
{
"input": "64",
"output": "8 8"
},
{
"input": "5",
"output": "1 5"
},
{
"input": "999999",
"output": "999 1001"
},
{
"input": "716539",
"output": "97 7387"
},
{
"input": "1",
"output": "1 1"
},
{
"input":... | 1,516,528,274 | 2,147,483,647 | Python 3 | OK | TESTS | 43 | 62 | 5,632,000 | from math import sqrt
n = int(input().strip())
sq = int(sqrt(n))
for i in range(sq, 0, -1):
if not n%i:
print(i, n//i)
break
| Title: Display Size
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly *n* pixels.
Your task is to determine the size of the rectangular display β the number of lines (rows) ... | ```python
from math import sqrt
n = int(input().strip())
sq = int(sqrt(n))
for i in range(sq, 0, -1):
if not n%i:
print(i, n//i)
break
``` | 3 | |
592 | B | The Monster and the Squirrel | PROGRAMMING | 1,100 | [
"math"
] | null | null | Ari the monster always wakes up very early with the first ray of the sun and the first thing she does is feeding her squirrel.
Ari draws a regular convex polygon on the floor and numbers it's vertices 1,<=2,<=...,<=*n* in clockwise order. Then starting from the vertex 1 she draws a ray in the direction of each other v... | The first and only line of the input contains a single integer *n* (3<=β€<=*n*<=β€<=54321) - the number of vertices of the regular polygon drawn by Ari. | Print the minimum number of jumps Ada should make to collect all the walnuts. Note, that she doesn't need to leave the polygon after. | [
"5\n",
"3\n"
] | [
"9\n",
"1\n"
] | One of the possible solutions for the first sample is shown on the picture above. | 1,000 | [
{
"input": "5",
"output": "9"
},
{
"input": "3",
"output": "1"
},
{
"input": "54321",
"output": "2950553761"
},
{
"input": "4",
"output": "4"
},
{
"input": "6",
"output": "16"
},
{
"input": "7",
"output": "25"
},
{
"input": "8",
"output... | 1,446,310,365 | 1,365 | Python 3 | OK | TESTS | 24 | 61 | 0 | #!/usr/bin/env python3
from sys import stdin
n = int(stdin.readline().strip())
out = (n - 2) ** 2
print(out)
| Title: The Monster and the Squirrel
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Ari the monster always wakes up very early with the first ray of the sun and the first thing she does is feeding her squirrel.
Ari draws a regular convex polygon on the floor and numbers it's vertices 1,<=... | ```python
#!/usr/bin/env python3
from sys import stdin
n = int(stdin.readline().strip())
out = (n - 2) ** 2
print(out)
``` | 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 i... | 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"... | 1,539,862,468 | 2,147,483,647 | Python 3 | OK | TESTS | 32 | 218 | 0 | x=int(input())
y=list(map(int,input().split()))
z=[]
q=[]
for i in range(x):
if y[i]%2==0:
z.append(y[i])
else:
q.append(y[i])
if len(z)==1:
print(y.index(z[0])+1)
else:
print(y.index(q[0])+1) | Title: IQ test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob β t... | ```python
x=int(input())
y=list(map(int,input().split()))
z=[]
q=[]
for i in range(x):
if y[i]%2==0:
z.append(y[i])
else:
q.append(y[i])
if len(z)==1:
print(y.index(z[0])+1)
else:
print(y.index(q[0])+1)
``` | 3.9455 |
770 | A | New Password | PROGRAMMING | 800 | [
"*special",
"implementation"
] | null | null | Innokentiy decides to change the password in the social net "Contact!", but he is too lazy to invent a new password by himself. That is why he needs your help.
Innokentiy decides that new password should satisfy the following conditions:
- the length of the password must be equal to *n*, - the password should cons... | The first line contains two positive integers *n* and *k* (2<=β€<=*n*<=β€<=100, 2<=β€<=*k*<=β€<=*min*(*n*,<=26)) β the length of the password and the number of distinct symbols in it.
Pay attention that a desired new password always exists. | Print any password which satisfies all conditions given by Innokentiy. | [
"4 3\n",
"6 6\n",
"5 2\n"
] | [
"java\n",
"python\n",
"phphp\n"
] | In the first test there is one of the appropriate new passwords β java, because its length is equal to 4 and 3 distinct lowercase letters a, j and v are used in it.
In the second test there is one of the appropriate new passwords β python, because its length is equal to 6 and it consists of 6 distinct lowercase letter... | 500 | [
{
"input": "4 3",
"output": "abca"
},
{
"input": "6 6",
"output": "abcdef"
},
{
"input": "5 2",
"output": "ababa"
},
{
"input": "3 2",
"output": "aba"
},
{
"input": "10 2",
"output": "ababababab"
},
{
"input": "26 13",
"output": "abcdefghijklmabcde... | 1,652,099,605 | 2,147,483,647 | Python 3 | OK | TESTS | 47 | 62 | 409,600 | from string import ascii_lowercase as alph
n, k = map(int, input().split())
print(''.join(alph[i % k] for i in range(n))) | Title: New Password
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Innokentiy decides to change the password in the social net "Contact!", but he is too lazy to invent a new password by himself. That is why he needs your help.
Innokentiy decides that new password should satisfy the foll... | ```python
from string import ascii_lowercase as alph
n, k = map(int, input().split())
print(''.join(alph[i % k] for i in range(n)))
``` | 3 | |
270 | A | Fancy Fence | PROGRAMMING | 1,100 | [
"geometry",
"implementation",
"math"
] | null | null | Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle *a*.
Will the robot be able to build the fence Emuska... | The first line of input contains an integer *t* (0<=<<=*t*<=<<=180) β the number of tests. Each of the following *t* lines contains a single integer *a* (0<=<<=*a*<=<<=180) β the angle the robot can make corners at measured in degrees. | For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible. | [
"3\n30\n60\n90\n"
] | [
"NO\nYES\nYES\n"
] | In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/df5f4b07dd5316fde165b43657b2696e2919e791.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second test case, the fence is a r... | 500 | [
{
"input": "3\n30\n60\n90",
"output": "NO\nYES\nYES"
},
{
"input": "6\n1\n2\n3\n170\n179\n25",
"output": "NO\nNO\nNO\nYES\nYES\nNO"
}
] | 1,665,559,685 | 2,147,483,647 | PyPy 3 | OK | TESTS | 3 | 124 | 0 | # -*- coding: utf-8 -*-
"""
Created on Wed Oct 12 15:20:42 2022
@author: lenovo
"""
t=int(input())
for i in range(t):
a=int(input())
print('YES' if 360%(180-a)==0 else'NO') | Title: Fancy Fence
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can... | ```python
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 12 15:20:42 2022
@author: lenovo
"""
t=int(input())
for i in range(t):
a=int(input())
print('YES' if 360%(180-a)==0 else'NO')
``` | 3 | |
41 | A | Translation | PROGRAMMING | 800 | [
"implementation",
"strings"
] | A. Translation | 2 | 256 | The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc.... | 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... | 1,630,481,928 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 124 | 6,758,400 | word_1 = input()
word_2 = input()
word_2 = word_2[-1:0:-1] + word_2[0]
if word_1 == word_2:
print("YES")
else:
print("NO") | 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 pron... | ```python
word_1 = input()
word_2 = input()
word_2 = word_2[-1:0:-1] + word_2[0]
if word_1 == word_2:
print("YES")
else:
print("NO")
``` | 3.956411 |
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 Vasy... | 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... | 1,591,045,045 | 2,147,483,647 | Python 3 | OK | TESTS | 81 | 218 | 0 | no = int(input())
final_sum = 0
vectors = []
for i in range(no):
vector = list(map(int, input().split()))
vectors.append(vector)
x_count = y_count = z_count = 0
for vector in vectors:
x_count += vector[0]
y_count += vector[1]
z_count += vector[2]
if(x_count == y_count == z_count == 0):
print... | 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. S... | ```python
no = int(input())
final_sum = 0
vectors = []
for i in range(no):
vector = list(map(int, input().split()))
vectors.append(vector)
x_count = y_count = z_count = 0
for vector in vectors:
x_count += vector[0]
y_count += vector[1]
z_count += vector[2]
if(x_count == y_count == z_count == 0):... | 3.9455 |
80 | A | Panoramix's Prediction | PROGRAMMING | 800 | [
"brute force"
] | A. Panoramix's Prediction | 2 | 256 | A prime number is a number which has exactly two distinct divisors: one and itself. For example, numbers 2, 7, 3 are prime, and 1, 6, 4 are not.
The next prime number after *x* is the smallest prime number greater than *x*. For example, the next prime number after 2 is 3, and the next prime number after 3 is 5. Note t... | The first and only input line contains two positive integers β *n* and *m* (2<=β€<=*n*<=<<=*m*<=β€<=50). It is guaranteed that *n* is prime.
Pretests contain all the cases with restrictions 2<=β€<=*n*<=<<=*m*<=β€<=4. | Print YES, if *m* is the next prime number after *n*, or NO otherwise. | [
"3 5\n",
"7 11\n",
"7 9\n"
] | [
"YES",
"YES",
"NO"
] | none | 500 | [
{
"input": "3 5",
"output": "YES"
},
{
"input": "7 11",
"output": "YES"
},
{
"input": "7 9",
"output": "NO"
},
{
"input": "2 3",
"output": "YES"
},
{
"input": "2 4",
"output": "NO"
},
{
"input": "3 4",
"output": "NO"
},
{
"input": "3 5",
... | 1,690,273,542 | 2,147,483,647 | Python 3 | OK | TESTS | 45 | 92 | 0 | s, k = list(map(int, input().split()))
count, prime = 0, 0
for i in range(2, (k // 2) + 1):
if k % i == 0:
count += 1
if count > 0:
print("NO")
exit()
count, prime = 0, 0
for j in range(s, k + 1):
count = 0
for i in range(2, (j // 2) + 1):
if j % i == 0:
... | Title: Panoramix's Prediction
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
A prime number is a number which has exactly two distinct divisors: one and itself. For example, numbers 2, 7, 3 are prime, and 1, 6, 4 are not.
The next prime number after *x* is the smallest prime number greater t... | ```python
s, k = list(map(int, input().split()))
count, prime = 0, 0
for i in range(2, (k // 2) + 1):
if k % i == 0:
count += 1
if count > 0:
print("NO")
exit()
count, prime = 0, 0
for j in range(s, k + 1):
count = 0
for i in range(2, (j // 2) + 1):
if j % i == 0:... | 3.977 |
614 | A | Link/Cut Tree | PROGRAMMING | 1,500 | [
"brute force",
"implementation"
] | null | null | Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the *expose* procedure.
Unfortunately, Rostislav is unable to understand the definition of this procedure, so he decided to ask programmer Serezha to help him. Serezha agre... | The first line of the input contains three space-separated integers *l*, *r* and *k* (1<=β€<=*l*<=β€<=*r*<=β€<=1018, 2<=β€<=*k*<=β€<=109). | Print all powers of number *k*, that lie within range from *l* to *r* in the increasing order. If there are no such numbers, print "-1" (without the quotes). | [
"1 10 2\n",
"2 4 5\n"
] | [
"1 2 4 8 ",
"-1"
] | Note to the first sample: numbers 2<sup class="upper-index">0</sup>β=β1, 2<sup class="upper-index">1</sup>β=β2, 2<sup class="upper-index">2</sup>β=β4, 2<sup class="upper-index">3</sup>β=β8 lie within the specified range. The number 2<sup class="upper-index">4</sup>β=β16 is greater then 10, thus it shouldn't be printed. | 500 | [
{
"input": "1 10 2",
"output": "1 2 4 8 "
},
{
"input": "2 4 5",
"output": "-1"
},
{
"input": "18102 43332383920 28554",
"output": "28554 815330916 "
},
{
"input": "19562 31702689720 17701",
"output": "313325401 "
},
{
"input": "11729 55221128400 313",
"output... | 1,489,423,409 | 2,147,483,647 | Python 3 | OK | TESTS | 44 | 62 | 4,608,000 | l,r,k=map(int,input().split())
f=0
t=1
while (t<=r):
if(t>=l):
f=1
print(t)
t*=k;
if (not(f)):
print(-1) | Title: Link/Cut Tree
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the *expose* procedure.
Unfortunately, Rostislav is unable to understand ... | ```python
l,r,k=map(int,input().split())
f=0
t=1
while (t<=r):
if(t>=l):
f=1
print(t)
t*=k;
if (not(f)):
print(-1)
``` | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are thr... | The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters. | Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them. | [
"hellno\n",
"abacaba\n",
"asdfasdf\n"
] | [
"hell no \n",
"abacaba \n",
"asd fasd f \n"
] | none | 0 | [
{
"input": "hellno",
"output": "hell no "
},
{
"input": "abacaba",
"output": "abacaba "
},
{
"input": "asdfasdf",
"output": "asd fasd f "
},
{
"input": "ooo",
"output": "ooo "
},
{
"input": "moyaoborona",
"output": "moyaoborona "
},
{
"input": "jxegxxx... | 1,689,956,231 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 108 | 77 | 2,150,400 | word = input()
n = len(word)
breaks = [False] * n
vowels = set({'a', 'e', 'i', 'o', 'u'})
streak = 1 if word[0] not in vowels else 0
numdiff = streak
for i in range(1, n):
if word[i] not in vowels:
streak += 1
if word[i] != word[i - 1]:
numdiff += 1
else:
streak =... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 2... | ```python
word = input()
n = len(word)
breaks = [False] * n
vowels = set({'a', 'e', 'i', 'o', 'u'})
streak = 1 if word[0] not in vowels else 0
numdiff = streak
for i in range(1, n):
if word[i] not in vowels:
streak += 1
if word[i] != word[i - 1]:
numdiff += 1
else:
... | 3 | |
939 | A | Love Triangle | PROGRAMMING | 800 | [
"graphs"
] | null | null | As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are *n* planes on Earth, numbered from 1 to *n*, and the plane with number *i* likes the plane with number *f**i*, where 1<=β€<=*f**i*<=β€<=*n* and *f**i*<=β <=*i*.
We call a love triangle a situation ... | The first line contains a single integer *n* (2<=β€<=*n*<=β€<=5000)Β β the number of planes.
The second line contains *n* integers *f*1,<=*f*2,<=...,<=*f**n* (1<=β€<=*f**i*<=β€<=*n*, *f**i*<=β <=*i*), meaning that the *i*-th plane likes the *f**i*-th. | Output Β«YESΒ» if there is a love triangle consisting of planes on Earth. Otherwise, output Β«NOΒ».
You can output any letter in lower case or in upper case. | [
"5\n2 4 5 1 3\n",
"5\n5 5 5 5 1\n"
] | [
"YES\n",
"NO\n"
] | In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles. | 500 | [
{
"input": "5\n2 4 5 1 3",
"output": "YES"
},
{
"input": "5\n5 5 5 5 1",
"output": "NO"
},
{
"input": "3\n3 1 2",
"output": "YES"
},
{
"input": "10\n4 10 9 5 3 1 5 10 6 4",
"output": "NO"
},
{
"input": "10\n5 5 4 9 10 9 9 5 3 1",
"output": "YES"
},
{
"... | 1,666,795,255 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 16 | 77 | 1,740,800 | import sys
#sys.stdin = open("input.txt", "r")
n = int(input())
li = list(map(int, input().split()))
li.insert(0,0)
# print(li)
res = 0
for i in range(1,n):
if i == li[li[li[i]]]:
res = 1
break
if res == 1:
print("YES")
else:
print("NO") | Title: Love Triangle
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are *n* planes on Earth, numbered from 1 to *n*, and the plane with number *i* likes the plane with ... | ```python
import sys
#sys.stdin = open("input.txt", "r")
n = int(input())
li = list(map(int, input().split()))
li.insert(0,0)
# print(li)
res = 0
for i in range(1,n):
if i == li[li[li[i]]]:
res = 1
break
if res == 1:
print("YES")
else:
print("NO")
``` | 3 | |
255 | A | Greg's Workout | PROGRAMMING | 800 | [
"implementation"
] | null | null | Greg is a beginner bodybuilder. Today the gym coach gave him the training plan. All it had was *n* integers *a*1,<=*a*2,<=...,<=*a**n*. These numbers mean that Greg needs to do exactly *n* exercises today. Besides, Greg should repeat the *i*-th in order exercise *a**i* times.
Greg now only does three types of exercise... | The first line contains integer *n* (1<=β€<=*n*<=β€<=20). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=25) β the number of times Greg repeats the exercises. | Print word "chest" (without the quotes), if the chest gets the most exercise, "biceps" (without the quotes), if the biceps gets the most exercise and print "back" (without the quotes) if the back gets the most exercise.
It is guaranteed that the input is such that the answer to the problem is unambiguous. | [
"2\n2 8\n",
"3\n5 1 10\n",
"7\n3 3 2 7 9 6 8\n"
] | [
"biceps\n",
"back\n",
"chest\n"
] | In the first sample Greg does 2 chest, 8 biceps and zero back exercises, so the biceps gets the most exercises.
In the second sample Greg does 5 chest, 1 biceps and 10 back exercises, so the back gets the most exercises.
In the third sample Greg does 18 chest, 12 biceps and 8 back exercises, so the chest gets the mos... | 500 | [
{
"input": "2\n2 8",
"output": "biceps"
},
{
"input": "3\n5 1 10",
"output": "back"
},
{
"input": "7\n3 3 2 7 9 6 8",
"output": "chest"
},
{
"input": "4\n5 6 6 2",
"output": "chest"
},
{
"input": "5\n8 2 2 6 3",
"output": "chest"
},
{
"input": "6\n8 7 ... | 1,658,005,291 | 2,147,483,647 | PyPy 3 | OK | TESTS | 61 | 184 | 0 | n = int(input())
arr = list(map(int, input().split()))
brr = [0] * 3
for i in range(n):
brr[i%3] += arr[i]
print(('chest', 'biceps', 'back')[brr.index(max(brr))]) | Title: Greg's Workout
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Greg is a beginner bodybuilder. Today the gym coach gave him the training plan. All it had was *n* integers *a*1,<=*a*2,<=...,<=*a**n*. These numbers mean that Greg needs to do exactly *n* exercises today. Besides, Greg ... | ```python
n = int(input())
arr = list(map(int, input().split()))
brr = [0] * 3
for i in range(n):
brr[i%3] += arr[i]
print(('chest', 'biceps', 'back')[brr.index(max(brr))])
``` | 3 | |
443 | A | Anton and Letters | PROGRAMMING | 800 | [
"constructive algorithms",
"implementation"
] | null | null | Recently, Anton has found a set. The set consists of small English letters. Anton carefully wrote out all the letters from the set in one line, separated by a comma. He also added an opening curved bracket at the beginning of the line and a closing curved bracket at the end of the line.
Unfortunately, from time to ti... | The first and the single line contains the set of letters. The length of the line doesn't exceed 1000. It is guaranteed that the line starts from an opening curved bracket and ends with a closing curved bracket. Between them, small English letters are listed, separated by a comma. Each comma is followed by a space. | Print a single number β the number of distinct letters in Anton's set. | [
"{a, b, c}\n",
"{b, a, b, a}\n",
"{}\n"
] | [
"3\n",
"2\n",
"0\n"
] | none | 500 | [
{
"input": "{a, b, c}",
"output": "3"
},
{
"input": "{b, a, b, a}",
"output": "2"
},
{
"input": "{}",
"output": "0"
},
{
"input": "{a, a, c, b, b, b, c, c, c, c}",
"output": "3"
},
{
"input": "{a, c, b, b}",
"output": "3"
},
{
"input": "{a, b}",
"o... | 1,693,918,987 | 2,147,483,647 | Python 3 | OK | TESTS | 27 | 46 | 0 | input_string = input()
distinct_l = set()
for char in input_string[1:-1]:
if char.isalpha():
distinct_l.add(char)
print(len(distinct_l)) | Title: Anton and Letters
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Recently, Anton has found a set. The set consists of small English letters. Anton carefully wrote out all the letters from the set in one line, separated by a comma. He also added an opening curved bracket at the begi... | ```python
input_string = input()
distinct_l = set()
for char in input_string[1:-1]:
if char.isalpha():
distinct_l.add(char)
print(len(distinct_l))
``` | 3 | |
166 | E | Tetrahedron | PROGRAMMING | 1,500 | [
"dp",
"math",
"matrices"
] | null | null | You are given a tetrahedron. Let's mark its vertices with letters *A*, *B*, *C* and *D* correspondingly.
An ant is standing in the vertex *D* of the tetrahedron. The ant is quite active and he wouldn't stay idle. At each moment of time he makes a step from one vertex to another one along some edge of the tetrahedron. ... | The first line contains the only integer *n* (1<=β€<=*n*<=β€<=107) β the required length of the cyclic path. | Print the only integer β the required number of ways modulo 1000000007 (109<=+<=7). | [
"2\n",
"4\n"
] | [
"3\n",
"21\n"
] | The required paths in the first sample are:
- *D*β-β*A*β-β*D* - *D*β-β*B*β-β*D* - *D*β-β*C*β-β*D* | 1,000 | [
{
"input": "2",
"output": "3"
},
{
"input": "4",
"output": "21"
},
{
"input": "1",
"output": "0"
},
{
"input": "3",
"output": "6"
},
{
"input": "5",
"output": "60"
},
{
"input": "6",
"output": "183"
},
{
"input": "7",
"output": "546"
... | 1,658,203,703 | 2,147,483,647 | PyPy 3 | OK | TESTS | 36 | 1,528 | 1,536,000 | b,power,mod = 0,3,10**9+7
for i in range(int(input())-1): b=(power-b)%mod; power=(power*3)%mod
print(b) | Title: Tetrahedron
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a tetrahedron. Let's mark its vertices with letters *A*, *B*, *C* and *D* correspondingly.
An ant is standing in the vertex *D* of the tetrahedron. The ant is quite active and he wouldn't stay idle. At each m... | ```python
b,power,mod = 0,3,10**9+7
for i in range(int(input())-1): b=(power-b)%mod; power=(power*3)%mod
print(b)
``` | 3 | |
556 | A | Case of the Zeros and Ones | PROGRAMMING | 900 | [
"greedy"
] | null | null | Andrewid the Android is a galaxy-famous detective. In his free time he likes to think about strings containing zeros and ones.
Once he thought about a string of length *n* consisting of zeroes and ones. Consider the following operation: we choose any two adjacent positions in the string, and if one them contains 0, an... | First line of the input contains a single integer *n* (1<=β€<=*n*<=β€<=2Β·105), the length of the string that Andreid has.
The second line contains the string of length *n* consisting only from zeros and ones. | Output the minimum length of the string that may remain after applying the described operations several times. | [
"4\n1100\n",
"5\n01010\n",
"8\n11101111\n"
] | [
"0\n",
"1\n",
"6\n"
] | In the first sample test it is possible to change the string like the following: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/10df55364c21c6e8d5da31b6ab6f6294c4fc26b3.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second sample test it is possible to change the string like... | 250 | [
{
"input": "4\n1100",
"output": "0"
},
{
"input": "5\n01010",
"output": "1"
},
{
"input": "8\n11101111",
"output": "6"
},
{
"input": "1\n0",
"output": "1"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "2\n00",
"output": "2"
},
{
"input"... | 1,688,812,390 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 49 | 108 | 15,974,400 | n = int(input())
a = input()
x = []
for i in a:
if len(x) == 0 or x[-1] == i:
x.append(i)
else:
x.pop()
print(len(x)) | Title: Case of the Zeros and Ones
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Andrewid the Android is a galaxy-famous detective. In his free time he likes to think about strings containing zeros and ones.
Once he thought about a string of length *n* consisting of zeroes and ones. Cons... | ```python
n = int(input())
a = input()
x = []
for i in a:
if len(x) == 0 or x[-1] == i:
x.append(i)
else:
x.pop()
print(len(x))
``` | 3 | |
978 | A | Remove Duplicates | PROGRAMMING | 800 | [
"implementation"
] | null | null | Petya has an array $a$ consisting of $n$ integers. He wants to remove duplicate (equal) elements.
Petya wants to leave only the rightmost entry (occurrence) for each element of the array. The relative order of the remaining unique elements should not be changed. | The first line contains a single integer $n$ ($1 \le n \le 50$) β the number of elements in Petya's array.
The following line contains a sequence $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 1\,000$) β the Petya's array. | In the first line print integer $x$ β the number of elements which will be left in Petya's array after he removed the duplicates.
In the second line print $x$ integers separated with a space β Petya's array after he removed the duplicates. For each unique element only the rightmost entry should be left. | [
"6\n1 5 5 1 6 1\n",
"5\n2 4 2 4 4\n",
"5\n6 6 6 6 6\n"
] | [
"3\n5 6 1 \n",
"2\n2 4 \n",
"1\n6 \n"
] | In the first example you should remove two integers $1$, which are in the positions $1$ and $4$. Also you should remove the integer $5$, which is in the position $2$.
In the second example you should remove integer $2$, which is in the position $1$, and two integers $4$, which are in the positions $2$ and $4$.
In the... | 0 | [
{
"input": "6\n1 5 5 1 6 1",
"output": "3\n5 6 1 "
},
{
"input": "5\n2 4 2 4 4",
"output": "2\n2 4 "
},
{
"input": "5\n6 6 6 6 6",
"output": "1\n6 "
},
{
"input": "7\n1 2 3 4 2 2 3",
"output": "4\n1 4 2 3 "
},
{
"input": "9\n100 100 100 99 99 99 100 100 100",
... | 1,700,129,966 | 2,147,483,647 | Python 3 | OK | TESTS | 28 | 46 | 0 | input()
num = list(map(int, input().split()))
unique = []
for i in reversed(num):
if i not in unique:
unique.insert(0, i)
print(len(unique))
print(" ".join(map(str, unique))) | Title: Remove Duplicates
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Petya has an array $a$ consisting of $n$ integers. He wants to remove duplicate (equal) elements.
Petya wants to leave only the rightmost entry (occurrence) for each element of the array. The relative order of the re... | ```python
input()
num = list(map(int, input().split()))
unique = []
for i in reversed(num):
if i not in unique:
unique.insert(0, i)
print(len(unique))
print(" ".join(map(str, unique)))
``` | 3 | |
58 | A | Chat room | PROGRAMMING | 1,000 | [
"greedy",
"strings"
] | A. Chat room | 1 | 256 | Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, ... | The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters. | If Vasya managed to say hello, print "YES", otherwise print "NO". | [
"ahhellllloou\n",
"hlelo\n"
] | [
"YES\n",
"NO\n"
] | none | 500 | [
{
"input": "ahhellllloou",
"output": "YES"
},
{
"input": "hlelo",
"output": "NO"
},
{
"input": "helhcludoo",
"output": "YES"
},
{
"input": "hehwelloho",
"output": "YES"
},
{
"input": "pnnepelqomhhheollvlo",
"output": "YES"
},
{
"input": "tymbzjyqhymeda... | 1,696,251,051 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 46 | 0 | w = input()
h=w.find('h')
e=w.find('e',h+1)
l=w.find('l',e+1)
l2=w.find('l',l+1)
o=w.find('o',l2+1)
if (h<e<l<l2<o) == True:
print("YES")
else:
print("NO") | Title: Chat room
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letter... | ```python
w = input()
h=w.find('h')
e=w.find('e',h+1)
l=w.find('l',e+1)
l2=w.find('l',l+1)
o=w.find('o',l2+1)
if (h<e<l<l2<o) == True:
print("YES")
else:
print("NO")
``` | 3.977 |
357 | A | Group of Students | PROGRAMMING | 1,000 | [
"brute force",
"greedy",
"implementation"
] | null | null | At the beginning of the school year Berland State University starts two city school programming groups, for beginners and for intermediate coders. The children were tested in order to sort them into groups. According to the results, each student got some score from 1 to *m* points. We know that *c*1 schoolchildren got ... | The first line contains integer *m* (2<=β€<=*m*<=β€<=100). The second line contains *m* integers *c*1, *c*2, ..., *c**m*, separated by single spaces (0<=β€<=*c**i*<=β€<=100). The third line contains two space-separated integers *x* and *y* (1<=β€<=*x*<=β€<=*y*<=β€<=10000). At least one *c**i* is greater than 0. | If it is impossible to pick a passing rate in a way that makes the size of each resulting groups at least *x* and at most *y*, print 0. Otherwise, print an integer from 1 to *m* β the passing rate you'd like to suggest. If there are multiple possible answers, print any of them. | [
"5\n3 4 3 2 1\n6 8\n",
"5\n0 3 3 4 2\n3 10\n",
"2\n2 5\n3 6\n"
] | [
"3\n",
"4\n",
"0\n"
] | In the first sample the beginner group has 7 students, the intermediate group has 6 of them.
In the second sample another correct answer is 3. | 500 | [
{
"input": "5\n3 4 3 2 1\n6 8",
"output": "3"
},
{
"input": "5\n0 3 3 4 2\n3 10",
"output": "4"
},
{
"input": "2\n2 5\n3 6",
"output": "0"
},
{
"input": "3\n0 1 0\n2 10",
"output": "0"
},
{
"input": "5\n2 2 2 2 2\n5 5",
"output": "0"
},
{
"input": "10\... | 1,586,624,871 | 2,147,483,647 | Python 3 | OK | TESTS | 58 | 109 | 307,200 | estudiantes = int(input())
calificaciones = list(str(input()).split())
xy = list(str(input()).split())
contador1 = 0
contador2 = 0
partitura = 0
entro = False
for i in range(len(calificaciones)):
calificaciones[i] = int(calificaciones[i])
xy[0] = int(xy[0])
xy[1] = int(xy[1])
for j in range(len(calificaciones)):
... | Title: Group of Students
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
At the beginning of the school year Berland State University starts two city school programming groups, for beginners and for intermediate coders. The children were tested in order to sort them into groups. According ... | ```python
estudiantes = int(input())
calificaciones = list(str(input()).split())
xy = list(str(input()).split())
contador1 = 0
contador2 = 0
partitura = 0
entro = False
for i in range(len(calificaciones)):
calificaciones[i] = int(calificaciones[i])
xy[0] = int(xy[0])
xy[1] = int(xy[1])
for j in range(len(calificac... | 3 | |
780 | A | Andryusha and Socks | PROGRAMMING | 800 | [
"implementation"
] | null | null | Andryusha is an orderly boy and likes to keep things in their place.
Today he faced a problem to put his socks in the wardrobe. He has *n* distinct pairs of socks which are initially in a bag. The pairs are numbered from 1 to *n*. Andryusha wants to put paired socks together and put them in the wardrobe. He takes the ... | The first line contains the single integer *n* (1<=β€<=*n*<=β€<=105)Β β the number of sock pairs.
The second line contains 2*n* integers *x*1,<=*x*2,<=...,<=*x*2*n* (1<=β€<=*x**i*<=β€<=*n*), which describe the order in which Andryusha took the socks from the bag. More precisely, *x**i* means that the *i*-th sock Andryusha ... | Print single integerΒ β the maximum number of socks that were on the table at the same time. | [
"1\n1 1\n",
"3\n2 1 1 3 2 3\n"
] | [
"1\n",
"2\n"
] | In the first example Andryusha took a sock from the first pair and put it on the table. Then he took the next sock which is from the first pair as well, so he immediately puts both socks to the wardrobe. Thus, at most one sock was on the table at the same time.
In the second example Andryusha behaved as follows:
- ... | 500 | [
{
"input": "1\n1 1",
"output": "1"
},
{
"input": "3\n2 1 1 3 2 3",
"output": "2"
},
{
"input": "5\n5 1 3 2 4 3 1 2 4 5",
"output": "5"
},
{
"input": "10\n4 2 6 3 4 8 7 1 1 5 2 10 6 8 3 5 10 9 9 7",
"output": "6"
},
{
"input": "50\n30 47 31 38 37 50 36 43 9 23 2 2 ... | 1,563,048,210 | 2,147,483,647 | Python 3 | OK | TESTS | 56 | 280 | 11,264,000 | n = int(input())
a = [0]*n
k = 0
km = 0
for i in input().split():
i = int(i) - 1
if a[i] == 0:
a[i] = 1
k += 1
if k > km: km = k
else:
a[i] = 0
k -= 1
print(km)
| Title: Andryusha and Socks
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Andryusha is an orderly boy and likes to keep things in their place.
Today he faced a problem to put his socks in the wardrobe. He has *n* distinct pairs of socks which are initially in a bag. The pairs are numbere... | ```python
n = int(input())
a = [0]*n
k = 0
km = 0
for i in input().split():
i = int(i) - 1
if a[i] == 0:
a[i] = 1
k += 1
if k > km: km = k
else:
a[i] = 0
k -= 1
print(km)
``` | 3 | |
851 | A | Arpa and a research in Mexican wave | PROGRAMMING | 800 | [
"implementation",
"math"
] | null | null | Arpa is researching the Mexican wave.
There are *n* spectators in the stadium, labeled from 1 to *n*. They start the Mexican wave at time 0.
- At time 1, the first spectator stands. - At time 2, the second spectator stands. - ... - At time *k*, the *k*-th spectator stands. - At time *k*<=+<=1, the (*k*<=+<=1)-t... | The first line contains three integers *n*, *k*, *t* (1<=β€<=*n*<=β€<=109, 1<=β€<=*k*<=β€<=*n*, 1<=β€<=*t*<=<<=*n*<=+<=*k*). | Print single integer: how many spectators are standing at time *t*. | [
"10 5 3\n",
"10 5 7\n",
"10 5 12\n"
] | [
"3\n",
"5\n",
"3\n"
] | In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
- At *t*β=β0β ---------- <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/4d97e684117250a9afe9be022ab8a63653dd15aa.png" style="max-width: 100.0%;max-height: 100.0%;"/> number of standing spe... | 500 | [
{
"input": "10 5 3",
"output": "3"
},
{
"input": "10 5 7",
"output": "5"
},
{
"input": "10 5 12",
"output": "3"
},
{
"input": "840585600 770678331 788528791",
"output": "770678331"
},
{
"input": "25462281 23343504 8024619",
"output": "8024619"
},
{
"in... | 1,504,537,424 | 1,724 | PyPy 3 | OK | TESTS | 166 | 124 | 307,200 | mass = input().split()
n = int(mass[0])
k = int(mass[1])
t = int(mass[2])
'''for i in range(1, t + 1):
if i <= k:
result = result + 1
elif i <= n:
result = result
else:
result = result - 1
'''
if t <= k:
print(t)
elif t <= n:
print(k)
else:
print(... | Title: Arpa and a research in Mexican wave
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Arpa is researching the Mexican wave.
There are *n* spectators in the stadium, labeled from 1 to *n*. They start the Mexican wave at time 0.
- At time 1, the first spectator stands. - At time 2,... | ```python
mass = input().split()
n = int(mass[0])
k = int(mass[1])
t = int(mass[2])
'''for i in range(1, t + 1):
if i <= k:
result = result + 1
elif i <= n:
result = result
else:
result = result - 1
'''
if t <= k:
print(t)
elif t <= n:
print(k)
else:
... | 3 | |
453 | A | Little Pony and Expected Maximum | PROGRAMMING | 1,600 | [
"probabilities"
] | null | null | Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has *m* faces: the first face of the dice contains a dot, the second one contains two dots... | A single line contains two integers *m* and *n* (1<=β€<=*m*,<=*n*<=β€<=105). | Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10<=<=-<=4. | [
"6 1\n",
"6 3\n",
"2 2\n"
] | [
"3.500000000000\n",
"4.958333333333\n",
"1.750000000000\n"
] | Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2. 1. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1. 1. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2. 1. You can get 2 in t... | 500 | [
{
"input": "6 1",
"output": "3.500000000000"
},
{
"input": "6 3",
"output": "4.958333333333"
},
{
"input": "2 2",
"output": "1.750000000000"
},
{
"input": "5 4",
"output": "4.433600000000"
},
{
"input": "5 8",
"output": "4.814773760000"
},
{
"input": "... | 1,602,940,343 | 2,147,483,647 | Python 3 | OK | TESTS | 41 | 187 | 0 | def prob(m, n):
ans = 0.0
i = m
while (i):
ans += (pow(i / m, n) - pow((i - 1) / m, n)) * i
i = i - 1
return ans
m, n = map(int, input().split())
print(prob(m, n))
| Title: Little Pony and Expected Maximum
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were ... | ```python
def prob(m, n):
ans = 0.0
i = m
while (i):
ans += (pow(i / m, n) - pow((i - 1) / m, n)) * i
i = i - 1
return ans
m, n = map(int, input().split())
print(prob(m, n))
``` | 3 | |
768 | A | Oath of the Night's Watch | PROGRAMMING | 900 | [
"constructive algorithms",
"sortings"
] | null | null | "Night gathers, and now my watch begins. It shall not end until my death. I shall take no wife, hold no lands, father no children. I shall wear no crowns and win no glory. I shall live and die at my post. I am the sword in the darkness. I am the watcher on the walls. I am the shield that guards the realms of men. I ple... | First line consists of a single integer *n* (1<=β€<=*n*<=β€<=105) β the number of stewards with Jon Snow.
Second line consists of *n* space separated integers *a*1,<=*a*2,<=...,<=*a**n* (0<=β€<=*a**i*<=β€<=109) representing the values assigned to the stewards. | Output a single integer representing the number of stewards which Jon will feed. | [
"2\n1 5\n",
"3\n1 2 5\n"
] | [
"0",
"1"
] | In the first sample, Jon Snow cannot support steward with strength 1 because there is no steward with strength less than 1 and he cannot support steward with strength 5 because there is no steward with strength greater than 5.
In the second sample, Jon Snow can support steward with strength 2 because there are steward... | 500 | [
{
"input": "2\n1 5",
"output": "0"
},
{
"input": "3\n1 2 5",
"output": "1"
},
{
"input": "4\n1 2 3 4",
"output": "2"
},
{
"input": "8\n7 8 9 4 5 6 1 2",
"output": "6"
},
{
"input": "1\n1",
"output": "0"
},
{
"input": "1\n100",
"output": "0"
},
... | 1,657,178,590 | 2,147,483,647 | Python 3 | OK | TESTS | 88 | 108 | 9,113,600 | x = int(input())
s = list(map(int,input().split()))
c = 0
max = max(s)
min = min(s)
for i in range(0,x):
if s[i] != max and s[i]!=min:
c = c + 1
print(c) | Title: Oath of the Night's Watch
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
"Night gathers, and now my watch begins. It shall not end until my death. I shall take no wife, hold no lands, father no children. I shall wear no crowns and win no glory. I shall live and die at my post. I am... | ```python
x = int(input())
s = list(map(int,input().split()))
c = 0
max = max(s)
min = min(s)
for i in range(0,x):
if s[i] != max and s[i]!=min:
c = c + 1
print(c)
``` | 3 | |
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 megabyt... | 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"
... | 1,688,846,066 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 46 | 0 | #Code:
test=[]
for i in range(int(input())+1):
test.append(int(input()))
size= test[0]
test.remove(test[0])
test.sort(reverse=True)
c=0
n=0
while c<size:
a= test[0]
c=c+a
n=n+1
test.remove(test[0])
print(n) | 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... | ```python
#Code:
test=[]
for i in range(int(input())+1):
test.append(int(input()))
size= test[0]
test.remove(test[0])
test.sort(reverse=True)
c=0
n=0
while c<size:
a= test[0]
c=c+a
n=n+1
test.remove(test[0])
print(n)
``` | 3 | |
61 | A | Ultra-Fast Mathematician | PROGRAMMING | 800 | [
"implementation"
] | A. Ultra-Fast Mathematician | 2 | 256 | Shapur was an extremely gifted student. He was great at everything including Combinatorics, Algebra, Number Theory, Geometry, Calculus, etc. He was not only smart but extraordinarily fast! He could manage to sum 1018 numbers in a single second.
One day in 230 AD Shapur was trying to find out if any one can possibly do... | There are two lines in each input. Each of them contains a single number. It is guaranteed that the numbers are made from 0 and 1 only and that their length is same. The numbers may start with 0. The length of each number doesn't exceed 100. | Write one line β the corresponding answer. Do not omit the leading 0s. | [
"1010100\n0100101\n",
"000\n111\n",
"1110\n1010\n",
"01110\n01100\n"
] | [
"1110001\n",
"111\n",
"0100\n",
"00010\n"
] | none | 500 | [
{
"input": "1010100\n0100101",
"output": "1110001"
},
{
"input": "000\n111",
"output": "111"
},
{
"input": "1110\n1010",
"output": "0100"
},
{
"input": "01110\n01100",
"output": "00010"
},
{
"input": "011101\n000001",
"output": "011100"
},
{
"input": "... | 1,592,494,845 | 2,147,483,647 | Python 3 | OK | TESTS | 102 | 139 | 0 | s1 = input();s2 = input();string = ""
for i in range(len(s1)):
if s1[i] == s2[i]:string += '0'
else:string += '1'
print(string) | Title: Ultra-Fast Mathematician
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Shapur was an extremely gifted student. He was great at everything including Combinatorics, Algebra, Number Theory, Geometry, Calculus, etc. He was not only smart but extraordinarily fast! He could manage to sum 10... | ```python
s1 = input();s2 = input();string = ""
for i in range(len(s1)):
if s1[i] == s2[i]:string += '0'
else:string += '1'
print(string)
``` | 3.96525 |
344 | A | Magnets | PROGRAMMING | 800 | [
"implementation"
] | null | null | Mad scientist Mike entertains himself by arranging rows of dominoes. He doesn't need dominoes, though: he uses rectangular magnets instead. Each magnet has two poles, positive (a "plus") and negative (a "minus"). If two magnets are put together at a close distance, then the like poles will repel each other and the oppo... | The first line of the input contains an integer *n* (1<=β€<=*n*<=β€<=100000) β the number of magnets. Then *n* lines follow. The *i*-th line (1<=β€<=*i*<=β€<=*n*) contains either characters "01", if Mike put the *i*-th magnet in the "plus-minus" position, or characters "10", if Mike put the magnet in the "minus-plus" posit... | On the single line of the output print the number of groups of magnets. | [
"6\n10\n10\n10\n01\n10\n10\n",
"4\n01\n01\n10\n10\n"
] | [
"3\n",
"2\n"
] | The first testcase corresponds to the figure. The testcase has three groups consisting of three, one and two magnets.
The second testcase has two groups, each consisting of two magnets. | 500 | [
{
"input": "6\n10\n10\n10\n01\n10\n10",
"output": "3"
},
{
"input": "4\n01\n01\n10\n10",
"output": "2"
},
{
"input": "1\n10",
"output": "1"
},
{
"input": "2\n01\n10",
"output": "2"
},
{
"input": "2\n10\n10",
"output": "1"
},
{
"input": "3\n10\n01\n10",... | 1,699,016,498 | 2,147,483,647 | Python 3 | OK | TESTS | 31 | 278 | 8,704,000 | n=int(input())
m_o=[input() for _ in range(n)]
grp=1
for i in range(1,n):
if m_o[i]!=m_o[i-1]:
grp+=1
print(grp)
| Title: Magnets
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mad scientist Mike entertains himself by arranging rows of dominoes. He doesn't need dominoes, though: he uses rectangular magnets instead. Each magnet has two poles, positive (a "plus") and negative (a "minus"). If two magnets... | ```python
n=int(input())
m_o=[input() for _ in range(n)]
grp=1
for i in range(1,n):
if m_o[i]!=m_o[i-1]:
grp+=1
print(grp)
``` | 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. - Icosahed... | 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" (withou... | 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\nIcosa... | 1,690,249,748 | 2,147,483,647 | PyPy 3 | OK | TESTS | 30 | 1,512 | 9,523,200 | # LUOGU_RID: 117305460
n = int(input().strip())
ans = 0
while n:
n -= 1
q = input().strip()
if q == "Tetrahedron":
ans += 4
elif q == "Cube":
ans += 6
elif q == "Octahedron":
ans += 8
elif q == "Dodecahedron":
ans += 12
else:
ans += 20
p... | 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. - Octahe... | ```python
# LUOGU_RID: 117305460
n = int(input().strip())
ans = 0
while n:
n -= 1
q = input().strip()
if q == "Tetrahedron":
ans += 4
elif q == "Cube":
ans += 6
elif q == "Octahedron":
ans += 8
elif q == "Dodecahedron":
ans += 12
else:
an... | 3 | |
710 | B | Optimal Point on a Line | PROGRAMMING | 1,400 | [
"brute force",
"sortings"
] | null | null | You are given *n* points on a line with their coordinates *x**i*. Find the point *x* so the sum of distances to the given points is minimal. | The first line contains integer *n* (1<=β€<=*n*<=β€<=3Β·105) β the number of points on the line.
The second line contains *n* integers *x**i* (<=-<=109<=β€<=*x**i*<=β€<=109) β the coordinates of the given *n* points. | Print the only integer *x* β the position of the optimal point on the line. If there are several optimal points print the position of the leftmost one. It is guaranteed that the answer is always the integer. | [
"4\n1 2 3 4\n"
] | [
"2\n"
] | none | 0 | [
{
"input": "4\n1 2 3 4",
"output": "2"
},
{
"input": "5\n-1 -10 2 6 7",
"output": "2"
},
{
"input": "10\n-68 10 87 22 30 89 82 -97 -52 25",
"output": "22"
},
{
"input": "100\n457 827 807 17 871 935 907 -415 536 170 551 -988 865 758 -457 -892 -875 -488 684 19 0 555 -807 -624 -... | 1,473,153,236 | 2,147,483,647 | Python 3 | OK | TESTS | 42 | 342 | 22,937,600 | n = int(input())
a = [int(i) for i in input().split()]
a.sort()
if n % 2 == 0:
x = n // 2
else:
x = (n + 1) // 2
print(a[x-1])
| Title: Optimal Point on a Line
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given *n* points on a line with their coordinates *x**i*. Find the point *x* so the sum of distances to the given points is minimal.
Input Specification:
The first line contains integer *n* (1<=β€<=*n*<=... | ```python
n = int(input())
a = [int(i) for i in input().split()]
a.sort()
if n % 2 == 0:
x = n // 2
else:
x = (n + 1) // 2
print(a[x-1])
``` | 3 | |
719 | B | Anatoly and Cockroaches | PROGRAMMING | 1,400 | [
"greedy"
] | null | null | Anatoly lives in the university dorm as many other students do. As you know, cockroaches are also living there together with students. Cockroaches might be of two colors: black and red. There are *n* cockroaches living in Anatoly's room.
Anatoly just made all his cockroaches to form a single line. As he is a perfectio... | The first line of the input contains a single integer *n* (1<=β€<=*n*<=β€<=100<=000)Β β the number of cockroaches.
The second line contains a string of length *n*, consisting of characters 'b' and 'r' that denote black cockroach and red cockroach respectively. | Print one integerΒ β the minimum number of moves Anatoly has to perform in order to make the colors of cockroaches in the line to alternate. | [
"5\nrbbrr\n",
"5\nbbbbb\n",
"3\nrbr\n"
] | [
"1\n",
"2\n",
"0\n"
] | In the first sample, Anatoly has to swap third and fourth cockroaches. He needs 1 turn to do this.
In the second sample, the optimum answer is to paint the second and the fourth cockroaches red. This requires 2 turns.
In the third sample, the colors of cockroaches in the line are alternating already, thus the answer ... | 1,000 | [
{
"input": "5\nrbbrr",
"output": "1"
},
{
"input": "5\nbbbbb",
"output": "2"
},
{
"input": "3\nrbr",
"output": "0"
},
{
"input": "13\nrbbbrbrrbrrbb",
"output": "3"
},
{
"input": "18\nrrrrrrrrrrrrrrrrrb",
"output": "8"
},
{
"input": "100\nbrbbbrrrbbrbrb... | 1,474,652,923 | 2,147,483,647 | Python 3 | OK | TESTS | 46 | 249 | 716,800 | n = int(input())
s = list(input())
order = "rb"
data0 = sum(map(lambda x, y: order.index(x) == 0 and y % 2 == 0 , s, range(n)))
data1 = sum(map(lambda x, y: order.index(x) == 1 and y % 2 == 1 , s, range(n)))
count1 = max(data0, data1)
order = "br"
data0 = sum(map(lambda x, y: order.index(x) == 0 and y % 2 =... | Title: Anatoly and Cockroaches
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Anatoly lives in the university dorm as many other students do. As you know, cockroaches are also living there together with students. Cockroaches might be of two colors: black and red. There are *n* cockroaches... | ```python
n = int(input())
s = list(input())
order = "rb"
data0 = sum(map(lambda x, y: order.index(x) == 0 and y % 2 == 0 , s, range(n)))
data1 = sum(map(lambda x, y: order.index(x) == 1 and y % 2 == 1 , s, range(n)))
count1 = max(data0, data1)
order = "br"
data0 = sum(map(lambda x, y: order.index(x) == 0 a... | 3 | |
699 | A | Launch of Collider | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | There will be a launch of a new, powerful and unusual collider very soon, which located along a straight line. *n* particles will be launched inside it. All of them are located in a straight line and there can not be two or more particles located in the same point. The coordinates of the particles coincide with the dis... | The first line contains the positive integer *n* (1<=β€<=*n*<=β€<=200<=000)Β β the number of particles.
The second line contains *n* symbols "L" and "R". If the *i*-th symbol equals "L", then the *i*-th particle will move to the left, otherwise the *i*-th symbol equals "R" and the *i*-th particle will move to the right.... | In the first line print the only integerΒ β the first moment (in microseconds) when two particles are at the same point and there will be an explosion.
Print the only integer -1, if the collision of particles doesn't happen. | [
"4\nRLRL\n2 4 6 10\n",
"3\nLLR\n40 50 60\n"
] | [
"1\n",
"-1\n"
] | In the first sample case the first explosion will happen in 1 microsecond because the particles number 1 and 2 will simultaneously be at the same point with the coordinate 3.
In the second sample case there will be no explosion because there are no particles which will simultaneously be at the same point. | 500 | [
{
"input": "4\nRLRL\n2 4 6 10",
"output": "1"
},
{
"input": "3\nLLR\n40 50 60",
"output": "-1"
},
{
"input": "4\nRLLR\n46 230 264 470",
"output": "92"
},
{
"input": "6\nLLRLLL\n446 492 650 844 930 970",
"output": "97"
},
{
"input": "8\nRRLLLLLL\n338 478 512 574 59... | 1,667,568,059 | 2,147,483,647 | Python 3 | OK | TESTS | 85 | 218 | 16,179,200 |
num = int(input())
directions = input()
positions = list(map(int, input().split(' ')))
count = positions[-1]
stop = True
for ind in range(num-1):
if(directions[ind]!=directions[ind+1]):
x = (positions[ind]-positions[ind+1])
if ( directions[ind]=='R'):
... | Title: Launch of Collider
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There will be a launch of a new, powerful and unusual collider very soon, which located along a straight line. *n* particles will be launched inside it. All of them are located in a straight line and there can not be... | ```python
num = int(input())
directions = input()
positions = list(map(int, input().split(' ')))
count = positions[-1]
stop = True
for ind in range(num-1):
if(directions[ind]!=directions[ind+1]):
x = (positions[ind]-positions[ind+1])
if ( directions[ind]=='R'):
... | 3 | |
991 | B | Getting an A | PROGRAMMING | 900 | [
"greedy",
"sortings"
] | null | null | Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that... | The first line contains a single integer $n$Β β the number of Vasya's grades ($1 \leq n \leq 100$).
The second line contains $n$ integers from $2$ to $5$Β β Vasya's grades for his lab works. | Output a single integerΒ β the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a $5$. | [
"3\n4 4 4\n",
"4\n5 4 5 5\n",
"4\n5 3 3 5\n"
] | [
"2\n",
"0\n",
"1\n"
] | In the first sample, it is enough to redo two lab works to make two $4$s into $5$s.
In the second sample, Vasya's average is already $4.75$ so he doesn't have to redo anything to get a $5$.
In the second sample Vasya has to redo one lab work to get rid of one of the $3$s, that will make the average exactly $4.5$ so t... | 1,000 | [
{
"input": "3\n4 4 4",
"output": "2"
},
{
"input": "4\n5 4 5 5",
"output": "0"
},
{
"input": "4\n5 3 3 5",
"output": "1"
},
{
"input": "1\n5",
"output": "0"
},
{
"input": "4\n3 2 5 4",
"output": "2"
},
{
"input": "5\n5 4 3 2 5",
"output": "2"
},
... | 1,609,999,996 | 2,147,483,647 | PyPy 3 | OK | TESTS | 61 | 155 | 0 | n = int(input())
a = list(map(int, input().strip().split()))
a.sort()
s = sum(a)
ans = 0
for i in range(n):
if 2 * s >= n * 9:
print(ans)
exit(0)
delta = 5 - a[i]
s += delta
ans += 1
print(ans)
| Title: Getting an A
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming t... | ```python
n = int(input())
a = list(map(int, input().strip().split()))
a.sort()
s = sum(a)
ans = 0
for i in range(n):
if 2 * s >= n * 9:
print(ans)
exit(0)
delta = 5 - a[i]
s += delta
ans += 1
print(ans)
``` | 3 | |
275 | A | Lights Out | PROGRAMMING | 900 | [
"implementation"
] | null | null | Lenny is playing a game on a 3<=Γ<=3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be sw... | The input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The *j*-th number in the *i*-th row is the number of times the *j*-th light of the *i*-th row of the grid is pressed. | Print three lines, each containing three characters. The *j*-th character of the *i*-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0". | [
"1 0 0\n0 0 0\n0 0 1\n",
"1 0 1\n8 8 8\n2 0 3\n"
] | [
"001\n010\n100\n",
"010\n011\n100\n"
] | none | 500 | [
{
"input": "1 0 0\n0 0 0\n0 0 1",
"output": "001\n010\n100"
},
{
"input": "1 0 1\n8 8 8\n2 0 3",
"output": "010\n011\n100"
},
{
"input": "13 85 77\n25 50 45\n65 79 9",
"output": "000\n010\n000"
},
{
"input": "96 95 5\n8 84 74\n67 31 61",
"output": "011\n011\n101"
},
{... | 1,630,462,828 | 2,147,483,647 | PyPy 3 | OK | TESTS | 33 | 109 | 20,172,800 | from sys import stdin, stdout
def read():
return stdin.readline().rstrip()
def read_int():
return int(read())
def read_ints():
return list(map(int, read().split()))
def solve():
a=[[1,1,1],[1,1,1],[1,1,1]]
for i in range(3):
v=read_ints()
for j in range(3):
if v[j]%2==1:
for (nx, ny... | Title: Lights Out
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Lenny is playing a game on a 3<=Γ<=3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the ... | ```python
from sys import stdin, stdout
def read():
return stdin.readline().rstrip()
def read_int():
return int(read())
def read_ints():
return list(map(int, read().split()))
def solve():
a=[[1,1,1],[1,1,1],[1,1,1]]
for i in range(3):
v=read_ints()
for j in range(3):
if v[j]%2==1:
f... | 3 | |
994 | A | Fingerprints | PROGRAMMING | 800 | [
"implementation"
] | null | null | You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keypad have fingerprints. You believe the correct code is the longest not necessarily contiguous subse... | The first line contains two integers $n$ and $m$ ($1 \le n, m \le 10$) representing the number of digits in the sequence you have and the number of keys on the keypad that have fingerprints.
The next line contains $n$ distinct space-separated integers $x_1, x_2, \ldots, x_n$ ($0 \le x_i \le 9$) representing the sequen... | In a single line print a space-separated sequence of integers representing the code. If the resulting sequence is empty, both printing nothing and printing a single line break is acceptable. | [
"7 3\n3 5 7 1 6 2 8\n1 2 7\n",
"4 4\n3 4 1 0\n0 1 7 9\n"
] | [
"7 1 2\n",
"1 0\n"
] | In the first example, the only digits with fingerprints are $1$, $2$ and $7$. All three of them appear in the sequence you know, $7$ first, then $1$ and then $2$. Therefore the output is 7 1 2. Note that the order is important, and shall be the same as the order in the original sequence.
In the second example digits $... | 500 | [
{
"input": "7 3\n3 5 7 1 6 2 8\n1 2 7",
"output": "7 1 2"
},
{
"input": "4 4\n3 4 1 0\n0 1 7 9",
"output": "1 0"
},
{
"input": "9 4\n9 8 7 6 5 4 3 2 1\n2 4 6 8",
"output": "8 6 4 2"
},
{
"input": "10 5\n3 7 1 2 4 6 9 0 5 8\n4 3 0 7 9",
"output": "3 7 4 9 0"
},
{
"... | 1,538,317,360 | 760 | Python 3 | OK | TESTS | 31 | 124 | 0 | a,b = map(int,input().split())
y = [int(i) for i in input().split()]
g = {i for i in input().split()}
s = []
for i in range(a):
if str(y[i]) in g:
s.append(y[i])
for i in range(len(s)):
print(s[i],end=' ') | Title: Fingerprints
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are locked in a room with a door that has a keypad with 10 keys corresponding to digits from 0 to 9. To escape from the room, you need to enter a correct code. You also have a sequence of digits.
Some keys on the keyp... | ```python
a,b = map(int,input().split())
y = [int(i) for i in input().split()]
g = {i for i in input().split()}
s = []
for i in range(a):
if str(y[i]) in g:
s.append(y[i])
for i in range(len(s)):
print(s[i],end=' ')
``` | 3 | |
158 | A | Next Round | PROGRAMMING | 800 | [
"*special",
"implementation"
] | null | null | "Contestant who earns a score equal to or greater than the *k*-th place finisher's score will advance to the next round, as long as the contestant earns a positive score..." β an excerpt from contest rules.
A total of *n* participants took part in the contest (*n*<=β₯<=*k*), and you already know their scores. Calculate... | The first line of the input contains two integers *n* and *k* (1<=β€<=*k*<=β€<=*n*<=β€<=50) separated by a single space.
The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (0<=β€<=*a**i*<=β€<=100), where *a**i* is the score earned by the participant who got the *i*-th place. The given sequence... | Output the number of participants who advance to the next round. | [
"8 5\n10 9 8 7 7 7 5 5\n",
"4 2\n0 0 0 0\n"
] | [
"6\n",
"0\n"
] | In the first example the participant on the 5th place earned 7 points. As the participant on the 6th place also earned 7 points, there are 6 advancers.
In the second example nobody got a positive score. | 500 | [
{
"input": "8 5\n10 9 8 7 7 7 5 5",
"output": "6"
},
{
"input": "4 2\n0 0 0 0",
"output": "0"
},
{
"input": "5 1\n1 1 1 1 1",
"output": "5"
},
{
"input": "5 5\n1 1 1 1 1",
"output": "5"
},
{
"input": "1 1\n10",
"output": "1"
},
{
"input": "17 14\n16 15... | 1,699,033,293 | 2,147,483,647 | Python 3 | OK | TESTS | 50 | 92 | 0 | n, k = map(int, input().split())
scores = list(map(int, input().split()))
t = 0
min_score = scores[k-1]
for s in scores:
if s >= min_score and s > 0:
t += 1
print(t)
| Title: Next Round
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
"Contestant who earns a score equal to or greater than the *k*-th place finisher's score will advance to the next round, as long as the contestant earns a positive score..." β an excerpt from contest rules.
A total of *n* p... | ```python
n, k = map(int, input().split())
scores = list(map(int, input().split()))
t = 0
min_score = scores[k-1]
for s in scores:
if s >= min_score and s > 0:
t += 1
print(t)
``` | 3 | |
699 | A | Launch of Collider | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | There will be a launch of a new, powerful and unusual collider very soon, which located along a straight line. *n* particles will be launched inside it. All of them are located in a straight line and there can not be two or more particles located in the same point. The coordinates of the particles coincide with the dis... | The first line contains the positive integer *n* (1<=β€<=*n*<=β€<=200<=000)Β β the number of particles.
The second line contains *n* symbols "L" and "R". If the *i*-th symbol equals "L", then the *i*-th particle will move to the left, otherwise the *i*-th symbol equals "R" and the *i*-th particle will move to the right.... | In the first line print the only integerΒ β the first moment (in microseconds) when two particles are at the same point and there will be an explosion.
Print the only integer -1, if the collision of particles doesn't happen. | [
"4\nRLRL\n2 4 6 10\n",
"3\nLLR\n40 50 60\n"
] | [
"1\n",
"-1\n"
] | In the first sample case the first explosion will happen in 1 microsecond because the particles number 1 and 2 will simultaneously be at the same point with the coordinate 3.
In the second sample case there will be no explosion because there are no particles which will simultaneously be at the same point. | 500 | [
{
"input": "4\nRLRL\n2 4 6 10",
"output": "1"
},
{
"input": "3\nLLR\n40 50 60",
"output": "-1"
},
{
"input": "4\nRLLR\n46 230 264 470",
"output": "92"
},
{
"input": "6\nLLRLLL\n446 492 650 844 930 970",
"output": "97"
},
{
"input": "8\nRRLLLLLL\n338 478 512 574 59... | 1,610,083,488 | 2,147,483,647 | Python 3 | OK | TESTS | 85 | 405 | 15,974,400 | n = int(input())
s = input()
x = [int(x) for x in input().split()]
a = [0 for x in range(n)]
a[-1]=-1
for i in range(len(a)-2,-1,-1):
if s[i+1]=='L':
a[i]=i+1
else:
a[i]=a[i+1]
mini = float('inf')
flag = False
for i in range(len(x)):
if s[i]=='R' and a[i]!=-1:
mini = mi... | Title: Launch of Collider
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There will be a launch of a new, powerful and unusual collider very soon, which located along a straight line. *n* particles will be launched inside it. All of them are located in a straight line and there can not be... | ```python
n = int(input())
s = input()
x = [int(x) for x in input().split()]
a = [0 for x in range(n)]
a[-1]=-1
for i in range(len(a)-2,-1,-1):
if s[i+1]=='L':
a[i]=i+1
else:
a[i]=a[i+1]
mini = float('inf')
flag = False
for i in range(len(x)):
if s[i]=='R' and a[i]!=-1:
... | 3 | |
194 | A | Exams | PROGRAMMING | 900 | [
"implementation",
"math"
] | null | null | One day the Codeforces round author sat exams. He had *n* exams and he needed to get an integer from 2 to 5 for each exam. He will have to re-sit each failed exam, i.e. the exam that gets mark 2.
The author would need to spend too much time and effort to make the sum of his marks strictly more than *k*. That could ha... | The single input line contains space-separated integers *n* and *k* (1<=β€<=*n*<=β€<=50, 1<=β€<=*k*<=β€<=250) β the number of exams and the required sum of marks.
It is guaranteed that there exists a way to pass *n* exams in the way that makes the sum of marks equal exactly *k*. | Print the single number β the minimum number of exams that the author will get a 2 for, considering that the sum of marks for all exams must equal *k*. | [
"4 8\n",
"4 10\n",
"1 3\n"
] | [
"4\n",
"2\n",
"0\n"
] | In the first sample the author has to get a 2 for all his exams.
In the second sample he should get a 3 for two exams and a 2 for two more.
In the third sample he should get a 3 for one exam. | 500 | [
{
"input": "4 8",
"output": "4"
},
{
"input": "4 10",
"output": "2"
},
{
"input": "1 3",
"output": "0"
},
{
"input": "1 2",
"output": "1"
},
{
"input": "4 9",
"output": "3"
},
{
"input": "50 234",
"output": "0"
},
{
"input": "50 100",
"... | 1,693,844,420 | 2,147,483,647 | Python 3 | OK | TESTS | 38 | 92 | 0 | n, k = map(int, input().split())
print(max(3*n-k, 0)) | Title: Exams
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day the Codeforces round author sat exams. He had *n* exams and he needed to get an integer from 2 to 5 for each exam. He will have to re-sit each failed exam, i.e. the exam that gets mark 2.
The author would need to spend ... | ```python
n, k = map(int, input().split())
print(max(3*n-k, 0))
``` | 3 | |
271 | A | Beautiful Year | PROGRAMMING | 800 | [
"brute force"
] | null | null | It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits.
Now you are suggested to solve the following problem: given a year number, find the minimum year number which is strictly larger than the given one and has on... | The single line contains integer *y* (1000<=β€<=*y*<=β€<=9000) β the year number. | Print a single integer β the minimum year number that is strictly larger than *y* and all it's digits are distinct. It is guaranteed that the answer exists. | [
"1987\n",
"2013\n"
] | [
"2013\n",
"2014\n"
] | none | 500 | [
{
"input": "1987",
"output": "2013"
},
{
"input": "2013",
"output": "2014"
},
{
"input": "1000",
"output": "1023"
},
{
"input": "1001",
"output": "1023"
},
{
"input": "1234",
"output": "1235"
},
{
"input": "5555",
"output": "5601"
},
{
"inp... | 1,690,042,543 | 2,147,483,647 | Python 3 | OK | TESTS | 27 | 92 | 0 | a=int(input())
while True:
a+=1
if len(set(str(a)))==len(str(a)):
print(a)
break | Title: Beautiful Year
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits.
Now you are suggested to solve the following problem: give... | ```python
a=int(input())
while True:
a+=1
if len(set(str(a)))==len(str(a)):
print(a)
break
``` | 3 | |
29 | C | Mail Stamps | PROGRAMMING | 1,700 | [
"data structures",
"dfs and similar",
"graphs",
"implementation"
] | C. Mail Stamps | 2 | 256 | One day Bob got a letter in an envelope. Bob knows that when Berland's post officers send a letter directly from city Β«AΒ» to city Β«BΒ», they stamp it with Β«A BΒ», or Β«B AΒ». Unfortunately, often it is impossible to send a letter directly from the city of the sender to the city of the receiver, that's why the letter is sen... | The first line contains integer *n* (1<=β€<=*n*<=β€<=105) β amount of mail stamps on the envelope. Then there follow *n* lines with two integers each β description of the stamps. Each stamp is described with indexes of the cities between which a letter is sent. The indexes of cities are integers from 1 to 109. Indexes of... | Output *n*<=+<=1 numbers β indexes of cities in one of the two possible routes of the letter. | [
"2\n1 100\n100 2\n",
"3\n3 1\n100 2\n3 2\n"
] | [
"2 100 1 ",
"100 2 3 1 "
] | none | 1,500 | [
{
"input": "2\n1 100\n100 2",
"output": "2 100 1 "
},
{
"input": "3\n3 1\n100 2\n3 2",
"output": "100 2 3 1 "
},
{
"input": "3\n458744979 589655889\n248228386 824699605\n458744979 824699605",
"output": "589655889 458744979 824699605 248228386 "
},
{
"input": "4\n90104473 2210... | 1,615,519,075 | 2,147,483,647 | PyPy 3 | OK | TESTS | 20 | 1,154 | 20,992,000 | import sys
from collections import deque
input = sys.stdin.readline
g={}
v=set()
for _ in range(int(input())):
a,b=[int(x) for x in input().split()]
if a in v:
v.remove(a)
else:
v.add(a)
if b in v:
v.remove(b)
else:
v.add(b)
if a in g:
g[a]... | Title: Mail Stamps
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
One day Bob got a letter in an envelope. Bob knows that when Berland's post officers send a letter directly from city Β«AΒ» to city Β«BΒ», they stamp it with Β«A BΒ», or Β«B AΒ». Unfortunately, often it is impossible to send a letter d... | ```python
import sys
from collections import deque
input = sys.stdin.readline
g={}
v=set()
for _ in range(int(input())):
a,b=[int(x) for x in input().split()]
if a in v:
v.remove(a)
else:
v.add(a)
if b in v:
v.remove(b)
else:
v.add(b)
if a in g:
... | 3.672399 |
779 | C | Dishonest Sellers | PROGRAMMING | 1,200 | [
"constructive algorithms",
"greedy",
"sortings"
] | null | null | Igor found out discounts in a shop and decided to buy *n* items. Discounts at the store will last for a week and Igor knows about each item that its price now is *a**i*, and after a week of discounts its price will be *b**i*.
Not all of sellers are honest, so now some products could be more expensive than after a week... | In the first line there are two positive integer numbers *n* and *k* (1<=β€<=*n*<=β€<=2Β·105, 0<=β€<=*k*<=β€<=*n*) β total number of items to buy and minimal number of items Igor wants to by right now.
The second line contains sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=104) β prices of items during d... | Print the minimal amount of money Igor will spend to buy all *n* items. Remember, he should buy at least *k* items right now. | [
"3 1\n5 4 6\n3 1 5\n",
"5 3\n3 4 7 10 3\n4 5 5 12 5\n"
] | [
"10\n",
"25\n"
] | In the first example Igor should buy item 3 paying 6. But items 1 and 2 he should buy after a week. He will pay 3 and 1 for them. So in total he will pay 6β+β3β+β1β=β10.
In the second example Igor should buy right now items 1, 2, 4 and 5, paying for them 3, 4, 10 and 3, respectively. Item 3 he should buy after a week ... | 1,000 | [
{
"input": "3 1\n5 4 6\n3 1 5",
"output": "10"
},
{
"input": "5 3\n3 4 7 10 3\n4 5 5 12 5",
"output": "25"
},
{
"input": "1 0\n9\n8",
"output": "8"
},
{
"input": "2 0\n4 10\n1 2",
"output": "3"
},
{
"input": "4 2\n19 5 17 13\n3 18 8 10",
"output": "29"
},
... | 1,617,528,439 | 2,147,483,647 | PyPy 3 | OK | TESTS | 67 | 358 | 23,040,000 | import sys
from os import path
if (path.exists('input.txt') and path.exists('output.txt')):
sys.stdout = open('output.txt', 'w')
sys.stdin = open('input.txt', 'r')
def main():
n, k = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
di... | Title: Dishonest Sellers
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Igor found out discounts in a shop and decided to buy *n* items. Discounts at the store will last for a week and Igor knows about each item that its price now is *a**i*, and after a week of discounts its price will be... | ```python
import sys
from os import path
if (path.exists('input.txt') and path.exists('output.txt')):
sys.stdout = open('output.txt', 'w')
sys.stdin = open('input.txt', 'r')
def main():
n, k = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split... | 3 | |
701 | B | Cells Not Under Attack | PROGRAMMING | 1,200 | [
"data structures",
"math"
] | null | null | Vasya has the square chessboard of size *n*<=Γ<=*n* and *m* rooks. Initially the chessboard is empty. Vasya will consequently put the rooks on the board one after another.
The cell of the field is under rook's attack, if there is at least one rook located in the same row or in the same column with this cell. If there ... | The first line of the input contains two integers *n* and *m* (1<=β€<=*n*<=β€<=100<=000, 1<=β€<=*m*<=β€<=*min*(100<=000,<=*n*2))Β β the size of the board and the number of rooks.
Each of the next *m* lines contains integers *x**i* and *y**i* (1<=β€<=*x**i*,<=*y**i*<=β€<=*n*)Β β the number of the row and the number of the col... | Print *m* integer, the *i*-th of them should be equal to the number of cells that are not under attack after first *i* rooks are put. | [
"3 3\n1 1\n3 1\n2 2\n",
"5 2\n1 5\n5 1\n",
"100000 1\n300 400\n"
] | [
"4 2 0 \n",
"16 9 \n",
"9999800001 \n"
] | On the picture below show the state of the board after put each of the three rooks. The cells which painted with grey color is not under the attack. | 750 | [
{
"input": "3 3\n1 1\n3 1\n2 2",
"output": "4 2 0 "
},
{
"input": "5 2\n1 5\n5 1",
"output": "16 9 "
},
{
"input": "100000 1\n300 400",
"output": "9999800001 "
},
{
"input": "10 4\n2 8\n1 8\n9 8\n6 9",
"output": "81 72 63 48 "
},
{
"input": "30 30\n3 13\n27 23\n18... | 1,670,579,443 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 982 | 7,782,400 | n,m=map(int,input().split())
xaxis,yaxis=set(),set()
for i in range(m):
x,y=map(int,input().split())
cntx,cnty=0,0
if(x not in xaxis):
xaxis.add(x)
if(y not in yaxis):
yaxis.add(y)
print(n*n-n*(len(xaxis)+len(yaxis))+len(xaxis)*len(yaxis),end=' ') | Title: Cells Not Under Attack
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya has the square chessboard of size *n*<=Γ<=*n* and *m* rooks. Initially the chessboard is empty. Vasya will consequently put the rooks on the board one after another.
The cell of the field is under rook's a... | ```python
n,m=map(int,input().split())
xaxis,yaxis=set(),set()
for i in range(m):
x,y=map(int,input().split())
cntx,cnty=0,0
if(x not in xaxis):
xaxis.add(x)
if(y not in yaxis):
yaxis.add(y)
print(n*n-n*(len(xaxis)+len(yaxis))+len(xaxis)*len(yaxis),end=' ')
``` | 3 | |
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 th... | 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": "chn... | 1,696,999,716 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 92 | 0 | import sys
user_input = sys.stdin.readline().strip()
lowercase_letters = list('abcdefghijklmnopqrstuvwxyz')
uppercase_letters = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
sum_low = 0
sum_high = 0
for i in user_input:
if i in lowercase_letters:
sum_low += 1
elif i in uppercase_letters:
... | 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 ei... | ```python
import sys
user_input = sys.stdin.readline().strip()
lowercase_letters = list('abcdefghijklmnopqrstuvwxyz')
uppercase_letters = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
sum_low = 0
sum_high = 0
for i in user_input:
if i in lowercase_letters:
sum_low += 1
elif i in uppercase_letters:... | 3.977 |
1,000 | C | Covered Points Count | PROGRAMMING | 1,700 | [
"data structures",
"implementation",
"sortings"
] | null | null | You are given $n$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every $k \in [1..n]$, calculate the number of points with in... | The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) β the number of segments.
The next $n$ lines contain segments. The $i$-th line contains a pair of integers $l_i, r_i$ ($0 \le l_i \le r_i \le 10^{18}$) β the endpoints of the $i$-th segment. | Print $n$ space separated integers $cnt_1, cnt_2, \dots, cnt_n$, where $cnt_i$ is equal to the number of points such that the number of segments that cover these points equals to $i$. | [
"3\n0 3\n1 3\n3 8\n",
"3\n1 3\n2 4\n5 7\n"
] | [
"6 2 1 \n",
"5 2 0 \n"
] | The picture describing the first example:
<img class="tex-graphics" src="https://espresso.codeforces.com/f76b3fe547bff6be5b14de76c8b78ba3efecc744.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Points with coordinates $[0, 4, 5, 6, 7, 8]$ are covered by one segment, points $[1, 2]$ are covered by two segments an... | 0 | [
{
"input": "3\n0 3\n1 3\n3 8",
"output": "6 2 1 "
},
{
"input": "3\n1 3\n2 4\n5 7",
"output": "5 2 0 "
},
{
"input": "1\n0 1000000000000000000",
"output": "1000000000000000001 "
}
] | 1,650,964,783 | 2,147,483,647 | Python 3 | OK | TESTS | 18 | 1,872 | 56,627,200 | import collections
if __name__ == '__main__':
n = int(input())
ans = collections.defaultdict(int)
for i in range(n):
l, r = list(map(int, input().strip().split()))
ans[l] += 1; ans[r + 1] -= 1
ans = dict(sorted(ans.items(), key=lambda k: k[0]))
keys = list(ans.keys())
... | Title: Covered Points Count
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given $n$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or ev... | ```python
import collections
if __name__ == '__main__':
n = int(input())
ans = collections.defaultdict(int)
for i in range(n):
l, r = list(map(int, input().strip().split()))
ans[l] += 1; ans[r + 1] -= 1
ans = dict(sorted(ans.items(), key=lambda k: k[0]))
keys = list(ans.key... | 3 | |
50 | A | Domino piling | PROGRAMMING | 800 | [
"greedy",
"math"
] | A. Domino piling | 2 | 256 | You are given a rectangular board of *M*<=Γ<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=Γ<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions:
1. Each domino completely covers ... | In a single line you are given two integers *M* and *N* β board sizes in squares (1<=β€<=*M*<=β€<=*N*<=β€<=16). | Output one number β the maximal number of dominoes, which can be placed. | [
"2 4\n",
"3 3\n"
] | [
"4\n",
"4\n"
] | none | 500 | [
{
"input": "2 4",
"output": "4"
},
{
"input": "3 3",
"output": "4"
},
{
"input": "1 5",
"output": "2"
},
{
"input": "1 6",
"output": "3"
},
{
"input": "1 15",
"output": "7"
},
{
"input": "1 16",
"output": "8"
},
{
"input": "2 5",
"outpu... | 1,671,442,026 | 2,147,483,647 | Python 3 | OK | TESTS | 35 | 92 | 0 | x,y=map(int,input().split());
sum=int(x*y/2);
print(sum);
'''rrewtgwrfffffhgggtrjgrtghtghr'''
| Title: Domino piling
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
You are given a rectangular board of *M*<=Γ<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=Γ<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as p... | ```python
x,y=map(int,input().split());
sum=int(x*y/2);
print(sum);
'''rrewtgwrfffffhgggtrjgrtghtghr'''
``` | 3.977 |
266 | B | Queue at the School | PROGRAMMING | 800 | [
"constructive algorithms",
"graph matchings",
"implementation",
"shortest paths"
] | null | null | During the break the schoolchildren, boys and girls, formed a queue of *n* people in the canteen. Initially the children stood in the order they entered the canteen. However, after a while the boys started feeling awkward for standing in front of the girls in the queue and they started letting the girls move forward ea... | The first line contains two integers *n* and *t* (1<=β€<=*n*,<=*t*<=β€<=50), which represent the number of children in the queue and the time after which the queue will transform into the arrangement you need to find.
The next line contains string *s*, which represents the schoolchildren's initial arrangement. If the *... | Print string *a*, which describes the arrangement after *t* seconds. If the *i*-th position has a boy after the needed time, then the *i*-th character *a* must equal "B", otherwise it must equal "G". | [
"5 1\nBGGBG\n",
"5 2\nBGGBG\n",
"4 1\nGGGB\n"
] | [
"GBGGB\n",
"GGBGB\n",
"GGGB\n"
] | none | 500 | [
{
"input": "5 1\nBGGBG",
"output": "GBGGB"
},
{
"input": "5 2\nBGGBG",
"output": "GGBGB"
},
{
"input": "4 1\nGGGB",
"output": "GGGB"
},
{
"input": "2 1\nBB",
"output": "BB"
},
{
"input": "2 1\nBG",
"output": "GB"
},
{
"input": "6 2\nBBGBBG",
"outpu... | 1,699,169,971 | 2,147,483,647 | Python 3 | OK | TESTS | 44 | 92 | 0 | n, t = map(int, input().split())
s = input()
lst = list(s)
for _ in range(t):
i = 0
while i < n - 1:
if lst[i] == 'B' and lst[i+1] == 'G':
lst[i], lst[i+1] = lst[i+1], lst[i]
i += 2
else:
i += 1
final = ""
for ch in lst:
final += ch
print(f... | Title: Queue at the School
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
During the break the schoolchildren, boys and girls, formed a queue of *n* people in the canteen. Initially the children stood in the order they entered the canteen. However, after a while the boys started feeling a... | ```python
n, t = map(int, input().split())
s = input()
lst = list(s)
for _ in range(t):
i = 0
while i < n - 1:
if lst[i] == 'B' and lst[i+1] == 'G':
lst[i], lst[i+1] = lst[i+1], lst[i]
i += 2
else:
i += 1
final = ""
for ch in lst:
final += c... | 3 | |
448 | B | Suffix Structures | PROGRAMMING | 1,400 | [
"implementation",
"strings"
] | null | null | Bizon the Champion isn't just a bison. He also is a favorite of the "Bizons" team.
At a competition the "Bizons" got the following problem: "You are given two distinct words (strings of English letters), *s* and *t*. You need to transform word *s* into word *t*". The task looked simple to the guys because they know th... | The first line contains a non-empty word *s*. The second line contains a non-empty word *t*. Words *s* and *t* are different. Each word consists only of lowercase English letters. Each word contains at most 100 letters. | In the single line print the answer to the problem. Print "need tree" (without the quotes) if word *s* cannot be transformed into word *t* even with use of both suffix array and suffix automaton. Print "automaton" (without the quotes) if you need only the suffix automaton to solve the problem. Print "array" (without th... | [
"automaton\ntomat\n",
"array\narary\n",
"both\nhot\n",
"need\ntree\n"
] | [
"automaton\n",
"array\n",
"both\n",
"need tree\n"
] | In the third sample you can act like that: first transform "both" into "oth" by removing the first character using the suffix automaton and then make two swaps of the string using the suffix array and get "hot". | 1,000 | [
{
"input": "automaton\ntomat",
"output": "automaton"
},
{
"input": "array\narary",
"output": "array"
},
{
"input": "both\nhot",
"output": "both"
},
{
"input": "need\ntree",
"output": "need tree"
},
{
"input": "abacaba\naaaa",
"output": "automaton"
},
{
... | 1,684,921,894 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 36 | 62 | 0 | def main():
s = input()
t = input()
lent, lens = len(t), len(s)
def is_in(s, t):
i, j = 0, 0
while i < lens and j < lent:
if s[i] == t[j]:
j += 1
i += 1
return j == lent
tmps = ''.join(sorted(s))
tmpt = ''.join(sorted(t))
msg = 'automaton' if is_in(s, t) else 'array' if is_in(tmps, tmpt) and lent... | Title: Suffix Structures
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bizon the Champion isn't just a bison. He also is a favorite of the "Bizons" team.
At a competition the "Bizons" got the following problem: "You are given two distinct words (strings of English letters), *s* and *t*.... | ```python
def main():
s = input()
t = input()
lent, lens = len(t), len(s)
def is_in(s, t):
i, j = 0, 0
while i < lens and j < lent:
if s[i] == t[j]:
j += 1
i += 1
return j == lent
tmps = ''.join(sorted(s))
tmpt = ''.join(sorted(t))
msg = 'automaton' if is_in(s, t) else 'array' if is_in(tmps, tmpt... | 3 | |
78 | B | Easter Eggs | PROGRAMMING | 1,200 | [
"constructive algorithms",
"implementation"
] | B. Easter Eggs | 2 | 256 | The Easter Rabbit laid *n* eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
- Each of the seven colors should be used to paint at least one egg. - Any four eggs lying s... | The only line contains an integer *n* β the amount of eggs (7<=β€<=*n*<=β€<=100). | Print one line consisting of *n* characters. The *i*-th character should describe the color of the *i*-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indi... | [
"8\n",
"13\n"
] | [
"ROYGRBIV\n",
"ROYGBIVGBIVYG\n"
] | The way the eggs will be painted in the first sample is shown on the picture: | 1,000 | [
{
"input": "8",
"output": "ROYGBIVG"
},
{
"input": "13",
"output": "ROYGBIVOYGBIV"
},
{
"input": "7",
"output": "ROYGBIV"
},
{
"input": "10",
"output": "ROYGBIVYGB"
},
{
"input": "14",
"output": "ROYGBIVROYGBIV"
},
{
"input": "50",
"output": "ROYGB... | 1,622,307,770 | 2,147,483,647 | PyPy 3 | OK | TESTS | 34 | 186 | 0 | n=int(input())
a='ROYGBIV'
for i in range(7,n):
for j in ['R','O','Y','G','B','I','V']:
if j!=a[i-1] and j!=a[i-2] and j!=a[i-3] and (i+1<n or j!=a[(i+1)%n]) and (i+2<n or j!=a[(i+2)%n]) and (i+3<n or j!=a[(i+3)%n]):
a+=j
break
print(a) | Title: Easter Eggs
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
The Easter Rabbit laid *n* eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
-... | ```python
n=int(input())
a='ROYGBIV'
for i in range(7,n):
for j in ['R','O','Y','G','B','I','V']:
if j!=a[i-1] and j!=a[i-2] and j!=a[i-3] and (i+1<n or j!=a[(i+1)%n]) and (i+2<n or j!=a[(i+2)%n]) and (i+3<n or j!=a[(i+3)%n]):
a+=j
break
print(a)
``` | 3.9535 |
208 | A | Dubstep | PROGRAMMING | 900 | [
"strings"
] | null | null | Vasya works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.
Let's assume that a song consists of some number of words. To make the dubstep remix of this song, Vasya inserts a certain nu... | The input consists of a single non-empty string, consisting only of uppercase English letters, the string's length doesn't exceed 200 characters. It is guaranteed that before Vasya remixed the song, no word contained substring "WUB" in it; Vasya didn't change the word order. It is also guaranteed that initially the son... | Print the words of the initial song that Vasya used to make a dubsteb remix. Separate the words with a space. | [
"WUBWUBABCWUB\n",
"WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB\n"
] | [
"ABC ",
"WE ARE THE CHAMPIONS MY FRIEND "
] | In the first sample: "WUBWUBABCWUB" = "WUB" + "WUB" + "ABC" + "WUB". That means that the song originally consisted of a single word "ABC", and all words "WUB" were added by Vasya.
In the second sample Vasya added a single word "WUB" between all neighbouring words, in the beginning and in the end, except for words "ARE... | 500 | [
{
"input": "WUBWUBABCWUB",
"output": "ABC "
},
{
"input": "WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB",
"output": "WE ARE THE CHAMPIONS MY FRIEND "
},
{
"input": "WUBWUBWUBSR",
"output": "SR "
},
{
"input": "RWUBWUBWUBLWUB",
"output": "R L "
},
{
"input": "... | 1,680,330,112 | 2,147,483,647 | Python 3 | OK | TESTS | 71 | 92 | 0 | string = input()
newstr = ""
newlist = string.split("WUB")
for element in newlist:
if element != "":
newstr += f" {element}"
print(newstr[1:]) | Title: Dubstep
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.
Let's assume that a song consist... | ```python
string = input()
newstr = ""
newlist = string.split("WUB")
for element in newlist:
if element != "":
newstr += f" {element}"
print(newstr[1:])
``` | 3 | |
771 | B | Bear and Different Names | PROGRAMMING | 1,500 | [
"constructive algorithms",
"greedy"
] | null | null | In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names... | The first line of the input contains two integers *n* and *k* (2<=β€<=*k*<=β€<=*n*<=β€<=50)Β β the number of soldiers and the size of a group respectively.
The second line contains *n*<=-<=*k*<=+<=1 strings *s*1,<=*s*2,<=...,<=*s**n*<=-<=*k*<=+<=1. The string *s**i* is "YES" if the group of soldiers *i* through *i*<=+<=*k... | Find any solution satisfying all given conditions. In one line print *n* space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
... | [
"8 3\nNO NO YES YES YES NO\n",
"9 8\nYES NO\n",
"3 2\nNO NO\n"
] | [
"Adam Bob Bob Cpqepqwer Limak Adam Bob Adam",
"R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc",
"Na Na Na"
] | In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
- First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string *s*<sub class="lower-index">1</... | 500 | [
{
"input": "8 3\nNO NO YES YES YES NO",
"output": "Ab Ac Ab Ac Af Ag Ah Ag "
},
{
"input": "9 8\nYES NO",
"output": "Ab Ac Ad Ae Af Ag Ah Ai Ac "
},
{
"input": "3 2\nNO NO",
"output": "Ab Ab Ab "
},
{
"input": "2 2\nYES",
"output": "Ab Ac "
},
{
"input": "2 2\nNO"... | 1,489,856,721 | 5,421 | Python 3 | OK | TESTS | 59 | 62 | 4,608,000 | names = [i for i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'] + [ 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'[i:i+2] for i in range(0, len('AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'), 2)]
n, k = map(int, input().split())
yes_no = input().split()
guess = names[:n]
for i in range(len(yes_no)):
if yes_... | Title: Bear and Different Names
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an orde... | ```python
names = [i for i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'] + [ 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'[i:i+2] for i in range(0, len('AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'), 2)]
n, k = map(int, input().split())
yes_no = input().split()
guess = names[:n]
for i in range(len(yes_no)):
... | 3 | |
912 | A | Tricky Alchemy | PROGRAMMING | 800 | [
"implementation"
] | null | null | During the winter holidays, the demand for Christmas balls is exceptionally high. Since it's already 2018, the advances in alchemy allow easy and efficient ball creation by utilizing magic crystals.
Grisha needs to obtain some yellow, green and blue balls. It's known that to produce a yellow ball one needs two yellow ... | The first line features two integers *A* and *B* (0<=β€<=*A*,<=*B*<=β€<=109), denoting the number of yellow and blue crystals respectively at Grisha's disposal.
The next line contains three integers *x*, *y* and *z* (0<=β€<=*x*,<=*y*,<=*z*<=β€<=109)Β β the respective amounts of yellow, green and blue balls to be obtained. | Print a single integerΒ β the minimum number of crystals that Grisha should acquire in addition. | [
"4 3\n2 1 1\n",
"3 9\n1 1 3\n",
"12345678 87654321\n43043751 1000000000 53798715\n"
] | [
"2\n",
"1\n",
"2147483648\n"
] | In the first sample case, Grisha needs five yellow and four blue crystals to create two yellow balls, one green ball, and one blue ball. To do that, Grisha needs to obtain two additional crystals: one yellow and one blue. | 500 | [
{
"input": "4 3\n2 1 1",
"output": "2"
},
{
"input": "3 9\n1 1 3",
"output": "1"
},
{
"input": "12345678 87654321\n43043751 1000000000 53798715",
"output": "2147483648"
},
{
"input": "12 12\n3 5 2",
"output": "0"
},
{
"input": "770 1390\n170 442 311",
"output"... | 1,589,178,797 | 2,147,483,647 | PyPy 3 | OK | TESTS | 38 | 156 | 20,172,800 | Y , B = map(int,input().split())
y , g , b = map(int,input().split())
print(max(0 , 2*y+g - Y) + max(0 , 3*b+g - B)) | Title: Tricky Alchemy
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
During the winter holidays, the demand for Christmas balls is exceptionally high. Since it's already 2018, the advances in alchemy allow easy and efficient ball creation by utilizing magic crystals.
Grisha needs to obta... | ```python
Y , B = map(int,input().split())
y , g , b = map(int,input().split())
print(max(0 , 2*y+g - Y) + max(0 , 3*b+g - B))
``` | 3 | |
915 | A | Garden | PROGRAMMING | 900 | [
"implementation"
] | null | null | Luba thinks about watering her garden. The garden can be represented as a segment of length *k*. Luba has got *n* buckets, the *i*-th bucket allows her to water some continuous subsegment of garden of length exactly *a**i* each hour. Luba can't water any parts of the garden that were already watered, also she can't wat... | The first line of input contains two integer numbers *n* and *k* (1<=β€<=*n*,<=*k*<=β€<=100) β the number of buckets and the length of the garden, respectively.
The second line of input contains *n* integer numbers *a**i* (1<=β€<=*a**i*<=β€<=100) β the length of the segment that can be watered by the *i*-th bucket in one ... | Print one integer number β the minimum number of hours required to water the garden. | [
"3 6\n2 3 5\n",
"6 7\n1 2 3 4 5 6\n"
] | [
"2\n",
"7\n"
] | In the first test the best option is to choose the bucket that allows to water the segment of length 3. We can't choose the bucket that allows to water the segment of length 5 because then we can't water the whole garden.
In the second test we can choose only the bucket that allows us to water the segment of length 1. | 0 | [
{
"input": "3 6\n2 3 5",
"output": "2"
},
{
"input": "6 7\n1 2 3 4 5 6",
"output": "7"
},
{
"input": "5 97\n1 10 50 97 2",
"output": "1"
},
{
"input": "5 97\n1 10 50 100 2",
"output": "97"
},
{
"input": "100 100\n2 46 24 18 86 90 31 38 84 49 58 28 15 80 14 24 87 5... | 1,637,944,761 | 2,147,483,647 | Python 3 | OK | TESTS | 83 | 62 | 0 | #nacitanie vstupu
pocet_n,velkost_k=list(map(int,input().split()))
jednotlive_hodnoty=list(map(int,input().split()))
najvacsie_k=-1
#for loop s ifom
for hodnota in jednotlive_hodnoty:
if velkost_k%hodnota==0 and hodnota>najvacsie_k:
najvacsie_k=hodnota
#vypocitanie vysledku
vystup=velkost_k//najv... | Title: Garden
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Luba thinks about watering her garden. The garden can be represented as a segment of length *k*. Luba has got *n* buckets, the *i*-th bucket allows her to water some continuous subsegment of garden of length exactly *a**i* each ... | ```python
#nacitanie vstupu
pocet_n,velkost_k=list(map(int,input().split()))
jednotlive_hodnoty=list(map(int,input().split()))
najvacsie_k=-1
#for loop s ifom
for hodnota in jednotlive_hodnoty:
if velkost_k%hodnota==0 and hodnota>najvacsie_k:
najvacsie_k=hodnota
#vypocitanie vysledku
vystup=velko... | 3 | |
841 | A | Generous Kefa | PROGRAMMING | 900 | [
"brute force",
"implementation"
] | null | null | One day Kefa found *n* baloons. For convenience, we denote color of *i*-th baloon as *s**i* β lowercase letter of the Latin alphabet. Also Kefa has *k* friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his... | The first line contains two integers *n* and *k* (1<=β€<=*n*,<=*k*<=β€<=100) β the number of baloons and friends.
Next line contains string *s* β colors of baloons. | Answer to the task β Β«YESΒ» or Β«NOΒ» in a single line.
You can choose the case (lower or upper) for each letter arbitrary. | [
"4 2\naabb\n",
"6 3\naacaab\n"
] | [
"YES\n",
"NO\n"
] | In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is Β«NOΒ». | 500 | [
{
"input": "4 2\naabb",
"output": "YES"
},
{
"input": "6 3\naacaab",
"output": "NO"
},
{
"input": "2 2\nlu",
"output": "YES"
},
{
"input": "5 3\novvoo",
"output": "YES"
},
{
"input": "36 13\nbzbzcffczzcbcbzzfzbbfzfzzbfbbcbfccbf",
"output": "YES"
},
{
"... | 1,600,791,344 | 2,147,483,647 | Python 3 | OK | TESTS | 114 | 109 | 0 | # Generous Kefa
def balloons(s, k):
for i in s:
x = s.count(i)
if x > k:
return "NO"
return "YES"
n, k = list(map(int, input().split()))
s = input()
print(balloons(s, k))
| Title: Generous Kefa
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Kefa found *n* baloons. For convenience, we denote color of *i*-th baloon as *s**i* β lowercase letter of the Latin alphabet. Also Kefa has *k* friends. Friend will be upset, If he get two baloons of the same colo... | ```python
# Generous Kefa
def balloons(s, k):
for i in s:
x = s.count(i)
if x > k:
return "NO"
return "YES"
n, k = list(map(int, input().split()))
s = input()
print(balloons(s, k))
``` | 3 | |
865 | A | Save the problem! | PROGRAMMING | 1,400 | [
"constructive algorithms"
] | null | null | Attention: we lost all the test cases for this problem, so instead of solving the problem, we need you to generate test cases. We're going to give you the answer, and you need to print a test case that produces the given answer. The original problem is in the following paragraph.
People don't use cash as often as they... | Input will consist of a single integer *A* (1<=β€<=*A*<=β€<=105), the desired number of ways. | In the first line print integers *N* and *M* (1<=β€<=*N*<=β€<=106,<=1<=β€<=*M*<=β€<=10), the amount of change to be made, and the number of denominations, respectively.
Then print *M* integers *D*1,<=*D*2,<=...,<=*D**M* (1<=β€<=*D**i*<=β€<=106), the denominations of the coins. All denominations must be distinct: for any *i*... | [
"18\n",
"3\n",
"314\n"
] | [
"30 4\n1 5 10 25\n",
"20 2\n5 2\n",
"183 4\n6 5 2 139\n"
] | none | 500 | [
{
"input": "18",
"output": "30 4\n1 5 10 25"
},
{
"input": "3",
"output": "20 2\n5 2"
},
{
"input": "314",
"output": "183 4\n6 5 2 139"
},
{
"input": "1023",
"output": "2045 2\n1 2"
},
{
"input": "100000",
"output": "199999 2\n1 2"
},
{
"input": "1",
... | 1,641,822,714 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 37 | 109 | 0 | n=int(input())
print(2*n-1, 2)
print(1, 2) | Title: Save the problem!
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Attention: we lost all the test cases for this problem, so instead of solving the problem, we need you to generate test cases. We're going to give you the answer, and you need to print a test case that produces the gi... | ```python
n=int(input())
print(2*n-1, 2)
print(1, 2)
``` | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Limak is a little bear who loves to play. Today he is playing by destroying block towers. He built *n* towers in a row. The *i*-th tower is made of *h**i* identical blocks. For clarification see picture for the first sample.
Limak will repeat the following operation till everything is destroyed.
Block is called inter... | The first line contains single integer *n* (1<=β€<=*n*<=β€<=105).
The second line contains *n* space-separated integers *h*1,<=*h*2,<=...,<=*h**n* (1<=β€<=*h**i*<=β€<=109) β sizes of towers. | Print the number of operations needed to destroy all towers. | [
"6\n2 1 4 6 2 2\n",
"7\n3 3 3 1 3 3 3\n"
] | [
"3\n",
"2\n"
] | The picture below shows all three operations for the first sample test. Each time boundary blocks are marked with red color. | 0 | [
{
"input": "6\n2 1 4 6 2 2",
"output": "3"
},
{
"input": "7\n3 3 3 1 3 3 3",
"output": "2"
},
{
"input": "7\n5128 5672 5805 5452 5882 5567 5032",
"output": "4"
},
{
"input": "10\n1 2 2 3 5 5 5 4 2 1",
"output": "5"
},
{
"input": "14\n20 20 20 20 20 20 3 20 20 20 2... | 1,451,403,606 | 3,246 | Python 3 | OK | TESTS | 41 | 218 | 9,113,600 | def main():
n = int(input())
a = [int(i) for i in input().split()]
dpl = [1] * n
dpr = [1] * n
for i in range(1, n):
dpl[i] = min(dpl[i - 1] + 1, a[i])
for i in range(n - 2, -1, -1):
dpr[i] = min(dpr[i + 1] + 1, a[i])
ans = 0
for i in range(n):
ans = ma... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Limak is a little bear who loves to play. Today he is playing by destroying block towers. He built *n* towers in a row. The *i*-th tower is made of *h**i* identical blocks. For clarification see picture for the first sample.
Lima... | ```python
def main():
n = int(input())
a = [int(i) for i in input().split()]
dpl = [1] * n
dpr = [1] * n
for i in range(1, n):
dpl[i] = min(dpl[i - 1] + 1, a[i])
for i in range(n - 2, -1, -1):
dpr[i] = min(dpr[i + 1] + 1, a[i])
ans = 0
for i in range(n):
... | 3 | |
61 | A | Ultra-Fast Mathematician | PROGRAMMING | 800 | [
"implementation"
] | A. Ultra-Fast Mathematician | 2 | 256 | Shapur was an extremely gifted student. He was great at everything including Combinatorics, Algebra, Number Theory, Geometry, Calculus, etc. He was not only smart but extraordinarily fast! He could manage to sum 1018 numbers in a single second.
One day in 230 AD Shapur was trying to find out if any one can possibly do... | There are two lines in each input. Each of them contains a single number. It is guaranteed that the numbers are made from 0 and 1 only and that their length is same. The numbers may start with 0. The length of each number doesn't exceed 100. | Write one line β the corresponding answer. Do not omit the leading 0s. | [
"1010100\n0100101\n",
"000\n111\n",
"1110\n1010\n",
"01110\n01100\n"
] | [
"1110001\n",
"111\n",
"0100\n",
"00010\n"
] | none | 500 | [
{
"input": "1010100\n0100101",
"output": "1110001"
},
{
"input": "000\n111",
"output": "111"
},
{
"input": "1110\n1010",
"output": "0100"
},
{
"input": "01110\n01100",
"output": "00010"
},
{
"input": "011101\n000001",
"output": "011100"
},
{
"input": "... | 1,587,022,295 | 2,147,483,647 | Python 3 | OK | TESTS | 102 | 109 | 0 | a = input()
b = input()
ans = ""
for i in range(0,len(a)):
if a[i]==b[i]=="0" or a[i]==b[i]=="1":
ans += "0"
else:
ans += "1"
print(ans) | Title: Ultra-Fast Mathematician
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Shapur was an extremely gifted student. He was great at everything including Combinatorics, Algebra, Number Theory, Geometry, Calculus, etc. He was not only smart but extraordinarily fast! He could manage to sum 10... | ```python
a = input()
b = input()
ans = ""
for i in range(0,len(a)):
if a[i]==b[i]=="0" or a[i]==b[i]=="1":
ans += "0"
else:
ans += "1"
print(ans)
``` | 3.97275 |
161 | A | Dress'em in Vests! | PROGRAMMING | 1,300 | [
"binary search",
"brute force",
"greedy",
"two pointers"
] | null | null | The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line.
The Two-dimensional kingdom has a regular army of *n* people. Each soldier registered him... | The first input line contains four integers *n*, *m*, *x* and *y* (1<=β€<=*n*,<=*m*<=β€<=105, 0<=β€<=*x*,<=*y*<=β€<=109) β the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i... | In the first line print a single integer *k* β the maximum number of soldiers equipped with bulletproof vests.
In the next *k* lines print *k* pairs, one pair per line, as "*u**i* *v**i*" (without the quotes). Pair (*u**i*, *v**i*) means that soldier number *u**i* must wear vest number *v**i*. Soldiers and vests are ... | [
"5 3 0 0\n1 2 3 3 4\n1 3 5\n",
"3 3 2 2\n1 5 9\n3 5 7\n"
] | [
"2\n1 1\n3 2\n",
"3\n1 1\n2 2\n3 3\n"
] | In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one.
In the second sample the vest size can differ... | 1,000 | [
{
"input": "5 3 0 0\n1 2 3 3 4\n1 3 5",
"output": "2\n1 1\n3 2"
},
{
"input": "3 3 2 2\n1 5 9\n3 5 7",
"output": "3\n1 1\n2 2\n3 3"
},
{
"input": "1 1 0 0\n1\n1",
"output": "1\n1 1"
},
{
"input": "1 1 0 0\n1\n2",
"output": "0"
},
{
"input": "2 3 1 4\n1 5\n1 2 2",
... | 1,546,267,457 | 2,147,483,647 | Python 3 | OK | TESTS | 84 | 1,028 | 15,155,200 | # 161A-sua bai >> accepted
# n: num of solder
# m: num of vest
# x: margin duoi
# y: margin tren
# chu giai giai thuat: i chay tu 0>>n, neu ao vest b[j] nho hon (a[i]-x), thi tang j (xet bo ao vest tiep theo) cho toi khi tim
# thay j phu hop, sau do xet xem ung voi j do, ao vest co phu hop voi soldier i ko (b[j]<(a[i]+... | Title: Dress'em in Vests!
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the s... | ```python
# 161A-sua bai >> accepted
# n: num of solder
# m: num of vest
# x: margin duoi
# y: margin tren
# chu giai giai thuat: i chay tu 0>>n, neu ao vest b[j] nho hon (a[i]-x), thi tang j (xet bo ao vest tiep theo) cho toi khi tim
# thay j phu hop, sau do xet xem ung voi j do, ao vest co phu hop voi soldier i ko (b... | 3 | |
50 | A | Domino piling | PROGRAMMING | 800 | [
"greedy",
"math"
] | A. Domino piling | 2 | 256 | You are given a rectangular board of *M*<=Γ<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=Γ<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions:
1. Each domino completely covers ... | In a single line you are given two integers *M* and *N* β board sizes in squares (1<=β€<=*M*<=β€<=*N*<=β€<=16). | Output one number β the maximal number of dominoes, which can be placed. | [
"2 4\n",
"3 3\n"
] | [
"4\n",
"4\n"
] | none | 500 | [
{
"input": "2 4",
"output": "4"
},
{
"input": "3 3",
"output": "4"
},
{
"input": "1 5",
"output": "2"
},
{
"input": "1 6",
"output": "3"
},
{
"input": "1 15",
"output": "7"
},
{
"input": "1 16",
"output": "8"
},
{
"input": "2 5",
"outpu... | 1,663,362,589 | 2,147,483,647 | Python 3 | OK | TESTS | 35 | 92 | 0 | m,n = map(int,input().split())
aria = m * n
if aria %2 != 0:
aria-=1
print(int(aria/2)) | Title: Domino piling
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
You are given a rectangular board of *M*<=Γ<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=Γ<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as p... | ```python
m,n = map(int,input().split())
aria = m * n
if aria %2 != 0:
aria-=1
print(int(aria/2))
``` | 3.977 |
177 | A1 | Good Matrix Elements | PROGRAMMING | 800 | [
"implementation"
] | null | null | The Smart Beaver from ABBYY got hooked on square matrices. Now he is busy studying an *n*<=Γ<=*n* size matrix, where *n* is odd. The Smart Beaver considers the following matrix elements good:
- Elements of the main diagonal. - Elements of the secondary diagonal. - Elements of the "middle" row β the row which ha... | The first line of input data contains a single odd integer *n*. Each of the next *n* lines contains *n* integers *a**ij* (0<=β€<=*a**ij*<=β€<=100) separated by single spaces β the elements of the given matrix.
The input limitations for getting 30 points are:
- 1<=β€<=*n*<=β€<=5
The input limitations for getting 100 po... | Print a single integer β the sum of good matrix elements. | [
"3\n1 2 3\n4 5 6\n7 8 9\n",
"5\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n"
] | [
"45\n",
"17\n"
] | In the first sample all matrix elements will be good. Good elements in the second sample are shown on the figure. | 30 | [
{
"input": "3\n1 2 3\n4 5 6\n7 8 9",
"output": "45"
},
{
"input": "5\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 1 1 1 1",
"output": "17"
},
{
"input": "1\n3",
"output": "3"
},
{
"input": "5\n27 7 3 11 72\n19 49 68 19 59\n41 25 37 64 65\n8 39 96 62 90\n13 37 43 26 33",
... | 1,563,706,195 | 2,147,483,647 | Python 3 | OK | TESTS1 | 17 | 218 | 0 | #import sys
#sys.stdin = open("input.in","r")
#sys.stdout = open("test.out","w")
n=int(input())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
c=0
for i in range(n):
for j in range(n):
if(i==j or i==n//2 or j==n//2 or i==n-1-j):
c+=l[i][j]
print(c) | Title: Good Matrix Elements
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Smart Beaver from ABBYY got hooked on square matrices. Now he is busy studying an *n*<=Γ<=*n* size matrix, where *n* is odd. The Smart Beaver considers the following matrix elements good:
- Elements of the ... | ```python
#import sys
#sys.stdin = open("input.in","r")
#sys.stdout = open("test.out","w")
n=int(input())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
c=0
for i in range(n):
for j in range(n):
if(i==j or i==n//2 or j==n//2 or i==n-1-j):
c+=l[i][j]
print(c)
``` | 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.