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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
618 | A | Slime Combining | PROGRAMMING | 800 | [
"implementation"
] | null | null | Your friend recently gave you some slimes for your birthday. You have *n* slimes all initially with value 1.
You are going to play a game with these slimes. Initially, you put a single slime by itself in a row. Then, you will add the other *n*<=-<=1 slimes one by one. When you add a slime, you place it at the right of... | The first line of the input will contain a single integer, *n* (1<=β€<=*n*<=β€<=100<=000). | Output a single line with *k* integers, where *k* is the number of slimes in the row after you've finished the procedure described in the problem statement. The *i*-th of these numbers should be the value of the *i*-th slime from the left. | [
"1\n",
"2\n",
"3\n",
"8\n"
] | [
"1\n",
"2\n",
"2 1\n",
"4\n"
] | In the first sample, we only have a single slime with value 1. The final state of the board is just a single slime with value 1.
In the second sample, we perform the following steps:
Initially we place a single slime in a row by itself. Thus, row is initially 1.
Then, we will add another slime. The row is now 1 1. S... | 500 | [
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "2"
},
{
"input": "3",
"output": "2 1"
},
{
"input": "8",
"output": "4"
},
{
"input": "100000",
"output": "17 16 11 10 8 6"
},
{
"input": "12345",
"output": "14 13 6 5 4 1"
},
{
"in... | 1,454,222,657 | 2,147,483,647 | Python 3 | OK | TESTS | 27 | 62 | 0 | n=int(input())
i=1
k=1
a=[]
while i<=n:
if i&n:
a.append(k)
i<<=1
k+=1
for i in range(len(a)-1,-1,-1):
print(a[i],end=' ') | Title: Slime Combining
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Your friend recently gave you some slimes for your birthday. You have *n* slimes all initially with value 1.
You are going to play a game with these slimes. Initially, you put a single slime by itself in a row. Then, y... | ```python
n=int(input())
i=1
k=1
a=[]
while i<=n:
if i&n:
a.append(k)
i<<=1
k+=1
for i in range(len(a)-1,-1,-1):
print(a[i],end=' ')
``` | 3 | |
102 | B | Sum of Digits | PROGRAMMING | 1,000 | [
"implementation"
] | B. Sum of Digits | 2 | 265 | Having watched the last Harry Potter film, little Gerald also decided to practice magic. He found in his father's magical book a spell that turns any number in the sum of its digits. At the moment Gerald learned that, he came across a number *n*. How many times can Gerald put a spell on it until the number becomes one-... | The first line contains the only integer *n* (0<=β€<=*n*<=β€<=10100000). It is guaranteed that *n* doesn't contain any leading zeroes. | Print the number of times a number can be replaced by the sum of its digits until it only contains one digit. | [
"0\n",
"10\n",
"991\n"
] | [
"0\n",
"1\n",
"3\n"
] | In the first sample the number already is one-digit β Herald can't cast a spell.
The second test contains number 10. After one casting of a spell it becomes 1, and here the process is completed. Thus, Gerald can only cast the spell once.
The third test contains number 991. As one casts a spell the following transform... | 1,000 | [
{
"input": "0",
"output": "0"
},
{
"input": "10",
"output": "1"
},
{
"input": "991",
"output": "3"
},
{
"input": "99",
"output": "2"
},
{
"input": "100",
"output": "1"
},
{
"input": "123456789",
"output": "2"
},
{
"input": "32",
"output... | 1,596,712,617 | 2,147,483,647 | PyPy 3 | OK | TESTS | 51 | 1,308 | 28,160,000 | import sys
import math
input = sys.stdin.readline
def solve():
def magic(n):
return sum([int(ch) for ch in str(n)])
n = int(input().strip())
ans = 0
while n >= 10:
ans += 1
n = magic(n)
print(ans)
if __name__ == '__main__':
solve()
| Title: Sum of Digits
Time Limit: 2 seconds
Memory Limit: 265 megabytes
Problem Description:
Having watched the last Harry Potter film, little Gerald also decided to practice magic. He found in his father's magical book a spell that turns any number in the sum of its digits. At the moment Gerald learned that, he came... | ```python
import sys
import math
input = sys.stdin.readline
def solve():
def magic(n):
return sum([int(ch) for ch in str(n)])
n = int(input().strip())
ans = 0
while n >= 10:
ans += 1
n = magic(n)
print(ans)
if __name__ == '__main__':
solve()
``` | 3.622329 |
389 | A | Fox and Number Game | PROGRAMMING | 1,000 | [
"greedy",
"math"
] | null | null | Fox Ciel is playing a game with numbers now.
Ciel has *n* positive integers: *x*1, *x*2, ..., *x**n*. She can do the following operation as many times as needed: select two different indexes *i* and *j* such that *x**i* > *x**j* hold, and then apply assignment *x**i* = *x**i* - *x**j*. The goal is to make the sum ... | The first line contains an integer *n* (2<=β€<=*n*<=β€<=100). Then the second line contains *n* integers: *x*1, *x*2, ..., *x**n* (1<=β€<=*x**i*<=β€<=100). | Output a single integer β the required minimal sum. | [
"2\n1 2\n",
"3\n2 4 6\n",
"2\n12 18\n",
"5\n45 12 27 30 18\n"
] | [
"2\n",
"6\n",
"12\n",
"15\n"
] | In the first example the optimal way is to do the assignment: *x*<sub class="lower-index">2</sub> = *x*<sub class="lower-index">2</sub> - *x*<sub class="lower-index">1</sub>.
In the second example the optimal sequence of operations is: *x*<sub class="lower-index">3</sub> = *x*<sub class="lower-index">3</sub> - *x*<sub... | 500 | [
{
"input": "2\n1 2",
"output": "2"
},
{
"input": "3\n2 4 6",
"output": "6"
},
{
"input": "2\n12 18",
"output": "12"
},
{
"input": "5\n45 12 27 30 18",
"output": "15"
},
{
"input": "2\n1 1",
"output": "2"
},
{
"input": "2\n100 100",
"output": "200"
... | 1,467,116,793 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 78 | 0 | n = int(input())
a = [int(x) for x in input().split()]
while any(x != a[0] for x in a):
a.sort()
a = [a[i] - a[0] if a[i] > a[0] else a[i] for i in range(0, n)]
print(sum(a))
| Title: Fox and Number Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Fox Ciel is playing a game with numbers now.
Ciel has *n* positive integers: *x*1, *x*2, ..., *x**n*. She can do the following operation as many times as needed: select two different indexes *i* and *j* such that ... | ```python
n = int(input())
a = [int(x) for x in input().split()]
while any(x != a[0] for x in a):
a.sort()
a = [a[i] - a[0] if a[i] > a[0] else a[i] for i in range(0, n)]
print(sum(a))
``` | 3 | |
124 | A | The number of positions | PROGRAMMING | 1,000 | [
"math"
] | null | null | Petr stands in line of *n* people, but he doesn't know exactly which position he occupies. He can say that there are no less than *a* people standing in front of him and no more than *b* people standing behind him. Find the number of different positions Petr can occupy. | The only line contains three integers *n*, *a* and *b* (0<=β€<=*a*,<=*b*<=<<=*n*<=β€<=100). | Print the single number β the number of the sought positions. | [
"3 1 1\n",
"5 2 3\n"
] | [
"2\n",
"3\n"
] | The possible positions in the first sample are: 2 and 3 (if we number the positions starting with 1).
In the second sample they are 3, 4 and 5. | 500 | [
{
"input": "3 1 1",
"output": "2"
},
{
"input": "5 2 3",
"output": "3"
},
{
"input": "5 4 0",
"output": "1"
},
{
"input": "6 5 5",
"output": "1"
},
{
"input": "9 4 3",
"output": "4"
},
{
"input": "11 4 6",
"output": "7"
},
{
"input": "13 8 ... | 1,653,633,553 | 2,147,483,647 | PyPy 3 | OK | TESTS | 50 | 186 | 0 |
'''
β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬ βββββββββ β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬
###########################
// β’οΈΏβ’ \\
/\\ //\
/\\ //\
/\\//\
###########################
''... | Title: The number of positions
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Petr stands in line of *n* people, but he doesn't know exactly which position he occupies. He can say that there are no less than *a* people standing in front of him and no more than *b* people standing behind h... | ```python
'''
β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬ βββββββββ β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬ ββ ββ β¬β¬
β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬
###########################
// β’οΈΏβ’ \\
/\\ //\
/\\ //\
/\\//\
#####################... | 3 | |
981 | B | Businessmen Problems | PROGRAMMING | 1,000 | [
"sortings"
] | null | null | Two famous competing companies ChemForces and TopChemist decided to show their sets of recently discovered chemical elements on an exhibition. However they know that no element should be present in the sets of both companies.
In order to avoid this representatives of both companies decided to make an agreement on the ... | The first line contains a single integer $n$ ($1 \leq n \leq 10^5$) Β β the number of elements discovered by ChemForces.
The $i$-th of the next $n$ lines contains two integers $a_i$ and $x_i$ ($1 \leq a_i \leq 10^9$, $1 \leq x_i \leq 10^9$) Β β the index of the $i$-th element and the income of its usage on the exhibitio... | Print the maximum total income you can obtain by choosing the sets for both companies in such a way that no element is presented in both sets. | [
"3\n1 2\n7 2\n3 10\n4\n1 4\n2 4\n3 4\n4 4\n",
"1\n1000000000 239\n3\n14 15\n92 65\n35 89\n"
] | [
"24\n",
"408\n"
] | In the first example ChemForces can choose the set ($3, 7$), while TopChemist can choose ($1, 2, 4$). This way the total income is $(10 + 2) + (4 + 4 + 4) = 24$.
In the second example ChemForces can choose the only element $10^9$, while TopChemist can choose ($14, 92, 35$). This way the total income is $(239) + (15 + ... | 750 | [
{
"input": "3\n1 2\n7 2\n3 10\n4\n1 4\n2 4\n3 4\n4 4",
"output": "24"
},
{
"input": "1\n1000000000 239\n3\n14 15\n92 65\n35 89",
"output": "408"
},
{
"input": "10\n598654597 488228616\n544064902 21923894\n329635457 980089248\n988262691 654502493\n967529230 543358150\n835120075 128123793\... | 1,530,010,019 | 2,147,483,647 | Python 3 | OK | TESTS | 33 | 826 | 23,756,800 | n=int(input())
dict1={}
for i in range(n):
a,x=map(int,input().split())
dict1[a]=[x]
m=int(input())
for i in range(m):
a,x=map(int,input().split())
try:
dict1[a].append(x)
except:
KeyError
dict1[a]=[x]
ans=0
for i in dict1:
ans+=max(dict1[i])
print(ans)
| Title: Businessmen Problems
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Two famous competing companies ChemForces and TopChemist decided to show their sets of recently discovered chemical elements on an exhibition. However they know that no element should be present in the sets of both... | ```python
n=int(input())
dict1={}
for i in range(n):
a,x=map(int,input().split())
dict1[a]=[x]
m=int(input())
for i in range(m):
a,x=map(int,input().split())
try:
dict1[a].append(x)
except:
KeyError
dict1[a]=[x]
ans=0
for i in dict1:
ans+=max(dict1[i])
print(ans)
``` | 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,650,485,144 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 436 | 10,649,600 | n, m = map(int, input().split())
rows = set()
columns = set()
answers = []
for i in range(m):
r, c = map(int, input().split())
rows.add(r)
columns.add(c)
answers.append((n-len(rows)) * (n-len(columns)))
for i in range(m):
if i == m-1:
print(answers[i])
else:
print(answers[i], 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())
rows = set()
columns = set()
answers = []
for i in range(m):
r, c = map(int, input().split())
rows.add(r)
columns.add(c)
answers.append((n-len(rows)) * (n-len(columns)))
for i in range(m):
if i == m-1:
print(answers[i])
else:
print(answers[i], end=' ')
... | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Hongcow is ruler of the world. As ruler of the world, he wants to make it easier for people to travel by road within their own countries.
The world can be modeled as an undirected graph with *n* nodes and *m* edges. *k* of the nodes are home to the governments of the *k* countries that make up the world.
There is at ... | The first line of input will contain three integers *n*, *m* and *k* (1<=β€<=*n*<=β€<=1<=000, 0<=β€<=*m*<=β€<=100<=000, 1<=β€<=*k*<=β€<=*n*)Β β the number of vertices and edges in the graph, and the number of vertices that are homes of the government.
The next line of input will contain *k* integers *c*1,<=*c*2,<=...,<=*c**... | Output a single integer, the maximum number of edges Hongcow can add to the graph while keeping it stable. | [
"4 1 2\n1 3\n1 2\n",
"3 3 1\n2\n1 2\n1 3\n2 3\n"
] | [
"2\n",
"0\n"
] | For the first sample test, the graph looks like this:
For the second sample test, the graph looks like this: | 0 | [
{
"input": "4 1 2\n1 3\n1 2",
"output": "2"
},
{
"input": "3 3 1\n2\n1 2\n1 3\n2 3",
"output": "0"
},
{
"input": "10 3 2\n1 10\n1 2\n1 3\n4 5",
"output": "33"
},
{
"input": "1 0 1\n1",
"output": "0"
},
{
"input": "1000 0 1\n72",
"output": "499500"
},
{
... | 1,481,996,981 | 4,481 | Python 3 | OK | TESTS | 61 | 374 | 7,782,400 | def dfs(vertex, summ, has_capital, am):
summ += len(neigh[vertex])
am += 1
if vertex in capitals:
has_capital = True
used[vertex] = True
for nei in neigh[vertex]:
if not used[nei]:
tmp_c, am, summ = dfs(nei, summ, has_capital, am)
has_capital |= tmp_c... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Hongcow is ruler of the world. As ruler of the world, he wants to make it easier for people to travel by road within their own countries.
The world can be modeled as an undirected graph with *n* nodes and *m* edges. *k* of the no... | ```python
def dfs(vertex, summ, has_capital, am):
summ += len(neigh[vertex])
am += 1
if vertex in capitals:
has_capital = True
used[vertex] = True
for nei in neigh[vertex]:
if not used[nei]:
tmp_c, am, summ = dfs(nei, summ, has_capital, am)
has_capita... | 3 | |
507 | B | Amr and Pins | PROGRAMMING | 1,400 | [
"geometry",
"math"
] | null | null | Amr loves Geometry. One day he came up with a very interesting problem.
Amr has a circle of radius *r* and center in point (*x*,<=*y*). He wants the circle center to be in new position (*x*',<=*y*').
In one step Amr can put a pin to the border of the circle in a certain point, then rotate the circle around that pin b... | Input consists of 5 space-separated integers *r*, *x*, *y*, *x*' *y*' (1<=β€<=*r*<=β€<=105, <=-<=105<=β€<=*x*,<=*y*,<=*x*',<=*y*'<=β€<=105), circle radius, coordinates of original center of the circle and coordinates of destination center of the circle respectively. | Output a single integer β minimum number of steps required to move the center of the circle to the destination point. | [
"2 0 0 0 4\n",
"1 1 1 4 4\n",
"4 5 6 5 6\n"
] | [
"1\n",
"3\n",
"0\n"
] | In the first sample test the optimal way is to put a pin at point (0,β2) and rotate the circle by 180 degrees counter-clockwise (or clockwise, no matter).
<img class="tex-graphics" src="https://espresso.codeforces.com/4e40fd4cc24a2050a0488aa131e6244369328039.png" style="max-width: 100.0%;max-height: 100.0%;"/> | 1,000 | [
{
"input": "2 0 0 0 4",
"output": "1"
},
{
"input": "1 1 1 4 4",
"output": "3"
},
{
"input": "4 5 6 5 6",
"output": "0"
},
{
"input": "10 20 0 40 0",
"output": "1"
},
{
"input": "9 20 0 40 0",
"output": "2"
},
{
"input": "5 -1 -6 -5 1",
"output": "... | 1,622,635,025 | 2,147,483,647 | PyPy 3 | OK | TESTS | 37 | 155 | 102,400 | from math import *
r,x,y,xd,yd=map(int,input().split())
d=sqrt((x-xd)**2+(y-yd)**2)
print(ceil(d/(2*r))) | Title: Amr and Pins
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Amr loves Geometry. One day he came up with a very interesting problem.
Amr has a circle of radius *r* and center in point (*x*,<=*y*). He wants the circle center to be in new position (*x*',<=*y*').
In one step Amr can ... | ```python
from math import *
r,x,y,xd,yd=map(int,input().split())
d=sqrt((x-xd)**2+(y-yd)**2)
print(ceil(d/(2*r)))
``` | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers $1$, $5$, $10$ and $50$ respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence s... | The only line of the input file contains a single integer $n$ ($1 \le n \le 10^9$)Β β the number of roman digits to use. | Output a single integerΒ β the number of distinct integers which can be represented using $n$ roman digits exactly. | [
"1\n",
"2\n",
"10\n"
] | [
"4\n",
"10\n",
"244\n"
] | In the first sample there are exactly $4$ integers which can be representedΒ β I, V, X and L.
In the second sample it is possible to represent integers $2$ (II), $6$ (VI), $10$ (VV), $11$ (XI), $15$ (XV), $20$ (XX), $51$ (IL), $55$ (VL), $60$ (XL) and $100$ (LL). | 0 | [
{
"input": "1",
"output": "4"
},
{
"input": "2",
"output": "10"
},
{
"input": "10",
"output": "244"
},
{
"input": "1000",
"output": "48753"
},
{
"input": "2000",
"output": "97753"
},
{
"input": "5000",
"output": "244753"
},
{
"input": "1000... | 1,602,544,827 | 2,147,483,647 | Python 3 | OK | TESTS | 42 | 109 | 0 | non_representable = {
1: 46,
2: 89,
3: 128,
4: 162,
5: 190,
6: 212,
7: 228,
8: 238,
9: 244,
10: 247,
}
n = int(input())
print(49 * n + 1 - non_representable.get(n, 248))
| Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers $1$, $5$, $10$ and $50$ respectively. The use of other roman digits is not allowed.
Numbers in this sys... | ```python
non_representable = {
1: 46,
2: 89,
3: 128,
4: 162,
5: 190,
6: 212,
7: 228,
8: 238,
9: 244,
10: 247,
}
n = int(input())
print(49 * n + 1 - non_representable.get(n, 248))
``` | 3 | |
265 | A | Colorful Stones (Simplified Edition) | PROGRAMMING | 800 | [
"implementation"
] | null | null | There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string *s*. The *i*-th (1-based) character of *s* represents the color of the *i*-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.
Ini... | The input contains two lines. The first line contains the string *s* (1<=β€<=|*s*|<=β€<=50). The second line contains the string *t* (1<=β€<=|*t*|<=β€<=50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence. | Print the final 1-based position of Liss in a single line. | [
"RGB\nRRR\n",
"RRRBGBRBBB\nBBBRR\n",
"BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB\nBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB\n"
] | [
"2\n",
"3\n",
"15\n"
] | none | 500 | [
{
"input": "RGB\nRRR",
"output": "2"
},
{
"input": "RRRBGBRBBB\nBBBRR",
"output": "3"
},
{
"input": "BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB\nBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB",
"output": "15"
},
{
"input": "G\nRRBBRBRRBR",
"output": "1"
},
... | 1,604,213,151 | 2,147,483,647 | Python 3 | OK | TESTS | 19 | 216 | 0 | s1=input()
s2=input()
i=j=0
while i<len(s1) and j<len(s2):
if s1[i]==s2[j]:
i+=1
j+=1
else:
j+=1
print(i+1) | Title: Colorful Stones (Simplified Edition)
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string *s*. The *i*-th (1-based) character of *s* represents the color of the *i*-th st... | ```python
s1=input()
s2=input()
i=j=0
while i<len(s1) and j<len(s2):
if s1[i]==s2[j]:
i+=1
j+=1
else:
j+=1
print(i+1)
``` | 3 | |
66 | B | Petya and Countryside | PROGRAMMING | 1,100 | [
"brute force",
"implementation"
] | B. Petya and Countryside | 2 | 256 | Little Petya often travels to his grandmother in the countryside. The grandmother has a large garden, which can be represented as a rectangle 1<=Γ<=*n* in size, when viewed from above. This rectangle is divided into *n* equal square sections. The garden is very unusual as each of the square sections possesses its own f... | The first line contains a positive integer *n* (1<=β€<=*n*<=β€<=1000). The second line contains *n* positive integers which are the height of the sections. All the numbers are no less than 1 and not more than 1000. | Print a single number, the maximal number of watered sections if we create artificial rain above exactly one section. | [
"1\n2\n",
"5\n1 2 1 2 1\n",
"8\n1 2 1 1 1 3 3 4\n"
] | [
"1\n",
"3\n",
"6\n"
] | none | 1,000 | [
{
"input": "1\n2",
"output": "1"
},
{
"input": "5\n1 2 1 2 1",
"output": "3"
},
{
"input": "8\n1 2 1 1 1 3 3 4",
"output": "6"
},
{
"input": "10\n1 2 3 4 5 6 7 8 9 10",
"output": "10"
},
{
"input": "10\n10 9 8 7 6 5 4 3 2 1",
"output": "10"
},
{
"input... | 1,609,676,460 | 2,147,483,647 | PyPy 3 | OK | TESTS | 80 | 342 | 1,536,000 | def main():
n = int(input())
a = [int(i) for i in input().split()]
cnt = 0
for i in range(n):
temp = 1
k = i
j = i - 1
while j >= 0 and a[j] <= a[k]:
temp += 1
j -= 1
k -= 1
if i == n - 1:
cnt = max(cnt, temp)
break
k = i
j = i + 1
while j <= n - 1 and a[j] ... | Title: Petya and Countryside
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Little Petya often travels to his grandmother in the countryside. The grandmother has a large garden, which can be represented as a rectangle 1<=Γ<=*n* in size, when viewed from above. This rectangle is divided into *... | ```python
def main():
n = int(input())
a = [int(i) for i in input().split()]
cnt = 0
for i in range(n):
temp = 1
k = i
j = i - 1
while j >= 0 and a[j] <= a[k]:
temp += 1
j -= 1
k -= 1
if i == n - 1:
cnt = max(cnt, temp)
break
k = i
j = i + 1
while j <= n - 1... | 3.911639 |
330 | B | Road Construction | PROGRAMMING | 1,300 | [
"constructive algorithms",
"graphs"
] | null | null | A country has *n* cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constructed in such a way that it is possible to go from each city to any other city by traversing at most two... | The first line consists of two integers *n* and *m* .
Then *m* lines follow, each consisting of two integers *a**i* and *b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*, *a**i*<=β <=*b**i*), which means that it is not possible to construct a road connecting cities *a**i* and *b**i*. Consider the cities are numbered from 1 to *n*.... | You should print an integer *s*: the minimum number of roads that should be constructed, in the first line. Then *s* lines should follow, each consisting of two integers *a**i* and *b**i* (1<=β€<=*a**i*,<=*b**i*<=β€<=*n*,<=*a**i*<=β <=*b**i*), which means that a road should be constructed between cities *a**i* and *b**i*.... | [
"4 1\n1 3\n"
] | [
"3\n1 2\n4 2\n2 3\n"
] | This is one possible solution of the example:
These are examples of wrong solutions: | 1,000 | [
{
"input": "4 1\n1 3",
"output": "3\n1 2\n4 2\n2 3"
},
{
"input": "1000 0",
"output": "999\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 ... | 1,620,829,160 | 2,147,483,647 | Python 3 | OK | TESTS | 43 | 124 | 6,963,200 | termo1, termo2 = (int(_) for _ in input().split())
lista = [True]*termo1
for i in range(termo2):
x, y = (int(_) for _ in input().split())
lista[x - 1] = lista[y - 1] = False
aux = -1
for i in range(termo1):
if lista[i]:
aux = i
break
print(termo1 - 1)
for i in range(termo... | Title: Road Construction
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A country has *n* cities. Initially, there is no road in the country. One day, the king decides to construct some roads connecting pairs of cities. Roads can be traversed either way. He wants those roads to be constru... | ```python
termo1, termo2 = (int(_) for _ in input().split())
lista = [True]*termo1
for i in range(termo2):
x, y = (int(_) for _ in input().split())
lista[x - 1] = lista[y - 1] = False
aux = -1
for i in range(termo1):
if lista[i]:
aux = i
break
print(termo1 - 1)
for i in r... | 3 | |
996 | A | Hit the Lottery | PROGRAMMING | 800 | [
"dp",
"greedy"
] | null | null | Allen has a LOT of money. He has $n$ dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are $1$, $5$, $10$, $20$, $100$. What is the minimum number of bills Allen could receive after withdrawing his entire balance? | The first and only line of input contains a single integer $n$ ($1 \le n \le 10^9$). | Output the minimum number of bills that Allen could receive. | [
"125\n",
"43\n",
"1000000000\n"
] | [
"3\n",
"5\n",
"10000000\n"
] | In the first sample case, Allen can withdraw this with a $100$ dollar bill, a $20$ dollar bill, and a $5$ dollar bill. There is no way for Allen to receive $125$ dollars in one or two bills.
In the second sample case, Allen can withdraw two $20$ dollar bills and three $1$ dollar bills.
In the third sample case, Allen... | 500 | [
{
"input": "125",
"output": "3"
},
{
"input": "43",
"output": "5"
},
{
"input": "1000000000",
"output": "10000000"
},
{
"input": "4",
"output": "4"
},
{
"input": "5",
"output": "1"
},
{
"input": "1",
"output": "1"
},
{
"input": "74",
"o... | 1,690,758,241 | 2,147,483,647 | Python 3 | OK | TESTS | 49 | 46 | 0 | n = int(input())
ans = 0
money = [1, 5, 10, 20, 100]
for x in money[::-1]:
ans += n // x
n = n % x
# print(ans, n)
print(ans)
| Title: Hit the Lottery
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Allen has a LOT of money. He has $n$ dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are $1$, $5$, $10$, $20$, $100$... | ```python
n = int(input())
ans = 0
money = [1, 5, 10, 20, 100]
for x in money[::-1]:
ans += n // x
n = n % x
# print(ans, n)
print(ans)
``` | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after *k* minutes after turning on.
During cooking, Julia goes to the kitchen every *d* minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. T... | The single line contains three integers *k*, *d* and *t* (1<=β€<=*k*,<=*d*,<=*t*<=β€<=1018). | Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10<=-<=9.
Namely, let's assume that your answer is *x* and the answer of the jury is *y*. The checker program will consider your answer correct if . | [
"3 2 6\n",
"4 2 20\n"
] | [
"6.5\n",
"20.0\n"
] | In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/cce5d3f2f46552034d5ae5d487725705429ec7a5.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Then the chicken will be coo... | 0 | [
{
"input": "3 2 6",
"output": "6.5"
},
{
"input": "4 2 20",
"output": "20.0"
},
{
"input": "8 10 9",
"output": "10.0"
},
{
"input": "43 50 140",
"output": "150.5"
},
{
"input": "251 79 76",
"output": "76.0"
},
{
"input": "892 67 1000",
"output": "1... | 1,527,260,786 | 2,147,483,647 | Python 3 | OK | TESTS | 59 | 78 | 0 | k,d,t=input().split()
k,d,t=int(k),int(d),int(t)
on=k
off=d-(k-1)%d-1
cycle=on+off/2
time=(on+off)*(t//cycle)
t-=cycle*(t//cycle)
if t<k:
print(t+time)
else:
print(time+k+(t-k)*2) | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after *k* minutes after turning on.
During cooking, Julia goes to the kitchen every *d* minutes an... | ```python
k,d,t=input().split()
k,d,t=int(k),int(d),int(t)
on=k
off=d-(k-1)%d-1
cycle=on+off/2
time=(on+off)*(t//cycle)
t-=cycle*(t//cycle)
if t<k:
print(t+time)
else:
print(time+k+(t-k)*2)
``` | 3 | |
75 | A | Life Without Zeros | PROGRAMMING | 1,000 | [
"implementation"
] | A. Life Without Zeros | 2 | 256 | Can you imagine our life if we removed all zeros from it? For sure we will have many problems.
In this problem we will have a simple example if we removed all zeros from our life, it's the addition operation. Let's assume you are given this equation *a*<=+<=*b*<==<=*c*, where *a* and *b* are positive integers, and *c*... | The input will consist of two lines, the first line will contain the integer *a*, and the second line will contain the integer *b* which are in the equation as described above (1<=β€<=*a*,<=*b*<=β€<=109). There won't be any leading zeros in both. The value of *c* should be calculated as *c*<==<=*a*<=+<=*b*. | The output will be just one line, you should print "YES" if the equation will remain correct after removing all zeros, and print "NO" otherwise. | [
"101\n102\n",
"105\n106\n"
] | [
"YES\n",
"NO\n"
] | none | 500 | [
{
"input": "101\n102",
"output": "YES"
},
{
"input": "105\n106",
"output": "NO"
},
{
"input": "544\n397",
"output": "YES"
},
{
"input": "822\n280",
"output": "NO"
},
{
"input": "101\n413",
"output": "NO"
},
{
"input": "309\n139",
"output": "NO"
}... | 1,534,888,032 | 2,147,483,647 | Python 3 | OK | TESTS | 43 | 218 | 0 | n = input()
m = input()
s1 = int(n) + int(m)
s = str(s1)
s = s.replace('0','')
n = n.replace('0','')
m = m.replace('0','')
k = int(n) + int(m)
if(int(k)==int(s)):
print("YES")
else:
print("NO")
# 1534888106664
| Title: Life Without Zeros
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Can you imagine our life if we removed all zeros from it? For sure we will have many problems.
In this problem we will have a simple example if we removed all zeros from our life, it's the addition operation. Let's assu... | ```python
n = input()
m = input()
s1 = int(n) + int(m)
s = str(s1)
s = s.replace('0','')
n = n.replace('0','')
m = m.replace('0','')
k = int(n) + int(m)
if(int(k)==int(s)):
print("YES")
else:
print("NO")
# 1534888106664
``` | 3.9455 |
992 | A | Nastya and an Array | PROGRAMMING | 800 | [
"implementation",
"sortings"
] | null | null | Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties:
- In one second we can add an arbitrary (possibly negative) integer to all elements of the array that are not equal to ze... | The first line contains a single integer *n* (1<=β€<=*n*<=β€<=105) β the size of the array.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=105<=β€<=*a**i*<=β€<=105) β the elements of the array. | Print a single integer β the minimum number of seconds needed to make all elements of the array equal to zero. | [
"5\n1 1 1 1 1\n",
"3\n2 0 -1\n",
"4\n5 -6 -5 1\n"
] | [
"1\n",
"2\n",
"4\n"
] | In the first example you can add β-β1 to all non-zero elements in one second and make them equal to zero.
In the second example you can add β-β2 on the first second, then the array becomes equal to [0,β0,ββ-β3]. On the second second you can add 3 to the third (the only non-zero) element. | 500 | [
{
"input": "5\n1 1 1 1 1",
"output": "1"
},
{
"input": "3\n2 0 -1",
"output": "2"
},
{
"input": "4\n5 -6 -5 1",
"output": "4"
},
{
"input": "1\n0",
"output": "0"
},
{
"input": "2\n21794 -79194",
"output": "2"
},
{
"input": "3\n-63526 95085 -5239",
... | 1,534,962,160 | 520 | Python 3 | OK | TESTS | 79 | 186 | 8,908,800 | from collections import Counter
n = int(input())
arr = [int(x) for x in input().split()]
count = Counter(arr)
if 0 in arr:
print(len(count) - 1)
else:
print(len(count))
| Title: Nastya and an Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties:
- In one second ... | ```python
from collections import Counter
n = int(input())
arr = [int(x) for x in input().split()]
count = Counter(arr)
if 0 in arr:
print(len(count) - 1)
else:
print(len(count))
``` | 3 | |
63 | A | Sinking Ship | PROGRAMMING | 900 | [
"implementation",
"sortings",
"strings"
] | A. Sinking Ship | 2 | 256 | The ship crashed into a reef and is sinking. Now the entire crew must be evacuated. All *n* crew members have already lined up in a row (for convenience let's label them all from left to right with positive integers from 1 to *n*) and await further instructions. However, one should evacuate the crew properly, in a stri... | The first line contains an integer *n*, which is the number of people in the crew (1<=β€<=*n*<=β€<=100). Then follow *n* lines. The *i*-th of those lines contains two words β the name of the crew member who is *i*-th in line, and his status on the ship. The words are separated by exactly one space. There are no other spa... | Print *n* lines. The *i*-th of them should contain the name of the crew member who must be the *i*-th one to leave the ship. | [
"6\nJack captain\nAlice woman\nCharlie man\nTeddy rat\nBob child\nJulia woman\n"
] | [
"Teddy\nAlice\nBob\nJulia\nCharlie\nJack\n"
] | none | 500 | [
{
"input": "6\nJack captain\nAlice woman\nCharlie man\nTeddy rat\nBob child\nJulia woman",
"output": "Teddy\nAlice\nBob\nJulia\nCharlie\nJack"
},
{
"input": "1\nA captain",
"output": "A"
},
{
"input": "1\nAbcdefjhij captain",
"output": "Abcdefjhij"
},
{
"input": "5\nA captain... | 1,622,129,337 | 2,147,483,647 | PyPy 3 | OK | TESTS | 26 | 186 | 0 | from sys import stdin
d={}
for _ in range(int(stdin.readline())):
n,k=stdin.readline().split()
if k=='woman' or k=='child': k='common'
d[k]=d.get(k,"")+n+"\n"
print(str(d.get('rat',""))+str(d.get('common',""))+str(d.get('man',""))+str(d.get('captain',"")),end="")
| Title: Sinking Ship
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
The ship crashed into a reef and is sinking. Now the entire crew must be evacuated. All *n* crew members have already lined up in a row (for convenience let's label them all from left to right with positive integers from 1 to ... | ```python
from sys import stdin
d={}
for _ in range(int(stdin.readline())):
n,k=stdin.readline().split()
if k=='woman' or k=='child': k='common'
d[k]=d.get(k,"")+n+"\n"
print(str(d.get('rat',""))+str(d.get('common',""))+str(d.get('man',""))+str(d.get('captain',"")),end="")
`... | 3.9535 |
441 | A | Valera and Antique Items | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | Valera is a collector. Once he wanted to expand his collection with exactly one antique item.
Valera knows *n* sellers of antiques, the *i*-th of them auctioned *k**i* items. Currently the auction price of the *j*-th object of the *i*-th seller is *s**ij*. Valera gets on well with each of the *n* sellers. He is perfec... | The first line contains two space-separated integers *n*,<=*v* (1<=β€<=*n*<=β€<=50;Β 104<=β€<=*v*<=β€<=106) β the number of sellers and the units of money the Valera has.
Then *n* lines follow. The *i*-th line first contains integer *k**i* (1<=β€<=*k**i*<=β€<=50) the number of items of the *i*-th seller. Then go *k**i* space... | In the first line, print integer *p* β the number of sellers with who Valera can make a deal.
In the second line print *p* space-separated integers *q*1,<=*q*2,<=...,<=*q**p* (1<=β€<=*q**i*<=β€<=*n*) β the numbers of the sellers with who Valera can make a deal. Print the numbers of the sellers in the increasing order. | [
"3 50000\n1 40000\n2 20000 60000\n3 10000 70000 190000\n",
"3 50000\n1 50000\n3 100000 120000 110000\n3 120000 110000 120000\n"
] | [
"3\n1 2 3\n",
"0\n\n"
] | In the first sample Valera can bargain with each of the sellers. He can outbid the following items: a 40000 item from the first seller, a 20000 item from the second seller, and a 10000 item from the third seller.
In the second sample Valera can not make a deal with any of the sellers, as the prices of all items in the... | 500 | [
{
"input": "3 50000\n1 40000\n2 20000 60000\n3 10000 70000 190000",
"output": "3\n1 2 3"
},
{
"input": "3 50000\n1 50000\n3 100000 120000 110000\n3 120000 110000 120000",
"output": "0"
},
{
"input": "2 100001\n1 895737\n1 541571",
"output": "0"
},
{
"input": "1 1000000\n1 100... | 1,467,767,896 | 2,147,483,647 | Python 3 | OK | TESTS | 26 | 62 | 0 | enteros = input()
#n es nΓΊmero de vendedores
#v cantidad de dinero de Valera
n, v = enteros.split()
n = int(n)
v = int(v)
#print("n", n, "v", v)
resultado = []
for i in range(1, n+1):
#print("i =", i)
datos = input().split()
for j in datos[1:]:
if v > int(j):
resultado.append(i)
... | Title: Valera and Antique Items
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Valera is a collector. Once he wanted to expand his collection with exactly one antique item.
Valera knows *n* sellers of antiques, the *i*-th of them auctioned *k**i* items. Currently the auction price of the... | ```python
enteros = input()
#n es nΓΊmero de vendedores
#v cantidad de dinero de Valera
n, v = enteros.split()
n = int(n)
v = int(v)
#print("n", n, "v", v)
resultado = []
for i in range(1, n+1):
#print("i =", i)
datos = input().split()
for j in datos[1:]:
if v > int(j):
resultado.append(i... | 3 | |
799 | A | Carrot Cakes | PROGRAMMING | 1,100 | [
"brute force",
"implementation"
] | null | null | In some game by Playrix it takes *t* minutes for an oven to bake *k* carrot cakes, all cakes are ready at the same moment *t* minutes after they started baking. Arkady needs at least *n* cakes to complete a task, but he currently don't have any. However, he has infinitely many ingredients and one oven. Moreover, Arkady... | The only line contains four integers *n*, *t*, *k*, *d* (1<=β€<=*n*,<=*t*,<=*k*,<=*d*<=β€<=1<=000)Β β the number of cakes needed, the time needed for one oven to bake *k* cakes, the number of cakes baked at the same time, the time needed to build the second oven. | If it is reasonable to build the second oven, print "YES". Otherwise print "NO". | [
"8 6 4 5\n",
"8 6 4 6\n",
"10 3 11 4\n",
"4 2 1 4\n"
] | [
"YES\n",
"NO\n",
"NO\n",
"YES\n"
] | In the first example it is possible to get 8 cakes in 12 minutes using one oven. The second oven can be built in 5 minutes, so after 6 minutes the first oven bakes 4 cakes, the second oven bakes 4 more ovens after 11 minutes. Thus, it is reasonable to build the second oven.
In the second example it doesn't matter whe... | 500 | [
{
"input": "8 6 4 5",
"output": "YES"
},
{
"input": "8 6 4 6",
"output": "NO"
},
{
"input": "10 3 11 4",
"output": "NO"
},
{
"input": "4 2 1 4",
"output": "YES"
},
{
"input": "28 17 16 26",
"output": "NO"
},
{
"input": "60 69 9 438",
"output": "NO"... | 1,677,433,180 | 2,147,483,647 | Python 3 | OK | TESTS | 93 | 46 | 0 | n,t,k,d=map(int,input().split())
u=0--n//k
u-=d//t+1
print('YNEOS'[u<=0::2]) | Title: Carrot Cakes
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In some game by Playrix it takes *t* minutes for an oven to bake *k* carrot cakes, all cakes are ready at the same moment *t* minutes after they started baking. Arkady needs at least *n* cakes to complete a task, but he cu... | ```python
n,t,k,d=map(int,input().split())
u=0--n//k
u-=d//t+1
print('YNEOS'[u<=0::2])
``` | 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,612,329,908 | 2,147,483,647 | Python 3 | OK | TESTS | 102 | 77 | 0 | n1=input()
n2=input()
res=''
for i in range(len(n2)):
if n1[i]=='1' and n2[i]=='1':
res=res+'0'
elif n1[i]=='0' and n2[i]=='0':
res=res+'0'
else:
res=res+'1'
print(res)
| 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
n1=input()
n2=input()
res=''
for i in range(len(n2)):
if n1[i]=='1' and n2[i]=='1':
res=res+'0'
elif n1[i]=='0' and n2[i]=='0':
res=res+'0'
else:
res=res+'1'
print(res)
``` | 3.98075 |
673 | A | Bear and Game | PROGRAMMING | 800 | [
"implementation"
] | null | null | Bear Limak likes watching sports on TV. He is going to watch a game today. The game lasts 90 minutes and there are no breaks.
Each minute can be either interesting or boring. If 15 consecutive minutes are boring then Limak immediately turns TV off.
You know that there will be *n* interesting minutes *t*1,<=*t*2,<=...... | The first line of the input contains one integer *n* (1<=β€<=*n*<=β€<=90)Β β the number of interesting minutes.
The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=β€<=*t*1<=<<=*t*2<=<<=... *t**n*<=β€<=90), given in the increasing order. | Print the number of minutes Limak will watch the game. | [
"3\n7 20 88\n",
"9\n16 20 30 40 50 60 70 80 90\n",
"9\n15 20 30 40 50 60 70 80 90\n"
] | [
"35\n",
"15\n",
"90\n"
] | In the first sample, minutes 21,β22,β...,β35 are all boring and thus Limak will turn TV off immediately after the 35-th minute. So, he would watch the game for 35 minutes.
In the second sample, the first 15 minutes are boring.
In the third sample, there are no consecutive 15 boring minutes. So, Limak will watch the w... | 500 | [
{
"input": "3\n7 20 88",
"output": "35"
},
{
"input": "9\n16 20 30 40 50 60 70 80 90",
"output": "15"
},
{
"input": "9\n15 20 30 40 50 60 70 80 90",
"output": "90"
},
{
"input": "30\n6 11 12 15 22 24 30 31 32 33 34 35 40 42 44 45 47 50 53 54 57 58 63 67 75 77 79 81 83 88",
... | 1,556,799,013 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 108 | 0 | def main():
input()
t = [int(_) for _ in input().split()] + [90]
end = 0
still_interesting = True
next_interesting = 0
while end < 90 and still_interesting:
end = min(end + 15, 90)
if end >= t[next_interesting]:
end = t[next_interesting]
next_interesting... | Title: Bear and Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bear Limak likes watching sports on TV. He is going to watch a game today. The game lasts 90 minutes and there are no breaks.
Each minute can be either interesting or boring. If 15 consecutive minutes are boring then Lim... | ```python
def main():
input()
t = [int(_) for _ in input().split()] + [90]
end = 0
still_interesting = True
next_interesting = 0
while end < 90 and still_interesting:
end = min(end + 15, 90)
if end >= t[next_interesting]:
end = t[next_interesting]
next_i... | 3 | |
672 | B | Different is Good | PROGRAMMING | 1,000 | [
"constructive algorithms",
"implementation",
"strings"
] | null | null | A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string *s* consisting of lowercase English letters. Since Kerem likes it when things are different, he wants all substrings of his string *s* to be distinct. Substring is a string formed by some... | The first line of the input contains an integer *n* (1<=β€<=*n*<=β€<=100<=000)Β β the length of the string *s*.
The second line contains the string *s* of length *n* consisting of only lowercase English letters. | If it's impossible to change the string *s* such that all its substring are distinct print -1. Otherwise print the minimum required number of changes. | [
"2\naa\n",
"4\nkoko\n",
"5\nmurat\n"
] | [
"1\n",
"2\n",
"0\n"
] | In the first sample one of the possible solutions is to change the first character to 'b'.
In the second sample, one may change the first character to 'a' and second character to 'b', so the string becomes "abko". | 1,000 | [
{
"input": "2\naa",
"output": "1"
},
{
"input": "4\nkoko",
"output": "2"
},
{
"input": "5\nmurat",
"output": "0"
},
{
"input": "6\nacbead",
"output": "1"
},
{
"input": "7\ncdaadad",
"output": "4"
},
{
"input": "25\npeoaicnbisdocqofsqdpgobpn",
"outp... | 1,616,284,191 | 2,147,483,647 | PyPy 3 | OK | TESTS | 47 | 108 | 0 | n = int(input())
if n <= 26:
print(n-len(set(input())))
else:
print("-1")
| Title: Different is Good
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string *s* consisting of lowercase English letters. Since Kerem likes it when things are di... | ```python
n = int(input())
if n <= 26:
print(n-len(set(input())))
else:
print("-1")
``` | 3 | |
950 | A | Left-handers, Right-handers and Ambidexters | PROGRAMMING | 800 | [
"implementation",
"math"
] | null | null | You are at a water bowling training. There are *l* people who play with their left hand, *r* people, who play with their right hand, and *a* ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and ... | The only line contains three integers *l*, *r* and *a* (0<=β€<=*l*,<=*r*,<=*a*<=β€<=100) β the number of left-handers, the number of right-handers and the number of ambidexters at the training. | Print a single even integerΒ β the maximum number of players in the team. It is possible that the team can only have zero number of players. | [
"1 4 2\n",
"5 5 5\n",
"0 2 0\n"
] | [
"6\n",
"14\n",
"0\n"
] | In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five l... | 500 | [
{
"input": "1 4 2",
"output": "6"
},
{
"input": "5 5 5",
"output": "14"
},
{
"input": "0 2 0",
"output": "0"
},
{
"input": "30 70 34",
"output": "128"
},
{
"input": "89 32 24",
"output": "112"
},
{
"input": "89 44 77",
"output": "210"
},
{
... | 1,579,257,569 | 2,147,483,647 | Python 3 | OK | TESTS | 79 | 109 | 307,200 | def solve(l, r, a):
x = abs(l - r)
y = min(x, a)
x = min(l, r) + y
return (x + (a - y)//2)*2
def main():
l, r, a = list(map(int, input().split()))
print(solve(l, r, a))
main()
| Title: Left-handers, Right-handers and Ambidexters
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are at a water bowling training. There are *l* people who play with their left hand, *r* people, who play with their right hand, and *a* ambidexters, who can play with left or right hand.... | ```python
def solve(l, r, a):
x = abs(l - r)
y = min(x, a)
x = min(l, r) + y
return (x + (a - y)//2)*2
def main():
l, r, a = list(map(int, input().split()))
print(solve(l, r, a))
main()
``` | 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,573,106,381 | 2,147,483,647 | Python 3 | OK | TESTS | 31 | 109 | 0 | n,m=[int(x) for x in input().split()]
l=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
res=[]
for i in l:
if i in a:
res.append(i)
print(*res,sep=' ')
| 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
n,m=[int(x) for x in input().split()]
l=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
res=[]
for i in l:
if i in a:
res.append(i)
print(*res,sep=' ')
``` | 3 | |
11 | A | Increasing Sequence | PROGRAMMING | 900 | [
"constructive algorithms",
"implementation",
"math"
] | A. Increasing Sequence | 1 | 64 | A sequence *a*0,<=*a*1,<=...,<=*a**t*<=-<=1 is called increasing if *a**i*<=-<=1<=<<=*a**i* for each *i*:<=0<=<<=*i*<=<<=*t*.
You are given a sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 and a positive integer *d*. In each move you may choose one element of the given sequence and add *d* to it. What is the least... | The first line of the input contains two integer numbers *n* and *d* (2<=β€<=*n*<=β€<=2000,<=1<=β€<=*d*<=β€<=106). The second line contains space separated sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 (1<=β€<=*b**i*<=β€<=106). | Output the minimal number of moves needed to make the sequence increasing. | [
"4 2\n1 3 3 2\n"
] | [
"3\n"
] | none | 0 | [
{
"input": "4 2\n1 3 3 2",
"output": "3"
},
{
"input": "2 1\n1 1",
"output": "1"
},
{
"input": "2 1\n2 5",
"output": "0"
},
{
"input": "2 1\n1 2",
"output": "0"
},
{
"input": "2 1\n1 1",
"output": "1"
},
{
"input": "2 7\n10 20",
"output": "0"
},
... | 1,598,711,889 | 2,147,483,647 | PyPy 3 | OK | TESTS | 25 | 310 | 1,843,200 | n,d = map(int,input().split())
bi = list(map(int,input().split()))
maxn = bi[0]
ans = 0
for i in range(1,n):
maxn = max(maxn+1,bi[i])
n = (maxn - bi[i])//d + int((maxn - bi[i])% d != 0)
maxn = bi[i] + n * d
ans += n
print(ans)
| Title: Increasing Sequence
Time Limit: 1 seconds
Memory Limit: 64 megabytes
Problem Description:
A sequence *a*0,<=*a*1,<=...,<=*a**t*<=-<=1 is called increasing if *a**i*<=-<=1<=<<=*a**i* for each *i*:<=0<=<<=*i*<=<<=*t*.
You are given a sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 and a positive integer *d*... | ```python
n,d = map(int,input().split())
bi = list(map(int,input().split()))
maxn = bi[0]
ans = 0
for i in range(1,n):
maxn = max(maxn+1,bi[i])
n = (maxn - bi[i])//d + int((maxn - bi[i])% d != 0)
maxn = bi[i] + n * d
ans += n
print(ans)
``` | 3.831267 |
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,652,515,834 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 45 | 124 | 0 | ls = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
n, m = map(int, input().split())
if m == n:
print('NO')
elif m < n:
print('NO')
else:
if n in ls and m in ls:
x = ls.index(n)
y = ls.index(m)
if y - x == 1:
print('YES')
else:
... | 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
ls = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
n, m = map(int, input().split())
if m == n:
print('NO')
elif m < n:
print('NO')
else:
if n in ls and m in ls:
x = ls.index(n)
y = ls.index(m)
if y - x == 1:
print('YES')
else:
... | 3.969 |
466 | C | Number of Ways | PROGRAMMING | 1,700 | [
"binary search",
"brute force",
"data structures",
"dp",
"two pointers"
] | null | null | You've got array *a*[1],<=*a*[2],<=...,<=*a*[*n*], consisting of *n* integers. Count the number of ways to split all the elements of the array into three contiguous parts so that the sum of elements in each part is the same.
More formally, you need to find the number of such pairs of indices *i*,<=*j* (2<=β€<=*i*<=β€<=... | The first line contains integer *n* (1<=β€<=*n*<=β€<=5Β·105), showing how many numbers are in the array. The second line contains *n* integers *a*[1], *a*[2], ..., *a*[*n*] (|*a*[*i*]|<=β€<=<=109) β the elements of array *a*. | Print a single integer β the number of ways to split the array into three parts with the same sum. | [
"5\n1 2 3 0 3\n",
"4\n0 1 -1 0\n",
"2\n4 1\n"
] | [
"2\n",
"1\n",
"0\n"
] | none | 1,500 | [
{
"input": "5\n1 2 3 0 3",
"output": "2"
},
{
"input": "4\n0 1 -1 0",
"output": "1"
},
{
"input": "2\n4 1",
"output": "0"
},
{
"input": "9\n0 0 0 0 0 0 0 0 0",
"output": "28"
},
{
"input": "10\n2 5 -2 2 -3 -2 3 5 -5 -2",
"output": "0"
},
{
"input": "1\... | 1,699,580,934 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 358 | 62,361,600 | N=int(input())
arr=list(map(int,input().split()))
s=sum(arr)
if s%3!=0:
print('0')
else:
s=s//3
L=count=0
tot=arr[0]
for i in arr[1:]:
if tot == s*2:
count+=L
if tot == s:
L+=1
tot+=i
print(count) | Title: Number of Ways
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You've got array *a*[1],<=*a*[2],<=...,<=*a*[*n*], consisting of *n* integers. Count the number of ways to split all the elements of the array into three contiguous parts so that the sum of elements in each part is the s... | ```python
N=int(input())
arr=list(map(int,input().split()))
s=sum(arr)
if s%3!=0:
print('0')
else:
s=s//3
L=count=0
tot=arr[0]
for i in arr[1:]:
if tot == s*2:
count+=L
if tot == s:
L+=1
tot+=i
print(count)
``` | 3 | |
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,606,040,105 | 2,147,483,647 | Python 3 | OK | TESTS | 41 | 109 | 614,400 | [n, m] = list(map(int, input().split()))
a = list(map(int, input().split()))[:n]
b = list(map(int, input().split()))[:m]
result = 0
j = 0
for i in range(n):
while(j < m):
if(a[i] <= b[j]):
result = result + 1
j = j + 1
break
j = j + 1
print(n -... | 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
[n, m] = list(map(int, input().split()))
a = list(map(int, input().split()))[:n]
b = list(map(int, input().split()))[:m]
result = 0
j = 0
for i in range(n):
while(j < m):
if(a[i] <= b[j]):
result = result + 1
j = j + 1
break
j = j + 1
... | 3 | |
408 | A | Line to Cashier | PROGRAMMING | 900 | [
"implementation"
] | null | null | Little Vasya went to the supermarket to get some groceries. He walked about the supermarket for a long time and got a basket full of products. Now he needs to choose the cashier to pay for the products.
There are *n* cashiers at the exit from the supermarket. At the moment the queue for the *i*-th cashier already has ... | The first line contains integer *n* (1<=β€<=*n*<=β€<=100)Β β the number of cashes in the shop. The second line contains *n* space-separated integers: *k*1,<=*k*2,<=...,<=*k**n* (1<=β€<=*k**i*<=β€<=100), where *k**i* is the number of people in the queue to the *i*-th cashier.
The *i*-th of the next *n* lines contains *k**i*... | Print a single integer β the minimum number of seconds Vasya needs to get to the cashier. | [
"1\n1\n1\n",
"4\n1 4 3 2\n100\n1 2 2 3\n1 9 1\n7 8\n"
] | [
"20\n",
"100\n"
] | In the second test sample, if Vasya goes to the first queue, he gets to the cashier in 100Β·5β+β15β=β515 seconds. But if he chooses the second queue, he will need 1Β·5β+β2Β·5β+β2Β·5β+β3Β·5β+β4Β·15β=β100 seconds. He will need 1Β·5β+β9Β·5β+β1Β·5β+β3Β·15β=β100 seconds for the third one and 7Β·5β+β8Β·5β+β2Β·15β=β105 seconds for the fou... | 500 | [
{
"input": "1\n1\n1",
"output": "20"
},
{
"input": "4\n1 4 3 2\n100\n1 2 2 3\n1 9 1\n7 8",
"output": "100"
},
{
"input": "4\n5 4 5 5\n3 1 3 1 2\n3 1 1 3\n1 1 1 2 2\n2 2 1 1 3",
"output": "100"
},
{
"input": "5\n5 3 6 6 4\n7 5 3 3 9\n6 8 2\n1 10 8 5 9 2\n9 7 8 5 9 10\n9 8 3 3"... | 1,539,191,683 | 2,147,483,647 | Python 3 | OK | TESTS | 20 | 124 | 0 | n=int(input())
a= list(map(int, input().split()))
b=[]
for i in range(n):
c= list(map(int, input().split()))
temp=sum(c)*5+a[i]*15
b.append(temp)
print(min(b))
| Title: Line to Cashier
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little Vasya went to the supermarket to get some groceries. He walked about the supermarket for a long time and got a basket full of products. Now he needs to choose the cashier to pay for the products.
There are *n* c... | ```python
n=int(input())
a= list(map(int, input().split()))
b=[]
for i in range(n):
c= list(map(int, input().split()))
temp=sum(c)*5+a[i]*15
b.append(temp)
print(min(b))
``` | 3 | |
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,698,147,002 | 2,147,483,647 | Python 3 | OK | TESTS | 44 | 124 | 0 | a,b = map(int,input().split())
c = list(input())
for i in range(b):
j = 1
while j<a:
if c[-j] == 'G' and c[-j-1] == 'B':
c[-j],c[-j-1] = c[-j-1],c[-j]
j += 2
else:
j += 1
print(''.join(c))
| 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
a,b = map(int,input().split())
c = list(input())
for i in range(b):
j = 1
while j<a:
if c[-j] == 'G' and c[-j-1] == 'B':
c[-j],c[-j-1] = c[-j-1],c[-j]
j += 2
else:
j += 1
print(''.join(c))
``` | 3 | |
112 | A | Petya and Strings | PROGRAMMING | 800 | [
"implementation",
"strings"
] | A. Petya and Strings | 2 | 256 | Little Petya loves presents. His mum bought him two strings of the same size for his birthday. The strings consist of uppercase and lowercase Latin letters. Now Petya wants to compare those two strings lexicographically. The letters' case does not matter, that is an uppercase letter is considered equivalent to the corr... | Each of the first two lines contains a bought string. The strings' lengths range from 1 to 100 inclusive. It is guaranteed that the strings are of the same length and also consist of uppercase and lowercase Latin letters. | If the first string is less than the second one, print "-1". If the second string is less than the first one, print "1". If the strings are equal, print "0". Note that the letters' case is not taken into consideration when the strings are compared. | [
"aaaa\naaaA\n",
"abs\nAbz\n",
"abcdefg\nAbCdEfF\n"
] | [
"0\n",
"-1\n",
"1\n"
] | If you want more formal information about the lexicographical order (also known as the "dictionary order" or "alphabetical order"), you can visit the following site:
- http://en.wikipedia.org/wiki/Lexicographical_order | 500 | [
{
"input": "aaaa\naaaA",
"output": "0"
},
{
"input": "abs\nAbz",
"output": "-1"
},
{
"input": "abcdefg\nAbCdEfF",
"output": "1"
},
{
"input": "asadasdasd\nasdwasdawd",
"output": "-1"
},
{
"input": "aslkjlkasdd\nasdlkjdajwi",
"output": "1"
},
{
"input":... | 1,699,207,616 | 2,147,483,647 | Python 3 | OK | TESTS | 53 | 92 | 0 | n1 = input()
n2 = input()
if n1.lower() < n2.lower():
print(-1)
elif n1.lower() > n2.lower():
print(1)
else:
print(0) | Title: Petya and Strings
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Little Petya loves presents. His mum bought him two strings of the same size for his birthday. The strings consist of uppercase and lowercase Latin letters. Now Petya wants to compare those two strings lexicographically. ... | ```python
n1 = input()
n2 = input()
if n1.lower() < n2.lower():
print(-1)
elif n1.lower() > n2.lower():
print(1)
else:
print(0)
``` | 3.977 |
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,561,177,689 | 189 | Python 3 | OK | TESTS | 34 | 124 | 0 | n = input(); n =int(n) # n usbs
m = input(); m = int(m) # file size
caps = [] # capacities
for i in range(int(n)):
cap = input(); cap = int(cap)
caps.append(cap)
caps.sort(reverse=True)
count = 0
value = 0
for cap in caps:
count += 1
value = value + cap
if value >= m:
bre... | 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
n = input(); n =int(n) # n usbs
m = input(); m = int(m) # file size
caps = [] # capacities
for i in range(int(n)):
cap = input(); cap = int(cap)
caps.append(cap)
caps.sort(reverse=True)
count = 0
value = 0
for cap in caps:
count += 1
value = value + cap
if value >= m:
... | 3 | |
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,621,407,882 | 2,147,483,647 | Python 3 | OK | TESTS | 47 | 77 | 0 | import math
# test = int(input())
# for q in range(test):
x, y = map(int, input().split())
# n = int(input())
# s = input()
s = ""
i = 0
while i<x:
for j in range(min(y, x-i)):
s += chr(ord("a")+j)
i += j + 1
print(s) | 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
import math
# test = int(input())
# for q in range(test):
x, y = map(int, input().split())
# n = int(input())
# s = input()
s = ""
i = 0
while i<x:
for j in range(min(y, x-i)):
s += chr(ord("a")+j)
i += j + 1
print(s)
``` | 3 | |
459 | A | Pashmak and Garden | PROGRAMMING | 1,200 | [
"implementation"
] | null | null | Pashmak has fallen in love with an attractive girl called Parmida since one year ago...
Today, Pashmak set up a meeting with his partner in a romantic garden. Unfortunately, Pashmak has forgotten where the garden is. But he remembers that the garden looks like a square with sides parallel to the coordinate axes. He al... | The first line contains four space-separated *x*1,<=*y*1,<=*x*2,<=*y*2 (<=-<=100<=β€<=*x*1,<=*y*1,<=*x*2,<=*y*2<=β€<=100) integers, where *x*1 and *y*1 are coordinates of the first tree and *x*2 and *y*2 are coordinates of the second tree. It's guaranteed that the given points are distinct. | If there is no solution to the problem, print -1. Otherwise print four space-separated integers *x*3,<=*y*3,<=*x*4,<=*y*4 that correspond to the coordinates of the two other trees. If there are several solutions you can output any of them.
Note that *x*3,<=*y*3,<=*x*4,<=*y*4 must be in the range (<=-<=1000<=β€<=*x*3,<... | [
"0 0 0 1\n",
"0 0 1 1\n",
"0 0 1 2\n"
] | [
"1 0 1 1\n",
"0 1 1 0\n",
"-1\n"
] | none | 500 | [
{
"input": "0 0 0 1",
"output": "1 0 1 1"
},
{
"input": "0 0 1 1",
"output": "0 1 1 0"
},
{
"input": "0 0 1 2",
"output": "-1"
},
{
"input": "-100 -100 100 100",
"output": "-100 100 100 -100"
},
{
"input": "-100 -100 99 100",
"output": "-1"
},
{
"input... | 1,690,579,822 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 74 | 62 | 0 | import sys
input = sys.stdin.readline
x1,y1,x2,y2 = map(int,input().split())
if x1 == x2:
print(x1 + abs(y1-y2), y2, x1 + abs(y1-y2), y1)
elif y1 == y2:
print(x1, y1+abs(x2-x1), x2, y1 + abs(x2-x1))
else:
if abs(x1-x2) != abs(y1-y2):
print(-1)
else:
print(x1, y2, x2, y1)
| Title: Pashmak and Garden
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Pashmak has fallen in love with an attractive girl called Parmida since one year ago...
Today, Pashmak set up a meeting with his partner in a romantic garden. Unfortunately, Pashmak has forgotten where the garden is... | ```python
import sys
input = sys.stdin.readline
x1,y1,x2,y2 = map(int,input().split())
if x1 == x2:
print(x1 + abs(y1-y2), y2, x1 + abs(y1-y2), y1)
elif y1 == y2:
print(x1, y1+abs(x2-x1), x2, y1 + abs(x2-x1))
else:
if abs(x1-x2) != abs(y1-y2):
print(-1)
else:
print(x1, y2, x2, y1)
``` | 3 | |
378 | A | Playing with Dice | PROGRAMMING | 800 | [
"brute force"
] | null | null | Two players are playing a game. First each of them writes an integer from 1 to 6, and then a dice is thrown. The player whose written number got closer to the number on the dice wins. If both payers have the same difference, it's a draw.
The first player wrote number *a*, the second player wrote number *b*. How many w... | The single line contains two integers *a* and *b* (1<=β€<=*a*,<=*b*<=β€<=6)Β β the numbers written on the paper by the first and second player, correspondingly. | Print three integers: the number of ways to throw the dice at which the first player wins, the game ends with a draw or the second player wins, correspondingly. | [
"2 5\n",
"2 4\n"
] | [
"3 0 3\n",
"2 1 3\n"
] | The dice is a standard cube-shaped six-sided object with each side containing a number from 1 to 6, and where all numbers on all sides are distinct.
You can assume that number *a* is closer to number *x* than number *b*, if |*a*β-β*x*|β<β|*b*β-β*x*|. | 500 | [
{
"input": "2 5",
"output": "3 0 3"
},
{
"input": "2 4",
"output": "2 1 3"
},
{
"input": "5 3",
"output": "2 1 3"
},
{
"input": "1 6",
"output": "3 0 3"
},
{
"input": "5 1",
"output": "3 1 2"
},
{
"input": "6 3",
"output": "2 0 4"
},
{
"inp... | 1,588,497,812 | 2,147,483,647 | Python 3 | OK | TESTS | 38 | 109 | 0 | a,b = list(map(int,input().split()))
x=0;y=0;z=0
for i in range(1,7):
if abs(a-i)<abs(b-i):
x = x + 1
elif abs(a-i)==abs(b-i):
y = y + 1
else:
z = z + 1
print(x,y,z)
| Title: Playing with Dice
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Two players are playing a game. First each of them writes an integer from 1 to 6, and then a dice is thrown. The player whose written number got closer to the number on the dice wins. If both payers have the same diff... | ```python
a,b = list(map(int,input().split()))
x=0;y=0;z=0
for i in range(1,7):
if abs(a-i)<abs(b-i):
x = x + 1
elif abs(a-i)==abs(b-i):
y = y + 1
else:
z = z + 1
print(x,y,z)
``` | 3 | |
295 | A | Greg and Array | PROGRAMMING | 1,400 | [
"data structures",
"implementation"
] | null | null | Greg has an array *a*<==<=*a*1,<=*a*2,<=...,<=*a**n* and *m* operations. Each operation looks as: *l**i*, *r**i*, *d**i*, (1<=β€<=*l**i*<=β€<=*r**i*<=β€<=*n*). To apply operation *i* to the array means to increase all array elements with numbers *l**i*,<=*l**i*<=+<=1,<=...,<=*r**i* by value *d**i*.
Greg wrote down *k* qu... | The first line contains integers *n*, *m*, *k* (1<=β€<=*n*,<=*m*,<=*k*<=β€<=105). The second line contains *n* integers: *a*1,<=*a*2,<=...,<=*a**n* (0<=β€<=*a**i*<=β€<=105) β the initial array.
Next *m* lines contain operations, the operation number *i* is written as three integers: *l**i*, *r**i*, *d**i*, (1<=β€<=*l**i*<=... | On a single line print *n* integers *a*1,<=*a*2,<=...,<=*a**n* β the array after executing all the queries. Separate the printed numbers by spaces.
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 of the %I64d specifier. | [
"3 3 3\n1 2 3\n1 2 1\n1 3 2\n2 3 4\n1 2\n1 3\n2 3\n",
"1 1 1\n1\n1 1 1\n1 1\n",
"4 3 6\n1 2 3 4\n1 2 1\n2 3 2\n3 4 4\n1 2\n1 3\n2 3\n1 2\n1 3\n2 3\n"
] | [
"9 18 17\n",
"2\n",
"5 18 31 20\n"
] | none | 500 | [
{
"input": "3 3 3\n1 2 3\n1 2 1\n1 3 2\n2 3 4\n1 2\n1 3\n2 3",
"output": "9 18 17"
},
{
"input": "1 1 1\n1\n1 1 1\n1 1",
"output": "2"
},
{
"input": "4 3 6\n1 2 3 4\n1 2 1\n2 3 2\n3 4 4\n1 2\n1 3\n2 3\n1 2\n1 3\n2 3",
"output": "5 18 31 20"
},
{
"input": "1 1 1\n0\n1 1 0\n1 1... | 1,642,190,218 | 2,147,483,647 | Python 3 | OK | TESTS | 31 | 857 | 17,100,800 | line = input().split(' ')
n, m, k = int(line[0]), int(line[1]), int(line[2])
# create arr
arr = input().split(' ')
for i in range(len(arr)):
arr[i] = int(arr[i])
arr = [0] + arr + [0]
# create operations
ops = [(0, 0, 0)]
for i in range(m):
line = input().split(' ')
l, r, d = int(l... | Title: Greg and Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Greg has an array *a*<==<=*a*1,<=*a*2,<=...,<=*a**n* and *m* operations. Each operation looks as: *l**i*, *r**i*, *d**i*, (1<=β€<=*l**i*<=β€<=*r**i*<=β€<=*n*). To apply operation *i* to the array means to increase all array... | ```python
line = input().split(' ')
n, m, k = int(line[0]), int(line[1]), int(line[2])
# create arr
arr = input().split(' ')
for i in range(len(arr)):
arr[i] = int(arr[i])
arr = [0] + arr + [0]
# create operations
ops = [(0, 0, 0)]
for i in range(m):
line = input().split(' ')
l, r,... | 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,646,251,667 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 40 | 62 | 0 |
b = "hello"
j = 0
pas = 0
a = input()
for i in range(len(a)):
if a[i] == b [j]:
j += 1
pas += 1
if pas == 5:
break
if pas == 5 :
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
b = "hello"
j = 0
pas = 0
a = input()
for i in range(len(a)):
if a[i] == b [j]:
j += 1
pas += 1
if pas == 5:
break
if pas == 5 :
print("YES")
else:
print("NO")
``` | 3.969 |
287 | A | IQ Test | PROGRAMMING | 1,100 | [
"brute force",
"implementation"
] | null | null | In the city of Ultima Thule job applicants are often offered an IQ test.
The test is as follows: the person gets a piece of squared paper with a 4<=Γ<=4 square painted on it. Some of the square's cells are painted black and others are painted white. Your task is to repaint at most one cell the other color so that the... | Four lines contain four characters each: the *j*-th character of the *i*-th line equals "." if the cell in the *i*-th row and the *j*-th column of the square is painted white, and "#", if the cell is black. | Print "YES" (without the quotes), if the test can be passed and "NO" (without the quotes) otherwise. | [
"####\n.#..\n####\n....\n",
"####\n....\n####\n....\n"
] | [
"YES\n",
"NO\n"
] | In the first test sample it is enough to repaint the first cell in the second row. After such repainting the required 2βΓβ2 square is on the intersection of the 1-st and 2-nd row with the 1-st and 2-nd column. | 500 | [
{
"input": "###.\n...#\n###.\n...#",
"output": "NO"
},
{
"input": ".##.\n#..#\n.##.\n#..#",
"output": "NO"
},
{
"input": ".#.#\n#.#.\n.#.#\n#.#.",
"output": "NO"
},
{
"input": "##..\n..##\n##..\n..##",
"output": "NO"
},
{
"input": "#.#.\n#.#.\n.#.#\n.#.#",
"ou... | 1,676,010,838 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 30 | 62 | 0 | def f():
a1, a2, a3, a4 = input(), input(), input(), input()
li = []
li.append(a1[:2] + a2[:2])
li.append(a1[1:3] + a2[1:3])
li.append(a1[2:] + a2[2:])
li.append(a2[:2] + a3[:2])
li.append(a2[1:3] + a3[1:3])
li.append(a2[2:] + a3[2:])
li.append(a3[:2] + a4[:2])
li.appen... | Title: IQ Test
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In the city of Ultima Thule job applicants are often offered an IQ test.
The test is as follows: the person gets a piece of squared paper with a 4<=Γ<=4 square painted on it. Some of the square's cells are painted black and o... | ```python
def f():
a1, a2, a3, a4 = input(), input(), input(), input()
li = []
li.append(a1[:2] + a2[:2])
li.append(a1[1:3] + a2[1:3])
li.append(a1[2:] + a2[2:])
li.append(a2[:2] + a3[:2])
li.append(a2[1:3] + a3[1:3])
li.append(a2[2:] + a3[2:])
li.append(a3[:2] + a4[:2])
... | 3 | |
95 | A | Hockey | PROGRAMMING | 1,600 | [
"implementation",
"strings"
] | A. Hockey | 2 | 256 | Petya loves hockey very much. One day, as he was watching a hockey match, he fell asleep. Petya dreamt of being appointed to change a hockey team's name. Thus, Petya was given the original team name *w* and the collection of forbidden substrings *s*1,<=*s*2,<=...,<=*s**n*. All those strings consist of uppercase and low... | The first line contains the only integer *n* (1<=β€<=*n*<=β€<=100) β the number of forbidden substrings in the collection. Next *n* lines contain these substrings. The next line contains string *w*. All those *n*<=+<=1 lines are non-empty strings consisting of uppercase and lowercase Latin letters whose length does not e... | Output the only line β Petya's resulting string with the maximum number of letters *letter*. If there are several answers then output the one that comes first lexicographically.
The lexicographical comparison is performed by the standard < operator in modern programming languages. The line *a* is lexicographically ... | [
"3\nbers\nucky\nelu\nPetrLoveLuckyNumbers\nt\n",
"4\nhello\nparty\nabefglghjdhfgj\nIVan\npetrsmatchwin\na\n",
"2\naCa\ncba\nabAcaba\nc\n"
] | [
"PetrLovtTttttNumtttt\n",
"petrsmatchwin\n",
"abCacba\n"
] | none | 500 | [
{
"input": "3\nbers\nucky\nelu\nPetrLoveLuckyNumbers\nt",
"output": "PetrLovtTttttNumtttt"
},
{
"input": "4\nhello\nparty\nabefglghjdhfgj\nIVan\npetrsmatchwin\na",
"output": "petrsmatchwin"
},
{
"input": "2\naCa\ncba\nabAcaba\nc",
"output": "abCacba"
},
{
"input": "3\nlol\nhe... | 1,699,127,011 | 2,147,483,647 | PyPy 3 | OK | TESTS | 49 | 248 | 1,331,200 | s = [input().lower() for i in range(int(input()))]
u, x = input(), input()
y = 'ab'[x == 'a']
d = [(x, y), (x.upper(), y.upper())]
v = u.lower()
n = len(v)
k = [0] * (n + 1)
for q in s:
i = v.find(q)
while i != -1:
k[i] += 1
k[i + len(q)] -= 1
i = v.find(q, i + 1)
p = ''
fo... | Title: Hockey
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Petya loves hockey very much. One day, as he was watching a hockey match, he fell asleep. Petya dreamt of being appointed to change a hockey team's name. Thus, Petya was given the original team name *w* and the collection of forbidd... | ```python
s = [input().lower() for i in range(int(input()))]
u, x = input(), input()
y = 'ab'[x == 'a']
d = [(x, y), (x.upper(), y.upper())]
v = u.lower()
n = len(v)
k = [0] * (n + 1)
for q in s:
i = v.find(q)
while i != -1:
k[i] += 1
k[i + len(q)] -= 1
i = v.find(q, i + 1)
... | 3.93552 |
119 | A | Epic Game | PROGRAMMING | 800 | [
"implementation"
] | null | null | Simon and Antisimon play a game. Initially each player receives one fixed positive integer that doesn't change throughout the game. Simon receives number *a* and Antisimon receives number *b*. They also have a heap of *n* stones. The players take turns to make a move and Simon starts. During a move a player should take... | The only string contains space-separated integers *a*, *b* and *n* (1<=β€<=*a*,<=*b*,<=*n*<=β€<=100) β the fixed numbers Simon and Antisimon have received correspondingly and the initial number of stones in the pile. | If Simon wins, print "0" (without the quotes), otherwise print "1" (without the quotes). | [
"3 5 9\n",
"1 1 100\n"
] | [
"0",
"1"
] | The greatest common divisor of two non-negative integers *a* and *b* is such maximum positive integer *k*, that *a* is divisible by *k* without remainder and similarly, *b* is divisible by *k* without remainder. Let *gcd*(*a*,β*b*) represent the operation of calculating the greatest common divisor of numbers *a* and *b... | 500 | [
{
"input": "3 5 9",
"output": "0"
},
{
"input": "1 1 100",
"output": "1"
},
{
"input": "23 12 16",
"output": "1"
},
{
"input": "95 26 29",
"output": "1"
},
{
"input": "73 32 99",
"output": "1"
},
{
"input": "1 1 1",
"output": "0"
},
{
"inpu... | 1,699,476,447 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 45 | 124 | 0 | import math
a, b, c =map(int, input().split())
win=0
while True:
if win:
if math.gcd(c,b)<=c:
c-=math.gcd(c,b)
win=1-win
else:
break
else:
if math.gcd(c,a)<=c:
c-=math.gcd(c,a)
win=1-win
else:
... | Title: Epic Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Simon and Antisimon play a game. Initially each player receives one fixed positive integer that doesn't change throughout the game. Simon receives number *a* and Antisimon receives number *b*. They also have a heap of *n* sto... | ```python
import math
a, b, c =map(int, input().split())
win=0
while True:
if win:
if math.gcd(c,b)<=c:
c-=math.gcd(c,b)
win=1-win
else:
break
else:
if math.gcd(c,a)<=c:
c-=math.gcd(c,a)
win=1-win
else:
... | 3 | |
510 | A | Fox And Snake | PROGRAMMING | 800 | [
"implementation"
] | null | null | Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a *n* by *m* table. Denote *c*-th cell of *r*-th row as (*r*,<=*c*). The tail of the snake is located at (1,<=1), then it's body ... | The only line contains two integers: *n* and *m* (3<=β€<=*n*,<=*m*<=β€<=50).
*n* is an odd number. | Output *n* lines. Each line should contain a string consisting of *m* characters. Do not output spaces. | [
"3 3\n",
"3 4\n",
"5 3\n",
"9 9\n"
] | [
"###\n..#\n###\n",
"####\n...#\n####\n",
"###\n..#\n###\n#..\n###\n",
"#########\n........#\n#########\n#........\n#########\n........#\n#########\n#........\n#########\n"
] | none | 500 | [
{
"input": "3 3",
"output": "###\n..#\n###"
},
{
"input": "3 4",
"output": "####\n...#\n####"
},
{
"input": "5 3",
"output": "###\n..#\n###\n#..\n###"
},
{
"input": "9 9",
"output": "#########\n........#\n#########\n#........\n#########\n........#\n#########\n#........\n#... | 1,683,208,438 | 2,147,483,647 | Python 3 | OK | TESTS | 28 | 46 | 0 | column, row = map(int, input().split())
align = 1
for i in range(1, column + 1):
if i % 2 != 0:
print("#" * row)
elif align % 2 != 0:
print("." * (row - 1), end="")
print("#")
align += 1
elif align % 2 == 0:
print("#", end="")
print("." * (row - 1... | Title: Fox And Snake
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a *n* by *m* table. Denote *c*... | ```python
column, row = map(int, input().split())
align = 1
for i in range(1, column + 1):
if i % 2 != 0:
print("#" * row)
elif align % 2 != 0:
print("." * (row - 1), end="")
print("#")
align += 1
elif align % 2 == 0:
print("#", end="")
print("." ... | 3 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Bike is interested in permutations. A permutation of length *n* is an integer sequence such that each integer from 0 to (*n*<=-<=1) appears exactly once in it. For example, [0,<=2,<=1] is a permutation of length 3 while both [0,<=2,<=2] and [1,<=2,<=3] is not.
A permutation triple of permutations of length *n* (*a*,<=... | The first line contains a single integer *n* (1<=β€<=*n*<=β€<=105). | If no Lucky Permutation Triple of length *n* exists print -1.
Otherwise, you need to print three lines. Each line contains *n* space-seperated integers. The first line must contain permutation *a*, the second line β permutation *b*, the third β permutation *c*.
If there are multiple solutions, print any of them. | [
"5\n",
"2\n"
] | [
"1 4 3 2 0\n1 0 2 4 3\n2 4 0 1 3\n",
"-1\n"
] | In Sample 1, the permutation triple ([1,β4,β3,β2,β0],β[1,β0,β2,β4,β3],β[2,β4,β0,β1,β3]) is Lucky Permutation Triple, as following holds:
- <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a6bf1b9b57809dbec5021f65f89616f259587c07.png" style="max-width: 100.0%;max-height: 100.0%;"/>; - <img... | 0 | [
{
"input": "5",
"output": "1 4 3 2 0\n1 0 2 4 3\n2 4 0 1 3"
},
{
"input": "2",
"output": "-1"
},
{
"input": "8",
"output": "-1"
},
{
"input": "9",
"output": "0 1 2 3 4 5 6 7 8 \n0 1 2 3 4 5 6 7 8 \n0 2 4 6 8 1 3 5 7 "
},
{
"input": "2",
"output": "-1"
},
{... | 1,622,810,089 | 2,147,483,647 | Python 3 | OK | TESTS | 54 | 996 | 8,192,000 | t=int(input())
if(t%2==0):
print(-1)
else:
arr=[]
brr=[]
crr=[]
for i in range(t-1,-1,-1):
arr.append(i)
for i in range(0,t,2):
brr.append(i)
for i in range(1,t-1,2):
brr.append(i)
for i in range(t):
x=arr[i]+brr[i]
y=int(x%t)
crr.append(y)... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bike is interested in permutations. A permutation of length *n* is an integer sequence such that each integer from 0 to (*n*<=-<=1) appears exactly once in it. For example, [0,<=2,<=1] is a permutation of length 3 while both [0,<=... | ```python
t=int(input())
if(t%2==0):
print(-1)
else:
arr=[]
brr=[]
crr=[]
for i in range(t-1,-1,-1):
arr.append(i)
for i in range(0,t,2):
brr.append(i)
for i in range(1,t-1,2):
brr.append(i)
for i in range(t):
x=arr[i]+brr[i]
y=int(x%t)
crr... | 3 | |
11 | A | Increasing Sequence | PROGRAMMING | 900 | [
"constructive algorithms",
"implementation",
"math"
] | A. Increasing Sequence | 1 | 64 | A sequence *a*0,<=*a*1,<=...,<=*a**t*<=-<=1 is called increasing if *a**i*<=-<=1<=<<=*a**i* for each *i*:<=0<=<<=*i*<=<<=*t*.
You are given a sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 and a positive integer *d*. In each move you may choose one element of the given sequence and add *d* to it. What is the least... | The first line of the input contains two integer numbers *n* and *d* (2<=β€<=*n*<=β€<=2000,<=1<=β€<=*d*<=β€<=106). The second line contains space separated sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 (1<=β€<=*b**i*<=β€<=106). | Output the minimal number of moves needed to make the sequence increasing. | [
"4 2\n1 3 3 2\n"
] | [
"3\n"
] | none | 0 | [
{
"input": "4 2\n1 3 3 2",
"output": "3"
},
{
"input": "2 1\n1 1",
"output": "1"
},
{
"input": "2 1\n2 5",
"output": "0"
},
{
"input": "2 1\n1 2",
"output": "0"
},
{
"input": "2 1\n1 1",
"output": "1"
},
{
"input": "2 7\n10 20",
"output": "0"
},
... | 1,676,729,932 | 2,147,483,647 | Python 3 | OK | TESTS | 25 | 92 | 0 | n,d=map(int,input().split())
L=[int(x) for x in input().split()]
ans=0
for i in range(n-1):
if L[i+1]<=L[i]:
x=L[i]-L[i+1]
ans+=x//d +1
L[i+1]+=d*(x//d +1)
print(ans) | Title: Increasing Sequence
Time Limit: 1 seconds
Memory Limit: 64 megabytes
Problem Description:
A sequence *a*0,<=*a*1,<=...,<=*a**t*<=-<=1 is called increasing if *a**i*<=-<=1<=<<=*a**i* for each *i*:<=0<=<<=*i*<=<<=*t*.
You are given a sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 and a positive integer *d*... | ```python
n,d=map(int,input().split())
L=[int(x) for x in input().split()]
ans=0
for i in range(n-1):
if L[i+1]<=L[i]:
x=L[i]-L[i+1]
ans+=x//d +1
L[i+1]+=d*(x//d +1)
print(ans)
``` | 3.954 |
27 | A | Next Test | PROGRAMMING | 1,200 | [
"implementation",
"sortings"
] | A. Next Test | 2 | 256 | Β«PolygonΒ» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated ... | The first line contains one integer *n* (1<=β€<=*n*<=β€<=3000) β the amount of previously added tests. The second line contains *n* distinct integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=3000) β indexes of these tests. | Output the required default value for the next test index. | [
"3\n1 7 2\n"
] | [
"3\n"
] | none | 500 | [
{
"input": "1\n1",
"output": "2"
},
{
"input": "2\n2 1",
"output": "3"
},
{
"input": "3\n3 4 1",
"output": "2"
},
{
"input": "4\n6 4 3 5",
"output": "1"
},
{
"input": "5\n3 2 1 7 4",
"output": "5"
},
{
"input": "6\n4 1 2 5 3 7",
"output": "6"
},
... | 1,531,851,507 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 248 | 0 | import sys
n = input()
arr = [int(i) for i in input().split()]
arr.sort()
count =arr[0]
if count > 1:
print (1)
else:
for i in range(arr.__len__()):
if count<arr[i]and count>arr[i-1]:
break
count+=1
print (count) | Title: Next Test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Β«PolygonΒ» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the... | ```python
import sys
n = input()
arr = [int(i) for i in input().split()]
arr.sort()
count =arr[0]
if count > 1:
print (1)
else:
for i in range(arr.__len__()):
if count<arr[i]and count>arr[i-1]:
break
count+=1
print (count)
``` | 3.938 |
735 | A | Ostap and Grasshopper | PROGRAMMING | 800 | [
"implementation",
"strings"
] | null | null | On the way to Rio de Janeiro Ostap kills time playing with a grasshopper he took with him in a special box. Ostap builds a line of length *n* such that some cells of this line are empty and some contain obstacles. Then, he places his grasshopper to one of the empty cells and a small insect in another empty cell. The gr... | The first line of the input contains two integers *n* and *k* (2<=β€<=*n*<=β€<=100, 1<=β€<=*k*<=β€<=*n*<=-<=1)Β β the number of cells in the line and the length of one grasshopper's jump.
The second line contains a string of length *n* consisting of characters '.', '#', 'G' and 'T'. Character '.' means that the correspondi... | If there exists a sequence of jumps (each jump of length *k*), such that the grasshopper can get from his initial position to the cell with the insect, print "YES" (without quotes) in the only line of the input. Otherwise, print "NO" (without quotes). | [
"5 2\n#G#T#\n",
"6 1\nT....G\n",
"7 3\nT..#..G\n",
"6 2\n..GT..\n"
] | [
"YES\n",
"YES\n",
"NO\n",
"NO\n"
] | In the first sample, the grasshopper can make one jump to the right in order to get from cell 2 to cell 4.
In the second sample, the grasshopper is only able to jump to neighboring cells but the way to the insect is freeΒ β he can get there by jumping left 5 times.
In the third sample, the grasshopper can't make a sin... | 500 | [
{
"input": "5 2\n#G#T#",
"output": "YES"
},
{
"input": "6 1\nT....G",
"output": "YES"
},
{
"input": "7 3\nT..#..G",
"output": "NO"
},
{
"input": "6 2\n..GT..",
"output": "NO"
},
{
"input": "2 1\nGT",
"output": "YES"
},
{
"input": "100 5\nG####.####.###... | 1,547,986,626 | 2,147,483,647 | Python 3 | OK | TESTS | 83 | 124 | 0 | n, k = map(int, input().split())
s = input()
i = s.find("G")
ans = 0
while i < n:
if s[i] == "#":
break
if s[i] == "T":
ans = 1
break
i += k
i = s.find("G")
while i > -1:
if s[i] == "#":
break
if s[i] == "T":
ans = 1
break
i -= k
if ans == 1:
p... | Title: Ostap and Grasshopper
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
On the way to Rio de Janeiro Ostap kills time playing with a grasshopper he took with him in a special box. Ostap builds a line of length *n* such that some cells of this line are empty and some contain obstacles.... | ```python
n, k = map(int, input().split())
s = input()
i = s.find("G")
ans = 0
while i < n:
if s[i] == "#":
break
if s[i] == "T":
ans = 1
break
i += k
i = s.find("G")
while i > -1:
if s[i] == "#":
break
if s[i] == "T":
ans = 1
break
i -= k
if ans =... | 3 | |
958 | B1 | Maximum Control (easy) | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | The Resistance is trying to take control over all planets in a particular solar system. This solar system is shaped like a tree. More precisely, some planets are connected by bidirectional hyperspace tunnels in such a way that there is a path between every pair of the planets, but removing any tunnel would disconnect s... | The first line of the input contains an integer *N* (2<=β€<=*N*<=β€<=1000) β the number of planets in the galaxy.
The next *N*<=-<=1 lines describe the hyperspace tunnels between the planets. Each of the *N*<=-<=1 lines contains two space-separated integers *u* and *v* (1<=β€<=*u*,<=*v*<=β€<=*N*) indicating that there is ... | A single integer denoting the number of remote planets. | [
"5\n4 1\n4 2\n1 3\n1 5\n",
"4\n1 2\n4 3\n1 4\n"
] | [
"3\n",
"2\n"
] | In the first example, only planets 2, 3 and 5 are connected by a single tunnel.
In the second example, the remote planets are 2 and 3.
Note that this problem has only two versions β easy and medium. | 0 | [
{
"input": "5\n4 1\n4 2\n1 3\n1 5",
"output": "3"
},
{
"input": "4\n1 2\n4 3\n1 4",
"output": "2"
},
{
"input": "10\n4 3\n2 6\n10 1\n5 7\n5 8\n10 6\n5 9\n9 3\n2 9",
"output": "4"
}
] | 1,687,142,478 | 2,147,483,647 | PyPy 3 | OK | TESTS | 9 | 280 | 1,433,600 | n = int(input())
l = []
s = 0
for i in range(n - 1):
u, v = map(int, input().split())
l.append(u)
l.append(v)
for i in l:
if l.count(i) == 1:
s += 1
print(s) | Title: Maximum Control (easy)
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Resistance is trying to take control over all planets in a particular solar system. This solar system is shaped like a tree. More precisely, some planets are connected by bidirectional hyperspace tunnels in s... | ```python
n = int(input())
l = []
s = 0
for i in range(n - 1):
u, v = map(int, input().split())
l.append(u)
l.append(v)
for i in l:
if l.count(i) == 1:
s += 1
print(s)
``` | 3 | |
258 | A | Little Elephant and Bits | PROGRAMMING | 1,100 | [
"greedy",
"math"
] | null | null | The Little Elephant has an integer *a*, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number *a* fits on the piece of paper, the Little Elephant ought to delete exactly one any digit from number *a* in the binary record. At that a new number appears. It consis... | The single line contains integer *a*, written in the binary notation without leading zeroes. This number contains more than 1 and at most 105 digits. | In the single line print the number that is written without leading zeroes in the binary notation β the answer to the problem. | [
"101\n",
"110010\n"
] | [
"11\n",
"11010\n"
] | In the first sample the best strategy is to delete the second digit. That results in number 11<sub class="lower-index">2</sub>β=β3<sub class="lower-index">10</sub>.
In the second sample the best strategy is to delete the third or fourth digits β that results in number 11010<sub class="lower-index">2</sub>β=β26<sub cla... | 500 | [
{
"input": "101",
"output": "11"
},
{
"input": "110010",
"output": "11010"
},
{
"input": "10000",
"output": "1000"
},
{
"input": "1111111110",
"output": "111111111"
},
{
"input": "10100101011110101",
"output": "1100101011110101"
},
{
"input": "11101001... | 1,682,882,248 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 37 | 154 | 1,638,400 | n=input();flag=True
for i in range(len(n)):
if n[i]=="0":
n=n[:i]+n[i+1:]
flag=False
break
if flag:
print(n[:-1])
else:
print(n)
| Title: Little Elephant and Bits
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Little Elephant has an integer *a*, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number *a* fits on the piece of paper, the Little Elephant ought... | ```python
n=input();flag=True
for i in range(len(n)):
if n[i]=="0":
n=n[:i]+n[i+1:]
flag=False
break
if flag:
print(n[:-1])
else:
print(n)
``` | 3 | |
475 | B | Strongly Connected City | PROGRAMMING | 1,400 | [
"brute force",
"dfs and similar",
"graphs",
"implementation"
] | null | null | Imagine a city with *n* horizontal streets crossing *m* vertical streets, forming an (*n*<=-<=1)<=Γ<=(*m*<=-<=1) grid. In order to increase the traffic flow, mayor of the city has decided to make each street one way. This means in each horizontal street, the traffic moves only from west to east or only from east to wes... | The first line of input contains two integers *n* and *m*, (2<=β€<=*n*,<=*m*<=β€<=20), denoting the number of horizontal streets and the number of vertical streets.
The second line contains a string of length *n*, made of characters '<' and '>', denoting direction of each horizontal street. If the *i*-th character... | If the given pattern meets the mayor's criteria, print a single line containing "YES", otherwise print a single line containing "NO". | [
"3 3\n><>\nv^v\n",
"4 6\n<><>\nv^v^v^\n"
] | [
"NO\n",
"YES\n"
] | The figure above shows street directions in the second sample test case. | 1,000 | [
{
"input": "3 3\n><>\nv^v",
"output": "NO"
},
{
"input": "4 6\n<><>\nv^v^v^",
"output": "YES"
},
{
"input": "2 2\n<>\nv^",
"output": "YES"
},
{
"input": "2 2\n>>\n^v",
"output": "NO"
},
{
"input": "3 3\n>><\n^^v",
"output": "YES"
},
{
"input": "3 4\n>>... | 1,667,154,946 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 81 | 998 | 61,440,000 | import sys
input = lambda: sys.stdin.buffer.readline().decode().strip()
# print = sys.stdout.write
inl = lambda: list(map(int, input().split()))
hs, vs = inl()
h_streets = input()
v_streets = input()
h_streets = [1 if i == ">" else -1 for i in h_streets]
v_streets = [1 if i == "v" else -1 for i in v_stree... | Title: Strongly Connected City
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Imagine a city with *n* horizontal streets crossing *m* vertical streets, forming an (*n*<=-<=1)<=Γ<=(*m*<=-<=1) grid. In order to increase the traffic flow, mayor of the city has decided to make each street one... | ```python
import sys
input = lambda: sys.stdin.buffer.readline().decode().strip()
# print = sys.stdout.write
inl = lambda: list(map(int, input().split()))
hs, vs = inl()
h_streets = input()
v_streets = input()
h_streets = [1 if i == ">" else -1 for i in h_streets]
v_streets = [1 if i == "v" else -1 for i ... | 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,665,854,447 | 2,147,483,647 | Python 3 | OK | TESTS | 20 | 46 | 0 | from math import ceil
X,Y,Z = list(map(int,input().split()))
A = ceil(X/Z)
B = ceil(Y/Z)
print(int(A*B))
| 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
from math import ceil
X,Y,Z = list(map(int,input().split()))
A = ceil(X/Z)
B = ceil(Y/Z)
print(int(A*B))
``` | 3.977 |
265 | A | Colorful Stones (Simplified Edition) | PROGRAMMING | 800 | [
"implementation"
] | null | null | There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string *s*. The *i*-th (1-based) character of *s* represents the color of the *i*-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.
Ini... | The input contains two lines. The first line contains the string *s* (1<=β€<=|*s*|<=β€<=50). The second line contains the string *t* (1<=β€<=|*t*|<=β€<=50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence. | Print the final 1-based position of Liss in a single line. | [
"RGB\nRRR\n",
"RRRBGBRBBB\nBBBRR\n",
"BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB\nBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB\n"
] | [
"2\n",
"3\n",
"15\n"
] | none | 500 | [
{
"input": "RGB\nRRR",
"output": "2"
},
{
"input": "RRRBGBRBBB\nBBBRR",
"output": "3"
},
{
"input": "BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB\nBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB",
"output": "15"
},
{
"input": "G\nRRBBRBRRBR",
"output": "1"
},
... | 1,697,041,457 | 2,147,483,647 | Python 3 | OK | TESTS | 19 | 92 | 0 | x=input()
y=input()
c=0
for i in range(len(y)):
if y[i]==x[c]:
c+=1
else:
continue
print(c+1)
| Title: Colorful Stones (Simplified Edition)
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string *s*. The *i*-th (1-based) character of *s* represents the color of the *i*-th st... | ```python
x=input()
y=input()
c=0
for i in range(len(y)):
if y[i]==x[c]:
c+=1
else:
continue
print(c+1)
``` | 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,642,526,505 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 40 | 92 | 0 | a = ['h', 'e', 'l', 'l', 'o']
j = 4
s = input()
i = len(s)-1
while(i >= 0 and j >= 0):
if(a[j] == s[i]):
j -= 1
i -= 1
else:
i -= 1
print("YES" if(j == -1) else "NO") | Title: Chat room
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letter... | ```python
a = ['h', 'e', 'l', 'l', 'o']
j = 4
s = input()
i = len(s)-1
while(i >= 0 and j >= 0):
if(a[j] == s[i]):
j -= 1
i -= 1
else:
i -= 1
print("YES" if(j == -1) else "NO")
``` | 3.954 |
625 | B | War of the Corporations | PROGRAMMING | 1,200 | [
"constructive algorithms",
"greedy",
"strings"
] | null | null | A long time ago, in a galaxy far far away two giant IT-corporations Pineapple and Gogol continue their fierce competition. Crucial moment is just around the corner: Gogol is ready to release it's new tablet Lastus 3000.
This new device is equipped with specially designed artificial intelligence (AI). Employees of Pine... | The first line of the input contains the name of AI designed by Gogol, its length doesn't exceed 100<=000 characters. Second line contains the name of the phone released by Pineapple 200 years ago, its length doesn't exceed 30. Both string are non-empty and consist of only small English letters. | Print the minimum number of characters that must be replaced with "#" in order to obtain that the name of the phone doesn't occur in the name of AI as a substring. | [
"intellect\ntell\n",
"google\napple\n",
"sirisiri\nsir\n"
] | [
"1",
"0",
"2"
] | In the first sample AI's name may be replaced with "int#llect".
In the second sample Gogol can just keep things as they are.
In the third sample one of the new possible names of AI may be "s#ris#ri". | 750 | [
{
"input": "intellect\ntell",
"output": "1"
},
{
"input": "google\napple",
"output": "0"
},
{
"input": "sirisiri\nsir",
"output": "2"
},
{
"input": "sirisiri\nsiri",
"output": "2"
},
{
"input": "aaaaaaa\naaaa",
"output": "1"
},
{
"input": "bbbbbb\nbb",... | 1,604,069,611 | 1,111 | PyPy 3 | OK | TESTS | 56 | 155 | 512,000 | s1=str(input())
s2=str(input())
ans=s1.count(s2)
print(ans) | Title: War of the Corporations
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A long time ago, in a galaxy far far away two giant IT-corporations Pineapple and Gogol continue their fierce competition. Crucial moment is just around the corner: Gogol is ready to release it's new tablet Last... | ```python
s1=str(input())
s2=str(input())
ans=s1.count(s2)
print(ans)
``` | 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,554,990,286 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 218 | 0 | num = int(input())
lst = []
for i in range(num):
komanda = input()
lst.append(komanda)
set_lst = set(lst)
spisok = list(set_lst)
if len(spisok) == 1:
print(spisok[0])
else:
if lst.count(spisok[0]) > lst.count(spisok[1]):
print(spisok[0])
else:
print(spisok[1]) | 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
num = int(input())
lst = []
for i in range(num):
komanda = input()
lst.append(komanda)
set_lst = set(lst)
spisok = list(set_lst)
if len(spisok) == 1:
print(spisok[0])
else:
if lst.count(spisok[0]) > lst.count(spisok[1]):
print(spisok[0])
else:
print(spisok[1])
... | 3.9455 |
157 | B | Trace | PROGRAMMING | 1,000 | [
"geometry",
"sortings"
] | null | null | One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides,... | The first line contains the single integer *n* (1<=β€<=*n*<=β€<=100). The second line contains *n* space-separated integers *r**i* (1<=β€<=*r**i*<=β€<=1000) β the circles' radii. It is guaranteed that all circles are different. | Print the single real number β total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10<=-<=4. | [
"1\n1\n",
"3\n1 4 2\n"
] | [
"3.1415926536\n",
"40.8407044967\n"
] | In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals ΟβΓβ1<sup class="upper-index">2</sup>β=βΟ.
In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the secon... | 1,000 | [
{
"input": "1\n1",
"output": "3.1415926536"
},
{
"input": "3\n1 4 2",
"output": "40.8407044967"
},
{
"input": "4\n4 1 3 2",
"output": "31.4159265359"
},
{
"input": "4\n100 10 2 1",
"output": "31111.1920484997"
},
{
"input": "10\n10 9 8 7 6 5 4 3 2 1",
"output"... | 1,629,811,328 | 2,147,483,647 | Python 3 | OK | TESTS | 44 | 154 | 6,963,200 | n=int(input())
l=list(map(int,input().split()))
l.sort()
pi=3.1415926536
area=[l[0]**2]
for i in range(1,n):
area.append(l[i]**2-l[i-1]**2)
ans=0
#print(l,area)
if n%2==1:
for i in range(0,n,2):
ans+=area[i]
#print(ans,area[i])
else:
for i in range(1,n,2):
ans+=area[... | Title: Trace
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall in... | ```python
n=int(input())
l=list(map(int,input().split()))
l.sort()
pi=3.1415926536
area=[l[0]**2]
for i in range(1,n):
area.append(l[i]**2-l[i-1]**2)
ans=0
#print(l,area)
if n%2==1:
for i in range(0,n,2):
ans+=area[i]
#print(ans,area[i])
else:
for i in range(1,n,2):
... | 3 | |
689 | C | Mike and Chocolate Thieves | PROGRAMMING | 1,700 | [
"binary search",
"combinatorics",
"math"
] | null | null | Bad news came to Mike's village, some thieves stole a bunch of chocolates from the local factory! Horrible!
Aside from loving sweet things, thieves from this area are known to be very greedy. So after a thief takes his number of chocolates for himself, the next thief will take exactly *k* times more than the previous... | The single line of input contains the integer *m* (1<=β€<=*m*<=β€<=1015)Β β the number of ways the thieves might steal the chocolates, as rumours say. | Print the only integer *n*Β β the maximum amount of chocolates that thieves' bags can carry. If there are more than one *n* satisfying the rumors, print the smallest one.
If there is no such *n* for a false-rumoured *m*, print <=-<=1. | [
"1\n",
"8\n",
"10\n"
] | [
"8\n",
"54\n",
"-1\n"
] | In the first sample case the smallest *n* that leads to exactly one way of stealing chocolates is *n*β=β8, whereas the amounts of stealed chocolates are (1,β2,β4,β8) (the number of chocolates stolen by each of the thieves).
In the second sample case the smallest *n* that leads to exactly 8 ways is *n*β=β54 with the po... | 1,500 | [
{
"input": "1",
"output": "8"
},
{
"input": "8",
"output": "54"
},
{
"input": "10",
"output": "-1"
},
{
"input": "27",
"output": "152"
},
{
"input": "28206",
"output": "139840"
},
{
"input": "32",
"output": "184"
},
{
"input": "115",
"o... | 1,678,376,921 | 1,421 | PyPy 3-64 | OK | TESTS | 54 | 811 | 10,035,200 | import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def binary_search(c1, c2):
c = (c1 + c2 + 1) // 2
while abs(c1 - c2) > 1:
c = (c1 + c2 + 1) // 2
if ok(c):
c2 = c
else:
c1 = c
c = max(c - 1, 0)
while not ok(c):
... | Title: Mike and Chocolate Thieves
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bad news came to Mike's village, some thieves stole a bunch of chocolates from the local factory! Horrible!
Aside from loving sweet things, thieves from this area are known to be very greedy. So after a thi... | ```python
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def binary_search(c1, c2):
c = (c1 + c2 + 1) // 2
while abs(c1 - c2) > 1:
c = (c1 + c2 + 1) // 2
if ok(c):
c2 = c
else:
c1 = c
c = max(c - 1, 0)
while no... | 3 | |
844 | A | Diversity | PROGRAMMING | 1,000 | [
"greedy",
"implementation",
"strings"
] | null | null | Calculate the minimum number of characters you need to change in the string *s*, so that it contains at least *k* different letters, or print that it is impossible.
String *s* consists only of lowercase Latin letters, and it is allowed to change characters only to lowercase Latin letters too. | First line of input contains string *s*, consisting only of lowercase Latin letters (1<=β€<=|*s*|<=β€<=1000, |*s*| denotes the length of *s*).
Second line of input contains integer *k* (1<=β€<=*k*<=β€<=26). | Print single line with a minimum number of necessary changes, or the word Β«impossibleΒ» (without quotes) if it is impossible. | [
"yandex\n6\n",
"yahoo\n5\n",
"google\n7\n"
] | [
"0\n",
"1\n",
"impossible\n"
] | In the first test case string contains 6 different letters, so we don't need to change anything.
In the second test case string contains 4 different letters: {'*a*',β'*h*',β'*o*',β'*y*'}. To get 5 different letters it is necessary to change one occurrence of '*o*' to some letter, which doesn't occur in the string, for... | 500 | [
{
"input": "yandex\n6",
"output": "0"
},
{
"input": "yahoo\n5",
"output": "1"
},
{
"input": "google\n7",
"output": "impossible"
},
{
"input": "a\n1",
"output": "0"
},
{
"input": "z\n2",
"output": "impossible"
},
{
"input": "fwgfrwgkuwghfiruhewgirueguhe... | 1,567,835,533 | 2,147,483,647 | Python 3 | OK | TESTS | 41 | 109 | 0 | def Diversity(s,k):
if len(s)<k:
return "impossible"
charCnt = [0] * 26
for c in s:
charCnt[ord(c)-97]+=1
numberOfUniqueCharacters = 26 - charCnt.count(0)
if(numberOfUniqueCharacters>=k):
return 0
return k - numberOfUniqueCharacters
s = input()
k = int(input())
print(Diversity(s,k))
... | Title: Diversity
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Calculate the minimum number of characters you need to change in the string *s*, so that it contains at least *k* different letters, or print that it is impossible.
String *s* consists only of lowercase Latin letters, and it... | ```python
def Diversity(s,k):
if len(s)<k:
return "impossible"
charCnt = [0] * 26
for c in s:
charCnt[ord(c)-97]+=1
numberOfUniqueCharacters = 26 - charCnt.count(0)
if(numberOfUniqueCharacters>=k):
return 0
return k - numberOfUniqueCharacters
s = input()
k = int(input())
print(Diversit... | 3 | |
766 | B | Mahmoud and a Triangle | PROGRAMMING | 1,000 | [
"constructive algorithms",
"geometry",
"greedy",
"math",
"number theory",
"sortings"
] | null | null | Mahmoud has *n* line segments, the *i*-th of them has length *a**i*. Ehab challenged him to use exactly 3 line segments to form a non-degenerate triangle. Mahmoud doesn't accept challenges unless he is sure he can win, so he asked you to tell him if he should accept the challenge. Given the lengths of the line segments... | The first line contains single integer *n* (3<=β€<=*n*<=β€<=105)Β β the number of line segments Mahmoud has.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=109)Β β the lengths of line segments Mahmoud has. | In the only line print "YES" if he can choose exactly three line segments and form a non-degenerate triangle with them, and "NO" otherwise. | [
"5\n1 5 3 2 4\n",
"3\n4 1 2\n"
] | [
"YES\n",
"NO\n"
] | For the first example, he can use line segments with lengths 2, 4 and 5 to form a non-degenerate triangle. | 1,000 | [
{
"input": "5\n1 5 3 2 4",
"output": "YES"
},
{
"input": "3\n4 1 2",
"output": "NO"
},
{
"input": "30\n197 75 517 39724 7906061 1153471 3 15166 168284 3019844 272293 316 16 24548 42 118 5792 5 9373 1866366 4886214 24 2206 712886 104005 1363 836 64273 440585 3576",
"output": "NO"
},... | 1,685,388,672 | 2,147,483,647 | Python 3 | OK | TESTS | 87 | 78 | 13,619,200 | n = int(input())
lens = list(map(int, input().split()))
lens.sort()
triangle = False
for i in range(n - 2):
if lens[i] + lens[i + 1] > lens[i + 2]:
triangle = True
break
if triangle:
print("YES")
else:
print("NO")
| Title: Mahmoud and a Triangle
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mahmoud has *n* line segments, the *i*-th of them has length *a**i*. Ehab challenged him to use exactly 3 line segments to form a non-degenerate triangle. Mahmoud doesn't accept challenges unless he is sure he ca... | ```python
n = int(input())
lens = list(map(int, input().split()))
lens.sort()
triangle = False
for i in range(n - 2):
if lens[i] + lens[i + 1] > lens[i + 2]:
triangle = True
break
if triangle:
print("YES")
else:
print("NO")
``` | 3 | |
534 | B | Covered Path | PROGRAMMING | 1,400 | [
"dp",
"greedy",
"math"
] | null | null | The on-board computer on Polycarp's car measured that the car speed at the beginning of some section of the path equals *v*1 meters per second, and in the end it is *v*2 meters per second. We know that this section of the route took exactly *t* seconds to pass.
Assuming that at each of the seconds the speed is constan... | The first line contains two integers *v*1 and *v*2 (1<=β€<=*v*1,<=*v*2<=β€<=100) β the speeds in meters per second at the beginning of the segment and at the end of the segment, respectively.
The second line contains two integers *t* (2<=β€<=*t*<=β€<=100) β the time when the car moves along the segment in seconds, *d* (0<... | Print the maximum possible length of the path segment in meters. | [
"5 6\n4 2\n",
"10 10\n10 0\n"
] | [
"26",
"100"
] | In the first sample the sequence of speeds of Polycarpus' car can look as follows: 5, 7, 8, 6. Thus, the total path is 5β+β7β+β8β+β6β=β26 meters.
In the second sample, as *d*β=β0, the car covers the whole segment at constant speed *v*β=β10. In *t*β=β10 seconds it covers the distance of 100 meters. | 1,000 | [
{
"input": "5 6\n4 2",
"output": "26"
},
{
"input": "10 10\n10 0",
"output": "100"
},
{
"input": "87 87\n2 10",
"output": "174"
},
{
"input": "1 11\n6 2",
"output": "36"
},
{
"input": "100 10\n10 10",
"output": "550"
},
{
"input": "1 1\n100 10",
"o... | 1,621,661,567 | 2,147,483,647 | PyPy 3 | OK | TESTS | 64 | 170 | 4,403,200 | def f(start,end,time,dif):
dp=[[-float("inf") for j in range(1000) ]for i in range(time+1)]
dp[0][start]=start
for i in range(time):
for val in range(1000):
for d in range(-dif,dif+1):
if val+d>=0 and val+d<1000:
dp[i+1][val+d]=max(dp[i][val]+val+d,dp[i+1][val+d])
return dp[time-1][end]
... | Title: Covered Path
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The on-board computer on Polycarp's car measured that the car speed at the beginning of some section of the path equals *v*1 meters per second, and in the end it is *v*2 meters per second. We know that this section of the ... | ```python
def f(start,end,time,dif):
dp=[[-float("inf") for j in range(1000) ]for i in range(time+1)]
dp[0][start]=start
for i in range(time):
for val in range(1000):
for d in range(-dif,dif+1):
if val+d>=0 and val+d<1000:
dp[i+1][val+d]=max(dp[i][val]+val+d,dp[i+1][val+d])
return dp[time-1]... | 3 | |
499 | B | Lecture | PROGRAMMING | 1,000 | [
"implementation",
"strings"
] | null | null | You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.
You know two languages, and the professor is giving the lecture in the first one. The words in both languages consist of lowercase English characters, each language consi... | The first line contains two integers, *n* and *m* (1<=β€<=*n*<=β€<=3000, 1<=β€<=*m*<=β€<=3000) β the number of words in the professor's lecture and the number of words in each of these languages.
The following *m* lines contain the words. The *i*-th line contains two strings *a**i*, *b**i* meaning that the word *a**i* bel... | Output exactly *n* words: how you will record the lecture in your notebook. Output the words of the lecture in the same order as in the input. | [
"4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest\n",
"5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll\n"
] | [
"codeforces round letter round\n",
"hbnyiyc joll joll un joll\n"
] | none | 500 | [
{
"input": "4 3\ncodeforces codesecrof\ncontest round\nletter message\ncodeforces contest letter contest",
"output": "codeforces round letter round"
},
{
"input": "5 3\njoll wuqrd\neuzf un\nhbnyiyc rsoqqveh\nhbnyiyc joll joll euzf joll",
"output": "hbnyiyc joll joll un joll"
},
{
"input"... | 1,684,824,587 | 2,147,483,647 | Python 3 | OK | TESTS | 37 | 61 | 921,600 | dictionary = {}
n, m = map(int, input().split())
for i in range(m):
a, b = input().split()
dictionary[a] = b
#print(dictionary)
for i in input().split():
print(min(i, dictionary[i], key=len), "", end="") | Title: Lecture
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.
You know two languages, and the professor is giving the lecture in the first ... | ```python
dictionary = {}
n, m = map(int, input().split())
for i in range(m):
a, b = input().split()
dictionary[a] = b
#print(dictionary)
for i in input().split():
print(min(i, dictionary[i], key=len), "", end="")
``` | 3 | |
676 | C | Vasya and String | PROGRAMMING | 1,500 | [
"binary search",
"dp",
"strings",
"two pointers"
] | null | null | High school student Vasya got a string of length *n* as a birthday present. This string consists of letters 'a' and 'b' only. Vasya denotes beauty of the string as the maximum length of a substring (consecutive subsequence) consisting of equal letters.
Vasya can change no more than *k* characters of the original strin... | The first line of the input contains two integers *n* and *k* (1<=β€<=*n*<=β€<=100<=000,<=0<=β€<=*k*<=β€<=*n*)Β β the length of the string and the maximum number of characters to change.
The second line contains the string, consisting of letters 'a' and 'b' only. | Print the only integerΒ β the maximum beauty of the string Vasya can achieve by changing no more than *k* characters. | [
"4 2\nabba\n",
"8 1\naabaabaa\n"
] | [
"4\n",
"5\n"
] | In the first sample, Vasya can obtain both strings "aaaa" and "bbbb".
In the second sample, the optimal answer is obtained with the string "aaaaabaa" or with the string "aabaaaaa". | 1,500 | [
{
"input": "4 2\nabba",
"output": "4"
},
{
"input": "8 1\naabaabaa",
"output": "5"
},
{
"input": "1 0\na",
"output": "1"
},
{
"input": "1 1\nb",
"output": "1"
},
{
"input": "1 0\nb",
"output": "1"
},
{
"input": "1 1\na",
"output": "1"
},
{
... | 1,646,616,394 | 2,147,483,647 | Python 3 | OK | TESTS | 117 | 124 | 102,400 | n, k = map(int, input().split())
s = input()
a, b = 0, 0
j = 0
ans = 0
for i in s:
if i == 'a':
a += 1
else:
b += 1
if min(a, b) > k:
if s[j] == 'a':
a -= 1
else:
b -= 1
j += 1
else:
ans += 1
print(ans)
| Title: Vasya and String
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
High school student Vasya got a string of length *n* as a birthday present. This string consists of letters 'a' and 'b' only. Vasya denotes beauty of the string as the maximum length of a substring (consecutive subsequ... | ```python
n, k = map(int, input().split())
s = input()
a, b = 0, 0
j = 0
ans = 0
for i in s:
if i == 'a':
a += 1
else:
b += 1
if min(a, b) > k:
if s[j] == 'a':
a -= 1
else:
b -= 1
j += 1
else:
ans += 1
print(ans)
... | 3 | |
365 | A | Good Number | PROGRAMMING | 1,100 | [
"implementation"
] | null | null | Let's call a number *k*-good if it contains all digits not exceeding *k* (0,<=...,<=*k*). You've got a number *k* and an array *a* containing *n* numbers. Find out how many *k*-good numbers are in *a* (count each number every time it occurs in array *a*). | The first line contains integers *n* and *k* (1<=β€<=*n*<=β€<=100, 0<=β€<=*k*<=β€<=9). The *i*-th of the following *n* lines contains integer *a**i* without leading zeroes (1<=β€<=*a**i*<=β€<=109). | Print a single integer β the number of *k*-good numbers in *a*. | [
"10 6\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n",
"2 1\n1\n10\n"
] | [
"10\n",
"1\n"
] | none | 500 | [
{
"input": "10 6\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560\n1234560",
"output": "10"
},
{
"input": "2 1\n1\n10",
"output": "1"
},
{
"input": "1 0\n1000000000",
"output": "1"
},
{
"input": "1 1\n1000000000",
"output": "1"
},
{
... | 1,695,833,538 | 2,147,483,647 | Python 3 | OK | TESTS | 37 | 46 | 0 | def main():
inp = input().split()
n = int(inp[0])
k = int(inp[1])
numbers = [input() for i in range(n)]
for i in range(n):
number = numbers[i]
numbers[i] = []
for letter in number:
numbers[i].append(int(letter))
counter = 0
for element in numbers:
... | Title: Good Number
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Let's call a number *k*-good if it contains all digits not exceeding *k* (0,<=...,<=*k*). You've got a number *k* and an array *a* containing *n* numbers. Find out how many *k*-good numbers are in *a* (count each number eve... | ```python
def main():
inp = input().split()
n = int(inp[0])
k = int(inp[1])
numbers = [input() for i in range(n)]
for i in range(n):
number = numbers[i]
numbers[i] = []
for letter in number:
numbers[i].append(int(letter))
counter = 0
for element in n... | 3 | |
618 | A | Slime Combining | PROGRAMMING | 800 | [
"implementation"
] | null | null | Your friend recently gave you some slimes for your birthday. You have *n* slimes all initially with value 1.
You are going to play a game with these slimes. Initially, you put a single slime by itself in a row. Then, you will add the other *n*<=-<=1 slimes one by one. When you add a slime, you place it at the right of... | The first line of the input will contain a single integer, *n* (1<=β€<=*n*<=β€<=100<=000). | Output a single line with *k* integers, where *k* is the number of slimes in the row after you've finished the procedure described in the problem statement. The *i*-th of these numbers should be the value of the *i*-th slime from the left. | [
"1\n",
"2\n",
"3\n",
"8\n"
] | [
"1\n",
"2\n",
"2 1\n",
"4\n"
] | In the first sample, we only have a single slime with value 1. The final state of the board is just a single slime with value 1.
In the second sample, we perform the following steps:
Initially we place a single slime in a row by itself. Thus, row is initially 1.
Then, we will add another slime. The row is now 1 1. S... | 500 | [
{
"input": "1",
"output": "1"
},
{
"input": "2",
"output": "2"
},
{
"input": "3",
"output": "2 1"
},
{
"input": "8",
"output": "4"
},
{
"input": "100000",
"output": "17 16 11 10 8 6"
},
{
"input": "12345",
"output": "14 13 6 5 4 1"
},
{
"in... | 1,661,453,526 | 2,147,483,647 | Python 3 | OK | TESTS | 27 | 109 | 921,600 | n=int(input())
s=[1]*n
while not len(set(s))==len(s):
sc=[]
i=0
while i <(len(s)):
if i==(len(s)-1):
sc.append(s[i])
break
if s[i]==s[i+1]:
sc.append(s[i]+1)
i+=1
else:
sc.append(s[i])
i+=1
s=sc
p... | Title: Slime Combining
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Your friend recently gave you some slimes for your birthday. You have *n* slimes all initially with value 1.
You are going to play a game with these slimes. Initially, you put a single slime by itself in a row. Then, y... | ```python
n=int(input())
s=[1]*n
while not len(set(s))==len(s):
sc=[]
i=0
while i <(len(s)):
if i==(len(s)-1):
sc.append(s[i])
break
if s[i]==s[i+1]:
sc.append(s[i]+1)
i+=1
else:
sc.append(s[i])
i+=1
... | 3 | |
596 | B | Wilbur and Array | PROGRAMMING | 1,100 | [
"greedy",
"implementation"
] | null | null | Wilbur the pig is tinkering with arrays again. He has the array *a*1,<=*a*2,<=...,<=*a**n* initially consisting of *n* zeros. At one step, he can choose any index *i* and either add 1 to all elements *a**i*,<=*a**i*<=+<=1,<=... ,<=*a**n* or subtract 1 from all elements *a**i*,<=*a**i*<=+<=1,<=...,<=*a**n*. His goal is ... | The first line of the input contains a single integer *n* (1<=β€<=*n*<=β€<=200<=000)Β β the length of the array *a**i*. Initially *a**i*<==<=0 for every position *i*, so this array is not given in the input.
The second line of the input contains *n* integers *b*1,<=*b*2,<=...,<=*b**n* (<=-<=109<=β€<=*b**i*<=β€<=109). | Print the minimum number of steps that Wilbur needs to make in order to achieve *a**i*<==<=*b**i* for all *i*. | [
"5\n1 2 3 4 5\n",
"4\n1 2 2 1\n"
] | [
"5",
"3"
] | In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | 1,000 | [
{
"input": "5\n1 2 3 4 5",
"output": "5"
},
{
"input": "4\n1 2 2 1",
"output": "3"
},
{
"input": "3\n1 2 4",
"output": "4"
},
{
"input": "6\n1 2 3 6 5 4",
"output": "8"
},
{
"input": "10\n2 1 4 3 6 5 8 7 10 9",
"output": "19"
},
{
"input": "7\n12 6 12 ... | 1,685,169,578 | 2,147,483,647 | Python 3 | OK | TESTS | 76 | 140 | 27,238,400 | n = int(input())
b = list(map(int, input().split()))
steps = abs(b[0])
for i in range(1, n):
steps += abs(b[i] - b[i-1])
print(steps)
| Title: Wilbur and Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Wilbur the pig is tinkering with arrays again. He has the array *a*1,<=*a*2,<=...,<=*a**n* initially consisting of *n* zeros. At one step, he can choose any index *i* and either add 1 to all elements *a**i*,<=*a**i*<=+... | ```python
n = int(input())
b = list(map(int, input().split()))
steps = abs(b[0])
for i in range(1, n):
steps += abs(b[i] - b[i-1])
print(steps)
``` | 3 | |
867 | A | Between the Offices | PROGRAMMING | 800 | [
"implementation"
] | null | null | As you may know, MemSQL has American offices in both San Francisco and Seattle. Being a manager in the company, you travel a lot between the two cities, always by plane.
You prefer flying from Seattle to San Francisco than in the other direction, because it's warmer in San Francisco. You are so busy that you don't rem... | The first line of input contains single integer *n* (2<=β€<=*n*<=β€<=100)Β β the number of days.
The second line contains a string of length *n* consisting of only capital 'S' and 'F' letters. If the *i*-th letter is 'S', then you were in Seattle office on that day. Otherwise you were in San Francisco. The days are given... | Print "YES" if you flew more times from Seattle to San Francisco, and "NO" otherwise.
You can print each letter in any case (upper or lower). | [
"4\nFSSF\n",
"2\nSF\n",
"10\nFFFFFFFFFF\n",
"10\nSSFFSFFSFF\n"
] | [
"NO\n",
"YES\n",
"NO\n",
"YES\n"
] | In the first example you were initially at San Francisco, then flew to Seattle, were there for two days and returned to San Francisco. You made one flight in each direction, so the answer is "NO".
In the second example you just flew from Seattle to San Francisco, so the answer is "YES".
In the third example you staye... | 500 | [
{
"input": "4\nFSSF",
"output": "NO"
},
{
"input": "2\nSF",
"output": "YES"
},
{
"input": "10\nFFFFFFFFFF",
"output": "NO"
},
{
"input": "10\nSSFFSFFSFF",
"output": "YES"
},
{
"input": "20\nSFSFFFFSSFFFFSSSSFSS",
"output": "NO"
},
{
"input": "20\nSSFFF... | 1,582,389,489 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 124 | 0 | n=int(input())
f=list(input())
a=0
b=0
for i in range(n-1):
if(f[i]=="S" and f[i+1]=="F"):
a+=1
if(f[i]=="F" and f[i+1]=="S"):
b+=1
if(a>b):
print("YES")
else:
print("NO") | Title: Between the Offices
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
As you may know, MemSQL has American offices in both San Francisco and Seattle. Being a manager in the company, you travel a lot between the two cities, always by plane.
You prefer flying from Seattle to San Franci... | ```python
n=int(input())
f=list(input())
a=0
b=0
for i in range(n-1):
if(f[i]=="S" and f[i+1]=="F"):
a+=1
if(f[i]=="F" and f[i+1]=="S"):
b+=1
if(a>b):
print("YES")
else:
print("NO")
``` | 3 | |
23 | A | You're Given a String... | PROGRAMMING | 1,200 | [
"brute force",
"greedy"
] | A. You're Given a String... | 2 | 256 | You're given a string of lower-case Latin letters. Your task is to find the length of its longest substring that can be met in the string at least twice. These occurrences can overlap (see sample test 2). | The first input line contains the string. It's guaranteed, that the string is non-empty, consists of lower-case Latin letters, and its length doesn't exceed 100. | Output one number β length of the longest substring that can be met in the string at least twice. | [
"abcd\n",
"ababa\n",
"zzz\n"
] | [
"0",
"3",
"2"
] | none | 0 | [
{
"input": "abcd",
"output": "0"
},
{
"input": "ababa",
"output": "3"
},
{
"input": "zzz",
"output": "2"
},
{
"input": "kmmm",
"output": "2"
},
{
"input": "wzznz",
"output": "1"
},
{
"input": "qlzazaaqll",
"output": "2"
},
{
"input": "lzggg... | 1,681,384,209 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 45 | 154 | 2,150,400 | strg = input().strip()
n = len(strg)
result = 0
for i in range(n):
for j in range(i + 1, n):
k = 0
while j + k < n and strg[i + k] == strg[j + k]:
k += 1
result = max(result, k)
print(result)
| Title: You're Given a String...
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
You're given a string of lower-case Latin letters. Your task is to find the length of its longest substring that can be met in the string at least twice. These occurrences can overlap (see sample test 2).
Input Sp... | ```python
strg = input().strip()
n = len(strg)
result = 0
for i in range(n):
for j in range(i + 1, n):
k = 0
while j + k < n and strg[i + k] == strg[j + k]:
k += 1
result = max(result, k)
print(result)
``` | 3.957495 |
916 | A | Jamie and Alarm Snooze | PROGRAMMING | 900 | [
"brute force",
"implementation",
"math"
] | null | null | Jamie loves sleeping. One day, he decides that he needs to wake up at exactly *hh*:<=*mm*. However, he hates waking up, so he wants to make waking up less painful by setting the alarm at a lucky time. He will then press the snooze button every *x* minutes until *hh*:<=*mm* is reached, and only then he will wake up. He ... | The first line contains a single integer *x* (1<=β€<=*x*<=β€<=60).
The second line contains two two-digit integers, *hh* and *mm* (00<=β€<=*hh*<=β€<=23,<=00<=β€<=*mm*<=β€<=59). | Print the minimum number of times he needs to press the button. | [
"3\n11 23\n",
"5\n01 07\n"
] | [
"2\n",
"0\n"
] | In the first sample, Jamie needs to wake up at 11:23. So, he can set his alarm at 11:17. He would press the snooze button when the alarm rings at 11:17 and at 11:20.
In the second sample, Jamie can set his alarm at exactly at 01:07 which is lucky. | 500 | [
{
"input": "3\n11 23",
"output": "2"
},
{
"input": "5\n01 07",
"output": "0"
},
{
"input": "34\n09 24",
"output": "3"
},
{
"input": "2\n14 37",
"output": "0"
},
{
"input": "14\n19 54",
"output": "9"
},
{
"input": "42\n15 44",
"output": "12"
},
... | 1,536,003,498 | 2,147,483,647 | Python 3 | OK | TESTS | 254 | 124 | 0 | x=int(input())
hh,mm=map(str,input().split())
flag=0
count=0
while(flag==0):
if('7' in hh or '7' in mm):
flag=1
break
else:
mm=str(int(mm)-x)
if(int(mm)<0):
mm=str(60+int(mm))
hh=str(int(hh)-1)
if(int(hh)<0):
hh=st... | Title: Jamie and Alarm Snooze
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Jamie loves sleeping. One day, he decides that he needs to wake up at exactly *hh*:<=*mm*. However, he hates waking up, so he wants to make waking up less painful by setting the alarm at a lucky time. He will the... | ```python
x=int(input())
hh,mm=map(str,input().split())
flag=0
count=0
while(flag==0):
if('7' in hh or '7' in mm):
flag=1
break
else:
mm=str(int(mm)-x)
if(int(mm)<0):
mm=str(60+int(mm))
hh=str(int(hh)-1)
if(int(hh)<0):
... | 3 | |
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,488,102,381 | 6,081 | Python 3 | OK | TESTS | 67 | 1,013 | 30,003,200 | n,m=map(int,input().split())
a=input().split()
b=input().split()
for i in range(n):
a[i]=int(a[i])
b[i]=int(b[i])
a[i]=[a[i]-b[i],a[i]]
a=sorted(a)
f=0
suum=0
for i in range(n):
if f<m or a[i][0]<0:
suum+=a[i][1]
else:
break
f+=1
for i in range(f,n):
suum+=a[... | 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
n,m=map(int,input().split())
a=input().split()
b=input().split()
for i in range(n):
a[i]=int(a[i])
b[i]=int(b[i])
a[i]=[a[i]-b[i],a[i]]
a=sorted(a)
f=0
suum=0
for i in range(n):
if f<m or a[i][0]<0:
suum+=a[i][1]
else:
break
f+=1
for i in range(f,n):
... | 3 | |
474 | A | Keyboard | PROGRAMMING | 900 | [
"implementation"
] | null | null | Our good friend Mole is trying to code a big message. He is typing on an unusual keyboard with characters arranged in following way:
Unfortunately Mole is blind, so sometimes it is problem for him to put his hands accurately. He accidentally moved both his hands with one position to the left or to the right. That mean... | First line of the input contains one letter describing direction of shifting ('L' or 'R' respectively for left or right).
Second line contains a sequence of characters written by Mole. The size of this sequence will be no more than 100. Sequence contains only symbols that appear on Mole's keyboard. It doesn't contain ... | Print a line that contains the original message. | [
"R\ns;;upimrrfod;pbr\n"
] | [
"allyouneedislove\n"
] | none | 500 | [
{
"input": "R\ns;;upimrrfod;pbr",
"output": "allyouneedislove"
},
{
"input": "R\nwertyuiop;lkjhgfdsxcvbnm,.",
"output": "qwertyuiolkjhgfdsazxcvbnm,"
},
{
"input": "L\nzxcvbnm,kjhgfdsaqwertyuio",
"output": "xcvbnm,.lkjhgfdswertyuiop"
},
{
"input": "R\nbubbuduppudup",
"outp... | 1,686,069,589 | 2,147,483,647 | Python 3 | OK | TESTS | 31 | 46 | 0 | def org_msg(msg, add=1):
for char in msg:
print(keys[keys.index(char) - add], end='')
keys = 'qwertyuiopasdfghjkl;zxcvbnm,./'
pos = input()
msg = input()
if pos == 'R':
org_msg(msg)
else:
org_msg(msg, -1) | Title: Keyboard
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Our good friend Mole is trying to code a big message. He is typing on an unusual keyboard with characters arranged in following way:
Unfortunately Mole is blind, so sometimes it is problem for him to put his hands accurately.... | ```python
def org_msg(msg, add=1):
for char in msg:
print(keys[keys.index(char) - add], end='')
keys = 'qwertyuiopasdfghjkl;zxcvbnm,./'
pos = input()
msg = input()
if pos == 'R':
org_msg(msg)
else:
org_msg(msg, -1)
``` | 3 | |
78 | A | Haiku | PROGRAMMING | 800 | [
"implementation",
"strings"
] | A. Haiku | 2 | 256 | Haiku is a genre of Japanese traditional poetry.
A haiku poem consists of 17 syllables split into three phrases, containing 5, 7 and 5 syllables correspondingly (the first phrase should contain exactly 5 syllables, the second phrase should contain exactly 7 syllables, and the third phrase should contain exactly 5 syll... | The input data consists of three lines. The length of each line is between 1 and 100, inclusive. The *i*-th line contains the *i*-th phrase of the poem. Each phrase consists of one or more words, which are separated by one or more spaces. A word is a non-empty sequence of lowercase Latin letters. Leading and/or trailin... | Print "YES" (without the quotes) if the poem is a haiku. Otherwise, print "NO" (also without the quotes). | [
"on codeforces \nbeta round is running\n a rustling of keys \n",
"how many gallons\nof edo s rain did you drink\n cuckoo\n"
] | [
"YES",
"NO"
] | none | 500 | [
{
"input": "on codeforces \nbeta round is running\n a rustling of keys ",
"output": "YES"
},
{
"input": "how many gallons\nof edo s rain did you drink\n cuckoo",
"output": "NO"
},
{
"input": " hatsu shigure\n saru mo komino wo\nhoshige nari",
... | 1,652,439,457 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 92 | 0 | s1 = input()
s2 = input()
s3 = input()
sum = s1.count('a') + s1.count('e') + s1.count('i') + s1.count('o') + s1.count('u')
sum2 = s2.count('a') + s2.count('e') + s2.count('i') + s2.count('o') + s2.count('u')
sum3 = s3.count('a') + s3.count('e') + s3.count('i') + s3.count('o') + s3.count('u')
if sum == 5 and... | Title: Haiku
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Haiku is a genre of Japanese traditional poetry.
A haiku poem consists of 17 syllables split into three phrases, containing 5, 7 and 5 syllables correspondingly (the first phrase should contain exactly 5 syllables, the second phrase... | ```python
s1 = input()
s2 = input()
s3 = input()
sum = s1.count('a') + s1.count('e') + s1.count('i') + s1.count('o') + s1.count('u')
sum2 = s2.count('a') + s2.count('e') + s2.count('i') + s2.count('o') + s2.count('u')
sum3 = s3.count('a') + s3.count('e') + s3.count('i') + s3.count('o') + s3.count('u')
if su... | 3.977 |
740 | B | Alyona and flowers | PROGRAMMING | 1,200 | [
"constructive algorithms"
] | null | null | Little Alyona is celebrating Happy Birthday! Her mother has an array of *n* flowers. Each flower has some mood, the mood of *i*-th flower is *a**i*. The mood can be positive, zero or negative.
Let's define a subarray as a segment of consecutive flowers. The mother suggested some set of subarrays. Alyona wants to choos... | The first line contains two integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=100)Β β the number of flowers and the number of subarrays suggested by the mother.
The second line contains the flowers moodsΒ β *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=100<=β€<=*a**i*<=β€<=100).
The next *m* lines contain the description of the ... | Print single integerΒ β the maximum possible value added to the Alyona's happiness. | [
"5 4\n1 -2 1 3 -4\n1 2\n4 5\n3 4\n1 4\n",
"4 3\n1 2 3 4\n1 3\n2 4\n1 1\n",
"2 2\n-1 -2\n1 1\n1 2\n"
] | [
"7\n",
"16\n",
"0\n"
] | The first example is the situation described in the statements.
In the second example Alyona should choose all subarrays.
The third example has answer 0 because Alyona can choose none of the subarrays. | 1,000 | [
{
"input": "5 4\n1 -2 1 3 -4\n1 2\n4 5\n3 4\n1 4",
"output": "7"
},
{
"input": "4 3\n1 2 3 4\n1 3\n2 4\n1 1",
"output": "16"
},
{
"input": "2 2\n-1 -2\n1 1\n1 2",
"output": "0"
},
{
"input": "5 6\n1 1 1 -1 0\n2 4\n1 3\n4 5\n1 5\n1 4\n4 5",
"output": "8"
},
{
"inpu... | 1,678,880,492 | 2,147,483,647 | PyPy 3 | OK | TESTS | 53 | 77 | 1,638,400 | I=lambda:map(int,input().split())
R=range
ans=0
n,m=I()
a=list(I())
for _ in R(m):l,r=I();ans+=max(0,sum(a[i]for i in R(l-1,r)))
print(ans) | Title: Alyona and flowers
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little Alyona is celebrating Happy Birthday! Her mother has an array of *n* flowers. Each flower has some mood, the mood of *i*-th flower is *a**i*. The mood can be positive, zero or negative.
Let's define a subarra... | ```python
I=lambda:map(int,input().split())
R=range
ans=0
n,m=I()
a=list(I())
for _ in R(m):l,r=I();ans+=max(0,sum(a[i]for i in R(l-1,r)))
print(ans)
``` | 3 | |
6 | C | Alice, Bob and Chocolate | PROGRAMMING | 1,200 | [
"greedy",
"two pointers"
] | C. Alice, Bob and Chocolate | 2 | 64 | Alice and Bob like games. And now they are ready to start a new game. They have placed *n* chocolate bars in a line. Alice starts to eat chocolate bars one by one from left to right, and Bob β from right to left. For each chocololate bar the time, needed for the player to consume it, is known (Alice and Bob eat them wi... | The first line contains one integer *n* (1<=β€<=*n*<=β€<=105) β the amount of bars on the table. The second line contains a sequence *t*1,<=*t*2,<=...,<=*t**n* (1<=β€<=*t**i*<=β€<=1000), where *t**i* is the time (in seconds) needed to consume the *i*-th bar (in the order from left to right). | Print two numbers *a* and *b*, where *a* is the amount of bars consumed by Alice, and *b* is the amount of bars consumed by Bob. | [
"5\n2 9 8 2 7\n"
] | [
"2 3\n"
] | none | 0 | [
{
"input": "5\n2 9 8 2 7",
"output": "2 3"
},
{
"input": "1\n1",
"output": "1 0"
},
{
"input": "2\n1 1",
"output": "1 1"
},
{
"input": "3\n1 1 1",
"output": "2 1"
},
{
"input": "4\n1 1 1 1",
"output": "2 2"
},
{
"input": "1\n6",
"output": "1 0"
}... | 1,430,561,643 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 374 | 11,776,000 | f, l = 0, int(input()) - 1
ts = [int(x) for x in input().split()]
a, b, bc = 0, 0, False
while l - f > 0:
if ts[f] < ts[l]:
ts[l], a, f, bc = ts[l] - ts[f], a + 1, f + 1, True
elif ts[l] < ts[f]:
ts[f], b, l, bc = ts[f] - ts[l], b + 1, l - 1, False
else:
a, f, b, l, bc = a... | Title: Alice, Bob and Chocolate
Time Limit: 2 seconds
Memory Limit: 64 megabytes
Problem Description:
Alice and Bob like games. And now they are ready to start a new game. They have placed *n* chocolate bars in a line. Alice starts to eat chocolate bars one by one from left to right, and Bob β from right to left. Fo... | ```python
f, l = 0, int(input()) - 1
ts = [int(x) for x in input().split()]
a, b, bc = 0, 0, False
while l - f > 0:
if ts[f] < ts[l]:
ts[l], a, f, bc = ts[l] - ts[f], a + 1, f + 1, True
elif ts[l] < ts[f]:
ts[f], b, l, bc = ts[f] - ts[l], b + 1, l - 1, False
else:
a, f, b,... | 3.818762 |
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,694,705,079 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 56 | 109 | 19,660,800 | n=int(input())
b=list(map(int,input().split()))
c=0
z=0
v=[0]*100001
for i in b:
v[i]+=1
if v[i]!=2:
c+=1
z=max(z,c)
elif v[i]==2:
c-=1
print(z)
| 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())
b=list(map(int,input().split()))
c=0
z=0
v=[0]*100001
for i in b:
v[i]+=1
if v[i]!=2:
c+=1
z=max(z,c)
elif v[i]==2:
c-=1
print(z)
``` | 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,680,453,720 | 2,147,483,647 | Python 3 | OK | TESTS | 102 | 46 | 0 | a=input()
b=input()
lst=[]
for i in range(len(a)):
if a[i]==b[i]:
lst.append(0)
else:
lst.append(1)
for i in range(len(lst)):
print(lst[i],end='') | 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()
lst=[]
for i in range(len(a)):
if a[i]==b[i]:
lst.append(0)
else:
lst.append(1)
for i in range(len(lst)):
print(lst[i],end='')
``` | 3.9885 |
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,641,623,776 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 92 | 0 |
print(["YES","NO"][input()!=input()[::-1]]) | Title: Translation
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pron... | ```python
print(["YES","NO"][input()!=input()[::-1]])
``` | 3.977 |
0 | none | none | none | 0 | [
"none"
] | null | null | The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and *n* columns. At the beginning of the game the hero is in some cell of the left... | Each test contains from one to ten sets of the input data. The first line of the test contains a single integer *t* (1<=β€<=*t*<=β€<=10 for pretests and tests or *t*<==<=1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of *t* sets of the input data.
The first line of t... | For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise. | [
"2\n16 4\n...AAAAA........\ns.BBB......CCCCC\n........DDDDD...\n16 4\n...AAAAA........\ns.BBB....CCCCC..\n.......DDDDD....\n",
"2\n10 4\ns.ZZ......\n.....AAABB\n.YYYYYY...\n10 4\ns.ZZ......\n....AAAABB\n.YYYYYY...\n"
] | [
"YES\nNO\n",
"YES\nNO\n"
] | In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the ... | 0 | [] | 1,538,283,407 | 5,387 | Python 3 | OK | TESTS | 40 | 202 | 1,126,400 | import sys
import time
import traceback
from contextlib import contextmanager
from io import StringIO
def trains(n, k, field):
pos = [row[0] == 's' for row in field]
def advance(p):
npos = [False for r in range(3)]
for r in range(3):
if pos[r] and field[r][c] == '.':
... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of thr... | ```python
import sys
import time
import traceback
from contextlib import contextmanager
from io import StringIO
def trains(n, k, field):
pos = [row[0] == 's' for row in field]
def advance(p):
npos = [False for r in range(3)]
for r in range(3):
if pos[r] and field[r][c] == '.':
... | 3 | |
612 | C | Replace To Make Regular Bracket Sequence | PROGRAMMING | 1,400 | [
"data structures",
"expression parsing",
"math"
] | null | null | You are given string *s* consists of opening and closing brackets of four kinds <>, {}, [], (). There are two types of brackets: opening and closing. You can replace any bracket by another of the same type. For example, you can replace < by the bracket {, but you can't replace it by ) or >.
The following d... | The only line contains a non empty string *s*, consisting of only opening and closing brackets of four kinds. The length of *s* does not exceed 106. | If it's impossible to get RBS from *s* print Impossible.
Otherwise print the least number of replaces needed to get RBS from *s*. | [
"[<}){}\n",
"{()}[]\n",
"]]\n"
] | [
"2",
"0",
"Impossible"
] | none | 0 | [
{
"input": "[<}){}",
"output": "2"
},
{
"input": "{()}[]",
"output": "0"
},
{
"input": "]]",
"output": "Impossible"
},
{
"input": ">",
"output": "Impossible"
},
{
"input": "{}",
"output": "0"
},
{
"input": "{}",
"output": "0"
},
{
"input": ... | 1,567,008,370 | 2,147,483,647 | PyPy 3 | OK | TESTS | 52 | 280 | 47,616,000 | import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
stack = []
c=0
opts = {'(':0,')':1,'<':2,'>':3,'[':4,']':5,'{':6,'}':7}
for s in input():
if s not in opts:break
v = opts[s]
if v&1:
if not stack:
print("Impossible")
exit()
x = stack.pop()
if x != v: c+=1... | Title: Replace To Make Regular Bracket Sequence
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given string *s* consists of opening and closing brackets of four kinds <>, {}, [], (). There are two types of brackets: opening and closing. You can replace any bracket by another... | ```python
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
stack = []
c=0
opts = {'(':0,')':1,'<':2,'>':3,'[':4,']':5,'{':6,'}':7}
for s in input():
if s not in opts:break
v = opts[s]
if v&1:
if not stack:
print("Impossible")
exit()
x = stack.pop()
if x ... | 3 | |
814 | B | An express train to reveries | PROGRAMMING | 1,300 | [
"constructive algorithms"
] | null | null | Sengoku still remembers the mysterious "colourful meteoroids" she discovered with Lala-chan when they were little. In particular, one of the nights impressed her deeply, giving her the illusion that all her fancies would be realized.
On that night, Sengoku constructed a permutation *p*1,<=*p*2,<=...,<=*p**n* of intege... | The first line of input contains a positive integer *n* (2<=β€<=*n*<=β€<=1<=000) β the length of Sengoku's permutation, being the length of both meteor outbursts at the same time.
The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=β€<=*a**i*<=β€<=*n*) β the sequence of colours in the firs... | Output *n* space-separated integers *p*1,<=*p*2,<=...,<=*p**n*, denoting a possible permutation Sengoku could have had. If there are more than one possible answer, output any one of them.
Input guarantees that such permutation exists. | [
"5\n1 2 3 4 3\n1 2 5 4 5\n",
"5\n4 4 2 3 1\n5 4 5 3 1\n",
"4\n1 1 3 4\n1 4 3 4\n"
] | [
"1 2 5 4 3\n",
"5 4 2 3 1\n",
"1 2 3 4\n"
] | In the first sample, both 1,β2,β5,β4,β3 and 1,β2,β3,β4,β5 are acceptable outputs.
In the second sample, 5,β4,β2,β3,β1 is the only permutation to satisfy the constraints. | 1,000 | [
{
"input": "5\n1 2 3 4 3\n1 2 5 4 5",
"output": "1 2 5 4 3"
},
{
"input": "5\n4 4 2 3 1\n5 4 5 3 1",
"output": "5 4 2 3 1"
},
{
"input": "4\n1 1 3 4\n1 4 3 4",
"output": "1 2 3 4"
},
{
"input": "10\n1 2 3 4 7 6 7 8 9 10\n1 2 3 4 5 6 5 8 9 10",
"output": "1 2 3 4 5 6 7 8 9... | 1,497,394,082 | 2,147,483,647 | Python 3 | OK | TESTS | 54 | 62 | 307,200 | '''input
5
1 2 3 4 3
1 2 5 4 5
'''
n = int(input())
d, u, ans = [], [], ""
a, b = input().split(), input().split()
for x in range(n):
if a[x] != b[x]:
d.append(x)
else:
u.append(a[x])
u = [str(i) for i in range(1, n+1) if str(i) not in u]
if len(d) == 1:
ans = a[:d[0]] + [u[0]] + a[d[0]+1:]
else:
ans = a[:d[0]]... | Title: An express train to reveries
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Sengoku still remembers the mysterious "colourful meteoroids" she discovered with Lala-chan when they were little. In particular, one of the nights impressed her deeply, giving her the illusion that all her... | ```python
'''input
5
1 2 3 4 3
1 2 5 4 5
'''
n = int(input())
d, u, ans = [], [], ""
a, b = input().split(), input().split()
for x in range(n):
if a[x] != b[x]:
d.append(x)
else:
u.append(a[x])
u = [str(i) for i in range(1, n+1) if str(i) not in u]
if len(d) == 1:
ans = a[:d[0]] + [u[0]] + a[d[0]+1:]
else:
ans ... | 3 | |
732 | A | Buy a Shovel | PROGRAMMING | 800 | [
"brute force",
"constructive algorithms",
"implementation",
"math"
] | null | null | Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for *k* burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of *r* burles (1<... | The single line of input contains two integers *k* and *r* (1<=β€<=*k*<=β€<=1000, 1<=β€<=*r*<=β€<=9)Β β the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has e... | Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change. | [
"117 3\n",
"237 7\n",
"15 2\n"
] | [
"9\n",
"1\n",
"2\n"
] | In the first example Polycarp can buy 9 shovels and pay 9Β·117β=β1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels ... | 500 | [
{
"input": "117 3",
"output": "9"
},
{
"input": "237 7",
"output": "1"
},
{
"input": "15 2",
"output": "2"
},
{
"input": "1 1",
"output": "1"
},
{
"input": "1 9",
"output": "9"
},
{
"input": "1000 3",
"output": "1"
},
{
"input": "1000 1",
... | 1,691,177,990 | 2,147,483,647 | Python 3 | OK | TESTS | 54 | 46 | 0 | n,k=input("").split()
n=int(n)
t=n
k=int(k)
m=2
count=1
while(True):
if (n%10==0 or n%10==k):
break
else:
count+=1
n=t*(count)
print(count) | Title: Buy a Shovel
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for *k* burles. Assume that there is an unlimited number of such shovels in the shop.
In his ... | ```python
n,k=input("").split()
n=int(n)
t=n
k=int(k)
m=2
count=1
while(True):
if (n%10==0 or n%10==k):
break
else:
count+=1
n=t*(count)
print(count)
``` | 3 | |
900 | A | Find Extra One | PROGRAMMING | 800 | [
"geometry",
"implementation"
] | null | null | You have *n* distinct points on a plane, none of them lie on *OY* axis. Check that there is a point after removal of which the remaining points are located on one side of the *OY* axis. | The first line contains a single positive integer *n* (2<=β€<=*n*<=β€<=105).
The following *n* lines contain coordinates of the points. The *i*-th of these lines contains two single integers *x**i* and *y**i* (|*x**i*|,<=|*y**i*|<=β€<=109, *x**i*<=β <=0). No two points coincide. | Print "Yes" if there is such a point, "No" β otherwise.
You can print every letter in any case (upper or lower). | [
"3\n1 1\n-1 -1\n2 -1\n",
"4\n1 1\n2 2\n-1 1\n-2 2\n",
"3\n1 2\n2 1\n4 60\n"
] | [
"Yes",
"No",
"Yes"
] | In the first example the second point can be removed.
In the second example there is no suitable for the condition point.
In the third example any point can be removed. | 500 | [
{
"input": "3\n1 1\n-1 -1\n2 -1",
"output": "Yes"
},
{
"input": "4\n1 1\n2 2\n-1 1\n-2 2",
"output": "No"
},
{
"input": "3\n1 2\n2 1\n4 60",
"output": "Yes"
},
{
"input": "10\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6\n7 7\n8 8\n9 9\n-1 -1",
"output": "Yes"
},
{
"input": "2\n1... | 1,670,521,684 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 71 | 638 | 9,932,800 | n = int(input())
pozitive = 0
negative = 0
for i in range(n):
x, y = map(int, input().split())
if x > 0:
pozitive += 1
else:
negative += 1
if pozitive == 0 or pozitive == 1 or negative == 0 or negative == 1:
print("Yes")
else:
print("No") | Title: Find Extra One
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You have *n* distinct points on a plane, none of them lie on *OY* axis. Check that there is a point after removal of which the remaining points are located on one side of the *OY* axis.
Input Specification:
The first li... | ```python
n = int(input())
pozitive = 0
negative = 0
for i in range(n):
x, y = map(int, input().split())
if x > 0:
pozitive += 1
else:
negative += 1
if pozitive == 0 or pozitive == 1 or negative == 0 or negative == 1:
print("Yes")
else:
print("No")
``` | 3 | |
136 | A | Presents | PROGRAMMING | 800 | [
"implementation"
] | null | null | Little Petya very much likes gifts. Recently he has received a new laptop as a New Year gift from his mother. He immediately decided to give it to somebody else as what can be more pleasant than giving somebody gifts. And on this occasion he organized a New Year party at his place and invited *n* his friends there.
If... | The first line contains one integer *n* (1<=β€<=*n*<=β€<=100) β the quantity of friends Petya invited to the party. The second line contains *n* space-separated integers: the *i*-th number is *p**i* β the number of a friend who gave a gift to friend number *i*. It is guaranteed that each friend received exactly one gift.... | Print *n* space-separated integers: the *i*-th number should equal the number of the friend who gave a gift to friend number *i*. | [
"4\n2 3 4 1\n",
"3\n1 3 2\n",
"2\n1 2\n"
] | [
"4 1 2 3\n",
"1 3 2\n",
"1 2\n"
] | none | 500 | [
{
"input": "4\n2 3 4 1",
"output": "4 1 2 3"
},
{
"input": "3\n1 3 2",
"output": "1 3 2"
},
{
"input": "2\n1 2",
"output": "1 2"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "10\n1 3 2 6 4 5 7 9 8 10",
"output": "1 3 2 5 6 4 7 9 8 10"
},
{
"input"... | 1,680,962,034 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 101 | 124 | 0 | n = int(input())
array = list(map(int, input().split()))
for i in range(1, n+1):
print(array.index(i) + 1, end=' ')
| Title: Presents
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little Petya very much likes gifts. Recently he has received a new laptop as a New Year gift from his mother. He immediately decided to give it to somebody else as what can be more pleasant than giving somebody gifts. And on t... | ```python
n = int(input())
array = list(map(int, input().split()))
for i in range(1, n+1):
print(array.index(i) + 1, end=' ')
``` | 3 | |
7 | C | Line | PROGRAMMING | 1,800 | [
"math",
"number theory"
] | C. Line | 1 | 256 | A line on the plane is described by an equation *Ax*<=+<=*By*<=+<=*C*<==<=0. You are to find any point on this line, whose coordinates are integer numbers from <=-<=5Β·1018 to 5Β·1018 inclusive, or to find out that such points do not exist. | The first line contains three integers *A*, *B* and *C* (<=-<=2Β·109<=β€<=*A*,<=*B*,<=*C*<=β€<=2Β·109) β corresponding coefficients of the line equation. It is guaranteed that *A*2<=+<=*B*2<=><=0. | If the required point exists, output its coordinates, otherwise output -1. | [
"2 5 3\n"
] | [
"6 -3\n"
] | none | 0 | [
{
"input": "2 5 3",
"output": "6 -3"
},
{
"input": "0 2 3",
"output": "-1"
},
{
"input": "931480234 -1767614767 -320146190",
"output": "-98880374013340920 -52107006370101410"
},
{
"input": "-1548994394 -1586527767 -1203252104",
"output": "-878123061596147680 8573488141506... | 1,687,287,756 | 2,147,483,647 | Python 3 | OK | TESTS | 48 | 62 | 0 | def gcd(a,b):
if b==0:
return (1,0,a)
else:
x,y,g=gcd(b, a%b)
return (y,x-(a//b)*y,g)
a,b,c=map(int,input().split())
if a>b:
x,y,g=gcd(max(a,b),min(a,b))
else:
y,x,g=gcd(max(a,b),min(a,b))
if abs(c)%g!=0:
print(-1)
else:
print(-x*(c//g),-y*(c//g)) | Title: Line
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
A line on the plane is described by an equation *Ax*<=+<=*By*<=+<=*C*<==<=0. You are to find any point on this line, whose coordinates are integer numbers from <=-<=5Β·1018 to 5Β·1018 inclusive, or to find out that such points do not ex... | ```python
def gcd(a,b):
if b==0:
return (1,0,a)
else:
x,y,g=gcd(b, a%b)
return (y,x-(a//b)*y,g)
a,b,c=map(int,input().split())
if a>b:
x,y,g=gcd(max(a,b),min(a,b))
else:
y,x,g=gcd(max(a,b),min(a,b))
if abs(c)%g!=0:
print(-1)
else:
print(-x*(c//g),-y*(c//g)... | 3.969 |
483 | A | Counterexample | PROGRAMMING | 1,100 | [
"brute force",
"implementation",
"math",
"number theory"
] | null | null | Your friend has recently learned about coprime numbers. A pair of numbers {*a*,<=*b*} is called coprime if the maximum number that divides both *a* and *b* is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (*a*,<=*b*) is coprime and the pair (*b*,<=*c*) i... | The single line contains two positive space-separated integers *l*, *r* (1<=β€<=*l*<=β€<=*r*<=β€<=1018; *r*<=-<=*l*<=β€<=50). | Print three positive space-separated integers *a*, *b*, *c*Β β three distinct numbers (*a*,<=*b*,<=*c*) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1. | [
"2 4\n",
"10 11\n",
"900000000000000009 900000000000000029\n"
] | [
"2 3 4\n",
"-1\n",
"900000000000000009 900000000000000010 900000000000000021\n"
] | In the first sample pair (2,β4) is not coprime and pairs (2,β3) and (3,β4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three. | 500 | [
{
"input": "2 4",
"output": "2 3 4"
},
{
"input": "10 11",
"output": "-1"
},
{
"input": "900000000000000009 900000000000000029",
"output": "900000000000000009 900000000000000010 900000000000000021"
},
{
"input": "640097987171091791 640097987171091835",
"output": "64009798... | 1,563,780,752 | 2,147,483,647 | Python 3 | OK | TESTS | 42 | 124 | 0 | X = list(map(int, input().split()))
if (X[0] % 2 == 0 and X[1] - X[0] < 2) or (X[0] % 2 != 0 and X[1] - X[0] < 3):
print(-1)
exit()
if X[0] % 2 == 0:
print(X[0], X[0] + 1, X[0] + 2)
else:
print(X[0] + 1, X[0] + 2, X[0] + 3)
# UB_CodeForces
# Advice: Everyone deserves the second chance, but no... | Title: Counterexample
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Your friend has recently learned about coprime numbers. A pair of numbers {*a*,<=*b*} is called coprime if the maximum number that divides both *a* and *b* is equal to one.
Your friend often comes up with different st... | ```python
X = list(map(int, input().split()))
if (X[0] % 2 == 0 and X[1] - X[0] < 2) or (X[0] % 2 != 0 and X[1] - X[0] < 3):
print(-1)
exit()
if X[0] % 2 == 0:
print(X[0], X[0] + 1, X[0] + 2)
else:
print(X[0] + 1, X[0] + 2, X[0] + 3)
# UB_CodeForces
# Advice: Everyone deserves the second chan... | 3 | |
673 | A | Bear and Game | PROGRAMMING | 800 | [
"implementation"
] | null | null | Bear Limak likes watching sports on TV. He is going to watch a game today. The game lasts 90 minutes and there are no breaks.
Each minute can be either interesting or boring. If 15 consecutive minutes are boring then Limak immediately turns TV off.
You know that there will be *n* interesting minutes *t*1,<=*t*2,<=...... | The first line of the input contains one integer *n* (1<=β€<=*n*<=β€<=90)Β β the number of interesting minutes.
The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=β€<=*t*1<=<<=*t*2<=<<=... *t**n*<=β€<=90), given in the increasing order. | Print the number of minutes Limak will watch the game. | [
"3\n7 20 88\n",
"9\n16 20 30 40 50 60 70 80 90\n",
"9\n15 20 30 40 50 60 70 80 90\n"
] | [
"35\n",
"15\n",
"90\n"
] | In the first sample, minutes 21,β22,β...,β35 are all boring and thus Limak will turn TV off immediately after the 35-th minute. So, he would watch the game for 35 minutes.
In the second sample, the first 15 minutes are boring.
In the third sample, there are no consecutive 15 boring minutes. So, Limak will watch the w... | 500 | [
{
"input": "3\n7 20 88",
"output": "35"
},
{
"input": "9\n16 20 30 40 50 60 70 80 90",
"output": "15"
},
{
"input": "9\n15 20 30 40 50 60 70 80 90",
"output": "90"
},
{
"input": "30\n6 11 12 15 22 24 30 31 32 33 34 35 40 42 44 45 47 50 53 54 57 58 63 67 75 77 79 81 83 88",
... | 1,598,393,222 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 109 | 0 | def game_watched(interesting_list,n):
time = 0
for i in range(n):
if interesting_list[i+1] - 15 <= interesting_list[i]:
time = interesting_list[i + 1]
else:
break
return time + 15
n = int(input())
lista = [0]
input_list = list(map(int,input().split()))
li... | Title: Bear and Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bear Limak likes watching sports on TV. He is going to watch a game today. The game lasts 90 minutes and there are no breaks.
Each minute can be either interesting or boring. If 15 consecutive minutes are boring then Lim... | ```python
def game_watched(interesting_list,n):
time = 0
for i in range(n):
if interesting_list[i+1] - 15 <= interesting_list[i]:
time = interesting_list[i + 1]
else:
break
return time + 15
n = int(input())
lista = [0]
input_list = list(map(int,input().spl... | 3 | |
38 | C | Blinds | PROGRAMMING | 1,400 | [
"brute force"
] | C. Blinds | 2 | 256 | The blinds are known to consist of opaque horizontal stripes that can be rotated thus regulating the amount of light flowing in the room. There are *n* blind stripes with the width of 1 in the factory warehouse for blind production. The problem is that all of them are spare details from different orders, that is, they ... | The first output line contains two space-separated integers *n* and *l* (1<=β€<=*n*,<=*l*<=β€<=100). They are the number of stripes in the warehouse and the minimal acceptable length of a blind stripe in bourlemeters. The second line contains space-separated *n* integers *a**i*. They are the lengths of initial stripes in... | Print the single number β the maximal area of the window in square bourlemeters that can be completely covered. If no window with a positive area that can be covered completely without breaking any of the given rules exist, then print the single number 0. | [
"4 2\n1 2 3 4\n",
"5 3\n5 5 7 3 1\n",
"2 3\n1 2\n"
] | [
"8\n",
"15\n",
"0\n"
] | In the first sample test the required window is 2βΓβ4 in size and the blinds for it consist of 4 parts, each 2 bourlemeters long. One of the parts is the initial stripe with the length of 2, the other one is a part of a cut stripe with the length of 3 and the two remaining stripes are parts of a stripe with the length ... | 0 | [
{
"input": "4 2\n1 2 3 4",
"output": "8"
},
{
"input": "5 3\n5 5 7 3 1",
"output": "15"
},
{
"input": "2 3\n1 2",
"output": "0"
},
{
"input": "2 2\n3 3",
"output": "6"
},
{
"input": "5 2\n2 4 1 1 3",
"output": "8"
},
{
"input": "7 4\n3 2 1 1 1 3 2",
... | 1,696,161,561 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 36 | 154 | 1,638,400 | def main():
n, l = map(int, input().split())
a = list(map(int, input().split()))
result = 0
for x in range(l, 101):
s = sum([a[i] // x for i in range(n)])
result = max(result, s * x)
print(result)
main()
| Title: Blinds
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
The blinds are known to consist of opaque horizontal stripes that can be rotated thus regulating the amount of light flowing in the room. There are *n* blind stripes with the width of 1 in the factory warehouse for blind production.... | ```python
def main():
n, l = map(int, input().split())
a = list(map(int, input().split()))
result = 0
for x in range(l, 101):
s = sum([a[i] // x for i in range(n)])
result = max(result, s * x)
print(result)
main()
``` | 3.958448 |
43 | B | Letter | PROGRAMMING | 1,100 | [
"implementation",
"strings"
] | B. Letter | 2 | 256 | Vasya decided to write an anonymous letter cutting the letters out of a newspaper heading. He knows heading *s*1 and text *s*2 that he wants to send. Vasya can use every single heading letter no more than once. Vasya doesn't have to cut the spaces out of the heading β he just leaves some blank space to mark them. Help ... | The first line contains a newspaper heading *s*1. The second line contains the letter text *s*2. *s*1 ΠΈ *s*2 are non-empty lines consisting of spaces, uppercase and lowercase Latin letters, whose lengths do not exceed 200 symbols. The uppercase and lowercase letters should be differentiated. Vasya does not cut spaces o... | If Vasya can write the given anonymous letter, print YES, otherwise print NO | [
"Instead of dogging Your footsteps it disappears but you dont notice anything\nwhere is your dog\n",
"Instead of dogging Your footsteps it disappears but you dont notice anything\nYour dog is upstears\n",
"Instead of dogging your footsteps it disappears but you dont notice anything\nYour dog is upstears\n",
"... | [
"NO\n",
"YES\n",
"NO\n",
"YES\n"
] | none | 1,000 | [
{
"input": "Instead of dogging Your footsteps it disappears but you dont notice anything\nwhere is your dog",
"output": "NO"
},
{
"input": "Instead of dogging Your footsteps it disappears but you dont notice anything\nYour dog is upstears",
"output": "YES"
},
{
"input": "Instead of doggi... | 1,623,923,833 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 154 | 102,400 | from collections import Counter
def solve():
s1=input()
s2=input()
d1=Counter(s1)
d2=Counter(s2)
# print(d1)
# print(d2)
for i in d2:
if i!=" ":
if i not in d1:
print("NO")
return
if d1[i]<d2[i]:
pr... | Title: Letter
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya decided to write an anonymous letter cutting the letters out of a newspaper heading. He knows heading *s*1 and text *s*2 that he wants to send. Vasya can use every single heading letter no more than once. Vasya doesn't have to... | ```python
from collections import Counter
def solve():
s1=input()
s2=input()
d1=Counter(s1)
d2=Counter(s2)
# print(d1)
# print(d2)
for i in d2:
if i!=" ":
if i not in d1:
print("NO")
return
if d1[i]<d2[i]:
... | 3.961309 |
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,687,943,187 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 46 | 0 | def can_say_hello(s):
target = "hello"
i = 0
for letter in s:
if letter == target[i]:
i += 1
if i == len(target):
return "YES"
return "NO"
s = str(input())
result = can_say_hello(s)
print(result)
| 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
def can_say_hello(s):
target = "hello"
i = 0
for letter in s:
if letter == target[i]:
i += 1
if i == len(target):
return "YES"
return "NO"
s = str(input())
result = can_say_hello(s)
print(result)
``` | 3.977 |
39 | D | Cubical Planet | PROGRAMMING | 1,100 | [
"math"
] | D. Cubical Planet | 2 | 64 | You can find anything whatsoever in our Galaxy! A cubical planet goes round an icosahedral star. Let us introduce a system of axes so that the edges of the cubical planet are parallel to the coordinate axes and two opposite vertices lay in the points (0,<=0,<=0) and (1,<=1,<=1). Two flies live on the planet. At the mom... | The first line contains three space-separated integers (0 or 1) β the coordinates of the first fly, the second line analogously contains the coordinates of the second fly. | Output "YES" (without quotes) if the flies see each other. Otherwise, output "NO". | [
"0 0 0\n0 1 0\n",
"1 1 0\n0 1 0\n",
"0 0 0\n1 1 1\n"
] | [
"YES\n",
"YES\n",
"NO\n"
] | none | 0 | [
{
"input": "0 0 0\n0 1 0",
"output": "YES"
},
{
"input": "1 1 0\n0 1 0",
"output": "YES"
},
{
"input": "0 0 0\n1 1 1",
"output": "NO"
},
{
"input": "0 0 0\n1 0 0",
"output": "YES"
},
{
"input": "0 0 0\n0 1 0",
"output": "YES"
},
{
"input": "0 0 0\n1 1 ... | 1,695,301,310 | 2,147,483,647 | Python 3 | OK | TESTS | 59 | 92 | 0 | # LUOGU_RID: 125479243
i=0
a,b,c=map(int,input().split())
d,e,f=map(int,input().split())
if(a==d):
i=i+1
if(b==e):
i=i+1
if(c==f):
i=i+1
if(i>=1):
print("YES")
else:
print("NO") | Title: Cubical Planet
Time Limit: 2 seconds
Memory Limit: 64 megabytes
Problem Description:
You can find anything whatsoever in our Galaxy! A cubical planet goes round an icosahedral star. Let us introduce a system of axes so that the edges of the cubical planet are parallel to the coordinate axes and two opposite v... | ```python
# LUOGU_RID: 125479243
i=0
a,b,c=map(int,input().split())
d,e,f=map(int,input().split())
if(a==d):
i=i+1
if(b==e):
i=i+1
if(c==f):
i=i+1
if(i>=1):
print("YES")
else:
print("NO")
``` | 3.977 |
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,612,459,059 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 154 | 0 | h = input()
t = 0
b = 0
for i in h:
o = i
o1 = i.lower()
o2 = i.upper()
if i == o1:
t += 1
elif i == o2:
b += 1
if t >= b:
print(h.lower())
else:
print(h.upper())
| Title: Word
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it ei... | ```python
h = input()
t = 0
b = 0
for i in h:
o = i
o1 = i.lower()
o2 = i.upper()
if i == o1:
t += 1
elif i == o2:
b += 1
if t >= b:
print(h.lower())
else:
print(h.upper())
``` | 3.9615 |
405 | A | Gravity Flip | PROGRAMMING | 900 | [
"greedy",
"implementation",
"sortings"
] | null | null | Little Chris is bored during his physics lessons (too easy), so he has built a toy box to keep himself occupied. The box is special, since it has the ability to change gravity.
There are *n* columns of toy cubes in the box arranged in a line. The *i*-th column contains *a**i* cubes. At first, the gravity in the box is... | The first line of input contains an integer *n* (1<=β€<=*n*<=β€<=100), the number of the columns in the box. The next line contains *n* space-separated integer numbers. The *i*-th number *a**i* (1<=β€<=*a**i*<=β€<=100) denotes the number of cubes in the *i*-th column. | Output *n* integer numbers separated by spaces, where the *i*-th number is the amount of cubes in the *i*-th column after the gravity switch. | [
"4\n3 2 1 2\n",
"3\n2 3 8\n"
] | [
"1 2 2 3 \n",
"2 3 8 \n"
] | The first example case is shown on the figure. The top cube of the first column falls to the top of the last column; the top cube of the second column falls to the top of the third column; the middle cube of the first column falls to the top of the second column.
In the second example case the gravity switch does not ... | 500 | [
{
"input": "4\n3 2 1 2",
"output": "1 2 2 3 "
},
{
"input": "3\n2 3 8",
"output": "2 3 8 "
},
{
"input": "5\n2 1 2 1 2",
"output": "1 1 2 2 2 "
},
{
"input": "1\n1",
"output": "1 "
},
{
"input": "2\n4 3",
"output": "3 4 "
},
{
"input": "6\n100 40 60 20... | 1,688,720,453 | 2,147,483,647 | Python 3 | OK | TESTS | 32 | 31 | 0 | def gravity_switch(columns):
columns.sort()
return columns
n = int(input())
columns = list(map(int, input().split()))
result = gravity_switch(columns)
print(*result)
| Title: Gravity Flip
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little Chris is bored during his physics lessons (too easy), so he has built a toy box to keep himself occupied. The box is special, since it has the ability to change gravity.
There are *n* columns of toy cubes in the bo... | ```python
def gravity_switch(columns):
columns.sort()
return columns
n = int(input())
columns = list(map(int, input().split()))
result = gravity_switch(columns)
print(*result)
``` | 3 | |
931 | A | Friends Meeting | PROGRAMMING | 800 | [
"brute force",
"greedy",
"implementation",
"math"
] | null | null | Two friends are on the coordinate axis *Ox* in points with integer coordinates. One of them is in the point *x*1<==<=*a*, another one is in the point *x*2<==<=*b*.
Each of the friends can move by one along the line in any direction unlimited number of times. When a friend moves, the tiredness of a friend changes acco... | The first line contains a single integer *a* (1<=β€<=*a*<=β€<=1000) β the initial position of the first friend.
The second line contains a single integer *b* (1<=β€<=*b*<=β€<=1000) β the initial position of the second friend.
It is guaranteed that *a*<=β <=*b*. | Print the minimum possible total tiredness if the friends meet in the same point. | [
"3\n4\n",
"101\n99\n",
"5\n10\n"
] | [
"1\n",
"2\n",
"9\n"
] | In the first example the first friend should move by one to the right (then the meeting happens at point 4), or the second friend should move by one to the left (then the meeting happens at point 3). In both cases, the total tiredness becomes 1.
In the second example the first friend should move by one to the left, an... | 500 | [
{
"input": "3\n4",
"output": "1"
},
{
"input": "101\n99",
"output": "2"
},
{
"input": "5\n10",
"output": "9"
},
{
"input": "1\n2",
"output": "1"
},
{
"input": "1\n1000",
"output": "250000"
},
{
"input": "999\n1000",
"output": "1"
},
{
"inpu... | 1,655,892,138 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 40 | 62 | 0 | a=int(input())
b=int(input())
s=abs(a-b)
t=0
i=1
while s>0:
if s==1:
t+=i
s-=1
else:
s-=2
t+=i*2
i+=1
print(t)
| Title: Friends Meeting
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Two friends are on the coordinate axis *Ox* in points with integer coordinates. One of them is in the point *x*1<==<=*a*, another one is in the point *x*2<==<=*b*.
Each of the friends can move by one along the line in... | ```python
a=int(input())
b=int(input())
s=abs(a-b)
t=0
i=1
while s>0:
if s==1:
t+=i
s-=1
else:
s-=2
t+=i*2
i+=1
print(t)
``` | 3 | |
22 | B | Bargaining Table | PROGRAMMING | 1,500 | [
"brute force",
"dp"
] | B. Bargaining Table | 2 | 256 | Bob wants to put a new bargaining table in his office. To do so he measured the office room thoroughly and drew its plan: Bob's office room is a rectangular room *n*<=Γ<=*m* meters. Each square meter of the room is either occupied by some furniture, or free. A bargaining table is rectangular, and should be placed so, t... | The first line contains 2 space-separated numbers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=25) β the office room dimensions. Then there follow *n* lines with *m* characters 0 or 1 each. 0 stands for a free square meter of the office room. 1 stands for an occupied square meter. It's guaranteed that at least one square meter in ... | Output one number β the maximum possible perimeter of a bargaining table for Bob's office room. | [
"3 3\n000\n010\n000\n",
"5 4\n1100\n0000\n0000\n0000\n0000\n"
] | [
"8\n",
"16\n"
] | none | 0 | [
{
"input": "3 3\n000\n010\n000",
"output": "8"
},
{
"input": "5 4\n1100\n0000\n0000\n0000\n0000",
"output": "16"
},
{
"input": "3 3\n000\n110\n000",
"output": "8"
},
{
"input": "4 2\n00\n10\n11\n00",
"output": "6"
},
{
"input": "3 5\n00001\n00000\n10100",
"out... | 1,580,511,082 | 2,147,483,647 | PyPy 3 | OK | TESTS | 23 | 592 | 6,348,800 | n,m = [int(i) for i in input().split()]
matriz = []
for i in range(n):
matriz.append(input())
ans = 4
for i in range(n):
for j in range(m):
for k in range(i,n):
for l in range(j,m):
#print(i,j,k,l)
block = False
for x... | Title: Bargaining Table
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob wants to put a new bargaining table in his office. To do so he measured the office room thoroughly and drew its plan: Bob's office room is a rectangular room *n*<=Γ<=*m* meters. Each square meter of the room is either ... | ```python
n,m = [int(i) for i in input().split()]
matriz = []
for i in range(n):
matriz.append(input())
ans = 4
for i in range(n):
for j in range(m):
for k in range(i,n):
for l in range(j,m):
#print(i,j,k,l)
block = False
... | 3.840174 |
721 | A | One-dimensional Japanese Crossword | PROGRAMMING | 800 | [
"implementation"
] | null | null | Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized *a*<=Γ<=*b* squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers repr... | The first line of the input contains a single integer *n* (1<=β€<=*n*<=β€<=100)Β β the length of the row. The second line of the input contains a single string consisting of *n* characters 'B' or 'W', ('B' corresponds to black square, 'W'Β β to white square in the row that Adaltik drew). | The first line should contain a single integer *k*Β β the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain *k* integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right. | [
"3\nBBW\n",
"5\nBWBWB\n",
"4\nWWWW\n",
"4\nBBBB\n",
"13\nWBBBBWWBWBBBW\n"
] | [
"1\n2 ",
"3\n1 1 1 ",
"0\n",
"1\n4 ",
"3\n4 1 3 "
] | The last sample case correspond to the picture in the statement. | 500 | [
{
"input": "3\nBBW",
"output": "1\n2 "
},
{
"input": "5\nBWBWB",
"output": "3\n1 1 1 "
},
{
"input": "4\nWWWW",
"output": "0"
},
{
"input": "4\nBBBB",
"output": "1\n4 "
},
{
"input": "13\nWBBBBWWBWBBBW",
"output": "3\n4 1 3 "
},
{
"input": "1\nB",
... | 1,660,948,051 | 2,147,483,647 | Python 3 | OK | TESTS | 54 | 46 | 0 | # -*- coding: utf-8 -*-
_ = int(input())
squares = input()
blocks = []
block_size = 0
last_char = 'W'
for square in squares:
if square == 'B':
block_size += 1
elif square == 'W' and last_char == 'B':
blocks.append(str(block_size))
block_size = 0
last_char = square
if block_siz... | Title: One-dimensional Japanese Crossword
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized *a*<=Γ<=*b* squares, and each square is colored white or black. There are integers to the... | ```python
# -*- coding: utf-8 -*-
_ = int(input())
squares = input()
blocks = []
block_size = 0
last_char = 'W'
for square in squares:
if square == 'B':
block_size += 1
elif square == 'W' and last_char == 'B':
blocks.append(str(block_size))
block_size = 0
last_char = square
if... | 3 | |
707 | A | Brain's Photos | PROGRAMMING | 800 | [
"implementation"
] | null | null | Small, but very brave, mouse Brain was not accepted to summer school of young villains. He was upset and decided to postpone his plans of taking over the world, but to become a photographer instead.
As you may know, the coolest photos are on the film (because you can specify the hashtag #film for such).
Brain took a ... | The first line of the input contains two integers *n* and *m* (1<=β€<=*n*,<=*m*<=β€<=100)Β β the number of photo pixel matrix rows and columns respectively.
Then *n* lines describing matrix rows follow. Each of them contains *m* space-separated characters describing colors of pixels in a row. Each character in the line i... | Print the "#Black&White" (without quotes), if the photo is black-and-white and "#Color" (without quotes), if it is colored, in the only line. | [
"2 2\nC M\nY Y\n",
"3 2\nW W\nW W\nB B\n",
"1 1\nW\n"
] | [
"#Color",
"#Black&White",
"#Black&White"
] | none | 500 | [
{
"input": "2 2\nC M\nY Y",
"output": "#Color"
},
{
"input": "3 2\nW W\nW W\nB B",
"output": "#Black&White"
},
{
"input": "1 1\nW",
"output": "#Black&White"
},
{
"input": "2 3\nW W W\nB G Y",
"output": "#Color"
},
{
"input": "1 1\nW",
"output": "#Black&White"
... | 1,655,958,351 | 2,147,483,647 | Python 3 | OK | TESTS | 50 | 46 | 0 | n, m = map(int, input().split())
for _ in range(n):
line = input().split()
if "C" in line or "M" in line or "Y" in line:
print("#Color")
break
else:
print("#Black&White")
| Title: Brain's Photos
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Small, but very brave, mouse Brain was not accepted to summer school of young villains. He was upset and decided to postpone his plans of taking over the world, but to become a photographer instead.
As you may know, the... | ```python
n, m = map(int, input().split())
for _ in range(n):
line = input().split()
if "C" in line or "M" in line or "Y" in line:
print("#Color")
break
else:
print("#Black&White")
``` | 3 | |
750 | A | New Year and Hurry | PROGRAMMING | 800 | [
"binary search",
"brute force",
"implementation",
"math"
] | null | null | Limak is going to participate in a contest on the last day of the 2016. The contest will start at 20:00 and will last four hours, exactly until midnight. There will be *n* problems, sorted by difficulty, i.e. problem 1 is the easiest and problem *n* is the hardest. Limak knows it will take him 5Β·*i* minutes to solve th... | The only line of the input contains two integers *n* and *k* (1<=β€<=*n*<=β€<=10, 1<=β€<=*k*<=β€<=240)Β β the number of the problems in the contest and the number of minutes Limak needs to get to the party from his house. | Print one integer, denoting the maximum possible number of problems Limak can solve so that he could get to the party at midnight or earlier. | [
"3 222\n",
"4 190\n",
"7 1\n"
] | [
"2\n",
"4\n",
"7\n"
] | In the first sample, there are 3 problems and Limak needs 222 minutes to get to the party. The three problems require 5, 10 and 15 minutes respectively. Limak can spend 5β+β10β=β15 minutes to solve first two problems. Then, at 20:15 he can leave his house to get to the party at 23:57 (after 222 minutes). In this scenar... | 500 | [
{
"input": "3 222",
"output": "2"
},
{
"input": "4 190",
"output": "4"
},
{
"input": "7 1",
"output": "7"
},
{
"input": "10 135",
"output": "6"
},
{
"input": "10 136",
"output": "5"
},
{
"input": "1 1",
"output": "1"
},
{
"input": "1 240",
... | 1,695,510,652 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 52 | 62 | 0 | p, m = map(int, input().strip().split()); count, org = 0, 4*60
for i in range(1, p+1):
dn = 5*i
if (org - dn) < m:
break
else:
count += 1
org -= dn
print (count) | Title: New Year and Hurry
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Limak is going to participate in a contest on the last day of the 2016. The contest will start at 20:00 and will last four hours, exactly until midnight. There will be *n* problems, sorted by difficulty, i.e. problem... | ```python
p, m = map(int, input().strip().split()); count, org = 0, 4*60
for i in range(1, p+1):
dn = 5*i
if (org - dn) < m:
break
else:
count += 1
org -= dn
print (count)
``` | 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,621,875,260 | 2,147,483,647 | PyPy 3 | OK | TESTS | 34 | 280 | 2,355,200 | import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float("inf")
# input = sys.stdin.readline
flush = lambda: sys.stdout.flush
comb = lambda x, y: (factorial(x) // factorial(y))... | 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
import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float("inf")
# input = sys.stdin.readline
flush = lambda: sys.stdout.flush
comb = lambda x, y: (factorial(x) // fac... | 3.925613 |
672 | B | Different is Good | PROGRAMMING | 1,000 | [
"constructive algorithms",
"implementation",
"strings"
] | null | null | A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string *s* consisting of lowercase English letters. Since Kerem likes it when things are different, he wants all substrings of his string *s* to be distinct. Substring is a string formed by some... | The first line of the input contains an integer *n* (1<=β€<=*n*<=β€<=100<=000)Β β the length of the string *s*.
The second line contains the string *s* of length *n* consisting of only lowercase English letters. | If it's impossible to change the string *s* such that all its substring are distinct print -1. Otherwise print the minimum required number of changes. | [
"2\naa\n",
"4\nkoko\n",
"5\nmurat\n"
] | [
"1\n",
"2\n",
"0\n"
] | In the first sample one of the possible solutions is to change the first character to 'b'.
In the second sample, one may change the first character to 'a' and second character to 'b', so the string becomes "abko". | 1,000 | [
{
"input": "2\naa",
"output": "1"
},
{
"input": "4\nkoko",
"output": "2"
},
{
"input": "5\nmurat",
"output": "0"
},
{
"input": "6\nacbead",
"output": "1"
},
{
"input": "7\ncdaadad",
"output": "4"
},
{
"input": "25\npeoaicnbisdocqofsqdpgobpn",
"outp... | 1,577,289,082 | 2,147,483,647 | Python 3 | OK | TESTS | 47 | 109 | 307,200 | t=int(input())
a=input()
l=[]
f=list(set(a))
for i in f:
l.append(a.count(i))
if len(a)<27:
print(sum(l)-len(f))
else:
print(-1) | Title: Different is Good
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string *s* consisting of lowercase English letters. Since Kerem likes it when things are di... | ```python
t=int(input())
a=input()
l=[]
f=list(set(a))
for i in f:
l.append(a.count(i))
if len(a)<27:
print(sum(l)-len(f))
else:
print(-1)
``` | 3 | |
141 | A | Amusing Joke | PROGRAMMING | 800 | [
"implementation",
"sortings",
"strings"
] | null | null | So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's name and the host's name in honor of this event. Then the hung the letters above the main entrance. O... | The input file consists of three lines: the first line contains the guest's name, the second line contains the name of the residence host and the third line contains letters in a pile that were found at the door in the morning. All lines are not empty and contain only uppercase Latin letters. The length of each line do... | Print "YES" without the quotes, if the letters in the pile could be permuted to make the names of the "New Year and Christmas Men". Otherwise, print "NO" without the quotes. | [
"SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS\n",
"PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI\n",
"BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER\n"
] | [
"YES\n",
"NO\n",
"NO\n"
] | In the first sample the letters written in the last line can be used to write the names and there won't be any extra letters left.
In the second sample letter "P" is missing from the pile and there's an extra letter "L".
In the third sample there's an extra letter "L". | 500 | [
{
"input": "SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS",
"output": "YES"
},
{
"input": "PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI",
"output": "NO"
},
{
"input": "BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER",
"output": "NO"
},
{
"input": "B\nA\nAB",
"output": ... | 1,687,785,237 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 54 | 124 | 0 | from collections import Counter
s1=input()
s2=input()
s3=input()
name=s1+s2
'''name_counter=Counter(name)
s3_counter=Counter(s3)'''
if Counter(name)==Counter(s3):
print('YES')
else:
print('NO') | Title: Amusing Joke
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's nam... | ```python
from collections import Counter
s1=input()
s2=input()
s3=input()
name=s1+s2
'''name_counter=Counter(name)
s3_counter=Counter(s3)'''
if Counter(name)==Counter(s3):
print('YES')
else:
print('NO')
``` | 3 | |
466 | C | Number of Ways | PROGRAMMING | 1,700 | [
"binary search",
"brute force",
"data structures",
"dp",
"two pointers"
] | null | null | You've got array *a*[1],<=*a*[2],<=...,<=*a*[*n*], consisting of *n* integers. Count the number of ways to split all the elements of the array into three contiguous parts so that the sum of elements in each part is the same.
More formally, you need to find the number of such pairs of indices *i*,<=*j* (2<=β€<=*i*<=β€<=... | The first line contains integer *n* (1<=β€<=*n*<=β€<=5Β·105), showing how many numbers are in the array. The second line contains *n* integers *a*[1], *a*[2], ..., *a*[*n*] (|*a*[*i*]|<=β€<=<=109) β the elements of array *a*. | Print a single integer β the number of ways to split the array into three parts with the same sum. | [
"5\n1 2 3 0 3\n",
"4\n0 1 -1 0\n",
"2\n4 1\n"
] | [
"2\n",
"1\n",
"0\n"
] | none | 1,500 | [
{
"input": "5\n1 2 3 0 3",
"output": "2"
},
{
"input": "4\n0 1 -1 0",
"output": "1"
},
{
"input": "2\n4 1",
"output": "0"
},
{
"input": "9\n0 0 0 0 0 0 0 0 0",
"output": "28"
},
{
"input": "10\n2 5 -2 2 -3 -2 3 5 -5 -2",
"output": "0"
},
{
"input": "1\... | 1,699,349,292 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 342 | 61,440,000 | n=int(input())
nums=list(map(int,input().split()))
s=sum(nums)
if s%3!=0:
print(0)
exit()
s=s//3
ans,cnt,pre_sum=0,0,0
for i in range(n-1):
pre_sum+=nums[i]
if pre_sum==s*2:
ans+=cnt
if pre_sum==s:
cnt+=1
print(ans) | Title: Number of Ways
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You've got array *a*[1],<=*a*[2],<=...,<=*a*[*n*], consisting of *n* integers. Count the number of ways to split all the elements of the array into three contiguous parts so that the sum of elements in each part is the s... | ```python
n=int(input())
nums=list(map(int,input().split()))
s=sum(nums)
if s%3!=0:
print(0)
exit()
s=s//3
ans,cnt,pre_sum=0,0,0
for i in range(n-1):
pre_sum+=nums[i]
if pre_sum==s*2:
ans+=cnt
if pre_sum==s:
cnt+=1
print(ans)
``` | 3 | |
9 | A | Die Roll | PROGRAMMING | 800 | [
"math",
"probabilities"
] | A. Die Roll | 1 | 64 | Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpr... | The only line of the input file contains two natural numbers Y and W β the results of Yakko's and Wakko's die rolls. | Output the required probability in the form of irreducible fraction in format Β«A/BΒ», where A β the numerator, and B β the denominator. If the required probability equals to zero, output Β«0/1Β». If the required probability equals to 1, output Β«1/1Β». | [
"4 2\n"
] | [
"1/2\n"
] | Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points. | 0 | [
{
"input": "4 2",
"output": "1/2"
},
{
"input": "1 1",
"output": "1/1"
},
{
"input": "1 2",
"output": "5/6"
},
{
"input": "1 3",
"output": "2/3"
},
{
"input": "1 4",
"output": "1/2"
},
{
"input": "1 5",
"output": "1/3"
},
{
"input": "1 6",
... | 1,683,063,935 | 2,147,483,647 | Python 3 | OK | TESTS | 36 | 92 | 0 | w = 7 - max(map(int, input().split()))
d = {1:"1/6", 2:"1/3", 3:"1/2", 4:"2/3", 5:"5/6", 6:"1/1"}
print(d[w])
| Title: Die Roll
Time Limit: 1 seconds
Memory Limit: 64 megabytes
Problem Description:
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about T... | ```python
w = 7 - max(map(int, input().split()))
d = {1:"1/6", 2:"1/3", 3:"1/2", 4:"2/3", 5:"5/6", 6:"1/1"}
print(d[w])
``` | 3.954 |
235 | A | LCM Challenge | PROGRAMMING | 1,600 | [
"number theory"
] | null | null | Some days ago, I learned the concept of LCM (least common multiple). I've played with it for several times and I want to make a big number with it.
But I also don't want to use many numbers, so I'll choose three positive integers (they don't have to be distinct) which are not greater than *n*. Can you help me to find ... | The first line contains an integer *n* (1<=β€<=*n*<=β€<=106) β the *n* mentioned in the statement. | Print a single integer β the maximum possible LCM of three not necessarily distinct positive integers that are not greater than *n*. | [
"9\n",
"7\n"
] | [
"504\n",
"210\n"
] | The least common multiple of some positive integers is the least positive integer which is multiple for each of them.
The result may become very large, 32-bit integer won't be enough. So using 64-bit integers is recommended.
For the last example, we can chose numbers 7, 6, 5 and the LCM of them is 7Β·6Β·5β=β210. It is ... | 500 | [
{
"input": "9",
"output": "504"
},
{
"input": "7",
"output": "210"
},
{
"input": "1",
"output": "1"
},
{
"input": "5",
"output": "60"
},
{
"input": "6",
"output": "60"
},
{
"input": "33",
"output": "32736"
},
{
"input": "21",
"output": ... | 1,689,343,390 | 2,147,483,647 | Python 3 | OK | TESTS | 87 | 92 | 307,200 | import sys
sys.setrecursionlimit(2000000)
from collections import defaultdict
import math
def clc():
n = int(input())
if n<=2:print(n)
elif n%2:print(n*(n-1)*(n-2))
else:print(max((n-1)*(n-2)*(n-3),(n*(n-1)*(n-3))//math.gcd(n,n-3)))
return True
cc = clc()
if not cc ... | Title: LCM Challenge
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Some days ago, I learned the concept of LCM (least common multiple). I've played with it for several times and I want to make a big number with it.
But I also don't want to use many numbers, so I'll choose three positive... | ```python
import sys
sys.setrecursionlimit(2000000)
from collections import defaultdict
import math
def clc():
n = int(input())
if n<=2:print(n)
elif n%2:print(n*(n-1)*(n-2))
else:print(max((n-1)*(n-2)*(n-3),(n*(n-1)*(n-3))//math.gcd(n,n-3)))
return True
cc = clc()
... | 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.