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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
200 | B | Drinks | PROGRAMMING | 800 | [
"implementation",
"math"
] | null | null | Little Vasya loves orange juice very much. That's why any food and drink in his kitchen necessarily contains orange juice. There are *n* drinks in his fridge, the volume fraction of orange juice in the *i*-th drink equals *p**i* percent.
One day Vasya decided to make himself an orange cocktail. He took equal proportio... | The first input line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of orange-containing drinks in Vasya's fridge. The second line contains *n* integers *p**i* (0<=≤<=*p**i*<=≤<=100) — the volume fraction of orange juice in the *i*-th drink, in percent. The numbers are separated by a space. | Print the volume fraction in percent of orange juice in Vasya's cocktail. The answer will be considered correct if the absolute or relative error does not exceed 10<=<=-<=4. | [
"3\n50 50 100\n",
"4\n0 25 50 75\n"
] | [
"66.666666666667\n",
"37.500000000000\n"
] | Note to the first sample: let's assume that Vasya takes *x* milliliters of each drink from the fridge. Then the volume of pure juice in the cocktail will equal <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c1fac6e64d3a8ee6a5ac138cbe51e60039b22473.png" style="max-width: 100.0%;max-height: ... | 500 | [
{
"input": "3\n50 50 100",
"output": "66.666666666667"
},
{
"input": "4\n0 25 50 75",
"output": "37.500000000000"
},
{
"input": "3\n0 1 8",
"output": "3.000000000000"
},
{
"input": "5\n96 89 93 95 70",
"output": "88.600000000000"
},
{
"input": "7\n62 41 78 4 38 39... | 1,697,704,901 | 2,147,483,647 | Python 3 | OK | TESTS | 31 | 92 | 0 | n = int(input())
d = list(map(int,input().split()))
s = sum(d)
print(round(s/n,4))
| Title: Drinks
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little Vasya loves orange juice very much. That's why any food and drink in his kitchen necessarily contains orange juice. There are *n* drinks in his fridge, the volume fraction of orange juice in the *i*-th drink equals *p**i*... | ```python
n = int(input())
d = list(map(int,input().split()))
s = sum(d)
print(round(s/n,4))
``` | 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,582,127,002 | 2,147,483,647 | Python 3 | OK | TESTS | 32 | 248 | 0 | n=int(input())
L=list(map(int,input().split()))
L1=[]
for i in L:
if i%2==0:
L1.append(1)
else:
L1.append(0)
if L1.count(1)==1:
print(L1.index(1)+1)
elif L1.count(0)==1:
print(L1.index(0)+1)
| Title: IQ test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — t... | ```python
n=int(input())
L=list(map(int,input().split()))
L1=[]
for i in L:
if i%2==0:
L1.append(1)
else:
L1.append(0)
if L1.count(1)==1:
print(L1.index(1)+1)
elif L1.count(0)==1:
print(L1.index(0)+1)
``` | 3.938 |
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,647,619,730 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 39 | 372 | 18,329,600 | n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
j=0
ans=0
for i in range(2,n):
while abs(a[j]-a[i])>k:
j=j+1
d=i-j
ans=ans+(d)*(d-1)//2
print(ans) | 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
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
j=0
ans=0
for i in range(2,n):
while abs(a[j]-a[i])>k:
j=j+1
d=i-j
ans=ans+(d)*(d-1)//2
print(ans)
``` | 3 | |
489 | C | Given Length and Sum of Digits... | PROGRAMMING | 1,400 | [
"dp",
"greedy",
"implementation"
] | null | null | You have a positive integer *m* and a non-negative integer *s*. Your task is to find the smallest and the largest of the numbers that have length *m* and sum of digits *s*. The required numbers should be non-negative integers written in the decimal base without leading zeroes. | The single line of the input contains a pair of integers *m*, *s* (1<=≤<=*m*<=≤<=100,<=0<=≤<=*s*<=≤<=900) — the length and the sum of the digits of the required numbers. | In the output print the pair of the required non-negative integer numbers — first the minimum possible number, then — the maximum possible number. If no numbers satisfying conditions required exist, print the pair of numbers "-1 -1" (without the quotes). | [
"2 15\n",
"3 0\n"
] | [
"69 96\n",
"-1 -1\n"
] | none | 1,500 | [
{
"input": "2 15",
"output": "69 96"
},
{
"input": "3 0",
"output": "-1 -1"
},
{
"input": "2 1",
"output": "10 10"
},
{
"input": "3 10",
"output": "109 910"
},
{
"input": "100 100",
"output": "1000000000000000000000000000000000000000000000000000000000000000000... | 1,688,488,760 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 0 | 46 | 0 | """
author: manoj.py
"""
import sys
m, s = map(int, input().split())
min_ans = []
def min_n(n):
print(n, )
if n<=0:
return
min_ans.append(n%9 if n%9 else 9)
min_n(n-(n%9 if n%9 else 9))
min_n(s)
if len(min_ans)>m:
print(-1, -1)
sys.exit(0)
temp = []
if len(min... | Title: Given Length and Sum of Digits...
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You have a positive integer *m* and a non-negative integer *s*. Your task is to find the smallest and the largest of the numbers that have length *m* and sum of digits *s*. The required numbers should ... | ```python
"""
author: manoj.py
"""
import sys
m, s = map(int, input().split())
min_ans = []
def min_n(n):
print(n, )
if n<=0:
return
min_ans.append(n%9 if n%9 else 9)
min_n(n-(n%9 if n%9 else 9))
min_n(s)
if len(min_ans)>m:
print(-1, -1)
sys.exit(0)
temp = []
... | 0 | |
633 | D | Fibonacci-ish | PROGRAMMING | 2,000 | [
"brute force",
"dp",
"hashing",
"implementation",
"math"
] | null | null | Yash has recently learnt about the Fibonacci sequence and is very excited about it. He calls a sequence Fibonacci-ish if
1. the sequence consists of at least two elements 1. *f*0 and *f*1 are arbitrary 1. *f**n*<=+<=2<==<=*f**n*<=+<=1<=+<=*f**n* for all *n*<=≥<=0.
You are given some sequence of integers *a*1,<=*a... | The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=1000) — the length of the sequence *a**i*.
The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=109). | Print the length of the longest possible Fibonacci-ish prefix of the given sequence after rearrangement. | [
"3\n1 2 -1\n",
"5\n28 35 7 14 21\n"
] | [
"3\n",
"4\n"
] | In the first sample, if we rearrange elements of the sequence as - 1, 2, 1, the whole sequence *a*<sub class="lower-index">*i*</sub> would be Fibonacci-ish.
In the second sample, the optimal way to rearrange elements is <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/16f1f7e35511b29cb1396... | 1,750 | [
{
"input": "3\n1 2 -1",
"output": "3"
},
{
"input": "5\n28 35 7 14 21",
"output": "4"
},
{
"input": "11\n-9 -1 -10 9 7 -4 0 -8 -3 3 5",
"output": "5"
},
{
"input": "10\n-4 -8 -8 8 -9 0 -7 9 1 0",
"output": "4"
},
{
"input": "2\n2 2",
"output": "2"
},
{
... | 1,456,511,417 | 4,517 | Python 3 | WRONG_ANSWER | PRETESTS | 0 | 46 | 0 | m=int(input())
if m%5==0:
print(0)
else:
print(5)
startvalue=0
howmany=m
subtract=0
for i in range(1,1000):
subtract=subtract+(m//(5**i))
startvalue=(howmany-subtract)*5
for i in range(5):
print(startvalue+i)
... | Title: Fibonacci-ish
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Yash has recently learnt about the Fibonacci sequence and is very excited about it. He calls a sequence Fibonacci-ish if
1. the sequence consists of at least two elements 1. *f*0 and *f*1 are arbitrary 1. *f**n*<=+<=... | ```python
m=int(input())
if m%5==0:
print(0)
else:
print(5)
startvalue=0
howmany=m
subtract=0
for i in range(1,1000):
subtract=subtract+(m//(5**i))
startvalue=(howmany-subtract)*5
for i in range(5):
print(startvalue+i)
... | 0 | |
915 | A | Garden | PROGRAMMING | 900 | [
"implementation"
] | null | null | Luba thinks about watering her garden. The garden can be represented as a segment of length *k*. Luba has got *n* buckets, the *i*-th bucket allows her to water some continuous subsegment of garden of length exactly *a**i* each hour. Luba can't water any parts of the garden that were already watered, also she can't wat... | The first line of input contains two integer numbers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=100) — the number of buckets and the length of the garden, respectively.
The second line of input contains *n* integer numbers *a**i* (1<=≤<=*a**i*<=≤<=100) — the length of the segment that can be watered by the *i*-th bucket in one ... | Print one integer number — the minimum number of hours required to water the garden. | [
"3 6\n2 3 5\n",
"6 7\n1 2 3 4 5 6\n"
] | [
"2\n",
"7\n"
] | In the first test the best option is to choose the bucket that allows to water the segment of length 3. We can't choose the bucket that allows to water the segment of length 5 because then we can't water the whole garden.
In the second test we can choose only the bucket that allows us to water the segment of length 1. | 0 | [
{
"input": "3 6\n2 3 5",
"output": "2"
},
{
"input": "6 7\n1 2 3 4 5 6",
"output": "7"
},
{
"input": "5 97\n1 10 50 97 2",
"output": "1"
},
{
"input": "5 97\n1 10 50 100 2",
"output": "97"
},
{
"input": "100 100\n2 46 24 18 86 90 31 38 84 49 58 28 15 80 14 24 87 5... | 1,553,839,215 | 2,147,483,647 | Python 3 | OK | TESTS | 83 | 109 | 0 |
_=list(map(int,input().split()))
__=sorted(list(map(int,input().split())))
for ___ in range(_[0]-1,-1,-1):
if _[1]%__[___]==0:
print(_[1]//__[___])
break
#ye jaye door bedoone IDE va net E :( | Title: Garden
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Luba thinks about watering her garden. The garden can be represented as a segment of length *k*. Luba has got *n* buckets, the *i*-th bucket allows her to water some continuous subsegment of garden of length exactly *a**i* each ... | ```python
_=list(map(int,input().split()))
__=sorted(list(map(int,input().split())))
for ___ in range(_[0]-1,-1,-1):
if _[1]%__[___]==0:
print(_[1]//__[___])
break
#ye jaye door bedoone IDE va net E :(
``` | 3 | |
108 | A | Palindromic Times | PROGRAMMING | 1,000 | [
"implementation",
"strings"
] | A. Palindromic Times | 2 | 256 | Tattah is asleep if and only if Tattah is attending a lecture. This is a well-known formula among Tattah's colleagues.
On a Wednesday afternoon, Tattah was attending Professor HH's lecture. At 12:21, right before falling asleep, he was staring at the digital watch around Saher's wrist. He noticed that the digits on th... | The first and only line of the input starts with a string with the format "HH:MM" where "HH" is from "00" to "23" and "MM" is from "00" to "59". Both "HH" and "MM" have exactly two digits. | Print the palindromic time of day that comes soonest after the time given in the input. If the input time is palindromic, output the soonest palindromic time after the input time. | [
"12:21\n",
"23:59\n"
] | [
"13:31\n",
"00:00\n"
] | none | 500 | [
{
"input": "12:21",
"output": "13:31"
},
{
"input": "23:59",
"output": "00:00"
},
{
"input": "15:51",
"output": "20:02"
},
{
"input": "10:44",
"output": "11:11"
},
{
"input": "04:02",
"output": "04:40"
},
{
"input": "02:11",
"output": "02:20"
},
... | 1,597,953,629 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 186 | 204,800 | z=input()
qwe=False
x=z.split(":")
y=list(z)
d=""
a=int(x[0])
for i in range(1,24+1):
if qwe:
break
a+=i
if a>=24:
a=0
for o in range(0,60):
if a<10:
if o<10:
d="0"+str(a)+":"+"0"+str(o)
else:
... | Title: Palindromic Times
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Tattah is asleep if and only if Tattah is attending a lecture. This is a well-known formula among Tattah's colleagues.
On a Wednesday afternoon, Tattah was attending Professor HH's lecture. At 12:21, right before falling... | ```python
z=input()
qwe=False
x=z.split(":")
y=list(z)
d=""
a=int(x[0])
for i in range(1,24+1):
if qwe:
break
a+=i
if a>=24:
a=0
for o in range(0,60):
if a<10:
if o<10:
d="0"+str(a)+":"+"0"+str(o)
else:
... | 0 |
69 | A | Young Physicist | PROGRAMMING | 1,000 | [
"implementation",
"math"
] | A. Young Physicist | 2 | 256 | A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasy... | The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100), then follow *n* lines containing three integers each: the *x**i* coordinate, the *y**i* coordinate and the *z**i* coordinate of the force vector, applied to the body (<=-<=100<=≤<=*x**i*,<=*y**i*,<=*z**i*<=≤<=100). | Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not. | [
"3\n4 1 7\n-2 4 -1\n1 -5 -3\n",
"3\n3 -1 7\n-5 2 -4\n2 -1 -3\n"
] | [
"NO",
"YES"
] | none | 500 | [
{
"input": "3\n4 1 7\n-2 4 -1\n1 -5 -3",
"output": "NO"
},
{
"input": "3\n3 -1 7\n-5 2 -4\n2 -1 -3",
"output": "YES"
},
{
"input": "10\n21 32 -46\n43 -35 21\n42 2 -50\n22 40 20\n-27 -9 38\n-4 1 1\n-40 6 -31\n-13 -2 34\n-21 34 -12\n-32 -29 41",
"output": "NO"
},
{
"input": "10... | 1,559,546,741 | 2,147,483,647 | Python 3 | OK | TESTS | 81 | 218 | 0 | cordsC = [0, 0, 0]
for i in range(int(input())):
cords = list(map(int, input().split()))
cordsC[0] += cords[0]; cordsC[1] += cords[1]; cordsC[2] += cords[2]
print("YES" if (cordsC[0] == 0 and cordsC[1] == 0 and cordsC[2] == 0) else "NO") | Title: Young Physicist
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. S... | ```python
cordsC = [0, 0, 0]
for i in range(int(input())):
cords = list(map(int, input().split()))
cordsC[0] += cords[0]; cordsC[1] += cords[1]; cordsC[2] += cords[2]
print("YES" if (cordsC[0] == 0 and cordsC[1] == 0 and cordsC[2] == 0) else "NO")
``` | 3.9455 |
141 | A | Amusing Joke | PROGRAMMING | 800 | [
"implementation",
"sortings",
"strings"
] | null | null | So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's name and the host's name in honor of this event. Then the hung the letters above the main entrance. O... | The input file consists of three lines: the first line contains the guest's name, the second line contains the name of the residence host and the third line contains letters in a pile that were found at the door in the morning. All lines are not empty and contain only uppercase Latin letters. The length of each line do... | Print "YES" without the quotes, if the letters in the pile could be permuted to make the names of the "New Year and Christmas Men". Otherwise, print "NO" without the quotes. | [
"SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS\n",
"PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI\n",
"BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER\n"
] | [
"YES\n",
"NO\n",
"NO\n"
] | In the first sample the letters written in the last line can be used to write the names and there won't be any extra letters left.
In the second sample letter "P" is missing from the pile and there's an extra letter "L".
In the third sample there's an extra letter "L". | 500 | [
{
"input": "SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS",
"output": "YES"
},
{
"input": "PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI",
"output": "NO"
},
{
"input": "BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER",
"output": "NO"
},
{
"input": "B\nA\nAB",
"output": ... | 1,690,119,395 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 62 | 0 | def can_form_names(guest_name, host_name, pile_letters):
# Concatenate the guest and host names
combined_names = guest_name + host_name
# Create dictionaries to store the counts of letters in the names and the pile
name_counts = {}
pile_counts = {}
# Count the occurrences of letter... | Title: Amusing Joke
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's nam... | ```python
def can_form_names(guest_name, host_name, pile_letters):
# Concatenate the guest and host names
combined_names = guest_name + host_name
# Create dictionaries to store the counts of letters in the names and the pile
name_counts = {}
pile_counts = {}
# Count the occurrences... | 0 | |
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,588,089,702 | 2,147,483,647 | PyPy 3 | OK | TESTS | 133 | 140 | 0 | s=str(input())
if(s!=s[::-1]):
print(len(s))
else:
flag=0
for i in range(1,len(s)):
d=s[i:]
if(d!=d[::-1]):
flag=1
break
else:
pass
if(flag>0):
print(len(s)-i)
else:
print(0)
| 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
s=str(input())
if(s!=s[::-1]):
print(len(s))
else:
flag=0
for i in range(1,len(s)):
d=s[i:]
if(d!=d[::-1]):
flag=1
break
else:
pass
if(flag>0):
print(len(s)-i)
else:
print(0)
... | 3 | |
150 | A | Win or Freeze | PROGRAMMING | 1,400 | [
"games",
"math",
"number theory"
] | null | null | You can't possibly imagine how cold our friends are this winter in Nvodsk! Two of them play the following game to warm up: initially a piece of paper has an integer *q*. During a move a player should write any integer number that is a non-trivial divisor of the last written number. Then he should run this number of cir... | The first line contains the only integer *q* (1<=≤<=*q*<=≤<=1013).
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator. | In the first line print the number of the winning player (1 or 2). If the first player wins then the second line should contain another integer — his first move (if the first player can't even make the first move, print 0). If there are multiple solutions, print any of them. | [
"6\n",
"30\n",
"1\n"
] | [
"2\n",
"1\n6\n",
"1\n0\n"
] | Number 6 has only two non-trivial divisors: 2 and 3. It is impossible to make a move after the numbers 2 and 3 are written, so both of them are winning, thus, number 6 is the losing number. A player can make a move and write number 6 after number 30; 6, as we know, is a losing number. Thus, this move will bring us the ... | 500 | [
{
"input": "6",
"output": "2"
},
{
"input": "30",
"output": "1\n6"
},
{
"input": "1",
"output": "1\n0"
},
{
"input": "2",
"output": "1\n0"
},
{
"input": "3",
"output": "1\n0"
},
{
"input": "5",
"output": "1\n0"
},
{
"input": "445538663413",... | 1,586,884,547 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 13 | 592 | 0 | import math
def checkprime(x):
for j in range(2,math.ceil(math.sqrt(x))):
if(x%j==0):
return (j)
return x
x=int(input())
y=checkprime(x)
if y==x:
print(1,0,sep='\n')
else:
y1=x/y
if checkprime(y1)==y1:
print(2)
else:
print(1,y*checkprime(y1),sep... | Title: Win or Freeze
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You can't possibly imagine how cold our friends are this winter in Nvodsk! Two of them play the following game to warm up: initially a piece of paper has an integer *q*. During a move a player should write any integer num... | ```python
import math
def checkprime(x):
for j in range(2,math.ceil(math.sqrt(x))):
if(x%j==0):
return (j)
return x
x=int(input())
y=checkprime(x)
if y==x:
print(1,0,sep='\n')
else:
y1=x/y
if checkprime(y1)==y1:
print(2)
else:
print(1,y*checkpri... | 0 | |
573 | B | Bear and Blocks | PROGRAMMING | 1,600 | [
"binary search",
"data structures",
"dp",
"math"
] | null | null | Limak is a little bear who loves to play. Today he is playing by destroying block towers. He built *n* towers in a row. The *i*-th tower is made of *h**i* identical blocks. For clarification see picture for the first sample.
Limak will repeat the following operation till everything is destroyed.
Block is called inter... | The first line contains single integer *n* (1<=≤<=*n*<=≤<=105).
The second line contains *n* space-separated integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=109) — sizes of towers. | Print the number of operations needed to destroy all towers. | [
"6\n2 1 4 6 2 2\n",
"7\n3 3 3 1 3 3 3\n"
] | [
"3\n",
"2\n"
] | The picture below shows all three operations for the first sample test. Each time boundary blocks are marked with red color. | 1,000 | [
{
"input": "6\n2 1 4 6 2 2",
"output": "3"
},
{
"input": "7\n3 3 3 1 3 3 3",
"output": "2"
},
{
"input": "7\n5128 5672 5805 5452 5882 5567 5032",
"output": "4"
},
{
"input": "10\n1 2 2 3 5 5 5 4 2 1",
"output": "5"
},
{
"input": "14\n20 20 20 20 20 20 3 20 20 20 2... | 1,443,797,815 | 2,095 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 6 | 1,000 | 9,216,000 | def solve(n,a):
a.insert(0,0)
a.append(0)
count = 0
b = a[:]
while True:
found = False
for i in range(1,len(a)-1):
if a[i] != 0 and not found:
found = True
count += 1
cur = max(a[i]-1, 0)
b[i] = min([cur,... | Title: Bear and Blocks
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Limak is a little bear who loves to play. Today he is playing by destroying block towers. He built *n* towers in a row. The *i*-th tower is made of *h**i* identical blocks. For clarification see picture for the first sa... | ```python
def solve(n,a):
a.insert(0,0)
a.append(0)
count = 0
b = a[:]
while True:
found = False
for i in range(1,len(a)-1):
if a[i] != 0 and not found:
found = True
count += 1
cur = max(a[i]-1, 0)
b[i] =... | 0 | |
263 | A | Beautiful Matrix | PROGRAMMING | 800 | [
"implementation"
] | null | null | You've got a 5<=×<=5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1.... | The input consists of five lines, each line contains five integers: the *j*-th integer in the *i*-th line of the input represents the element of the matrix that is located on the intersection of the *i*-th row and the *j*-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one. | Print a single integer — the minimum number of moves needed to make the matrix beautiful. | [
"0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n",
"0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n"
] | [
"3\n",
"1\n"
] | none | 500 | [
{
"input": "0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "3"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "1"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 1 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "0"
},
{
"input": "0 0 0 0 0... | 1,694,883,529 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 0 | 30 | 0 | # Función para calcular la distancia entre dos puntos en una matriz
def calculate_distance(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
# Función para calcular el mínimo número de movimientos para colocar el 1 en el centro
def min_moves_to_beautiful(matrix):
# Encontrar la posición actual del número 1
... | Title: Beautiful Matrix
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You've got a 5<=×<=5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to ri... | ```python
# Función para calcular la distancia entre dos puntos en una matriz
def calculate_distance(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
# Función para calcular el mínimo número de movimientos para colocar el 1 en el centro
def min_moves_to_beautiful(matrix):
# Encontrar la posición actual del ... | 0 | |
907 | A | Masha and Bears | PROGRAMMING | 1,300 | [
"brute force",
"implementation"
] | null | null | A family consisting of father bear, mother bear and son bear owns three cars. Father bear can climb into the largest car and he likes it. Also, mother bear can climb into the middle car and she likes it. Moreover, son bear can climb into the smallest car and he likes it. It's known that the largest car is strictly larg... | You are given four integers *V*1, *V*2, *V*3, *V**m*(1<=≤<=*V**i*<=≤<=100) — sizes of father bear, mother bear, son bear and Masha, respectively. It's guaranteed that *V*1<=><=*V*2<=><=*V*3. | Output three integers — sizes of father bear's car, mother bear's car and son bear's car, respectively.
If there are multiple possible solutions, print any.
If there is no solution, print "-1" (without quotes). | [
"50 30 10 10\n",
"100 50 10 21\n"
] | [
"50\n30\n10\n",
"-1\n"
] | In first test case all conditions for cars' sizes are satisfied.
In second test case there is no answer, because Masha should be able to climb into smallest car (so size of smallest car in not less than 21), but son bear should like it, so maximum possible size of it is 20. | 500 | [
{
"input": "50 30 10 10",
"output": "50\n30\n10"
},
{
"input": "100 50 10 21",
"output": "-1"
},
{
"input": "100 50 19 10",
"output": "100\n50\n19"
},
{
"input": "99 50 25 49",
"output": "100\n99\n49"
},
{
"input": "3 2 1 1",
"output": "4\n3\n1"
},
{
"... | 1,514,038,244 | 344 | Python 3 | WRONG_ANSWER | PRETESTS | 0 | 62 | 5,529,600 | v1, v2, v3, vm = map(int, input().split())
if vm > 2*v3:
print(-1)
else:
print(vm)
print(2*v2)
print(2*v1) | Title: Masha and Bears
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A family consisting of father bear, mother bear and son bear owns three cars. Father bear can climb into the largest car and he likes it. Also, mother bear can climb into the middle car and she likes it. Moreover, son b... | ```python
v1, v2, v3, vm = map(int, input().split())
if vm > 2*v3:
print(-1)
else:
print(vm)
print(2*v2)
print(2*v1)
``` | 0 | |
745 | A | Hongcow Learns the Cyclic Shift | PROGRAMMING | 900 | [
"implementation",
"strings"
] | null | null | Hongcow is learning to spell! One day, his teacher gives him a word that he needs to learn to spell. Being a dutiful student, he immediately learns how to spell the word.
Hongcow has decided to try to make new words from this one. He starts by taking the word he just learned how to spell, and moves the last character ... | The first line of input will be a single string *s* (1<=≤<=|*s*|<=≤<=50), the word Hongcow initially learns how to spell. The string *s* consists only of lowercase English letters ('a'–'z'). | Output a single integer equal to the number of distinct strings that Hongcow can obtain by applying the cyclic shift arbitrarily many times to the given string. | [
"abcd\n",
"bbb\n",
"yzyz\n"
] | [
"4\n",
"1\n",
"2\n"
] | For the first sample, the strings Hongcow can generate are "abcd", "dabc", "cdab", and "bcda".
For the second sample, no matter how many times Hongcow does the cyclic shift, Hongcow can only generate "bbb".
For the third sample, the two strings Hongcow can generate are "yzyz" and "zyzy". | 500 | [
{
"input": "abcd",
"output": "4"
},
{
"input": "bbb",
"output": "1"
},
{
"input": "yzyz",
"output": "2"
},
{
"input": "abcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxy",
"output": "25"
},
{
"input": "zclkjadoprqronzclkjadoprqronzclkjadoprqron",
"output": "14... | 1,568,146,324 | 2,147,483,647 | Python 3 | OK | TESTS | 28 | 109 | 0 | l=list(input())
s="".join(l)
d=[]
d.append(s)
for i in range(len(l)):
l.append(l[0])
l.pop(0)
s="".join(l)
if s not in d:
d.append(s)
print(len(d)) | Title: Hongcow Learns the Cyclic Shift
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Hongcow is learning to spell! One day, his teacher gives him a word that he needs to learn to spell. Being a dutiful student, he immediately learns how to spell the word.
Hongcow has decided to try to m... | ```python
l=list(input())
s="".join(l)
d=[]
d.append(s)
for i in range(len(l)):
l.append(l[0])
l.pop(0)
s="".join(l)
if s not in d:
d.append(s)
print(len(d))
``` | 3 | |
877 | B | Nikita and string | PROGRAMMING | 1,500 | [
"brute force",
"dp"
] | null | null | One day Nikita found the string containing letters "a" and "b" only.
Nikita thinks that string is beautiful if it can be cut into 3 strings (possibly empty) without changing the order of the letters, where the 1-st and the 3-rd one contain only letters "a" and the 2-nd contains only letters "b".
Nikita wants to make... | The first line contains a non-empty string of length not greater than 5<=000 containing only lowercase English letters "a" and "b". | Print a single integer — the maximum possible size of beautiful string Nikita can get. | [
"abba\n",
"bab\n"
] | [
"4",
"2"
] | It the first sample the string is already beautiful.
In the second sample he needs to delete one of "b" to make it beautiful. | 1,000 | [
{
"input": "abba",
"output": "4"
},
{
"input": "bab",
"output": "2"
},
{
"input": "bbabbbaabbbb",
"output": "9"
},
{
"input": "bbabbbbbaaba",
"output": "10"
},
{
"input": "bbabbbababaa",
"output": "9"
},
{
"input": "aabbaababbab",
"output": "8"
}... | 1,586,092,192 | 2,147,483,647 | Python 3 | OK | TESTS | 46 | 109 | 307,200 |
max1=0
string=input()
first=0
second=0
third=0
i=0
length=len(string)
while(i<length):
if string[i]=='a':
if second>third:
third=second+1
else:
third+=1
first+=1
if string[i]=='b':
if first>second:
second=first+1... | Title: Nikita and string
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Nikita found the string containing letters "a" and "b" only.
Nikita thinks that string is beautiful if it can be cut into 3 strings (possibly empty) without changing the order of the letters, where the 1-st ... | ```python
max1=0
string=input()
first=0
second=0
third=0
i=0
length=len(string)
while(i<length):
if string[i]=='a':
if second>third:
third=second+1
else:
third+=1
first+=1
if string[i]=='b':
if first>second:
seco... | 3 | |
630 | F | Selection of Personnel | PROGRAMMING | 1,300 | [
"combinatorics",
"math"
] | null | null | One company of IT City decided to create a group of innovative developments consisting from 5 to 7 people and hire new employees for it. After placing an advertisment the company received *n* resumes. Now the HR department has to evaluate each possible group composition and select one of them. Your task is to count the... | The only line of the input contains one integer *n* (7<=≤<=*n*<=≤<=777) — the number of potential employees that sent resumes. | Output one integer — the number of different variants of group composition. | [
"7\n"
] | [
"29"
] | none | 0 | [
{
"input": "7",
"output": "29"
},
{
"input": "8",
"output": "92"
},
{
"input": "9",
"output": "246"
},
{
"input": "10",
"output": "582"
},
{
"input": "321",
"output": "66715035255088"
},
{
"input": "624",
"output": "7147161340917624"
},
{
"... | 1,695,471,646 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 10 | 46 | 0 | from math import comb
n = int(input())
print(comb(n, 5) + comb(n, 6) + comb(n, 7))
| Title: Selection of Personnel
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One company of IT City decided to create a group of innovative developments consisting from 5 to 7 people and hire new employees for it. After placing an advertisment the company received *n* resumes. Now the HR ... | ```python
from math import comb
n = int(input())
print(comb(n, 5) + comb(n, 6) + comb(n, 7))
``` | 3 | |
331 | C1 | The Great Julya Calendar | PROGRAMMING | 1,100 | [
"dp"
] | null | null | Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar.
The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on it. The translation from Old Beaverish is as follows:
"May the Great Beaver bless you! May your chacres open ... | The single line contains the magic integer *n*, 0<=≤<=*n*.
- to get 20 points, you need to solve the problem with constraints: *n*<=≤<=106 (subproblem C1); - to get 40 points, you need to solve the problem with constraints: *n*<=≤<=1012 (subproblems C1+C2); - to get 100 points, you need to solve the problem with co... | Print a single integer — the minimum number of subtractions that turns the magic number to a zero. | [
"24\n"
] | [
"5"
] | In the first test sample the minimum number of operations can be reached by the following sequence of subtractions: | 20 | [
{
"input": "24",
"output": "5"
},
{
"input": "0",
"output": "0"
},
{
"input": "3",
"output": "1"
},
{
"input": "8",
"output": "1"
},
{
"input": "9",
"output": "1"
},
{
"input": "10",
"output": "2"
},
{
"input": "31",
"output": "6"
},
... | 1,551,463,575 | 2,147,483,647 | Python 3 | COMPILATION_ERROR | TESTS1 | 0 | 0 | 0 | n, k = int(input()), 0
while n:
n- = int(max(str(n)))
k + = 1
print( k )
#python ki jai ho :p | Title: The Great Julya Calendar
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar.
The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on i... | ```python
n, k = int(input()), 0
while n:
n- = int(max(str(n)))
k + = 1
print( k )
#python ki jai ho :p
``` | -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,689,849,911 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 62 | 0 | n = int(input())
MOD = 10 ** 9 + 7
if n == 1:
print(0)
exit(0)
n -= 2
ans = 3 * (2 ** n)
ans %= MOD
print(ans) | 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())
MOD = 10 ** 9 + 7
if n == 1:
print(0)
exit(0)
n -= 2
ans = 3 * (2 ** n)
ans %= MOD
print(ans)
``` | 0 | |
985 | A | Chess Placing | PROGRAMMING | 1,100 | [
"implementation"
] | null | null | You are given a chessboard of size 1<=×<=*n*. It is guaranteed that *n* is even. The chessboard is painted like this: "BWBW...BW".
Some cells of the board are occupied by the chess pieces. Each cell contains no more than one chess piece. It is known that the total number of pieces equals to .
In one step you can move... | The first line of the input contains one integer *n* (2<=≤<=*n*<=≤<=100, *n* is even) — the size of the chessboard.
The second line of the input contains integer numbers (1<=≤<=*p**i*<=≤<=*n*) — initial positions of the pieces. It is guaranteed that all the positions are distinct. | Print one integer — the minimum number of moves you have to make to place all the pieces in the cells of the same color. | [
"6\n1 2 6\n",
"10\n1 2 3 4 5\n"
] | [
"2\n",
"10\n"
] | In the first example the only possible strategy is to move the piece at the position 6 to the position 5 and move the piece at the position 2 to the position 3. Notice that if you decide to place the pieces in the white cells the minimum number of moves will be 3.
In the second example the possible strategy is to move... | 0 | [
{
"input": "6\n1 2 6",
"output": "2"
},
{
"input": "10\n1 2 3 4 5",
"output": "10"
},
{
"input": "2\n2",
"output": "0"
},
{
"input": "100\n2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 ... | 1,603,170,371 | 2,147,483,647 | Python 3 | OK | TESTS | 27 | 109 | 307,200 | import math
#n,k = map(int, input().strip().split(' '))
n=int(input())
lst = list(map(int, input().strip().split(' ')))
sum_odd=0
sum_even=0
lst.sort()
for i in range(n//2):
sum_odd+=abs(lst[i]-(2*i+1))
for i in range(n//2):
sum_even+=abs(lst[i]-(2*(i+1)))
print(min(sum_odd,sum_even))
| Title: Chess Placing
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a chessboard of size 1<=×<=*n*. It is guaranteed that *n* is even. The chessboard is painted like this: "BWBW...BW".
Some cells of the board are occupied by the chess pieces. Each cell contains no more than... | ```python
import math
#n,k = map(int, input().strip().split(' '))
n=int(input())
lst = list(map(int, input().strip().split(' ')))
sum_odd=0
sum_even=0
lst.sort()
for i in range(n//2):
sum_odd+=abs(lst[i]-(2*i+1))
for i in range(n//2):
sum_even+=abs(lst[i]-(2*(i+1)))
print(min(sum_odd,sum_even))
... | 3 | |
279 | B | Books | PROGRAMMING | 1,400 | [
"binary search",
"brute force",
"implementation",
"two pointers"
] | null | null | When Valera has got some free time, he goes to the library to read some books. Today he's got *t* free minutes to read. That's why Valera took *n* books in the library and for each book he estimated the time he is going to need to read it. Let's number the books by integers from 1 to *n*. Valera needs *a**i* minutes to... | The first line contains two integers *n* and *t* (1<=≤<=*n*<=≤<=105; 1<=≤<=*t*<=≤<=109) — the number of books and the number of free minutes Valera's got. The second line contains a sequence of *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=104), where number *a**i* shows the number of minutes that the boy n... | Print a single integer — the maximum number of books Valera can read. | [
"4 5\n3 1 2 1\n",
"3 3\n2 2 3\n"
] | [
"3\n",
"1\n"
] | none | 1,000 | [
{
"input": "4 5\n3 1 2 1",
"output": "3"
},
{
"input": "3 3\n2 2 3",
"output": "1"
},
{
"input": "1 3\n5",
"output": "0"
},
{
"input": "1 10\n4",
"output": "1"
},
{
"input": "2 10\n6 4",
"output": "2"
},
{
"input": "6 10\n2 3 4 2 1 1",
"output": "4... | 1,694,616,724 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 1 | 2,000 | 0 | a,b=[int(x) for x in input().split()]
A=list(map(int, input().split()))
A.append(10**10)
x=0
c=b
while c>=0:
c-=A[x]
x+=1
i=0
while i+x<a:
c+=A[i]-A[i+x]
if c>=0:
x+=1
c-=A[i+x]
print(x-1) | Title: Books
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
When Valera has got some free time, he goes to the library to read some books. Today he's got *t* free minutes to read. That's why Valera took *n* books in the library and for each book he estimated the time he is going to need t... | ```python
a,b=[int(x) for x in input().split()]
A=list(map(int, input().split()))
A.append(10**10)
x=0
c=b
while c>=0:
c-=A[x]
x+=1
i=0
while i+x<a:
c+=A[i]-A[i+x]
if c>=0:
x+=1
c-=A[i+x]
print(x-1)
``` | 0 | |
53 | C | Little Frog | PROGRAMMING | 1,200 | [
"constructive algorithms"
] | C. Little Frog | 2 | 256 | Once upon a time a little frog whose name was Vasya decided to travel around his home swamp. Overall there are *n* mounds on the swamp, located on one line. The distance between the neighboring mounds is one meter. Vasya wants to visit all the mounds in one day; besides, he wants to visit each one exactly once. For tha... | The single line contains a number *n* (1<=≤<=*n*<=≤<=104) which is the number of mounds. | Print *n* integers *p**i* (1<=≤<=*p**i*<=≤<=*n*) which are the frog's route plan.
- All the *p**i*'s should be mutually different. - All the |*p**i*–*p**i*<=+<=1|'s should be mutually different (1<=≤<=*i*<=≤<=*n*<=-<=1).
If there are several solutions, output any. | [
"2\n",
"3\n"
] | [
"1 2 ",
"1 3 2 "
] | none | 1,500 | [
{
"input": "2",
"output": "1 2 "
},
{
"input": "3",
"output": "1 3 2 "
},
{
"input": "4",
"output": "1 4 2 3 "
},
{
"input": "5",
"output": "1 5 2 4 3 "
},
{
"input": "6",
"output": "1 6 2 5 3 4 "
},
{
"input": "1",
"output": "1 "
},
{
"inp... | 1,594,450,297 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 186 | 6,656,000 | n=int(input())
odd=[]
even=[]
for i in range(1,n+1):
if i%2:
odd.append(i)
else:
even.append(i)
print(*(odd+even)) | Title: Little Frog
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Once upon a time a little frog whose name was Vasya decided to travel around his home swamp. Overall there are *n* mounds on the swamp, located on one line. The distance between the neighboring mounds is one meter. Vasya wants ... | ```python
n=int(input())
odd=[]
even=[]
for i in range(1,n+1):
if i%2:
odd.append(i)
else:
even.append(i)
print(*(odd+even))
``` | 0 |
672 | B | Different is Good | PROGRAMMING | 1,000 | [
"constructive algorithms",
"implementation",
"strings"
] | null | null | A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string *s* consisting of lowercase English letters. Since Kerem likes it when things are different, he wants all substrings of his string *s* to be distinct. Substring is a string formed by some... | The first line of the input contains an integer *n* (1<=≤<=*n*<=≤<=100<=000) — the length of the string *s*.
The second line contains the string *s* of length *n* consisting of only lowercase English letters. | If it's impossible to change the string *s* such that all its substring are distinct print -1. Otherwise print the minimum required number of changes. | [
"2\naa\n",
"4\nkoko\n",
"5\nmurat\n"
] | [
"1\n",
"2\n",
"0\n"
] | In the first sample one of the possible solutions is to change the first character to 'b'.
In the second sample, one may change the first character to 'a' and second character to 'b', so the string becomes "abko". | 1,000 | [
{
"input": "2\naa",
"output": "1"
},
{
"input": "4\nkoko",
"output": "2"
},
{
"input": "5\nmurat",
"output": "0"
},
{
"input": "6\nacbead",
"output": "1"
},
{
"input": "7\ncdaadad",
"output": "4"
},
{
"input": "25\npeoaicnbisdocqofsqdpgobpn",
"outp... | 1,587,543,122 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 108 | 0 | input()
s = input()
a = len(set(s))
if a == 0:
a = len(s)
print(a)
else:
print(a) | Title: Different is Good
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string *s* consisting of lowercase English letters. Since Kerem likes it when things are di... | ```python
input()
s = input()
a = len(set(s))
if a == 0:
a = len(s)
print(a)
else:
print(a)
``` | 0 | |
1,005 | B | Delete from the Left | PROGRAMMING | 900 | [
"brute force",
"implementation",
"strings"
] | null | null | You are given two strings $s$ and $t$. In a single move, you can choose any of two strings and delete the first (that is, the leftmost) character. After a move, the length of the string decreases by $1$. You can't choose a string if it is empty.
For example:
- by applying a move to the string "where", the result is ... | The first line of the input contains $s$. In the second line of the input contains $t$. Both strings consist only of lowercase Latin letters. The number of letters in each string is between 1 and $2\cdot10^5$, inclusive. | Output the fewest number of moves required. It is possible that, in the end, both strings will be equal to the empty string, and so, are equal to each other. In this case, the answer is obviously the sum of the lengths of the given strings. | [
"test\nwest\n",
"codeforces\nyes\n",
"test\nyes\n",
"b\nab\n"
] | [
"2\n",
"9\n",
"7\n",
"1\n"
] | In the first example, you should apply the move once to the first string and apply the move once to the second string. As a result, both strings will be equal to "est".
In the second example, the move should be applied to the string "codeforces" $8$ times. As a result, the string becomes "codeforces" $\to$ "es". The m... | 0 | [
{
"input": "test\nwest",
"output": "2"
},
{
"input": "codeforces\nyes",
"output": "9"
},
{
"input": "test\nyes",
"output": "7"
},
{
"input": "b\nab",
"output": "1"
},
{
"input": "z\nz",
"output": "0"
},
{
"input": "abacabadabacaba\nabacabadacaba",
... | 1,641,827,957 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 6 | 93 | 1,126,400 | def max_string(s,t):
if len(s)>len(t):
return(s)
else:
return (t)
def min_string(s,t):
if len(s)<len(t):
return(s)
else:
return (t)
s=input()
t=input()
x=''
y=''
if len(s)!=len(t):
x=max_string(s,t)
y=min_string(s,t)
else:
x=s
y=t
l=len(x)
ll=len(x)-1
ss=len(y... | Title: Delete from the Left
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given two strings $s$ and $t$. In a single move, you can choose any of two strings and delete the first (that is, the leftmost) character. After a move, the length of the string decreases by $1$. You can't ... | ```python
def max_string(s,t):
if len(s)>len(t):
return(s)
else:
return (t)
def min_string(s,t):
if len(s)<len(t):
return(s)
else:
return (t)
s=input()
t=input()
x=''
y=''
if len(s)!=len(t):
x=max_string(s,t)
y=min_string(s,t)
else:
x=s
y=t
l=len(x)
ll=len(x)-1... | 0 | |
112 | A | Petya and Strings | PROGRAMMING | 800 | [
"implementation",
"strings"
] | A. Petya and Strings | 2 | 256 | Little Petya loves presents. His mum bought him two strings of the same size for his birthday. The strings consist of uppercase and lowercase Latin letters. Now Petya wants to compare those two strings lexicographically. The letters' case does not matter, that is an uppercase letter is considered equivalent to the corr... | Each of the first two lines contains a bought string. The strings' lengths range from 1 to 100 inclusive. It is guaranteed that the strings are of the same length and also consist of uppercase and lowercase Latin letters. | If the first string is less than the second one, print "-1". If the second string is less than the first one, print "1". If the strings are equal, print "0". Note that the letters' case is not taken into consideration when the strings are compared. | [
"aaaa\naaaA\n",
"abs\nAbz\n",
"abcdefg\nAbCdEfF\n"
] | [
"0\n",
"-1\n",
"1\n"
] | If you want more formal information about the lexicographical order (also known as the "dictionary order" or "alphabetical order"), you can visit the following site:
- http://en.wikipedia.org/wiki/Lexicographical_order | 500 | [
{
"input": "aaaa\naaaA",
"output": "0"
},
{
"input": "abs\nAbz",
"output": "-1"
},
{
"input": "abcdefg\nAbCdEfF",
"output": "1"
},
{
"input": "asadasdasd\nasdwasdawd",
"output": "-1"
},
{
"input": "aslkjlkasdd\nasdlkjdajwi",
"output": "1"
},
{
"input":... | 1,698,654,790 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 0 | 122 | 0 | a, b = str(input()), str(input())
a, b = sorted(a.lower()), sorted(b.lower())
for x in range(len(a)):
if a[x] != b[x]:
oA, oB = ord(a[x]), ord(b[x])
if oA > oB: print(1)
elif oB > oA: print(-1)
else: print(0) | Title: Petya and Strings
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Little Petya loves presents. His mum bought him two strings of the same size for his birthday. The strings consist of uppercase and lowercase Latin letters. Now Petya wants to compare those two strings lexicographically. ... | ```python
a, b = str(input()), str(input())
a, b = sorted(a.lower()), sorted(b.lower())
for x in range(len(a)):
if a[x] != b[x]:
oA, oB = ord(a[x]), ord(b[x])
if oA > oB: print(1)
elif oB > oA: print(-1)
else: print(0)
``` | 0 |
621 | A | Wet Shark and Odd and Even | PROGRAMMING | 900 | [
"implementation"
] | null | null | Today, Wet Shark is given *n* integers. Using any of these integers no more than once, Wet Shark wants to get maximum possible even (divisible by 2) sum. Please, calculate this value for Wet Shark.
Note, that if Wet Shark uses no integers from the *n* integers, the sum is an even integer 0. | The first line of the input contains one integer, *n* (1<=≤<=*n*<=≤<=100<=000). The next line contains *n* space separated integers given to Wet Shark. Each of these integers is in range from 1 to 109, inclusive. | Print the maximum possible even sum that can be obtained if we use some of the given integers. | [
"3\n1 2 3\n",
"5\n999999999 999999999 999999999 999999999 999999999\n"
] | [
"6",
"3999999996"
] | In the first sample, we can simply take all three integers for a total sum of 6.
In the second sample Wet Shark should take any four out of five integers 999 999 999. | 500 | [
{
"input": "3\n1 2 3",
"output": "6"
},
{
"input": "5\n999999999 999999999 999999999 999999999 999999999",
"output": "3999999996"
},
{
"input": "1\n1",
"output": "0"
},
{
"input": "15\n39 52 88 78 46 95 84 98 55 3 68 42 6 18 98",
"output": "870"
},
{
"input": "15\... | 1,667,932,217 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 14 | 93 | 7,884,800 | n = int(input())
listN = list(map(int, input().split()))
listN.sort()
listDiv2 = [i%2 for i in listN]
if(listDiv2.count(1)%2 == 0): print(sum(listN))
else: print(sum(listN) - listN[0])
| Title: Wet Shark and Odd and Even
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Today, Wet Shark is given *n* integers. Using any of these integers no more than once, Wet Shark wants to get maximum possible even (divisible by 2) sum. Please, calculate this value for Wet Shark.
Note, th... | ```python
n = int(input())
listN = list(map(int, input().split()))
listN.sort()
listDiv2 = [i%2 for i in listN]
if(listDiv2.count(1)%2 == 0): print(sum(listN))
else: print(sum(listN) - listN[0])
``` | 0 | |
171 | B | Star | PROGRAMMING | 1,300 | [
"*special",
"combinatorics"
] | null | null | The input contains a single integer *a* (1<=≤<=*a*<=≤<=18257). | Print a single integer *output* (1<=≤<=*output*<=≤<=2·109). | [
"2\n"
] | [
"13"
] | none | 0 | [
{
"input": "2",
"output": "13"
},
{
"input": "1",
"output": "1"
},
{
"input": "3",
"output": "37"
},
{
"input": "4",
"output": "73"
},
{
"input": "5",
"output": "121"
},
{
"input": "6",
"output": "181"
},
{
"input": "7",
"output": "253"... | 1,694,847,487 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 0 | 62 | 0 | # LUOGU_RID: 124877803
a=int(input())
output=(2*n-1)*(2*n-1)+4*(n-1)*n/2
print(output) | Title: Star
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Input Specification:
The input contains a single integer *a* (1<=≤<=*a*<=≤<=18257).
Output Specification:
Print a single integer *output* (1<=≤<=*output*<=≤<=2·109).
Demo Input:
['2\n']
Demo Output:
['13']
Note:
none | ```python
# LUOGU_RID: 124877803
a=int(input())
output=(2*n-1)*(2*n-1)+4*(n-1)*n/2
print(output)
``` | -1 | ||
124 | A | The number of positions | PROGRAMMING | 1,000 | [
"math"
] | null | null | Petr stands in line of *n* people, but he doesn't know exactly which position he occupies. He can say that there are no less than *a* people standing in front of him and no more than *b* people standing behind him. Find the number of different positions Petr can occupy. | The only line contains three integers *n*, *a* and *b* (0<=≤<=*a*,<=*b*<=<<=*n*<=≤<=100). | Print the single number — the number of the sought positions. | [
"3 1 1\n",
"5 2 3\n"
] | [
"2\n",
"3\n"
] | The possible positions in the first sample are: 2 and 3 (if we number the positions starting with 1).
In the second sample they are 3, 4 and 5. | 500 | [
{
"input": "3 1 1",
"output": "2"
},
{
"input": "5 2 3",
"output": "3"
},
{
"input": "5 4 0",
"output": "1"
},
{
"input": "6 5 5",
"output": "1"
},
{
"input": "9 4 3",
"output": "4"
},
{
"input": "11 4 6",
"output": "7"
},
{
"input": "13 8 ... | 1,661,310,028 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 4 | 154 | 0 | # Online Python compiler (interpreter) to run Python online.
# Write Python 3 code in this online editor and run it.
a, b, c = [int(x) for x in input().split()]
print(a-b) | Title: The number of positions
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Petr stands in line of *n* people, but he doesn't know exactly which position he occupies. He can say that there are no less than *a* people standing in front of him and no more than *b* people standing behind h... | ```python
# Online Python compiler (interpreter) to run Python online.
# Write Python 3 code in this online editor and run it.
a, b, c = [int(x) for x in input().split()]
print(a-b)
``` | 0 | |
76 | B | Mice | PROGRAMMING | 2,100 | [
"greedy",
"two pointers"
] | B. Mice | 0 | 256 | Modern researches has shown that a flock of hungry mice searching for a piece of cheese acts as follows: if there are several pieces of cheese then each mouse chooses the closest one. After that all mice start moving towards the chosen piece of cheese. When a mouse or several mice achieve the destination point and ther... | The first line of the input contains four integer numbers *N* (1<=≤<=*N*<=≤<=105), *M* (0<=≤<=*M*<=≤<=105), *Y*0 (0<=≤<=*Y*0<=≤<=107), *Y*1 (0<=≤<=*Y*1<=≤<=107, *Y*0<=≠<=*Y*1). The second line contains a strictly increasing sequence of *N* numbers — *x* coordinates of mice. Third line contains a strictly increasing seq... | The only line of output should contain one number — the minimal number of mice which will remain without cheese. | [
"3 2 0 2\n0 1 3\n2 5\n"
] | [
"1\n"
] | All the three mice will choose the first piece of cheese. Second and third mice will eat this piece. The first one will remain hungry, because it was running towards the same piece, but it was late. The second piece of cheese will remain uneaten. | 0 | [
{
"input": "3 2 0 2\n0 1 3\n2 5",
"output": "1"
},
{
"input": "7 11 10 20\n6 18 32 63 66 68 87\n6 8 15 23 25 41 53 59 60 75 90",
"output": "1"
},
{
"input": "13 17 14 1\n6 9 10 12 17 25 91 100 118 136 145 163 172\n0 1 2 3 4 10 12 13 16 17 19 22 26 27 28 109 154",
"output": "4"
},
... | 1,669,198,216 | 2,147,483,647 | PyPy 3 | OK | TESTS | 20 | 311 | 14,745,600 | def distance(x, y):
return abs(x - y)
n, m, y0, y1 = map(int, input().split())
mouse = list(map(int, input().split()))
cheeses = list(map(int, input().split()))
i = 0
j = 0
res = 0
mouse.append(float("inf"))
cheeses.append(float("inf"))
prevJ = -1
for i in range(n):
while distance(mouse[i], c... | Title: Mice
Time Limit: 0 seconds
Memory Limit: 256 megabytes
Problem Description:
Modern researches has shown that a flock of hungry mice searching for a piece of cheese acts as follows: if there are several pieces of cheese then each mouse chooses the closest one. After that all mice start moving towards the chose... | ```python
def distance(x, y):
return abs(x - y)
n, m, y0, y1 = map(int, input().split())
mouse = list(map(int, input().split()))
cheeses = list(map(int, input().split()))
i = 0
j = 0
res = 0
mouse.append(float("inf"))
cheeses.append(float("inf"))
prevJ = -1
for i in range(n):
while distance(m... | 3 |
272 | A | Dima and Friends | PROGRAMMING | 1,000 | [
"implementation",
"math"
] | null | null | Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and t... | The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains *n* positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single s... | In a single line print the answer to the problem. | [
"1\n1\n",
"1\n2\n",
"2\n3 5\n"
] | [
"3\n",
"2\n",
"3\n"
] | In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers. | 500 | [
{
"input": "1\n1",
"output": "3"
},
{
"input": "1\n2",
"output": "2"
},
{
"input": "2\n3 5",
"output": "3"
},
{
"input": "2\n3 5",
"output": "3"
},
{
"input": "1\n5",
"output": "3"
},
{
"input": "5\n4 4 3 5 1",
"output": "4"
},
{
"input": "... | 1,609,222,648 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 0 | 154 | 0 | n=int(input())
l=list(map(int,input().split()))
s=sum(l)
if(s%(n+1)==0):
print(n+1)
else:
print(s%(n+1)) | Title: Dima and Friends
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the... | ```python
n=int(input())
l=list(map(int,input().split()))
s=sum(l)
if(s%(n+1)==0):
print(n+1)
else:
print(s%(n+1))
``` | 0 | |
660 | A | Co-prime Array | PROGRAMMING | 1,200 | [
"greedy",
"implementation",
"math",
"number theory"
] | null | null | You are given an array of *n* elements, you must make it a co-prime array in as few moves as possible.
In each move you can insert any positive integral number you want not greater than 109 in any place in the array.
An array is co-prime if any two adjacent numbers of it are co-prime.
In the number theory, two integ... | The first line contains integer *n* (1<=≤<=*n*<=≤<=1000) — the number of elements in the given array.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=109) — the elements of the array *a*. | Print integer *k* on the first line — the least number of elements needed to add to the array *a* to make it co-prime.
The second line should contain *n*<=+<=*k* integers *a**j* — the elements of the array *a* after adding *k* elements to it. Note that the new array should be co-prime, so any two adjacent values shoul... | [
"3\n2 7 28\n"
] | [
"1\n2 7 9 28\n"
] | none | 0 | [
{
"input": "3\n2 7 28",
"output": "1\n2 7 1 28"
},
{
"input": "1\n1",
"output": "0\n1"
},
{
"input": "1\n548",
"output": "0\n548"
},
{
"input": "1\n963837006",
"output": "0\n963837006"
},
{
"input": "10\n1 1 1 1 1 1 1 1 1 1",
"output": "0\n1 1 1 1 1 1 1 1 1 1"... | 1,656,467,021 | 2,147,483,647 | PyPy 3-64 | OK | TESTS | 93 | 124 | 4,812,800 | def gcd(a, b):
if b == 0:
return a
return gcd(b, a%b)
n = int(input())
arr = list(map(int, input().split()))
length = n
count = 0
i = 0
while i < length - 1:
if gcd(arr[i], arr[i+1]) > 1:
arr.insert(i+1, 1)
count += 1
length += 1
i += 1
print(count)
pr... | Title: Co-prime Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given an array of *n* elements, you must make it a co-prime array in as few moves as possible.
In each move you can insert any positive integral number you want not greater than 109 in any place in the array.
A... | ```python
def gcd(a, b):
if b == 0:
return a
return gcd(b, a%b)
n = int(input())
arr = list(map(int, input().split()))
length = n
count = 0
i = 0
while i < length - 1:
if gcd(arr[i], arr[i+1]) > 1:
arr.insert(i+1, 1)
count += 1
length += 1
i += 1
print(... | 3 | |
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,637,750,090 | 2,147,483,647 | Python 3 | OK | TESTS | 64 | 46 | 0 | n = int(input())
m = n % 10
if m <= 5:
num = n - m
else:
num = (n // 10 + 1) * 10
print(num)
| 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
n = int(input())
m = n % 10
if m <= 5:
num = n - m
else:
num = (n // 10 + 1) * 10
print(num)
``` | 3 | |
71 | A | Way Too Long Words | PROGRAMMING | 800 | [
"strings"
] | A. Way Too Long Words | 1 | 256 | Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome.
Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation.
This abbreviation is made lik... | The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters. | Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data. | [
"4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n"
] | [
"word\nl10n\ni18n\np43s\n"
] | none | 500 | [
{
"input": "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis",
"output": "word\nl10n\ni18n\np43s"
},
{
"input": "5\nabcdefgh\nabcdefghi\nabcdefghij\nabcdefghijk\nabcdefghijklm",
"output": "abcdefgh\nabcdefghi\nabcdefghij\na9k\na11m"
},
{
"input":... | 1,681,906,768 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 0 | 62 | 0 | n = int(input())
for i in range(n):
w = str(input())
if len(w) > 10:
print(w[0],end="")
print(len(w)-2,end="")
print(w[-1],end="")
else:
print(w) | Title: Way Too Long Words
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome.
Let's consider a word too long, if its length is strictly more than 10 character... | ```python
n = int(input())
for i in range(n):
w = str(input())
if len(w) > 10:
print(w[0],end="")
print(len(w)-2,end="")
print(w[-1],end="")
else:
print(w)
``` | 0 |
703 | A | Mishka and Game | PROGRAMMING | 800 | [
"implementation"
] | null | null | Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds *n* is defined.... | The first line of the input contains single integer *n* *n* (1<=≤<=*n*<=≤<=100) — the number of game rounds.
The next *n* lines contains rounds description. *i*-th of them contains pair of integers *m**i* and *c**i* (1<=≤<=*m**i*,<=<=*c**i*<=≤<=6) — values on dice upper face after Mishka's and Chris' throws in *i*-th ... | If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line. | [
"3\n3 5\n2 1\n4 2\n",
"2\n6 1\n1 6\n",
"3\n1 5\n3 3\n2 2\n"
] | [
"Mishka",
"Friendship is magic!^^",
"Chris"
] | In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there... | 500 | [
{
"input": "3\n3 5\n2 1\n4 2",
"output": "Mishka"
},
{
"input": "2\n6 1\n1 6",
"output": "Friendship is magic!^^"
},
{
"input": "3\n1 5\n3 3\n2 2",
"output": "Chris"
},
{
"input": "6\n4 1\n4 2\n5 3\n5 1\n5 3\n4 1",
"output": "Mishka"
},
{
"input": "8\n2 4\n1 4\n1 ... | 1,671,529,672 | 2,147,483,647 | Python 3 | OK | TESTS | 69 | 46 | 0 | N = int(input())
m = 0
c = 0
for i in range (N):
m1,c1 = map(int, input().split())
if (m1>c1):
m += 1
if (m1<c1):
c += 1
if m<c:
print("Chris")
if c<m:
print("Mishka")
if c==m:
print("Friendship is magic!^^") | Title: Mishka and Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they st... | ```python
N = int(input())
m = 0
c = 0
for i in range (N):
m1,c1 = map(int, input().split())
if (m1>c1):
m += 1
if (m1<c1):
c += 1
if m<c:
print("Chris")
if c<m:
print("Mishka")
if c==m:
print("Friendship is magic!^^")
``` | 3 | |
302 | B | Eugeny and Play List | PROGRAMMING | 1,200 | [
"binary search",
"implementation",
"two pointers"
] | null | null | Eugeny loves listening to music. He has *n* songs in his play list. We know that song number *i* has the duration of *t**i* minutes. Eugeny listens to each song, perhaps more than once. He listens to song number *i* *c**i* times. Eugeny's play list is organized as follows: first song number 1 plays *c*1 times, then son... | The first line contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=105). The next *n* lines contain pairs of integers. The *i*-th line contains integers *c**i*,<=*t**i* (1<=≤<=*c**i*,<=*t**i*<=≤<=109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 .
The next... | Print *m* integers — the *i*-th number must equal the number of the song that was playing during the *v**i*-th minute after Eugeny started listening to the play list. | [
"1 2\n2 8\n1 16\n",
"4 9\n1 2\n2 1\n1 1\n2 2\n1 2 3 4 5 6 7 8 9\n"
] | [
"1\n1\n",
"1\n1\n2\n2\n3\n4\n4\n4\n4\n"
] | none | 1,000 | [
{
"input": "1 2\n2 8\n1 16",
"output": "1\n1"
},
{
"input": "4 9\n1 2\n2 1\n1 1\n2 2\n1 2 3 4 5 6 7 8 9",
"output": "1\n1\n2\n2\n3\n4\n4\n4\n4"
},
{
"input": "3 3\n2 8\n5 1\n10 5\n13 16 62",
"output": "1\n1\n3"
},
{
"input": "4 4\n2 8\n2 2\n6 3\n8 7\n13 23 29 85",
"output... | 1,616,802,587 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 11 | 2,000 | 11,366,400 | qtd_musicas, qtd_momentos = [int(i) for i in input().split()]
musicas = [0] # lista de tuplas (vezes, tempo)
aux = 0
for i in range(qtd_musicas):
vezes, tempo = [int(i) for i in input().split()]
aux += vezes * tempo
musicas.append(aux)
momentos = [int(i) for i in input().split()]
for i in momentos:
for j in r... | Title: Eugeny and Play List
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Eugeny loves listening to music. He has *n* songs in his play list. We know that song number *i* has the duration of *t**i* minutes. Eugeny listens to each song, perhaps more than once. He listens to song number *i... | ```python
qtd_musicas, qtd_momentos = [int(i) for i in input().split()]
musicas = [0] # lista de tuplas (vezes, tempo)
aux = 0
for i in range(qtd_musicas):
vezes, tempo = [int(i) for i in input().split()]
aux += vezes * tempo
musicas.append(aux)
momentos = [int(i) for i in input().split()]
for i in momentos:
... | 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,538,241,174 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 11 | 2,000 | 0 | def number():
num = int(input())
if num < 6:
return 0
res=0
for i in range(6, num+1):
almost = 0
for j in range(2, i+1):
primo = True
for k in range(2, j):
if j % k == 0:
primo = False
bre... | 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 number():
num = int(input())
if num < 6:
return 0
res=0
for i in range(6, num+1):
almost = 0
for j in range(2, i+1):
primo = True
for k in range(2, j):
if j % k == 0:
primo = False
... | 0 |
171 | A | Mysterious numbers - 1 | PROGRAMMING | 1,200 | [
"*special",
"constructive algorithms"
] | null | null | The input contains two integers *a*1,<=*a*2 (0<=≤<=*a**i*<=≤<=109), separated by a single space.
Output a single integer. | The input contains two integers *a*1,<=*a*2 (0<=≤<=*a**i*<=≤<=109), separated by a single space. | Output a single integer. | [
"3 14\n",
"27 12\n",
"100 200\n"
] | [
"44\n",
"48\n",
"102\n"
] | none | 0 | [
{
"input": "3 14",
"output": "44"
},
{
"input": "27 12",
"output": "48"
},
{
"input": "100 200",
"output": "102"
},
{
"input": "0 0",
"output": "0"
},
{
"input": "31415 92653",
"output": "67044"
},
{
"input": "1000000000 0",
"output": "1000000000"
... | 1,490,865,387 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 0 | 92 | 4,608,000 | a=input()
b=input()[::-1]
print(int(a)+int(b)) | Title: Mysterious numbers - 1
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The input contains two integers *a*1,<=*a*2 (0<=≤<=*a**i*<=≤<=109), separated by a single space.
Output a single integer.
Input Specification:
The input contains two integers *a*1,<=*a*2 (0<=≤<=*a**i*<=≤<=109),... | ```python
a=input()
b=input()[::-1]
print(int(a)+int(b))
``` | -1 | |
393 | A | Nineteen | PROGRAMMING | 0 | [] | null | null | Alice likes word "nineteen" very much. She has a string *s* and wants the string to contain as many such words as possible. For that reason she can rearrange the letters of the string.
For example, if she has string "xiineteenppnnnewtnee", she can get string "xnineteenppnineteenw", containing (the occurrences marked) ... | The first line contains a non-empty string *s*, consisting only of lowercase English letters. The length of string *s* doesn't exceed 100. | Print a single integer — the maximum number of "nineteen"s that she can get in her string. | [
"nniinneetteeeenn\n",
"nneteenabcnneteenabcnneteenabcnneteenabcnneteenabcii\n",
"nineteenineteen\n"
] | [
"2",
"2",
"2"
] | none | 500 | [
{
"input": "nniinneetteeeenn",
"output": "2"
},
{
"input": "nneteenabcnneteenabcnneteenabcnneteenabcnneteenabcii",
"output": "2"
},
{
"input": "nineteenineteen",
"output": "2"
},
{
"input": "nssemsnnsitjtihtthij",
"output": "0"
},
{
"input": "eehihnttehtherjsihihn... | 1,631,025,243 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 3 | 46 | 6,963,200 | s=input()
c1=0
c2=0
c3=0
c4=0
for i in s:
if i=='n':
c1+=1
elif i=='i':
c2+=1
elif i=='e':
c3+=1
elif i=='t':
c4+=1
if c1>=3 and c2>=1 and c3>=3 and c4>=1 and c1%3==0:
print(int(min((c1/3), (c2), (c3/3), (c4))))
elif c1>=3 and c2>=1 and c3>=3 and c4>=1... | Title: Nineteen
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Alice likes word "nineteen" very much. She has a string *s* and wants the string to contain as many such words as possible. For that reason she can rearrange the letters of the string.
For example, if she has string "xiinetee... | ```python
s=input()
c1=0
c2=0
c3=0
c4=0
for i in s:
if i=='n':
c1+=1
elif i=='i':
c2+=1
elif i=='e':
c3+=1
elif i=='t':
c4+=1
if c1>=3 and c2>=1 and c3>=3 and c4>=1 and c1%3==0:
print(int(min((c1/3), (c2), (c3/3), (c4))))
elif c1>=3 and c2>=1 and c3>=3... | 0 | |
935 | A | Fafa and his Company | PROGRAMMING | 800 | [
"brute force",
"implementation"
] | null | null | Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees.
Fafa finds doing this every time is very tiring for him. So, he decided to choose the best *l* em... | The input consists of a single line containing a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of employees in Fafa's company. | Print a single integer representing the answer to the problem. | [
"2\n",
"10\n"
] | [
"1\n",
"3\n"
] | In the second sample Fafa has 3 ways:
- choose only 1 employee as a team leader with 9 employees under his responsibility. - choose 2 employees as team leaders with 4 employees under the responsibility of each of them. - choose 5 employees as team leaders with 1 employee under the responsibility of each of them. | 500 | [
{
"input": "2",
"output": "1"
},
{
"input": "10",
"output": "3"
},
{
"input": "3",
"output": "1"
},
{
"input": "4",
"output": "2"
},
{
"input": "6",
"output": "3"
},
{
"input": "13",
"output": "1"
},
{
"input": "100000",
"output": "35"
... | 1,636,804,742 | 2,147,483,647 | Python 3 | OK | TESTS | 33 | 61 | 4,300,800 | n=int(input())
p=0
for i in range(1,n):
if n%i==0:
p+=1
print(p)
| Title: Fafa and his Company
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the emp... | ```python
n=int(input())
p=0
for i in range(1,n):
if n%i==0:
p+=1
print(p)
``` | 3 | |
676 | A | Nicholas and Permutation | PROGRAMMING | 800 | [
"constructive algorithms",
"implementation"
] | null | null | Nicholas has an array *a* that contains *n* distinct integers from 1 to *n*. In other words, Nicholas has a permutation of size *n*.
Nicholas want the minimum element (integer 1) and the maximum element (integer *n*) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize th... | The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=100) — the size of the permutation.
The second line of the input contains *n* distinct integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=*n*), where *a**i* is equal to the element at the *i*-th position. | Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap. | [
"5\n4 5 1 3 2\n",
"7\n1 6 5 3 4 7 2\n",
"6\n6 5 4 3 2 1\n"
] | [
"3\n",
"6\n",
"5\n"
] | In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possib... | 500 | [
{
"input": "5\n4 5 1 3 2",
"output": "3"
},
{
"input": "7\n1 6 5 3 4 7 2",
"output": "6"
},
{
"input": "6\n6 5 4 3 2 1",
"output": "5"
},
{
"input": "2\n1 2",
"output": "1"
},
{
"input": "2\n2 1",
"output": "1"
},
{
"input": "3\n2 3 1",
"output": "... | 1,620,993,214 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 5 | 46 | 6,758,400 | n=int(input())
l=list(map(int,input().split()))
a=min(l.index(max(l)),l.index(min(l)))
print(n-a-1) | Title: Nicholas and Permutation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Nicholas has an array *a* that contains *n* distinct integers from 1 to *n*. In other words, Nicholas has a permutation of size *n*.
Nicholas want the minimum element (integer 1) and the maximum element (integ... | ```python
n=int(input())
l=list(map(int,input().split()))
a=min(l.index(max(l)),l.index(min(l)))
print(n-a-1)
``` | 0 | |
109 | A | Lucky Sum of Digits | PROGRAMMING | 1,000 | [
"brute force",
"implementation"
] | A. Lucky Sum of Digits | 2 | 256 | Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to *n*. Help him cope wi... | The single line contains an integer *n* (1<=≤<=*n*<=≤<=106) — the sum of digits of the required lucky number. | Print on the single line the result — the minimum lucky number, whose sum of digits equals *n*. If such number does not exist, print -1. | [
"11\n",
"10\n"
] | [
"47\n",
"-1\n"
] | none | 500 | [
{
"input": "11",
"output": "47"
},
{
"input": "10",
"output": "-1"
},
{
"input": "64",
"output": "4477777777"
},
{
"input": "1",
"output": "-1"
},
{
"input": "4",
"output": "4"
},
{
"input": "7",
"output": "7"
},
{
"input": "12",
"outpu... | 1,679,354,597 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 6 | 92 | 0 | from math import ceil
x = int(input())
i = 0
limite = 0
if (x % 7 == 0):
print("7" * (x//7))
else:
limite = ceil(x/7)
valor = 4*limite
while(valor != x and i < limite):
valor += 3
i += 1
if (valor != x):
print(-1)
else:
print("4" * (limite - i), "... | Title: Lucky Sum of Digits
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
... | ```python
from math import ceil
x = int(input())
i = 0
limite = 0
if (x % 7 == 0):
print("7" * (x//7))
else:
limite = ceil(x/7)
valor = 4*limite
while(valor != x and i < limite):
valor += 3
i += 1
if (valor != x):
print(-1)
else:
print("4" * (limi... | 0 |
340 | A | The Wall | PROGRAMMING | 1,200 | [
"math"
] | null | null | Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on.
Iahub has the following scheme of painting: he skips *x*<=-<=1 consecutive bricks, then he paints th... | The input will have a single line containing four integers in this order: *x*, *y*, *a*, *b*. (1<=≤<=*x*,<=*y*<=≤<=1000, 1<=≤<=*a*,<=*b*<=≤<=2·109, *a*<=≤<=*b*). | Output a single integer — the number of bricks numbered no less than *a* and no greater than *b* that are painted both red and pink. | [
"2 3 6 18\n"
] | [
"3"
] | Let's look at the bricks from *a* to *b* (*a* = 6, *b* = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18. | 500 | [
{
"input": "2 3 6 18",
"output": "3"
},
{
"input": "4 6 20 201",
"output": "15"
},
{
"input": "15 27 100 10000",
"output": "74"
},
{
"input": "105 60 3456 78910",
"output": "179"
},
{
"input": "1 1 1000 100000",
"output": "99001"
},
{
"input": "3 2 5 5... | 1,590,978,544 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 186 | 0 | x,y,a,b=map(int,input().split())
i=a//x
lst=[]
r1=0
while r1 < b:
r1=i * x
lst.append(r1)
i+=1
ii=a//y
lst2=[]
r2=0
while r2 < b:
r2=ii * y
lst2.append(r2)
ii+=1
print(len(set(lst).intersection(lst2))) | Title: The Wall
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on.
Iahub ... | ```python
x,y,a,b=map(int,input().split())
i=a//x
lst=[]
r1=0
while r1 < b:
r1=i * x
lst.append(r1)
i+=1
ii=a//y
lst2=[]
r2=0
while r2 < b:
r2=ii * y
lst2.append(r2)
ii+=1
print(len(set(lst).intersection(lst2)))
``` | 0 | |
620 | A | Professor GukiZ's Robot | PROGRAMMING | 800 | [
"implementation",
"math"
] | null | null | Professor GukiZ makes a new robot. The robot are in the point with coordinates (*x*1,<=*y*1) and should go to the point (*x*2,<=*y*2). In a single step the robot can change any of its coordinates (maybe both of them) by one (decrease or increase). So the robot can move in one of the 8 directions. Find the minimal numbe... | The first line contains two integers *x*1,<=*y*1 (<=-<=109<=≤<=*x*1,<=*y*1<=≤<=109) — the start position of the robot.
The second line contains two integers *x*2,<=*y*2 (<=-<=109<=≤<=*x*2,<=*y*2<=≤<=109) — the finish position of the robot. | Print the only integer *d* — the minimal number of steps to get the finish position. | [
"0 0\n4 5\n",
"3 4\n6 1\n"
] | [
"5\n",
"3\n"
] | In the first example robot should increase both of its coordinates by one four times, so it will be in position (4, 4). After that robot should simply increase its *y* coordinate and get the finish position.
In the second example robot should simultaneously increase *x* coordinate and decrease *y* coordinate by one th... | 0 | [
{
"input": "0 0\n4 5",
"output": "5"
},
{
"input": "3 4\n6 1",
"output": "3"
},
{
"input": "0 0\n4 6",
"output": "6"
},
{
"input": "1 1\n-3 -5",
"output": "6"
},
{
"input": "-1 -1\n-10 100",
"output": "101"
},
{
"input": "1 -1\n100 -100",
"output":... | 1,606,128,306 | 2,147,483,647 | PyPy 3 | OK | TESTS | 75 | 140 | 0 | x, y=map(int, input().split())
z, t=map(int, input().split())
print(max(abs(x-z), abs(y-t))) | Title: Professor GukiZ's Robot
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Professor GukiZ makes a new robot. The robot are in the point with coordinates (*x*1,<=*y*1) and should go to the point (*x*2,<=*y*2). In a single step the robot can change any of its coordinates (maybe both of ... | ```python
x, y=map(int, input().split())
z, t=map(int, input().split())
print(max(abs(x-z), abs(y-t)))
``` | 3 | |
884 | B | Japanese Crosswords Strike Back | PROGRAMMING | 1,100 | [
"implementation"
] | null | null | A one-dimensional Japanese crossword can be represented as a binary string of length *x*. An encoding of this crossword is an array *a* of size *n*, where *n* is the number of segments formed completely of 1's, and *a**i* is the length of *i*-th segment. No two segments touch or intersect.
For example:
- If *x*<==<... | The first line contains two integer numbers *n* and *x* (1<=≤<=*n*<=≤<=100000, 1<=≤<=*x*<=≤<=109) — the number of elements in the encoding and the length of the crossword Mishka picked.
The second line contains *n* integer numbers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=10000) — the encoding. | Print YES if there exists exaclty one crossword with chosen length and encoding. Otherwise, print NO. | [
"2 4\n1 3\n",
"3 10\n3 3 2\n",
"2 10\n1 3\n"
] | [
"NO\n",
"YES\n",
"NO\n"
] | none | 0 | [
{
"input": "2 4\n1 3",
"output": "NO"
},
{
"input": "3 10\n3 3 2",
"output": "YES"
},
{
"input": "2 10\n1 3",
"output": "NO"
},
{
"input": "1 1\n1",
"output": "YES"
},
{
"input": "1 10\n10",
"output": "YES"
},
{
"input": "1 10000\n10000",
"output":... | 1,510,270,637 | 2,147,483,647 | Python 3 | OK | TESTS | 66 | 92 | 7,372,800 | n,x = list(map(int,input().split()))
a = list(map(int,input().split()))
if x - sum(a) == n-1:
print("YES")
else:
print("NO")
| Title: Japanese Crosswords Strike Back
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A one-dimensional Japanese crossword can be represented as a binary string of length *x*. An encoding of this crossword is an array *a* of size *n*, where *n* is the number of segments formed completely ... | ```python
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))
if x - sum(a) == n-1:
print("YES")
else:
print("NO")
``` | 3 | |
52 | A | 123-sequence | PROGRAMMING | 900 | [
"implementation"
] | A. 123-sequence | 2 | 256 | There is a given sequence of integers *a*1,<=*a*2,<=...,<=*a**n*, where every number is from 1 to 3 inclusively. You have to replace the minimum number of numbers in it so that all the numbers in the sequence are equal to each other. | The first line contains an integer *n* (1<=≤<=*n*<=≤<=106). The second line contains a sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=3). | Print the minimum number of replacements needed to be performed to make all the numbers in the sequence equal. | [
"9\n1 3 2 2 2 1 1 2 3\n"
] | [
"5\n"
] | In the example all the numbers equal to 1 and 3 should be replaced by 2. | 500 | [
{
"input": "9\n1 3 2 2 2 1 1 2 3",
"output": "5"
},
{
"input": "6\n3 3 2 2 1 3",
"output": "3"
},
{
"input": "12\n3 1 3 1 2 1 3 2 2 1 2 1",
"output": "7"
},
{
"input": "15\n3 2 1 1 1 1 3 2 2 3 3 1 2 3 2",
"output": "10"
},
{
"input": "2\n2 1",
"output": "1"
... | 1,674,661,826 | 2,147,483,647 | Python 3 | OK | TESTS | 23 | 278 | 11,059,200 | length = int(input())
numbers = tuple(input().split())
a = numbers.count('1')
b = numbers.count('2')
c = numbers.count('3')
print(min((a + b), (a + c), (b + c)))
| Title: 123-sequence
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
There is a given sequence of integers *a*1,<=*a*2,<=...,<=*a**n*, where every number is from 1 to 3 inclusively. You have to replace the minimum number of numbers in it so that all the numbers in the sequence are equal to each... | ```python
length = int(input())
numbers = tuple(input().split())
a = numbers.count('1')
b = numbers.count('2')
c = numbers.count('3')
print(min((a + b), (a + c), (b + c)))
``` | 3.909901 |
272 | A | Dima and Friends | PROGRAMMING | 1,000 | [
"implementation",
"math"
] | null | null | Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and t... | The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains *n* positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single s... | In a single line print the answer to the problem. | [
"1\n1\n",
"1\n2\n",
"2\n3 5\n"
] | [
"3\n",
"2\n",
"3\n"
] | In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers. | 500 | [
{
"input": "1\n1",
"output": "3"
},
{
"input": "1\n2",
"output": "2"
},
{
"input": "2\n3 5",
"output": "3"
},
{
"input": "2\n3 5",
"output": "3"
},
{
"input": "1\n5",
"output": "3"
},
{
"input": "5\n4 4 3 5 1",
"output": "4"
},
{
"input": "... | 1,608,734,561 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 0 | 186 | 204,800 | n=int(input()) #Number of divisors of a and b
divisors = input().split(" ")
divisors = [int(i) for i in divisors]
divisors.sort()
possibleValue = divisors[0]*divisors[n-1]
temp=[]
i=1
while (i*i)<=possibleValue:
if possibleValue%i==0:
temp.append(i)
if possibleValue//i !=i:
temp.appen... | Title: Dima and Friends
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the... | ```python
n=int(input()) #Number of divisors of a and b
divisors = input().split(" ")
divisors = [int(i) for i in divisors]
divisors.sort()
possibleValue = divisors[0]*divisors[n-1]
temp=[]
i=1
while (i*i)<=possibleValue:
if possibleValue%i==0:
temp.append(i)
if possibleValue//i !=i:
... | -1 | |
202 | A | LLPS | PROGRAMMING | 800 | [
"binary search",
"bitmasks",
"brute force",
"greedy",
"implementation",
"strings"
] | null | null | This problem's actual name, "Lexicographically Largest Palindromic Subsequence" is too long to fit into the page headline.
You are given string *s* consisting of lowercase English letters only. Find its lexicographically largest palindromic subsequence.
We'll call a non-empty string *s*[*p*1*p*2... *p**k*] = *s**p*1*... | The only input line contains a non-empty string *s* consisting of lowercase English letters only. Its length does not exceed 10. | Print the lexicographically largest palindromic subsequence of string *s*. | [
"radar\n",
"bowwowwow\n",
"codeforces\n",
"mississipp\n"
] | [
"rr\n",
"wwwww\n",
"s\n",
"ssss\n"
] | Among all distinct subsequences of string "radar" the following ones are palindromes: "a", "d", "r", "aa", "rr", "ada", "rar", "rdr", "raar" and "radar". The lexicographically largest of them is "rr". | 500 | [
{
"input": "radar",
"output": "rr"
},
{
"input": "bowwowwow",
"output": "wwwww"
},
{
"input": "codeforces",
"output": "s"
},
{
"input": "mississipp",
"output": "ssss"
},
{
"input": "tourist",
"output": "u"
},
{
"input": "romka",
"output": "r"
},
... | 1,616,939,969 | 2,147,483,647 | Python 3 | OK | TESTS | 54 | 154 | 0 | def palindromic_subseq(word):
largest_char = sorted(word)[-1]
return largest_char * (word.count(largest_char))
word = input()
print(palindromic_subseq(word)) | Title: LLPS
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
This problem's actual name, "Lexicographically Largest Palindromic Subsequence" is too long to fit into the page headline.
You are given string *s* consisting of lowercase English letters only. Find its lexicographically largest ... | ```python
def palindromic_subseq(word):
largest_char = sorted(word)[-1]
return largest_char * (word.count(largest_char))
word = input()
print(palindromic_subseq(word))
``` | 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,565,480,665 | 2,147,483,647 | Python 3 | OK | TESTS | 133 | 124 | 0 | # https://vjudge.net/contest/319028#problem/D
def is_palindrome(word):
palindrome = True
size = len(word)
middle = int(size / 2)
for i in range(0, middle):
palindrome = palindrome and word[i] == word[size - i - 1]
return palindrome
word = str(input())
result = len(word)
if is_palind... | 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
# https://vjudge.net/contest/319028#problem/D
def is_palindrome(word):
palindrome = True
size = len(word)
middle = int(size / 2)
for i in range(0, middle):
palindrome = palindrome and word[i] == word[size - i - 1]
return palindrome
word = str(input())
result = len(word)
if... | 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,608,909,022 | 2,147,483,647 | PyPy 3 | OK | TESTS | 32 | 340 | 0 | x, numbers = input(), list(map(int, input().split()))
if numbers[0] % 2 == 0 and (numbers[1] % 2 == 0 or numbers[-1] % 2 == 0):
for i in numbers:
if i % 2 != 0:
print(numbers.index(i)+1)
break
elif numbers[0] % 2 != 0 and (numbers[1] % 2 == 0 and numbers[-1] % 2 == 0):
for... | Title: IQ test
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — t... | ```python
x, numbers = input(), list(map(int, input().split()))
if numbers[0] % 2 == 0 and (numbers[1] % 2 == 0 or numbers[-1] % 2 == 0):
for i in numbers:
if i % 2 != 0:
print(numbers.index(i)+1)
break
elif numbers[0] % 2 != 0 and (numbers[1] % 2 == 0 and numbers[-1] % 2 == 0)... | 3.915 |
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,650,110,741 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 46 | 0 | mes = input()
word = ''
for i in range(len(mes)):
if mes[i] == 'h':
if 'h' not in word:
word += 'h'
else:
continue
elif mes[i] == 'e' and 'h' in word:
if 'e' not in word:
word += 'e'
else:
continue
elif mes[i] == 'l... | 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
mes = input()
word = ''
for i in range(len(mes)):
if mes[i] == 'h':
if 'h' not in word:
word += 'h'
else:
continue
elif mes[i] == 'e' and 'h' in word:
if 'e' not in word:
word += 'e'
else:
continue
elif me... | 3.977 |
466 | C | Number of Ways | PROGRAMMING | 1,700 | [
"binary search",
"brute force",
"data structures",
"dp",
"two pointers"
] | null | null | You've got array *a*[1],<=*a*[2],<=...,<=*a*[*n*], consisting of *n* integers. Count the number of ways to split all the elements of the array into three contiguous parts so that the sum of elements in each part is the same.
More formally, you need to find the number of such pairs of indices *i*,<=*j* (2<=≤<=*i*<=≤<=... | The first line contains integer *n* (1<=≤<=*n*<=≤<=5·105), showing how many numbers are in the array. The second line contains *n* integers *a*[1], *a*[2], ..., *a*[*n*] (|*a*[*i*]|<=≤<=<=109) — the elements of array *a*. | Print a single integer — the number of ways to split the array into three parts with the same sum. | [
"5\n1 2 3 0 3\n",
"4\n0 1 -1 0\n",
"2\n4 1\n"
] | [
"2\n",
"1\n",
"0\n"
] | none | 1,500 | [
{
"input": "5\n1 2 3 0 3",
"output": "2"
},
{
"input": "4\n0 1 -1 0",
"output": "1"
},
{
"input": "2\n4 1",
"output": "0"
},
{
"input": "9\n0 0 0 0 0 0 0 0 0",
"output": "28"
},
{
"input": "10\n2 5 -2 2 -3 -2 3 5 -5 -2",
"output": "0"
},
{
"input": "1\... | 1,699,802,862 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 420 | 62,976,000 | l=int(input())
a=[int(v) for v in input().split(' ')]
c=0;m=0;C=0;s=sum(a)
for i in range(l-1):
c+=a[i]
if c==2*s/3:
C+=m
if c==s/3:
m+=1
print(C) | Title: Number of Ways
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You've got array *a*[1],<=*a*[2],<=...,<=*a*[*n*], consisting of *n* integers. Count the number of ways to split all the elements of the array into three contiguous parts so that the sum of elements in each part is the s... | ```python
l=int(input())
a=[int(v) for v in input().split(' ')]
c=0;m=0;C=0;s=sum(a)
for i in range(l-1):
c+=a[i]
if c==2*s/3:
C+=m
if c==s/3:
m+=1
print(C)
``` | 3 | |
181 | A | Series of Crimes | PROGRAMMING | 800 | [
"brute force",
"geometry",
"implementation"
] | null | null | The Berland capital is shaken with three bold crimes committed by the Pihsters, a notorious criminal gang.
The Berland capital's map is represented by an *n*<=×<=*m* rectangular table. Each cell of the table on the map represents some districts of the capital.
The capital's main detective Polycarpus took a map and m... | The first line contains two space-separated integers *n* and *m* (2<=≤<=*n*,<=*m*<=≤<=100) — the number of rows and columns in the table, correspondingly.
Each of the next *n* lines contains *m* characters — the description of the capital's map. Each character can either be a "." (dot), or an "*" (asterisk). A charact... | Print two integers — the number of the row and the number of the column of the city district that is the fourth one to be robbed. The rows are numbered starting from one from top to bottom and the columns are numbered starting from one from left to right. | [
"3 2\n.*\n..\n**\n",
"3 3\n*.*\n*..\n...\n"
] | [
"1 1\n",
"2 3\n"
] | none | 500 | [
{
"input": "3 2\n.*\n..\n**",
"output": "1 1"
},
{
"input": "2 5\n*....\n*...*",
"output": "1 5"
},
{
"input": "7 2\n..\n**\n..\n..\n..\n..\n.*",
"output": "7 1"
},
{
"input": "7 2\n*.\n..\n..\n..\n..\n..\n**",
"output": "1 2"
},
{
"input": "2 10\n*......*..\n....... | 1,636,533,925 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 1 | 92 | 4,505,600 | n, m = list(map(int, input().split()))
row, column = [0, 0]
index_value = 0
diff = 0
if m >= n:
g = 0
for i in range(n):
data = list(input())
if data.count("*") == 2:
temp = [i for i, i1 in enumerate(data) if i1 == "*"]
row = temp[0]
column +=... | Title: Series of Crimes
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Berland capital is shaken with three bold crimes committed by the Pihsters, a notorious criminal gang.
The Berland capital's map is represented by an *n*<=×<=*m* rectangular table. Each cell of the table on the ma... | ```python
n, m = list(map(int, input().split()))
row, column = [0, 0]
index_value = 0
diff = 0
if m >= n:
g = 0
for i in range(n):
data = list(input())
if data.count("*") == 2:
temp = [i for i, i1 in enumerate(data) if i1 == "*"]
row = temp[0]
... | 0 | |
588 | A | Duff and Meat | PROGRAMMING | 900 | [
"greedy"
] | null | null | Duff is addicted to meat! Malek wants to keep her happy for *n* days. In order to be happy in *i*-th day, she needs to eat exactly *a**i* kilograms of meat.
There is a big shop uptown and Malek wants to buy meat for her from there. In *i*-th day, they sell meat for *p**i* dollars per kilogram. Malek knows all numbers ... | The first line of input contains integer *n* (1<=≤<=*n*<=≤<=105), the number of days.
In the next *n* lines, *i*-th line contains two integers *a**i* and *p**i* (1<=≤<=*a**i*,<=*p**i*<=≤<=100), the amount of meat Duff needs and the cost of meat in that day. | Print the minimum money needed to keep Duff happy for *n* days, in one line. | [
"3\n1 3\n2 2\n3 1\n",
"3\n1 3\n2 1\n3 2\n"
] | [
"10\n",
"8\n"
] | In the first sample case: An optimal way would be to buy 1 kg on the first day, 2 kg on the second day and 3 kg on the third day.
In the second sample case: An optimal way would be to buy 1 kg on the first day and 5 kg (needed meat for the second and third day) on the second day. | 750 | [
{
"input": "3\n1 3\n2 2\n3 1",
"output": "10"
},
{
"input": "3\n1 3\n2 1\n3 2",
"output": "8"
},
{
"input": "1\n39 52",
"output": "2028"
},
{
"input": "2\n25 56\n94 17",
"output": "2998"
},
{
"input": "5\n39 21\n95 89\n73 90\n9 55\n85 32",
"output": "6321"
}... | 1,577,700,248 | 2,147,483,647 | PyPy 3 | OK | TESTS | 30 | 842 | 12,697,600 | n=int(input())
a=[0]*n
p=[0]*n
for i in range(n):
x, b = map(int, input().split())
a[i]=x
p[i]=b
k1=n
k=n
summ=0
while k!=0:
k = p[:k1].index(min(p[:k1]))
summ+=sum(a[k:k1])*p[k]
k1=k
print(summ)
| Title: Duff and Meat
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Duff is addicted to meat! Malek wants to keep her happy for *n* days. In order to be happy in *i*-th day, she needs to eat exactly *a**i* kilograms of meat.
There is a big shop uptown and Malek wants to buy meat for her ... | ```python
n=int(input())
a=[0]*n
p=[0]*n
for i in range(n):
x, b = map(int, input().split())
a[i]=x
p[i]=b
k1=n
k=n
summ=0
while k!=0:
k = p[:k1].index(min(p[:k1]))
summ+=sum(a[k:k1])*p[k]
k1=k
print(summ)
``` | 3 | |
946 | C | String Transformation | PROGRAMMING | 1,300 | [
"greedy",
"strings"
] | null | null | You are given a string *s* consisting of |*s*| small english letters.
In one move you can replace any character of this string to the next character in alphabetical order (a will be replaced with b, s will be replaced with t, etc.). You cannot replace letter z with any other letter.
Your target is to make some number... | The only one line of the input consisting of the string *s* consisting of |*s*| (1<=≤<=|*s*|<=≤<=105) small english letters. | If you can get a string that can be obtained from the given string and will contain english alphabet as a subsequence, print it. Otherwise print «-1» (without quotes). | [
"aacceeggiikkmmooqqssuuwwyy\n",
"thereisnoanswer\n"
] | [
"abcdefghijklmnopqrstuvwxyz\n",
"-1\n"
] | none | 0 | [
{
"input": "aacceeggiikkmmooqqssuuwwyy",
"output": "abcdefghijklmnopqrstuvwxyz"
},
{
"input": "thereisnoanswer",
"output": "-1"
},
{
"input": "jqcfvsaveaixhioaaeephbmsmfcgdyawscpyioybkgxlcrhaxs",
"output": "-1"
},
{
"input": "rtdacjpsjjmjdhcoprjhaenlwuvpfqzurnrswngmpnkdnunaen... | 1,632,394,196 | 896 | PyPy 3 | RUNTIME_ERROR | TESTS | 2 | 108 | 22,220,800 | s = str(input())
n = len(s)
if len(s) < 26:
print(-1)
exit()
cur = 0
t = []
for i in range(n):
if s[i] != 'z':
t.append(chr(cur+ord('a')))
cur += 1
else:
t.append('z')
cnt = 0
for i in range(n):
if t[i] == chr(cnt+ord('a')):
cnt += 1
if cnt == 26:... | Title: String Transformation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a string *s* consisting of |*s*| small english letters.
In one move you can replace any character of this string to the next character in alphabetical order (a will be replaced with b, s will be rep... | ```python
s = str(input())
n = len(s)
if len(s) < 26:
print(-1)
exit()
cur = 0
t = []
for i in range(n):
if s[i] != 'z':
t.append(chr(cur+ord('a')))
cur += 1
else:
t.append('z')
cnt = 0
for i in range(n):
if t[i] == chr(cnt+ord('a')):
cnt += 1
if ... | -1 | |
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,560,598,298 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 6 | 2,000 | 5,836,800 | n = int(input())
a = list(sorted(map(int, input().split())))
s = sum(a)
p = 0
x = max(a)
while len(a) > 0:
p = sum(a)
len(a) - 1
s = s + p
a.remove(min(a))
print(s - x) | 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
n = int(input())
a = list(sorted(map(int, input().split())))
s = sum(a)
p = 0
x = max(a)
while len(a) > 0:
p = sum(a)
len(a) - 1
s = s + p
a.remove(min(a))
print(s - x)
``` | 0 | |
525 | A | Vitaliy and Pie | PROGRAMMING | 1,100 | [
"greedy",
"hashing",
"strings"
] | null | null | After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with *n* room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third ... | The first line of the input contains a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of rooms in the house.
The second line of the input contains string *s* of length 2·*n*<=-<=2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string *s* contain ... | Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room *n*. | [
"3\naAbB\n",
"4\naBaCaB\n",
"5\nxYyXzZaZ\n"
] | [
"0\n",
"3\n",
"2\n"
] | none | 250 | [
{
"input": "3\naAbB",
"output": "0"
},
{
"input": "4\naBaCaB",
"output": "3"
},
{
"input": "5\nxYyXzZaZ",
"output": "2"
},
{
"input": "26\naAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyY",
"output": "0"
},
{
"input": "26\nzAyBxCwDvEuFtGsHrIqJpKoLnMmNlOkPjQiRhSg... | 1,427,388,081 | 681 | Python 3 | TIME_LIMIT_EXCEEDED | PRETESTS | 7 | 2,000 | 409,600 | n = int(input())
s = input()
list1 = []
count = 0
counter = 0
for i in s:
if counter % 2 == 0:
list1.append(i.upper())
counter += 1
else:
if i not in list1:
count += 1
counter += 1
else:
list1.remove(i.upper())
counte... | Title: Vitaliy and Pie
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with *n* room located in a line and numbered starting from one from... | ```python
n = int(input())
s = input()
list1 = []
count = 0
counter = 0
for i in s:
if counter % 2 == 0:
list1.append(i.upper())
counter += 1
else:
if i not in list1:
count += 1
counter += 1
else:
list1.remove(i.upper())
... | 0 | |
0 | none | none | none | 0 | [
"none"
] | null | null | Dreamoon likes to play with sets, integers and . is defined as the largest positive integer that divides both *a* and *b*.
Let *S* be a set of exactly four distinct integers greater than 0. Define *S* to be of rank *k* if and only if for all pairs of distinct elements *s**i*, *s**j* from *S*, .
Given *k* and *n*, Dr... | The single line of the input contains two space separated integers *n*, *k* (1<=≤<=*n*<=≤<=10<=000,<=1<=≤<=*k*<=≤<=100). | On the first line print a single integer — the minimal possible *m*.
On each of the next *n* lines print four space separated integers representing the *i*-th set.
Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal *m*, print any o... | [
"1 1\n",
"2 2\n"
] | [
"5\n1 2 3 5\n",
"22\n2 4 6 22\n14 18 10 16\n"
] | For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/e2af04e5e60e1fe79a4d74bf22dfa575f0b0f7bb.png" style="max-width: 100.0%;max-height: 100.0%;"/>. | 0 | [
{
"input": "1 1",
"output": "5\n1 3 4 5"
},
{
"input": "2 2",
"output": "22\n2 6 8 10\n14 18 20 22"
},
{
"input": "7 7",
"output": "287\n7 21 28 35\n49 63 70 77\n91 105 112 119\n133 147 154 161\n175 189 196 203\n217 231 238 245\n259 273 280 287"
},
{
"input": "13 7",
"out... | 1,566,992,003 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 1 | 109 | 0 | class CodeforcesTask477BSolution:
def __init__(self):
self.result = ''
self.n_k = []
def read_input(self):
self.n_k = [int(x) for x in input().split(" ")]
def process_task(self):
m = (6 * self.n_k[0] - 1) * self.n_k[1]
results = []
for x in range(self.n_k[0]... | Title: none
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Dreamoon likes to play with sets, integers and . is defined as the largest positive integer that divides both *a* and *b*.
Let *S* be a set of exactly four distinct integers greater than 0. Define *S* to be of rank *k* if and on... | ```python
class CodeforcesTask477BSolution:
def __init__(self):
self.result = ''
self.n_k = []
def read_input(self):
self.n_k = [int(x) for x in input().split(" ")]
def process_task(self):
m = (6 * self.n_k[0] - 1) * self.n_k[1]
results = []
for x in range(s... | 0 | |
246 | B | Increase and Decrease | PROGRAMMING | 1,300 | [
"greedy",
"math"
] | null | null | Polycarpus has an array, consisting of *n* integers *a*1,<=*a*2,<=...,<=*a**n*. Polycarpus likes it when numbers in an array match. That's why he wants the array to have as many equal numbers as possible. For that Polycarpus performs the following operation multiple times:
- he chooses two elements of the array *a**i... | The first line contains integer *n* (1<=≤<=*n*<=≤<=105) — the array size. The second line contains space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=104) — the original array. | Print a single integer — the maximum number of equal array elements he can get if he performs an arbitrary number of the given operation. | [
"2\n2 1\n",
"3\n1 4 1\n"
] | [
"1\n",
"3\n"
] | none | 1,000 | [
{
"input": "2\n2 1",
"output": "1"
},
{
"input": "3\n1 4 1",
"output": "3"
},
{
"input": "4\n2 -7 -2 -6",
"output": "3"
},
{
"input": "4\n2 0 -2 -1",
"output": "3"
},
{
"input": "6\n-1 1 0 0 -1 -1",
"output": "5"
},
{
"input": "5\n0 0 0 0 0",
"outp... | 1,604,295,661 | 2,147,483,647 | PyPy 3 | OK | TESTS | 30 | 310 | 5,120,000 | n = int(input())
l=list(map(int,input().split()))
l=sum(l)
if l%n==0 :
print(n)
else:
print(n-1)
| Title: Increase and Decrease
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarpus has an array, consisting of *n* integers *a*1,<=*a*2,<=...,<=*a**n*. Polycarpus likes it when numbers in an array match. That's why he wants the array to have as many equal numbers as possible. For that... | ```python
n = int(input())
l=list(map(int,input().split()))
l=sum(l)
if l%n==0 :
print(n)
else:
print(n-1)
``` | 3 | |
614 | B | Gena's Code | PROGRAMMING | 1,400 | [
"implementation",
"math"
] | null | null | It's the year 4527 and the tanks game that we all know and love still exists. There also exists Great Gena's code, written in 2016. The problem this code solves is: given the number of tanks that go into the battle from each country, find their product. If it is turns to be too large, then the servers might have not en... | The first line of the input contains the number of countries *n* (1<=≤<=*n*<=≤<=100<=000). The second line contains *n* non-negative integers *a**i* without leading zeroes — the number of tanks of the *i*-th country.
It is guaranteed that the second line contains at least *n*<=-<=1 beautiful numbers and the total leng... | Print a single number without leading zeroes — the product of the number of tanks presented by each country. | [
"3\n5 10 1\n",
"4\n1 1 10 11\n",
"5\n0 3 1 100 1\n"
] | [
"50",
"110",
"0"
] | In sample 1 numbers 10 and 1 are beautiful, number 5 is not not.
In sample 2 number 11 is not beautiful (contains two '1's), all others are beautiful.
In sample 3 number 3 is not beautiful, all others are beautiful. | 1,000 | [
{
"input": "3\n5 10 1",
"output": "50"
},
{
"input": "4\n1 1 10 11",
"output": "110"
},
{
"input": "5\n0 3 1 100 1",
"output": "0"
},
{
"input": "40\n10 100 10 1 10 10 100 10 10 100 10 100 100 10 1824868942 100 100 1 10 100 100 10 100 100 10 100 10 1 10 100 100 100 10 1 10 1 ... | 1,550,077,626 | 2,147,483,647 | PyPy 3 | TIME_LIMIT_EXCEEDED | TESTS | 14 | 500 | 7,884,800 | import collections
n=int(input())
ss=""
l=list(map(int,input().split()))
d=collections.Counter(l)
if d[0]>0 :
print(0)
exit()
r=1
for x in d :
if x%10==0 and str(x)[0]=="1" :
ss+="0"*(len(str(x))-1)*d[x]
else :
if x!=1 :
r=x
print(str(r)+... | Title: Gena's Code
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
It's the year 4527 and the tanks game that we all know and love still exists. There also exists Great Gena's code, written in 2016. The problem this code solves is: given the number of tanks that go into the battle from eac... | ```python
import collections
n=int(input())
ss=""
l=list(map(int,input().split()))
d=collections.Counter(l)
if d[0]>0 :
print(0)
exit()
r=1
for x in d :
if x%10==0 and str(x)[0]=="1" :
ss+="0"*(len(str(x))-1)*d[x]
else :
if x!=1 :
r=x
pri... | 0 | |
567 | B | Berland National Library | PROGRAMMING | 1,300 | [
"implementation"
] | null | null | Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed... | The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100) — the number of records in the system log. Next follow *n* events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ *r**i*" or "- *r**i*", where *r**i* is an integer from 1 to 106, the r... | Print a single integer — the minimum possible capacity of the reading room. | [
"6\n+ 12001\n- 12001\n- 1\n- 1200\n+ 1\n+ 7\n",
"2\n- 1\n- 2\n",
"2\n+ 1\n- 1\n"
] | [
"3",
"2",
"1"
] | In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | 1,000 | [
{
"input": "6\n+ 12001\n- 12001\n- 1\n- 1200\n+ 1\n+ 7",
"output": "3"
},
{
"input": "2\n- 1\n- 2",
"output": "2"
},
{
"input": "2\n+ 1\n- 1",
"output": "1"
},
{
"input": "5\n+ 1\n- 1\n+ 2\n+ 3\n- 4",
"output": "3"
},
{
"input": "3\n- 1\n- 2\n- 3",
"output": "... | 1,667,199,319 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 3 | 46 | 0 | n = int(input())
visitors = 0
best = 0
for _ in range(n):
op, id = input().split()
if op == "+":
visitors += 1
best = max(best, abs(visitors))
elif op == "-":
visitors -= 1
if visitors < 0:
visitors = 0
best += 1
print(best)
| Title: Berland National Library
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the... | ```python
n = int(input())
visitors = 0
best = 0
for _ in range(n):
op, id = input().split()
if op == "+":
visitors += 1
best = max(best, abs(visitors))
elif op == "-":
visitors -= 1
if visitors < 0:
visitors = 0
best += 1
print(best)
... | 0 | |
900 | A | Find Extra One | PROGRAMMING | 800 | [
"geometry",
"implementation"
] | null | null | You have *n* distinct points on a plane, none of them lie on *OY* axis. Check that there is a point after removal of which the remaining points are located on one side of the *OY* axis. | The first line contains a single positive integer *n* (2<=≤<=*n*<=≤<=105).
The following *n* lines contain coordinates of the points. The *i*-th of these lines contains two single integers *x**i* and *y**i* (|*x**i*|,<=|*y**i*|<=≤<=109, *x**i*<=≠<=0). No two points coincide. | Print "Yes" if there is such a point, "No" — otherwise.
You can print every letter in any case (upper or lower). | [
"3\n1 1\n-1 -1\n2 -1\n",
"4\n1 1\n2 2\n-1 1\n-2 2\n",
"3\n1 2\n2 1\n4 60\n"
] | [
"Yes",
"No",
"Yes"
] | In the first example the second point can be removed.
In the second example there is no suitable for the condition point.
In the third example any point can be removed. | 500 | [
{
"input": "3\n1 1\n-1 -1\n2 -1",
"output": "Yes"
},
{
"input": "4\n1 1\n2 2\n-1 1\n-2 2",
"output": "No"
},
{
"input": "3\n1 2\n2 1\n4 60",
"output": "Yes"
},
{
"input": "10\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6\n7 7\n8 8\n9 9\n-1 -1",
"output": "Yes"
},
{
"input": "2\n1... | 1,570,448,122 | 2,147,483,647 | Python 3 | OK | TESTS | 71 | 327 | 0 | n=int(input())
r=0
l=0
for _ in range(n):
x,y=map(int,input().split())
if (x>0 and y>=0) or (x>0 and y<=0):
r=r+1
else:
l=l+1
if min(r,l)>1:
print("No")
else:
print("Yes") | Title: Find Extra One
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You have *n* distinct points on a plane, none of them lie on *OY* axis. Check that there is a point after removal of which the remaining points are located on one side of the *OY* axis.
Input Specification:
The first li... | ```python
n=int(input())
r=0
l=0
for _ in range(n):
x,y=map(int,input().split())
if (x>0 and y>=0) or (x>0 and y<=0):
r=r+1
else:
l=l+1
if min(r,l)>1:
print("No")
else:
print("Yes")
``` | 3 | |
41 | A | Translation | PROGRAMMING | 800 | [
"implementation",
"strings"
] | A. Translation | 2 | 256 | The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc.... | The first line contains word *s*, the second line contains word *t*. The words consist of lowercase Latin letters. The input data do not consist unnecessary spaces. The words are not empty and their lengths do not exceed 100 symbols. | If the word *t* is a word *s*, written reversely, print YES, otherwise print NO. | [
"code\nedoc\n",
"abb\naba\n",
"code\ncode\n"
] | [
"YES\n",
"NO\n",
"NO\n"
] | none | 500 | [
{
"input": "code\nedoc",
"output": "YES"
},
{
"input": "abb\naba",
"output": "NO"
},
{
"input": "code\ncode",
"output": "NO"
},
{
"input": "abacaba\nabacaba",
"output": "YES"
},
{
"input": "q\nq",
"output": "YES"
},
{
"input": "asrgdfngfnmfgnhweratgjkk... | 1,674,507,327 | 2,147,483,647 | Python 3 | OK | TESTS | 40 | 92 | 0 | n=input()
m=input()
sum=""
for i in range(-1,-len(n),-1):
sum+=n[i]
sum+=n[-len(n)]
if(sum==m):
print("YES")
elif(sum!=m):
print("NO")
| Title: Translation
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pron... | ```python
n=input()
m=input()
sum=""
for i in range(-1,-len(n),-1):
sum+=n[i]
sum+=n[-len(n)]
if(sum==m):
print("YES")
elif(sum!=m):
print("NO")
``` | 3.977 |
237 | A | Free Cash | PROGRAMMING | 1,000 | [
"implementation"
] | null | null | Valera runs a 24/7 fast food cafe. He magically learned that next day *n* people will visit his cafe. For each person we know the arrival time: the *i*-th person comes exactly at *h**i* hours *m**i* minutes. The cafe spends less than a minute to serve each client, but if a client comes in and sees that there is no free... | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105), that is the number of cafe visitors.
Each of the following *n* lines has two space-separated integers *h**i* and *m**i* (0<=≤<=*h**i*<=≤<=23; 0<=≤<=*m**i*<=≤<=59), representing the time when the *i*-th person comes into the cafe.
Note that the time is... | Print a single integer — the minimum number of cashes, needed to serve all clients next day. | [
"4\n8 0\n8 10\n8 10\n8 45\n",
"3\n0 12\n10 11\n22 22\n"
] | [
"2\n",
"1\n"
] | In the first sample it is not enough one cash to serve all clients, because two visitors will come into cafe in 8:10. Therefore, if there will be one cash in cafe, then one customer will be served by it, and another one will not wait and will go away.
In the second sample all visitors will come in different times, so ... | 500 | [
{
"input": "4\n8 0\n8 10\n8 10\n8 45",
"output": "2"
},
{
"input": "3\n0 12\n10 11\n22 22",
"output": "1"
},
{
"input": "5\n12 8\n15 27\n15 27\n16 2\n19 52",
"output": "2"
},
{
"input": "7\n5 6\n7 34\n7 34\n7 34\n12 29\n15 19\n20 23",
"output": "3"
},
{
"input": "... | 1,658,726,421 | 2,147,483,647 | PyPy 3 | TIME_LIMIT_EXCEEDED | TESTS | 9 | 2,000 | 9,420,800 | def _input(): return map(int, input().split())
lst = []
for _ in range(int(input())):
a, b = _input()
lst.append((a,b))
res = 0; b = set(lst)
for i in b:
res = max(res, lst.count(i))
print(res) | Title: Free Cash
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Valera runs a 24/7 fast food cafe. He magically learned that next day *n* people will visit his cafe. For each person we know the arrival time: the *i*-th person comes exactly at *h**i* hours *m**i* minutes. The cafe spends l... | ```python
def _input(): return map(int, input().split())
lst = []
for _ in range(int(input())):
a, b = _input()
lst.append((a,b))
res = 0; b = set(lst)
for i in b:
res = max(res, lst.count(i))
print(res)
``` | 0 | |
34 | A | Reconnaissance 2 | PROGRAMMING | 800 | [
"implementation"
] | A. Reconnaissance 2 | 2 | 256 | *n* soldiers stand in a circle. For each soldier his height *a**i* is known. A reconnaissance unit can be made of such two neighbouring soldiers, whose heights difference is minimal, i.e. |*a**i*<=-<=*a**j*| is minimal. So each of them will be less noticeable with the other. Output any pair of soldiers that can form a ... | The first line contains integer *n* (2<=≤<=*n*<=≤<=100) — amount of soldiers. Then follow the heights of the soldiers in their order in the circle — *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000). The soldier heights are given in clockwise or counterclockwise direction. | Output two integers — indexes of neighbouring soldiers, who should form a reconnaissance unit. If there are many optimum solutions, output any of them. Remember, that the soldiers stand in a circle. | [
"5\n10 12 13 15 10\n",
"4\n10 20 30 40\n"
] | [
"5 1\n",
"1 2\n"
] | none | 500 | [
{
"input": "5\n10 12 13 15 10",
"output": "5 1"
},
{
"input": "4\n10 20 30 40",
"output": "1 2"
},
{
"input": "6\n744 359 230 586 944 442",
"output": "2 3"
},
{
"input": "5\n826 747 849 687 437",
"output": "1 2"
},
{
"input": "5\n999 999 993 969 999",
"output"... | 1,607,667,322 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 0 | 154 | 307,200 | n=int(input())
lst=map(int,input().split())
min=99999
for i in range(0,n-1):
if abs(lst[i]-lst[i+1]<min):
min=abs(lst[i]-lst[i+1])
id1=i+1
id2=i+2
if(abs(lst[-1]-lst[0])<min):
min=abs(lst[-1]-lst[0])
id1=n
id2=1
print(id1,end=" ")
print(id2) | Title: Reconnaissance 2
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
*n* soldiers stand in a circle. For each soldier his height *a**i* is known. A reconnaissance unit can be made of such two neighbouring soldiers, whose heights difference is minimal, i.e. |*a**i*<=-<=*a**j*| is minimal. So... | ```python
n=int(input())
lst=map(int,input().split())
min=99999
for i in range(0,n-1):
if abs(lst[i]-lst[i+1]<min):
min=abs(lst[i]-lst[i+1])
id1=i+1
id2=i+2
if(abs(lst[-1]-lst[0])<min):
min=abs(lst[-1]-lst[0])
id1=n
id2=1
print(id1,end=" ")
print(id2)
``` | -1 |
69 | A | Young Physicist | PROGRAMMING | 1,000 | [
"implementation",
"math"
] | A. Young Physicist | 2 | 256 | A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasy... | The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100), then follow *n* lines containing three integers each: the *x**i* coordinate, the *y**i* coordinate and the *z**i* coordinate of the force vector, applied to the body (<=-<=100<=≤<=*x**i*,<=*y**i*,<=*z**i*<=≤<=100). | Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not. | [
"3\n4 1 7\n-2 4 -1\n1 -5 -3\n",
"3\n3 -1 7\n-5 2 -4\n2 -1 -3\n"
] | [
"NO",
"YES"
] | none | 500 | [
{
"input": "3\n4 1 7\n-2 4 -1\n1 -5 -3",
"output": "NO"
},
{
"input": "3\n3 -1 7\n-5 2 -4\n2 -1 -3",
"output": "YES"
},
{
"input": "10\n21 32 -46\n43 -35 21\n42 2 -50\n22 40 20\n-27 -9 38\n-4 1 1\n-40 6 -31\n-13 -2 34\n-21 34 -12\n-32 -29 41",
"output": "NO"
},
{
"input": "10... | 1,615,559,191 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 80 | 186 | 0 | #!/usr/bin/env python
# coding: utf-8
# In[2]:
n = int(input())
summ=0
for i in range(0,n):
A = map(int, input().split())
summ+=sum(A)
if summ==0:
print('YES')
else:
print('NO')
# In[ ]:
| Title: Young Physicist
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. S... | ```python
#!/usr/bin/env python
# coding: utf-8
# In[2]:
n = int(input())
summ=0
for i in range(0,n):
A = map(int, input().split())
summ+=sum(A)
if summ==0:
print('YES')
else:
print('NO')
# In[ ]:
``` | 0 |
52 | C | Circular RMQ | PROGRAMMING | 2,200 | [
"data structures"
] | C. Circular RMQ | 1 | 256 | You are given circular array *a*0,<=*a*1,<=...,<=*a**n*<=-<=1. There are two types of operations with it:
- *inc*(*lf*,<=*rg*,<=*v*) — this operation increases each element on the segment [*lf*,<=*rg*] (inclusively) by *v*; - *rmq*(*lf*,<=*rg*) — this operation returns minimal value on the segment [*lf*,<=*rg*] (in... | The first line contains integer *n* (1<=≤<=*n*<=≤<=200000). The next line contains initial state of the array: *a*0,<=*a*1,<=...,<=*a**n*<=-<=1 (<=-<=106<=≤<=*a**i*<=≤<=106), *a**i* are integer. The third line contains integer *m* (0<=≤<=*m*<=≤<=200000), *m* — the number of operartons. Next *m* lines contain one operat... | For each *rmq* operation write result for it. Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d). | [
"4\n1 2 3 4\n4\n3 0\n3 0 -1\n0 1\n2 1\n"
] | [
"1\n0\n0\n"
] | none | 1,500 | [
{
"input": "4\n1 2 3 4\n4\n3 0\n3 0 -1\n0 1\n2 1",
"output": "1\n0\n0"
},
{
"input": "1\n-1\n10\n0 0 -1\n0 0\n0 0 1\n0 0\n0 0 1\n0 0\n0 0 0\n0 0\n0 0 -1\n0 0 1",
"output": "-2\n-1\n0\n0"
},
{
"input": "2\n-1 -1\n10\n0 0\n0 0\n0 0 1\n0 0\n1 1\n0 0 -1\n0 0 0\n0 0 1\n1 1 0\n0 0 -1",
"ou... | 1,591,197,418 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 0 | 124 | 0 | import sys
from math import inf, log2
class LazySegmentTree:
def __init__(self, array, func=min):
self.n = len(array)
self.size = 2**(int(log2(self.n-1))+1) if n != 1 else 1
self.func = func
self.default = 0 if self.func != min else inf
self.data = [self.default] *... | Title: Circular RMQ
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
You are given circular array *a*0,<=*a*1,<=...,<=*a**n*<=-<=1. There are two types of operations with it:
- *inc*(*lf*,<=*rg*,<=*v*) — this operation increases each element on the segment [*lf*,<=*rg*] (inclusively) by *v*;... | ```python
import sys
from math import inf, log2
class LazySegmentTree:
def __init__(self, array, func=min):
self.n = len(array)
self.size = 2**(int(log2(self.n-1))+1) if n != 1 else 1
self.func = func
self.default = 0 if self.func != min else inf
self.data = [self.... | 0 |
612 | E | Square Root of Permutation | PROGRAMMING | 2,200 | [
"combinatorics",
"constructive algorithms",
"dfs and similar",
"graphs",
"math"
] | null | null | A permutation of length *n* is an array containing each integer from 1 to *n* exactly once. For example, *q*<==<=[4,<=5,<=1,<=2,<=3] is a permutation. For the permutation *q* the square of permutation is the permutation *p* that *p*[*i*]<==<=*q*[*q*[*i*]] for each *i*<==<=1... *n*. For example, the square of *q*<==<=[4... | The first line contains integer *n* (1<=≤<=*n*<=≤<=106) — the number of elements in permutation *p*.
The second line contains *n* distinct integers *p*1,<=*p*2,<=...,<=*p**n* (1<=≤<=*p**i*<=≤<=*n*) — the elements of permutation *p*. | If there is no permutation *q* such that *q*2<==<=*p* print the number "-1".
If the answer exists print it. The only line should contain *n* different integers *q**i* (1<=≤<=*q**i*<=≤<=*n*) — the elements of the permutation *q*. If there are several solutions print any of them. | [
"4\n2 1 4 3\n",
"4\n2 1 3 4\n",
"5\n2 3 4 5 1\n"
] | [
"3 4 2 1\n",
"-1\n",
"4 5 1 2 3\n"
] | none | 0 | [
{
"input": "4\n2 1 4 3",
"output": "3 4 2 1"
},
{
"input": "4\n2 1 3 4",
"output": "-1"
},
{
"input": "5\n2 3 4 5 1",
"output": "4 5 1 2 3"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "10\n8 2 10 3 4 6 1 7 9 5"... | 1,502,994,086 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 62 | 204,800 |
n = int(input())
c = input()
c = c.split(" ")
c = [int(p) - 1 for p in c]
visited = [0 for p in range(0,n,1)]
cycle_st = []
for i in range(0,n,1):
if visited[i] != 1:
cycle = []
cycle.append([i,c[i]])
visited[i] = 1
d = c[i]
while visited[d] != 1:
c... | Title: Square Root of Permutation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A permutation of length *n* is an array containing each integer from 1 to *n* exactly once. For example, *q*<==<=[4,<=5,<=1,<=2,<=3] is a permutation. For the permutation *q* the square of permutation is the ... | ```python
n = int(input())
c = input()
c = c.split(" ")
c = [int(p) - 1 for p in c]
visited = [0 for p in range(0,n,1)]
cycle_st = []
for i in range(0,n,1):
if visited[i] != 1:
cycle = []
cycle.append([i,c[i]])
visited[i] = 1
d = c[i]
while visited[d] != 1:
... | 0 | |
591 | A | Wizards' Duel | PROGRAMMING | 900 | [
"implementation",
"math"
] | null | null | Harry Potter and He-Who-Must-Not-Be-Named engaged in a fight to the death once again. This time they are located at opposite ends of the corridor of length *l*. Two opponents simultaneously charge a deadly spell in the enemy. We know that the impulse of Harry's magic spell flies at a speed of *p* meters per second, and... | The first line of the input contains a single integer *l* (1<=≤<=*l*<=≤<=1<=000) — the length of the corridor where the fight takes place.
The second line contains integer *p*, the third line contains integer *q* (1<=≤<=*p*,<=*q*<=≤<=500) — the speeds of magical impulses for Harry Potter and He-Who-Must-Not-Be-Named, ... | Print a single real number — the distance from the end of the corridor, where Harry is located, to the place of the second meeting of the spell impulses. Your answer will be considered correct if its absolute or relative error will not exceed 10<=-<=4.
Namely: let's assume that your answer equals *a*, and the answer ... | [
"100\n50\n50\n",
"199\n60\n40\n"
] | [
"50\n",
"119.4\n"
] | In the first sample the speeds of the impulses are equal, so both of their meetings occur exactly in the middle of the corridor. | 500 | [
{
"input": "100\n50\n50",
"output": "50"
},
{
"input": "199\n60\n40",
"output": "119.4"
},
{
"input": "1\n1\n1",
"output": "0.5"
},
{
"input": "1\n1\n500",
"output": "0.001996007984"
},
{
"input": "1\n500\n1",
"output": "0.998003992"
},
{
"input": "1\n... | 1,445,765,046 | 1,446 | Python 3 | OK | TESTS | 45 | 62 | 0 | l, p, q = map(int, [input(), input(), input()])
print(l * p / float(p + q)) | Title: Wizards' Duel
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Harry Potter and He-Who-Must-Not-Be-Named engaged in a fight to the death once again. This time they are located at opposite ends of the corridor of length *l*. Two opponents simultaneously charge a deadly spell in the en... | ```python
l, p, q = map(int, [input(), input(), input()])
print(l * p / float(p + q))
``` | 3 | |
834 | B | The Festive Evening | PROGRAMMING | 1,100 | [
"data structures",
"implementation"
] | null | null | It's the end of July – the time when a festive evening is held at Jelly Castle! Guests from all over the kingdom gather here to discuss new trends in the world of confectionery. Yet some of the things discussed here are not supposed to be disclosed to the general public: the information can cause discord in the kingdom... | Two integers are given in the first string: the number of guests *n* and the number of guards *k* (1<=≤<=*n*<=≤<=106, 1<=≤<=*k*<=≤<=26).
In the second string, *n* uppercase English letters *s*1*s*2... *s**n* are given, where *s**i* is the entrance used by the *i*-th guest. | Output «YES» if at least one door was unguarded during some time, and «NO» otherwise.
You can output each letter in arbitrary case (upper or lower). | [
"5 1\nAABBB\n",
"5 1\nABABB\n"
] | [
"NO\n",
"YES\n"
] | In the first sample case, the door A is opened right before the first guest's arrival and closed when the second guest enters the castle. The door B is opened right before the arrival of the third guest, and closed after the fifth one arrives. One guard can handle both doors, as the first one is closed before the secon... | 1,000 | [
{
"input": "5 1\nAABBB",
"output": "NO"
},
{
"input": "5 1\nABABB",
"output": "YES"
},
{
"input": "26 1\nABCDEFGHIJKLMNOPQRSTUVWXYZ",
"output": "NO"
},
{
"input": "27 1\nABCDEFGHIJKLMNOPQRSTUVWXYZA",
"output": "YES"
},
{
"input": "5 2\nABACA",
"output": "NO"
... | 1,501,427,069 | 1,769 | Python 3 | TIME_LIMIT_EXCEEDED | PRETESTS | 5 | 1,000 | 7,884,800 | n, k = map(int, input().strip().split(" "))
s = input().strip()
sum_hash = [0 for _ in range(26)]
cur_hash = [0 for _ in range(26)]
for c in s:
sum_hash[ord(c) - ord('A')] += 1
printyes = False
guard_need = 0
for c in s:
if cur_hash[ord(c) - ord('A')] == 0:
guard_need += 1
if guard_... | Title: The Festive Evening
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
It's the end of July – the time when a festive evening is held at Jelly Castle! Guests from all over the kingdom gather here to discuss new trends in the world of confectionery. Yet some of the things discussed here... | ```python
n, k = map(int, input().strip().split(" "))
s = input().strip()
sum_hash = [0 for _ in range(26)]
cur_hash = [0 for _ in range(26)]
for c in s:
sum_hash[ord(c) - ord('A')] += 1
printyes = False
guard_need = 0
for c in s:
if cur_hash[ord(c) - ord('A')] == 0:
guard_need += 1
... | 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,638,719,445 | 2,147,483,647 | Python 3 | OK | TESTS | 37 | 46 | 0 | #This was submitted to codeforces.com
n,k=map(int,input().split())
good=0
s=list(range(0,k+1))
for i in range(n):
lst=list(map(int,input()))
nums=[]
tem=list(sorted(list(set(lst)))) #Removing repeating occurences, and sorting
if k!=0:
nums=tem[0:len(s)]
else:
if s[0] in ls... | 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
#This was submitted to codeforces.com
n,k=map(int,input().split())
good=0
s=list(range(0,k+1))
for i in range(n):
lst=list(map(int,input()))
nums=[]
tem=list(sorted(list(set(lst)))) #Removing repeating occurences, and sorting
if k!=0:
nums=tem[0:len(s)]
else:
if ... | 3 | |
653 | A | Bear and Three Balls | PROGRAMMING | 900 | [
"brute force",
"implementation",
"sortings"
] | null | null | Limak is a little polar bear. He has *n* balls, the *i*-th ball has size *t**i*.
Limak wants to give one ball to each of his three friends. Giving gifts isn't easy — there are two rules Limak must obey to make friends happy:
- No two friends can get balls of the same size. - No two friends can get balls of sizes th... | The first line of the input contains one integer *n* (3<=≤<=*n*<=≤<=50) — the number of balls Limak has.
The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=1000) where *t**i* denotes the size of the *i*-th ball. | Print "YES" (without quotes) if Limak can choose three balls of distinct sizes, such that any two of them differ by no more than 2. Otherwise, print "NO" (without quotes). | [
"4\n18 55 16 17\n",
"6\n40 41 43 44 44 44\n",
"8\n5 972 3 4 1 4 970 971\n"
] | [
"YES\n",
"NO\n",
"YES\n"
] | In the first sample, there are 4 balls and Limak is able to choose three of them to satisfy the rules. He must must choose balls with sizes 18, 16 and 17.
In the second sample, there is no way to give gifts to three friends without breaking the rules.
In the third sample, there is even more than one way to choose bal... | 500 | [
{
"input": "4\n18 55 16 17",
"output": "YES"
},
{
"input": "6\n40 41 43 44 44 44",
"output": "NO"
},
{
"input": "8\n5 972 3 4 1 4 970 971",
"output": "YES"
},
{
"input": "3\n959 747 656",
"output": "NO"
},
{
"input": "4\n1 2 2 3",
"output": "YES"
},
{
... | 1,459,282,600 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 4 | 61 | 4,608,000 | a = input("")
b = map(int, input("").split(" "))
b = sorted(b)
ans = "NO"
for i in range(len(b)-2):
if(b[i+2]-b[i]<=2 and b[i+1]!=b[i] and b[i+2]!=b[i] and b[i+2]!=b[i+1]):
ans = "YES"
print(ans)
| Title: Bear and Three Balls
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Limak is a little polar bear. He has *n* balls, the *i*-th ball has size *t**i*.
Limak wants to give one ball to each of his three friends. Giving gifts isn't easy — there are two rules Limak must obey to make fri... | ```python
a = input("")
b = map(int, input("").split(" "))
b = sorted(b)
ans = "NO"
for i in range(len(b)-2):
if(b[i+2]-b[i]<=2 and b[i+1]!=b[i] and b[i+2]!=b[i] and b[i+2]!=b[i+1]):
ans = "YES"
print(ans)
``` | 0 | |
978 | E | Bus Video System | PROGRAMMING | 1,400 | [
"combinatorics",
"math"
] | null | null | The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If $x$ is the number of passengers in a bus just before the current bus stop and $y$ is the number of passengers in the bus just after current bus stop, th... | The first line contains two integers $n$ and $w$ $(1 \le n \le 1\,000, 1 \le w \le 10^{9})$ — the number of bus stops and the capacity of the bus.
The second line contains a sequence $a_1, a_2, \dots, a_n$ $(-10^{6} \le a_i \le 10^{6})$, where $a_i$ equals to the number, which has been recorded by the video system aft... | Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to $w$. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0. | [
"3 5\n2 1 -3\n",
"2 4\n-1 1\n",
"4 10\n2 4 1 2\n"
] | [
"3\n",
"4\n",
"2\n"
] | In the first example initially in the bus could be $0$, $1$ or $2$ passengers.
In the second example initially in the bus could be $1$, $2$, $3$ or $4$ passengers.
In the third example initially in the bus could be $0$ or $1$ passenger. | 0 | [
{
"input": "3 5\n2 1 -3",
"output": "3"
},
{
"input": "2 4\n-1 1",
"output": "4"
},
{
"input": "4 10\n2 4 1 2",
"output": "2"
},
{
"input": "2 10\n-1 2",
"output": "9"
},
{
"input": "3 4\n-3 -4 4",
"output": "0"
},
{
"input": "10 1\n-1 -1 3 -4 2 3 0 -3... | 1,691,952,405 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 4 | 61 | 0 | n,w=map(int,input().split())
a=list(map(int,input().split()))
l,r=0,w
for i in a[::-1]:
if i>0:
r-=i
if l>0:
l-=i
else:
l-=i
if r<w:
r-=i
#01234
#0123
#1234
#print(l,r)
print(abs(r-l)+1) | Title: Bus Video System
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If $x$ is the number of passengers in a bus just befo... | ```python
n,w=map(int,input().split())
a=list(map(int,input().split()))
l,r=0,w
for i in a[::-1]:
if i>0:
r-=i
if l>0:
l-=i
else:
l-=i
if r<w:
r-=i
#01234
#0123
#1234
#print(l,r)
print(abs(r-l)+1)
``` | 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,595,479,663 | 2,147,483,647 | Python 3 | OK | TESTS | 34 | 109 | 6,656,000 | n=int(input())
a=input()
sfs=0;
ssf=0;i=0;
while(i<n-1):
if(a[i]=='F' and a[i+1]=='S'):
sfs+=1;
elif(a[i]=='S' and a[i+1]=='F'):
ssf+=1;
i+=1;
if(ssf>sfs):
print("YES");
else:
print("NO") | Title: Between the Offices
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
As you may know, MemSQL has American offices in both San Francisco and Seattle. Being a manager in the company, you travel a lot between the two cities, always by plane.
You prefer flying from Seattle to San Franci... | ```python
n=int(input())
a=input()
sfs=0;
ssf=0;i=0;
while(i<n-1):
if(a[i]=='F' and a[i+1]=='S'):
sfs+=1;
elif(a[i]=='S' and a[i+1]=='F'):
ssf+=1;
i+=1;
if(ssf>sfs):
print("YES");
else:
print("NO")
``` | 3 | |
598 | B | Queries on a String | PROGRAMMING | 1,300 | [
"implementation",
"strings"
] | null | null | You are given a string *s* and should process *m* queries. Each query is described by two 1-based indices *l**i*, *r**i* and integer *k**i*. It means that you should cyclically shift the substring *s*[*l**i*... *r**i*] *k**i* times. The queries should be processed one after another in the order they are given.
One ope... | The first line of the input contains the string *s* (1<=≤<=|*s*|<=≤<=10<=000) in its initial state, where |*s*| stands for the length of *s*. It contains only lowercase English letters.
Second line contains a single integer *m* (1<=≤<=*m*<=≤<=300) — the number of queries.
The *i*-th of the next *m* lines contains thr... | Print the resulting string *s* after processing all *m* queries. | [
"abacaba\n2\n3 6 1\n1 4 2\n"
] | [
"baabcaa\n"
] | The sample is described in problem statement. | 0 | [
{
"input": "abacaba\n2\n3 6 1\n1 4 2",
"output": "baabcaa"
},
{
"input": "u\n1\n1 1 1",
"output": "u"
},
{
"input": "p\n5\n1 1 5\n1 1 9\n1 1 10\n1 1 10\n1 1 4",
"output": "p"
},
{
"input": "ssssssssss\n5\n5 7 9\n3 9 3\n2 7 1\n7 7 10\n1 9 6",
"output": "ssssssssss"
},
... | 1,620,658,200 | 2,147,483,647 | PyPy 3 | OK | TESTS | 24 | 327 | 36,659,200 | import sys
import bisect
from bisect import bisect_left as lb
input_=lambda: sys.stdin.readline().strip("\r\n")
from math import log
from math import gcd
from random import randint
sa=lambda :input_()
sb=lambda:int(input_())
sc=lambda:input_().split()
sd=lambda:list(map(int,input_().split()))
se=lambda:float... | Title: Queries on a String
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a string *s* and should process *m* queries. Each query is described by two 1-based indices *l**i*, *r**i* and integer *k**i*. It means that you should cyclically shift the substring *s*[*l**i*... *r**... | ```python
import sys
import bisect
from bisect import bisect_left as lb
input_=lambda: sys.stdin.readline().strip("\r\n")
from math import log
from math import gcd
from random import randint
sa=lambda :input_()
sb=lambda:int(input_())
sc=lambda:input_().split()
sd=lambda:list(map(int,input_().split()))
se=la... | 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,601,751,155 | 2,147,483,647 | Python 3 | OK | TESTS | 30 | 218 | 102,400 | s = input()
upper, lower = 0, 0
for i in s:
if i >= 'A' and i <= 'Z':
upper += 1
elif i >= 'a' and i <= 'z':
lower +=1
if upper > lower:
print(s.upper())
else:
print(s.lower())
| Title: Word
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it ei... | ```python
s = input()
upper, lower = 0, 0
for i in s:
if i >= 'A' and i <= 'Z':
upper += 1
elif i >= 'a' and i <= 'z':
lower +=1
if upper > lower:
print(s.upper())
else:
print(s.lower())
``` | 3.945309 |
156 | A | Message | PROGRAMMING | 1,700 | [
"brute force"
] | null | null | Dr. Moriarty is about to send a message to Sherlock Holmes. He has a string *s*.
String *p* is called a substring of string *s* if you can read it starting from some position in the string *s*. For example, string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
Dr. Moriarty plans to take string *s* and c... | The first line contains a non-empty string *s*, consisting of lowercase Latin letters. The second line contains a non-empty string *u*, consisting of lowercase Latin letters. The lengths of both strings are in the range from 1 to 2000, inclusive. | Print the only integer — the minimum number of changes that Dr. Moriarty has to make with the string that you choose. | [
"aaaaa\naaa\n",
"abcabc\nbcd\n",
"abcdef\nklmnopq\n"
] | [
"0\n",
"1\n",
"7\n"
] | In the first sample Moriarty can take any substring of length 3, and it will be equal to the required message *u*, so Moriarty won't have to make any changes.
In the second sample you should take a substring consisting of characters from second to fourth ("bca") or from fifth to sixth ("bc"). Then you will only have t... | 500 | [
{
"input": "aaaaa\naaa",
"output": "0"
},
{
"input": "abcabc\nbcd",
"output": "1"
},
{
"input": "abcdef\nklmnopq",
"output": "7"
},
{
"input": "aaabbbaaa\naba",
"output": "1"
},
{
"input": "a\na",
"output": "0"
},
{
"input": "z\nz",
"output": "0"
... | 1,422,703,930 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 4 | 2,000 | 0 | # 156A
from sys import stdin
__author__ = 'artyom'
def read_line():
return stdin.readline().strip()
s = read_line()
u = read_line()
len_s = len(s)
len_u = len(u)
mn = 10000
for i in range(-len_u + 1, len_s):
count = max(0, len_u - len_s + i) + (-i if i < 0 else 0)
start = max(0, i)
fini... | Title: Message
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Dr. Moriarty is about to send a message to Sherlock Holmes. He has a string *s*.
String *p* is called a substring of string *s* if you can read it starting from some position in the string *s*. For example, string "aba" has s... | ```python
# 156A
from sys import stdin
__author__ = 'artyom'
def read_line():
return stdin.readline().strip()
s = read_line()
u = read_line()
len_s = len(s)
len_u = len(u)
mn = 10000
for i in range(-len_u + 1, len_s):
count = max(0, len_u - len_s + i) + (-i if i < 0 else 0)
start = max(0, ... | 0 | |
680 | B | Bear and Finding Criminals | PROGRAMMING | 1,000 | [
"constructive algorithms",
"implementation"
] | null | null | There are *n* cities in Bearland, numbered 1 through *n*. Cities are arranged in one long row. The distance between cities *i* and *j* is equal to |*i*<=-<=*j*|.
Limak is a police officer. He lives in a city *a*. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he... | The first line of the input contains two integers *n* and *a* (1<=≤<=*a*<=≤<=*n*<=≤<=100) — the number of cities and the index of city where Limak lives.
The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (0<=≤<=*t**i*<=≤<=1). There are *t**i* criminals in the *i*-th city. | Print the number of criminals Limak will catch. | [
"6 3\n1 1 1 0 1 0\n",
"5 2\n0 0 0 1 0\n"
] | [
"3\n",
"1\n"
] | In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
Using the BCD gives Limak the following information:
- There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city. - There i... | 1,000 | [
{
"input": "6 3\n1 1 1 0 1 0",
"output": "3"
},
{
"input": "5 2\n0 0 0 1 0",
"output": "1"
},
{
"input": "1 1\n1",
"output": "1"
},
{
"input": "1 1\n0",
"output": "0"
},
{
"input": "9 3\n1 1 1 1 1 1 1 1 0",
"output": "8"
},
{
"input": "9 5\n1 0 1 0 1 0... | 1,686,605,902 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 6 | 62 | 0 | a, n = list(map(int, input().split()))
def valid(x):
if (x < 0 or x >= a):
return False
return True
criminals = list(map(int, input().split()))
left_idx = n-1
right_idx = n-1
criminals_caught = 0
while(left_idx > 0 or right_idx <a):
if (valid(left_idx) and valid(right_idx)):
if (criminals[... | Title: Bear and Finding Criminals
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There are *n* cities in Bearland, numbered 1 through *n*. Cities are arranged in one long row. The distance between cities *i* and *j* is equal to |*i*<=-<=*j*|.
Limak is a police officer. He lives in a city... | ```python
a, n = list(map(int, input().split()))
def valid(x):
if (x < 0 or x >= a):
return False
return True
criminals = list(map(int, input().split()))
left_idx = n-1
right_idx = n-1
criminals_caught = 0
while(left_idx > 0 or right_idx <a):
if (valid(left_idx) and valid(right_idx)):
if (... | 0 | |
258 | A | Little Elephant and Bits | PROGRAMMING | 1,100 | [
"greedy",
"math"
] | null | null | The Little Elephant has an integer *a*, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number *a* fits on the piece of paper, the Little Elephant ought to delete exactly one any digit from number *a* in the binary record. At that a new number appears. It consis... | The single line contains integer *a*, written in the binary notation without leading zeroes. This number contains more than 1 and at most 105 digits. | In the single line print the number that is written without leading zeroes in the binary notation — the answer to the problem. | [
"101\n",
"110010\n"
] | [
"11\n",
"11010\n"
] | In the first sample the best strategy is to delete the second digit. That results in number 11<sub class="lower-index">2</sub> = 3<sub class="lower-index">10</sub>.
In the second sample the best strategy is to delete the third or fourth digits — that results in number 11010<sub class="lower-index">2</sub> = 26<sub cla... | 500 | [
{
"input": "101",
"output": "11"
},
{
"input": "110010",
"output": "11010"
},
{
"input": "10000",
"output": "1000"
},
{
"input": "1111111110",
"output": "111111111"
},
{
"input": "10100101011110101",
"output": "1100101011110101"
},
{
"input": "11101001... | 1,567,328,350 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 9 | 218 | 0 | t = input()
if t.count("1") == len(t):
print(t[:len(t)-1])
n = t.index("0")
print(t[:n]+t[n+1:]) | Title: Little Elephant and Bits
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Little Elephant has an integer *a*, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number *a* fits on the piece of paper, the Little Elephant ought... | ```python
t = input()
if t.count("1") == len(t):
print(t[:len(t)-1])
n = t.index("0")
print(t[:n]+t[n+1:])
``` | -1 | |
31 | D | Chocolate | PROGRAMMING | 2,000 | [
"dfs and similar",
"implementation"
] | D. Chocolate | 2 | 256 | Bob has a rectangular chocolate bar of the size *W*<=×<=*H*. He introduced a cartesian coordinate system so that the point (0,<=0) corresponds to the lower-left corner of the bar, and the point (*W*,<=*H*) corresponds to the upper-right corner. Bob decided to split the bar into pieces by breaking it. Each break is a se... | The first line contains 3 integers *W*, *H* and *n* (1<=≤<=*W*,<=*H*,<=*n*<=≤<=100) — width of the bar, height of the bar and amount of breaks. Each of the following *n* lines contains four integers *x**i*,<=1,<=*y**i*,<=1,<=*x**i*,<=2,<=*y**i*,<=2 — coordinates of the endpoints of the *i*-th break (0<=≤<=*x**i*,<=1<=≤... | Output *n*<=+<=1 numbers — areas of the resulting parts in the increasing order. | [
"2 2 2\n1 0 1 2\n0 1 1 1\n",
"2 2 3\n1 0 1 2\n0 1 1 1\n1 1 2 1\n",
"2 4 2\n0 1 2 1\n0 3 2 3\n"
] | [
"1 1 2 ",
"1 1 1 1 ",
"2 2 4 "
] | none | 2,000 | [
{
"input": "2 2 2\n1 0 1 2\n0 1 1 1",
"output": "1 1 2 "
},
{
"input": "2 2 3\n1 0 1 2\n0 1 1 1\n1 1 2 1",
"output": "1 1 1 1 "
},
{
"input": "2 4 2\n0 1 2 1\n0 3 2 3",
"output": "2 2 4 "
},
{
"input": "5 5 3\n2 1 2 5\n0 1 5 1\n4 0 4 1",
"output": "1 4 8 12 "
},
{
... | 1,674,897,784 | 2,147,483,647 | Python 3 | RUNTIME_ERROR | TESTS | 3 | 92 | 0 | w,h,n=map(int,input().split())
N=5
x=[[0]*N for _ in range(N)]
y=[[0]*N for _ in range(N)]
x[h][0],y[0][w],p=2,2,[]
for a,b,c,d in [[*map(int,input().split())] for i in range(n)]:
m,n=sorted([(a,b),(c,d)])
x[m[1]][m[0]]=1
y[m[1]][m[0]]=1
if m[0]==n[0]:
x[n[1]][n[0]]=2
if m[1]==n[1]:
... | Title: Chocolate
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Bob has a rectangular chocolate bar of the size *W*<=×<=*H*. He introduced a cartesian coordinate system so that the point (0,<=0) corresponds to the lower-left corner of the bar, and the point (*W*,<=*H*) corresponds to the uppe... | ```python
w,h,n=map(int,input().split())
N=5
x=[[0]*N for _ in range(N)]
y=[[0]*N for _ in range(N)]
x[h][0],y[0][w],p=2,2,[]
for a,b,c,d in [[*map(int,input().split())] for i in range(n)]:
m,n=sorted([(a,b),(c,d)])
x[m[1]][m[0]]=1
y[m[1]][m[0]]=1
if m[0]==n[0]:
x[n[1]][n[0]]=2
if m[1]==n[1]... | -1 |
920 | E | Connected Components? | PROGRAMMING | 2,100 | [
"data structures",
"dfs and similar",
"dsu",
"graphs"
] | null | null | You are given an undirected graph consisting of *n* vertices and edges. Instead of giving you the edges that exist in the graph, we give you *m* unordered pairs (*x*,<=*y*) such that there is no edge between *x* and *y*, and if some pair of vertices is not listed in the input, then there is an edge between these verti... | The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=200000, ).
Then *m* lines follow, each containing a pair of integers *x* and *y* (1<=≤<=*x*,<=*y*<=≤<=*n*, *x*<=≠<=*y*) denoting that there is no edge between *x* and *y*. Each pair is listed at most once; (*x*,<=*y*) and (*y*,<=*x*) are considered the sa... | Firstly print *k* — the number of connected components in this graph.
Then print *k* integers — the sizes of components. You should output these integers in non-descending order. | [
"5 5\n1 2\n3 4\n3 2\n4 2\n2 5\n"
] | [
"2\n1 4 "
] | none | 0 | [
{
"input": "5 5\n1 2\n3 4\n3 2\n4 2\n2 5",
"output": "2\n1 4 "
},
{
"input": "8 15\n2 1\n4 5\n2 4\n3 4\n2 5\n3 5\n2 6\n3 6\n5 6\n4 6\n2 7\n3 8\n2 8\n3 7\n6 7",
"output": "1\n8 "
},
{
"input": "12 58\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 10\n1 11\n1 12\n2 3\n2 4\n2 5\n2 6\n2 7\n2 8\n2 9\n... | 1,599,096,373 | 2,147,483,647 | PyPy 3 | MEMORY_LIMIT_EXCEEDED | TESTS | 8 | 1,559 | 268,390,400 | class Node:
def __init__(self, val):
self.val = val
self.parent = self
self.size = 1
class UnionFind:
def __init__(self):
self.map = {}
def find(self, node):
if node.val not in self.map:
self.map[node.val] = node
elif node.parent != node:
node = self.find(node.parent)
return node
def union(se... | Title: Connected Components?
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given an undirected graph consisting of *n* vertices and edges. Instead of giving you the edges that exist in the graph, we give you *m* unordered pairs (*x*,<=*y*) such that there is no edge between *x* ... | ```python
class Node:
def __init__(self, val):
self.val = val
self.parent = self
self.size = 1
class UnionFind:
def __init__(self):
self.map = {}
def find(self, node):
if node.val not in self.map:
self.map[node.val] = node
elif node.parent != node:
node = self.find(node.parent)
return node
de... | 0 | |
208 | A | Dubstep | PROGRAMMING | 900 | [
"strings"
] | null | null | Vasya works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.
Let's assume that a song consists of some number of words. To make the dubstep remix of this song, Vasya inserts a certain nu... | The input consists of a single non-empty string, consisting only of uppercase English letters, the string's length doesn't exceed 200 characters. It is guaranteed that before Vasya remixed the song, no word contained substring "WUB" in it; Vasya didn't change the word order. It is also guaranteed that initially the son... | Print the words of the initial song that Vasya used to make a dubsteb remix. Separate the words with a space. | [
"WUBWUBABCWUB\n",
"WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB\n"
] | [
"ABC ",
"WE ARE THE CHAMPIONS MY FRIEND "
] | In the first sample: "WUBWUBABCWUB" = "WUB" + "WUB" + "ABC" + "WUB". That means that the song originally consisted of a single word "ABC", and all words "WUB" were added by Vasya.
In the second sample Vasya added a single word "WUB" between all neighbouring words, in the beginning and in the end, except for words "ARE... | 500 | [
{
"input": "WUBWUBABCWUB",
"output": "ABC "
},
{
"input": "WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB",
"output": "WE ARE THE CHAMPIONS MY FRIEND "
},
{
"input": "WUBWUBWUBSR",
"output": "SR "
},
{
"input": "RWUBWUBWUBLWUB",
"output": "R L "
},
{
"input": "... | 1,693,161,233 | 2,147,483,647 | Python 3 | OK | TESTS | 71 | 92 | 0 | remix = input()
# remix = "WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB"
remix_list = list(remix.split("WUB"))
org_list = []
# print(remix_list)
for i in remix_list:
# print(f"- step one: {i}")
if i != '':
org_list.append(i)
else:
pass
org = ' '.join(org_list)
print(org) | Title: Dubstep
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.
Let's assume that a song consist... | ```python
remix = input()
# remix = "WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB"
remix_list = list(remix.split("WUB"))
org_list = []
# print(remix_list)
for i in remix_list:
# print(f"- step one: {i}")
if i != '':
org_list.append(i)
else:
pass
org = ' '.join(org_list)
print(org)
``` | 3 | |
817 | B | Makes And The Product | PROGRAMMING | 1,500 | [
"combinatorics",
"implementation",
"math",
"sortings"
] | null | null | After returning from the army Makes received a gift — an array *a* consisting of *n* positive integer numbers. He hadn't been solving problems for a long time, so he became interested to answer a particular question: how many triples of indices (*i*,<= *j*,<= *k*) (*i*<=<<=*j*<=<<=*k*), such that *a**i*·*a**j*·*a... | The first line of input contains a positive integer number *n* (3<=≤<=*n*<=≤<=105) — the number of elements in array *a*. The second line contains *n* positive integer numbers *a**i* (1<=≤<=*a**i*<=≤<=109) — the elements of a given array. | Print one number — the quantity of triples (*i*,<= *j*,<= *k*) such that *i*,<= *j* and *k* are pairwise distinct and *a**i*·*a**j*·*a**k* is minimum possible. | [
"4\n1 1 1 1\n",
"5\n1 3 2 3 4\n",
"6\n1 3 3 1 3 2\n"
] | [
"4\n",
"2\n",
"1\n"
] | In the first example Makes always chooses three ones out of four, and the number of ways to choose them is 4.
In the second example a triple of numbers (1, 2, 3) is chosen (numbers, not indices). Since there are two ways to choose an element 3, then the answer is 2.
In the third example a triple of numbers (1, 1, 2) ... | 0 | [
{
"input": "4\n1 1 1 1",
"output": "4"
},
{
"input": "5\n1 3 2 3 4",
"output": "2"
},
{
"input": "6\n1 3 3 1 3 2",
"output": "1"
},
{
"input": "3\n1000000000 1000000000 1000000000",
"output": "1"
},
{
"input": "4\n1 1 2 2",
"output": "2"
},
{
"input": ... | 1,554,962,587 | 2,147,483,647 | PyPy 3 | OK | TESTS | 80 | 202 | 15,667,200 | from math import factorial
n=int(input())
a=[int(i) for i in input().split()]
a.sort()
c1 = c2 = c3 = 0
for i in range(n):
if a[i] == a[0]:
c1 += 1
if a[i] == a[1]:
c2 += 1
if a[i] == a[2]:
c3 += 1
if a[0] == a[1]:
if a[1] == a[2]:
print((c1*(c1-1)*(c1-2))//... | Title: Makes And The Product
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
After returning from the army Makes received a gift — an array *a* consisting of *n* positive integer numbers. He hadn't been solving problems for a long time, so he became interested to answer a particular questi... | ```python
from math import factorial
n=int(input())
a=[int(i) for i in input().split()]
a.sort()
c1 = c2 = c3 = 0
for i in range(n):
if a[i] == a[0]:
c1 += 1
if a[i] == a[1]:
c2 += 1
if a[i] == a[2]:
c3 += 1
if a[0] == a[1]:
if a[1] == a[2]:
print((c1*(c1-1)... | 3 | |
387 | A | George and Sleep | PROGRAMMING | 900 | [
"implementation"
] | null | null | George woke up and saw the current time *s* on the digital clock. Besides, George knows that he has slept for time *t*.
Help George! Write a program that will, given time *s* and *t*, determine the time *p* when George went to bed. Note that George could have gone to bed yesterday relatively to the current time (see ... | The first line contains current time *s* as a string in the format "hh:mm". The second line contains time *t* in the format "hh:mm" — the duration of George's sleep. It is guaranteed that the input contains the correct time in the 24-hour format, that is, 00<=≤<=*hh*<=≤<=23, 00<=≤<=*mm*<=≤<=59. | In the single line print time *p* — the time George went to bed in the format similar to the format of the time in the input. | [
"05:50\n05:44\n",
"00:00\n01:00\n",
"00:01\n00:00\n"
] | [
"00:06\n",
"23:00\n",
"00:01\n"
] | In the first sample George went to bed at "00:06". Note that you should print the time only in the format "00:06". That's why answers "0:06", "00:6" and others will be considered incorrect.
In the second sample, George went to bed yesterday.
In the third sample, George didn't do to bed at all. | 500 | [
{
"input": "05:50\n05:44",
"output": "00:06"
},
{
"input": "00:00\n01:00",
"output": "23:00"
},
{
"input": "00:01\n00:00",
"output": "00:01"
},
{
"input": "23:59\n23:59",
"output": "00:00"
},
{
"input": "23:44\n23:55",
"output": "23:49"
},
{
"input": "... | 1,546,694,832 | 2,147,483,647 | Python 3 | COMPILATION_ERROR | TESTS | 0 | 0 | 0 | #include<iostream>
#include<cstring>
using namespace std;
int main()
{
string a,b;
int h1=0,h2=0,m1=0,m2=0,a1,a2;
bool flag=false;
cin>>a>>b;
for(int i=0;i<a.size();i++)
if(flag==false&&a[i]!=':')
h1*=10,h1+=(a[i]-48);
else if(a[i]==':')
flag=true;
else
m1*=10,m1+=(a[i]-48);
flag=fa... | Title: George and Sleep
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
George woke up and saw the current time *s* on the digital clock. Besides, George knows that he has slept for time *t*.
Help George! Write a program that will, given time *s* and *t*, determine the time *p* when Geor... | ```python
#include<iostream>
#include<cstring>
using namespace std;
int main()
{
string a,b;
int h1=0,h2=0,m1=0,m2=0,a1,a2;
bool flag=false;
cin>>a>>b;
for(int i=0;i<a.size();i++)
if(flag==false&&a[i]!=':')
h1*=10,h1+=(a[i]-48);
else if(a[i]==':')
flag=true;
else
m1*=10,m1+=(a[i]-48);... | -1 | |
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,495,004 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 5 | 1,000 | 63,488,000 | from itertools import product,permutations,combinations
a,b,c=[int(s) for s in input().split()]
k=0
lists=[]
masa=[int(s) for s in input().split()]
masb=[int(s) for s in input().split()]
masc=[int(s) for s in input().split()]
comb1=list(combinations(masa,1))
comb2=list(combinations(masb,2))
comb3=list(combinat... | Title: Красивая команда
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Завтра у хоккейной команды, которой руководит Евгений, важный матч. Евгению нужно выбрать шесть игроков, которые выйдут на лед в стартовом составе: один вратарь, два защитника и три нападающих.
Так как это стартовый с... | ```python
from itertools import product,permutations,combinations
a,b,c=[int(s) for s in input().split()]
k=0
lists=[]
masa=[int(s) for s in input().split()]
masb=[int(s) for s in input().split()]
masc=[int(s) for s in input().split()]
comb1=list(combinations(masa,1))
comb2=list(combinations(masb,2))
comb3=lis... | 0 | |
984 | A | Game | PROGRAMMING | 800 | [
"sortings"
] | null | null | Two players play a game.
Initially there are $n$ integers $a_1, a_2, \ldots, a_n$ written on the board. Each turn a player selects one number and erases it from the board. This continues until there is only one number left on the board, i. e. $n - 1$ turns are made. The first player makes the first move, then players ... | The first line contains one integer $n$ ($1 \le n \le 1000$) — the number of numbers on the board.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^6$). | Print one number that will be left on the board. | [
"3\n2 1 3\n",
"3\n2 2 2\n"
] | [
"2",
"2"
] | In the first sample, the first player erases $3$ and the second erases $1$. $2$ is left on the board.
In the second sample, $2$ is left on the board regardless of the actions of the players. | 500 | [
{
"input": "3\n2 1 3",
"output": "2"
},
{
"input": "3\n2 2 2",
"output": "2"
},
{
"input": "9\n44 53 51 80 5 27 74 79 94",
"output": "53"
},
{
"input": "10\n38 82 23 37 96 4 81 60 67 86",
"output": "60"
},
{
"input": "10\n58 26 77 15 53 81 68 48 22 65",
"outpu... | 1,686,311,506 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 2 | 30 | 0 | import sys
n = sys.stdin.readline()
y = list(sys.stdin.readline().split())
y.remove(max(y))
y.remove(min(y))
print(*y) | Title: Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Two players play a game.
Initially there are $n$ integers $a_1, a_2, \ldots, a_n$ written on the board. Each turn a player selects one number and erases it from the board. This continues until there is only one number left on the... | ```python
import sys
n = sys.stdin.readline()
y = list(sys.stdin.readline().split())
y.remove(max(y))
y.remove(min(y))
print(*y)
``` | 0 | |
69 | A | Young Physicist | PROGRAMMING | 1,000 | [
"implementation",
"math"
] | A. Young Physicist | 2 | 256 | A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasy... | The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100), then follow *n* lines containing three integers each: the *x**i* coordinate, the *y**i* coordinate and the *z**i* coordinate of the force vector, applied to the body (<=-<=100<=≤<=*x**i*,<=*y**i*,<=*z**i*<=≤<=100). | Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not. | [
"3\n4 1 7\n-2 4 -1\n1 -5 -3\n",
"3\n3 -1 7\n-5 2 -4\n2 -1 -3\n"
] | [
"NO",
"YES"
] | none | 500 | [
{
"input": "3\n4 1 7\n-2 4 -1\n1 -5 -3",
"output": "NO"
},
{
"input": "3\n3 -1 7\n-5 2 -4\n2 -1 -3",
"output": "YES"
},
{
"input": "10\n21 32 -46\n43 -35 21\n42 2 -50\n22 40 20\n-27 -9 38\n-4 1 1\n-40 6 -31\n-13 -2 34\n-21 34 -12\n-32 -29 41",
"output": "NO"
},
{
"input": "10... | 1,549,295,023 | 2,147,483,647 | Python 3 | OK | TESTS | 81 | 218 | 0 | n = int(input())
t_x = 0
t_y = 0
t_z = 0
for i in range(0,n):
s = str(input())
l = s.split()
t_x = t_x + int(l[0])
t_y = t_y + int(l[1])
t_z = t_z + int(l[2])
if t_x == 0 and t_y == 0 and t_z == 0 :
print("YES")
else:
print("NO") | Title: Young Physicist
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. S... | ```python
n = int(input())
t_x = 0
t_y = 0
t_z = 0
for i in range(0,n):
s = str(input())
l = s.split()
t_x = t_x + int(l[0])
t_y = t_y + int(l[1])
t_z = t_z + int(l[2])
if t_x == 0 and t_y == 0 and t_z == 0 :
print("YES")
else:
print("NO")
``` | 3.9455 |
913 | A | Modular Exponentiation | PROGRAMMING | 900 | [
"implementation",
"math"
] | null | null | The following problem is well-known: given integers *n* and *m*, calculate
where 2*n*<==<=2·2·...·2 (*n* factors), and denotes the remainder of division of *x* by *y*.
You are asked to solve the "reverse" problem. Given integers *n* and *m*, calculate | The first line contains a single integer *n* (1<=≤<=*n*<=≤<=108).
The second line contains a single integer *m* (1<=≤<=*m*<=≤<=108). | Output a single integer — the value of . | [
"4\n42\n",
"1\n58\n",
"98765432\n23456789\n"
] | [
"10\n",
"0\n",
"23456789\n"
] | In the first example, the remainder of division of 42 by 2<sup class="upper-index">4</sup> = 16 is equal to 10.
In the second example, 58 is divisible by 2<sup class="upper-index">1</sup> = 2 without remainder, and the answer is 0. | 500 | [
{
"input": "4\n42",
"output": "10"
},
{
"input": "1\n58",
"output": "0"
},
{
"input": "98765432\n23456789",
"output": "23456789"
},
{
"input": "8\n88127381",
"output": "149"
},
{
"input": "32\n92831989",
"output": "92831989"
},
{
"input": "92831989\n25... | 1,594,404,806 | 2,147,483,647 | PyPy 3 | TIME_LIMIT_EXCEEDED | TESTS | 2 | 1,000 | 22,425,600 | from sys import stdin
def binpow(a,b):
res = 1
while b > 0:
if b & 1:
res *= a
a *= a
b >>= 1
return res
n = int(stdin.readline())
m = int(stdin.readline())
print(m % binpow(2,n)) | Title: Modular Exponentiation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The following problem is well-known: given integers *n* and *m*, calculate
where 2*n*<==<=2·2·...·2 (*n* factors), and denotes the remainder of division of *x* by *y*.
You are asked to solve the "reverse" prob... | ```python
from sys import stdin
def binpow(a,b):
res = 1
while b > 0:
if b & 1:
res *= a
a *= a
b >>= 1
return res
n = int(stdin.readline())
m = int(stdin.readline())
print(m % binpow(2,n))
``` | 0 | |
476 | B | Dreamoon and WiFi | PROGRAMMING | 1,300 | [
"bitmasks",
"brute force",
"combinatorics",
"dp",
"math",
"probabilities"
] | null | null | Dreamoon is standing at the position 0 on a number line. Drazil is sending a list of commands through Wi-Fi to Dreamoon's smartphone and Dreamoon follows them.
Each command is one of the following two types:
1. Go 1 unit towards the positive direction, denoted as '+' 1. Go 1 unit towards the negative direction, de... | The first line contains a string *s*1 — the commands Drazil sends to Dreamoon, this string consists of only the characters in the set {'+', '-'}.
The second line contains a string *s*2 — the commands Dreamoon's smartphone recognizes, this string consists of only the characters in the set {'+', '-', '?'}. '?' denotes ... | Output a single real number corresponding to the probability. The answer will be considered correct if its relative or absolute error doesn't exceed 10<=-<=9. | [
"++-+-\n+-+-+\n",
"+-+-\n+-??\n",
"+++\n??-\n"
] | [
"1.000000000000\n",
"0.500000000000\n",
"0.000000000000\n"
] | For the first sample, both *s*<sub class="lower-index">1</sub> and *s*<sub class="lower-index">2</sub> will lead Dreamoon to finish at the same position + 1.
For the second sample, *s*<sub class="lower-index">1</sub> will lead Dreamoon to finish at position 0, while there are four possibilites for *s*<sub class="low... | 1,500 | [
{
"input": "++-+-\n+-+-+",
"output": "1.000000000000"
},
{
"input": "+-+-\n+-??",
"output": "0.500000000000"
},
{
"input": "+++\n??-",
"output": "0.000000000000"
},
{
"input": "++++++++++\n+++??++?++",
"output": "0.125000000000"
},
{
"input": "--+++---+-\n????????... | 1,656,087,788 | 2,147,483,647 | PyPy 3-64 | WRONG_ANSWER | TESTS | 3 | 46 | 0 | f = input()
s = input()
t = f.count('+') - f.count('-')
known = s.count('+') - s.count('-')
sp = s.count('?')
if sp == 0:
if known == t:
print(1.0)
else:
print(0.0)
exit(0)
diff = abs(t-known)
if diff - sp > 0:
print(0.0)
exit(0)
print(1/sp) | Title: Dreamoon and WiFi
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Dreamoon is standing at the position 0 on a number line. Drazil is sending a list of commands through Wi-Fi to Dreamoon's smartphone and Dreamoon follows them.
Each command is one of the following two types:
1. Go... | ```python
f = input()
s = input()
t = f.count('+') - f.count('-')
known = s.count('+') - s.count('-')
sp = s.count('?')
if sp == 0:
if known == t:
print(1.0)
else:
print(0.0)
exit(0)
diff = abs(t-known)
if diff - sp > 0:
print(0.0)
exit(0)
print(1/sp)
``` | 0 | |
1,010 | C | Border | PROGRAMMING | 1,800 | [
"number theory"
] | null | null | Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inhabitant of Earth, therefore she had to pay the tax to enter the territory of Mars.
There are... | The first line contains two integers $n$ and $k$ ($1 \le n \le 100\,000$, $2 \le k \le 100\,000$) — the number of denominations of banknotes and the base of the number system on Mars.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$) — denominations of banknotes on Mars.
All numbers... | On the first line output the number of values $d$ for which Natasha can make the Martians happy.
In the second line, output all these values in increasing order.
Print all numbers in decimal notation. | [
"2 8\n12 20\n",
"3 10\n10 20 30\n"
] | [
"2\n0 4 ",
"1\n0 "
] | Consider the first test case. It uses the octal number system.
If you take one banknote with the value of $12$, you will get $14_8$ in octal system. The last digit is $4_8$.
If you take one banknote with the value of $12$ and one banknote with the value of $20$, the total value will be $32$. In the octal system, it i... | 1,000 | [
{
"input": "2 8\n12 20",
"output": "2\n0 4 "
},
{
"input": "3 10\n10 20 30",
"output": "1\n0 "
},
{
"input": "5 10\n20 16 4 16 2",
"output": "5\n0 2 4 6 8 "
},
{
"input": "10 5\n4 6 8 6 4 10 2 10 8 6",
"output": "5\n0 1 2 3 4 "
},
{
"input": "20 25\n15 10 5 20 10 ... | 1,578,300,511 | 2,147,483,647 | PyPy 3 | OK | TESTS | 107 | 249 | 13,824,000 | n,k=map(int,input().split())
g=lambda x:int(x)%k
a=list(map(g,input().split()))
def nod(a,b):
while b>0:
a%=b
a,b=b,a
return a
c=k
for x in a:
if x!=0:
c=nod(c,x)
print(k//c)
print(' '.join(map(str,list(range(0,k,c)))))
| Title: Border
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Astronaut Natasha arrived on Mars. She knows that the Martians are very poor aliens. To ensure a better life for the Mars citizens, their emperor decided to take tax from every tourist who visited the planet. Natasha is the inha... | ```python
n,k=map(int,input().split())
g=lambda x:int(x)%k
a=list(map(g,input().split()))
def nod(a,b):
while b>0:
a%=b
a,b=b,a
return a
c=k
for x in a:
if x!=0:
c=nod(c,x)
print(k//c)
print(' '.join(map(str,list(range(0,k,c)))))
``` | 3 | |
32 | B | Borze | PROGRAMMING | 800 | [
"expression parsing",
"implementation"
] | B. Borze | 2 | 256 | Ternary numeric notation is quite popular in Berland. To telegraph the ternary number the Borze alphabet is used. Digit 0 is transmitted as «.», 1 as «-.» and 2 as «--». You are to decode the Borze code, i.e. to find out the ternary number given its representation in Borze alphabet. | The first line contains a number in Borze code. The length of the string is between 1 and 200 characters. It's guaranteed that the given string is a valid Borze code of some ternary number (this number can have leading zeroes). | Output the decoded ternary number. It can have leading zeroes. | [
".-.--\n",
"--.\n",
"-..-.--\n"
] | [
"012",
"20",
"1012"
] | none | 1,000 | [
{
"input": ".-.--",
"output": "012"
},
{
"input": "--.",
"output": "20"
},
{
"input": "-..-.--",
"output": "1012"
},
{
"input": "---..",
"output": "210"
},
{
"input": "..--.---..",
"output": "0020210"
},
{
"input": "-.....----.",
"output": "1000022... | 1,563,435,320 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 0 | 216 | 0 | lis = input()
i = 0
ln = len(lis)
while i< ln-1:
if lis[i] == '-':
i+=1
if lis[i] == '-':
print(2)
else:
print(1)
elif lis[i]== '.':
print(0)
i+=1
| Title: Borze
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Ternary numeric notation is quite popular in Berland. To telegraph the ternary number the Borze alphabet is used. Digit 0 is transmitted as «.», 1 as «-.» and 2 as «--». You are to decode the Borze code, i.e. to find out the ternary ... | ```python
lis = input()
i = 0
ln = len(lis)
while i< ln-1:
if lis[i] == '-':
i+=1
if lis[i] == '-':
print(2)
else:
print(1)
elif lis[i]== '.':
print(0)
i+=1
``` | 0 |
368 | B | Sereja and Suffixes | PROGRAMMING | 1,100 | [
"data structures",
"dp"
] | null | null | Sereja has an array *a*, consisting of *n* integers *a*1, *a*2, ..., *a**n*. The boy cannot sit and do nothing, he decided to study an array. Sereja took a piece of paper and wrote out *m* integers *l*1,<=*l*2,<=...,<=*l**m* (1<=≤<=*l**i*<=≤<=*n*). For each number *l**i* he wants to know how many distinct numbers are s... | The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=105). The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=105) — the array elements.
Next *m* lines contain integers *l*1,<=*l*2,<=...,<=*l**m*. The *i*-th line contains integer *l**i* (1<=≤<=*l**i*<=≤<=*n*). | Print *m* lines — on the *i*-th line print the answer to the number *l**i*. | [
"10 10\n1 2 3 4 1 2 3 4 100000 99999\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n"
] | [
"6\n6\n6\n6\n6\n5\n4\n3\n2\n1\n"
] | none | 1,000 | [
{
"input": "10 10\n1 2 3 4 1 2 3 4 100000 99999\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10",
"output": "6\n6\n6\n6\n6\n5\n4\n3\n2\n1"
},
{
"input": "8 3\n8 6 4 3 4 2 4 8\n6\n4\n2",
"output": "3\n4\n5"
},
{
"input": "7 10\n1 3 8 6 2 2 7\n4\n2\n6\n3\n4\n4\n6\n2\n7\n4",
"output": "3\n5\n2\n4\n3\n3\... | 1,667,962,596 | 2,147,483,647 | Python 3 | TIME_LIMIT_EXCEEDED | TESTS | 10 | 1,000 | 4,915,200 | [n,m]=[int(j) for j in input().split()]
a=list(int(j) for j in input().split())
b=[]
c=0
ans=[0]*n
for i in range(n):
if (a[n-1-i] in b):
ans[n-1-i]=int(c)
else:
c+=1
b.append(a[n-1-i])
ans[n-1-i]=int(c)
for i in range(m):
c=int(input())
print(ans[c-1]) | Title: Sereja and Suffixes
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Sereja has an array *a*, consisting of *n* integers *a*1, *a*2, ..., *a**n*. The boy cannot sit and do nothing, he decided to study an array. Sereja took a piece of paper and wrote out *m* integers *l*1,<=*l*2,<=...... | ```python
[n,m]=[int(j) for j in input().split()]
a=list(int(j) for j in input().split())
b=[]
c=0
ans=[0]*n
for i in range(n):
if (a[n-1-i] in b):
ans[n-1-i]=int(c)
else:
c+=1
b.append(a[n-1-i])
ans[n-1-i]=int(c)
for i in range(m):
c=int(input())
print(ans[... | 0 | |
496 | A | Minimum Difficulty | PROGRAMMING | 900 | [
"brute force",
"implementation",
"math"
] | null | null | Mike is trying rock climbing but he is awful at it.
There are *n* holds on the wall, *i*-th hold is at height *a**i* off the ground. Besides, let the sequence *a**i* increase, that is, *a**i*<=<<=*a**i*<=+<=1 for all *i* from 1 to *n*<=-<=1; we will call such sequence a track. Mike thinks that the track *a*1, ...,... | The first line contains a single integer *n* (3<=≤<=*n*<=≤<=100) — the number of holds.
The next line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=1000), where *a**i* is the height where the hold number *i* hangs. The sequence *a**i* is increasing (i.e. each element except for the first one is strict... | Print a single number — the minimum difficulty of the track after removing a single hold. | [
"3\n1 4 6\n",
"5\n1 2 3 4 5\n",
"5\n1 2 3 7 8\n"
] | [
"5\n",
"2\n",
"4\n"
] | In the first sample you can remove only the second hold, then the sequence looks like (1, 6), the maximum difference of the neighboring elements equals 5.
In the second test after removing every hold the difficulty equals 2.
In the third test you can obtain sequences (1, 3, 7, 8), (1, 2, 7, 8), (1, 2, 3, 8), for whic... | 500 | [
{
"input": "3\n1 4 6",
"output": "5"
},
{
"input": "5\n1 2 3 4 5",
"output": "2"
},
{
"input": "5\n1 2 3 7 8",
"output": "4"
},
{
"input": "3\n1 500 1000",
"output": "999"
},
{
"input": "10\n1 2 3 4 5 6 7 8 9 10",
"output": "2"
},
{
"input": "10\n1 4 9... | 1,633,493,453 | 2,147,483,647 | PyPy 3 | OK | TESTS | 19 | 93 | 20,172,800 | numnum = int(input())
nums = [int(x) for x in input().split()]
oned = nums[1] - nums[0]
twod = nums[2] - nums[0]
for i in range(2, numnum):
oned = max(oned, nums[i] - nums[i - 1])
twod = min(twod, nums[i] - nums[i - 2])
print(max(oned, twod)) | Title: Minimum Difficulty
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Mike is trying rock climbing but he is awful at it.
There are *n* holds on the wall, *i*-th hold is at height *a**i* off the ground. Besides, let the sequence *a**i* increase, that is, *a**i*<=<<=*a**i*<=+<=1 fo... | ```python
numnum = int(input())
nums = [int(x) for x in input().split()]
oned = nums[1] - nums[0]
twod = nums[2] - nums[0]
for i in range(2, numnum):
oned = max(oned, nums[i] - nums[i - 1])
twod = min(twod, nums[i] - nums[i - 2])
print(max(oned, twod))
``` | 3 | |
615 | A | Bulbs | PROGRAMMING | 800 | [
"implementation"
] | null | null | Vasya wants to turn on Christmas lights consisting of *m* bulbs. Initially, all bulbs are turned off. There are *n* buttons, each of them is connected to some set of bulbs. Vasya can press any of these buttons. When the button is pressed, it turns on all the bulbs it's connected to. Can Vasya light up all the bulbs?
I... | The first line of the input contains integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of buttons and the number of bulbs respectively.
Each of the next *n* lines contains *x**i* (0<=≤<=*x**i*<=≤<=*m*) — the number of bulbs that are turned on by the *i*-th button, and then *x**i* numbers *y**ij* (1<=≤<=*y**... | If it's possible to turn on all *m* bulbs print "YES", otherwise print "NO". | [
"3 4\n2 1 4\n3 1 3 1\n1 2\n",
"3 3\n1 1\n1 2\n1 1\n"
] | [
"YES\n",
"NO\n"
] | In the first sample you can press each button once and turn on all the bulbs. In the 2 sample it is impossible to turn on the 3-rd lamp. | 500 | [
{
"input": "3 4\n2 1 4\n3 1 3 1\n1 2",
"output": "YES"
},
{
"input": "3 3\n1 1\n1 2\n1 1",
"output": "NO"
},
{
"input": "3 4\n1 1\n1 2\n1 3",
"output": "NO"
},
{
"input": "1 5\n5 1 2 3 4 5",
"output": "YES"
},
{
"input": "1 5\n5 4 4 1 2 3",
"output": "NO"
},... | 1,665,477,709 | 2,147,483,647 | Python 3 | OK | TESTS | 45 | 46 | 0 | a,b = [int(x) for x in input().split()]
list1 = [0]*b
for i in range(a):
list2 = [int(x) for x in input().split()]
for j in list2[1:]:
list1[j-1] += 1
if list1.count(0)==0:
print("YES")
else:
print("NO") | Title: Bulbs
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya wants to turn on Christmas lights consisting of *m* bulbs. Initially, all bulbs are turned off. There are *n* buttons, each of them is connected to some set of bulbs. Vasya can press any of these buttons. When the button is... | ```python
a,b = [int(x) for x in input().split()]
list1 = [0]*b
for i in range(a):
list2 = [int(x) for x in input().split()]
for j in list2[1:]:
list1[j-1] += 1
if list1.count(0)==0:
print("YES")
else:
print("NO")
``` | 3 | |
235 | A | LCM Challenge | PROGRAMMING | 1,600 | [
"number theory"
] | null | null | Some days ago, I learned the concept of LCM (least common multiple). I've played with it for several times and I want to make a big number with it.
But I also don't want to use many numbers, so I'll choose three positive integers (they don't have to be distinct) which are not greater than *n*. Can you help me to find ... | The first line contains an integer *n* (1<=≤<=*n*<=≤<=106) — the *n* mentioned in the statement. | Print a single integer — the maximum possible LCM of three not necessarily distinct positive integers that are not greater than *n*. | [
"9\n",
"7\n"
] | [
"504\n",
"210\n"
] | The least common multiple of some positive integers is the least positive integer which is multiple for each of them.
The result may become very large, 32-bit integer won't be enough. So using 64-bit integers is recommended.
For the last example, we can chose numbers 7, 6, 5 and the LCM of them is 7·6·5 = 210. It is ... | 500 | [
{
"input": "9",
"output": "504"
},
{
"input": "7",
"output": "210"
},
{
"input": "1",
"output": "1"
},
{
"input": "5",
"output": "60"
},
{
"input": "6",
"output": "60"
},
{
"input": "33",
"output": "32736"
},
{
"input": "21",
"output": ... | 1,632,393,674 | 2,147,483,647 | PyPy 3 | WRONG_ANSWER | TESTS | 2 | 186 | 20,172,800 | from math import gcd
n = int(input())
arr = [n, n-1, n-2]
res = arr[0]
for i in range(1, 3):
res = (res*arr[i])//gcd(res, arr[i])
print(res) | Title: LCM Challenge
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Some days ago, I learned the concept of LCM (least common multiple). I've played with it for several times and I want to make a big number with it.
But I also don't want to use many numbers, so I'll choose three positive... | ```python
from math import gcd
n = int(input())
arr = [n, n-1, n-2]
res = arr[0]
for i in range(1, 3):
res = (res*arr[i])//gcd(res, arr[i])
print(res)
``` | 0 | |
767 | A | Snacktower | PROGRAMMING | 1,100 | [
"data structures",
"implementation"
] | null | null | According to an old legeng, a long time ago Ankh-Morpork residents did something wrong to miss Fortune, and she cursed them. She said that at some time *n* snacks of distinct sizes will fall on the city, and the residents should build a Snacktower of them by placing snacks one on another. Of course, big snacks should b... | The first line contains single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the total number of snacks.
The second line contains *n* integers, the *i*-th of them equals the size of the snack which fell on the *i*-th day. Sizes are distinct integers from 1 to *n*. | Print *n* lines. On the *i*-th of them print the sizes of the snacks which the residents placed on the top of the Snacktower on the *i*-th day in the order they will do that. If no snack is placed on some day, leave the corresponding line empty. | [
"3\n3 1 2\n",
"5\n4 5 1 2 3\n"
] | [
"3\n \n2 1",
"5 4\n \n \n3 2 1\n"
] | In the example a snack of size 3 fell on the first day, and the residents immediately placed it. On the second day a snack of size 1 fell, and the residents weren't able to place it because they were missing the snack of size 2. On the third day a snack of size 2 fell, and the residents immediately placed it. Right aft... | 500 | [
{
"input": "3\n3 1 2",
"output": "3 \n\n2 1 "
},
{
"input": "5\n4 5 1 2 3",
"output": "5 4 \n\n\n3 2 1 "
},
{
"input": "1\n1",
"output": "1 "
},
{
"input": "2\n1 2",
"output": "2 1 "
},
{
"input": "10\n5 1 6 2 8 3 4 10 9 7",
"output": "10 \n9 8 \n7 6 5 4 3 2 1... | 1,683,032,803 | 2,147,483,647 | PyPy 3-64 | TIME_LIMIT_EXCEEDED | TESTS | 7 | 2,000 | 13,516,800 | n = int(input())
arr = list(map(int,input().split()))
pack=[]
for i in range(n):
pack.append(arr[i])
while n in pack:
print(n,end=" ")
n-=1
else:
print("") | Title: Snacktower
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
According to an old legeng, a long time ago Ankh-Morpork residents did something wrong to miss Fortune, and she cursed them. She said that at some time *n* snacks of distinct sizes will fall on the city, and the residents sh... | ```python
n = int(input())
arr = list(map(int,input().split()))
pack=[]
for i in range(n):
pack.append(arr[i])
while n in pack:
print(n,end=" ")
n-=1
else:
print("")
``` | 0 | |
599 | A | Patrick and Shopping | PROGRAMMING | 800 | [
"implementation"
] | null | null | Today Patrick waits for a visit from his friend Spongebob. To prepare for the visit, Patrick needs to buy some goodies in two stores located near his house. There is a *d*1 meter long road between his house and the first shop and a *d*2 meter long road between his house and the second shop. Also, there is a road of len... | The first line of the input contains three integers *d*1, *d*2, *d*3 (1<=≤<=*d*1,<=*d*2,<=*d*3<=≤<=108) — the lengths of the paths.
- *d*1 is the length of the path connecting Patrick's house and the first shop; - *d*2 is the length of the path connecting Patrick's house and the second shop; - *d*3 is the length o... | Print the minimum distance that Patrick will have to walk in order to visit both shops and return to his house. | [
"10 20 30\n",
"1 1 5\n"
] | [
"60\n",
"4\n"
] | The first sample is shown on the picture in the problem statement. One of the optimal routes is: house <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> first shop <img align="middle" class="tex-form... | 500 | [
{
"input": "10 20 30",
"output": "60"
},
{
"input": "1 1 5",
"output": "4"
},
{
"input": "100 33 34",
"output": "134"
},
{
"input": "777 777 777",
"output": "2331"
},
{
"input": "2 2 8",
"output": "8"
},
{
"input": "12 34 56",
"output": "92"
},
... | 1,598,972,699 | 2,147,483,647 | PyPy 3 | OK | TESTS | 21 | 140 | 0 | a,b,c=map(int,input().split())
m=2*a+2*b
v=a+b+c
g=2*a+2*c
h=2*b+2*c
print(min(m,v,g,h)) | Title: Patrick and Shopping
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Today Patrick waits for a visit from his friend Spongebob. To prepare for the visit, Patrick needs to buy some goodies in two stores located near his house. There is a *d*1 meter long road between his house and the... | ```python
a,b,c=map(int,input().split())
m=2*a+2*b
v=a+b+c
g=2*a+2*c
h=2*b+2*c
print(min(m,v,g,h))
``` | 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,662,112,968 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 0 | 30 | 0 | m,n,a=map(int,input().split())
if n%a == 0:
b = 0
else:
b = 1
if m%a == 0:
c = 0
else:
c = 1
t = (n/a)+b
t1 = (m/a)+c
print(t*t1) | 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 n%a == 0:
b = 0
else:
b = 1
if m%a == 0:
c = 0
else:
c = 1
t = (n/a)+b
t1 = (m/a)+c
print(t*t1)
``` | 0 |
742 | A | Arpa’s hard exam and Mehrdad’s naive cheat | PROGRAMMING | 1,000 | [
"implementation",
"math",
"number theory"
] | null | null | There exists an island called Arpa’s land, some beautiful girls live there, as ugly ones do.
Mehrdad wants to become minister of Arpa’s land. Arpa has prepared an exam. Exam has only one question, given *n*, print the last digit of 1378*n*.
Mehrdad has become quite confused and wants you to help him. Please help, al... | The single line of input contains one integer *n* (0<=<=≤<=<=*n*<=<=≤<=<=109). | Print single integer — the last digit of 1378*n*. | [
"1\n",
"2\n"
] | [
"8",
"4"
] | In the first example, last digit of 1378<sup class="upper-index">1</sup> = 1378 is 8.
In the second example, last digit of 1378<sup class="upper-index">2</sup> = 1378·1378 = 1898884 is 4. | 500 | [
{
"input": "1",
"output": "8"
},
{
"input": "2",
"output": "4"
},
{
"input": "1000",
"output": "6"
},
{
"input": "3",
"output": "2"
},
{
"input": "4",
"output": "6"
},
{
"input": "1000000000",
"output": "6"
},
{
"input": "5",
"output": ... | 1,694,875,404 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 15 | 46 | 0 | import sys
import math
for line in sys.stdin:
numbers = [int(x) for x in line.strip().split()]
n= numbers[0]
if (n%4)==0:
print(6)
elif (n%4==1):
print(8)
elif (n%4==2):
print(4)
elif (n%4==3):
print(2) | Title: Arpa’s hard exam and Mehrdad’s naive cheat
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There exists an island called Arpa’s land, some beautiful girls live there, as ugly ones do.
Mehrdad wants to become minister of Arpa’s land. Arpa has prepared an exam. Exam has only one ques... | ```python
import sys
import math
for line in sys.stdin:
numbers = [int(x) for x in line.strip().split()]
n= numbers[0]
if (n%4)==0:
print(6)
elif (n%4==1):
print(8)
elif (n%4==2):
print(4)
elif (n%4==3):
print(2)
``` | 0 | |
984 | A | Game | PROGRAMMING | 800 | [
"sortings"
] | null | null | Two players play a game.
Initially there are $n$ integers $a_1, a_2, \ldots, a_n$ written on the board. Each turn a player selects one number and erases it from the board. This continues until there is only one number left on the board, i. e. $n - 1$ turns are made. The first player makes the first move, then players ... | The first line contains one integer $n$ ($1 \le n \le 1000$) — the number of numbers on the board.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^6$). | Print one number that will be left on the board. | [
"3\n2 1 3\n",
"3\n2 2 2\n"
] | [
"2",
"2"
] | In the first sample, the first player erases $3$ and the second erases $1$. $2$ is left on the board.
In the second sample, $2$ is left on the board regardless of the actions of the players. | 500 | [
{
"input": "3\n2 1 3",
"output": "2"
},
{
"input": "3\n2 2 2",
"output": "2"
},
{
"input": "9\n44 53 51 80 5 27 74 79 94",
"output": "53"
},
{
"input": "10\n38 82 23 37 96 4 81 60 67 86",
"output": "60"
},
{
"input": "10\n58 26 77 15 53 81 68 48 22 65",
"outpu... | 1,560,800,018 | 2,147,483,647 | Python 3 | WRONG_ANSWER | TESTS | 5 | 124 | 0 | a=int(input())
b=input().split()
if a%2==1:
for i in range(a//2):
b.remove(max(b))
b.remove(min(b))
else:
for i in range(a//2-1):
b.remove(max(b))
b.remove(min(b))
b.remove(max(b))
for i in range(len(b)):
print(b[i])
| Title: Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Two players play a game.
Initially there are $n$ integers $a_1, a_2, \ldots, a_n$ written on the board. Each turn a player selects one number and erases it from the board. This continues until there is only one number left on the... | ```python
a=int(input())
b=input().split()
if a%2==1:
for i in range(a//2):
b.remove(max(b))
b.remove(min(b))
else:
for i in range(a//2-1):
b.remove(max(b))
b.remove(min(b))
b.remove(max(b))
for i in range(len(b)):
print(b[i])
``` | 0 | |
859 | A | Declined Finalists | PROGRAMMING | 800 | [
"greedy",
"implementation"
] | null | null | This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible ... | The first line of input contains *K* (1<=≤<=*K*<=≤<=25), the number of onsite finalists you know. The second line of input contains *r*1,<=*r*2,<=...,<=*r**K* (1<=≤<=*r**i*<=≤<=106), the qualifying ranks of the finalists you know. All these ranks are distinct. | Print the minimum possible number of contestants that declined the invitation to compete onsite. | [
"25\n2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28\n",
"5\n16 23 8 15 4\n",
"3\n14 15 92\n"
] | [
"3\n",
"0\n",
"67\n"
] | In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | 500 | [
{
"input": "25\n2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28",
"output": "3"
},
{
"input": "5\n16 23 8 15 4",
"output": "0"
},
{
"input": "3\n14 15 92",
"output": "67"
},
{
"input": "1\n1000000",
"output": "999975"
},
{
"input": "25\n1000000 ... | 1,505,632,550 | 2,147,483,647 | Python 3 | OK | TESTS | 25 | 62 | 0 | n = int(input())
L = input().split()
mx = 0
for i in range(n):
L[i] = int(L[i])
mx = max(mx, L[i])
print(max(0, mx - 25)) | Title: Declined Finalists
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to t... | ```python
n = int(input())
L = input().split()
mx = 0
for i in range(n):
L[i] = int(L[i])
mx = max(mx, L[i])
print(max(0, mx - 25))
``` | 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.