text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of non-negative integers a_1, a_2, ..., a_n is called growing if for all i from 1 to n - 1 all ones (of binary representation) in a_i are in the places of ones (of binary representation) in a_{i + 1} (in other words, a_i \:\&\: a_{i + 1} = a_i, where \& denotes [bitwise AND](http://tiny.cc/xpy9uz)). If n = 1 then the sequence is considered growing as well.
For example, the following four sequences are growing:
* [2, 3, 15, 175] β in binary it's [10_2, 11_2, 1111_2, 10101111_2];
* [5] β in binary it's [101_2];
* [1, 3, 7, 15] β in binary it's [1_2, 11_2, 111_2, 1111_2];
* [0, 0, 0] β in binary it's [0_2, 0_2, 0_2].
The following three sequences are non-growing:
* [3, 4, 5] β in binary it's [11_2, 100_2, 101_2];
* [5, 4, 3] β in binary it's [101_2, 100_2, 011_2];
* [1, 2, 4, 8] β in binary it's [0001_2, 0010_2, 0100_2, 1000_2].
Consider two sequences of non-negative integers x_1, x_2, ..., x_n and y_1, y_2, ..., y_n. Let's call this pair of sequences co-growing if the sequence x_1 β y_1, x_2 β y_2, ..., x_n β y_n is growing where β denotes [bitwise XOR](http://tiny.cc/bry9uz).
You are given a sequence of integers x_1, x_2, ..., x_n. Find the lexicographically minimal sequence y_1, y_2, ..., y_n such that sequences x_i and y_i are co-growing.
The sequence a_1, a_2, ..., a_n is lexicographically smaller than the sequence b_1, b_2, ..., b_n if there exists 1 β€ k β€ n such that a_i = b_i for any 1 β€ i < k but a_k < b_k.
Input
The first line contains an integer t (1 β€ t β€ 10^4). Then t test cases follow.
The first line of each test case contains an integer n (1 β€ n β€ 2 β
10^5) β length of the sequence x_i.
The second line contains n integers x_1, x_2, ..., x_n (0 β€ x_i < 2^{30}) β elements of the sequence x_i.
It is guaranteed that the sum of n overall all test cases doesn't exceed 2 β
10^5.
Output
For each test case, print n integers y_1, y_2, ..., y_n (0 β€ y_i < 2^{30}) β lexicographically minimal sequence such that such that it's co-growing with given sequence x_i.
Example
Input
5
4
1 3 7 15
4
1 2 4 8
5
1 2 3 4 5
4
11 13 15 1
1
0
Output
0 0 0 0
0 1 3 7
0 1 0 3 2
0 2 0 14
0
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
dp=[0 for i in range(n)]
def f():
prev=dp[0]^l[0]
j=-1
for i in range(1,n):
t=j+1
s=1<<t
while prev&(s):
t+=1
s<<=1
temp=prev^l[i]
temp2=(prev+s)^l[i]
if temp2<temp:
dp[i]=temp2
prev+=s
j=t
else:
dp[i]=temp
f()
for i in range(n):
print(dp[i],end=" ")
print()
```
No
| 2,700 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of non-negative integers a_1, a_2, ..., a_n is called growing if for all i from 1 to n - 1 all ones (of binary representation) in a_i are in the places of ones (of binary representation) in a_{i + 1} (in other words, a_i \:\&\: a_{i + 1} = a_i, where \& denotes [bitwise AND](http://tiny.cc/xpy9uz)). If n = 1 then the sequence is considered growing as well.
For example, the following four sequences are growing:
* [2, 3, 15, 175] β in binary it's [10_2, 11_2, 1111_2, 10101111_2];
* [5] β in binary it's [101_2];
* [1, 3, 7, 15] β in binary it's [1_2, 11_2, 111_2, 1111_2];
* [0, 0, 0] β in binary it's [0_2, 0_2, 0_2].
The following three sequences are non-growing:
* [3, 4, 5] β in binary it's [11_2, 100_2, 101_2];
* [5, 4, 3] β in binary it's [101_2, 100_2, 011_2];
* [1, 2, 4, 8] β in binary it's [0001_2, 0010_2, 0100_2, 1000_2].
Consider two sequences of non-negative integers x_1, x_2, ..., x_n and y_1, y_2, ..., y_n. Let's call this pair of sequences co-growing if the sequence x_1 β y_1, x_2 β y_2, ..., x_n β y_n is growing where β denotes [bitwise XOR](http://tiny.cc/bry9uz).
You are given a sequence of integers x_1, x_2, ..., x_n. Find the lexicographically minimal sequence y_1, y_2, ..., y_n such that sequences x_i and y_i are co-growing.
The sequence a_1, a_2, ..., a_n is lexicographically smaller than the sequence b_1, b_2, ..., b_n if there exists 1 β€ k β€ n such that a_i = b_i for any 1 β€ i < k but a_k < b_k.
Input
The first line contains an integer t (1 β€ t β€ 10^4). Then t test cases follow.
The first line of each test case contains an integer n (1 β€ n β€ 2 β
10^5) β length of the sequence x_i.
The second line contains n integers x_1, x_2, ..., x_n (0 β€ x_i < 2^{30}) β elements of the sequence x_i.
It is guaranteed that the sum of n overall all test cases doesn't exceed 2 β
10^5.
Output
For each test case, print n integers y_1, y_2, ..., y_n (0 β€ y_i < 2^{30}) β lexicographically minimal sequence such that such that it's co-growing with given sequence x_i.
Example
Input
5
4
1 3 7 15
4
1 2 4 8
5
1 2 3 4 5
4
11 13 15 1
1
0
Output
0 0 0 0
0 1 3 7
0 1 0 3 2
0 2 0 14
0
Submitted Solution:
```
from math import gcd, floor, inf, log2, sqrt, log10
from bisect import bisect_right, bisect_left
from statistics import mode
power_of_two = lambda number: int(log2(number))
cases = int(input())
for _ in range(cases):
n = int(input())
arr = list(map(int, input().split()))
ans = [0]
prev = 0
first = arr[0]
if first == 0:
mx = 0
else:
mx = 2**(power_of_two(first)+1)-1
for num in arr[1:]:
if num == 0:
ans.append(mx)
continue
x = power_of_two(num)
x = max(x, prev)
prev = x
mx = 2**(x+1)-1
y = mx - num
ans.append(y)
print(*ans)
```
No
| 2,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
def main():
mode="filee"
if mode=="file":f=open("test.txt","r")
get = lambda :[str(x) for x in (f.readline() if mode=="file" else input()).split()]
[g]=get()
#print(g)
n = len(g)
maxx = -1
for i in range( 1, n-1 ):
for j in range(i+1, n):
x = g[:i]
y = g[i:j]
z = g[j:]
#print(x, y, z)
if int(x) > 10**6 or int(y) > 10**6 or int(z) > 10**6 or len(x) > 1 and x[0] == '0' or len(y) > 1 and y[0] == '0' or len(z) > 1 and z[0] == '0':
continue
maxx = max( maxx, int(x) + int(y) + int(z) )
print(maxx)
if mode=="file":f.close()
if __name__=="__main__":
main()
```
| 2,702 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
s = input()
n = len(s)
max_points = -1
for i in range(1, n - 1):
for j in range(i + 1, n):
a = s[:i]
b = s[i:j]
c = s[j:]
if(int(a) <= 10 ** 6 and int(b) <= 10 ** 6 and int(c) <= 10 ** 6):
if((a[0] == "0" and len(a) > 1) or (b[0] == "0" and len(b) > 1) or (c[0] == "0" and len(c) > 1)):
continue
else:
points = int(a) + int(b) + int(c)
if(max_points < points):
max_points = points
print(max_points)
```
| 2,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
s=input()
a=-1
for i in range(1,len(s)-1):
for j in range(i+1,len(s)):
x=int(s[:i])
y=int(s[i:j])
z=int(s[j:])
if s[0]=='0' and len(s[:i])>1:
continue
if s[i]=='0' and len(s[i:j])>1:
continue
if s[j]=='0' and len(s[j:])>1:
continue
if x>1e6 or y>1e6 or z>1e6:
continue
a=max(a,x+y+z)
print(a)
```
| 2,704 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
def max_score(n):
max_score = 0
any_choice = False
for i in range(0, len(n)-2):
for j in range(i+1, len(n)-1):
if ((n[:i+1][0] == '0' and len(n[:i+1]) > 1)
or (n[i+1:j+1][0] == '0' and len(n[i+1:j+1]) > 1)
or (n[j+1:][0] == '0' and len(n[j+1:]) > 1)
or int(n[:i+1]) > 1000000
or int(n[i+1:j+1]) > 1000000
or int(n[j+1:]) > 1000000):
continue
else:
any_choice = True
new_score = int(n[:i+1]) + int(n[i+1:j+1]) + int(n[j+1:])
if new_score > max_score:
max_score = new_score
if any_choice:
return max_score
else:
return -1
def main():
allscores = input()
print(max_score(allscores))
main()
```
| 2,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
s = input()
n = len(s)
ans = -1
def f(x):
if x[0] == '0' and len(x) > 1:
return -1000000000000000000000000000000000000000000000000
ret = int(x)
if ret > 1000000:
return -1000000000000000000000000000000000000000000000000
return ret
for i in range(1, n):
for j in range(i + 1, n):
ans = max(ans, f(s[0:i]) + f(s[i:j]) + f(s[j:]))
print(ans)
```
| 2,706 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
import sys
[s] = sys.stdin.read().split()
def isvalid (s):
if s == "0" or s=="1000000":
return True
if s[0] == '0' or len(s)>6:
return False
return True
mx = -1
for i in range(1, len(s)):
for j in range(i+1, len(s)):
s1 = s[0:i]
s2 = s[i:j]
s3 = s[j:]
if isvalid(s1) and isvalid(s2) and isvalid(s3):
a = int(s1)
b = int(s2)
c = int(s3)
mx = max(mx, a+b+c)
print(mx)
```
| 2,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
s=input()
n=len(s)
maxi=-1
for i in range(n-2):
for j in range(i+1,n-1):
a,b,c= s[:i+1],s[i+1:j+1],s[j+1:]
if len(a)==len(str(int(a))) and len(b)==len(str(int(b))) and len(c)==len(str(int(c))):
if int(a)<=1e6 and int(b)<=1e6 and int(c)<=1e6:
maxi=max(maxi,int(a)+int(b)+int(c))
print(maxi)
```
| 2,708 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Tags: brute force, implementation
Correct Solution:
```
def isint(strx):
if strx == '0':
return True
if strx[0] == '0':
return False
return int(strx) <= 1000000
maxx = -1
x = input()
for i in range(1, len(x)):
for j in range(i+1, len(x)):
a, b, c = x[:i], x[i:j], x[j:]
if isint(a) and isint(b) and isint(c):
maxx = max(maxx, int(a)+int(b)+int(c))
print(maxx)
```
| 2,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
s = input()
def valid(s):
if not (s[0] == '0' and len(s) > 1) and int(s) <= 1000000:
return True
return False
res = []
for x in range(1, len(s)):
for y in range(x, len(s)):
b = [x, y]
num1 = s[:x]
num2 = s[x:y]
num3 = s[y:]
if len(set(b)) != 2:
continue
if valid(num1) and valid(num2) and valid(num3):
res.append(int(num1) + int(num2) + int(num3))
if not len(res):
print(-1)
else:
print(max(res))
```
Yes
| 2,710 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
n=input()
l=len(n)
mini=-1
for i in range(1,l-1):
for j in range(1,l-1):
k=l-i-j
if(k>0):
# print(i,i+j)
t1="".join(n[:i])
t2="".join(n[i:i+j])
t3="".join(n[i+j:])
if((t1[0]=="0" and i>1) or (t2[0]=="0" and j>1) or (t3[0]=="0" and k>1)):
continue
# print(t1,t2,t3)
t1=int(t1)
t2=int(t2)
t3=int(t3)
s=t1+t2+t3
if(s>mini and t1<=10**6 and t2<=10**6 and t3<=10**6 ):
mini=s
print(mini)
```
Yes
| 2,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
def g(a):
return (len(a) == 1 or a[0] != '0') and int(a) <= 1000000
def f(a, b, c):
return int(a) + int(b) + int(c) if g(a) and g(b) and g(c) else -1
s, v = input(), -1
for i in range(1, len(s) - 1):
for j in range(i + 1, len(s)):
v = max(v, f(s[:i], s[i:j], s[j:]))
print(v)
```
Yes
| 2,712 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
s = input()
n = len(s)
def num(x):
if len(x) > 1 and x[0] == '0':
return 1000000000
x = int(x)
if x > 1000000:
return 1000000000
return x
ans = -1
for i in range(1, n-1):
for j in range(i+1, n):
l = s[:i]
m = s[i:j]
r = s[j:]
cur = num(l) + num(m) + num(r)
if cur < 100000000:
ans = max(ans, cur)
print(ans)
```
Yes
| 2,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
x=input()
if ( x.startswith('0') ):
print(-1)
else:
try1=int(x[0:len(x)-2])+int(x[len(x)-2])+int(x[len(x)-1])
try2=int(x[1:len(x)-1])+int(x[0])+int(x[len(x)-1])
try3=int(x[2:len(x)])+int(x[0])+int(x[1])
print(max(try1,try2,try3))
```
No
| 2,714 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
s=str(input())
n=len(s)
ans = []
if (n==3):
print(int(s[0])+int(s[1])+int(s[2]));
exit();
if (s[2]!="0"):
ans.append(int(s[0])+int(s[1])+int(s[2:]))
if (s[1]!="0"):
ans.append(int(s[0])+int(s[1:n-1])+int(s[-1]))
if (s[0]!="0"):
ans.append(int(s[0:n-2])+int(s[-2])+int(s[-1]))
if (len(ans)==0):
print(-1)
else:
print(max(ans))
```
No
| 2,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
# https://codeforces.com/problemset/problem/175/A
inputArray = [int(d) for d in str(input())]
# inputArray = [9, 0, 0, 0]
x = []
y = []
z = []
max_sum = -1
def convert(list):
# Converting integer list to string list
s = [str(i) for i in list]
# Join list items using join()
res = int("".join(s))
return(res)
for idxFirst in range(len(inputArray) - 2):
for idxSecond in range(idxFirst+1, len(inputArray)-1):
x = []
y = []
z = []
for idxX in range(idxFirst+1):
x.append(inputArray[idxX])
if len(x) > 1 and x[0] == 0:
break
x = convert(x)
for idxY in range(idxFirst+1, idxSecond+1):
y.append(inputArray[idxY])
if len(y) > 1 and y[0] == 0:
break
y = convert(y)
for idxZ in range(idxSecond+1, len(inputArray)):
z.append(inputArray[idxZ])
if len(z) > 1 and z[0] == 0:
break
z = convert(z)
temp = x + y + z
if temp > max_sum and max_sum <= 1000000:
max_sum = temp
print(max_sum)
```
No
| 2,716 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya plays Robot Bicorn Attack.
The game consists of three rounds. For each one a non-negative integer amount of points is given. The result of the game is the sum of obtained points. Vasya has already played three rounds and wrote obtained points one by one (without leading zeros) into the string s. Vasya decided to brag about his achievement to the friends. However, he has forgotten how many points he got for each round. The only thing he remembers is the string s.
Help Vasya to find out what is the maximum amount of points he could get. Take into account that Vasya played Robot Bicorn Attack for the first time, so he could not get more than 1000000 (106) points for one round.
Input
The only line of input contains non-empty string s obtained by Vasya. The string consists of digits only. The string length does not exceed 30 characters.
Output
Print the only number β the maximum amount of points Vasya could get. If Vasya is wrong and the string could not be obtained according to the rules then output number -1.
Examples
Input
1234
Output
37
Input
9000
Output
90
Input
0009
Output
-1
Note
In the first example the string must be split into numbers 1, 2 and 34.
In the second example the string must be split into numbers 90, 0 and 0.
In the third example the string is incorrect, because after splitting the string into 3 numbers number 00 or 09 will be obtained, but numbers cannot have leading zeroes.
Submitted Solution:
```
s = input()
final = -1
n = len(s)
flag = 0
l = ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09']
for i in range(1, n):
for j in range(i+1, n):
numbers = [s[:i], s[i:j], s[j:]]
# print(numbers)
# print(flag)
flag = 0;
# for element in numbers:
# if(str(int(element)) != element):
# flag = 1
# if(flag == 0):
# print(int(s[:i]) + int(s[i:j]) + int(s[j:]))
# print(final)
# print('f', s[:i], s[i:j], s[j:])
# print(str(s[j:][:1]))
if(str(s[:i][:2]) in l or str(s[i:j][:2]) in l or str(s[j:][:2]) in l):
# print(1)
flag = 1
else:
if(int(s[:i]) <= 1000000 and int(s[i:j]) <= 1000000 and int(s[j:]) <= 1000000):
# print(s[:i], s[i:j], s[j:])
final = max(final, (int(s[:i]) + int(s[i:j]) + int(s[j:])))
# flag = 0
# print(final)
# print('flag', flag)
if(flag == 1):
print(-1)
else:
print(final)
```
No
| 2,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
n, m = map(int, input().split())
a = [str((m+1)//2 + (1 - 2*((m+i%m-1)%2))*(((i%m)+1)//2)) for i in range(n)]
print("\n".join(a))
```
| 2,718 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
def task(n,m):
if m%2==0:
c=0
else:
c=1
mid=m//2+c
l=mid-1
hi=mid+1
print(mid)
n-=1
if m%2!=0:
while n:
if l>0:
print(l)
l-=1
n-=1
if hi<=m and n:
print(hi)
hi+=1
n-=1
if hi>m and l<=0:
hi=mid+1
l=mid-1
if n:
print(mid)
n-=1
return ""
else:
while n:
if hi<=m and n:
print(hi)
hi+=1
n-=1
if l>0 and n:
print(l)
l-=1
n-=1
if hi>m and l<=0:
hi=mid+1
l=mid-1
if n:
print(mid)
n-=1
return ""
a,b=map(int,input().strip().split())
print(task(a,b))
```
| 2,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
n,m=list(map(int,input().split()))
l=[0]*(n+1)
b=[0]*(m+1)
m1=(m+1)//2
if m%2==1:
for i in range(1,n+1):
if i<=m:
if i%2==1:
l[i]=m1+i//2
else:
l[i]=m1-i//2
else:
l[i]=l[i-m]
if m%2==0:
for i in range(1,n+1):
if i<=m:
if i%2==1:
l[i]=m1-i//2
else:
l[i]=m1+i//2
else:
l[i]=l[i-m]
for i in range(1,n+1):
print(l[i])
```
| 2,720 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
from sys import *
input = stdin.readline
n, m = map(int, input().split())
rishabh = (m + 1) // 2
ans = []
smh = rishabh
for kk in range(n):
ans.append(smh)
if smh == rishabh and m%2 == 1:
smh -= 1
elif smh <= rishabh:
smh = m - smh + 1
else:
smh = m - smh
if smh == 0:
smh = rishabh
for kkk in ans:
print(kkk)
```
| 2,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
n,m=map(int,input().split())
#baskets=[int(i) for i in input().split()]
if m%2==0:
ans=[]
for i in range(m//2,0,-1):
ans.append(i)
ans.append(m-i+1)
z=n//m
k=ans*z
k=k+ans[0:n%m]
else:
ans=[m//2+1]
for i in range(m//2,0,-1):
ans.append(i)
ans.append(m-i+1)
z=n//m
k=ans*z
k=k+ans[0:n%m]
for i in k:
print(i)
```
| 2,722 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
def func(i):
return abs((m+1)/2-i)
a = input()
[n, m] = a.split(' ')
[n, m] = [int(n), int(m)];
a = [i for i in range(1, m+1)]
a.sort(key=func)
i = 0;
while(i<n):
print(a[i%m])
i+=1;
# print(a)
```
| 2,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
n,m = input().split()
n,m = int(n),int(m)
for i in range(n):
j = i % m;
if m % 2 == 1:
if j % 2 == 0:
print(int(m/2 + j/2) + 1)
else:
print(int(m/2 - (j+1)/2) + 1)
else:
if j % 2 == 0:
print(int(m/2 - j/2))
else:
print(int(m/2 + (j+1)/2))
```
| 2,724 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Tags: data structures, implementation, math
Correct Solution:
```
n, m = map(int, input().split())
center = (m+1)//2
pos = center
for i in range(n):
print(pos)
if pos == center and m%2 == 1:
pos -= 1
elif pos <= center:
pos = m-pos+1
else:
pos = m-pos
if pos == 0:
pos = center
```
| 2,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m = map(int,input().split())
lst = [0]*m
if m%2:
i = 1
x = (m+1)//2
lst[0] = x
for j in range(x-1,0,-1):
lst[i] = j
i += 2
i = 2
for j in range(x+1,m+1):
lst[i] = j
i += 2
else:
i = 0
x = (m+1)//2
for j in range(x,0,-1):
lst[i] = j
i += 2
i = 1
for j in range(x+1,m+1):
lst[i] = j
i += 2
t = n//m
if t==0:
print(*lst[:n%m])
else:
lst *= t
lst += lst[:n%m]
print(*lst)
```
Yes
| 2,726 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
from sys import stdin, stdout, setrecursionlimit
from collections import deque
# tail-recursion optimization
# In case of tail-recusion optimized code, have to use python compiler.
# Otherwise, memory limit may exceed.
# declare the class Tail_Recursion_Optimization
class Tail_Recursion_Optimization:
def __init__(self, RECURSION_LIMIT, STACK_SIZE):
setrecursionlimit(RECURSION_LIMIT)
threading.stack_size(STACK_SIZE)
return None
class SOLVE:
def solve(self):
R = stdin.readline
#f = open('input.txt');R = f.readline
W = stdout.write
ans = []
n, m = [int(x) for x in R().split()]
a = (m+1) // 2
b = a + (-1 if m%2 else 1)
boxes = deque()
while 1 <= a <= m and 1 <= b <= m:
boxes.append(str(a))
boxes.append(str(b))
a += ( 1 if m%2 else -1)
b += (-1 if m%2 else 1)
if m%2:
boxes.append(str(m))
for i in range(1, n+1):
current_box = boxes.popleft()
ans.append(current_box)
boxes.append(current_box)
W('\n'.join(ans))
return 0
def main():
s = SOLVE()
s.solve()
#Tail_Recursion_Optimization(10**7, 100*1024**2) # recursion-call size, stack-size in byte (MB*1024**2)
#threading.Thread(target=main).start()
main()
```
Yes
| 2,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n, m = map(int, input().split())
p = [0] * (n + 1)
t = [0] + [[j + i for i in range(0, n - j + 1, m)] for j in range(m - 1, m % 2, - 2)] + [[j + i for i in range(0, n - j + 1, m)] for j in range(2 - m % 2, m + 1, 2)]
for j in range(1, m + 1):
for i in t[j]:
p[i] = str(j)
print('\n'.join(p[1: ]))
```
Yes
| 2,728 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m=map(int,input().split(' '))
arr=[]
mid=int((m+1)/2)
if(m%2==0):
if(m==2):
arr.append(mid)
arr.append(mid+1)
else:
arr.append(mid)
for i in range(1,mid):
arr.append(mid+i)
arr.append(mid-i)
arr.append(m)
else:
arr.append(mid)
for i in range(1,mid):
arr.append(mid-i)
arr.append(mid+i)
for i in range(n//m):
for j in range(m):
print(arr[j])
for i in range(n%m):
print(arr[i])
```
Yes
| 2,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m=map(int,input().split())
a=[]
if m%2==0:
t1=m//2
t2=m//2+1
while t1>0 or t2<m:
a.append(t1)
a.append(t2)
t1-=1
t2+=1
else:
t1=m//2
t2=t1-1
t3=t1+1
a.append(t1+1)
while t2>=0 and t3<m:
a.append(t2+1)
a.append(t3+1)
t2-=1
t3+=1
if (n//m)==0:
for i in range(n):
print(a[i])
print("ok")
else:
t1=n//m
while t1!=0:
for i in range(m):
print(a[i])
t1-=1
t2=n%m
for i in range(m):
if i<t2:
print(a[i])
else:
break
```
No
| 2,730 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m = map(int,input().split())
d = {i+1:0 for i in range(n)}
i = 0
t = int(m/2)
t1 = t + 1
r = 0
if m%2 == 0:
while i!= n:
d[i+1] = t
i = i + 1
if i < n:
d[i+1] = t1
i = i + 1
r = r + 1
if r == t:
r == 0
t = t - r
t1 = t1 + r
if m%2 == 1:
r = 1
while i != n:
d[i+1] = t1
i = i + 1
if i < n:
if r == t1:
r = 0
d[i+1] = t1-r
i = i + 1
if i < n:
if r == t1:
r = 0
d[i+1] = t1+r
i = i + 1
r = r + 1
for i in d:
print(d[i])
```
No
| 2,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
from sys import stdin ,stdout
from os import path
rd = lambda:stdin.readline().strip()
wr = stdout.write
if(path.exists('input.txt')):
stdin = open("input.txt","r")
import time
#------------------------------------
x,y = map(int,rd().split())
out =""
temp =0
if y % 2== 0 :
temp =y//2
out+=str(temp)
else:
temp =(y+1)//2
out+=str(temp)
for i in range(1,y+1):
if i != temp :
out+=str(i)
count = x//y
if count == 0 :
out=out[:x%y]
else:
out = (out*count)+out[:x%y]
for i in out :
print(i)
```
No
| 2,732 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
from sys import stdin,stdout
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007
n, m = iia()
if m % 2 == 0:
mid = m // 2 + 1
else:
mid = m // 2
l = r = mid
l1 = r1 = True
while n != 0:
if l1 and r1:
print(mid)
n -= 1
l = r = mid
l1 = r1 = False
if l > 1 and n:
print(l-1)
l -= 1
n -= 1
if l == 1:
l1 = True
if r < m and n:
print(r+1)
r += 1
n -= 1
if r == m:
r1 = True
```
No
| 2,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
p,d=map(int,input().split())
k=1;ans=p;
while(1):
if(p-p%10**k-1<p-d or p-p%10**k-1==-1):
break
elif(p-p%10**k-1>=p-d):
ans=p-p%10**k-1
if(p-ans==10**k):
ans=p
k+=1
print(ans)
```
| 2,734 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
a,b=map(int,input().split())
a += 1
n=a
k=10
while(True):
if ((a%k)>b):
break
n=a-(a%k)
k*=10
print(n-1)
```
| 2,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
def cnt(n):
c=0
while n:
if n%10==9:
c+=1
n//=10
else:
break
return c
def zerocheck(arr,i):
for x in range(i-1,-1,-1):
if arr[x]=="0":
arr[x]="9"
else:
arr[x] = str(int(arr[x]) - 1)
break
return arr
def offer(n,d):
if d==0:
return n
lst=[i for i in str(n)]
ans=[]
# temp=int("9"*(len(str(n))-1))
# while temp:
# if n-temp<=d:
# ans.append(temp)
# break
# else:
# temp//=10
i=len(lst)-1
while i>=1:
if lst[i]!="9" :
if lst[i-1]!="0":
lst[i]="9"
lst[i-1]=str(int(lst[i-1])-1)
else:
lst[i] = "9"
lst[i - 1] = "9"
lst=zerocheck(lst,i-1)
base=int("".join(lst))
if n-base<=d:
ans.append(base)
i-=1
if ans==[]:
return n
return max(ans,key=lambda s:cnt(s))
a,b=map(int,input().strip().split())
print(offer(a,b))
```
| 2,736 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
a,b=input().strip().split(" ")
a,b=[int(a),int(b)]
k=1
while(True):
nine=k-1
dif=(a-nine)%k
if(dif>b or dif<0):
break
if(k==1000000000000000000):
break
k*=10
k//=10
dif=(a-k+1)%k
ans=a-dif
print(ans)
```
| 2,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
import re
import itertools
from collections import Counter
class Task:
p, d = "", ""
answer = ""
def getData(self):
self.p, self.d = input().split(" ")
def solve(self):
p = self.p
p_minus_d = str(int(self.p) - int(self.d))
p_minus_d = '0' * (len(p) - len(p_minus_d)) + p_minus_d
for i in range(0, len(p)):
if p[i] == p_minus_d[i]:
continue
self.answer = p[0:i]
if p[i + 1:] == '9' * (len(p) - i - 1):
self.answer += p[i]
else:
self.answer += chr(ord(p[i]) - 1)
self.answer += '9' * (len(p) - i - 1)
self.answer = re.sub('^0+', '', self.answer)
return
self.answer = p
def printAnswer(self):
print(self.answer)
task = Task();
task.getData();
task.solve();
task.printAnswer();
```
| 2,738 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
"""http://codeforces.com/problemset/problem/219/B"""
if __name__ == '__main__':
p, d = map(int, input().split())
lo = p - d
res = p
for i in range(1, 18):
num = 10 ** i
t = p // num * num + (num - 1)
t = t if t <= p else t - num
if p - t <= d:
res = t
else:
break
print(res)
```
| 2,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
p, d = input().split()
p = int(p); d = int(d)
ans = p = p + 1
i = 10
while i <= 1000000000000000000:
if p % i <= d:
ans = p - p % i
i *= 10
print(ans - 1)
```
| 2,740 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Tags: implementation
Correct Solution:
```
import sys
p, d = map(int, sys.stdin.readline().split())
k = 10
n = p
while p>=k and p%k+1<=d:
if p%k < k-1:
n = p-p%k-1
k*=10
print (n)
# Made By Mostafa_Khaled
```
| 2,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
from math import *
n,d=map(int,input().split())
ln=0
temp=n
ta=0
num=n
k=1
while(1):
if(temp==0):
break
ans=num
val=0
if(temp%10!=9):
val=1
temp//=10
ln+=1
temp-=val
ta*=10
ta+=9
num=temp*(10**ln)+ta
if(n-num>d):
print(ans)
k=0
break
if(k):
print(ta)
```
Yes
| 2,742 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
import sys
import math
import collections
import heapq
import decimal
input=sys.stdin.readline
p,d=(int(i) for i in input().split())
prod=10
ans=-1
for i in range(20):
if(p-(p%prod)!=0):
k=p-(p%prod)-1
if(p-k<=d):
ans=k
prod*=10
if(ans==-1):
ans=p
s1=str(ans)
s2=str(p)
c1,c2=0,0
for i in range(len(s1)-1,-1,-1):
if(s1[i]!='9'):
break
else:
c1+=1
for i in range(len(s2)-1,-1,-1):
if(s2[i]!='9'):
break
else:
c2+=1
if(c2>=c1):
print(p)
else:
print(ans)
```
Yes
| 2,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
p, d = map(int, input().split())
digit = 0
while d >= 0:
last_digit = (p // (10 ** (digit))) % 10
sub = ((last_digit + 1) % 10) * (10 ** digit)
d -= sub
if d >= 0:
p -= sub
else:
break
s = str(p)
if s.count("9") == len(s):
break
digit += 1
print(p)
```
Yes
| 2,744 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
def solve(p, d):
diff = 0
place = 1
save = diff
psave = p
while p > 0 and diff <= d:
save = diff
if p % 10 != 9:
t = p%10 + 10 - 9
p -= t
diff += place*t
p //= 10
place *= 10
if(diff <= d):
save = diff
return psave - save
p, d = [int(x) for x in input().split()]
print(solve(p, d))
```
Yes
| 2,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
p,d = map(int,input().split())
k = p-d
# print(k)
count = 0
if str(p)[-1] == '9':
for i in str(p)[::-1]:
if i == '9':
count+=1
else:
break
x = len(str(p))
y = len(str(k))
# print(x,y)
if x>y:
if int(str(p)[0]) > 1:
first = str(int(str(p)[0])-1)
first+='9'*(x-1)
if x-1>count:
print(first)
else:
print(p)
else:
print('9'*(x-1))
else:
if int(str(p)[0])>int(str(k)[0]):
first = str(int(str(p)[0])-1)
first+='9'*(x-1)
if x-1>count:
print(first)
else:
print(p)
else:
if int(str(p)[0])==int(str(k)[0]):
i = 0
j = 0
ans = ''
# print(k)
while i<x and j<x:
if int(str(p)[i])!=int(str(k)[j]):
ans+=str(int(str(p)[i])-1)
ans+='9'*(x - (i+1))
if x - (i+1)>count:
print(ans)
else:
print(p)
break
else:
ans+=str(int(str(p)[i]))
i+=1
j+=1
```
No
| 2,746 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
n,d=value()
n=str(n)
i=len(n)-1
while(i>0):
if(n[i]!='9'):
#print(n,i)
new=str(int(n[:i])-1)+'9'+n[i+1:]
#print(new)
if(int(n)-int(new)<=d):
d-=int(n)-int(new)
n=str(new)
i=len(n)-1
else:
i-=1
else:
i-=1
print(n)
```
No
| 2,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
p, d = map(int, input().split())
best = p
for i in range(len(str(p))):
new_price = p - (p % 10**i) - 10**i + (0 if i == 0 else int('9' * i))
if p - new_price <= d:
best = new_price
else:
break
print(best)
```
No
| 2,748 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur businessman. Recently he was surprised to find out that the market for paper scissors is completely free! Without further ado, Polycarpus decided to start producing and selling such scissors.
Polycaprus calculated that the optimal celling price for such scissors would be p bourles. However, he read somewhere that customers are attracted by prices that say something like "Special Offer! Super price 999 bourles!". So Polycarpus decided to lower the price a little if it leads to the desired effect.
Polycarpus agrees to lower the price by no more than d bourles so that the number of nines at the end of the resulting price is maximum. If there are several ways to do it, he chooses the maximum possible price.
Note, Polycarpus counts only the trailing nines in a price.
Input
The first line contains two integers p and d (1 β€ p β€ 1018; 0 β€ d < p) β the initial price of scissors and the maximum possible price reduction.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print the required price β the maximum price that ends with the largest number of nines and that is less than p by no more than d.
The required number shouldn't have leading zeroes.
Examples
Input
1029 102
Output
999
Input
27191 17
Output
27189
Submitted Solution:
```
a,b=map(int,input().split())
#print(len(str(a)))
t=a
s=a
a=str(s)
p=t
for i in range(len(a)-1,0,-1):
if a[i]=='9':
continue
else:
x=9-int(a[i])
s=s-10**(len(a)-i)+x*10**(len(a)-i-1)
#print(s,t-s)
if t-s>b:
print(p)
exit()
p=a
a=str(s)
#break
print(s)
```
No
| 2,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera has n counters numbered from 1 to n. Some of them are connected by wires, and each of the counters has a special button.
Initially, all the counters contain number 0. When you press a button on a certain counter, the value it has increases by one. Also, the values recorded in all the counters, directly connected to it by a wire, increase by one.
Valera and Ignat started having a dispute, the dispute is as follows. Ignat thought of a sequence of n integers a1, a2, ..., an. Valera should choose some set of distinct counters and press buttons on each of them exactly once (on other counters the buttons won't be pressed). If after that there is a counter with the number i, which has value ai, then Valera loses the dispute, otherwise he wins the dispute.
Help Valera to determine on which counters he needs to press a button to win the dispute.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105), that denote the number of counters Valera has and the number of pairs of counters connected by wires.
Each of the following m lines contains two space-separated integers ui and vi (1 β€ ui, vi β€ n, ui β vi), that mean that counters with numbers ui and vi are connected by a wire. It is guaranteed that each pair of connected counters occurs exactly once in the input.
The last line contains n space-separated integers a1, a2, ..., an (0 β€ ai β€ 105), where ai is the value that Ignat choose for the i-th counter.
Output
If Valera can't win the dispute print in the first line -1.
Otherwise, print in the first line integer k (0 β€ k β€ n). In the second line print k distinct space-separated integers β the numbers of the counters, where Valera should push buttons to win the dispute, in arbitrary order.
If there exists multiple answers, you are allowed to print any of them.
Examples
Input
5 5
2 3
4 1
1 5
5 3
2 1
1 1 2 0 2
Output
2
1 2
Input
4 2
1 2
3 4
0 0 0 0
Output
3
1 3 4
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
from queue import Queue
n,m = map(int,input().split())
e = [[]for i in range(n+1)]
b = [0]*n
for i in range(m):
u,v = map(int,input().split())
e[u-1].append(v-1)
e[v-1].append(u-1)
ans = 0
q = Queue()
a = input().split()
ai = [-1]*n
c=0
mask = [False]*n
for i in a:
inti = int(i)
ai[c] = inti
if inti == 0:
q.put(c)
b[c]=1
c+=1
T=[]
while not q.empty():
i = q._get()
ans+=1
T.append(i+1)
for j in e[i]:
b[j]+=1
if b[j]== ai[j]:
q.put(j)
print(ans)
print(*T)
```
| 2,750 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera has n counters numbered from 1 to n. Some of them are connected by wires, and each of the counters has a special button.
Initially, all the counters contain number 0. When you press a button on a certain counter, the value it has increases by one. Also, the values recorded in all the counters, directly connected to it by a wire, increase by one.
Valera and Ignat started having a dispute, the dispute is as follows. Ignat thought of a sequence of n integers a1, a2, ..., an. Valera should choose some set of distinct counters and press buttons on each of them exactly once (on other counters the buttons won't be pressed). If after that there is a counter with the number i, which has value ai, then Valera loses the dispute, otherwise he wins the dispute.
Help Valera to determine on which counters he needs to press a button to win the dispute.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105), that denote the number of counters Valera has and the number of pairs of counters connected by wires.
Each of the following m lines contains two space-separated integers ui and vi (1 β€ ui, vi β€ n, ui β vi), that mean that counters with numbers ui and vi are connected by a wire. It is guaranteed that each pair of connected counters occurs exactly once in the input.
The last line contains n space-separated integers a1, a2, ..., an (0 β€ ai β€ 105), where ai is the value that Ignat choose for the i-th counter.
Output
If Valera can't win the dispute print in the first line -1.
Otherwise, print in the first line integer k (0 β€ k β€ n). In the second line print k distinct space-separated integers β the numbers of the counters, where Valera should push buttons to win the dispute, in arbitrary order.
If there exists multiple answers, you are allowed to print any of them.
Examples
Input
5 5
2 3
4 1
1 5
5 3
2 1
1 1 2 0 2
Output
2
1 2
Input
4 2
1 2
3 4
0 0 0 0
Output
3
1 3 4
Submitted Solution:
```
from queue import Queue
n,m = map(int,input().split())
e = [[]for i in range(n+1)]
b = [0]*n
for i in range(m):
u,v = map(int,input().split())
e[u-1].append(v-1)
e[v-1].append(u-1)
ans = 0
q = Queue()
a = input().split()
ai = [-1]*n
c=0
mask = [False]*n
for i in a:
inti = int(i)
ai[c] = inti
if inti == 0:
q.put(c)
b[c]=1
c+=1
T=[]
while not q.empty():
i = q._get()
ans+=1
T.append(i+1)
for j in e[i]:
b[j]+=1
if b[j]== ai[j]:
q.put(j)
print(ans)
print(T)
```
No
| 2,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
def pklk(n):
s=n
if (n==1):
return(n)
if (n==2):
return(3)
for i in range (2,n):
s+=1+i*(n-i)
return (s+1)
n=int(input())
print(pklk(n))
```
| 2,752 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
n=int(input())
t=(n*n)+5
print(n*t//6)
```
| 2,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
n=int(input())
if n==1:
print(1)
else:
num=n
for i in range(1,n):
num+=((i+1)*(n-i)-i)
print(num)
```
| 2,754 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
num = int(input().strip())
print(sum(x*(num-x) for x in range(num))+num)
```
| 2,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
n=int(input());print((n*((n**2)+5))//6)
```
| 2,756 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
n=int(input());ans=0
if n==1:print(1)
else:
ans+=((n)*(n+1))//2
cnt=0
for i in range(n,0,-1):
ans+=cnt*(i-1)
cnt+=1
print(ans)
```
| 2,757 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
n = int(input())
result = 0
i=0
while n != 0:
result += n + (n-1)*i
n -= 1
i+=1
print(result)
```
| 2,758 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Tags: implementation, math
Correct Solution:
```
n=int(input())
ans=0
for i in range(1,n):
ans+=(i*(n-i))
print(ans+n)
```
| 2,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
n=int(input())
z=1
x=n+1
if n==1:
print('1')
else:
for y in range(n-1,1,-1):
x=x+y*z+1;
z=z+1
print(x)
```
Yes
| 2,760 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
n = int(input())
print(sum((n*(i+1)-i*(i+2))for i in range(n)))
```
Yes
| 2,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
n=int(input())
def t(n):
t=(n-1)*n/2
return t
def m(n):
x=0
for i in range(0,n):
x+=t(i)+i+1
return x
print(int(m(n)))
```
Yes
| 2,762 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
#!/usr/bin/env python3
n = int(input())
print((n - 1) * n * (n + 1) // 6 + n)
```
Yes
| 2,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
def binaryExponentiation(x,n):
res = 1
while n > 0:
if n % 2 == 1:
res = res * x
x = x * x
n = n // 2
return res
h = int(input())
if h == 1:
print(1)
else:
print(binaryExponentiation(2,h)-(h//2))
```
No
| 2,764 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
n = int(input())
print(2)
```
No
| 2,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
import math
n = int(input())
if n % 2 == 0:
print(math.floor(math.exp(n)/n))
else:
print(math.ceil(math.exp(n)/n))
```
No
| 2,766 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
n = int(input())
print(int(n*(n-1)/2+1))
```
No
| 2,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous joke programming language HQ9+ has only 4 commands. In this problem we will explore its subset β a language called HQ...
Input
The only line of the input is a string between 1 and 106 characters long.
Output
Output "Yes" or "No".
Examples
Input
HHHH
Output
Yes
Input
HQHQH
Output
No
Input
HHQHHQH
Output
No
Input
HHQQHHQQHH
Output
Yes
Note
The rest of the problem statement was destroyed by a stray raccoon. We are terribly sorry for the inconvenience.
Tags: *special, constructive algorithms
Correct Solution:
```
from collections import Counter
import re
def issquare(n):
return round(n**0.5)**2==n
def check_orig(code):
counts = Counter(code)
orig = ''
if not issquare(counts['Q']):
return ''
nq = round(counts['Q']**0.5)
if counts['H']%(nq+1) != 0:
return ''
nh = counts['H']//(nq+1)
st = 0
while st<len(code) and code[st]=='H':
st+=1
if st%2!=0:
return ''
orig+='H'*(st//2)
if st==len(code):
return orig*2
end = -1
while code[end]=='H':
end-=1
if end%2!=1:
return ''
orig_end = 'H'*(abs(end+1)//2)
qcount = 0
while qcount<nq:
if st>=len(code):
return ''
orig+=code[st]
if code[st]=='Q':
qcount+=1
st+=1
orig+=orig_end
return orig
def is_real(code,orig):
ci = 0
l = len(orig)
for oi,letter in enumerate(orig):
if letter=='H':
if code[ci]!=letter:
return False
ci+=1
elif letter=='Q':
if code[ci:ci+l]!=orig:
return False
ci+=l
return ci==len(code)
code = input()
orig = check_orig(code)
if not orig:
print("No")
elif is_real(code,orig):
print("Yes")
else:
print("No")
```
| 2,768 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous joke programming language HQ9+ has only 4 commands. In this problem we will explore its subset β a language called HQ...
Input
The only line of the input is a string between 1 and 106 characters long.
Output
Output "Yes" or "No".
Examples
Input
HHHH
Output
Yes
Input
HQHQH
Output
No
Input
HHQHHQH
Output
No
Input
HHQQHHQQHH
Output
Yes
Note
The rest of the problem statement was destroyed by a stray raccoon. We are terribly sorry for the inconvenience.
Tags: *special, constructive algorithms
Correct Solution:
```
a = input()
b = []
h = ''
c = 0
for i in a:
if i == 'Q':
c += 1
if c == 0:
print('Yes')
exit(0)
r = -1
for i in range(1001):
if i*i == c:
r = i
break
if r == -1:
print('No')
exit(0)
h = [a.split('Q')[0], a.split('Q')[-1]]
c = [len(h[0]), len(h[1])]
if c[0] % 2 != 0 or c[1] % 2 != 0:
print('No')
exit(0)
c[0] //= 2
c[1] //= 2
resp = ''
i = c[0]
while True:
if i >= len(a):
break
if r == 0 and a[i] == 'Q':
break
resp += a[i]
if r == 0 and a[i] == 'H':
c[1] -= 1
if c[1] == 0 and r == 0:
break
if a[i] == 'Q':
r -= 1
if r == -1:
print('No')
exit(0)
i += 1
def hq(a):
resp = ''
for i in a:
if i == 'H':
resp += 'H'
else:
resp += a
return resp
if a == hq(resp):
print('Yes')
else:
print('No')
```
| 2,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The famous joke programming language HQ9+ has only 4 commands. In this problem we will explore its subset β a language called HQ...
Input
The only line of the input is a string between 1 and 106 characters long.
Output
Output "Yes" or "No".
Examples
Input
HHHH
Output
Yes
Input
HQHQH
Output
No
Input
HHQHHQH
Output
No
Input
HHQQHHQQHH
Output
Yes
Note
The rest of the problem statement was destroyed by a stray raccoon. We are terribly sorry for the inconvenience.
Tags: *special, constructive algorithms
Correct Solution:
```
import sys
s = input()
qc = s.count('Q')
qs = int(qc ** 0.5)
hc = s.count('H')
if qs == 0:
print('Yes')
sys.exit(0)
if not qc == qs ** 2:
print('No')
sys.exit(0)
if not hc % (qs + 1) == 0:
print('No')
sys.exit(0)
t = s.split('Q')
pre = len(t[0]) // 2
suf = 0 if len(t) == 1 else len(t[-1]) // 2
a = ['H' * pre] + t[1 : qs] + ['H' * suf]
o = [c for c in 'Q'.join(a)]
g = []
for c in o:
if c == 'H':
g += ['H']
else:
g += o
print('Yes' if ''.join(g) == s else 'No')
```
| 2,770 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The famous joke programming language HQ9+ has only 4 commands. In this problem we will explore its subset β a language called HQ...
Input
The only line of the input is a string between 1 and 106 characters long.
Output
Output "Yes" or "No".
Examples
Input
HHHH
Output
Yes
Input
HQHQH
Output
No
Input
HHQHHQH
Output
No
Input
HHQQHHQQHH
Output
Yes
Note
The rest of the problem statement was destroyed by a stray raccoon. We are terribly sorry for the inconvenience.
Submitted Solution:
```
text = input()
remainder = [x for x in text if x != "H" and x != "Q"]
if len(remainder) != 0: print("NO")
else:
if len(text) %2 == 0: print("YES")
else: print("NO")
```
No
| 2,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The famous joke programming language HQ9+ has only 4 commands. In this problem we will explore its subset β a language called HQ...
Input
The only line of the input is a string between 1 and 106 characters long.
Output
Output "Yes" or "No".
Examples
Input
HHHH
Output
Yes
Input
HQHQH
Output
No
Input
HHQHHQH
Output
No
Input
HHQQHHQQHH
Output
Yes
Note
The rest of the problem statement was destroyed by a stray raccoon. We are terribly sorry for the inconvenience.
Submitted Solution:
```
char = str(input())
o = 1
e = 0
t = len(char) - 1
y = len(char) - 1
if 1 <= len(char) <= 1000000 and not (len(char) % 2 == 0) and not (len(char) == 1):
while 'H' in char and 'Q' in char:
if char[e] + char[o] == "HQ" and char[t] == 'Q' or char[t] == 'H':
print("No")
elif not (char[e] + char[o] == "HQ") and char[t] == 'Q' or char[t] == 'H':
print("Yes")
e = e + 2
o = o + 2
if e == o == t:
break
break
if 1 <= len(char) <= 1000000 and len(char) % 2 == 0 and not (len(char) == 1):
while 'Q' in char and 'H' in char:
if char[e] + char[o] == "HQ":
print("NO")
else:
if not (char[e] + char[o] == "HQ") and char[y] == "H" or char[y] == "Q":
print("Yes")
e = e + 2
o = o + 2
if e == o == y:
break
break
if 1 <= len(char) <= 1000000 and len(char) == 1:
if 'Q' or 'H' in char and char[e] == 'Q' or char[e] == 'H':
print("Yes")
if 1 <= len(char) <= 1000000 and not (len(char) % 2 == 0):
while 'H' in char and not (len(char) == 1) and not ('Q' in char):
if char[e] + char[o] == "HH" and char[t] == 'H':
print("Yes")
break
if 1 <= len(char) <= 1000000 and not (len(char) % 2 == 0):
while 'Q' in char and not (len(char) == 1) and not ('H' in char):
if char[e] + char[o] == "QQ" and char[t] == 'Q':
print("Yes")
break
if 1 <= len(char) <= 1000000 and (len(char) % 2 == 0) and not (len(char) == 1):
while 'Q' in char and not ('H' in char):
if char[e] + char[o] == "QQ":
print("Yes")
break
if 1 <= len(char) <= 1000000 and (len(char) % 2 == 0) and not (len(char) == 1):
while 'H' in char and not ('Q' in char):
if char[e] + char[o] == "HH":
print("Yes")
break
```
No
| 2,772 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The famous joke programming language HQ9+ has only 4 commands. In this problem we will explore its subset β a language called HQ...
Input
The only line of the input is a string between 1 and 106 characters long.
Output
Output "Yes" or "No".
Examples
Input
HHHH
Output
Yes
Input
HQHQH
Output
No
Input
HHQHHQH
Output
No
Input
HHQQHHQQHH
Output
Yes
Note
The rest of the problem statement was destroyed by a stray raccoon. We are terribly sorry for the inconvenience.
Submitted Solution:
```
from collections import Counter
s = list(input())
cnt = Counter(s)
tr = False
for i in cnt.values():
if i % 2 != 0:
tr = True
break
if tr == False:
print("Yes")
else:
print("No")
```
No
| 2,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The famous joke programming language HQ9+ has only 4 commands. In this problem we will explore its subset β a language called HQ...
Input
The only line of the input is a string between 1 and 106 characters long.
Output
Output "Yes" or "No".
Examples
Input
HHHH
Output
Yes
Input
HQHQH
Output
No
Input
HHQHHQH
Output
No
Input
HHQQHHQQHH
Output
Yes
Note
The rest of the problem statement was destroyed by a stray raccoon. We are terribly sorry for the inconvenience.
Submitted Solution:
```
x = input().strip()
if len(x) % 2 == 0:
print("Yes")
else:
print("No")
```
No
| 2,774 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
arr=[int(i) for i in input().split()]
p=1
ans=0
for i in range(m):
if arr[i]<p:
ans+=n-(p-arr[i])
p=arr[i]
elif arr[i]>p:
ans+=arr[i]-p
p=arr[i]
print(ans)
```
| 2,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
while(1):
try:
n,m=map(int,input().split())
a=list(map(int,input().split()))
tt=a[0]-1
for i in range(1,len(a)):
if a[i]<a[i-1]:
tt+=n-a[i-1]+a[i]
else:
tt+=a[i]-a[i-1]
print(tt)
except EOFError:
break
```
| 2,776 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
m,n = list(map(int, input().split()))
na = list(map(int, input().split()))
a = [1]
a.extend(na)
ans = 0
for i in range(len(a)-1):
if a[i+1] - a[i] >=0:
ans += a[i+1] - a[i]
else:
ans += a[i+1]+m - a[i]
print(ans)
```
| 2,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
a=list(map(int,input().split()))
k=0
for i in range(1,len(a)):
if (a[i]<a[i-1]):
k+=n
c=k-1+a[-1]%n
if (a[-1]%n==0):
print(c+n)
else:
print(c)
```
| 2,778 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
R = lambda: list(map(int, input().split()))
n, m = R()
a = R()
d = lambda i, j: (n - i + j) % n
print(a[0] - 1 + sum(d(a[i], a[i + 1]) for i in range(m - 1)))
```
| 2,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
last=1
out=0
for i in a:
if i>=last:
out+=i-last
else:
out+=i+n-last
last=i
print(out)
```
| 2,780 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
a,b=map(int,input().split())
c=list(map(int,input().split()))
k=int(0)
x=int(1)
while x<b:
if c[x]-c[x-1]>=0:
k=k+c[x]-c[x-1]
else:
k=k+a-abs(c[x]-c[x-1])
x=x+1
print(k+c[0]-1)
```
| 2,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split())
ans, loc = 0, 1
homes = list(map(int, input().split()))
for dest in homes:
if(dest >= loc):
ans += dest - loc
else:
ans += n - loc + dest
loc = dest
print(ans)
```
| 2,782 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
n,m=input().split()
m=int(m)
n=int(n)
Ar=[]
for x in input().split():
Ar.append(int(x))
Cl=1
T=0
for i in Ar:
t=i-Cl
if t<0:
t+=n
Cl=i
T+=t
print(T)
```
Yes
| 2,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
n, m = map(int, input().split())
lst = list(map(int, input().split()))
ans = lst[0]
for i in range(1, m):
if lst[i] > lst[i-1]:
ans += lst[i] - lst[i-1]
elif lst[i] < lst[i-1]:
ans += n - lst[i-1] + lst[i]
print(ans-1)
```
Yes
| 2,784 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
n,m=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
for i in range(len(a)):
if i==0:
time=a[i]-1
continue
if a[i]<a[i-1]:
time+=n-a[i-1]+a[i]
else:
time+=a[i]-a[i-1]
print(time)
```
Yes
| 2,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
#https://codeforces.com/problemset/problem/339/B
#runtime error
'''
from sys import stdin
n, m = [int(c) for c in stdin.readline().split()]
d = [int(c) for c in stdin.readline().split()]
t = 1
count = 0
i = 0
l = len(d)
while i < l:
if t == d[i]:
i = i + 1
continue
t = t % n + 1
count = count + 1
print(count)
'''
from sys import stdin
n, m = [int(c) for c in stdin.readline().split()]
d = [int(c) for c in stdin.readline().split()]
t = 1
count = 0
l = len(d)
for x in d:
if t == x:
continue
elif t<x:
count = count + x - t
else:
count = count + n - t + x
t = x
print(count)
```
Yes
| 2,786 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
n,m=map(int, input().split(" "))
a=[1]+list(map(int, input().split(" ")))
sum=0
for i in range(m-1):
if a[i]>a[i-1]:
sum=sum+(a[i] - a[i-1])
elif a[i] < a[i-1]:
sum=sum+(n-(a[i-1]-a[i]))
print(sum)
```
No
| 2,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
s=k=0
n,m=map(int,input().split())
trouble=[int(x) for x in input().split()]
if sum(trouble)==m:
print(0)
else:
for i in range(m-1):
if trouble[i]==trouble[i+1]:
trouble[i]=0
for i in range(1,n+1):
if s<=trouble.count(i):
s=trouble.count(i)
k=i
print(n*(s-1)+k-1)
```
No
| 2,788 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
n, m = map(int, input().split())
works = list(map(int, input().split()))
ans = 0
current_home = 1
for i in works:
ans += current_home - 1 + i - 1 if current_home > i else i - current_home
current_home = i
print(ans)
```
No
| 2,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia lives in a city that has n houses built along the main ringroad. The ringroad houses are numbered 1 through n in the clockwise order. The ringroad traffic is one way and also is clockwise.
Xenia has recently moved into the ringroad house number 1. As a result, she's got m things to do. In order to complete the i-th task, she needs to be in the house number ai and complete all tasks with numbers less than i. Initially, Xenia is in the house number 1, find the minimum time she needs to complete all her tasks if moving from a house to a neighboring one along the ringroad takes one unit of time.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105). The second line contains m integers a1, a2, ..., am (1 β€ ai β€ n). Note that Xenia can have multiple consecutive tasks in one house.
Output
Print a single integer β the time Xenia needs to complete all tasks.
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.
Examples
Input
4 3
3 2 3
Output
6
Input
4 3
2 3 3
Output
2
Note
In the first test example the sequence of Xenia's moves along the ringroad looks as follows: 1 β 2 β 3 β 4 β 1 β 2 β 3. This is optimal sequence. So, she needs 6 time units.
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Dec 17 14:20:05 2018
@author: umang
"""
n, m = map(int, input().split())
a = list(map(int, input().split()))
cur_time = 0
prev = a[0]
for i in a[1:]:
if i < prev:
prev = i
cur_time += n + i - 1
else:
cur_time += i - prev
prev = i
print(cur_time)
```
No
| 2,790 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko has an array that consists of integers: a1, a2, ... , an. But he doesnβt like this array at all.
Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:
<image> The less value c(a) is, the more beautiful the array is.
Itβs time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.
Help Levko and calculate what minimum number c(a) he can reach.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 β€ ai β€ 109).
Output
A single number β the minimum value of c(a) Levko can get.
Examples
Input
5 2
4 7 4 7 4
Output
0
Input
3 1
-100 0 100
Output
100
Input
6 3
1 2 3 7 8 9
Output
1
Note
In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.
In the third sample he can get array: 1, 2, 3, 4, 5, 6.
Submitted Solution:
```
def f(A, k1, i):
global Min
if i == n + 1:
Sum = 0
for i in range(1, n):
Sum = max(abs(A[i + 1] - A[i]), Sum)
if Sum == 0:
print(A)
if Sum < Min:
Min = Sum
return
if k1 < k:
a = A[i]
A[i] = A[i - 1]
x1 = f(A, k1 + 1, i + 1)
A[i] = a
x2 = f(A, k1, i + 1)
n, k = map(int, input().split())
A1 = [0] + list(map(int, input().split())) + [0]
Min = 10**10
f(A1, 0, 1)
print(Min)
```
No
| 2,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko has an array that consists of integers: a1, a2, ... , an. But he doesnβt like this array at all.
Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:
<image> The less value c(a) is, the more beautiful the array is.
Itβs time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.
Help Levko and calculate what minimum number c(a) he can reach.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 β€ ai β€ 109).
Output
A single number β the minimum value of c(a) Levko can get.
Examples
Input
5 2
4 7 4 7 4
Output
0
Input
3 1
-100 0 100
Output
100
Input
6 3
1 2 3 7 8 9
Output
1
Note
In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.
In the third sample he can get array: 1, 2, 3, 4, 5, 6.
Submitted Solution:
```
import sys
import math
MAX = int(1e9)
MIN = int(1e9)
N = 2000
def reset(dp):
for i in range(1, N):
# Can always change all preceding entries
dp[i] = i
def check(n, k, arr, c, dp):
# dp[i]: minimum # of changes to make cost under c and i is unchanged.
reset(dp)
for i in range(1, n):
for j in range(0, i):
# Check if I can update the dp if arr[i] and arr[j] are kept unchanged
# Number of changeable spaces I have
have = i - j - 1
if c:
# Number of changeable spaces I need
needed = math.ceil(abs(arr[i] - arr[j]) / c) - 1
else:
# Can only change if arr[i] and arr[j] are the same if c == 0
needed = have + int(arr[i] != arr[j])
# Can only update dp if I have enough changeable spaces
if needed <= have:
dp[i] = min(dp[i], dp[j] + have)
return dp[n-1] <= k
def main():
# Parse input
lines = sys.stdin.readlines()
l1, l2 = lines[0], lines[1]
n, k = [int(x) for x in l1.strip().split(' ')]
arr = [int(x) for x in l2.strip().split(' ')]
dp = [0 for _ in range(N)]
# Binary search on c
lo = 0
hi = 2 * MAX
while lo < hi:
c = (lo + hi) // 2
valid = check(n, k, arr, c, dp)
if valid:
hi = c
else:
lo = c + 1
print(lo)
if __name__ == '__main__':
main()
```
No
| 2,792 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko has an array that consists of integers: a1, a2, ... , an. But he doesnβt like this array at all.
Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:
<image> The less value c(a) is, the more beautiful the array is.
Itβs time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.
Help Levko and calculate what minimum number c(a) he can reach.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 β€ ai β€ 109).
Output
A single number β the minimum value of c(a) Levko can get.
Examples
Input
5 2
4 7 4 7 4
Output
0
Input
3 1
-100 0 100
Output
100
Input
6 3
1 2 3 7 8 9
Output
1
Note
In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.
In the third sample he can get array: 1, 2, 3, 4, 5, 6.
Submitted Solution:
```
def f(A, k1, i):
global Min
if i == n + 1:
Sum = 0
for i in range(1, n):
Sum = max(abs(A[i + 1] - A[i]), Sum)
if Sum < Min:
Min = Sum
return
if k1 < k:
a = A[i]
A[i] = A[i - 1]
if i == 1:
A[i] = A[i + 1]
x1 = f(A, k1 + 1, i + 1)
A[i] = a
x2 = f(A, k1, i + 1)
n, k = map(int, input().split())
A1 = [0] + list(map(int, input().split())) + [0]
Min = 10**10
f(A1, 0, 1)
print(Min)
```
No
| 2,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko has an array that consists of integers: a1, a2, ... , an. But he doesnβt like this array at all.
Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:
<image> The less value c(a) is, the more beautiful the array is.
Itβs time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.
Help Levko and calculate what minimum number c(a) he can reach.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 β€ ai β€ 109).
Output
A single number β the minimum value of c(a) Levko can get.
Examples
Input
5 2
4 7 4 7 4
Output
0
Input
3 1
-100 0 100
Output
100
Input
6 3
1 2 3 7 8 9
Output
1
Note
In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.
In the third sample he can get array: 1, 2, 3, 4, 5, 6.
Submitted Solution:
```
def f(A, k1, i):
global Min
if i == n + 1:
Sum = 0
for i in range(1, n):
Sum = max(abs(A[i + 1] - A[i]), Sum)
if Sum < Min:
Min = Sum
return
if k1 < k:
a = A[i]
A[i] = A[i - 1]
x1 = f(A, k1 + 1, i + 1)
A[i] = a
x2 = f(A, k1, i + 1)
n, k = map(int, input().split())
A1 = [0] + list(map(int, input().split())) + [0]
Min = 10**10
f(A1, 0, 1)
print(Min)
```
No
| 2,794 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The bear has a string s = s1s2... s|s| (record |s| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices i, j (1 β€ i β€ j β€ |s|), that string x(i, j) = sisi + 1... sj contains at least one string "bear" as a substring.
String x(i, j) contains string "bear", if there is such index k (i β€ k β€ j - 3), that sk = b, sk + 1 = e, sk + 2 = a, sk + 3 = r.
Help the bear cope with the given problem.
Input
The first line contains a non-empty string s (1 β€ |s| β€ 5000). It is guaranteed that the string only consists of lowercase English letters.
Output
Print a single number β the answer to the problem.
Examples
Input
bearbtear
Output
6
Input
bearaabearc
Output
20
Note
In the first sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9).
In the second sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).
Tags: brute force, greedy, implementation, math, strings
Correct Solution:
```
s = input()
n = len(s)
ans = 0
lb = -1
for i in range(n - 3):
if s[i:i + 4] == 'bear':
left = i-lb
right = n - 3 - i
ans += left * right
lb = i
print(ans)
```
| 2,795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The bear has a string s = s1s2... s|s| (record |s| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices i, j (1 β€ i β€ j β€ |s|), that string x(i, j) = sisi + 1... sj contains at least one string "bear" as a substring.
String x(i, j) contains string "bear", if there is such index k (i β€ k β€ j - 3), that sk = b, sk + 1 = e, sk + 2 = a, sk + 3 = r.
Help the bear cope with the given problem.
Input
The first line contains a non-empty string s (1 β€ |s| β€ 5000). It is guaranteed that the string only consists of lowercase English letters.
Output
Print a single number β the answer to the problem.
Examples
Input
bearbtear
Output
6
Input
bearaabearc
Output
20
Note
In the first sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9).
In the second sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).
Tags: brute force, greedy, implementation, math, strings
Correct Solution:
```
s=input()
ans=0
w='bear'
cnt=s.count(w)
for i in range(cnt):
ans+=(s.index(w)+1)*(len(s)-(s.index(w)+3))
s=s[s.index(w)+1:]
print(ans)
```
| 2,796 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The bear has a string s = s1s2... s|s| (record |s| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices i, j (1 β€ i β€ j β€ |s|), that string x(i, j) = sisi + 1... sj contains at least one string "bear" as a substring.
String x(i, j) contains string "bear", if there is such index k (i β€ k β€ j - 3), that sk = b, sk + 1 = e, sk + 2 = a, sk + 3 = r.
Help the bear cope with the given problem.
Input
The first line contains a non-empty string s (1 β€ |s| β€ 5000). It is guaranteed that the string only consists of lowercase English letters.
Output
Print a single number β the answer to the problem.
Examples
Input
bearbtear
Output
6
Input
bearaabearc
Output
20
Note
In the first sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9).
In the second sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).
Tags: brute force, greedy, implementation, math, strings
Correct Solution:
```
#B. Bear and Strings
s = input()
ans = 0
for i in range(len(s)) :
part = s [i : ]
if 'bear' in part :
ans += len(part) - (part.index('bear') + 3 )
print(ans)
```
| 2,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The bear has a string s = s1s2... s|s| (record |s| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices i, j (1 β€ i β€ j β€ |s|), that string x(i, j) = sisi + 1... sj contains at least one string "bear" as a substring.
String x(i, j) contains string "bear", if there is such index k (i β€ k β€ j - 3), that sk = b, sk + 1 = e, sk + 2 = a, sk + 3 = r.
Help the bear cope with the given problem.
Input
The first line contains a non-empty string s (1 β€ |s| β€ 5000). It is guaranteed that the string only consists of lowercase English letters.
Output
Print a single number β the answer to the problem.
Examples
Input
bearbtear
Output
6
Input
bearaabearc
Output
20
Note
In the first sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9).
In the second sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).
Tags: brute force, greedy, implementation, math, strings
Correct Solution:
```
def solution():
s = input()
l = s.split('bear')
if len(l) == 1:
return 0
ans = 0
sums = []
_sum = 0
for i in range(len(l)-1):
_sum += len(l[i])
if i>=1:
_sum +=4
sums.append(_sum)
for i in range(len(l)-1):
if i==0:
ans+=(sums[i]+1)*(len(s)-sums[i]-4+1)
else:
ans+=(sums[i]-sums[i-1])*(len(s)-sums[i]-4+1)
return ans
print(solution())
```
| 2,798 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The bear has a string s = s1s2... s|s| (record |s| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices i, j (1 β€ i β€ j β€ |s|), that string x(i, j) = sisi + 1... sj contains at least one string "bear" as a substring.
String x(i, j) contains string "bear", if there is such index k (i β€ k β€ j - 3), that sk = b, sk + 1 = e, sk + 2 = a, sk + 3 = r.
Help the bear cope with the given problem.
Input
The first line contains a non-empty string s (1 β€ |s| β€ 5000). It is guaranteed that the string only consists of lowercase English letters.
Output
Print a single number β the answer to the problem.
Examples
Input
bearbtear
Output
6
Input
bearaabearc
Output
20
Note
In the first sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9).
In the second sample, the following pairs (i, j) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).
Tags: brute force, greedy, implementation, math, strings
Correct Solution:
```
z=list(map(str,input()))
x=['b','e','a','r']
a=0
ans=0
for i in range(len(z)-3):
a+=1
if z[i:i+4]==x:
ans+=(a*(len(z)-(i+4))+a)
a=0
print(ans)
```
| 2,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.