contestId int64 0 1.01k | index stringclasses 57
values | name stringlengths 2 58 | type stringclasses 2
values | rating int64 0 3.5k | tags listlengths 0 11 | title stringclasses 522
values | time-limit stringclasses 8
values | memory-limit stringclasses 8
values | problem-description stringlengths 0 7.15k | input-specification stringlengths 0 2.05k | output-specification stringlengths 0 1.5k | demo-input listlengths 0 7 | demo-output listlengths 0 7 | note stringlengths 0 5.24k | points float64 0 425k | test_cases listlengths 0 402 | creationTimeSeconds int64 1.37B 1.7B | relativeTimeSeconds int64 8 2.15B | programmingLanguage stringclasses 3
values | verdict stringclasses 14
values | testset stringclasses 12
values | passedTestCount int64 0 1k | timeConsumedMillis int64 0 15k | memoryConsumedBytes int64 0 805M | code stringlengths 3 65.5k | prompt stringlengths 262 8.2k | response stringlengths 17 65.5k | score float64 -1 3.99 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
552 | D | Vanya and Triangles | PROGRAMMING | 1,900 | [
"brute force",
"combinatorics",
"data structures",
"geometry",
"math",
"sortings"
] | null | null | Vanya got bored and he painted *n* distinct points on the plane. After that he connected all the points pairwise and saw that as a result many triangles were formed with vertices in the painted points. He asks you to count the number of the formed triangles with the non-zero area. | The first line contains integer *n* (1<=≤<=*n*<=≤<=2000) — the number of the points painted on the plane.
Next *n* lines contain two integers each *x**i*,<=*y**i* (<=-<=100<=≤<=*x**i*,<=*y**i*<=≤<=100) — the coordinates of the *i*-th point. It is guaranteed that no two given points coincide. | In the first line print an integer — the number of triangles with the non-zero area among the painted points. | [
"4\n0 0\n1 1\n2 0\n2 2\n",
"3\n0 0\n1 1\n2 0\n",
"1\n1 1\n"
] | [
"3\n",
"1\n",
"0\n"
] | Note to the first sample test. There are 3 triangles formed: (0, 0) - (1, 1) - (2, 0); (0, 0) - (2, 2) - (2, 0); (1, 1) - (2, 2) - (2, 0).
Note to the second sample test. There is 1 triangle formed: (0, 0) - (1, 1) - (2, 0).
Note to the third sample test. A single point doesn't form a single triangle. | 2,000 | [
{
"input": "4\n0 0\n1 1\n2 0\n2 2",
"output": "3"
},
{
"input": "3\n0 0\n1 1\n2 0",
"output": "1"
},
{
"input": "1\n1 1",
"output": "0"
},
{
"input": "5\n0 0\n1 1\n2 2\n3 3\n4 4",
"output": "0"
},
{
"input": "5\n0 0\n1 1\n2 3\n3 6\n4 10",
"output": "10"
},
... | 1,580,287,161 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 0 | 93 | 0 | """ Vanya and Triangles """
def slope(pointA, pointB):
return (pointB[1] - pointA[1]) / (pointB[0] - pointA[0]) if pointB[0] != pointA[0] else float('inf')
def CF552D():
N = int(input())
# Base case and input validation
if N < 3: return 0
points = [tuple(map(int, input().split())) ... | Title: Vanya and Triangles
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vanya got bored and he painted *n* distinct points on the plane. After that he connected all the points pairwise and saw that as a result many triangles were formed with vertices in the painted points. He asks you t... | ```python
""" Vanya and Triangles """
def slope(pointA, pointB):
return (pointB[1] - pointA[1]) / (pointB[0] - pointA[0]) if pointB[0] != pointA[0] else float('inf')
def CF552D():
N = int(input())
# Base case and input validation
if N < 3: return 0
points = [tuple(map(int, input().... | 0 | |
59 | A | Word | PROGRAMMING | 800 | [
"implementation",
"strings"
] | A. Word | 2 | 256 | Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At 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,694,171,204 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 92 | 0 | a = input()
uppercase_count = sum(1 for char in a if char.isupper())
half_length = len(a) // 2
if uppercase_count > half_length:
result = a.upper()
else:
result = a.lower()
print(result)
| 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
a = input()
uppercase_count = sum(1 for char in a if char.isupper())
half_length = len(a) // 2
if uppercase_count > half_length:
result = a.upper()
else:
result = a.lower()
print(result)
``` | 3.977 |
2 | B | The least round way | PROGRAMMING | 2,000 | [
"dp",
"math"
] | B. The least round way | 2 | 64 | There is a square matrix *n*<=×<=*n*, consisting of non-negative integer numbers. You should find such a way on it that
- starts in the upper left cell of the matrix; - each following cell is to the right or down from the current cell; - the way ends in the bottom right cell.
Moreover, if we multiply together all... | The first line contains an integer number *n* (2<=≤<=*n*<=≤<=1000), *n* is the size of the matrix. Then follow *n* lines containing the matrix elements (non-negative integer numbers not exceeding 109). | In the first line print the least number of trailing zeros. In the second line print the correspondent way itself. | [
"3\n1 2 3\n4 5 6\n7 8 9\n"
] | [
"0\nDDRR\n"
] | none | 0 | [
{
"input": "3\n1 2 3\n4 5 6\n7 8 9",
"output": "0\nDDRR"
},
{
"input": "2\n7 6\n3 8",
"output": "0\nDR"
},
{
"input": "3\n4 10 5\n10 9 4\n6 5 3",
"output": "1\nDRRD"
},
{
"input": "4\n1 1 9 9\n3 4 7 3\n7 9 1 7\n1 7 1 5",
"output": "0\nDDDRRR"
},
{
"input": "5\n8 3... | 1,488,053,907 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 10 | 2,000 | 4,915,200 | def num_zeros(s):
count = 0
for c in reversed(s):
if c == '0':
count += 1
else:
break
return count
def func(m, x, y):
w = h = len(m)
if x == w - 1 and y == h - 1:
return m[x][y], ""
elif x == w - 1:
dv, ds = func(m, x, y + 1)
dv *=... | Title: The least round way
Time Limit: 2 seconds
Memory Limit: 64 megabytes
Problem Description:
There is a square matrix *n*<=×<=*n*, consisting of non-negative integer numbers. You should find such a way on it that
- starts in the upper left cell of the matrix; - each following cell is to the right or down fro... | ```python
def num_zeros(s):
count = 0
for c in reversed(s):
if c == '0':
count += 1
else:
break
return count
def func(m, x, y):
w = h = len(m)
if x == w - 1 and y == h - 1:
return m[x][y], ""
elif x == w - 1:
dv, ds = func(m, x, y + 1)
... | 0 |
440 | A | Forgotten Episode | PROGRAMMING | 800 | [
"implementation"
] | null | null | Polycarpus adores TV series. Right now he is ready to finish watching a season of a popular sitcom "Graph Theory". In total, the season has *n* episodes, numbered with integers from 1 to *n*.
Polycarpus watches episodes not one by one but in a random order. He has already watched all the episodes except for one. Which... | The first line of the input contains integer *n* (2<=≤<=*n*<=≤<=100000) — the number of episodes in a season. Assume that the episodes are numbered by integers from 1 to *n*.
The second line contains *n*<=-<=1 integer *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=*n*) — the numbers of episodes that Polycarpus has watch... | Print the number of the episode that Polycarpus hasn't watched. | [
"10\n3 8 10 1 7 9 6 5 2\n"
] | [
"4\n"
] | none | 500 | [
{
"input": "10\n3 8 10 1 7 9 6 5 2",
"output": "4"
},
{
"input": "5\n4 3 2 1",
"output": "5"
},
{
"input": "2\n1",
"output": "2"
},
{
"input": "2\n2",
"output": "1"
},
{
"input": "3\n1 2",
"output": "3"
},
{
"input": "3\n1 3",
"output": "2"
},
... | 1,691,771,086 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 30 | 0 | n = int(input())
ep = l = []
count = 0
str = input()
l = str.split()
for i in range(n - 1):
ep.append(int(l[i]))
for i in range(min(ep), max(ep)):
if i not in ep:
print(i)
| Title: Forgotten Episode
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarpus adores TV series. Right now he is ready to finish watching a season of a popular sitcom "Graph Theory". In total, the season has *n* episodes, numbered with integers from 1 to *n*.
Polycarpus watches episo... | ```python
n = int(input())
ep = l = []
count = 0
str = input()
l = str.split()
for i in range(n - 1):
ep.append(int(l[i]))
for i in range(min(ep), max(ep)):
if i not in ep:
print(i)
``` | 0 | |
839 | C | Journey | PROGRAMMING | 1,500 | [
"dfs and similar",
"dp",
"graphs",
"probabilities",
"trees"
] | null | null | There are *n* cities and *n*<=-<=1 roads in the Seven Kingdoms, each road connects two cities and we can reach any city from any other by the roads.
Theon and Yara Greyjoy are on a horse in the first city, they are starting traveling through the roads. But the weather is foggy, so they can’t see where the horse brings... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100000) — number of cities.
Then *n*<=-<=1 lines follow. The *i*-th line of these lines contains two integers *u**i* and *v**i* (1<=≤<=*u**i*,<=*v**i*<=≤<=*n*, *u**i*<=≠<=*v**i*) — the cities connected by the *i*-th road.
It is guaranteed that one can reach ... | Print a number — the expected length of their journey. The journey starts in the city 1.
Your answer will be considered correct if its absolute or relative error does not exceed 10<=-<=6.
Namely: let's assume that your answer is *a*, and the answer of the jury is *b*. The checker program will consider your answer cor... | [
"4\n1 2\n1 3\n2 4\n",
"5\n1 2\n1 3\n3 4\n2 5\n"
] | [
"1.500000000000000\n",
"2.000000000000000\n"
] | In the first sample, their journey may end in cities 3 or 4 with equal probability. The distance to city 3 is 1 and to city 4 is 2, so the expected length is 1.5.
In the second sample, their journey may end in city 4 or 5. The distance to the both cities is 2, so the expected length is 2. | 1,500 | [
{
"input": "4\n1 2\n1 3\n2 4",
"output": "1.500000000000000"
},
{
"input": "5\n1 2\n1 3\n3 4\n2 5",
"output": "2.000000000000000"
},
{
"input": "70\n1 25\n57 1\n18 1\n65 1\n38 1\n1 41\n1 5\n1 69\n1 3\n31 1\n1 8\n1 9\n53 1\n70 1\n45 1\n1 24\n1 42\n1 30\n1 12\n1 37\n64 1\n1 28\n1 58\n1 22\... | 1,585,853,955 | 2,147,483,647 | PyPy 3 | RUNTIME_ERROR | TESTS | 9 | 966 | 14,438,400 | def func(a,x,prev):
s=0
c=0
for i in a[x]:
if i!=prev:
s=s+func(a,i,x)+1
c+=1
if c:
s=s/c
return s
n=int(input())
a=[]
for i in range(n+3):
a.append([])
for i in range(n-1):
b,c=list(map(int,input().split()))
a[b].append(c)
a... | Title: Journey
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There are *n* cities and *n*<=-<=1 roads in the Seven Kingdoms, each road connects two cities and we can reach any city from any other by the roads.
Theon and Yara Greyjoy are on a horse in the first city, they are starting tr... | ```python
def func(a,x,prev):
s=0
c=0
for i in a[x]:
if i!=prev:
s=s+func(a,i,x)+1
c+=1
if c:
s=s/c
return s
n=int(input())
a=[]
for i in range(n+3):
a.append([])
for i in range(n-1):
b,c=list(map(int,input().split()))
a[b].append... | -1 | |
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,691,649,857 | 2,147,483,647 | Python 3 | OK | TESTS | 20 | 46 | 0 | n, m, a = map(int, input().split())
flagstones_length = n // a
if n % a != 0:
flagstones_length += 1
flagstones_width = m // a
if m % a != 0:
flagstones_width += 1
total_flagstones = flagstones_length * flagstones_width
print(total_flagstones)
| Title: Theatre Square
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Theatre Square in the capital city of Berland has a rectangular shape with the size *n*<=×<=*m* meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each ... | ```python
n, m, a = map(int, input().split())
flagstones_length = n // a
if n % a != 0:
flagstones_length += 1
flagstones_width = m // a
if m % a != 0:
flagstones_width += 1
total_flagstones = flagstones_length * flagstones_width
print(total_flagstones)
``` | 3.977 |
350 | A | TL | PROGRAMMING | 1,200 | [
"brute force",
"greedy",
"implementation"
] | null | null | Valera wanted to prepare a Codesecrof round. He's already got one problem and he wants to set a time limit (TL) on it.
Valera has written *n* correct solutions. For each correct solution, he knows its running time (in seconds). Valera has also wrote *m* wrong solutions and for each wrong solution he knows its running ... | The first line contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=100). The second line contains *n* space-separated positive integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100) — the running time of each of the *n* correct solutions in seconds. The third line contains *m* space-separated positive integers *b*1... | If there is a valid TL value, print it. Otherwise, print -1. | [
"3 6\n4 5 2\n8 9 6 10 7 11\n",
"3 1\n3 4 5\n6\n"
] | [
"5",
"-1\n"
] | none | 500 | [
{
"input": "3 6\n4 5 2\n8 9 6 10 7 11",
"output": "5"
},
{
"input": "3 1\n3 4 5\n6",
"output": "-1"
},
{
"input": "2 5\n45 99\n49 41 77 83 45",
"output": "-1"
},
{
"input": "50 50\n18 13 5 34 10 36 36 12 15 11 16 17 14 36 23 45 32 24 31 18 24 32 7 1 31 3 49 8 16 23 3 39 47 43... | 1,561,538,708 | 2,147,483,647 | Python 3 | OK | TESTS | 45 | 218 | 0 | n, m = input().split()
n = int (n)
m = int (m)
#k = int (k)
#s = input()
#n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
#x1, y1, x2, y2 =map(int,input().split())
#n = int(input())
#f = []
#f = [0]*n
#t = [0]*n
#f = []
#h = [""] * n
#f1 = sorted(f, key = lambda tup: tup[... | Title: TL
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Valera wanted to prepare a Codesecrof round. He's already got one problem and he wants to set a time limit (TL) on it.
Valera has written *n* correct solutions. For each correct solution, he knows its running time (in seconds). Val... | ```python
n, m = input().split()
n = int (n)
m = int (m)
#k = int (k)
#s = input()
#n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
#x1, y1, x2, y2 =map(int,input().split())
#n = int(input())
#f = []
#f = [0]*n
#t = [0]*n
#f = []
#h = [""] * n
#f1 = sorted(f, key = lambda... | 3 | |
12 | B | Correct Solution? | PROGRAMMING | 1,100 | [
"implementation",
"sortings"
] | B. Correct Solution? | 2 | 256 | One cold winter evening Alice and her older brother Bob was sitting at home near the fireplace and giving each other interesting problems to solve. When it was Alice's turn, she told the number *n* to Bob and said:
—Shuffle the digits in this number in order to obtain the smallest possible number without leading zeroe... | The first line contains one integer *n* (0<=≤<=*n*<=≤<=109) without leading zeroes. The second lines contains one integer *m* (0<=≤<=*m*<=≤<=109) — Bob's answer, possibly with leading zeroes. | Print OK if Bob's answer is correct and WRONG_ANSWER otherwise. | [
"3310\n1033\n",
"4\n5\n"
] | [
"OK\n",
"WRONG_ANSWER\n"
] | none | 0 | [
{
"input": "3310\n1033",
"output": "OK"
},
{
"input": "4\n5",
"output": "WRONG_ANSWER"
},
{
"input": "40\n04",
"output": "WRONG_ANSWER"
},
{
"input": "12\n12",
"output": "OK"
},
{
"input": "432\n234",
"output": "OK"
},
{
"input": "17109\n01179",
"o... | 1,602,852,628 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 8 | 186 | 0 | n = input()
m = input()
z = n.count('0')
x = ''.join(sorted(n))
ans = x[z] + x[:z] + x[z+1:]
if(ans == m):
print('OK')
else:
print('WRONG_ANSWER')
| Title: Correct Solution?
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
One cold winter evening Alice and her older brother Bob was sitting at home near the fireplace and giving each other interesting problems to solve. When it was Alice's turn, she told the number *n* to Bob and said:
—Shuf... | ```python
n = input()
m = input()
z = n.count('0')
x = ''.join(sorted(n))
ans = x[z] + x[:z] + x[z+1:]
if(ans == m):
print('OK')
else:
print('WRONG_ANSWER')
``` | -1 |
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,649,781,168 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 34 | 124 | 0 |
n = int(input())
scores = {}
while n:
t = input()
if not t in scores.keys():
scores[t] = 1
else:
scores[t]+=1
n -= 1
winner = ""
winner_score = -1
for k, v in scores.items():
if v > winner_score:
winner = k
winner_score = v
print(win... | 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
n = int(input())
scores = {}
while n:
t = input()
if not t in scores.keys():
scores[t] = 1
else:
scores[t]+=1
n -= 1
winner = ""
winner_score = -1
for k, v in scores.items():
if v > winner_score:
winner = k
winner_score = v
... | 3.969 |
753 | A | Santa Claus and Candies | PROGRAMMING | 1,000 | [
"dp",
"greedy",
"math"
] | null | null | Santa Claus has *n* candies, he dreams to give them as gifts to children.
What is the maximal number of children for whose he can give candies if Santa Claus want each kid should get distinct positive integer number of candies. Santa Class wants to give all *n* candies he has. | The only line contains positive integer number *n* (1<=≤<=*n*<=≤<=1000) — number of candies Santa Claus has. | Print to the first line integer number *k* — maximal number of kids which can get candies.
Print to the second line *k* distinct integer numbers: number of candies for each of *k* kid. The sum of *k* printed numbers should be exactly *n*.
If there are many solutions, print any of them. | [
"5\n",
"9\n",
"2\n"
] | [
"2\n2 3\n",
"3\n3 5 1\n",
"1\n2 \n"
] | none | 500 | [
{
"input": "5",
"output": "2\n1 4 "
},
{
"input": "9",
"output": "3\n1 2 6 "
},
{
"input": "2",
"output": "1\n2 "
},
{
"input": "1",
"output": "1\n1 "
},
{
"input": "3",
"output": "2\n1 2 "
},
{
"input": "1000",
"output": "44\n1 2 3 4 5 6 7 8 9 10 ... | 1,588,525,750 | 2,147,483,647 | PyPy 3 | OK | TESTS | 49 | 155 | 1,331,200 | a=int(input())
t=[]
for j in range(1,10000):
if a>=j:
t.append(j)
a-=j
else:
for c in range(len(t)):
if a>0:
t[c]+=1
a-=1
else:
break
for i in range(len(t)):
if t.count(t[i])==2:
... | Title: Santa Claus and Candies
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Santa Claus has *n* candies, he dreams to give them as gifts to children.
What is the maximal number of children for whose he can give candies if Santa Claus want each kid should get distinct positive integer n... | ```python
a=int(input())
t=[]
for j in range(1,10000):
if a>=j:
t.append(j)
a-=j
else:
for c in range(len(t)):
if a>0:
t[c]+=1
a-=1
else:
break
for i in range(len(t)):
if t.count(t[i... | 3 | |
165 | A | Supercentral Point | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | One day Vasya painted a Cartesian coordinate system on a piece of paper and marked some set of points (*x*1,<=*y*1),<=(*x*2,<=*y*2),<=...,<=(*x**n*,<=*y**n*). Let's define neighbors for some fixed point from the given set (*x*,<=*y*):
- point (*x*',<=*y*') is (*x*,<=*y*)'s right neighbor, if *x*'<=><=*x* and *y*'... | The first input line contains the only integer *n* (1<=≤<=*n*<=≤<=200) — the number of points in the given set. Next *n* lines contain the coordinates of the points written as "*x* *y*" (without the quotes) (|*x*|,<=|*y*|<=≤<=1000), all coordinates are integers. The numbers in the line are separated by exactly one spac... | Print the only number — the number of supercentral points of the given set. | [
"8\n1 1\n4 2\n3 1\n1 2\n0 2\n0 1\n1 0\n1 3\n",
"5\n0 0\n0 1\n1 0\n0 -1\n-1 0\n"
] | [
"2\n",
"1\n"
] | In the first sample the supercentral points are only points (1, 1) and (1, 2).
In the second sample there is one supercental point — point (0, 0). | 500 | [
{
"input": "8\n1 1\n4 2\n3 1\n1 2\n0 2\n0 1\n1 0\n1 3",
"output": "2"
},
{
"input": "5\n0 0\n0 1\n1 0\n0 -1\n-1 0",
"output": "1"
},
{
"input": "9\n-565 -752\n-184 723\n-184 -752\n-184 1\n950 723\n-565 723\n950 -752\n950 1\n-565 1",
"output": "1"
},
{
"input": "25\n-651 897\n... | 1,673,527,434 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 26 | 124 | 1,945,600 | n = int(input())
li_li = []
for i in range(n):
x, y = list(map(int, input().split()))
li_li.append([x, y])
ans = 0
for i in range(n):
check_mark = [0] * 4
for j in range(n):
x = li_li[i][0]
y = li_li[i][1]
x_ = li_li[j][0]
y_ = li_li[j][1]
if x == x_:
if y_ > y: # up
... | Title: Supercentral Point
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Vasya painted a Cartesian coordinate system on a piece of paper and marked some set of points (*x*1,<=*y*1),<=(*x*2,<=*y*2),<=...,<=(*x**n*,<=*y**n*). Let's define neighbors for some fixed point from the give... | ```python
n = int(input())
li_li = []
for i in range(n):
x, y = list(map(int, input().split()))
li_li.append([x, y])
ans = 0
for i in range(n):
check_mark = [0] * 4
for j in range(n):
x = li_li[i][0]
y = li_li[i][1]
x_ = li_li[j][0]
y_ = li_li[j][1]
if x == x_:
if y_ > ... | 3 | |
443 | A | Anton and Letters | PROGRAMMING | 800 | [
"constructive algorithms",
"implementation"
] | null | null | Recently, Anton has found a set. The set consists of small English letters. Anton carefully wrote out all the letters from the set in one line, separated by a comma. He also added an opening curved bracket at the beginning of the line and a closing curved bracket at the end of the line.
Unfortunately, from time to ti... | The first and the single line contains the set of letters. The length of the line doesn't exceed 1000. It is guaranteed that the line starts from an opening curved bracket and ends with a closing curved bracket. Between them, small English letters are listed, separated by a comma. Each comma is followed by a space. | Print a single number — the number of distinct letters in Anton's set. | [
"{a, b, c}\n",
"{b, a, b, a}\n",
"{}\n"
] | [
"3\n",
"2\n",
"0\n"
] | none | 500 | [
{
"input": "{a, b, c}",
"output": "3"
},
{
"input": "{b, a, b, a}",
"output": "2"
},
{
"input": "{}",
"output": "0"
},
{
"input": "{a, a, c, b, b, b, c, c, c, c}",
"output": "3"
},
{
"input": "{a, c, b, b}",
"output": "3"
},
{
"input": "{a, b}",
"o... | 1,698,421,151 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 2 | 46 | 0 |
input_line = input().strip()
if not input_line:
print(0)
if not (input_line.startswith('{') and input_line.endswith('}')):
print("Invalid input: Missing opening and/or closing curly braces.")
letters = input_line[1:-1].split(', ')
distinct_letters = set(letters)
print(len(distinct_letters))
... | Title: Anton and Letters
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Recently, Anton has found a set. The set consists of small English letters. Anton carefully wrote out all the letters from the set in one line, separated by a comma. He also added an opening curved bracket at the begi... | ```python
input_line = input().strip()
if not input_line:
print(0)
if not (input_line.startswith('{') and input_line.endswith('}')):
print("Invalid input: Missing opening and/or closing curly braces.")
letters = input_line[1:-1].split(', ')
distinct_letters = set(letters)
print(len(distinct_... | 0 | |
4 | A | Watermelon | PROGRAMMING | 800 | [
"brute force",
"math"
] | A. Watermelon | 1 | 64 | One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem.
Pete and ... | The first (and the only) input line contains integer number *w* (1<=≤<=*w*<=≤<=100) — the weight of the watermelon bought by the boys. | Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case. | [
"8\n"
] | [
"YES\n"
] | For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos). | 0 | [
{
"input": "8",
"output": "YES"
},
{
"input": "5",
"output": "NO"
},
{
"input": "4",
"output": "YES"
},
{
"input": "3",
"output": "NO"
},
{
"input": "2",
"output": "NO"
},
{
"input": "1",
"output": "NO"
},
{
"input": "7",
"output": "NO"... | 1,690,275,065 | 2,147,483,647 | Python 3 | OK | TESTS | 20 | 92 | 0 | k=int(input())
if k%2==0 and k>2:
print("Yes")
else:
print("No")
| Title: Watermelon
Time Limit: 1 seconds
Memory Limit: 64 megabytes
Problem Description:
One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dyin... | ```python
k=int(input())
if k%2==0 and k>2:
print("Yes")
else:
print("No")
``` | 3.954 |
236 | A | Boy or Girl | PROGRAMMING | 800 | [
"brute force",
"implementation",
"strings"
] | null | null | Those days, many boys use beautiful girls' photos as avatars in forums. So it is pretty hard to tell the gender of a user at the first glance. Last year, our hero went to a forum and had a nice chat with a beauty (he thought so). After that they talked very often and eventually they became a couple in the network.
Bu... | The first line contains a non-empty string, that contains only lowercase English letters — the user name. This string contains at most 100 letters. | If it is a female by our hero's method, print "CHAT WITH HER!" (without the quotes), otherwise, print "IGNORE HIM!" (without the quotes). | [
"wjmzbmr\n",
"xiaodao\n",
"sevenkplus\n"
] | [
"CHAT WITH HER!\n",
"IGNORE HIM!\n",
"CHAT WITH HER!\n"
] | For the first example. There are 6 distinct characters in "wjmzbmr". These characters are: "w", "j", "m", "z", "b", "r". So wjmzbmr is a female and you should print "CHAT WITH HER!". | 500 | [
{
"input": "wjmzbmr",
"output": "CHAT WITH HER!"
},
{
"input": "xiaodao",
"output": "IGNORE HIM!"
},
{
"input": "sevenkplus",
"output": "CHAT WITH HER!"
},
{
"input": "pezu",
"output": "CHAT WITH HER!"
},
{
"input": "wnemlgppy",
"output": "CHAT WITH HER!"
},... | 1,696,587,385 | 2,147,483,647 | Python 3 | OK | TESTS | 85 | 92 | 0 | s=list(input())
r=len(set(s))
if(r%2==0):
print("CHAT WITH HER!")
else:
print("IGNORE HIM!") | Title: Boy or Girl
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Those days, many boys use beautiful girls' photos as avatars in forums. So it is pretty hard to tell the gender of a user at the first glance. Last year, our hero went to a forum and had a nice chat with a beauty (he though... | ```python
s=list(input())
r=len(set(s))
if(r%2==0):
print("CHAT WITH HER!")
else:
print("IGNORE HIM!")
``` | 3 | |
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,680,916,577 | 2,147,483,647 | Python 3 | OK | TESTS | 44 | 122 | 0 | from math import pi
n = int(input())
r = sorted(map(int, input().split()), reverse=True)
ans = 0
for i in range(n):
if i % 2 == 0:
ans += r[i] ** 2
else:
ans -= r[i] ** 2
print(ans * pi) | 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
from math import pi
n = int(input())
r = sorted(map(int, input().split()), reverse=True)
ans = 0
for i in range(n):
if i % 2 == 0:
ans += r[i] ** 2
else:
ans -= r[i] ** 2
print(ans * pi)
``` | 3 | |
727 | C | Guess the Array | PROGRAMMING | 1,400 | [
"constructive algorithms",
"interactive",
"math"
] | null | null | This is an interactive problem. You should use flush operation after each printed line. For example, in C++ you should use fflush(stdout), in Java you should use System.out.flush(), and in Pascal — flush(output).
In this problem you should guess an array *a* which is unknown for you. The only information you have init... | none | none | [
"5\n \n9\n \n7\n \n9\n \n11\n \n6\n "
] | [
"? 1 5\n \n? 2 3\n \n? 4 1\n \n? 5 2\n \n? 3 4\n \n! 4 6 1 5 5"
] | The format of a test to make a hack is:
- The first line contains an integer number *n* (3 ≤ *n* ≤ 5000) — the length of the array.- The second line contains *n* numbers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-inde... | 1,500 | [
{
"input": "5\n4 6 1 5 5",
"output": "5 out of 5"
},
{
"input": "3\n1 1 1",
"output": "3 out of 3"
},
{
"input": "4\n100 1 100 1",
"output": "4 out of 4"
},
{
"input": "10\n9 5 10 7 4 4 8 5 10 5",
"output": "10 out of 10"
},
{
"input": "3\n1 1 1",
"output": "3... | 1,634,243,151 | 2,147,483,647 | Python 3 | OK | TESTS | 36 | 202 | 204,800 | n = int(input())
lst = []
print("? 1 2")
apb = int(input())
print("? 2 3")
bpc = int(input())
print("? 1 3")
apc = int(input())
lst.append(int((apb+apc-bpc)/2))
lst.append(apb - lst[0])
lst.append(bpc - lst[1])
for i in range(3, n):
print(f"? {i} {i+1}")
sum = int(input())
lst.append(sum - lst... | Title: Guess the Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
This is an interactive problem. You should use flush operation after each printed line. For example, in C++ you should use fflush(stdout), in Java you should use System.out.flush(), and in Pascal — flush(output).
In th... | ```python
n = int(input())
lst = []
print("? 1 2")
apb = int(input())
print("? 2 3")
bpc = int(input())
print("? 1 3")
apc = int(input())
lst.append(int((apb+apc-bpc)/2))
lst.append(apb - lst[0])
lst.append(bpc - lst[1])
for i in range(3, n):
print(f"? {i} {i+1}")
sum = int(input())
lst.append... | 3 | |
731 | A | Night at the Museum | PROGRAMMING | 800 | [
"implementation",
"strings"
] | null | null | Grigoriy, like the hero of one famous comedy film, found a job as a night security guard at the museum. At first night he received embosser and was to take stock of the whole exposition.
Embosser is a special devise that allows to "print" the text of a plastic tape. Text is printed sequentially, character by character... | The only line of input contains the name of some exhibit — the non-empty string consisting of no more than 100 characters. It's guaranteed that the string consists of only lowercase English letters. | Print one integer — the minimum number of rotations of the wheel, required to print the name given in the input. | [
"zeus\n",
"map\n",
"ares\n"
] | [
"18\n",
"35\n",
"34\n"
] | To print the string from the first sample it would be optimal to perform the following sequence of rotations:
1. from 'a' to 'z' (1 rotation counterclockwise), 1. from 'z' to 'e' (5 clockwise rotations), 1. from 'e' to 'u' (10 rotations counterclockwise), 1. from 'u' to 's' (2 counterclockwise rotations). | 500 | [
{
"input": "zeus",
"output": "18"
},
{
"input": "map",
"output": "35"
},
{
"input": "ares",
"output": "34"
},
{
"input": "l",
"output": "11"
},
{
"input": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuv",
"... | 1,680,501,056 | 2,147,483,647 | Python 3 | OK | TESTS | 44 | 46 | 0 | def solve(string):
result = 0
prev = 'a'
for char in string:
diff = abs(ord(prev) - ord(char))
result += min(26 - diff, diff)
prev = char
return result
def main():
t = 1 #int(input())
for _ in range(t):
print(solve(input()))
main() | Title: Night at the Museum
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Grigoriy, like the hero of one famous comedy film, found a job as a night security guard at the museum. At first night he received embosser and was to take stock of the whole exposition.
Embosser is a special devis... | ```python
def solve(string):
result = 0
prev = 'a'
for char in string:
diff = abs(ord(prev) - ord(char))
result += min(26 - diff, diff)
prev = char
return result
def main():
t = 1 #int(input())
for _ in range(t):
print(solve(input()))
main()
``... | 3 | |
180 | C | Letter | PROGRAMMING | 1,400 | [
"dp"
] | null | null | Patrick has just finished writing a message to his sweetheart Stacey when he noticed that the message didn't look fancy. Patrick was nervous while writing the message, so some of the letters there were lowercase and some of them were uppercase.
Patrick believes that a message is fancy if any uppercase letter stands to... | The only line of the input contains a non-empty string consisting of uppercase and lowercase letters. The string's length does not exceed 105. | Print a single number — the least number of actions needed to make the message fancy. | [
"PRuvetSTAaYA\n",
"OYPROSTIYAOPECHATALSYAPRIVETSTASYA\n",
"helloworld\n"
] | [
"5\n",
"0\n",
"0\n"
] | none | 0 | [
{
"input": "PRuvetSTAaYA",
"output": "5"
},
{
"input": "OYPROSTIYAOPECHATALSYAPRIVETSTASYA",
"output": "0"
},
{
"input": "helloworld",
"output": "0"
},
{
"input": "P",
"output": "0"
},
{
"input": "t",
"output": "0"
},
{
"input": "XdJ",
"output": "1... | 1,631,600,450 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 0 | 122 | 20,172,800 | f = input().strip()
long = len(f) + 1
up,low = [0] * long,[0] * long
long -= 1
for i in range(long):
if f[i].isupper:
up[i] = up[i - 1] + 1
low[i] = low[i - 1]
else:
low[i] = low[i - 1] + 1
up[i] = up[i - 1]
print(min([low[i] + up[long - 1] - up[i]for i in range(long)]... | Title: Letter
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Patrick has just finished writing a message to his sweetheart Stacey when he noticed that the message didn't look fancy. Patrick was nervous while writing the message, so some of the letters there were lowercase and some of them... | ```python
f = input().strip()
long = len(f) + 1
up,low = [0] * long,[0] * long
long -= 1
for i in range(long):
if f[i].isupper:
up[i] = up[i - 1] + 1
low[i] = low[i - 1]
else:
low[i] = low[i - 1] + 1
up[i] = up[i - 1]
print(min([low[i] + up[long - 1] - up[i]for i in ra... | 0 | |
138 | A | Literature Lesson | PROGRAMMING | 1,600 | [
"implementation"
] | null | null | Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their ... | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=2500, 1<=≤<=*k*<=≤<=5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4*n* lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If ... | Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes. | [
"1 1\nday\nmay\nsun\nfun\n",
"1 1\nday\nmay\ngray\nway\n",
"2 1\na\na\na\na\na\na\ne\ne\n",
"2 1\nday\nmay\nsun\nfun\ntest\nhill\nfest\nthrill\n"
] | [
"aabb\n",
"aaaa\n",
"aabb\n",
"NO\n"
] | In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO". | 500 | [
{
"input": "1 1\nday\nmay\nsun\nfun",
"output": "aabb"
},
{
"input": "1 1\nday\nmay\ngray\nway",
"output": "aaaa"
},
{
"input": "2 1\na\na\na\na\na\na\ne\ne",
"output": "aabb"
},
{
"input": "2 1\nday\nmay\nsun\nfun\ntest\nhill\nfest\nthrill",
"output": "NO"
},
{
"... | 1,649,305,490 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 0 | 62 | 0 | n,k=map(int,input().split())
if k<=n-n//2:
print((k-1)*2+1)
else:
print((k-n+n//2)*2)
| Title: Literature Lesson
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin lett... | ```python
n,k=map(int,input().split())
if k<=n-n//2:
print((k-1)*2+1)
else:
print((k-n+n//2)*2)
``` | 0 | |
689 | B | Mike and Shortcuts | PROGRAMMING | 1,600 | [
"dfs and similar",
"graphs",
"greedy",
"shortest paths"
] | null | null | Recently, Mike was very busy with studying for exams and contests. Now he is going to chill a bit by doing some sight seeing in the city.
City consists of *n* intersections numbered from 1 to *n*. Mike starts walking from his house located at the intersection number 1 and goes along some sequence of intersections. Wal... | The first line contains an integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of Mike's city intersection.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (*i*<=≤<=*a**i*<=≤<=*n* , , describing shortcuts of Mike's city, allowing to walk from intersection *i* to intersection *a**i* using only 1 unit of ... | In the only line print *n* integers *m*1,<=*m*2,<=...,<=*m**n*, where *m**i* denotes the least amount of total energy required to walk from intersection 1 to intersection *i*. | [
"3\n2 2 3\n",
"5\n1 2 3 4 5\n",
"7\n4 4 4 4 7 7 7\n"
] | [
"0 1 2 \n",
"0 1 2 3 4 \n",
"0 1 2 1 2 3 3 \n"
] | In the first sample case desired sequences are:
1: 1; *m*<sub class="lower-index">1</sub> = 0;
2: 1, 2; *m*<sub class="lower-index">2</sub> = 1;
3: 1, 3; *m*<sub class="lower-index">3</sub> = |3 - 1| = 2.
In the second sample case the sequence for any intersection 1 < *i* is always 1, *i* and *m*<sub class="lowe... | 1,000 | [
{
"input": "3\n2 2 3",
"output": "0 1 2 "
},
{
"input": "5\n1 2 3 4 5",
"output": "0 1 2 3 4 "
},
{
"input": "7\n4 4 4 4 7 7 7",
"output": "0 1 2 1 2 3 3 "
},
{
"input": "98\n17 17 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 57 87 87... | 1,621,627,614 | 2,147,483,647 | Python 3 | OK | TESTS | 54 | 545 | 17,100,800 | def amount_of_total_energy(n, a):
dist = [-1] * n
dist[0] = 0
pos = [0]
for u in pos:
for v in [u - 1, u + 1, a[u] - 1]:
if v >= 0 and v < n and dist[v] == -1:
dist[v] = dist[u] + 1
pos.append(v)
return dist
n = int(input())
a = list(map(int,input().spl... | Title: Mike and Shortcuts
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Recently, Mike was very busy with studying for exams and contests. Now he is going to chill a bit by doing some sight seeing in the city.
City consists of *n* intersections numbered from 1 to *n*. Mike starts walkin... | ```python
def amount_of_total_energy(n, a):
dist = [-1] * n
dist[0] = 0
pos = [0]
for u in pos:
for v in [u - 1, u + 1, a[u] - 1]:
if v >= 0 and v < n and dist[v] == -1:
dist[v] = dist[u] + 1
pos.append(v)
return dist
n = int(input())
a = list(map(int,i... | 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,696,023,053 | 2,147,483,647 | Python 3 | OK | TESTS | 101 | 92 | 0 | # The idea behind this problem is as follows:
# Get [1] the index value and [2] the int value of a number.
# Turn the index value into a number.
# Assign the index value to its corrosponding int value in a list.
# Example:
# 2 3 4 1.
# 2 is in position 1. Flip. #1 is assigned to position 2.
# 3 is in position ... | 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
# The idea behind this problem is as follows:
# Get [1] the index value and [2] the int value of a number.
# Turn the index value into a number.
# Assign the index value to its corrosponding int value in a list.
# Example:
# 2 3 4 1.
# 2 is in position 1. Flip. #1 is assigned to position 2.
# 3 is in... | 3 | |
929 | C | Красивая команда | PROGRAMMING | 1,700 | [
"*special",
"combinatorics",
"math"
] | null | null | Завтра у хоккейной команды, которой руководит Евгений, важный матч. Евгению нужно выбрать шесть игроков, которые выйдут на лед в стартовом составе: один вратарь, два защитника и три нападающих.
Так как это стартовый состав, Евгения больше волнует, насколько красива будет команда на льду, чем способности игроков. А име... | Первая строка содержит три целых числа *g*, *d* и *f* (1<=≤<=*g*<=≤<=1<=000, 1<=≤<=*d*<=≤<=1<=000, 1<=≤<=*f*<=≤<=1<=000) — число вратарей, защитников и нападающих в команде Евгения.
Вторая строка содержит *g* целых чисел, каждое в пределах от 1 до 100<=000 — номера вратарей.
Третья строка содержит *d* целых чисел, к... | Выведите одно целое число — количество возможных стартовых составов. | [
"1 2 3\n15\n10 19\n20 11 13\n",
"2 3 4\n16 40\n20 12 19\n13 21 11 10\n"
] | [
"1\n",
"6\n"
] | В первом примере всего один вариант для выбора состава, который удовлетворяет описанным условиям, поэтому ответ 1.
Во втором примере подходят следующие игровые сочетания (в порядке вратарь-защитник-защитник-нападающий-нападающий-нападающий):
- 16 20 12 13 21 11 - 16 20 12 13 11 10 - 16 20 19 13 21 11 - 16 20 19 1... | 1,750 | [
{
"input": "1 2 3\n15\n10 19\n20 11 13",
"output": "1"
},
{
"input": "2 3 4\n16 40\n20 12 19\n13 21 11 10",
"output": "6"
},
{
"input": "4 4 5\n15 16 19 6\n8 11 9 18\n5 3 1 12 14",
"output": "0"
},
{
"input": "6 7 7\n32 35 26 33 16 23\n4 40 36 12 28 24 3\n39 11 31 37 1 25 6",... | 1,520,046,055 | 41,155 | Python 3 | TIME_LIMIT_EXCEEDED | PRETESTS | 5 | 1,000 | 19,251,200 | def cmp(a, b):
diff = a - b
if diff > 0:
return diff <= b
else:
return diff <= a
def istr(x, lst):
tmp_min = min(lst)
tmp_max = max(lst)
tmp_x = x
if tmp_x > tmp_max:
tmp_max, tmp_x = tmp_x, tmp_max
if tmp_x < tmp_min:
tmp_min, tmp_x = tmp... | Title: Красивая команда
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Завтра у хоккейной команды, которой руководит Евгений, важный матч. Евгению нужно выбрать шесть игроков, которые выйдут на лед в стартовом составе: один вратарь, два защитника и три нападающих.
Так как это стартовый с... | ```python
def cmp(a, b):
diff = a - b
if diff > 0:
return diff <= b
else:
return diff <= a
def istr(x, lst):
tmp_min = min(lst)
tmp_max = max(lst)
tmp_x = x
if tmp_x > tmp_max:
tmp_max, tmp_x = tmp_x, tmp_max
if tmp_x < tmp_min:
tmp_min, t... | 0 | |
492 | B | Vanya and Lanterns | PROGRAMMING | 1,200 | [
"binary search",
"implementation",
"math",
"sortings"
] | null | null | Vanya walks late at night along a straight street of length *l*, lit by *n* lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the point *l*. Then the *i*-th lantern is at the point *a**i*. The lantern lights all points of the street that... | The first line contains two integers *n*, *l* (1<=≤<=*n*<=≤<=1000, 1<=≤<=*l*<=≤<=109) — the number of lanterns and the length of the street respectively.
The next line contains *n* integers *a**i* (0<=≤<=*a**i*<=≤<=*l*). Multiple lanterns can be located at the same point. The lanterns may be located at the ends of th... | Print the minimum light radius *d*, needed to light the whole street. The answer will be considered correct if its absolute or relative error doesn't exceed 10<=-<=9. | [
"7 15\n15 5 3 7 9 14 0\n",
"2 5\n2 5\n"
] | [
"2.5000000000\n",
"2.0000000000\n"
] | Consider the second sample. At *d* = 2 the first lantern will light the segment [0, 4] of the street, and the second lantern will light segment [3, 5]. Thus, the whole street will be lit. | 1,000 | [
{
"input": "7 15\n15 5 3 7 9 14 0",
"output": "2.5000000000"
},
{
"input": "2 5\n2 5",
"output": "2.0000000000"
},
{
"input": "46 615683844\n431749087 271781274 274974690 324606253 480870261 401650581 13285442 478090364 266585394 425024433 588791449 492057200 391293435 563090494 317950 1... | 1,696,344,420 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 32 | 46 | 0 | n, l = map(int, input().split())
a = sorted(map(int, input().split()))
distances = [2*a[0], 2*(l-a[-1])]
for i in range(len(a)-1):
distances.append((a[i+1] - a[i]))
print(max(distances) / 2)
| Title: Vanya and Lanterns
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vanya walks late at night along a straight street of length *l*, lit by *n* lanterns. Consider the coordinate system with the beginning of the street corresponding to the point 0, and its end corresponding to the poi... | ```python
n, l = map(int, input().split())
a = sorted(map(int, input().split()))
distances = [2*a[0], 2*(l-a[-1])]
for i in range(len(a)-1):
distances.append((a[i+1] - a[i]))
print(max(distances) / 2)
``` | 3 | |
40 | A | Find Color | PROGRAMMING | 1,300 | [
"constructive algorithms",
"geometry",
"implementation",
"math"
] | A. Find Color | 2 | 256 | Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin correspond... | The first and single line contains two integers *x* and *y* — the coordinates of the hole made in the clock by the ball. Each of the numbers *x* and *y* has an absolute value that does not exceed 1000. | Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black. | [
"-2 1\n",
"2 1\n",
"4 3\n"
] | [
"white\n",
"black\n",
"black\n"
] | none | 500 | [
{
"input": "-2 1",
"output": "white"
},
{
"input": "2 1",
"output": "black"
},
{
"input": "4 3",
"output": "black"
},
{
"input": "3 3",
"output": "black"
},
{
"input": "4 4",
"output": "white"
},
{
"input": "-4 4",
"output": "black"
},
{
"i... | 1,638,021,900 | 2,147,483,647 | Python 3 | OK | TESTS | 70 | 122 | 0 | #!/usr/bin/env python
# coding=utf-8
'''
Author: Deean
Date: 2021-11-27 21:52:28
LastEditTime: 2021-11-27 22:03:15
Description: Find Color
FilePath: CF40A.py
'''
def func():
x, y = map(int, input().strip().split())
radius = (x * x + y * y) ** 0.5
if radius % 1 == 0:
print("black")
elif x * y >... | Title: Find Color
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. Th... | ```python
#!/usr/bin/env python
# coding=utf-8
'''
Author: Deean
Date: 2021-11-27 21:52:28
LastEditTime: 2021-11-27 22:03:15
Description: Find Color
FilePath: CF40A.py
'''
def func():
x, y = map(int, input().strip().split())
radius = (x * x + y * y) ** 0.5
if radius % 1 == 0:
print("black")
el... | 3.9695 |
0 | none | none | none | 0 | [
"none"
] | null | null | Let's assume that
- *v*(*n*) is the largest prime number, that does not exceed *n*;- *u*(*n*) is the smallest prime number strictly greater than *n*.
Find . | The first line contains integer *t* (1<=≤<=*t*<=≤<=500) — the number of testscases.
Each of the following *t* lines of the input contains integer *n* (2<=≤<=*n*<=≤<=109). | Print *t* lines: the *i*-th of them must contain the answer to the *i*-th test as an irreducible fraction "*p*/*q*", where *p*,<=*q* are integers, *q*<=><=0. | [
"2\n2\n3\n"
] | [
"1/6\n7/30\n"
] | none | 0 | [
{
"input": "2\n2\n3",
"output": "1/6\n7/30"
},
{
"input": "1\n1000000000",
"output": "999999941999999673/1999999887999999118"
},
{
"input": "5\n3\n6\n9\n10\n5",
"output": "7/30\n5/14\n61/154\n9/22\n23/70"
},
{
"input": "5\n5\n8\n18\n17\n17",
"output": "23/70\n59/154\n17/3... | 1,689,644,099 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 0 | 46 | 0 | print("_RANDOM_GUESS_1689644099.3308754")# 1689644099.3308961 | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Let's assume that
- *v*(*n*) is the largest prime number, that does not exceed *n*;- *u*(*n*) is the smallest prime number strictly greater than *n*.
Find .
Input Specification:
The first line contains integer *t* (1<=≤<=*t*... | ```python
print("_RANDOM_GUESS_1689644099.3308754")# 1689644099.3308961
``` | 0 | |
251 | A | Points on Line | PROGRAMMING | 1,300 | [
"binary search",
"combinatorics",
"two pointers"
] | null | null | Little Petya likes points a lot. Recently his mom has presented him *n* points lying on the line *OX*. Now Petya is wondering in how many ways he can choose three distinct points so that the distance between the two farthest of them doesn't exceed *d*.
Note that the order of the points inside the group of three chosen... | The first line contains two integers: *n* and *d* (1<=≤<=*n*<=≤<=105; 1<=≤<=*d*<=≤<=109). The next line contains *n* integers *x*1,<=*x*2,<=...,<=*x**n*, their absolute value doesn't exceed 109 — the *x*-coordinates of the points that Petya has got.
It is guaranteed that the coordinates of the points in the input stri... | Print a single integer — the number of groups of three points, where the distance between two farthest points doesn't exceed *d*.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier. | [
"4 3\n1 2 3 4\n",
"4 2\n-3 -2 -1 0\n",
"5 19\n1 10 20 30 50\n"
] | [
"4\n",
"2\n",
"1\n"
] | In the first sample any group of three points meets our conditions.
In the seconds sample only 2 groups of three points meet our conditions: {-3, -2, -1} and {-2, -1, 0}.
In the third sample only one group does: {1, 10, 20}. | 500 | [
{
"input": "4 3\n1 2 3 4",
"output": "4"
},
{
"input": "4 2\n-3 -2 -1 0",
"output": "2"
},
{
"input": "5 19\n1 10 20 30 50",
"output": "1"
},
{
"input": "10 5\n31 36 43 47 48 50 56 69 71 86",
"output": "2"
},
{
"input": "10 50\n1 4 20 27 65 79 82 83 99 100",
"... | 1,630,481,463 | 2,147,483,647 | PyPy 3 | OK | TESTS | 39 | 498 | 31,539,200 |
import math
from collections import Counter
import bisect
n, d = map(int, input().split())
x = list(map(int, input().split()))
ways = 0
for i in range(n - 2) :
y = bisect.bisect_right(x, x[i] + d)
ways += max(0, ((y - i - 2) * (y - i - 1)) // 2)
print(ways)
| Title: Points on Line
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little Petya likes points a lot. Recently his mom has presented him *n* points lying on the line *OX*. Now Petya is wondering in how many ways he can choose three distinct points so that the distance between the two fart... | ```python
import math
from collections import Counter
import bisect
n, d = map(int, input().split())
x = list(map(int, input().split()))
ways = 0
for i in range(n - 2) :
y = bisect.bisect_right(x, x[i] + d)
ways += max(0, ((y - i - 2) * (y - i - 1)) // 2)
print(ways)
``` | 3 | |
976 | B | Lara Croft and the New Game | PROGRAMMING | 1,300 | [
"implementation",
"math"
] | null | null | You might have heard about the next game in Lara Croft series coming out this year. You also might have watched its trailer. Though you definitely missed the main idea about its plot, so let me lift the veil of secrecy.
Lara is going to explore yet another dangerous dungeon. Game designers decided to use good old 2D e... | The only line contains three integers *n*, *m* and *k* (2<=≤<=*n*,<=*m*<=≤<=109, *n* is always even, 0<=≤<=*k*<=<<=*n*·*m*). Note that *k* doesn't fit into 32-bit integer type! | Print the cell (the row and the column where the cell is situated) where Lara ends up after she moves *k* times. | [
"4 3 0\n",
"4 3 11\n",
"4 3 7\n"
] | [
"1 1\n",
"1 2\n",
"3 2\n"
] | Here is her path on matrix 4 by 3: | 0 | [
{
"input": "4 3 0",
"output": "1 1"
},
{
"input": "4 3 11",
"output": "1 2"
},
{
"input": "4 3 7",
"output": "3 2"
},
{
"input": "1000000000 2 1999999999",
"output": "1 2"
},
{
"input": "1000000000 1000000000 999999999999999999",
"output": "1 2"
},
{
"... | 1,525,106,396 | 7,196 | Python 3 | CHALLENGED | CHALLENGES | 8 | 78 | 7,065,600 | n,m,a=map(int,input().split())
if a<n:
print(a+1,1)
elif a==n and n!=1:
print(a,2)
else:
a=a-n
aa=a//(m-1)
so=n-aa
ab=a%(m-1)
if aa%2==0:
sa=1+ab
else:
sa=m-ab
if so<1:
so=1
if n%2==0:
sa=2
else:
sa=m
... | Title: Lara Croft and the New Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You might have heard about the next game in Lara Croft series coming out this year. You also might have watched its trailer. Though you definitely missed the main idea about its plot, so let me lift the veil... | ```python
n,m,a=map(int,input().split())
if a<n:
print(a+1,1)
elif a==n and n!=1:
print(a,2)
else:
a=a-n
aa=a//(m-1)
so=n-aa
ab=a%(m-1)
if aa%2==0:
sa=1+ab
else:
sa=m-ab
if so<1:
so=1
if n%2==0:
sa=2
else:
... | -1 | |
50 | A | Domino piling | PROGRAMMING | 800 | [
"greedy",
"math"
] | A. Domino piling | 2 | 256 | You are given a rectangular board of *M*<=×<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=×<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions:
1. Each domino completely covers ... | In a single line you are given two integers *M* and *N* — board sizes in squares (1<=≤<=*M*<=≤<=*N*<=≤<=16). | Output one number — the maximal number of dominoes, which can be placed. | [
"2 4\n",
"3 3\n"
] | [
"4\n",
"4\n"
] | none | 500 | [
{
"input": "2 4",
"output": "4"
},
{
"input": "3 3",
"output": "4"
},
{
"input": "1 5",
"output": "2"
},
{
"input": "1 6",
"output": "3"
},
{
"input": "1 15",
"output": "7"
},
{
"input": "1 16",
"output": "8"
},
{
"input": "2 5",
"outpu... | 1,611,772,960 | 2,147,483,647 | PyPy 3 | RUNTIME_ERROR | TESTS | 0 | 218 | 2,252,800 | m=input()
#print (int(m[0]*m[1]/2))
print(type(int(m[1]))) | Title: Domino piling
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
You are given a rectangular board of *M*<=×<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=×<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as p... | ```python
m=input()
#print (int(m[0]*m[1]/2))
print(type(int(m[1])))
``` | -1 |
579 | A | Raising Bacteria | PROGRAMMING | 1,000 | [
"bitmasks"
] | null | null | You are a lover of bacteria. You want to raise some bacteria in a box.
Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split into two bacteria. You hope to see exactly *x* bacteria in the box at some moment.
What is the mini... | The only line containing one integer *x* (1<=≤<=*x*<=≤<=109). | The only line containing one integer: the answer. | [
"5\n",
"8\n"
] | [
"2\n",
"1\n"
] | For the first sample, we can add one bacterium in the box in the first day morning and at the third morning there will be 4 bacteria in the box. Now we put one more resulting 5 in the box. We added 2 bacteria in the process so the answer is 2.
For the second sample, we can put one in the first morning and in the 4-th ... | 250 | [
{
"input": "5",
"output": "2"
},
{
"input": "8",
"output": "1"
},
{
"input": "536870911",
"output": "29"
},
{
"input": "1",
"output": "1"
},
{
"input": "343000816",
"output": "14"
},
{
"input": "559980448",
"output": "12"
},
{
"input": "697... | 1,661,083,196 | 2,147,483,647 | Python 3 | OK | TESTS | 36 | 46 | 0 | from math import log2
m = int(input())
i = 0
while m > 0:
m -= pow(2,int(log2(m)))
i += 1
print(i) | Title: Raising Bacteria
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are a lover of bacteria. You want to raise some bacteria in a box.
Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split... | ```python
from math import log2
m = int(input())
i = 0
while m > 0:
m -= pow(2,int(log2(m)))
i += 1
print(i)
``` | 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,571,388,182 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 0 | 92 | 0 | a=int(input())
b=int(input())
if a>b:
k=a-b
if k%2==0:
j=k//2
else:
j=(k//2)+1
x=0
for v in range(j,1,-1):
x=x+v
y=0
for s in range (j-1,1,-1):
y=y+s
print(x+y)
else:
k=b-a
if k%2==0:
j=k//2
else:
j=(k//2)+1
... | 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())
if a>b:
k=a-b
if k%2==0:
j=k//2
else:
j=(k//2)+1
x=0
for v in range(j,1,-1):
x=x+v
y=0
for s in range (j-1,1,-1):
y=y+s
print(x+y)
else:
k=b-a
if k%2==0:
j=k//2
else:
j... | 0 | |
855 | A | Tom Riddle's Diary | PROGRAMMING | 800 | [
"brute force",
"implementation",
"strings"
] | null | null | Harry Potter is on a mission to destroy You-Know-Who's Horcruxes. The first Horcrux that he encountered in the Chamber of Secrets is Tom Riddle's diary. The diary was with Ginny and it forced her to open the Chamber of Secrets. Harry wants to know the different people who had ever possessed the diary to make sure they ... | First line of input contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of names in the list.
Next *n* lines each contain a string *s**i*, consisting of lowercase English letters. The length of each string is between 1 and 100. | Output *n* lines each containing either "YES" or "NO" (without quotes), depending on whether this string was already present in the stream or not.
You can print each letter in any case (upper or lower). | [
"6\ntom\nlucius\nginny\nharry\nginny\nharry\n",
"3\na\na\na\n"
] | [
"NO\nNO\nNO\nNO\nYES\nYES\n",
"NO\nYES\nYES\n"
] | In test case 1, for *i* = 5 there exists *j* = 3 such that *s*<sub class="lower-index">*i*</sub> = *s*<sub class="lower-index">*j*</sub> and *j* < *i*, which means that answer for *i* = 5 is "YES". | 500 | [
{
"input": "6\ntom\nlucius\nginny\nharry\nginny\nharry",
"output": "NO\nNO\nNO\nNO\nYES\nYES"
},
{
"input": "3\na\na\na",
"output": "NO\nYES\nYES"
},
{
"input": "1\nzn",
"output": "NO"
},
{
"input": "9\nliyzmbjwnzryjokufuxcqtzwworjeoxkbaqrujrhdidqdvwdfzilwszgnzglnnbogaclckfnb... | 1,586,279,258 | 2,147,483,647 | Python 3 | OK | TESTS | 55 | 109 | 307,200 | l = []
n = (int(input()))
for i in range(n):
s = input()
print('Yes' if s in l else 'No')
l.append(s) | Title: Tom Riddle's Diary
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Harry Potter is on a mission to destroy You-Know-Who's Horcruxes. The first Horcrux that he encountered in the Chamber of Secrets is Tom Riddle's diary. The diary was with Ginny and it forced her to open the Chamber ... | ```python
l = []
n = (int(input()))
for i in range(n):
s = input()
print('Yes' if s in l else 'No')
l.append(s)
``` | 3 | |
445 | A | DZY Loves Chessboard | PROGRAMMING | 1,200 | [
"dfs and similar",
"implementation"
] | null | null | DZY loves chessboard, and he enjoys playing with it.
He has a chessboard of *n* rows and *m* columns. Some cells of the chessboard are bad, others are good. For every good cell, DZY wants to put a chessman on it. Each chessman is either white or black. After putting all chessmen, DZY wants that no two chessmen with th... | The first line contains two space-separated integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100).
Each of the next *n* lines contains a string of *m* characters: the *j*-th character of the *i*-th string is either "." or "-". A "." means that the corresponding cell (in the *i*-th row and the *j*-th column) is good, while a ... | Output must contain *n* lines, each line must contain a string of *m* characters. The *j*-th character of the *i*-th string should be either "W", "B" or "-". Character "W" means the chessman on the cell is white, "B" means it is black, "-" means the cell is a bad cell.
If multiple answers exist, print any of them. It ... | [
"1 1\n.\n",
"2 2\n..\n..\n",
"3 3\n.-.\n---\n--."
] | [
"B\n",
"BW\nWB\n",
"B-B\n---\n--B"
] | In the first sample, DZY puts a single black chessman. Of course putting a white one is also OK.
In the second sample, all 4 cells are good. No two same chessmen share an edge in the sample output.
In the third sample, no good cells are adjacent. So you can just put 3 chessmen, no matter what their colors are. | 500 | [
{
"input": "1 1\n.",
"output": "B"
},
{
"input": "2 2\n..\n..",
"output": "BW\nWB"
},
{
"input": "3 3\n.-.\n---\n--.",
"output": "B-B\n---\n--B"
},
{
"input": "3 1\n-\n.\n.",
"output": "-\nW\nB"
},
{
"input": "11 11\n-----------\n-----------\n-----------\n--------... | 1,620,399,910 | 2,147,483,647 | Python 3 | OK | TESTS | 37 | 77 | 7,065,600 | n, m = input().split()
board = []
for i in range(int(n)):
s = list(input())
board.append(s)
color = ['B', 'W']
k = 0
for y in range(int(n)):
for x in range(int(m)):
if board[y][x] == '.':
board[y][x] = color[k]
k = 1 - k
if int(m) % 2 == 0:
k = 1 - k
for... | Title: DZY Loves Chessboard
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
DZY loves chessboard, and he enjoys playing with it.
He has a chessboard of *n* rows and *m* columns. Some cells of the chessboard are bad, others are good. For every good cell, DZY wants to put a chessman on it. ... | ```python
n, m = input().split()
board = []
for i in range(int(n)):
s = list(input())
board.append(s)
color = ['B', 'W']
k = 0
for y in range(int(n)):
for x in range(int(m)):
if board[y][x] == '.':
board[y][x] = color[k]
k = 1 - k
if int(m) % 2 == 0:
k = ... | 3 | |
922 | D | Robot Vacuum Cleaner | PROGRAMMING | 1,800 | [
"greedy",
"sortings"
] | null | null | Pushok the dog has been chasing Imp for a few hours already.
Fortunately, Imp knows that Pushok is afraid of a robot vacuum cleaner.
While moving, the robot generates a string *t* consisting of letters 's' and 'h', that produces a lot of noise. We define noise of string *t* as the number of occurrences of string "sh... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of strings in robot's memory.
Next *n* lines contain the strings *t*1,<=*t*2,<=...,<=*t**n*, one per line. It is guaranteed that the strings are non-empty, contain only English letters 's' and 'h' and their total length does not exceed 105. | Print a single integer — the maxumum possible noise Imp can achieve by changing the order of the strings. | [
"4\nssh\nhs\ns\nhhhs\n",
"2\nh\ns\n"
] | [
"18\n",
"1\n"
] | The optimal concatenation in the first sample is *ssshhshhhs*. | 1,500 | [
{
"input": "4\nssh\nhs\ns\nhhhs",
"output": "18"
},
{
"input": "2\nh\ns",
"output": "1"
},
{
"input": "6\nh\ns\nhhh\nh\nssssss\ns",
"output": "40"
},
{
"input": "1\ns",
"output": "0"
},
{
"input": "10\nsshshss\nhssssssssh\nhhhhhh\nhhhs\nhshhh\nhhhhshsh\nhh\nh\nshs... | 1,655,194,372 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 46 | 0 | import functools
n = 4
a = ["ssh", "hs", "s", "hhhs"]
def count(s):
cnt = 0
ps = 0
for c in s:
if c == 'h':
cnt += ps
else:
ps += 1
return cnt
def cmp(x, y):
if count(x + y) > count(y + x):
return -1
else:
return 1... | Title: Robot Vacuum Cleaner
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Pushok the dog has been chasing Imp for a few hours already.
Fortunately, Imp knows that Pushok is afraid of a robot vacuum cleaner.
While moving, the robot generates a string *t* consisting of letters 's' and '... | ```python
import functools
n = 4
a = ["ssh", "hs", "s", "hhhs"]
def count(s):
cnt = 0
ps = 0
for c in s:
if c == 'h':
cnt += ps
else:
ps += 1
return cnt
def cmp(x, y):
if count(x + y) > count(y + x):
return -1
else:
... | 0 | |
845 | C | Two TVs | PROGRAMMING | 1,500 | [
"data structures",
"greedy",
"sortings"
] | null | null | Polycarp is a great fan of television.
He wrote down all the TV programs he is interested in for today. His list contains *n* shows, *i*-th of them starts at moment *l**i* and ends at moment *r**i*.
Polycarp owns two TVs. He can watch two different shows simultaneously with two TVs but he can only watch one show at a... | The first line contains one integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of shows.
Each of the next *n* lines contains two integers *l**i* and *r**i* (0<=≤<=*l**i*<=<<=*r**i*<=≤<=109) — starting and ending time of *i*-th show. | If Polycarp is able to check out all the shows using only two TVs then print "YES" (without quotes). Otherwise, print "NO" (without quotes). | [
"3\n1 2\n2 3\n4 5\n",
"4\n1 2\n2 3\n2 3\n1 2\n"
] | [
"YES\n",
"NO\n"
] | none | 0 | [
{
"input": "3\n1 2\n2 3\n4 5",
"output": "YES"
},
{
"input": "4\n1 2\n2 3\n2 3\n1 2",
"output": "NO"
},
{
"input": "4\n0 1\n1 2\n2 3\n3 4",
"output": "YES"
},
{
"input": "3\n1 2\n2 3\n2 4",
"output": "NO"
},
{
"input": "3\n0 100\n0 100\n0 100",
"output": "NO"
... | 1,630,466,801 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 10 | 935 | 40,448,000 | from sys import stdin
input=stdin.readline
from collections import defaultdict
def f(q:list):
q.sort(key=lambda s:s[1])
q.sort(key=lambda s:s[0])
d=dict()
res=0
for l,r in q:
res+=1
d[r+1]=d.get(r+1,0)-1
res+=d.get(l,0)
if res>2:
return "NO"
... | Title: Two TVs
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarp is a great fan of television.
He wrote down all the TV programs he is interested in for today. His list contains *n* shows, *i*-th of them starts at moment *l**i* and ends at moment *r**i*.
Polycarp owns two TVs. He ... | ```python
from sys import stdin
input=stdin.readline
from collections import defaultdict
def f(q:list):
q.sort(key=lambda s:s[1])
q.sort(key=lambda s:s[0])
d=dict()
res=0
for l,r in q:
res+=1
d[r+1]=d.get(r+1,0)-1
res+=d.get(l,0)
if res>2:
ret... | 0 | |
165 | A | Supercentral Point | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | One day Vasya painted a Cartesian coordinate system on a piece of paper and marked some set of points (*x*1,<=*y*1),<=(*x*2,<=*y*2),<=...,<=(*x**n*,<=*y**n*). Let's define neighbors for some fixed point from the given set (*x*,<=*y*):
- point (*x*',<=*y*') is (*x*,<=*y*)'s right neighbor, if *x*'<=><=*x* and *y*'... | The first input line contains the only integer *n* (1<=≤<=*n*<=≤<=200) — the number of points in the given set. Next *n* lines contain the coordinates of the points written as "*x* *y*" (without the quotes) (|*x*|,<=|*y*|<=≤<=1000), all coordinates are integers. The numbers in the line are separated by exactly one spac... | Print the only number — the number of supercentral points of the given set. | [
"8\n1 1\n4 2\n3 1\n1 2\n0 2\n0 1\n1 0\n1 3\n",
"5\n0 0\n0 1\n1 0\n0 -1\n-1 0\n"
] | [
"2\n",
"1\n"
] | In the first sample the supercentral points are only points (1, 1) and (1, 2).
In the second sample there is one supercental point — point (0, 0). | 500 | [
{
"input": "8\n1 1\n4 2\n3 1\n1 2\n0 2\n0 1\n1 0\n1 3",
"output": "2"
},
{
"input": "5\n0 0\n0 1\n1 0\n0 -1\n-1 0",
"output": "1"
},
{
"input": "9\n-565 -752\n-184 723\n-184 -752\n-184 1\n950 723\n-565 723\n950 -752\n950 1\n-565 1",
"output": "1"
},
{
"input": "25\n-651 897\n... | 1,667,788,340 | 2,147,483,647 | Python 3 | OK | TESTS | 26 | 92 | 102,400 | # https://codeforces.com/problemset/problem/165/A
from collections import defaultdict
points = int(input())
all_points = defaultdict(set)
for line in range(points):
x, y = input().split(" ")
x = int(x)
y = int(y)
all_points[(x, y)].add("initial")
for point in all_points:
x, y = point[0], point[... | Title: Supercentral Point
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Vasya painted a Cartesian coordinate system on a piece of paper and marked some set of points (*x*1,<=*y*1),<=(*x*2,<=*y*2),<=...,<=(*x**n*,<=*y**n*). Let's define neighbors for some fixed point from the give... | ```python
# https://codeforces.com/problemset/problem/165/A
from collections import defaultdict
points = int(input())
all_points = defaultdict(set)
for line in range(points):
x, y = input().split(" ")
x = int(x)
y = int(y)
all_points[(x, y)].add("initial")
for point in all_points:
x, y = point[... | 3 | |
981 | A | Antipalindrome | PROGRAMMING | 900 | [
"brute force",
"implementation",
"strings"
] | null | null | A string is a palindrome if it reads the same from the left to the right and from the right to the left. For example, the strings "kek", "abacaba", "r" and "papicipap" are palindromes, while the strings "abb" and "iq" are not.
A substring $s[l \ldots r]$ ($1<=\leq<=l<=\leq<=r<=\leq<=|s|$) of a string $s<==<=s_{1}s_{2}... | The first line contains a non-empty string $s$ with length at most $50$ characters, containing lowercase English letters only. | If there is such a substring in $s$ that is not a palindrome, print the maximum length of such a substring. Otherwise print $0$.
Note that there can be multiple longest substrings that are not palindromes, but their length is unique. | [
"mew\n",
"wuffuw\n",
"qqqqqqqq\n"
] | [
"3\n",
"5\n",
"0\n"
] | "mew" is not a palindrome, so the longest substring of it that is not a palindrome, is the string "mew" itself. Thus, the answer for the first example is $3$.
The string "uffuw" is one of the longest non-palindrome substrings (of length $5$) of the string "wuffuw", so the answer for the second example is $5$.
All sub... | 500 | [
{
"input": "mew",
"output": "3"
},
{
"input": "wuffuw",
"output": "5"
},
{
"input": "qqqqqqqq",
"output": "0"
},
{
"input": "ijvji",
"output": "4"
},
{
"input": "iiiiiii",
"output": "0"
},
{
"input": "wobervhvvkihcuyjtmqhaaigvvgiaahqmtjyuchikvvhvrebow"... | 1,555,926,003 | 2,147,483,647 | Python 3 | OK | TESTS | 133 | 109 | 0 | X = input()
print(0 if len(set(X)) == 1 else (len(X) if X != "".join(reversed(X)) else len(X) - 1))
# Second_Comment
# UBCF
# UB_CodeForces
# Angry_because_of_sth | Title: Antipalindrome
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A string is a palindrome if it reads the same from the left to the right and from the right to the left. For example, the strings "kek", "abacaba", "r" and "papicipap" are palindromes, while the strings "abb" and "iq" ar... | ```python
X = input()
print(0 if len(set(X)) == 1 else (len(X) if X != "".join(reversed(X)) else len(X) - 1))
# Second_Comment
# UBCF
# UB_CodeForces
# Angry_because_of_sth
``` | 3 | |
595 | A | Vitaly and Night | PROGRAMMING | 800 | [
"constructive algorithms",
"implementation"
] | null | null | One day Vitaly was going home late at night and wondering: how many people aren't sleeping at that moment? To estimate, Vitaly decided to look which windows are lit in the house he was passing by at that moment.
Vitaly sees a building of *n* floors and 2·*m* windows on each floor. On each floor there are *m* flats num... | The first line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of floors in the house and the number of flats on each floor respectively.
Next *n* lines describe the floors from top to bottom and contain 2·*m* characters each. If the *i*-th window of the given floor has lights on,... | Print a single integer — the number of flats that have lights on in at least one window, that is, the flats where, according to Vitaly, people aren't sleeping. | [
"2 2\n0 0 0 1\n1 0 1 1\n",
"1 3\n1 1 0 1 0 0\n"
] | [
"3\n",
"2\n"
] | In the first test case the house has two floors, two flats on each floor. That is, in total there are 4 flats. The light isn't on only on the second floor in the left flat. That is, in both rooms of the flat the light is off.
In the second test case the house has one floor and the first floor has three flats. The ligh... | 500 | [
{
"input": "2 2\n0 0 0 1\n1 0 1 1",
"output": "3"
},
{
"input": "1 3\n1 1 0 1 0 0",
"output": "2"
},
{
"input": "3 3\n1 1 1 1 1 1\n1 1 0 1 1 0\n1 0 0 0 1 1",
"output": "8"
},
{
"input": "1 5\n1 0 1 1 1 0 1 1 1 1",
"output": "5"
},
{
"input": "1 100\n1 1 1 1 1 1 1 ... | 1,596,792,624 | 2,147,483,647 | Python 3 | OK | TESTS | 36 | 109 | 7,577,600 | floor, win = map(int, input().split())
d={};k=0
for i in range(floor):
a=list(map(int, input().split()))
for j in range(2*win):
if a[j]==1:
d[str(k//2)]=1
k+=1
print(len(d.values())) | Title: Vitaly and Night
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Vitaly was going home late at night and wondering: how many people aren't sleeping at that moment? To estimate, Vitaly decided to look which windows are lit in the house he was passing by at that moment.
Vital... | ```python
floor, win = map(int, input().split())
d={};k=0
for i in range(floor):
a=list(map(int, input().split()))
for j in range(2*win):
if a[j]==1:
d[str(k//2)]=1
k+=1
print(len(d.values()))
``` | 3 | |
980 | E | The Number Games | PROGRAMMING | 2,200 | [
"data structures",
"greedy",
"trees"
] | null | null | The nation of Panel holds an annual show called The Number Games, where each district in the nation will be represented by one contestant.
The nation has $n$ districts numbered from $1$ to $n$, each district has exactly one path connecting it to every other district. The number of fans of a contestant from district $i... | The first line of input contains two integers $n$ and $k$ ($1 \leq k < n \leq 10^6$) — the number of districts in Panel, and the number of contestants the president wishes to remove, respectively.
The next $n-1$ lines each contains two integers $a$ and $b$ ($1 \leq a, b \leq n$, $a \ne b$), that describe a road tha... | Print $k$ space-separated integers: the numbers of the districts of which the contestants should be removed, in increasing order of district number. | [
"6 3\n2 1\n2 6\n4 2\n5 6\n2 3\n",
"8 4\n2 6\n2 7\n7 8\n1 2\n3 1\n2 4\n7 5\n"
] | [
"1 3 4\n",
"1 3 4 5\n"
] | In the first sample, the maximum possible total number of fans is $2^2 + 2^5 + 2^6 = 100$. We can achieve it by removing the contestants of the districts 1, 3, and 4. | 2,500 | [
{
"input": "6 3\n2 1\n2 6\n4 2\n5 6\n2 3",
"output": "1 3 4"
},
{
"input": "8 4\n2 6\n2 7\n7 8\n1 2\n3 1\n2 4\n7 5",
"output": "1 3 4 5"
},
{
"input": "2 1\n1 2",
"output": "1"
},
{
"input": "3 1\n2 1\n2 3",
"output": "1"
},
{
"input": "3 2\n1 3\n1 2",
"output... | 1,565,342,112 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 6 | 249 | 6,041,600 | from typing import *
V = TypeVar("V")
class graph:
vertices:List[V]
graphDict:Dict[V,Set[V]]
def __init__(self,vertices,graphDict):
self.vertices = vertices
self.graphDict = graphDict
for v in vertices:
if not v in self.graphDict:
self.graphDict[v] = set... | Title: The Number Games
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The nation of Panel holds an annual show called The Number Games, where each district in the nation will be represented by one contestant.
The nation has $n$ districts numbered from $1$ to $n$, each district has exact... | ```python
from typing import *
V = TypeVar("V")
class graph:
vertices:List[V]
graphDict:Dict[V,Set[V]]
def __init__(self,vertices,graphDict):
self.vertices = vertices
self.graphDict = graphDict
for v in vertices:
if not v in self.graphDict:
self.graphDic... | 0 | |
1,004 | A | Sonya and Hotels | PROGRAMMING | 900 | [
"implementation"
] | null | null | Sonya decided that having her own hotel business is the best way of earning money because she can profit and rest wherever she wants.
The country where Sonya lives is an endless line. There is a city in each integer coordinate on this line. She has $n$ hotels, where the $i$-th hotel is located in the city with coordin... | The first line contains two integers $n$ and $d$ ($1\leq n\leq 100$, $1\leq d\leq 10^9$) — the number of Sonya's hotels and the needed minimum distance from a new hotel to all others.
The second line contains $n$ different integers in strictly increasing order $x_1, x_2, \ldots, x_n$ ($-10^9\leq x_i\leq 10^9$) — coord... | Print the number of cities where Sonya can build a new hotel so that the minimum distance from this hotel to all others is equal to $d$. | [
"4 3\n-3 2 9 16\n",
"5 2\n4 8 11 18 19\n"
] | [
"6\n",
"5\n"
] | In the first example, there are $6$ possible cities where Sonya can build a hotel. These cities have coordinates $-6$, $5$, $6$, $12$, $13$, and $19$.
In the second example, there are $5$ possible cities where Sonya can build a hotel. These cities have coordinates $2$, $6$, $13$, $16$, and $21$. | 500 | [
{
"input": "4 3\n-3 2 9 16",
"output": "6"
},
{
"input": "5 2\n4 8 11 18 19",
"output": "5"
},
{
"input": "10 10\n-67 -59 -49 -38 -8 20 41 59 74 83",
"output": "8"
},
{
"input": "10 10\n0 20 48 58 81 95 111 137 147 159",
"output": "9"
},
{
"input": "100 1\n0 1 2 3... | 1,530,835,430 | 2,147,483,647 | Python 3 | OK | TESTS | 45 | 124 | 0 | n, d = map(int, input().split())
data = list(map(int, input().split()))
pos = set([x - d for x in data] + [x + d for x in data])
isValid = lambda x: min(abs(x-p) for p in data) == d
ans = len(list(filter(isValid, list(pos))))
print (ans)
| Title: Sonya and Hotels
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Sonya decided that having her own hotel business is the best way of earning money because she can profit and rest wherever she wants.
The country where Sonya lives is an endless line. There is a city in each integer c... | ```python
n, d = map(int, input().split())
data = list(map(int, input().split()))
pos = set([x - d for x in data] + [x + d for x in data])
isValid = lambda x: min(abs(x-p) for p in data) == d
ans = len(list(filter(isValid, list(pos))))
print (ans)
``` | 3 | |
201 | B | Guess That Car! | PROGRAMMING | 1,800 | [
"math",
"ternary search"
] | null | null | A widely known among some people Belarusian sport programmer Yura possesses lots of information about cars. That is why he has been invited to participate in a game show called "Guess That Car!".
The game show takes place on a giant parking lot, which is 4*n* meters long from north to south and 4*m* meters wide from w... | The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=1000) — the sizes of the parking lot. Each of the next *n* lines contains *m* integers: the *j*-th number in the *i*-th line describes the "rarity" *c**ij* (0<=≤<=*c**ij*<=≤<=100000) of the car that is located in the square with coordinates (*i*,<=*j... | In the first line print the minimum total time Yura needs to guess all offered cars. In the second line print two numbers *l**i* and *l**j* (0<=≤<=*l**i*<=≤<=*n*,<=0<=≤<=*l**j*<=≤<=*m*) — the numbers of dividing lines that form a junction that Yura should choose to stand on at the beginning of the game show. If there a... | [
"2 3\n3 4 5\n3 9 1\n",
"3 4\n1 0 0 0\n0 0 3 0\n0 0 5 5\n"
] | [
"392\n1 1\n",
"240\n2 3\n"
] | In the first test case the total time of guessing all cars is equal to 3·8 + 3·8 + 4·8 + 9·8 + 5·40 + 1·40 = 392.
The coordinate system of the field: | 1,000 | [
{
"input": "2 3\n3 4 5\n3 9 1",
"output": "392\n1 1"
},
{
"input": "3 4\n1 0 0 0\n0 0 3 0\n0 0 5 5",
"output": "240\n2 3"
},
{
"input": "4 7\n91811 50656 97940 70982 88108 31856 80371\n94488 4672 15935 10209 22935 55803 57593\n79510 213 92494 7670 49727 97141 54221\n89004 67886 99994 222... | 1,689,646,473 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 0 | 124 | 0 | print("_RANDOM_GUESS_1689646473.0037155")# 1689646473.0037367 | Title: Guess That Car!
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A widely known among some people Belarusian sport programmer Yura possesses lots of information about cars. That is why he has been invited to participate in a game show called "Guess That Car!".
The game show takes pl... | ```python
print("_RANDOM_GUESS_1689646473.0037155")# 1689646473.0037367
``` | 0 | |
868 | A | Bark to Unlock | PROGRAMMING | 900 | [
"brute force",
"implementation",
"strings"
] | null | null | As technologies develop, manufacturers are making the process of unlocking a phone as user-friendly as possible. To unlock its new phone, Arkady's pet dog Mu-mu has to bark the password once. The phone represents a password as a string of two lowercase English letters.
Mu-mu's enemy Kashtanka wants to unlock Mu-mu's p... | The first line contains two lowercase English letters — the password on the phone.
The second line contains single integer *n* (1<=≤<=*n*<=≤<=100) — the number of words Kashtanka knows.
The next *n* lines contain two lowercase English letters each, representing the words Kashtanka knows. The words are guaranteed to b... | Print "YES" if Kashtanka can bark several words in a line forming a string containing the password, and "NO" otherwise.
You can print each letter in arbitrary case (upper or lower). | [
"ya\n4\nah\noy\nto\nha\n",
"hp\n2\nht\ntp\n",
"ah\n1\nha\n"
] | [
"YES\n",
"NO\n",
"YES\n"
] | In the first example the password is "ya", and Kashtanka can bark "oy" and then "ah", and then "ha" to form the string "oyahha" which contains the password. So, the answer is "YES".
In the second example Kashtanka can't produce a string containing password as a substring. Note that it can bark "ht" and then "tp" produ... | 250 | [
{
"input": "ya\n4\nah\noy\nto\nha",
"output": "YES"
},
{
"input": "hp\n2\nht\ntp",
"output": "NO"
},
{
"input": "ah\n1\nha",
"output": "YES"
},
{
"input": "bb\n4\nba\nab\naa\nbb",
"output": "YES"
},
{
"input": "bc\n4\nca\nba\nbb\ncc",
"output": "YES"
},
{
... | 1,652,545,197 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 3 | 31 | 0 | password = str(input())
n = int(input())
kash_s = ""
yes = False
for i in range(0,n):
kash_w = str(input())
kash_s += kash_w
for j in range(0, n*2, 1):
if (j%2 ==1) and (kash_s[j] == password[0]):
for k in range(0, n*2, 1):
if (k%2 ==0) and (kash_s[k] == password[1]):
print("YES")
yes ... | Title: Bark to Unlock
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
As technologies develop, manufacturers are making the process of unlocking a phone as user-friendly as possible. To unlock its new phone, Arkady's pet dog Mu-mu has to bark the password once. The phone represents a passw... | ```python
password = str(input())
n = int(input())
kash_s = ""
yes = False
for i in range(0,n):
kash_w = str(input())
kash_s += kash_w
for j in range(0, n*2, 1):
if (j%2 ==1) and (kash_s[j] == password[0]):
for k in range(0, n*2, 1):
if (k%2 ==0) and (kash_s[k] == password[1]):
print("YES")
... | 0 | |
766 | A | Mahmoud and Longest Uncommon Subsequence | PROGRAMMING | 1,000 | [
"constructive algorithms",
"strings"
] | null | null | While Mahmoud and Ehab were practicing for IOI, they found a problem which name was Longest common subsequence. They solved it, and then Ehab challenged Mahmoud with another problem.
Given two strings *a* and *b*, find the length of their longest uncommon subsequence, which is the longest string that is a subsequence ... | The first line contains string *a*, and the second line — string *b*. Both of these strings are non-empty and consist of lowercase letters of English alphabet. The length of each string is not bigger than 105 characters. | If there's no uncommon subsequence, print "-1". Otherwise print the length of the longest uncommon subsequence of *a* and *b*. | [
"abcd\ndefgh\n",
"a\na\n"
] | [
"5\n",
"-1\n"
] | In the first example: you can choose "defgh" from string *b* as it is the longest subsequence of string *b* that doesn't appear as a subsequence of string *a*. | 500 | [
{
"input": "abcd\ndefgh",
"output": "5"
},
{
"input": "a\na",
"output": "-1"
},
{
"input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaacccccccccccccccccccccccccccccccccccccccccccccccccc\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddd... | 1,643,468,883 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 31 | 0 | def main():
a = input()
b = input()
if len(a) > len(b):
print(len(a))
elif len(a) == len(b):
print(-1)
else:
print(len(b))
if __name__ == '__main__':
main() | Title: Mahmoud and Longest Uncommon Subsequence
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
While Mahmoud and Ehab were practicing for IOI, they found a problem which name was Longest common subsequence. They solved it, and then Ehab challenged Mahmoud with another problem.
Given two ... | ```python
def main():
a = input()
b = input()
if len(a) > len(b):
print(len(a))
elif len(a) == len(b):
print(-1)
else:
print(len(b))
if __name__ == '__main__':
main()
``` | 0 | |
47 | B | Coins | PROGRAMMING | 1,200 | [
"implementation"
] | B. Coins | 2 | 256 | One day Vasya came across three Berland coins. They didn't have any numbers that's why Vasya didn't understand how their denominations differ. He supposed that if one coin is heavier than the other one, then it should be worth more. Vasya weighed all the three pairs of coins on pan balance scales and told you the resul... | The input data contains the results of all the weighting, one result on each line. It is guaranteed that every coin pair was weighted exactly once. Vasya labelled the coins with letters «A», «B» and «C». Each result is a line that appears as (letter)(> or < sign)(letter). For example, if coin "A" proved lighter t... | It the results are contradictory, print Impossible. Otherwise, print without spaces the rearrangement of letters «A», «B» and «C» which represent the coins in the increasing order of their weights. | [
"A>B\nC<B\nA>C\n",
"A<B\nB>C\nC>A\n"
] | [
"CBA",
"ACB"
] | none | 1,000 | [
{
"input": "A>B\nC<B\nA>C",
"output": "CBA"
},
{
"input": "A<B\nB>C\nC>A",
"output": "ACB"
},
{
"input": "A<C\nB<A\nB>C",
"output": "Impossible"
},
{
"input": "A<B\nA<C\nB>C",
"output": "ACB"
},
{
"input": "B>A\nC<B\nC>A",
"output": "ACB"
},
{
"input":... | 1,647,640,026 | 2,147,483,647 | Python 3 | OK | TESTS | 50 | 92 | 0 | dict1= {'A':0, 'B':0, 'C':0}
list1=[]
order= ''
for i in range(3):
x= input()
list1.append(x)
for l in list1:
if l[1]=='>':
dict1[l[0]]+=1
elif l[1]== '<':
dict1[l[2]]+=1
if dict1['A']==dict1['B'] or dict1['B']==dict1['C'] or dict1['A']==dict1['C']:
print('Impossibl... | Title: Coins
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
One day Vasya came across three Berland coins. They didn't have any numbers that's why Vasya didn't understand how their denominations differ. He supposed that if one coin is heavier than the other one, then it should be worth more. ... | ```python
dict1= {'A':0, 'B':0, 'C':0}
list1=[]
order= ''
for i in range(3):
x= input()
list1.append(x)
for l in list1:
if l[1]=='>':
dict1[l[0]]+=1
elif l[1]== '<':
dict1[l[2]]+=1
if dict1['A']==dict1['B'] or dict1['B']==dict1['C'] or dict1['A']==dict1['C']:
print(... | 3.977 |
298 | A | Snow Footprints | PROGRAMMING | 1,300 | [
"greedy",
"implementation"
] | null | null | There is a straight snowy road, divided into *n* blocks. The blocks are numbered from 1 to *n* from left to right. If one moves from the *i*-th block to the (*i*<=+<=1)-th block, he will leave a right footprint on the *i*-th block. Similarly, if one moves from the *i*-th block to the (*i*<=-<=1)-th block, he will leave... | The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=1000).
The second line contains the description of the road — the string that consists of *n* characters. Each character will be either "." (a block without footprint), or "L" (a block with a left footprint), "R" (a block with a right footprint).
It's gu... | Print two space-separated integers — the values of *s* and *t*. If there are several possible solutions you can print any of them. | [
"9\n..RRLL...\n",
"11\n.RRRLLLLL..\n"
] | [
"3 4\n",
"7 5\n"
] | The first test sample is the one in the picture. | 500 | [
{
"input": "11\n.RRRLLLLL..",
"output": "7 5"
},
{
"input": "4\n.RL.",
"output": "3 2"
},
{
"input": "3\n.L.",
"output": "2 1"
},
{
"input": "3\n.R.",
"output": "2 3"
}
] | 1,525,958,431 | 2,147,483,647 | PyPy 3 | OK | TESTS | 23 | 186 | 21,401,600 | n = int(input())
s = list(input())
ans = ['', '']
i = 0
while s[i] == '.': i += 1
if s[i] == 'L':
ans[1] = str(i)
while s[i] != '.':
i += 1
ans[0] = str(i)
else:
ans[0] = str(i+1)
while s[i] == 'R':
i += 1
ans[1] = str(i+1)
print(' '.join(ans)) | Title: Snow Footprints
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There is a straight snowy road, divided into *n* blocks. The blocks are numbered from 1 to *n* from left to right. If one moves from the *i*-th block to the (*i*<=+<=1)-th block, he will leave a right footprint on the *... | ```python
n = int(input())
s = list(input())
ans = ['', '']
i = 0
while s[i] == '.': i += 1
if s[i] == 'L':
ans[1] = str(i)
while s[i] != '.':
i += 1
ans[0] = str(i)
else:
ans[0] = str(i+1)
while s[i] == 'R':
i += 1
ans[1] = str(i+1)
print(' '.join(ans))
``` | 3 | |
304 | A | Pythagorean Theorem II | PROGRAMMING | 1,200 | [
"brute force",
"math"
] | null | null | In mathematics, the Pythagorean theorem — is a relation in Euclidean geometry among the three sides of a right-angled triangle. In terms of areas, it states:
In any right-angled triangle, the area of the square whose side is the hypotenuse (the side opposite the right angle) is equal to the sum of the areas of the s... | The only line contains one integer *n* (1<=≤<=*n*<=≤<=104) as we mentioned above. | Print a single integer — the answer to the problem. | [
"5\n",
"74\n"
] | [
"1\n",
"35\n"
] | none | 500 | [
{
"input": "5",
"output": "1"
},
{
"input": "74",
"output": "35"
},
{
"input": "1000",
"output": "881"
},
{
"input": "586",
"output": "472"
},
{
"input": "2",
"output": "0"
},
{
"input": "362",
"output": "258"
},
{
"input": "778",
"outp... | 1,655,364,994 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 30 | 3,000 | 0 | import sys
input = sys.stdin.readline
n = int(input())
d = 0
for i in range(1, n+1):
for j in range(i, n+1):
c = i**2 + j**2
if c**0.5 <= n and c**0.5 == int(c**0.5):
d += 1
print(d) | Title: Pythagorean Theorem II
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In mathematics, the Pythagorean theorem — is a relation in Euclidean geometry among the three sides of a right-angled triangle. In terms of areas, it states:
In any right-angled triangle, the area of the squar... | ```python
import sys
input = sys.stdin.readline
n = int(input())
d = 0
for i in range(1, n+1):
for j in range(i, n+1):
c = i**2 + j**2
if c**0.5 <= n and c**0.5 == int(c**0.5):
d += 1
print(d)
``` | 0 | |
463 | B | Caisa and Pylons | PROGRAMMING | 1,100 | [
"brute force",
"implementation",
"math"
] | null | null | Caisa solved the problem with the sugar and now he is on the way back to home.
Caisa is playing a mobile game during his path. There are (*n*<=+<=1) pylons numbered from 0 to *n* in this game. The pylon with number 0 has zero height, the pylon with number *i* (*i*<=><=0) has height *h**i*. The goal of the game is ... | The first line contains integer *n* (1<=≤<=*n*<=≤<=105). The next line contains *n* integers *h*1, *h*2,<=..., *h**n* (1<=<=≤<=<=*h**i*<=<=≤<=<=105) representing the heights of the pylons. | Print a single number representing the minimum number of dollars paid by Caisa. | [
"5\n3 4 3 2 4\n",
"3\n4 4 4\n"
] | [
"4\n",
"4\n"
] | In the first sample he can pay 4 dollars and increase the height of pylon with number 0 by 4 units. Then he can safely pass to the last pylon. | 1,000 | [
{
"input": "5\n3 4 3 2 4",
"output": "4"
},
{
"input": "3\n4 4 4",
"output": "4"
},
{
"input": "99\n1401 2019 1748 3785 3236 3177 3443 3772 2138 1049 353 908 310 2388 1322 88 2160 2783 435 2248 1471 706 2468 2319 3156 3506 2794 1999 1983 2519 2597 3735 537 344 3519 3772 3872 2961 3895 20... | 1,627,895,084 | 2,147,483,647 | Python 3 | OK | TESTS | 49 | 155 | 14,438,400 | n=int(input())
l=list(map(int,input().split()))
count =l[0] #needed
e=0 #energy
for i in range(0,n-1):
if(l[i+1]>l[i]):
if(e):
e=e-(l[i+1]-l[i])
if(e>=0):
continue
else:
count=count+abs(e)
e=0
else:
... | Title: Caisa and Pylons
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Caisa solved the problem with the sugar and now he is on the way back to home.
Caisa is playing a mobile game during his path. There are (*n*<=+<=1) pylons numbered from 0 to *n* in this game. The pylon with number 0... | ```python
n=int(input())
l=list(map(int,input().split()))
count =l[0] #needed
e=0 #energy
for i in range(0,n-1):
if(l[i+1]>l[i]):
if(e):
e=e-(l[i+1]-l[i])
if(e>=0):
continue
else:
count=count+abs(e)
e=0
... | 3 | |
0 | none | none | none | 0 | [
"none"
] | 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 | 0 | [
{
"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,659,553,714 | 2,147,483,647 | Python 3 | OK | TESTS | 31 | 779 | 35,635,200 | def updateArray(arr, operations, queries, n, m, k):
if not arr:
return []
numOperations = [0]*m
for s, e in queries:
numOperations[s-1] += 1
if e < m:
numOperations[e] -= 1
for i in range(1, m):
numOperations[i] += numOperations[i-1]
... | Title: none
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 elements ... | ```python
def updateArray(arr, operations, queries, n, m, k):
if not arr:
return []
numOperations = [0]*m
for s, e in queries:
numOperations[s-1] += 1
if e < m:
numOperations[e] -= 1
for i in range(1, m):
numOperations[i] += numOperations[i-1]
... | 3 | |
832 | A | Sasha and Sticks | PROGRAMMING | 800 | [
"games",
"math"
] | null | null | It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws *n* sticks in a row. After that the players t... | The first line contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1018, *k*<=≤<=*n*) — the number of sticks drawn by Sasha and the number *k* — the number of sticks to be crossed out on each turn. | If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower). | [
"1 1\n",
"10 4\n"
] | [
"YES\n",
"NO\n"
] | In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sas... | 500 | [
{
"input": "1 1",
"output": "YES"
},
{
"input": "10 4",
"output": "NO"
},
{
"input": "251656215122324104 164397544865601257",
"output": "YES"
},
{
"input": "963577813436662285 206326039287271924",
"output": "NO"
},
{
"input": "1000000000000000000 1",
"output":... | 1,620,188,175 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 0 | 78 | 0 | n,k=map(int,input().split())
c=n/k
if c%2==0:
print("Yes")
else:
print("No") | Title: Sasha and Sticks
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with ... | ```python
n,k=map(int,input().split())
c=n/k
if c%2==0:
print("Yes")
else:
print("No")
``` | 0 | |
762 | A | k-th divisor | PROGRAMMING | 1,400 | [
"math",
"number theory"
] | null | null | You are given two integers *n* and *k*. Find *k*-th smallest divisor of *n*, or report that it doesn't exist.
Divisor of *n* is any such natural number, that *n* can be divided by it without remainder. | The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=1015, 1<=≤<=*k*<=≤<=109). | If *n* has less than *k* divisors, output -1.
Otherwise, output the *k*-th smallest divisor of *n*. | [
"4 2\n",
"5 3\n",
"12 5\n"
] | [
"2\n",
"-1\n",
"6\n"
] | In the first example, number 4 has three divisors: 1, 2 and 4. The second one is 2.
In the second example, number 5 has only two divisors: 1 and 5. The third divisor doesn't exist, so the answer is -1. | 0 | [
{
"input": "4 2",
"output": "2"
},
{
"input": "5 3",
"output": "-1"
},
{
"input": "12 5",
"output": "6"
},
{
"input": "1 1",
"output": "1"
},
{
"input": "866421317361600 26880",
"output": "866421317361600"
},
{
"input": "866421317361600 26881",
"ou... | 1,679,235,964 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 4 | 2,000 | 0 | n,k = map(int,input().split())
d = []
if k > n:
print("-1")
else:
for i in range(1,n+1):
if n % i == 0:
d.append(i)
if len(d) < k:
print("-1")
else:
print(d[k-1])
| Title: k-th divisor
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given two integers *n* and *k*. Find *k*-th smallest divisor of *n*, or report that it doesn't exist.
Divisor of *n* is any such natural number, that *n* can be divided by it without remainder.
Input Specificatio... | ```python
n,k = map(int,input().split())
d = []
if k > n:
print("-1")
else:
for i in range(1,n+1):
if n % i == 0:
d.append(i)
if len(d) < k:
print("-1")
else:
print(d[k-1])
``` | 0 | |
385 | C | Bear and Prime Numbers | PROGRAMMING | 1,700 | [
"binary search",
"brute force",
"data structures",
"dp",
"implementation",
"math",
"number theory"
] | null | null | Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers *x*1,<=*x*2,<=...,<=*x**n* of length *n* and *m* queries, each of them is characterized by two integers *l**i*,<=*r**i*. Let's introduce *f*(*p*) to represent the number of such indexes *k*, that *... | The first line contains integer *n* (1<=≤<=*n*<=≤<=106). The second line contains *n* integers *x*1,<=*x*2,<=...,<=*x**n* (2<=≤<=*x**i*<=≤<=107). The numbers are not necessarily distinct.
The third line contains integer *m* (1<=≤<=*m*<=≤<=50000). Each of the following *m* lines contains a pair of space-separated integ... | Print *m* integers — the answers to the queries on the order the queries appear in the input. | [
"6\n5 5 7 10 14 15\n3\n2 11\n3 12\n4 4\n",
"7\n2 3 5 7 11 4 8\n2\n8 10\n2 123\n"
] | [
"9\n7\n0\n",
"0\n7\n"
] | Consider the first sample. Overall, the first sample has 3 queries.
1. The first query *l* = 2, *r* = 11 comes. You need to count *f*(2) + *f*(3) + *f*(5) + *f*(7) + *f*(11) = 2 + 1 + 4 + 2 + 0 = 9. 1. The second query comes *l* = 3, *r* = 12. You need to count *f*(3) + *f*(5) + *f*(7) + *f*(11) = 1 + 4 + 2 + 0 = 7.... | 1,500 | [
{
"input": "6\n5 5 7 10 14 15\n3\n2 11\n3 12\n4 4",
"output": "9\n7\n0"
},
{
"input": "7\n2 3 5 7 11 4 8\n2\n8 10\n2 123",
"output": "0\n7"
},
{
"input": "9\n50 50 50 50 50 50 50 50 50\n7\n20 20\n8 13\n13 13\n6 14\n3 5\n15 17\n341 1792",
"output": "0\n0\n0\n0\n9\n0\n0"
},
{
"... | 1,673,238,455 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 0 | 311 | 120,115,200 | from sys import stdin
LIM = 10000001
stdin.readline()
a = [int(x) for x in stdin.readline().split()]
cnt = [0] * LIM
prime = [True] * LIM
ans = [0] * LIM
for x in a:
cnt[x] += 1
for p in xrange(2, LIM):
ans[p] = ans[p - 1]
if prime[p]:
for j in xrange(p, LIM, p):
prime[j] = False
ans[p] ... | Title: Bear and Prime Numbers
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers *x*1,<=*x*2,<=...,<=*x**n* of length *n* and *m* queries, each of them is characterized b... | ```python
from sys import stdin
LIM = 10000001
stdin.readline()
a = [int(x) for x in stdin.readline().split()]
cnt = [0] * LIM
prime = [True] * LIM
ans = [0] * LIM
for x in a:
cnt[x] += 1
for p in xrange(2, LIM):
ans[p] = ans[p - 1]
if prime[p]:
for j in xrange(p, LIM, p):
prime[j] = False
... | -1 | |
873 | B | Balanced Substring | PROGRAMMING | 1,500 | [
"dp",
"implementation"
] | null | null | You are given a string *s* consisting only of characters 0 and 1. A substring [*l*,<=*r*] of *s* is a string *s**l**s**l*<=+<=1*s**l*<=+<=2... *s**r*, and its length equals to *r*<=-<=*l*<=+<=1. A substring is called balanced if the number of zeroes (0) equals to the number of ones in this substring.
You have to deter... | The first line contains *n* (1<=≤<=*n*<=≤<=100000) — the number of characters in *s*.
The second line contains a string *s* consisting of exactly *n* characters. Only characters 0 and 1 can appear in *s*. | If there is no non-empty balanced substring in *s*, print 0. Otherwise, print the length of the longest balanced substring. | [
"8\n11010111\n",
"3\n111\n"
] | [
"4\n",
"0\n"
] | In the first example you can choose the substring [3, 6]. It is balanced, and its length is 4. Choosing the substring [2, 5] is also possible.
In the second example it's impossible to find a non-empty balanced substring. | 0 | [
{
"input": "8\n11010111",
"output": "4"
},
{
"input": "3\n111",
"output": "0"
},
{
"input": "11\n00001000100",
"output": "2"
},
{
"input": "10\n0100000000",
"output": "2"
},
{
"input": "13\n0001000011010",
"output": "6"
},
{
"input": "14\n0000010010101... | 1,675,279,039 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 53 | 77 | 14,131,200 | n = int(input())
s = input()
curr_sum = 0
pr = []
for el in s:
pr.append(curr_sum)
if el == '0':
curr_sum -= 1
elif el == '1':
curr_sum += 1
pr.append(curr_sum)
d = {}
max_ = 0
for i in range(len(pr)):
if (pr[i] in d) and (i - d[pr[i]] > max_):
max_ = i - d[pr[i]]
... | Title: Balanced Substring
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a string *s* consisting only of characters 0 and 1. A substring [*l*,<=*r*] of *s* is a string *s**l**s**l*<=+<=1*s**l*<=+<=2... *s**r*, and its length equals to *r*<=-<=*l*<=+<=1. A substring is called... | ```python
n = int(input())
s = input()
curr_sum = 0
pr = []
for el in s:
pr.append(curr_sum)
if el == '0':
curr_sum -= 1
elif el == '1':
curr_sum += 1
pr.append(curr_sum)
d = {}
max_ = 0
for i in range(len(pr)):
if (pr[i] in d) and (i - d[pr[i]] > max_):
max_ = i - d[pr[i]]
... | 3 | |
22 | A | Second Order Statistics | PROGRAMMING | 800 | [
"brute force"
] | A. Second Order Statistics | 2 | 256 | Once Bob needed to find the second order statistics of a sequence of integer numbers. Lets choose each number from the sequence exactly once and sort them. The value on the second position is the second order statistics of the given sequence. In other words it is the smallest element strictly greater than the minimum. ... | The first input line contains integer *n* (1<=≤<=*n*<=≤<=100) — amount of numbers in the sequence. The second line contains *n* space-separated integer numbers — elements of the sequence. These numbers don't exceed 100 in absolute value. | If the given sequence has the second order statistics, output this order statistics, otherwise output NO. | [
"4\n1 2 2 -4\n",
"5\n1 2 3 1 1\n"
] | [
"1\n",
"2\n"
] | none | 0 | [
{
"input": "4\n1 2 2 -4",
"output": "1"
},
{
"input": "5\n1 2 3 1 1",
"output": "2"
},
{
"input": "1\n28",
"output": "NO"
},
{
"input": "2\n-28 12",
"output": "12"
},
{
"input": "3\n-83 40 -80",
"output": "-80"
},
{
"input": "8\n93 77 -92 26 21 -48 53 ... | 1,686,649,549 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 0 | 92 | 0 | a = int(input())
arr = list(map(int, input().split()))
arr.sort()
g = []
if len(arr) < 2:
print('NO')
else:
for i in range(len(arr)):
if arr[0] <= arr[i]:
g.append(arr[i])
print(min(arr))
break | Title: Second Order Statistics
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Once Bob needed to find the second order statistics of a sequence of integer numbers. Lets choose each number from the sequence exactly once and sort them. The value on the second position is the second order statis... | ```python
a = int(input())
arr = list(map(int, input().split()))
arr.sort()
g = []
if len(arr) < 2:
print('NO')
else:
for i in range(len(arr)):
if arr[0] <= arr[i]:
g.append(arr[i])
print(min(arr))
break
``` | 0 |
22 | A | Second Order Statistics | PROGRAMMING | 800 | [
"brute force"
] | A. Second Order Statistics | 2 | 256 | Once Bob needed to find the second order statistics of a sequence of integer numbers. Lets choose each number from the sequence exactly once and sort them. The value on the second position is the second order statistics of the given sequence. In other words it is the smallest element strictly greater than the minimum. ... | The first input line contains integer *n* (1<=≤<=*n*<=≤<=100) — amount of numbers in the sequence. The second line contains *n* space-separated integer numbers — elements of the sequence. These numbers don't exceed 100 in absolute value. | If the given sequence has the second order statistics, output this order statistics, otherwise output NO. | [
"4\n1 2 2 -4\n",
"5\n1 2 3 1 1\n"
] | [
"1\n",
"2\n"
] | none | 0 | [
{
"input": "4\n1 2 2 -4",
"output": "1"
},
{
"input": "5\n1 2 3 1 1",
"output": "2"
},
{
"input": "1\n28",
"output": "NO"
},
{
"input": "2\n-28 12",
"output": "12"
},
{
"input": "3\n-83 40 -80",
"output": "-80"
},
{
"input": "8\n93 77 -92 26 21 -48 53 ... | 1,592,854,420 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 4 | 248 | 20,172,800 | from sys import stdin
def main():
n = stdin.readline()
while len(n) != 0:
n = int(n)
arr = stdin.readline().split()
arr.sort()
ans = "NO"
for i in range(1,len(arr)):
if arr[i-1] != arr[i]:
ans = arr[i]
break
prin... | Title: Second Order Statistics
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Once Bob needed to find the second order statistics of a sequence of integer numbers. Lets choose each number from the sequence exactly once and sort them. The value on the second position is the second order statis... | ```python
from sys import stdin
def main():
n = stdin.readline()
while len(n) != 0:
n = int(n)
arr = stdin.readline().split()
arr.sort()
ans = "NO"
for i in range(1,len(arr)):
if arr[i-1] != arr[i]:
ans = arr[i]
break
... | 0 |
304 | A | Pythagorean Theorem II | PROGRAMMING | 1,200 | [
"brute force",
"math"
] | null | null | In mathematics, the Pythagorean theorem — is a relation in Euclidean geometry among the three sides of a right-angled triangle. In terms of areas, it states:
In any right-angled triangle, the area of the square whose side is the hypotenuse (the side opposite the right angle) is equal to the sum of the areas of the s... | The only line contains one integer *n* (1<=≤<=*n*<=≤<=104) as we mentioned above. | Print a single integer — the answer to the problem. | [
"5\n",
"74\n"
] | [
"1\n",
"35\n"
] | none | 500 | [
{
"input": "5",
"output": "1"
},
{
"input": "74",
"output": "35"
},
{
"input": "1000",
"output": "881"
},
{
"input": "586",
"output": "472"
},
{
"input": "2",
"output": "0"
},
{
"input": "362",
"output": "258"
},
{
"input": "778",
"outp... | 1,682,768,768 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 30 | 3,000 | 0 | import math
n=int(input())
count=0
for i in range(1,n+1):
for j in range(i+1,n+1):
c=math.sqrt(i**2+j**2)
if (int(c)==c and c<=n):
count+=1
print(count)
| Title: Pythagorean Theorem II
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In mathematics, the Pythagorean theorem — is a relation in Euclidean geometry among the three sides of a right-angled triangle. In terms of areas, it states:
In any right-angled triangle, the area of the squar... | ```python
import math
n=int(input())
count=0
for i in range(1,n+1):
for j in range(i+1,n+1):
c=math.sqrt(i**2+j**2)
if (int(c)==c and c<=n):
count+=1
print(count)
``` | 0 | |
370 | A | Rook, Bishop and King | PROGRAMMING | 1,100 | [
"graphs",
"math",
"shortest paths"
] | null | null | Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8<=×<=8 table. A field is represented by a pair of integers (*r*,<=*c*) — the number of the row and the number of... | The input contains four integers *r*1,<=*c*1,<=*r*2,<=*c*2 (1<=≤<=*r*1,<=*c*1,<=*r*2,<=*c*2<=≤<=8) — the coordinates of the starting and the final field. The starting field doesn't coincide with the final one.
You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numb... | Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (*r*1,<=*c*1) to field (*r*2,<=*c*2). If a piece cannot make such a move, print a 0 instead of the corresponding number. | [
"4 3 1 6\n",
"5 5 5 6\n"
] | [
"2 1 3\n",
"1 0 1\n"
] | none | 500 | [
{
"input": "4 3 1 6",
"output": "2 1 3"
},
{
"input": "5 5 5 6",
"output": "1 0 1"
},
{
"input": "1 1 8 8",
"output": "2 1 7"
},
{
"input": "1 1 8 1",
"output": "1 0 7"
},
{
"input": "1 1 1 8",
"output": "1 0 7"
},
{
"input": "8 1 1 1",
"output": "... | 1,689,063,993 | 2,147,483,647 | PyPy 3 | OK | TESTS | 42 | 78 | 0 | x1, y1, x2, y2 = map(int, input().split())
if x1 == x2 or y1 == y2:
a = 1
else:
a = 2
if (x1 % 2 + y1 % 2) % 2 == (x2 % 2 + y2 % 2) % 2:
if abs(x1 - x2) == abs(y2 - y1):
b = 1
else:
b = 2
else:
b = 0
c = max(abs(x1 - x2), abs(y1 - y2))
print(a, b, c)
# Tue Jul ... | Title: Rook, Bishop and King
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8<=×<=... | ```python
x1, y1, x2, y2 = map(int, input().split())
if x1 == x2 or y1 == y2:
a = 1
else:
a = 2
if (x1 % 2 + y1 % 2) % 2 == (x2 % 2 + y2 % 2) % 2:
if abs(x1 - x2) == abs(y2 - y1):
b = 1
else:
b = 2
else:
b = 0
c = max(abs(x1 - x2), abs(y1 - y2))
print(a, b, c)
... | 3 | |
926 | A | 2-3-numbers | PROGRAMMING | 1,300 | [
"implementation",
"math"
] | null | null | A positive integer is called a 2-3-integer, if it is equal to 2*x*·3*y* for some non-negative integers *x* and *y*. In other words, these integers are such integers that only have 2 and 3 among their prime divisors. For example, integers 1, 6, 9, 16 and 108 — are 2-3 integers, while 5, 10, 21 and 120 are not.
Print th... | The only line contains two integers *l* and *r* (1<=≤<=*l*<=≤<=*r*<=≤<=2·109). | Print a single integer the number of 2-3-integers on the segment [*l*,<=*r*]. | [
"1 10\n",
"100 200\n",
"1 2000000000\n"
] | [
"7\n",
"5\n",
"326\n"
] | In the first example the 2-3-integers are 1, 2, 3, 4, 6, 8 and 9.
In the second example the 2-3-integers are 108, 128, 144, 162 and 192. | 0 | [
{
"input": "1 10",
"output": "7"
},
{
"input": "100 200",
"output": "5"
},
{
"input": "1 2000000000",
"output": "326"
},
{
"input": "1088391168 1934917632",
"output": "17"
},
{
"input": "1088391167 1934917632",
"output": "17"
},
{
"input": "1088391169 ... | 1,662,045,191 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 26 | 46 | 0 | from math import log
l, r = map(int, input().split())
result = set()
for x in range(int(log(r, 2)) + 1):
for y in range(int(log(r, 3)) + 1):
v = 2**x*3**y
if l <= v <= r:
result.add(v)
print(len(result)) | Title: 2-3-numbers
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A positive integer is called a 2-3-integer, if it is equal to 2*x*·3*y* for some non-negative integers *x* and *y*. In other words, these integers are such integers that only have 2 and 3 among their prime divisors. For exa... | ```python
from math import log
l, r = map(int, input().split())
result = set()
for x in range(int(log(r, 2)) + 1):
for y in range(int(log(r, 3)) + 1):
v = 2**x*3**y
if l <= v <= r:
result.add(v)
print(len(result))
``` | 0 | |
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,673,425,399 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 1 | 46 | 0 | n,k = map(int,input().split(" "))
a = [input() for i in range(n)]
count = 0
for i in a:
flag = 0
if str(k+1) in i:
flag = -1
else:
count +=1
print(count)
| 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
n,k = map(int,input().split(" "))
a = [input() for i in range(n)]
count = 0
for i in a:
flag = 0
if str(k+1) in i:
flag = -1
else:
count +=1
print(count)
``` | 0 | |
934 | A | A Compatible Pair | PROGRAMMING | 1,400 | [
"brute force",
"games"
] | null | null | Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.
Little Tommy has *n* lanterns and Big B... | The first line contains two space-separated integers *n* and *m* (2<=≤<=*n*,<=*m*<=≤<=50).
The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n*.
The third line contains *m* space-separated integers *b*1,<=*b*2,<=...,<=*b**m*.
All the integers range from <=-<=109 to 109. | Print a single integer — the brightness of the chosen pair. | [
"2 2\n20 18\n2 14\n",
"5 3\n-1 0 1 2 3\n-1 0 1\n"
] | [
"252\n",
"2\n"
] | In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.
In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself. | 500 | [
{
"input": "2 2\n20 18\n2 14",
"output": "252"
},
{
"input": "5 3\n-1 0 1 2 3\n-1 0 1",
"output": "2"
},
{
"input": "10 2\n1 6 2 10 2 3 2 10 6 4\n5 7",
"output": "70"
},
{
"input": "50 50\n1 6 2 10 2 3 2 10 6 4 5 0 3 1 7 3 2 4 4 2 1 5 0 6 10 1 8 0 10 9 0 4 10 5 5 7 4 9 9 5 5 ... | 1,545,310,664 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 9 | 140 | 0 | a=[int(x) for x in input().split()]
n=a[0]
m=a[1]
a1=[int(x) for x in input().split()]
a2=[int(x) for x in input().split()]
a1.sort(reverse=True)
a2.sort(reverse=True)
b1=a1[1]*a2[0]
b2=a1[-1]*a2[-1]
if b1>b2:print(b1)
else:print(b2) | Title: A Compatible Pair
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cr... | ```python
a=[int(x) for x in input().split()]
n=a[0]
m=a[1]
a1=[int(x) for x in input().split()]
a2=[int(x) for x in input().split()]
a1.sort(reverse=True)
a2.sort(reverse=True)
b1=a1[1]*a2[0]
b2=a1[-1]*a2[-1]
if b1>b2:print(b1)
else:print(b2)
``` | 0 | |
911 | C | Three Garlands | PROGRAMMING | 1,400 | [
"brute force",
"constructive algorithms"
] | null | null | Mishka is decorating the Christmas tree. He has got three garlands, and all of them will be put on the tree. After that Mishka will switch these garlands on.
When a garland is switched on, it periodically changes its state — sometimes it is lit, sometimes not. Formally, if *i*-th garland is switched on during *x*-th s... | The first line contains three integers *k*1, *k*2 and *k*3 (1<=≤<=*k**i*<=≤<=1500) — time intervals of the garlands. | If Mishka can choose moments of time to switch on the garlands in such a way that each second after switching the garlands on at least one garland will be lit, print YES.
Otherwise, print NO. | [
"2 2 3\n",
"4 2 3\n"
] | [
"YES\n",
"NO\n"
] | In the first example Mishka can choose *x*<sub class="lower-index">1</sub> = 1, *x*<sub class="lower-index">2</sub> = 2, *x*<sub class="lower-index">3</sub> = 1. The first garland will be lit during seconds 1, 3, 5, 7, ..., the second — 2, 4, 6, 8, ..., which already cover all the seconds after the 2-nd one. It doesn't... | 0 | [
{
"input": "2 2 3",
"output": "YES"
},
{
"input": "4 2 3",
"output": "NO"
},
{
"input": "1499 1498 1500",
"output": "NO"
},
{
"input": "1500 1500 1500",
"output": "NO"
},
{
"input": "100 4 1",
"output": "YES"
},
{
"input": "4 2 4",
"output": "YES"
... | 1,579,539,142 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 5 | 139 | 409,600 | '''input
4 2 3
'''
from collections import defaultdict as dd
from collections import Counter as ccd
from itertools import permutations as pp
from itertools import combinations as cc
from random import randint as rd
from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq as hq
... | Title: Three Garlands
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mishka is decorating the Christmas tree. He has got three garlands, and all of them will be put on the tree. After that Mishka will switch these garlands on.
When a garland is switched on, it periodically changes its st... | ```python
'''input
4 2 3
'''
from collections import defaultdict as dd
from collections import Counter as ccd
from itertools import permutations as pp
from itertools import combinations as cc
from random import randint as rd
from bisect import bisect_left as bl
from bisect import bisect_right as br
import he... | 0 | |
624 | B | Making a String | PROGRAMMING | 1,100 | [
"greedy",
"sortings"
] | null | null | You are given an alphabet consisting of *n* letters, your task is to make a string of the maximum possible length so that the following conditions are satisfied:
- the *i*-th letter occurs in the string no more than *a**i* times; - the number of occurrences of each letter in the string must be distinct for all the ... | The first line of the input contains a single integer *n* (2<=<=≤<=<=*n*<=<=≤<=<=26) — the number of letters in the alphabet.
The next line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=109) — *i*-th of these integers gives the limitation on the number of occurrences of the *i*-th character in the string. | Print a single integer — the maximum length of the string that meets all the requirements. | [
"3\n2 5 5\n",
"3\n1 1 2\n"
] | [
"11\n",
"3\n"
] | For convenience let's consider an alphabet consisting of three letters: "a", "b", "c". In the first sample, some of the optimal strings are: "cccaabbccbb", "aabcbcbcbcb". In the second sample some of the optimal strings are: "acc", "cbc". | 1,000 | [
{
"input": "3\n2 5 5",
"output": "11"
},
{
"input": "3\n1 1 2",
"output": "3"
},
{
"input": "2\n1 1",
"output": "1"
},
{
"input": "3\n1 1000000000 2",
"output": "1000000003"
},
{
"input": "26\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 10000... | 1,454,606,848 | 1,348 | Python 3 | OK | TESTS | 57 | 62 | 0 | n = int(input())
d = [int(i) for i in input().split()]
d = sorted(d, reverse=True)
for i in range(1, len(d)):
d[i] = max(0, min(d[i - 1] - 1, d[i]))
print(sum(d)) | Title: Making a String
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given an alphabet consisting of *n* letters, your task is to make a string of the maximum possible length so that the following conditions are satisfied:
- the *i*-th letter occurs in the string no more than ... | ```python
n = int(input())
d = [int(i) for i in input().split()]
d = sorted(d, reverse=True)
for i in range(1, len(d)):
d[i] = max(0, min(d[i - 1] - 1, d[i]))
print(sum(d))
``` | 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,687,976,822 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 31 | 0 | m,n,a = map(int,input().split())
if ((m==n or m==a or n==a) and( m<a or m>a)):
print(a) | 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
m,n,a = map(int,input().split())
if ((m==n or m==a or n==a) and( m<a or m>a)):
print(a)
``` | 0 |
215 | A | Bicycle Chain | PROGRAMMING | 900 | [
"brute force",
"implementation"
] | null | null | Vasya's bicycle chain drive consists of two parts: *n* stars are attached to the pedal axle, *m* stars are attached to the rear wheel axle. The chain helps to rotate the rear wheel by transmitting the pedal rotation.
We know that the *i*-th star on the pedal axle has *a**i* (0<=<<=*a*1<=<<=*a*2<=<<=...<=<<... | The first input line contains integer *n* (1<=≤<=*n*<=≤<=50) — the number of stars on the bicycle's pedal axle. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=104) in the order of strict increasing.
The third input line contains integer *m* (1<=≤<=*m*<=≤<=50) — the number of stars o... | Print the number of "integer" gears with the maximum ratio among all "integer" gears. | [
"2\n4 5\n3\n12 13 15\n",
"4\n1 2 3 4\n5\n10 11 12 13 14\n"
] | [
"2\n",
"1\n"
] | In the first sample the maximum "integer" gear ratio equals 3. There are two gears that have such gear ratio. For one of them *a*<sub class="lower-index">1</sub> = 4, *b*<sub class="lower-index">1</sub> = 12, and for the other *a*<sub class="lower-index">2</sub> = 5, *b*<sub class="lower-index">3</sub> = 15. | 500 | [
{
"input": "2\n4 5\n3\n12 13 15",
"output": "2"
},
{
"input": "4\n1 2 3 4\n5\n10 11 12 13 14",
"output": "1"
},
{
"input": "1\n1\n1\n1",
"output": "1"
},
{
"input": "2\n1 2\n1\n1",
"output": "1"
},
{
"input": "1\n1\n2\n1 2",
"output": "1"
},
{
"input":... | 1,662,671,883 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 57 | 124 | 1,740,800 | n = int(input())
a=[]
b=[]
c=input()
a=c.split()
m = int(input())
d=(input())
b=d.split()
ma=0
ans=0
for i in b:
for j in a:
if((int(i))%(int(j))==0):
ma=max(ma,(int(i))/(int(j)))
for i in b:
for j in a:
if(int(i)%int(j)==0):
if int(i)/int(j) == ... | Title: Bicycle Chain
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya's bicycle chain drive consists of two parts: *n* stars are attached to the pedal axle, *m* stars are attached to the rear wheel axle. The chain helps to rotate the rear wheel by transmitting the pedal rotation.
We ... | ```python
n = int(input())
a=[]
b=[]
c=input()
a=c.split()
m = int(input())
d=(input())
b=d.split()
ma=0
ans=0
for i in b:
for j in a:
if((int(i))%(int(j))==0):
ma=max(ma,(int(i))/(int(j)))
for i in b:
for j in a:
if(int(i)%int(j)==0):
if int(i)/... | 3 | |
339 | A | Helpful Maths | PROGRAMMING | 800 | [
"greedy",
"implementation",
"sortings",
"strings"
] | null | null | Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xe... | The first line contains a non-empty string *s* — the sum Xenia needs to count. String *s* contains no spaces. It only contains digits and characters "+". Besides, string *s* is a correct sum of numbers 1, 2 and 3. String *s* is at most 100 characters long. | Print the new sum that Xenia can count. | [
"3+2+1\n",
"1+1+3+1+3\n",
"2\n"
] | [
"1+2+3\n",
"1+1+1+3+3\n",
"2\n"
] | none | 500 | [
{
"input": "3+2+1",
"output": "1+2+3"
},
{
"input": "1+1+3+1+3",
"output": "1+1+1+3+3"
},
{
"input": "2",
"output": "2"
},
{
"input": "2+2+1+1+3",
"output": "1+1+2+2+3"
},
{
"input": "2+1+2+2+2+3+1+3+1+2",
"output": "1+1+1+2+2+2+2+2+3+3"
},
{
"input": ... | 1,699,193,448 | 2,147,483,647 | Python 3 | OK | TESTS | 21 | 92 | 0 | s = input()
summands = []
for char in s:
if char.isdigit():
summands.append(char)
summands.sort()
new_sum = '+'.join(summands)
print(new_sum)
| Title: Helpful Maths
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To mak... | ```python
s = input()
summands = []
for char in s:
if char.isdigit():
summands.append(char)
summands.sort()
new_sum = '+'.join(summands)
print(new_sum)
``` | 3 | |
729 | A | Interview with Oleg | PROGRAMMING | 900 | [
"implementation",
"strings"
] | null | null | Polycarp has interviewed Oleg and has written the interview down without punctuation marks and spaces to save time. Thus, the interview is now a string *s* consisting of *n* lowercase English letters.
There is a filler word ogo in Oleg's speech. All words that can be obtained from ogo by adding go several times to the... | The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100) — the length of the interview.
The second line contains the string *s* of length *n*, consisting of lowercase English letters. | Print the interview text after the replacement of each of the fillers with "***". It is allowed for the substring "***" to have several consecutive occurences. | [
"7\naogogob\n",
"13\nogogmgogogogo\n",
"9\nogoogoogo\n"
] | [
"a***b\n",
"***gmg***\n",
"*********\n"
] | The first sample contains one filler word ogogo, so the interview for printing is "a***b".
The second sample contains two fillers ogo and ogogogo. Thus, the interview is transformed to "***gmg***". | 500 | [
{
"input": "7\naogogob",
"output": "a***b"
},
{
"input": "13\nogogmgogogogo",
"output": "***gmg***"
},
{
"input": "9\nogoogoogo",
"output": "*********"
},
{
"input": "32\nabcdefogoghijklmnogoopqrstuvwxyz",
"output": "abcdef***ghijklmn***opqrstuvwxyz"
},
{
"input":... | 1,479,634,357 | 1,657 | Python 3 | WRONG_ANSWER | TESTS | 19 | 62 | 0 | n = int(input())
s = input()
i = 0
ans = ""
if n < 3:
ans = s
j = -1
while(i < n - 2):
res = s[i:i + 3]
if res == "ogo":
ans += "***"
i += 3
j = i
elif j == i and res[:2] == "go":
i += 2
j += 2
else:
ans += s[i]
i += 1
if j =... | Title: Interview with Oleg
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarp has interviewed Oleg and has written the interview down without punctuation marks and spaces to save time. Thus, the interview is now a string *s* consisting of *n* lowercase English letters.
There is a fi... | ```python
n = int(input())
s = input()
i = 0
ans = ""
if n < 3:
ans = s
j = -1
while(i < n - 2):
res = s[i:i + 3]
if res == "ogo":
ans += "***"
i += 3
j = i
elif j == i and res[:2] == "go":
i += 2
j += 2
else:
ans += s[i]
i +=... | 0 | |
58 | A | Chat room | PROGRAMMING | 1,000 | [
"greedy",
"strings"
] | A. Chat room | 1 | 256 | Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, ... | 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,509,766,360 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 61 | 0 | x = input()
l = list(x)
for i in range(len(l)-1,-1,-1):
if l[i] == l[i-1]:
if l[i]== 'l' and i >= 2:
if l[i-2] != 'l':
continue
else:
l.remove(l[i])
else:
l.remove(l[i])
s = ''.join(l)
if 'hello' in s :
print('YES... | Title: Chat room
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letter... | ```python
x = input()
l = list(x)
for i in range(len(l)-1,-1,-1):
if l[i] == l[i-1]:
if l[i]== 'l' and i >= 2:
if l[i-2] != 'l':
continue
else:
l.remove(l[i])
else:
l.remove(l[i])
s = ''.join(l)
if 'hello' in s :
... | 0 |
242 | C | King's Path | PROGRAMMING | 1,800 | [
"dfs and similar",
"graphs",
"hashing",
"shortest paths"
] | null | null | The black king is standing on a chess field consisting of 109 rows and 109 columns. We will consider the rows of the field numbered with integers from 1 to 109 from top to bottom. The columns are similarly numbered with integers from 1 to 109 from left to right. We will denote a cell of the field that is located in the... | The first line contains four space-separated integers *x*0,<=*y*0,<=*x*1,<=*y*1 (1<=≤<=*x*0,<=*y*0,<=*x*1,<=*y*1<=≤<=109), denoting the initial and the final positions of the king.
The second line contains a single integer *n* (1<=≤<=*n*<=≤<=105), denoting the number of segments of allowed cells. Next *n* lines contai... | If there is no path between the initial and final position along allowed cells, print -1.
Otherwise print a single integer — the minimum number of moves the king needs to get from the initial position to the final one. | [
"5 7 6 11\n3\n5 3 8\n6 7 11\n5 2 5\n",
"3 4 3 10\n3\n3 1 4\n4 5 9\n3 10 10\n",
"1 1 2 10\n2\n1 1 3\n2 6 10\n"
] | [
"4\n",
"6\n",
"-1\n"
] | none | 1,500 | [
{
"input": "5 7 6 11\n3\n5 3 8\n6 7 11\n5 2 5",
"output": "4"
},
{
"input": "3 4 3 10\n3\n3 1 4\n4 5 9\n3 10 10",
"output": "6"
},
{
"input": "1 1 2 10\n2\n1 1 3\n2 6 10",
"output": "-1"
},
{
"input": "9 8 7 8\n9\n10 6 6\n10 6 6\n7 7 8\n9 5 6\n8 9 9\n9 5 5\n9 8 8\n8 5 6\n9 10... | 1,655,997,773 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 43 | 1,652 | 19,251,200 | from collections import deque
x,y,x2,y2 = map(int,input().split())
n = int(input())
kletki = {}
for i in range(n):
r,a,b = map(int,input().split())
for j in range(a,b+1):
kletki[(r,j)] = -1
kletki[(x,y)] = 0
d = deque()
d.append((x,y))
dx = [ -1,-1,0,1,1,1,0,-1]
dy = [0,-1,-1,-1,0,1,... | Title: King's Path
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The black king is standing on a chess field consisting of 109 rows and 109 columns. We will consider the rows of the field numbered with integers from 1 to 109 from top to bottom. The columns are similarly numbered with int... | ```python
from collections import deque
x,y,x2,y2 = map(int,input().split())
n = int(input())
kletki = {}
for i in range(n):
r,a,b = map(int,input().split())
for j in range(a,b+1):
kletki[(r,j)] = -1
kletki[(x,y)] = 0
d = deque()
d.append((x,y))
dx = [ -1,-1,0,1,1,1,0,-1]
dy = [0,-1,... | 3 | |
600 | B | Queries about less or equal elements | PROGRAMMING | 1,300 | [
"binary search",
"data structures",
"sortings",
"two pointers"
] | null | null | You are given two arrays of integers *a* and *b*. For each element of the second array *b**j* you should find the number of elements in array *a* that are less than or equal to the value *b**j*. | The first line contains two integers *n*,<=*m* (1<=≤<=*n*,<=*m*<=≤<=2·105) — the sizes of arrays *a* and *b*.
The second line contains *n* integers — the elements of array *a* (<=-<=109<=≤<=*a**i*<=≤<=109).
The third line contains *m* integers — the elements of array *b* (<=-<=109<=≤<=*b**j*<=≤<=109). | Print *m* integers, separated by spaces: the *j*-th of which is equal to the number of such elements in array *a* that are less than or equal to the value *b**j*. | [
"5 4\n1 3 5 7 9\n6 4 2 8\n",
"5 5\n1 2 1 2 5\n3 1 4 1 5\n"
] | [
"3 2 1 4\n",
"4 2 4 2 5\n"
] | none | 0 | [
{
"input": "5 4\n1 3 5 7 9\n6 4 2 8",
"output": "3 2 1 4"
},
{
"input": "5 5\n1 2 1 2 5\n3 1 4 1 5",
"output": "4 2 4 2 5"
},
{
"input": "1 1\n-1\n-2",
"output": "0"
},
{
"input": "1 1\n-80890826\n686519510",
"output": "1"
},
{
"input": "11 11\n237468511 -77918754... | 1,680,514,904 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 60 | 405 | 33,280,000 | import bisect
a,b = map(int,input().split())
arr1 = list(map(int,input().split()))
arr2 = list(map(int,input().split()))
arr1.sort()
for i in arr2:
count=bisect.bisect_right(arr1,i)
print(count,end=" ")
| Title: Queries about less or equal elements
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given two arrays of integers *a* and *b*. For each element of the second array *b**j* you should find the number of elements in array *a* that are less than or equal to the value *b**j*.
In... | ```python
import bisect
a,b = map(int,input().split())
arr1 = list(map(int,input().split()))
arr2 = list(map(int,input().split()))
arr1.sort()
for i in arr2:
count=bisect.bisect_right(arr1,i)
print(count,end=" ")
``` | 3 | |
664 | A | Complicated GCD | PROGRAMMING | 800 | [
"math",
"number theory"
] | null | null | Greatest common divisor *GCD*(*a*,<=*b*) of two positive integers *a* and *b* is equal to the biggest integer *d* such that both integers *a* and *b* are divisible by *d*. There are many efficient algorithms to find greatest common divisor *GCD*(*a*,<=*b*), for example, Euclid algorithm.
Formally, find the biggest in... | The only line of the input contains two integers *a* and *b* (1<=≤<=*a*<=≤<=*b*<=≤<=10100). | Output one integer — greatest common divisor of all integers from *a* to *b* inclusive. | [
"1 2\n",
"61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576\n"
] | [
"1\n",
"61803398874989484820458683436563811772030917980576\n"
] | none | 500 | [
{
"input": "1 2",
"output": "1"
},
{
"input": "61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576",
"output": "61803398874989484820458683436563811772030917980576"
},
{
"input": "1 100",
"output": "1"
},
{
"input": "100 100000... | 1,680,292,206 | 2,147,483,647 | PyPy 3-64 | TIME_LIMIT_EXCEEDED | TESTS | 4 | 1,000 | 1,843,200 | a,b = map(int,input().split())
ans = a
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
for i in range(a+1, b+1):
ans = gcd(ans,i)
print(ans) | Title: Complicated GCD
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Greatest common divisor *GCD*(*a*,<=*b*) of two positive integers *a* and *b* is equal to the biggest integer *d* such that both integers *a* and *b* are divisible by *d*. There are many efficient algorithms to find gre... | ```python
a,b = map(int,input().split())
ans = a
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
for i in range(a+1, b+1):
ans = gcd(ans,i)
print(ans)
``` | 0 | |
0 | none | none | none | 0 | [
"none"
] | null | null | DZY has a sequence *a*, consisting of *n* integers.
We'll call a sequence *a**i*,<=*a**i*<=+<=1,<=...,<=*a**j* (1<=≤<=*i*<=≤<=*j*<=≤<=*n*) a subsegment of the sequence *a*. The value (*j*<=-<=*i*<=+<=1) denotes the length of the subsegment.
Your task is to find the longest subsegment of *a*, such that it is possible ... | The first line contains integer *n* (1<=≤<=*n*<=≤<=105). The next line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109). | In a single line print the answer to the problem — the maximum length of the required subsegment. | [
"6\n7 2 3 1 5 6\n"
] | [
"5\n"
] | You can choose subsegment *a*<sub class="lower-index">2</sub>, *a*<sub class="lower-index">3</sub>, *a*<sub class="lower-index">4</sub>, *a*<sub class="lower-index">5</sub>, *a*<sub class="lower-index">6</sub> and change its 3rd element (that is *a*<sub class="lower-index">4</sub>) to 4. | 0 | [
{
"input": "6\n7 2 3 1 5 6",
"output": "5"
},
{
"input": "10\n424238336 649760493 681692778 714636916 719885387 804289384 846930887 957747794 596516650 189641422",
"output": "9"
},
{
"input": "50\n804289384 846930887 681692778 714636916 957747794 424238336 719885387 649760493 596516650 1... | 1,405,268,339 | 2,147,483,647 | Python 3 | OK | TESTS | 92 | 405 | 9,216,000 | n = int(input())
a = [-1] + list(map(int, input().split())) + [1000000007]
maxi = 0
up = [0 for i in range(n+2)]
down = [0 for i in range(n+2)]
for i in range(1, n+1):
up[i] = up[i-1] + 1 if a[i] > a[i-1] else 1
for i in range(n, 0, -1):
down[i] = down[i+1] + 1 if a[i] < a[i+1] else 1
for i in range(1, n+1):
maxi ... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
DZY has a sequence *a*, consisting of *n* integers.
We'll call a sequence *a**i*,<=*a**i*<=+<=1,<=...,<=*a**j* (1<=≤<=*i*<=≤<=*j*<=≤<=*n*) a subsegment of the sequence *a*. The value (*j*<=-<=*i*<=+<=1) denotes the length of the ... | ```python
n = int(input())
a = [-1] + list(map(int, input().split())) + [1000000007]
maxi = 0
up = [0 for i in range(n+2)]
down = [0 for i in range(n+2)]
for i in range(1, n+1):
up[i] = up[i-1] + 1 if a[i] > a[i-1] else 1
for i in range(n, 0, -1):
down[i] = down[i+1] + 1 if a[i] < a[i+1] else 1
for i in range(1, n+... | 3 | |
128 | C | Games with Rectangle | PROGRAMMING | 2,000 | [
"combinatorics",
"dp"
] | null | null | In this task Anna and Maria play the following game. Initially they have a checkered piece of paper with a painted *n*<=×<=*m* rectangle (only the border, no filling). Anna and Maria move in turns and Anna starts. During each move one should paint inside the last-painted rectangle a new lesser rectangle (along the grid... | The first and only line contains three integers: *n*,<=*m*,<=*k* (1<=≤<=*n*,<=*m*,<=*k*<=≤<=1000). | Print the single number — the number of the ways to play the game. As this number can be very big, print the value modulo 1000000007 (109<=+<=7). | [
"3 3 1\n",
"4 4 1\n",
"6 7 2\n"
] | [
"1\n",
"9\n",
"75\n"
] | Two ways to play the game are considered different if the final pictures are different. In other words, if one way contains a rectangle that is not contained in the other way.
In the first sample Anna, who performs her first and only move, has only one possible action plan — insert a 1 × 1 square inside the given 3 × ... | 1,500 | [
{
"input": "3 3 1",
"output": "1"
},
{
"input": "4 4 1",
"output": "9"
},
{
"input": "6 7 2",
"output": "75"
},
{
"input": "5 5 3",
"output": "0"
},
{
"input": "2 2 1",
"output": "0"
},
{
"input": "999 999 499",
"output": "1"
},
{
"input": ... | 1,632,460,227 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 15 | 1,606 | 21,401,600 | p = int(1e9+7)
def solv(n,m,kk):
k2 = (kk<<1)+1
kn,km = n-k2,m-k2
if kn<0 or km<0: return 0
kl = max(kn,km)
K = list(range(1,kl+2))
M = [1]*(kl+1)
for k in range(1,kk+1): #convolution
T = [0]*(kl+1)
for i in range(kl+1):
t = 0
... | Title: Games with Rectangle
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In this task Anna and Maria play the following game. Initially they have a checkered piece of paper with a painted *n*<=×<=*m* rectangle (only the border, no filling). Anna and Maria move in turns and Anna starts. ... | ```python
p = int(1e9+7)
def solv(n,m,kk):
k2 = (kk<<1)+1
kn,km = n-k2,m-k2
if kn<0 or km<0: return 0
kl = max(kn,km)
K = list(range(1,kl+2))
M = [1]*(kl+1)
for k in range(1,kk+1): #convolution
T = [0]*(kl+1)
for i in range(kl+1):
t = 0
... | 0 | |
26 | A | Almost Prime | PROGRAMMING | 900 | [
"number theory"
] | A. Almost Prime | 2 | 256 | A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, inclusive. | Input contains one integer number *n* (1<=≤<=*n*<=≤<=3000). | Output the amount of almost prime numbers between 1 and *n*, inclusive. | [
"10\n",
"21\n"
] | [
"2\n",
"8\n"
] | none | 500 | [
{
"input": "10",
"output": "2"
},
{
"input": "21",
"output": "8"
},
{
"input": "1",
"output": "0"
},
{
"input": "2",
"output": "0"
},
{
"input": "4",
"output": "0"
},
{
"input": "3",
"output": "0"
},
{
"input": "8",
"output": "1"
},
... | 1,609,921,612 | 2,147,483,647 | Python 3 | COMPILATION_ERROR | TESTS | 0 | 0 | 0 | def fun(n):
l=[1]*n
l[0]=0
l[1]=0
for i in range(2,n):
if(l[i]==1):
for j in range(i*2,n,i):
l[j]=0
return l
n=int(input()
res=fun(n)
cnt=0
res=0
for i in range(4,n):
for j in range(n):
if(res[j]==1 and i%j==0 and j<=i):
cnt... | Title: Almost Prime
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, in... | ```python
def fun(n):
l=[1]*n
l[0]=0
l[1]=0
for i in range(2,n):
if(l[i]==1):
for j in range(i*2,n,i):
l[j]=0
return l
n=int(input()
res=fun(n)
cnt=0
res=0
for i in range(4,n):
for j in range(n):
if(res[j]==1 and i%j==0 and j<=i):
... | -1 |
169 | A | Chores | PROGRAMMING | 800 | [
"sortings"
] | null | null | Petya and Vasya are brothers. Today is a special day for them as their parents left them home alone and commissioned them to do *n* chores. Each chore is characterized by a single parameter — its complexity. The complexity of the *i*-th chore equals *h**i*.
As Petya is older, he wants to take the chores with complexit... | The first input line contains three integers *n*,<=*a* and *b* (2<=≤<=*n*<=≤<=2000; *a*,<=*b*<=≥<=1; *a*<=+<=*b*<==<=*n*) — the total number of chores, the number of Petya's chores and the number of Vasya's chores.
The next line contains a sequence of integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=109), *h**i* ... | Print the required number of ways to choose an integer value of *x*. If there are no such ways, print 0. | [
"5 2 3\n6 2 3 100 1\n",
"7 3 4\n1 1 9 1 1 1 1\n"
] | [
"3\n",
"0\n"
] | In the first sample the possible values of *x* are 3, 4 or 5.
In the second sample it is impossible to find such *x*, that Petya got 3 chores and Vasya got 4. | 500 | [
{
"input": "5 2 3\n6 2 3 100 1",
"output": "3"
},
{
"input": "7 3 4\n1 1 9 1 1 1 1",
"output": "0"
},
{
"input": "2 1 1\n10 2",
"output": "8"
},
{
"input": "2 1 1\n7 7",
"output": "0"
},
{
"input": "2 1 1\n1 1000000000",
"output": "999999999"
},
{
"inp... | 1,545,140,993 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 93 | 0 | fl = list(map(int, input().split()))
arr = list(map(int, input().split()))
count = 0
arr.sort()
max_vasya_chores = arr[fl[1]]
min_petya_chores = arr[fl[2]]
x = min_petya_chores - max_vasya_chores
print(x)
| Title: Chores
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Petya and Vasya are brothers. Today is a special day for them as their parents left them home alone and commissioned them to do *n* chores. Each chore is characterized by a single parameter — its complexity. The complexity of th... | ```python
fl = list(map(int, input().split()))
arr = list(map(int, input().split()))
count = 0
arr.sort()
max_vasya_chores = arr[fl[1]]
min_petya_chores = arr[fl[2]]
x = min_petya_chores - max_vasya_chores
print(x)
``` | 0 | |
954 | A | Diagonal Walking | PROGRAMMING | 800 | [
"implementation"
] | null | null | Mikhail walks on a 2D plane. He can go either up or right. You are given a sequence of Mikhail's moves. He thinks that this sequence is too long and he wants to make it as short as possible.
In the given sequence moving up is described by character U and moving right is described by character R. Mikhail can replace an... | The first line of the input contains one integer *n* (1<=≤<=*n*<=≤<=100) — the length of the sequence. The second line contains the sequence consisting of *n* characters U and R. | Print the minimum possible length of the sequence of moves after all replacements are done. | [
"5\nRUURU\n",
"17\nUUURRRRRUUURURUUU\n"
] | [
"3\n",
"13\n"
] | In the first test the shortened sequence of moves may be DUD (its length is 3).
In the second test the shortened sequence of moves can be UUDRRRDUDDUUU (its length is 13). | 0 | [
{
"input": "5\nRUURU",
"output": "3"
},
{
"input": "17\nUUURRRRRUUURURUUU",
"output": "13"
},
{
"input": "100\nUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU",
"output": "100"
},
{
"input": "100\nRRURRUUUURURRRURRRRURRRRRR... | 1,637,505,143 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 3 | 46 | 0 | n=int(input())
s=input()
c=s.count('UR' and 'RU')
if c==0:
print(n)
exit()
if c<n//2:
print(n-c-1)
if c>=n//2:
print(n-c) | Title: Diagonal Walking
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mikhail walks on a 2D plane. He can go either up or right. You are given a sequence of Mikhail's moves. He thinks that this sequence is too long and he wants to make it as short as possible.
In the given sequence movi... | ```python
n=int(input())
s=input()
c=s.count('UR' and 'RU')
if c==0:
print(n)
exit()
if c<n//2:
print(n-c-1)
if c>=n//2:
print(n-c)
``` | 0 | |
218 | B | Airport | PROGRAMMING | 1,100 | [
"implementation"
] | null | null | Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
- it is up to a passenger to choose a plane to fly on; - if the chosen plane has *x* (*x*<=><=0) empty seats at the given moment, then the ticket for such a plane ... | The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains *m* integers *a*1,<=*a*2,<=...,<=*a**m* (1<=≤<=*a**i*<=≤<=1000) — *a**i* stands for the number of empty seats in the *i*-th... | Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly. | [
"4 3\n2 1 1\n",
"4 3\n2 2 2\n"
] | [
"5 5\n",
"7 6\n"
] | In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd pl... | 500 | [
{
"input": "4 3\n2 1 1",
"output": "5 5"
},
{
"input": "4 3\n2 2 2",
"output": "7 6"
},
{
"input": "10 5\n10 3 3 1 2",
"output": "58 26"
},
{
"input": "10 1\n10",
"output": "55 55"
},
{
"input": "10 1\n100",
"output": "955 955"
},
{
"input": "10 2\n4 7... | 1,676,567,260 | 2,147,483,647 | PyPy 3 | OK | TESTS | 33 | 156 | 0 | m,n=map(int,input().split())
l=list(map(int,input().split()))
x=[i for i in l]
y=[i for i in l]
x.sort()
y.sort()
maxi=0
mini=0
for i in range(m):
maxi+=x[-1]
x[-1]-=1
x.sort()
mini+=y[0]
y[0]-=1
y.sort()
if 0 in y:
y.remove(0)
print(maxi,mini)
| Title: Airport
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
- it is up to a passenger to choose a plane to fly on; - if the chosen pl... | ```python
m,n=map(int,input().split())
l=list(map(int,input().split()))
x=[i for i in l]
y=[i for i in l]
x.sort()
y.sort()
maxi=0
mini=0
for i in range(m):
maxi+=x[-1]
x[-1]-=1
x.sort()
mini+=y[0]
y[0]-=1
y.sort()
if 0 in y:
y.remove(0)
print(maxi,mini)
... | 3 | |
25 | A | IQ test | PROGRAMMING | 1,300 | [
"brute force"
] | A. IQ test | 2 | 256 | Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that i... | The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness. | Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order. | [
"5\n2 4 7 8 10\n",
"4\n1 2 1 1\n"
] | [
"3\n",
"2\n"
] | none | 0 | [
{
"input": "5\n2 4 7 8 10",
"output": "3"
},
{
"input": "4\n1 2 1 1",
"output": "2"
},
{
"input": "3\n1 2 2",
"output": "1"
},
{
"input": "3\n100 99 100",
"output": "2"
},
{
"input": "3\n5 3 2",
"output": "3"
},
{
"input": "4\n43 28 1 91",
"output"... | 1,591,941,299 | 2,147,483,647 | Python 3 | OK | TESTS | 32 | 218 | 307,200 | from math import ceil
n=int(input())
vals=[int(i) for i in input().split(" ")]
if(vals[0]%2==0 and vals[1]%2==0):
for i in range(2,n):
# print("here")
if(vals[i]%2==1):
print(i+1)
break
elif(vals[0]%2!=0 and vals[1]%2!=0):
for i in range(2,n):
if(vals[i]%2==0):... | Title: IQ test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — t... | ```python
from math import ceil
n=int(input())
vals=[int(i) for i in input().split(" ")]
if(vals[0]%2==0 and vals[1]%2==0):
for i in range(2,n):
# print("here")
if(vals[i]%2==1):
print(i+1)
break
elif(vals[0]%2!=0 and vals[1]%2!=0):
for i in range(2,n):
if(vals... | 3.944928 |
296 | A | Yaroslav and Permutations | PROGRAMMING | 1,100 | [
"greedy",
"math"
] | null | null | Yaroslav has an array that consists of *n* integers. In one second Yaroslav can swap two neighboring array elements. Now Yaroslav is wondering if he can obtain an array where any two neighboring elements would be distinct in a finite time.
Help Yaroslav. | The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of elements in the array. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000) — the array elements. | In the single line print "YES" (without the quotes) if Yaroslav can obtain the array he needs, and "NO" (without the quotes) otherwise. | [
"1\n1\n",
"3\n1 1 2\n",
"4\n7 7 7 7\n"
] | [
"YES\n",
"YES\n",
"NO\n"
] | In the first sample the initial array fits well.
In the second sample Yaroslav can get array: 1, 2, 1. He can swap the last and the second last elements to obtain it.
In the third sample Yarosav can't get the array he needs. | 500 | [
{
"input": "1\n1",
"output": "YES"
},
{
"input": "3\n1 1 2",
"output": "YES"
},
{
"input": "4\n7 7 7 7",
"output": "NO"
},
{
"input": "4\n479 170 465 146",
"output": "YES"
},
{
"input": "5\n996 437 605 996 293",
"output": "YES"
},
{
"input": "6\n727 53... | 1,651,385,669 | 2,147,483,647 | PyPy 3 | RUNTIME_ERROR | TESTS | 11 | 184 | 2,048,000 | n = int(input())
lst = [int(i) for i in input().split(' ')]
lst2 = [0 for i in range(1000)]
mx = 0
for i in range(n):
lst2[lst[i]]+=1
if lst2[lst[i]]>mx:
mx = lst2[lst[i]]
if(mx>((n+1)//2)):
print('NO')
else:
print('YES') | Title: Yaroslav and Permutations
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Yaroslav has an array that consists of *n* integers. In one second Yaroslav can swap two neighboring array elements. Now Yaroslav is wondering if he can obtain an array where any two neighboring elements would... | ```python
n = int(input())
lst = [int(i) for i in input().split(' ')]
lst2 = [0 for i in range(1000)]
mx = 0
for i in range(n):
lst2[lst[i]]+=1
if lst2[lst[i]]>mx:
mx = lst2[lst[i]]
if(mx>((n+1)//2)):
print('NO')
else:
print('YES')
``` | -1 | |
757 | B | Bash's Big Day | PROGRAMMING | 1,400 | [
"greedy",
"math",
"number theory"
] | null | null | Bash has set out on a journey to become the greatest Pokemon master. To get his first Pokemon, he went to Professor Zulu's Lab. Since Bash is Professor Zulu's favourite student, Zulu allows him to take as many Pokemon from his lab as he pleases.
But Zulu warns him that a group of *k*<=><=1 Pokemon with strengths {*... | The input consists of two lines.
The first line contains an integer *n* (1<=≤<=*n*<=≤<=105), the number of Pokemon in the lab.
The next line contains *n* space separated integers, where the *i*-th of them denotes *s**i* (1<=≤<=*s**i*<=≤<=105), the strength of the *i*-th Pokemon. | Print single integer — the maximum number of Pokemons Bash can take. | [
"3\n2 3 4\n",
"5\n2 3 4 6 7\n"
] | [
"2\n",
"3\n"
] | *gcd* (greatest common divisor) of positive integers set {*a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub>} is the maximum positive integer that divides all the integers {*a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a... | 1,000 | [
{
"input": "3\n2 3 4",
"output": "2"
},
{
"input": "5\n2 3 4 6 7",
"output": "3"
},
{
"input": "3\n5 6 4",
"output": "2"
},
{
"input": "8\n41 74 4 27 85 39 100 36",
"output": "4"
},
{
"input": "6\n89 20 86 81 62 23",
"output": "3"
},
{
"input": "71\n23... | 1,616,222,992 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 11 | 249 | 9,216,000 | n=input()
l=[]
l2=[]
l=input().strip().split()
l=list(map(int,l))
for i in range(2,1000):
k=0
for j in l:
if j%i==0:
k+=1
l2.append(k)
print(max(l2))
| Title: Bash's Big Day
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bash has set out on a journey to become the greatest Pokemon master. To get his first Pokemon, he went to Professor Zulu's Lab. Since Bash is Professor Zulu's favourite student, Zulu allows him to take as many Pokemon fr... | ```python
n=input()
l=[]
l2=[]
l=input().strip().split()
l=list(map(int,l))
for i in range(2,1000):
k=0
for j in l:
if j%i==0:
k+=1
l2.append(k)
print(max(l2))
``` | 0 | |
583 | A | Asphalting Roads | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | City X consists of *n* vertical and *n* horizontal infinite roads, forming *n*<=×<=*n* intersections. Roads (both vertical and horizontal) are numbered from 1 to *n*, and the intersections are indicated by the numbers of the roads that form them.
Sand roads have long been recognized out of date, so the decision was ma... | The first line contains integer *n* (1<=≤<=*n*<=≤<=50) — the number of vertical and horizontal roads in the city.
Next *n*2 lines contain the order of intersections in the schedule. The *i*-th of them contains two numbers *h**i*,<=*v**i* (1<=≤<=*h**i*,<=*v**i*<=≤<=*n*), separated by a space, and meaning that the inte... | In the single line print the numbers of the days when road works will be in progress in ascending order. The days are numbered starting from 1. | [
"2\n1 1\n1 2\n2 1\n2 2\n",
"1\n1 1\n"
] | [
"1 4 \n",
"1 \n"
] | In the sample the brigade acts like that:
1. On the first day the brigade comes to the intersection of the 1-st horizontal and the 1-st vertical road. As none of them has been asphalted, the workers asphalt the 1-st vertical and the 1-st horizontal road; 1. On the second day the brigade of the workers comes to the i... | 500 | [
{
"input": "2\n1 1\n1 2\n2 1\n2 2",
"output": "1 4 "
},
{
"input": "1\n1 1",
"output": "1 "
},
{
"input": "2\n1 1\n2 2\n1 2\n2 1",
"output": "1 2 "
},
{
"input": "2\n1 2\n2 2\n2 1\n1 1",
"output": "1 3 "
},
{
"input": "3\n2 2\n1 2\n3 2\n3 3\n1 1\n2 3\n1 3\n3 1\n2 ... | 1,443,891,145 | 445 | Python 3 | WRONG_ANSWER | PRETESTS | 3 | 46 | 0 | n = int(input())
m = n**2
L = [list(map(int, input().split())) for _ in range(m)]
H = [ 0 for _ in range(n)]
V = [ 0 for _ in range(n)]
R = ""
for k in range(m):
i = L[k][0]-1
j = L[k][1]-1
if H[i] == 0 and V[j] == 0:
H[i] = 1
V[i] = 1
R = R + str(k+1) + ' '
print(R) | Title: Asphalting Roads
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
City X consists of *n* vertical and *n* horizontal infinite roads, forming *n*<=×<=*n* intersections. Roads (both vertical and horizontal) are numbered from 1 to *n*, and the intersections are indicated by the numbers ... | ```python
n = int(input())
m = n**2
L = [list(map(int, input().split())) for _ in range(m)]
H = [ 0 for _ in range(n)]
V = [ 0 for _ in range(n)]
R = ""
for k in range(m):
i = L[k][0]-1
j = L[k][1]-1
if H[i] == 0 and V[j] == 0:
H[i] = 1
V[i] = 1
R = R + str(k+1) + ' '
print(R)
``` | 0 | |
898 | A | Rounding | PROGRAMMING | 800 | [
"implementation",
"math"
] | null | null | Vasya has a non-negative integer *n*. He wants to round it to nearest integer, which ends up with 0. If *n* already ends up with 0, Vasya considers it already rounded.
For example, if *n*<==<=4722 answer is 4720. If *n*<==<=5 Vasya can round it to 0 or to 10. Both ways are correct.
For given *n* find out to which int... | The first line contains single integer *n* (0<=≤<=*n*<=≤<=109) — number that Vasya has. | Print result of rounding *n*. Pay attention that in some cases answer isn't unique. In that case print any correct answer. | [
"5\n",
"113\n",
"1000000000\n",
"5432359\n"
] | [
"0\n",
"110\n",
"1000000000\n",
"5432360\n"
] | In the first example *n* = 5. Nearest integers, that ends up with zero are 0 and 10. Any of these answers is correct, so you can print 0 or 10. | 500 | [
{
"input": "5",
"output": "0"
},
{
"input": "113",
"output": "110"
},
{
"input": "1000000000",
"output": "1000000000"
},
{
"input": "5432359",
"output": "5432360"
},
{
"input": "999999994",
"output": "999999990"
},
{
"input": "10",
"output": "10"
... | 1,558,572,514 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 0 | 93 | 0 | print(int(input()+5)/10*10) | Title: Rounding
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya has a non-negative integer *n*. He wants to round it to nearest integer, which ends up with 0. If *n* already ends up with 0, Vasya considers it already rounded.
For example, if *n*<==<=4722 answer is 4720. If *n*<==<=5... | ```python
print(int(input()+5)/10*10)
``` | -1 | |
526 | B | Om Nom and Dark Park | PROGRAMMING | 1,400 | [
"dfs and similar",
"greedy",
"implementation"
] | null | null | Om Nom is the main character of a game "Cut the Rope". He is a bright little monster who likes visiting friends living at the other side of the park. However the dark old parks can scare even somebody as fearless as Om Nom, so he asks you to help him.
The park consists of 2*n*<=+<=1<=-<=1 squares connected by roads so... | The first line contains integer *n* (1<=≤<=*n*<=≤<=10) — the number of roads on the path from the entrance to any exit.
The next line contains 2*n*<=+<=1<=-<=2 numbers *a*2,<=*a*3,<=... *a*2*n*<=+<=1<=-<=1 — the initial numbers of street lights on each road of the park. Here *a**i* is the number of street lights on th... | Print the minimum number of street lights that we should add to the roads of the park to make Om Nom feel safe. | [
"2\n1 2 3 4 5 6\n"
] | [
"5\n"
] | Picture for the sample test. Green color denotes the additional street lights. | 500 | [
{
"input": "2\n1 2 3 4 5 6",
"output": "5"
},
{
"input": "2\n1 2 3 3 2 2",
"output": "0"
},
{
"input": "1\n39 52",
"output": "13"
},
{
"input": "2\n59 96 34 48 8 72",
"output": "139"
},
{
"input": "3\n87 37 91 29 58 45 51 74 70 71 47 38 91 89",
"output": "210"... | 1,428,683,694 | 2,147,483,647 | Python 3 | OK | TESTS | 38 | 77 | 1,843,200 | n = int(input())
w = [0, 0] + list(map(int, input().split()))
val = [0 for i in range(100500)]
ans = [0 for i in range(100500)]
def dfs(i):
if i >= 2 ** n:
ans[i] = 0
val[i] = 0
else:
dfs(2 * i + 1)
dfs(2 * i)
ans[i] = ans[2 * i] + ans[2 * i + 1]
val[i] = max(va... | Title: Om Nom and Dark Park
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Om Nom is the main character of a game "Cut the Rope". He is a bright little monster who likes visiting friends living at the other side of the park. However the dark old parks can scare even somebody as fearless a... | ```python
n = int(input())
w = [0, 0] + list(map(int, input().split()))
val = [0 for i in range(100500)]
ans = [0 for i in range(100500)]
def dfs(i):
if i >= 2 ** n:
ans[i] = 0
val[i] = 0
else:
dfs(2 * i + 1)
dfs(2 * i)
ans[i] = ans[2 * i] + ans[2 * i + 1]
val[i... | 3 | |
201 | A | Clear Symmetry | PROGRAMMING | 1,700 | [
"constructive algorithms",
"dp",
"math"
] | null | null | Consider some square matrix *A* with side *n* consisting of zeros and ones. There are *n* rows numbered from 1 to *n* from top to bottom and *n* columns numbered from 1 to *n* from left to right in this matrix. We'll denote the element of the matrix which is located at the intersection of the *i*-row and the *j*-th col... | The only line contains a single integer *x* (1<=≤<=*x*<=≤<=100) — the required sharpness of the matrix. | Print a single number — the sought value of *n*. | [
"4\n",
"9\n"
] | [
"3\n",
"5\n"
] | The figure below shows the matrices that correspond to the samples: | 1,000 | [
{
"input": "4",
"output": "3"
},
{
"input": "9",
"output": "5"
},
{
"input": "10",
"output": "5"
},
{
"input": "12",
"output": "5"
},
{
"input": "1",
"output": "1"
},
{
"input": "19",
"output": "7"
},
{
"input": "3",
"output": "5"
},
... | 1,565,073,813 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 2 | 248 | 0 | def abc () :
pp = (t+1)//2
ans = pp*(pp-1) + pp
#print(ans)
if ans >= x :
return (1)
return (0)
x = int(input())
t = int (pow(x,0.5))
while t :
tt = abc ()
if tt == 1 :
exit(print(t))
t+=1 | Title: Clear Symmetry
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Consider some square matrix *A* with side *n* consisting of zeros and ones. There are *n* rows numbered from 1 to *n* from top to bottom and *n* columns numbered from 1 to *n* from left to right in this matrix. We'll den... | ```python
def abc () :
pp = (t+1)//2
ans = pp*(pp-1) + pp
#print(ans)
if ans >= x :
return (1)
return (0)
x = int(input())
t = int (pow(x,0.5))
while t :
tt = abc ()
if tt == 1 :
exit(print(t))
t+=1
``` | 0 | |
343 | B | Alternating Current | PROGRAMMING | 1,600 | [
"data structures",
"greedy",
"implementation"
] | null | null | Mad scientist Mike has just finished constructing a new device to search for extraterrestrial intelligence! He was in such a hurry to launch it for the first time that he plugged in the power wires without giving it a proper glance and started experimenting right away. After a while Mike observed that the wires ended u... | The single line of the input contains a sequence of characters "+" and "-" of length *n* (1<=≤<=*n*<=≤<=100000). The *i*-th (1<=≤<=*i*<=≤<=*n*) position of the sequence contains the character "+", if on the *i*-th step from the wall the "plus" wire runs above the "minus" wire, and the character "-" otherwise. | Print either "Yes" (without the quotes) if the wires can be untangled or "No" (without the quotes) if the wires cannot be untangled. | [
"-++-\n",
"+-\n",
"++\n",
"-\n"
] | [
"Yes\n",
"No\n",
"Yes\n",
"No\n"
] | The first testcase corresponds to the picture in the statement. To untangle the wires, one can first move the "plus" wire lower, thus eliminating the two crosses in the middle, and then draw it under the "minus" wire, eliminating also the remaining two crosses.
In the second testcase the "plus" wire makes one full rev... | 1,000 | [
{
"input": "-++-",
"output": "Yes"
},
{
"input": "+-",
"output": "No"
},
{
"input": "++",
"output": "Yes"
},
{
"input": "-",
"output": "No"
},
{
"input": "+-+-",
"output": "No"
},
{
"input": "-+-",
"output": "No"
},
{
"input": "-++-+--+",
... | 1,617,720,619 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 92 | 0 | s = input()
res = "NO"
if len(s)%2 == 0:
if s == s[::-1]:
res = "YES"
elif s[:len(s)//2]==s[:len(s)//2][::-1] and s[len(s)//2:]==s[len(s)//2:][::-1]:
res = "YES"
print(res)
| Title: Alternating Current
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mad scientist Mike has just finished constructing a new device to search for extraterrestrial intelligence! He was in such a hurry to launch it for the first time that he plugged in the power wires without giving it... | ```python
s = input()
res = "NO"
if len(s)%2 == 0:
if s == s[::-1]:
res = "YES"
elif s[:len(s)//2]==s[:len(s)//2][::-1] and s[len(s)//2:]==s[len(s)//2:][::-1]:
res = "YES"
print(res)
``` | 0 | |
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,559,187,754 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 109 | 0 | # -*- coding: utf-8 -*-
"""
Created on Thu May 30 09:08:28 2019
@author: avina
"""
n = int(input())
s = input()
e=0;e1=0
for i in range(n-1):
if s[i] == 'S' and s[i+1] == 'F':
e+=1
elif s[i] == 'F' and s[i+1] == 'S':
e1+=1
if e > e1:
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
# -*- coding: utf-8 -*-
"""
Created on Thu May 30 09:08:28 2019
@author: avina
"""
n = int(input())
s = input()
e=0;e1=0
for i in range(n-1):
if s[i] == 'S' and s[i+1] == 'F':
e+=1
elif s[i] == 'F' and s[i+1] == 'S':
e1+=1
if e > e1:
print('YES')
else:
pri... | 3 | |
527 | A | Playing with Paper | PROGRAMMING | 1,100 | [
"implementation",
"math"
] | null | null | One day Vasya was sitting on a not so interesting Maths lesson and making an origami from a rectangular *a* mm <=×<= *b* mm sheet of paper (*a*<=><=*b*). Usually the first step in making an origami is making a square piece of paper from the rectangular sheet by folding the sheet along the bisector of the right angle... | The first line of the input contains two integers *a*, *b* (1<=≤<=*b*<=<<=*a*<=≤<=1012) — the sizes of the original sheet of paper. | Print a single integer — the number of ships that Vasya will make. | [
"2 1\n",
"10 7\n",
"1000000000000 1\n"
] | [
"2\n",
"6\n",
"1000000000000\n"
] | Pictures to the first and second sample test. | 500 | [
{
"input": "2 1",
"output": "2"
},
{
"input": "10 7",
"output": "6"
},
{
"input": "1000000000000 1",
"output": "1000000000000"
},
{
"input": "3 1",
"output": "3"
},
{
"input": "4 1",
"output": "4"
},
{
"input": "3 2",
"output": "3"
},
{
"in... | 1,539,787,786 | 2,147,483,647 | Python 3 | OK | TESTS | 46 | 124 | 0 |
# -*- coding: utf-8 -*-
# @Date : 2018-10-17 19:41:42
# @Author : raj lath ([email protected])
# @Link : link
# @Version : 1.0.0
from sys import stdin
max_val=int(10e12)
min_val=int(-10e12)
def read_int() : return int(stdin.readline())
def read_ints() : return [int(x) for x in stdin.readl... | Title: Playing with Paper
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Vasya was sitting on a not so interesting Maths lesson and making an origami from a rectangular *a* mm <=×<= *b* mm sheet of paper (*a*<=><=*b*). Usually the first step in making an origami is making a squ... | ```python
# -*- coding: utf-8 -*-
# @Date : 2018-10-17 19:41:42
# @Author : raj lath ([email protected])
# @Link : link
# @Version : 1.0.0
from sys import stdin
max_val=int(10e12)
min_val=int(-10e12)
def read_int() : return int(stdin.readline())
def read_ints() : return [int(x) for x in s... | 3 | |
59 | A | Word | PROGRAMMING | 800 | [
"implementation",
"strings"
] | A. Word | 2 | 256 | Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At th... | The first line contains a word *s* — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100. | Print the corrected word *s*. If the given word *s* has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one. | [
"HoUse\n",
"ViP\n",
"maTRIx\n"
] | [
"house\n",
"VIP\n",
"matrix\n"
] | none | 500 | [
{
"input": "HoUse",
"output": "house"
},
{
"input": "ViP",
"output": "VIP"
},
{
"input": "maTRIx",
"output": "matrix"
},
{
"input": "BNHWpnpawg",
"output": "bnhwpnpawg"
},
{
"input": "VTYGP",
"output": "VTYGP"
},
{
"input": "CHNenu",
"output": "chn... | 1,682,360,482 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 154 | 0 | text = input()
low, up = 0, 0
for char in text :
if char.islower():
low += 1
else :
up += 1
if low>=up :
print(text.lower())
else :
print(text.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
text = input()
low, up = 0, 0
for char in text :
if char.islower():
low += 1
else :
up += 1
if low>=up :
print(text.lower())
else :
print(text.upper())
``` | 3.9615 |
25 | A | IQ test | PROGRAMMING | 1,300 | [
"brute force"
] | A. IQ test | 2 | 256 | Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that i... | The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness. | Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order. | [
"5\n2 4 7 8 10\n",
"4\n1 2 1 1\n"
] | [
"3\n",
"2\n"
] | none | 0 | [
{
"input": "5\n2 4 7 8 10",
"output": "3"
},
{
"input": "4\n1 2 1 1",
"output": "2"
},
{
"input": "3\n1 2 2",
"output": "1"
},
{
"input": "3\n100 99 100",
"output": "2"
},
{
"input": "3\n5 3 2",
"output": "3"
},
{
"input": "4\n43 28 1 91",
"output"... | 1,570,667,801 | 2,147,483,647 | Python 3 | OK | TESTS | 32 | 248 | 0 | #25A-IQ test
n=int(input())
list1=input().split(' ')
for i in range(0,n):
list1[i]=str(int(list1[i]) % 2)
x=list1.count('0')
if x == 1:
print(list1.index('0')+1)
else:
print(list1.index('1')+1)
| Title: IQ test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — t... | ```python
#25A-IQ test
n=int(input())
list1=input().split(' ')
for i in range(0,n):
list1[i]=str(int(list1[i]) % 2)
x=list1.count('0')
if x == 1:
print(list1.index('0')+1)
else:
print(list1.index('1')+1)
``` | 3.938 |
777 | A | Shell Game | PROGRAMMING | 1,000 | [
"constructive algorithms",
"implementation",
"math"
] | null | null | Bomboslav likes to look out of the window in his room and watch lads outside playing famous shell game. The game is played by two persons: operator and player. Operator takes three similar opaque shells and places a ball beneath one of them. Then he shuffles the shells by swapping some pairs and the player has to guess... | The first line of the input contains an integer *n* (1<=≤<=*n*<=≤<=2·109) — the number of movements made by the operator.
The second line contains a single integer *x* (0<=≤<=*x*<=≤<=2) — the index of the shell where the ball was found after *n* movements. | Print one integer from 0 to 2 — the index of the shell where the ball was initially placed. | [
"4\n2\n",
"1\n1\n"
] | [
"1\n",
"0\n"
] | In the first sample, the ball was initially placed beneath the middle shell and the operator completed four movements.
1. During the first move operator swapped the left shell and the middle shell. The ball is now under the left shell. 1. During the second move operator swapped the middle shell and the right one. Th... | 500 | [
{
"input": "4\n2",
"output": "1"
},
{
"input": "1\n1",
"output": "0"
},
{
"input": "2\n2",
"output": "0"
},
{
"input": "3\n1",
"output": "1"
},
{
"input": "3\n2",
"output": "0"
},
{
"input": "3\n0",
"output": "2"
},
{
"input": "2000000000\n... | 1,505,995,455 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 6 | 500 | 0 | n = int(input())
x = int(input())
l=['s','s']
l.insert(x,x)
for i in range(n,0,-1):
if i%2 == 0:
l[1] ,l[2] = l[2] , l[1]
if i%2 != 0:
l[0] ,l[1] = l[1] , l[0]
print(l.index(x))
| Title: Shell Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Bomboslav likes to look out of the window in his room and watch lads outside playing famous shell game. The game is played by two persons: operator and player. Operator takes three similar opaque shells and places a ball ben... | ```python
n = int(input())
x = int(input())
l=['s','s']
l.insert(x,x)
for i in range(n,0,-1):
if i%2 == 0:
l[1] ,l[2] = l[2] , l[1]
if i%2 != 0:
l[0] ,l[1] = l[1] , l[0]
print(l.index(x))
``` | 0 | |
709 | A | Juicer | PROGRAMMING | 900 | [
"implementation"
] | null | null | Kolya is going to make fresh orange juice. He has *n* oranges of sizes *a*1,<=*a*2,<=...,<=*a**n*. Kolya will put them in the juicer in the fixed order, starting with orange of size *a*1, then orange of size *a*2 and so on. To be put in the juicer the orange must have size not exceeding *b*, so if Kolya sees an orange ... | The first line of the input contains three integers *n*, *b* and *d* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*b*<=≤<=*d*<=≤<=1<=000<=000) — the number of oranges, the maximum size of the orange that fits in the juicer and the value *d*, which determines the condition when the waste section should be emptied.
The second line co... | Print one integer — the number of times Kolya will have to empty the waste section. | [
"2 7 10\n5 6\n",
"1 5 10\n7\n",
"3 10 10\n5 7 7\n",
"1 1 1\n1\n"
] | [
"1\n",
"0\n",
"1\n",
"0\n"
] | In the first sample, Kolya will squeeze the juice from two oranges and empty the waste section afterwards.
In the second sample, the orange won't fit in the juicer so Kolya will have no juice at all. | 500 | [
{
"input": "2 7 10\n5 6",
"output": "1"
},
{
"input": "1 5 10\n7",
"output": "0"
},
{
"input": "3 10 10\n5 7 7",
"output": "1"
},
{
"input": "1 1 1\n1",
"output": "0"
},
{
"input": "2 951637 951638\n44069 951637",
"output": "1"
},
{
"input": "50 100 12... | 1,624,328,049 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 4 | 77 | 7,577,600 | n,b,d = map(int, input().split())
a = list (map(int, input().split()))
total=0
for i in a:
if i < b:
total +=i
else:
continue
print (total//d) | Title: Juicer
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Kolya is going to make fresh orange juice. He has *n* oranges of sizes *a*1,<=*a*2,<=...,<=*a**n*. Kolya will put them in the juicer in the fixed order, starting with orange of size *a*1, then orange of size *a*2 and so on. To b... | ```python
n,b,d = map(int, input().split())
a = list (map(int, input().split()))
total=0
for i in a:
if i < b:
total +=i
else:
continue
print (total//d)
``` | 0 | |
233 | A | Perfect Permutation | PROGRAMMING | 800 | [
"implementation",
"math"
] | null | null | A permutation is a sequence of integers *p*1,<=*p*2,<=...,<=*p**n*, consisting of *n* distinct positive integers, each of them doesn't exceed *n*. Let's denote the *i*-th element of permutation *p* as *p**i*. We'll call number *n* the size of permutation *p*1,<=*p*2,<=...,<=*p**n*.
Nickolas adores permutations. He lik... | A single line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the permutation size. | If a perfect permutation of size *n* doesn't exist, print a single integer -1. Otherwise print *n* distinct integers from 1 to *n*, *p*1,<=*p*2,<=...,<=*p**n* — permutation *p*, that is perfect. Separate printed numbers by whitespaces. | [
"1\n",
"2\n",
"4\n"
] | [
"-1\n",
"2 1 \n",
"2 1 4 3 \n"
] | none | 500 | [
{
"input": "1",
"output": "-1"
},
{
"input": "2",
"output": "2 1 "
},
{
"input": "4",
"output": "2 1 4 3 "
},
{
"input": "3",
"output": "-1"
},
{
"input": "5",
"output": "-1"
},
{
"input": "6",
"output": "2 1 4 3 6 5 "
},
{
"input": "7",
... | 1,652,419,712 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 124 | 0 | n = int(input().strip())
t = []
if n % 2 != 0:
print(-1)
else:
for i in range(1, n+1):
t.append(i)
i = 0
while n:
t[i], t[i+1] = t[i+1], t[i]
i += 2
n -= 2
for i in t:
print(i, end = " ")
| Title: Perfect Permutation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A permutation is a sequence of integers *p*1,<=*p*2,<=...,<=*p**n*, consisting of *n* distinct positive integers, each of them doesn't exceed *n*. Let's denote the *i*-th element of permutation *p* as *p**i*. We'll ... | ```python
n = int(input().strip())
t = []
if n % 2 != 0:
print(-1)
else:
for i in range(1, n+1):
t.append(i)
i = 0
while n:
t[i], t[i+1] = t[i+1], t[i]
i += 2
n -= 2
for i in t:
print(i, end = " ")
``` | 3 | |
271 | A | Beautiful Year | PROGRAMMING | 800 | [
"brute force"
] | null | null | It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits.
Now you are suggested to solve the following problem: given a year number, find the minimum year number which is strictly larger than the given one and has on... | The single line contains integer *y* (1000<=≤<=*y*<=≤<=9000) — the year number. | Print a single integer — the minimum year number that is strictly larger than *y* and all it's digits are distinct. It is guaranteed that the answer exists. | [
"1987\n",
"2013\n"
] | [
"2013\n",
"2014\n"
] | none | 500 | [
{
"input": "1987",
"output": "2013"
},
{
"input": "2013",
"output": "2014"
},
{
"input": "1000",
"output": "1023"
},
{
"input": "1001",
"output": "1023"
},
{
"input": "1234",
"output": "1235"
},
{
"input": "5555",
"output": "5601"
},
{
"inp... | 1,698,831,203 | 2,147,483,647 | Python 3 | COMPILATION_ERROR | TESTS | 0 | 0 | 0 | def norepeat(a):
if len(set(str(a)))==len(str(a)):
return True
else:
return False
a=int(input())
while True:
a+=1
if norepeat(a):
print(a)
break;
| Title: Beautiful Year
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits.
Now you are suggested to solve the following problem: give... | ```python
def norepeat(a):
if len(set(str(a)))==len(str(a)):
return True
else:
return False
a=int(input())
while True:
a+=1
if norepeat(a):
print(a)
break;
``` | -1 | |
166 | E | Tetrahedron | PROGRAMMING | 1,500 | [
"dp",
"math",
"matrices"
] | null | null | You are given a tetrahedron. Let's mark its vertices with letters *A*, *B*, *C* and *D* correspondingly.
An ant is standing in the vertex *D* of the tetrahedron. The ant is quite active and he wouldn't stay idle. At each moment of time he makes a step from one vertex to another one along some edge of the tetrahedron. ... | The first line contains the only integer *n* (1<=≤<=*n*<=≤<=107) — the required length of the cyclic path. | Print the only integer — the required number of ways modulo 1000000007 (109<=+<=7). | [
"2\n",
"4\n"
] | [
"3\n",
"21\n"
] | The required paths in the first sample are:
- *D* - *A* - *D* - *D* - *B* - *D* - *D* - *C* - *D* | 1,000 | [
{
"input": "2",
"output": "3"
},
{
"input": "4",
"output": "21"
},
{
"input": "1",
"output": "0"
},
{
"input": "3",
"output": "6"
},
{
"input": "5",
"output": "60"
},
{
"input": "6",
"output": "183"
},
{
"input": "7",
"output": "546"
... | 1,666,219,980 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 11 | 92 | 0 | n = int(input())
b_n = (3**(n-1) + (-1)**(n))//4
print(3*b_n)
# print(dp[n])
# a_n = 3*b_(n-1)
# b_n = 3*b_(n-2) + 2*b_(n-1)
# r^2 = 2r + 3
# r^2 - 2r - 3 = 0
# (r-3)(r+1) = 0
# a*3**n + b(-1)**n = b_n
# a +b = 0
# 3a - b = 1
# a = 1/4
# b = -1/4
| Title: Tetrahedron
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a tetrahedron. Let's mark its vertices with letters *A*, *B*, *C* and *D* correspondingly.
An ant is standing in the vertex *D* of the tetrahedron. The ant is quite active and he wouldn't stay idle. At each m... | ```python
n = int(input())
b_n = (3**(n-1) + (-1)**(n))//4
print(3*b_n)
# print(dp[n])
# a_n = 3*b_(n-1)
# b_n = 3*b_(n-2) + 2*b_(n-1)
# r^2 = 2r + 3
# r^2 - 2r - 3 = 0
# (r-3)(r+1) = 0
# a*3**n + b(-1)**n = b_n
# a +b = 0
# 3a - b = 1
# a = 1/4
# b = -1/4
``` | 0 | |
912 | A | Tricky Alchemy | PROGRAMMING | 800 | [
"implementation"
] | null | null | During the winter holidays, the demand for Christmas balls is exceptionally high. Since it's already 2018, the advances in alchemy allow easy and efficient ball creation by utilizing magic crystals.
Grisha needs to obtain some yellow, green and blue balls. It's known that to produce a yellow ball one needs two yellow ... | The first line features two integers *A* and *B* (0<=≤<=*A*,<=*B*<=≤<=109), denoting the number of yellow and blue crystals respectively at Grisha's disposal.
The next line contains three integers *x*, *y* and *z* (0<=≤<=*x*,<=*y*,<=*z*<=≤<=109) — the respective amounts of yellow, green and blue balls to be obtained. | Print a single integer — the minimum number of crystals that Grisha should acquire in addition. | [
"4 3\n2 1 1\n",
"3 9\n1 1 3\n",
"12345678 87654321\n43043751 1000000000 53798715\n"
] | [
"2\n",
"1\n",
"2147483648\n"
] | In the first sample case, Grisha needs five yellow and four blue crystals to create two yellow balls, one green ball, and one blue ball. To do that, Grisha needs to obtain two additional crystals: one yellow and one blue. | 500 | [
{
"input": "4 3\n2 1 1",
"output": "2"
},
{
"input": "3 9\n1 1 3",
"output": "1"
},
{
"input": "12345678 87654321\n43043751 1000000000 53798715",
"output": "2147483648"
},
{
"input": "12 12\n3 5 2",
"output": "0"
},
{
"input": "770 1390\n170 442 311",
"output"... | 1,649,906,430 | 2,147,483,647 | Python 3 | OK | TESTS | 38 | 46 | 0 | a, b = map(int, input().split())
x, y, z = map(int, input().split())
d = 3*z + y
c = y + 2*x
print(max(d-b,0) + max(c-a,0)) | Title: Tricky Alchemy
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
During the winter holidays, the demand for Christmas balls is exceptionally high. Since it's already 2018, the advances in alchemy allow easy and efficient ball creation by utilizing magic crystals.
Grisha needs to obta... | ```python
a, b = map(int, input().split())
x, y, z = map(int, input().split())
d = 3*z + y
c = y + 2*x
print(max(d-b,0) + max(c-a,0))
``` | 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,691,832,334 | 2,147,483,647 | Python 3 | OK | TESTS | 20 | 46 | 0 | import math
l,b,a=[int(x) for x in input().split()]
along_len=math.ceil(l/a)
along_bre=math.ceil(b/a)
print(along_len*along_bre) | 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
import math
l,b,a=[int(x) for x in input().split()]
along_len=math.ceil(l/a)
along_bre=math.ceil(b/a)
print(along_len*along_bre)
``` | 3.977 |
687 | B | Remainders Game | PROGRAMMING | 1,800 | [
"chinese remainder theorem",
"math",
"number theory"
] | null | null | Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer *x* and *k*, and tells Arya *k* but not *x*. Arya have to find the value . There are *n* ancient numbers *c*1,<=*c*2,<=...,<=*c**n* and Pari has to tell Arya if Arya wants. Given *k* and the ancient values, tell us if Arya has... | The first line of the input contains two integers *n* and *k* (1<=≤<=*n*,<= *k*<=≤<=1<=000<=000) — the number of ancient integers and value *k* that is chosen by Pari.
The second line contains *n* integers *c*1,<=*c*2,<=...,<=*c**n* (1<=≤<=*c**i*<=≤<=1<=000<=000). | Print "Yes" (without quotes) if Arya has a winning strategy independent of value of *x*, or "No" (without quotes) otherwise. | [
"4 5\n2 3 5 12\n",
"2 7\n2 3\n"
] | [
"Yes\n",
"No\n"
] | In the first sample, Arya can understand <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/d170efffcde0907ee6bcf32de21051bce0677a2c.png" style="max-width: 100.0%;max-height: 100.0%;"/> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <img align="middle" ... | 1,000 | [
{
"input": "4 5\n2 3 5 12",
"output": "Yes"
},
{
"input": "2 7\n2 3",
"output": "No"
},
{
"input": "1 6\n8",
"output": "No"
},
{
"input": "2 3\n9 4",
"output": "Yes"
},
{
"input": "4 16\n19 16 13 9",
"output": "Yes"
},
{
"input": "5 10\n5 16 19 9 17",
... | 1,591,663,597 | 2,147,483,647 | PyPy 3 | COMPILATION_ERROR | TESTS | 0 | 0 | 0 | import sys
input = sys.stdin.buffer.readline
def prog():
n,k = map(int,input().split())
nums = list(map(int,input().split()))
max_powers = 1
for num in nums:
max_powers = gcd(k, num*max_powers//gcd(num,max_powers))
if max_powers = k:
print('YES')
else:
print('N... | Title: Remainders Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer *x* and *k*, and tells Arya *k* but not *x*. Arya have to find the value . There are *n* ancient numbers *c*1,<=*c*2,<=...,<=*... | ```python
import sys
input = sys.stdin.buffer.readline
def prog():
n,k = map(int,input().split())
nums = list(map(int,input().split()))
max_powers = 1
for num in nums:
max_powers = gcd(k, num*max_powers//gcd(num,max_powers))
if max_powers = k:
print('YES')
else:
... | -1 | |
899 | D | Shovel Sale | PROGRAMMING | 1,800 | [
"constructive algorithms",
"math"
] | null | null | There are *n* shovels in Polycarp's shop. The *i*-th shovel costs *i* burles, that is, the first shovel costs 1 burle, the second shovel costs 2 burles, the third shovel costs 3 burles, and so on. Polycarps wants to sell shovels in pairs.
Visitors are more likely to buy a pair of shovels if their total cost ends with ... | The first line contains a single integer *n* (2<=≤<=*n*<=≤<=109) — the number of shovels in Polycarp's shop. | Print the number of pairs of shovels such that their total cost ends with maximum possible number of nines.
Note that it is possible that the largest number of 9s at the end is 0, then you should count all such ways.
It is guaranteed that for every *n*<=≤<=109 the answer doesn't exceed 2·109. | [
"7\n",
"14\n",
"50\n"
] | [
"3\n",
"9\n",
"1\n"
] | In the first example the maximum possible number of nines at the end is one. Polycarp cah choose the following pairs of shovels for that purpose:
- 2 and 7; - 3 and 6; - 4 and 5.
In the second example the maximum number of nines at the end of total cost of two shovels is one. The following pairs of shovels suit Po... | 1,750 | [
{
"input": "7",
"output": "3"
},
{
"input": "14",
"output": "9"
},
{
"input": "50",
"output": "1"
},
{
"input": "999999999",
"output": "499999999"
},
{
"input": "15",
"output": "11"
},
{
"input": "3",
"output": "3"
},
{
"input": "6500",
... | 1,513,590,329 | 2,147,483,647 | Python 3 | OK | TESTS | 106 | 62 | 5,529,600 | n = int(input())
a= 5
while a * 10 <= n:
a *= 10
print(sum(min(n - i * a + 1, a * i - 1) for i in range(1, n // a + 1)) if n>=5 else n*(n-1)//2) | Title: Shovel Sale
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There are *n* shovels in Polycarp's shop. The *i*-th shovel costs *i* burles, that is, the first shovel costs 1 burle, the second shovel costs 2 burles, the third shovel costs 3 burles, and so on. Polycarps wants to sell sh... | ```python
n = int(input())
a= 5
while a * 10 <= n:
a *= 10
print(sum(min(n - i * a + 1, a * i - 1) for i in range(1, n // a + 1)) if n>=5 else n*(n-1)//2)
``` | 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,666,545,396 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 8 | 1,000 | 0 | n,m,a = map(int,input().split())
r1 = 1
r2 = 1
sq = a
sq2 = a
while 1:
if a < n:
a = a+sq
r1+=1
elif sq2 < m:
sq2 = sq2+sq
r2+=1
else:
break
print(r1*r2)
| Title: Theatre Square
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Theatre Square in the capital city of Berland has a rectangular shape with the size *n*<=×<=*m* meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each ... | ```python
n,m,a = map(int,input().split())
r1 = 1
r2 = 1
sq = a
sq2 = a
while 1:
if a < n:
a = a+sq
r1+=1
elif sq2 < m:
sq2 = sq2+sq
r2+=1
else:
break
print(r1*r2)
``` | 0 |
461 | A | Appleman and Toastman | PROGRAMMING | 1,200 | [
"greedy",
"sortings"
] | null | null | Appleman and Toastman play a game. Initially Appleman gives one group of *n* numbers to the Toastman, then they start to complete the following tasks:
- Each time Toastman gets a group of numbers, he sums up all the numbers and adds this sum to the score. Then he gives the group to the Appleman. - Each time Appleman... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=3·105). The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=106) — the initial group that is given to Toastman. | Print a single integer — the largest possible score. | [
"3\n3 1 5\n",
"1\n10\n"
] | [
"26\n",
"10\n"
] | Consider the following situation in the first example. Initially Toastman gets group [3, 1, 5] and adds 9 to the score, then he give the group to Appleman. Appleman splits group [3, 1, 5] into two groups: [3, 5] and [1]. Both of them should be given to Toastman. When Toastman receives group [1], he adds 1 to score and ... | 500 | [
{
"input": "3\n3 1 5",
"output": "26"
},
{
"input": "1\n10",
"output": "10"
},
{
"input": "10\n8 10 2 5 6 2 4 7 2 1",
"output": "376"
},
{
"input": "10\n171308 397870 724672 431255 228496 892002 542924 718337 888642 161821",
"output": "40204082"
},
{
"input": "10\... | 1,409,159,431 | 2,147,483,647 | Python 3 | OK | TESTS | 36 | 421 | 20,172,800 | import sys
def main():
fin = sys.stdin
fout = sys.stdout
n = int(fin.readline())
A = list(map(int, fin.readline().split()))
A.sort(reverse = True)
for i in range(1, n):
A[i] += A[i - 1]
ans = A[n - 1]
for i in range(1, n):
ans += A[i]
fout.write(str(ans) + "\n")
fin.close()
fout.clos... | Title: Appleman and Toastman
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Appleman and Toastman play a game. Initially Appleman gives one group of *n* numbers to the Toastman, then they start to complete the following tasks:
- Each time Toastman gets a group of numbers, he sums up all... | ```python
import sys
def main():
fin = sys.stdin
fout = sys.stdout
n = int(fin.readline())
A = list(map(int, fin.readline().split()))
A.sort(reverse = True)
for i in range(1, n):
A[i] += A[i - 1]
ans = A[n - 1]
for i in range(1, n):
ans += A[i]
fout.write(str(ans) + "\n")
fin.close()
... | 3 | |
644 | B | Processing Queries | PROGRAMMING | 1,700 | [
"*special",
"constructive algorithms",
"data structures",
"two pointers"
] | null | null | In this problem you have to simulate the workflow of one-thread server. There are *n* queries to process, the *i*-th will be received at moment *t**i* and needs to be processed for *d**i* units of time. All *t**i* are guaranteed to be distinct.
When a query appears server may react in three possible ways:
1. If ser... | The first line of the input contains two integers *n* and *b* (1<=≤<=*n*,<=*b*<=≤<=200<=000) — the number of queries and the maximum possible size of the query queue.
Then follow *n* lines with queries descriptions (in chronological order). Each description consists of two integers *t**i* and *d**i* (1<=≤<=*t**i*,<=*d... | Print the sequence of *n* integers *e*1,<=*e*2,<=...,<=*e**n*, where *e**i* is the moment the server will finish to process the *i*-th query (queries are numbered in the order they appear in the input) or <=-<=1 if the corresponding query will be rejected. | [
"5 1\n2 9\n4 8\n10 9\n15 2\n19 1\n",
"4 1\n2 8\n4 8\n10 9\n15 2\n"
] | [
"11 19 -1 21 22 \n",
"10 18 27 -1 \n"
] | Consider the first sample.
1. The server will start to process first query at the moment 2 and will finish to process it at the moment 11. 1. At the moment 4 second query appears and proceeds to the queue. 1. At the moment 10 third query appears. However, the server is still busy with query 1, *b* = 1 and there is... | 1,000 | [
{
"input": "5 1\n2 9\n4 8\n10 9\n15 2\n19 1",
"output": "11 19 -1 21 22 "
},
{
"input": "4 1\n2 8\n4 8\n10 9\n15 2",
"output": "10 18 27 -1 "
},
{
"input": "1 1\n1000000000 1000000000",
"output": "2000000000 "
},
{
"input": "4 3\n999999996 1000000000\n999999997 1000000000\n99... | 1,458,291,172 | 172,372 | Python 3 | RUNTIME_ERROR | PRETESTS | 0 | 46 | 204,800 | class Event:
def __init__(self, at, wt):
self.arrival_time = at
self.work_time = wt
class Queue:
def __init__(self, ms):
self.maxSize = ms
self.storage = []
def push(self, e):
self.storage.append(e)
def front(self):
return self.storage[0];
def pop... | Title: Processing Queries
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In this problem you have to simulate the workflow of one-thread server. There are *n* queries to process, the *i*-th will be received at moment *t**i* and needs to be processed for *d**i* units of time. All *t**i* ar... | ```python
class Event:
def __init__(self, at, wt):
self.arrival_time = at
self.work_time = wt
class Queue:
def __init__(self, ms):
self.maxSize = ms
self.storage = []
def push(self, e):
self.storage.append(e)
def front(self):
return self.storage[0];
... | -1 | |
870 | C | Maximum splitting | PROGRAMMING | 1,300 | [
"dp",
"greedy",
"math",
"number theory"
] | null | null | You are given several queries. In the *i*-th query you are given a single positive integer *n**i*. You are to represent *n**i* as a sum of maximum possible number of composite summands and print this maximum number, or print -1, if there are no such splittings.
An integer greater than 1 is composite, if it is not prim... | The first line contains single integer *q* (1<=≤<=*q*<=≤<=105) — the number of queries.
*q* lines follow. The (*i*<=+<=1)-th line contains single integer *n**i* (1<=≤<=*n**i*<=≤<=109) — the *i*-th query. | For each query print the maximum possible number of summands in a valid splitting to composite summands, or -1, if there are no such splittings. | [
"1\n12\n",
"2\n6\n8\n",
"3\n1\n2\n3\n"
] | [
"3\n",
"1\n2\n",
"-1\n-1\n-1\n"
] | 12 = 4 + 4 + 4 = 4 + 8 = 6 + 6 = 12, but the first splitting has the maximum possible number of summands.
8 = 4 + 4, 6 can't be split into several composite summands.
1, 2, 3 are less than any composite number, so they do not have valid splittings. | 1,500 | [
{
"input": "1\n12",
"output": "3"
},
{
"input": "2\n6\n8",
"output": "1\n2"
},
{
"input": "3\n1\n2\n3",
"output": "-1\n-1\n-1"
},
{
"input": "6\n1\n2\n3\n5\n7\n11",
"output": "-1\n-1\n-1\n-1\n-1\n-1"
},
{
"input": "3\n4\n6\n9",
"output": "1\n1\n1"
},
{
... | 1,570,557,138 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 93 | 0 | n=int(input())
a=[]
for i in range(n) :
s=0
k=int(input())
if 1<=k<=3:
a.append(-1)
else:
while k>3:
k-=4
s+=1
if k==1:
a.append(s-1)
elif k==2:
a.append(s-2)
elif k==3:
a.append(s-3)
elif k==0:
... | Title: Maximum splitting
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given several queries. In the *i*-th query you are given a single positive integer *n**i*. You are to represent *n**i* as a sum of maximum possible number of composite summands and print this maximum number, o... | ```python
n=int(input())
a=[]
for i in range(n) :
s=0
k=int(input())
if 1<=k<=3:
a.append(-1)
else:
while k>3:
k-=4
s+=1
if k==1:
a.append(s-1)
elif k==2:
a.append(s-2)
elif k==3:
a.append(s-3)
el... | 0 | |
500 | A | New Year Transportation | PROGRAMMING | 1,000 | [
"dfs and similar",
"graphs",
"implementation"
] | null | null | New Year is coming in Line World! In this world, there are *n* cells numbered by integers from 1 to *n*, as a 1<=×<=*n* board. People live in cells. However, it was hard to move between distinct cells, because of the difficulty of escaping the cell. People wanted to meet people who live in other cells.
So, user tncks0... | The first line contains two space-separated integers *n* (3<=≤<=*n*<=≤<=3<=×<=104) and *t* (2<=≤<=*t*<=≤<=*n*) — the number of cells, and the index of the cell which I want to go to.
The second line contains *n*<=-<=1 space-separated integers *a*1,<=*a*2,<=...,<=*a**n*<=-<=1 (1<=≤<=*a**i*<=≤<=*n*<=-<=*i*). It is guara... | If I can go to cell *t* using the transportation system, print "YES". Otherwise, print "NO". | [
"8 4\n1 2 1 2 1 2 1\n",
"8 5\n1 2 1 2 1 1 1\n"
] | [
"YES\n",
"NO\n"
] | In the first sample, the visited cells are: 1, 2, 4; so we can successfully visit the cell 4.
In the second sample, the possible cells to visit are: 1, 2, 4, 6, 7, 8; so we can't visit the cell 5, which we want to visit. | 500 | [
{
"input": "8 4\n1 2 1 2 1 2 1",
"output": "YES"
},
{
"input": "8 5\n1 2 1 2 1 1 1",
"output": "NO"
},
{
"input": "20 19\n13 16 7 6 12 1 5 7 8 6 5 7 5 5 3 3 2 2 1",
"output": "YES"
},
{
"input": "50 49\n11 7 1 41 26 36 19 16 38 14 36 35 37 27 20 27 3 6 21 2 27 11 18 17 19 16 ... | 1,680,905,260 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 34 | 78 | 7,987,200 | from collections import defaultdict
def main():
n , t = map(int,input().split())
nums = list(map(int,input().split()))
portals = defaultdict()
for i,n in enumerate(nums):
portals[i+1] = i + n + 1
cur = 1
def dfs(nums):
nonlocal cur
while cur <= t:
... | Title: New Year Transportation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
New Year is coming in Line World! In this world, there are *n* cells numbered by integers from 1 to *n*, as a 1<=×<=*n* board. People live in cells. However, it was hard to move between distinct cells, because o... | ```python
from collections import defaultdict
def main():
n , t = map(int,input().split())
nums = list(map(int,input().split()))
portals = defaultdict()
for i,n in enumerate(nums):
portals[i+1] = i + n + 1
cur = 1
def dfs(nums):
nonlocal cur
while cur <=... | 3 |
Subsets and Splits
Successful Python Submissions
Retrieves all records from the train dataset where the verdict is 'OK', providing basic filtering but limited analytical value.
SQL Console for MatrixStudio/Codeforces-Python-Submissions
Retrieves records of users with a rating of 1600 or higher and a verdict of 'OK', providing basic filtering but limited analytical value.
SQL Console for MatrixStudio/Codeforces-Python-Submissions
Counts the number of entries with a rating above 2000 and a verdict of 'OK', providing basic filtering but limited analytical value.
SQL Console for MatrixStudio/Codeforces-Python-Submissions
Counts the number of entries with a 'OK' verdict, providing a basic overview of a specific category within the dataset.