message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
Submitted Solution:
```
line = input()
n = int(input())
dp = [[[-100] * 2 for _ in range(n+1)] for _ in range(len(line)+1)]
dp[0][0][0], dp[0][0][1] = 0, 0
for i in range(1, len(line)+1):
for j in range(n+1):
for k in range(j+1):
if (line[i-1] == "F" and k % 2 == 1) or (line[i-1] == "T" and k % 2 == 0):
dp[i][j][0] = max(dp[i][j][0], dp[i-1][j-k][1])
dp[i][j][1] = max(dp[i][j][1], dp[i-1][j-k][0])
else:
dp[i][j][0] = max(dp[i][j][0], dp[i-1][j-k][0] + 1)
dp[i][j][1] = max(dp[i][j][1], dp[i-1][j-k][1] - 1)
print(max(dp[-1][-1][0], dp[-1][-1][1]))
``` | instruction | 0 | 4,330 | 3 | 8,660 |
Yes | output | 1 | 4,330 | 3 | 8,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
Submitted Solution:
```
from sys import stdin,stdout,setrecursionlimit
setrecursionlimit(10**4)
PI=float('inf')
NI=float('-inf')
for _ in range(1):#int(stdin.readline())):
s=input()
n=int(stdin.readline())
# a=list(map(int, stdin.readline().split()))
f=s.count('F')
t=s.count('T')
mn=min(f,t)
mx=max(f,t)
ans=mx
if n<=mn:
ans=max(ans,mx+2*n-mn)
if n>=mx:
op1=n-mx# Changing max
if op1&1:ans=max(ans,mn+mx-1)
else:ans=max(ans,mx+mn)
if n>=mn:
op1=n-mn
if op1&1:ans=max(ans,mx+mn-1)
else:ans=max(ans,mx+mn)
print(ans)
``` | instruction | 0 | 4,331 | 3 | 8,662 |
No | output | 1 | 4,331 | 3 | 8,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
Submitted Solution:
```
s = input()
n = int(input())
t = [j for j, q in enumerate(s) if q == 'T']
l, r = [0] * 101, [0] * 101
for i, (a, b) in enumerate(zip([-1] + t, t + [len(s)])):
v = b - a
u = v - 1
if i:
l[i] = l[i - 1] + v
r[i] = max(r[i - 1] - v, l[i - 1] - 1)
else:
u, v = -u, -v
for k in range(i - 1, 0, -1):
l[k] = max(l[k] - u, l[k - 1] - v)
r[k] = max(r[k] + u, r[k - 1] + v)
u, v = -u, -v
l[0] -= u
r[0] += u
print(max(l[n % 2:n + 1:2] + r[n % 2:n + 1:2]))
``` | instruction | 0 | 4,332 | 3 | 8,664 |
No | output | 1 | 4,332 | 3 | 8,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
Submitted Solution:
```
s = input()
n, m = int(input()), len(s)
def g(p):
t = [j for j, q in enumerate(s) if q == p] + [m]
n = len(t) + 1
l = [0] * n
r = [0] * n
a = -1
for i, b in enumerate(t):
v = b - a
u = v - 1
l[i + 1] = l[i] + v
r[i + 1] = r[i] - v
for k in range(i, 0, -1):
l[k] = max(l[k] + u, l[k - 1] - v)
r[k] = max(r[k] - u, r[k - 1] + v)
u, v = -u, -v
l[0] += u
r[0] -= u
a = b
return l, r
t, f = g('T'), g('F')
print(max(t[0][n & 1:n + 1:2] + t[1][n & 1:n + 1:2] + f[0][m - n::2] + f[1][m - n::2]))
``` | instruction | 0 | 4,333 | 3 | 8,666 |
No | output | 1 | 4,333 | 3 | 8,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
Submitted Solution:
```
import sys
ILLEGAL = 10 ** 50
moves = sys.stdin.readline().strip()
n_changes = int(sys.stdin.readline())
mem = {}
def max_distance(n_changes_left, moves, cur_direction=1):
if (n_changes_left, moves, cur_direction) in mem:
return mem[(n_changes_left, moves, cur_direction)]
if moves == "":
if n_changes_left != 0:
return ILLEGAL
return 0
if n_changes_left == 0:
if moves[0] == 'F':
result = max_distance(n_changes_left, moves[1:])
return result
else:
return max_distance(n_changes_left, moves[1:], cur_direction * -1)
else:
first_solution, second_solution = 0, 0
if moves[0] == 'F':
first_solution = max_distance(n_changes_left, moves[1:], cur_direction)
second_solution = max_distance(n_changes_left-1, moves[1:], cur_direction * -1)
if first_solution != ILLEGAL:
first_solution += cur_direction
else:
first_solution = max_distance(n_changes_left, moves[1:], cur_direction * -1)
second_solution = max_distance(n_changes_left-1, moves[1:], cur_direction)
if second_solution != ILLEGAL:
second_solution += cur_direction
if first_solution == ILLEGAL and second_solution == ILLEGAL:
return 0
if first_solution == ILLEGAL:
return second_solution
if second_solution == ILLEGAL:
return first_solution
result = 0
if abs(first_solution) > abs(second_solution):
result = first_solution
else:
result = second_solution
mem[(n_changes_left, moves, cur_direction)] = result
return result
print(max_distance(n_changes, moves))
``` | instruction | 0 | 4,334 | 3 | 8,668 |
No | output | 1 | 4,334 | 3 | 8,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
n = int(input().strip())
a = [int(ai) for ai in input().strip().split()]
l = 1
r = max(a)
asum = sum(a)
ans = 0;
while l <= r:
mid = (l + r) >> 1
if 2 * n * mid >= 2 * asum - n * n - n :
r = mid - 1
ans = mid
else:
l = mid + 1
asum = asum - (ans + ans + n - 1) * n // 2
for i in range(0, n):
a[i] = ans + int(asum > 0)
ans = ans + 1
asum = asum - 1
print(' '.join(str(ai) for ai in a))
``` | instruction | 0 | 4,375 | 3 | 8,750 |
Yes | output | 1 | 4,375 | 3 | 8,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
# Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n = int(input())
a = list(map(int,input().split()))
s = sum(a)
s -= (n * n - n) // 2
k = s // n
r = s % n
ans = []
for i in range(n):
curAns = k + i
if r > i:
curAns += 1
ans.append(str(curAns))
print(" ".join(ans))
``` | instruction | 0 | 4,376 | 3 | 8,752 |
Yes | output | 1 | 4,376 | 3 | 8,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
n=int(input())
SUM=sum(map(int,input().split()))
OK=SUM//n-n//2-10
NG=SUM//n-n//2+10
def tousa(s,n):
return (s+(s+n-1))*n//2
while NG-OK>1:
mid=(OK+NG)//2
if tousa(mid,n)>SUM:
NG=mid
else:
OK=mid
#print(OK)
rest=SUM-tousa(OK,n)
for i in range(n):
if i<rest:
sys.stdout.write(str(OK+i+1)+" ")
else:
sys.stdout.write(str(OK+i)+" ")
``` | instruction | 0 | 4,377 | 3 | 8,754 |
Yes | output | 1 | 4,377 | 3 | 8,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.buffer.readline
N = int(input())
A = list(map(int, input().split()))
S = sum(A)
k = (S - (N-1) * (N-2) // 2) % N
x = (S - (N-1) * (N-2) // 2 - k) // N
for i in range(N-1):
sys.stdout.write(str(x + i) + " ")
if i == k:
sys.stdout.write(str(x + i) + " ")
if k == N-1:
sys.stdout.write(str(x + k) + " ")
if __name__ == '__main__':
main()
``` | instruction | 0 | 4,378 | 3 | 8,756 |
Yes | output | 1 | 4,378 | 3 | 8,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
h=[int(i) for i in input().split() if i!='\n']
suma=sum(h)
lo,hi=h[0],h[-1]-n+1
while lo<hi:
mid=(lo+hi)//2
prev=max(0,mid-1)
last=mid+n-1
test=(last*(last+1))/2-(prev*(prev+1))/2
if test>suma:
hi=mid
else:
lo=mid+1
ans=[int(i) for i in range(hi,hi+n)]
diff=sum(ans)-suma
if n==300000:
print(sum(ans)-suma)
for i in range(len(ans)-1,-1,-1):
if diff>0:
ans[i]-=1
diff-=1
ans=' '.join(map(str,ans))
sys.stdout.write(ans)
``` | instruction | 0 | 4,379 | 3 | 8,758 |
No | output | 1 | 4,379 | 3 | 8,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
import sys, random
input = sys.stdin.readline
def check(arr):
for i in range(len(arr)-1):
diff = abs(arr[i] - arr[i+1])
if diff <= 2:
arr[i] += diff//2
arr[i+1] -= diff//2
return arr
if __name__ == "__main__":
n = int(input())
arr = list(map(int, input().split()))
print(*check(arr))
``` | instruction | 0 | 4,380 | 3 | 8,760 |
No | output | 1 | 4,380 | 3 | 8,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
h=[int(i) for i in input().split() if i!='\n']
suma=sum(h)
lo,hi=h[0],h[-1]-n+1
while lo<hi:
mid=(lo+hi)//2
prev=max(0,mid-1)
last=mid+n-1
test=(last*(last+1))/2-(prev*(prev+1))/2
if test>suma:
hi=mid
else:
lo=mid+1
ans=[int(i) for i in range(hi,hi+n)]
diff=sum(ans)-suma
if diff>n:
diff=diff-n
if n==300000:
print(diff)
for i in range(len(ans)-1,-1,-1):
if diff>0:
ans[i]-=1
diff-=1
else:
break
ans=' '.join(map(str,ans))
sys.stdout.write(ans)
``` | instruction | 0 | 4,381 | 3 | 8,762 |
No | output | 1 | 4,381 | 3 | 8,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 ≤ j ≤ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 ≤ j ≤ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 ≤ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 ≤ h_{j + 1} and h_{j + 1} + 2 ≤ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 ≤ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 ≤ h_1 < h_2 < ... < h_n ≤ 10^{12} — the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 ≤ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 ≤ 5 and 5 + 2 ≤ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 ≤ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 ≤ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 ≤ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7.
Submitted Solution:
```
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
n=int(input())
H=list(map(int,input().split()))
OK=0
NG=10**12
def tousa(s,n):
return (s+(s+n-1))*n//2
SUM=sum(H)
while NG-OK>1:
mid=(OK+NG)//2
if tousa(mid,n)>SUM:
NG=mid
else:
OK=mid
#print(OK)
rest=SUM-tousa(OK,n)
ANS=[OK+i+1 for i in range(n) if i<rest]
sys.stdout.write(" ".join(map(str,ANS))+"\n")
``` | instruction | 0 | 4,382 | 3 | 8,764 |
No | output | 1 | 4,382 | 3 | 8,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3 | instruction | 0 | 4,501 | 3 | 9,002 |
Tags: brute force, geometry, implementation
Correct Solution:
```
x, y = map(int, input().split())
if abs(y) >= abs(x) and y != 0:
if y > 0:
ans = 2*(2*y-1)
else:
ans = 4*abs(y)
if x == y:
print(ans-1)
else:
print(ans)
elif abs(x) >= abs(y) and x != 0:
if x > 0:
if x == 1:
ans = 0
else:
ans = 4*x-3
else:
ans = 4*abs(x)-1
if (x < 0 and x == -y) or(x > 0 and y == -abs(abs(x)-1)):
print(max(ans-1, 0))
else:
print(ans)
else:
print(0)
``` | output | 1 | 4,501 | 3 | 9,003 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3 | instruction | 0 | 4,503 | 3 | 9,006 |
Tags: brute force, geometry, implementation
Correct Solution:
```
'''input
37 -100
'''
p = [(0, 0)]
a, b = 0, 0
c = 1
while c < 202:
for i in range(c-1):
a += 1
p.append((a, b))
p.append((a+1, b, "*"))
a += 1
for j in range(c-1):
b += 1
p.append((a, b))
p.append((a, b+1, "*"))
b += 1
for k in range(c):
a -= 1
p.append((a, b))
p.append((a-1, b, "*"))
a -= 1
for l in range(c):
b -= 1
p.append((a, b))
p.append((a, b-1, "*"))
b -= 1
c += 2
x, y = map(int, input().split())
if (x, y) in p:
z = p.index((x, y))
elif (x, y, "*") in p:
z = p.index((x, y, "*"))
t = 0
for w in p[:z]:
if len(w) == 3:
t += 1
print(t)
``` | output | 1 | 4,503 | 3 | 9,007 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3 | instruction | 0 | 4,505 | 3 | 9,010 |
Tags: brute force, geometry, implementation
Correct Solution:
```
x, y = map(int, input().split())
a, b, cnt = 0, 0, 0
if x == y == 0: print(0); exit()
while(1):
while(a + b != 1):
a += 1
if a == x and b == y: print(cnt); exit()
cnt += 1
while(a - b != 0):
b += 1
if a == x and b == y: print(cnt); exit()
cnt += 1
while(a + b != 0):
a -= 1
if a == x and b == y: print(cnt); exit()
cnt += 1
while(a != b):
b -= 1
if a == x and b == y: print(cnt); exit()
cnt += 1
``` | output | 1 | 4,505 | 3 | 9,011 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
x = 0
y = 0
nx,ny = map(int,input().split())
if ((nx == 0 or nx == 1) and ny == 0):
print(0)
else:
x = 1
turn = 0
flag = 0
while True:
turn = turn + 1
while y != x:
y = y + 1
if(x == nx and y == ny):
flag = 1
break
if flag == 1:
break
k = x * -1
turn = turn + 1
while x != k:
x = x - 1
if(x == nx and y == ny):
flag = 1
break
if flag == 1:
break
turn = turn + 1
while y != x:
y = y - 1
if(x == nx and y == ny):
flag = 1
break
if flag == 1:
break
k = (x * -1) + 1
turn = turn + 1
while x != k:
x = x + 1
if(x == nx and y == ny):
flag = 1
break
if flag == 1:
break
print(turn)
``` | instruction | 0 | 4,508 | 3 | 9,016 |
Yes | output | 1 | 4,508 | 3 | 9,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
x, y = map(int, input().split())
if y > x >= -y:
print(y * 4 - 2)
elif y < x <= -y + 1:
print(-y * 4)
elif y <= x and x > -y + 1:
print(x * 4 - 3)
elif y >= x and x < -y:
print(-1 - 4 * x)
else:
print(0)
``` | instruction | 0 | 4,509 | 3 | 9,018 |
Yes | output | 1 | 4,509 | 3 | 9,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
import time
x, y = map(int, input().split())
movements = [(1,0),(0,1),(-1,0),(0,-1)]
sizeOfSteps = 1
x_0, y_0 = 0, 0
x_1, y_1 = 1, 0
step = 0
change = 1
while not(((x_0 <= x <=x_1) or (x_0 >= x >=x_1)) and ((y_0 <= y <= y_1) or (y_0 >= y >= y_1))) :
step +=1
move_i = movements[step%4]
if change%2 == 0:
sizeOfSteps += 1
change +=1
x_0, y_0 = x_1 , y_1
x_1 = x_1 + move_i[0]*sizeOfSteps
y_1 = y_1 + move_i[1]*sizeOfSteps
"""
print("Vamos en el paso: ", step)
print(x_0,y_0)
print(x_1,y_1)
time.sleep(1)
"""
print(step)
``` | instruction | 0 | 4,510 | 3 | 9,020 |
Yes | output | 1 | 4,510 | 3 | 9,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
import sys
import math
import heapq
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from sys import stdin
from functools import cmp_to_key
input=stdin.readline
m=10**9+7
sys.setrecursionlimit(10**5)
#T=int(input())
#for _ in range(T):
n,m=map(int,input().split())
x,y,c=0,0,0
if x==n and y==m:
print(c)
else:
x+=1
f1,f2,f3,f4=1,0,0,0
p,q=0,0
s=set()
s.add((1,0))
now=1
f=1
while True:
if (n,m) in s:
print(c)
break
if f1:
c+=1
y+=now
j=0
for i in range(now):
s.add((x,y+j))
j-=1
f1,f2=0,1
#print(s)
elif f2:
c+=1
now+=1
x-=now
j=0
for i in range(now):
s.add((x+j,y))
j+=1
f2,f3=0,1
elif f3:
c+=1
y-=now
j=0
for i in range(now):
s.add((x,y+j))
j+=1
f3,f4=0,1
elif f4:
c+=1
now+=1
x+=now
j=0
for i in range(now):
s.add((x+j,y))
j-=1
f4,f1=0,1
#me+=1
#print(s)
``` | instruction | 0 | 4,511 | 3 | 9,022 |
Yes | output | 1 | 4,511 | 3 | 9,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
x,y=map(int,input().split())
x1=abs(x)
y1=abs(y)
mx=max(x1,y1)
if x==1 and y==0:
print(0)
elif x==0 and y==0:
print(0)
else:
if x1==y1:
if x>0:
if y>0:
print((4*x1)-3)
elif y<0:
print(4*x1)
elif x<0:
if y>0:
print((4*x1)-2)
elif y<0:
print(4*x1-1)
elif x1!=y1:
if x1==mx:
if x>0:
print((4*x1)-3)
elif x<0:
print((4*x1)-1)
elif y1==mx:
if y>0:
print((4*y1)-2)
elif y<0:
print(4*y1)
``` | instruction | 0 | 4,512 | 3 | 9,024 |
No | output | 1 | 4,512 | 3 | 9,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
# one ride costs a rubes
inputs = list(map(int, input().split()))
x = inputs[0]
y = inputs[1]
if y==0 and x>0: print(0)
elif x==1:print(1)
elif y==1: print(2)
elif x==-1:print(3)
elif y==-1:print(4)
else:
a = max(abs(x), abs(y))
m = 1 + 4*(a-1)
if x==a:
if y==-(a-1): print(m-1)
else: print(m)
elif x==-a:
if y==a: print(m+1)
else:
print(m+1)
elif y==a:
print(m+1)
elif y==-a:
print(m+3)
``` | instruction | 0 | 4,513 | 3 | 9,026 |
No | output | 1 | 4,513 | 3 | 9,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
x,y=tuple(map(int,input().split()))
if(x==0 and y==0):
print(0)
elif(x>=0 and y>=-x+1 and y<x):
if(y==-x+1):
print(4*(x-1))
else:
print(4*(x-1)+1)
elif(y>=0 and y!=-x):
if(y==x):
print(4*(abs(y)-1)+1)
else:
print(4*(abs(y)-1)+2)
elif(x<=0 and y!=x and y<abs(x) and y>=-abs(x)+1):
if(y==-x):
print(4*(abs(x)-1)+2)
else:
print(4*(abs(x)-1)+1+2)
else:
if(y==x):
print(4*(abs(y)-1)+3)
else:
print(4*(abs(y)-1)+1+3)
``` | instruction | 0 | 4,514 | 3 | 9,028 |
No | output | 1 | 4,514 | 3 | 9,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| ≤ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3
Submitted Solution:
```
'''input
0 0
'''
def nextStep(x,y):
if x == 0 and y == 0:
return (1,0)
if x == 1 and y == 0:
return (1,1)
if x > 0 and y > 0:
return (-x, y)
if x < 0 and y > 0:
return (x, -y)
if x < 0 and y < 0:
return (-x + 1, y)
if x > 0 and y < 0:
return (x, -y + 1)
def main():
a, b = map(int, input().split())
pos = (0,0)
turns = 0
if(a == 1 and b == 0):
print(0)
return
while(pos[0] < a or pos[1] < b):
pos = nextStep(pos[0], pos[1])
turns += 1
print(turns)
if __name__ == "__main__":
main()
``` | instruction | 0 | 4,515 | 3 | 9,030 |
No | output | 1 | 4,515 | 3 | 9,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
n,d=map(int,input().split())
s=input()
i=0
j=0
flag=0
while i<n:
if i==n-1:
print(j)
break
for k in range(d,0,-1):
if i+k<n:
if s[i+k]=='1':
j+=1
i+=k
break
if k==1:
if i+k<n:
if s[i+k]!='1':
flag=1
break
else:
i+=1
break
if flag==1:
print(-1)
break
``` | instruction | 0 | 4,759 | 3 | 9,518 |
Yes | output | 1 | 4,759 | 3 | 9,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
# https://codeforces.com/contest/910/problem/A
n,k = map(int, input().split())
s = input()
count = 0
i = 0
while i != (n-1):
j = min(i+k, n-1)
while j > i and s[j] != '1':
j -=1
if i == j:
count = -1
break
else:
count += 1
i = j
print(count)
``` | instruction | 0 | 4,760 | 3 | 9,520 |
Yes | output | 1 | 4,760 | 3 | 9,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
def solve():
n, d = map(int, input().split())
n -= 1
s = input()
i = 0
res = 0
while (i < len(s)):
r = min(len(s)-1,i+d)
for j in range(r,i,-1):
if (s[j] == '1'):
i = j
res += 1
break
else:
print(-1)
return
if (i == n):
print(res)
return
solve()
``` | instruction | 0 | 4,761 | 3 | 9,522 |
Yes | output | 1 | 4,761 | 3 | 9,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
n,d=[int(i) for i in input().split()]
a=[int(i) for i in input()]
dp=[0] ; l=d ; ans=0
for i in range(1,n):
if a[i]==1:
dp.append(i)
if i==l or i==n-1:
l=dp[-1]+d
if i==l:
print(-1)
exit(0)
ans+=1
print(ans)
``` | instruction | 0 | 4,762 | 3 | 9,524 |
Yes | output | 1 | 4,762 | 3 | 9,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
n,m =map(int,input().split())
a=list(input())
i=0
ans=0
while(i+m<=n-1):
for j in range(0,m):
if(a[m+i-j]=="1"):
i=m+i-j
ans+=1
break
else:
print(-1)
exit()
print(ans)
``` | instruction | 0 | 4,763 | 3 | 9,526 |
No | output | 1 | 4,763 | 3 | 9,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
n,m=map(int,input().split())
s=input()
c=0
t=m
i=0
while i <(len(s)):
if(t!=0 and i+t in range(len(s))and(s[i+t] =='1')):
c=c+1
i=i+t
t=m
continue
else:
if(t!=0):
t=t-1
continue
else:
break
if(i==len(s)-1):
break
if(c):
print(c)
else:
print(-1)
``` | instruction | 0 | 4,764 | 3 | 9,528 |
No | output | 1 | 4,764 | 3 | 9,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
# https://codeforces.com/problemset/problem/910/A
#
# Solution is to jump to farest lilie every time.
# If imagine we have 3 lilies in order on Ox axis: A, B, C in some distances between them.
# Notice if C is reachable from A then then it is reachable from B as distance from B to C is shorter than from A to C.
# Time complexity upper bounded with O(n) - every time jump by 1. Maybe there is better limit, but this one seems to be satisfactory.
def solution(n, d, L):
current_pos = 0
jumps = 0
while current_pos < n-1:
longest_jump = min(d, n-1-current_pos)
while L[current_pos + longest_jump] != '1' and longest_jump >= 0:
longest_jump -= 1
if longest_jump == 0:
return -1
current_pos += longest_jump
jumps += 1
return jumps
if __name__ == '__main__':
(n, k) = map(int, input().split())
L = input()
print(solution(n,k,L))
# print ('Start tests..')
# assert solution(8,4,'10010101') == 2
# assert solution(4,2,'1001') == -1
# assert solution(8,4,'11100101') == 3
# assert solution(12, 3, '101111100101') == 4
# assert solution(2, 1, '11') == 1
# assert solution(3, 1, '101') == -1
# assert solution(3, 2, '101') == 1
print ('passed!')
``` | instruction | 0 | 4,765 | 3 | 9,530 |
No | output | 1 | 4,765 | 3 | 9,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
Submitted Solution:
```
n,d = map(int,input().split())
s = input()
w = [0]*n
w[0]=1
for i in range(1,n):
if s[i]=='1':
if i<=d:
for j in range(i):
w[i]+=w[j]
else:
for j in range(i-d,i):
w[i]+=w[j]
#print(w)
if w[n-1]==0:
print(-1)
else:
print(w[n-1])
``` | instruction | 0 | 4,766 | 3 | 9,532 |
No | output | 1 | 4,766 | 3 | 9,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,195 | 3 | 10,390 |
Tags: binary search, math
Correct Solution:
```
import math
from sys import stdin,stdout
import sys
import fractions
mod=1000000007
F=fractions.Fraction
t=int(stdin.readline())
while t>0:
h,c,tt=list(map(int,stdin.readline().split()))
mini=sys.maxsize
ans=0
if(2*tt>h+c):
low=1
high=1000000
mid=low+(high-low)//2
x=0
while(low<=high):
mid=low+(high-low)//2
if(mid<(h-tt)/((2*tt)-(h+c))):
x=mid
low=mid+1
else:
high=mid-1
if(mini>abs(tt-F(h*(x+1)+c*x,(2*x+1)))):
mini=abs(tt-F(h*(x+1)+c*x,(2*x+1)))
ans=2*x+1
low=1
high=1000000
mid=low+(high-low)//2
x=0
while(low<=high):
mid=low+(high-low)//2
if(mid>=(h-tt)/((2*tt)-(h+c))):
x=mid
high=mid-1
else:
low=mid+1
if(mini>abs(tt-F(h*(x+1)+c*x,(2*x+1)))):
mini=abs(tt-F(h*(x+1)+c*x,(2*x+1)))
ans=2*x+1
else:
ans=2
stdout.write(f"{ans}\n")
t-=1
``` | output | 1 | 5,195 | 3 | 10,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,196 | 3 | 10,392 |
Tags: binary search, math
Correct Solution:
```
T=int(input())
for _ in range(T):
h,c,t=map(int,input().split())
d=10**9
if t<=(h+c)/2:
print(2)
continue
k=(h-t)//(2*t-h-c)
a=abs((k*(h+c)+h)-(2*k+1)*t)*(2*k+3)
b=abs(((k+1)*(h+c)+h)-(2*k+3)*t)*(2*k+1)
print([2*k+1,2*k+3][a>b])
``` | output | 1 | 5,196 | 3 | 10,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,197 | 3 | 10,394 |
Tags: binary search, math
Correct Solution:
```
from collections import deque
import sys
def input(): return sys.stdin.readline().rstrip()
for _ in range(int(input())):
h, c, t = list(map(int, input().split()))
if (2 * t == c + h):
print(2)
continue
base = abs(h - c) // abs(2*t - c - h)
ans = 0
d = 2e18
for i in range(base - 100, base + 100):
if i < 1: continue
if i % 2 == 1 and abs((2 * t - c - h) * i + c - h) * ans < d * i:
d = abs((2 * t - c - h) * i + c - h)
ans = i
if (ans * abs(2 * t - c - h) <= abs(2 * t * ans - (c + h) * (ans - 1) - 2 * h)): ans = 2
print(ans)
``` | output | 1 | 5,197 | 3 | 10,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,198 | 3 | 10,396 |
Tags: binary search, math
Correct Solution:
```
T = int(input())
s = []
for i in range(T):
s.append(input())
for i in range(T):
h, c, t = map(int,s[i].split())
if t == h:
n = 1
elif t <= (h+c)/2:
n = 2
else:
k = (c-t)/(h+c-2*t)
n = int(2*k-1)
if n%2 == 0:
n = n+1
k = (n+1)/2
tb = (k*h + (k-1)*c) / n
n1 = n-2
k = (n1+1)/2
tb1 = (k*h + (k-1)*c) / n1
n2 = n+2
k = (n2+1)/2
tb2 = (k*h + (k-1)*c) / n2
if abs(t-tb1)<abs(t-tb) and abs(t-tb1)<abs(t-tb2):
n = n1
if abs(t-tb2)<abs(t-tb) and abs(t-tb2)<abs(t-tb1):
n = n2
print(n)
``` | output | 1 | 5,198 | 3 | 10,397 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,199 | 3 | 10,398 |
Tags: binary search, math
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
nTests=int(input())
for _ in range(nTests):
h,c,t=[int(zz) for zz in input().split()]
#Observe that for every nHot==nCold (nCups//2==0), finalt=(h+c)/2.
#if t<=(h+c)/2, ans=2
#else, find temp(nHot) just larger than t and find temp(nHot+1) or temp(nHot) is closer
if t<=(h+c)/2:
print(2)
elif t==h:
print(1)
else:
nHot=(t-c)//(2*t-h-c)
x=nHot
den1=2*x-1;den2=2*x+1
num1=abs(x*h+(x-1)*c-t*den1);num2=abs((x+1)*h+x*c-t*den2)
if num1*den2<=num2*den1:
print(2*x-1)
else:
print(2*x+1)
``` | output | 1 | 5,199 | 3 | 10,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,200 | 3 | 10,400 |
Tags: binary search, math
Correct Solution:
```
for _ in range(int(input())):
h,c,t=[int(c) for c in input().split()]
if t <= (h + c)/2:
print(2)
else:
##finding k
a=h-t
b=2*t - h-c
k=2*(a//b) +1
# k = ( t - h) // (h+c - 2*t)
##comparing k and k + 1
a =abs((k//2)*c + ((k+1)//2)*h - t*k)
# a=abs(a)
b= abs(((k+2)//2)*c + ((k+3)//2)*h - t*(k+2))
if a*(k+2) <= b*(k) :
ans=k
else:
ans=k + 2
print(ans)
``` | output | 1 | 5,200 | 3 | 10,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,201 | 3 | 10,402 |
Tags: binary search, math
Correct Solution:
```
try:
for _ in range(int(input())):
h,c,t=map(int,input().split())
if h<=t:
print(1)
elif h+c>=2*t:
print(2)
else:
x=int((c-t)/(h+c-2*t))
m=abs((x*(h+c-2*t)+t-c)/(2*x-1))
n=abs(((x+1)*(h+c-2*t)+t-c)/(2*(x+1)-1))
if m<=n:
print(2*x-1)
else:
print(2*x+1)
except:
pass
``` | output | 1 | 5,201 | 3 | 10,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t. | instruction | 0 | 5,202 | 3 | 10,404 |
Tags: binary search, math
Correct Solution:
```
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
from sys import stdin
def run(h, c, t):
if (h + c - 2 * t) >= 0:
return 2
a = h - t
b = 2 * t - h - c
k = int(a / b)
val1 = abs((k + 1) * h + k * c - (2 * k + 1) * t)
val2 = abs((k + 2) * h + (k + 1) * c - (2 * k + 3) * t)
# val1 / (2k+1) <= val2 / (2k+3), return 2k+1
# print(val1, val2)
if val1 * (2 * k + 3) <= val2 * (2 * k + 1):
ans = 2 * k + 1
else:
ans = 2 * k + 3
return ans
def main():
cases = int(stdin.readline())
for _ in range(cases):
h, c, t = [int(x) for x in stdin.readline().split()]
ans = run(h, c, t)
print(ans)
if __name__ == '__main__':
import os
if os.path.exists('tmp.in'):
stdin = open('tmp.in')
main()
``` | output | 1 | 5,202 | 3 | 10,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
for _ in range(int(input())):
h, c, t = map(int, input().split())
if h==t:
print(1)
elif (t-c<=h-t):
print(2)
else:
temp = (t-h)/(h+c-2*t)
if (int(temp)==temp):
print(int(2*temp+1))
else:
a = int(temp)
b = a+1
if 2*t*(2*a+1)*(2*b+1) >= (2*b+1)*((a+1)*h+a*c)+(2*a+1)*((b+1)*h+b*c):
print(2*a+1)
else:
print(2*b+1)
# temp = round(abs((t-h)/(h+c-2*t)))
# print(2*temp+1)
# else:
# t1 = round(temp)
# print(2*t1+1)
# t1 = int(temp)
# m1 = ((t1+1)*c + (t1+2)*h)/(2*t1+3) - t
# m2 = (t1*c + (t1+1)*h)/(2*t1+1) - t
# print(m1, m2)
# if abs(m1)<abs(m2):
# print(2*t1 + 3)
# else:
# print(2*t1 + 1)
``` | instruction | 0 | 5,203 | 3 | 10,406 |
Yes | output | 1 | 5,203 | 3 | 10,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
# abs((desired*(2*n + 1) - ((n+1)*hot + n*cold))/(2*n + 1))
#EXPERIMENTING WITH LOSS DEFINTION - float ops ko aage peeche kar diya
import sys
def input():
return sys.stdin.readline().rstrip()
testcases = int(input())
answers = []
def loss(two_n_plus_one, hot, cold, desired):
n = two_n_plus_one//2
# if n == 0:
# return float('inf')
# else:
# return abs(desired - ((n+1)*hot + n*cold)/(2*n + 1))
return abs((desired*(2*n + 1) - ((n+1)*hot + n*cold))/(2*n + 1))
for _ in range(testcases):
hot, cold, desired_temp = [int(i) for i in input().split()]
#required number of cups to get it to desired_temp
mid_way = (hot + cold)/2
if hot == cold:
answers.append(1)
elif desired_temp >= hot:
answers.append(1)
elif desired_temp <= mid_way:
answers.append(2)
else:
#find n, -> num iters
#n + 1 hots, n colds
frac = (hot - desired_temp) / (desired_temp - mid_way)
frac /= 2
# option1 = int(frac)
option1 = 2*(int(frac)) + 1
option2 = option1 + 2
l1 , l2 = loss(option1, hot, cold, desired_temp),loss(option2, hot, cold, desired_temp)
if min(l1, l2) >= (hot - desired_temp) and (hot -desired_temp) <= (desired_temp - mid_way):
answers.append(1)
elif min(l1, l2) >= (desired_temp - mid_way):
answers.append(2)
elif l1 <= l2:
answers.append(option1)
else:
answers.append(option2)
# if option1%2 == 0:
# option1 += 1 #taki odd ho jaye
# option2 = option1 - 2
# option3 = option1 + 2
# l1, l2, l3 = loss(option1, hot, cold, desired_temp),loss(option2, hot, cold, desired_temp),loss(option3, hot, cold, desired_temp)
# option4 = option1 - 1
# answers.append(min(loss(option1, hot, cold, desired_temp),
# loss(option2, hot, cold, desired_temp),
# loss(option3, hot, cold, desired_temp)))
print(*answers, sep = '\n')
``` | instruction | 0 | 5,204 | 3 | 10,408 |
Yes | output | 1 | 5,204 | 3 | 10,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
T = int(input())
for _ in range(T):
h,c,t = map(int,input().split())
if h+c >= 2*t:
print(2)
else:
x = (h-t)//(2*t-c-h)
y = x+1
if abs(h*(x+1)+c*x-t*(2*x+1))*(2*y+1) <= abs(h*(y+1)+c*y-t*(2*y+1))*(2*x+1):
print(2*x+1)
else:
print(2*y+1)
``` | instruction | 0 | 5,205 | 3 | 10,410 |
Yes | output | 1 | 5,205 | 3 | 10,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def foo(h,c,n):
return (n*h+(n-1)*c)/(2*n-1)
def bar(h,c,t,n):
return (n*h+(n-1)*c)==t*(2*n-1)
ttt = inn()
for tt in range(ttt):
h,c,t = inm()
if 5*h+c<=6*t:
print(1)
elif 2*t<=(h+c):
print(2)
else:
mn = 1
mx = 10**16
found = False
while mx-mn>1:
mid = (mn+mx)//2
if bar(h,c,t,mid):
found = True
break
elif foo(h,c,mid)<t:
mx = mid
else:
mn = mid
if found:
#ddprint(f"found")
print(2*mid-1)
continue
#tn = foo(h,c,mn)
#tx = foo(h,c,mx)
#if abs(tn-t)>abs(tx-t):
x = 2*(2*mn-1)*(2*mx-1)*t
y = (2*mx-1)*(mn*h+(mn-1)*c) + (2*mn-1)*(mx*h+(mx-1)*c)
#ddprint(f"mn {mn} mx {mx} x {x} y {y}")
if x<y:
print(2*mx-1)
else:
print(2*mn-1)
``` | instruction | 0 | 5,206 | 3 | 10,412 |
Yes | output | 1 | 5,206 | 3 | 10,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
from math import ceil
a = int(input())
for _ in range(a):
b,c,d = map(int,input().split())
if b >= d and c >= d:
if b > c:
print(2)
else:
print(1)
elif b <= d and c <= d:
if b < c:
print(2)
else:
print(1)
else:
t = b - d
z = d - c
if t >= z:
print(2)
else:
print(1 + 2 * ceil((t / (z - t)) - 0.5))
``` | instruction | 0 | 5,207 | 3 | 10,414 |
No | output | 1 | 5,207 | 3 | 10,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
from sys import stdin, stdout
import math
def calc(h, c, t, n):
d = (h*(n+1)+c*n)/(2*n+1)-t
return abs(d)
t = int(stdin.readline())
for _ in range(t):
h, c, t = map(int, stdin.readline().split())
if t >= h:
print(1)
continue
if t <= (h+c)/2:
print(2)
continue
n = math.ceil((h-t)/(2*t-h-c))
d0, d1, d2, d3, d4 = calc(h, c, t, n-2), calc(h, c, t, n-1), calc(h, c, t, n), calc(h, c, t,n+1), calc(h, c, t, n+2)
md = min(d1, d2, d3)
if md == d0:
print(2*n-3)
elif md == d1:
print(2*n-1)
elif md == d2:
print(2*n+1)
elif md == d3:
print(2*n+3)
else:
print(2*n+5)
``` | instruction | 0 | 5,208 | 3 | 10,416 |
No | output | 1 | 5,208 | 3 | 10,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
def I(): return(list(map(int,input().split())))
def sieve(n):
a=[1]*n
for i in range(2,n):
if a[i]:
for j in range(i*i,n,i):
a[j]=0
return a
for __ in range(int(input())):
h,c,t=I()
# for n in range(1,22,2):
# if n%2:
# avg=(h+c*(n-1)//2+h*(n-1)//2)/n
# else:
# avg=(h*n//2+c*n//2)/n
# print(avg-(h+c)/2,n)
if h==t:
print(1)
continue
if (h+c)/2>=t:
print(2)
continue
# if (h+c)/2>t:
# if (h+c)/2<h:
# print(2)
# else:
# print(1)
# continue
l=1
r=10**30
ans=10**100
# print("---------")
left=t-(h+c)/2
# print(left)
while(l<=r):
mid=(l+r)//2
n=mid
delta=(h-c)/(2*(2*n+1))
# print(mid)
# print(delta,2*n+1)
if delta==left:
ans=n
break
if delta<left:
ans=n
r=mid-1
else:
l=mid+1
n=ans
delta1=(h-c)/(2*(2*n+1))
delta2=(h-c)/(2*(2*n+3))
if abs(delta1-left)<=abs(delta2-left):
print(2*n+1)
else:
print(2*n+3)
# print(2*ans+1)
# print("---------")
``` | instruction | 0 | 5,209 | 3 | 10,418 |
No | output | 1 | 5,209 | 3 | 10,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two infinite sources of water:
* hot water of temperature h;
* cold water of temperature c (c < h).
You perform the following procedure of alternating moves:
1. take one cup of the hot water and pour it into an infinitely deep barrel;
2. take one cup of the cold water and pour it into an infinitely deep barrel;
3. take one cup of the hot water ...
4. and so on ...
Note that you always start with the cup of hot water.
The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.
You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.
How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.
Input
The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.
Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.
Output
For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.
Example
Input
3
30 10 20
41 15 30
18 13 18
Output
2
7
1
Note
In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.
In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.
In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
Submitted Solution:
```
import sys,math
input=sys.stdin.readline
T=int(input())
for _ in range(T):
n,m,t=map(int,input().split())
diff=abs(t-((n+m)/2))
fv=2
if (2*t==(n+m)):
print(2)
else:
val=(n-t)/((2*t)-(n+m))
val=math.floor((2*val)+1)
if (val<0):
print(2)
elif (val%2==0):
x=(val-2)//2
v=((n+x*(n+m))/((2*x)+1))
v=abs(v-t)
if (v<diff):
fv=(2*x)+1
diff=v
elif (v==diff):
fv=min(fv,(2*x)+1)
diff=v
x=x+1
v=abs((n+x*(n+m))/((2*x)+1))
v=abs(v-t)
if (v<diff):
fv=(2*x)+1
diff=v
elif (v==diff):
fv=min(fv,(2*x)+1)
diff=v
print(fv)
else:
x=(val-1)//2
v=abs((n+x*(n+m))/((2*x)+1))
v=abs(v-t)
if (v<diff):
fv=(2*x)+1
diff=v
elif (v==diff):
fv=min(fv,(2*x)+1)
diff=v
x=x+1
v=abs((n+x*(n+m))/((2*x)+1))
v=abs(v-t)
if (v<diff):
fv=(2*x)+1
diff=v
elif (v==diff):
fv=min(fv,(2*x)+1)
diff=v
if (x-2>0):
x=x-2
v=abs((n+x*(n+m))/((2*x)+1))
v=abs(v-t)
if (v<diff):
fv=(2*x)+1
diff=v
elif (v==diff):
fv=min(fv,(2*x)+1)
diff=v
print(fv)
``` | instruction | 0 | 5,210 | 3 | 10,420 |
No | output | 1 | 5,210 | 3 | 10,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sarah has always been a lover of nature, and a couple of years ago she saved up enough money to travel the world and explore all the things built by nature over its lifetime on earth. During this time she visited some truly special places which were left untouched for centuries, from watching icebergs in freezing weather to scuba-diving in oceans and admiring the sea life, residing unseen. These experiences were enhanced with breathtaking views built by mountains over time and left there for visitors to see for years on end. Over time, all these expeditions took a toll on Sarah and culminated in her decision to settle down in the suburbs and live a quiet life.
However, as Sarah's love for nature never faded, she started growing flowers in her garden in an attempt to stay connected with nature. At the beginning she planted only blue orchids, but over time she started using different flower types to add variety to her collection of flowers. This collection of flowers can be represented as an array of N flowers and the i-th of them has a type associated with it, denoted as A_i. Each resident, passing by her collection and limited by the width of his view, can only see K contiguous flowers at each moment in time. To see the whole collection, the resident will look at the first K contiguous flowers A_1, A_2, ..., A_K, then shift his view by one flower and look at the next section of K contiguous flowers A_2, A_3, ..., A_{K+1} and so on until they scan the whole collection, ending with section A_{N-K+1}, ..., A_{N-1}, A_N.
Each resident determines the beautiness of a section of K flowers as the number of distinct flower types in that section. Furthermore, the beautiness of the whole collection is calculated by summing the beautiness values of each contiguous section. Formally, beautiness B_i of a section starting at the i-th position is calculated as B_i = distinct(A_i, A_{i+1}, ..., A_{i+K-1}), and beautiness of the collection B is calculated as B=B_1 + B_2 + ... + B_{N-K+1}.
In addition, as Sarah wants to keep her collection of flowers have a fresh feel, she can also pick two points L and R, dispose flowers between those two points and plant new flowers, all of them being the same type.
You will be given Q queries and each of those queries will be of the following two types:
1. You will be given three integers L, R, X describing that Sarah has planted flowers of type X between positions L and R inclusive. Formally collection is changed such that A[i]=X for all i in range [L.. R].
2. You will be given integer K, width of the resident's view and you have to determine the beautiness value B resident has associated with the collection
For each query of second type print the result – beautiness B of the collection.
Input
First line contains two integers N and Q \;(1 ≤ N, Q ≤ 10^5) — number of flowers and the number of queries, respectively.
The second line contains N integers A_1, A_2, ..., A_N\;(1 ≤ A_i ≤ 10^9) — where A_i represents type of the i-th flower.
Each of the next Q lines describe queries and start with integer T∈\{1, 2\}.
* If T = 1, there will be three more integers in the line L, R, X\;(1 ≤ L, R ≤ N;\; 1 ≤ X ≤ 10^9) — L and R describing boundaries and X describing the flower type
* If T = 2, there will be one more integer in the line K\;(1 ≤ K ≤ N) — resident's width of view
Output
For each query of the second type print the beautiness B of the collection.
Example
Input
5 5
1 2 3 4 5
2 3
1 1 2 5
2 4
1 2 4 5
2 2
Output
9
6
4
Note
Let's look at the example.
Initially the collection is [1, 2, 3, 4, 5]. In the first query K = 3, we consider sections of three flowers with the first being [1, 2, 3]. Since beautiness of the section is the number of distinct flower types in that section, B_1 = 3. Second section is [2, 3, 4] and B_2 = 3. Third section is [3, 4, 5] and B_3 = 3, since the flower types are all distinct. The beautiness value resident has associated with the collection is B = B_1 + B_2 + B_3 = 3 + 3 + 3 = 9.
After the second query, the collection becomes [5, 5, 3, 4, 5].
For the third query K = 4, so we consider sections of four flowers with the first being [5, 5, 3, 4]. There are three distinct flower types [5, 3, 4] in this section, so B_1 = 3. Second section [5, 3, 4, 5] also has 3 distinct flower types, so B_2 = 3. The beautiness value resident has associated with the collection is B = B_1 + B_2 = 3 + 3 = 6
After the fourth query, the collection becomes [5, 5, 5, 5, 5].
For the fifth query K = 2 and in this case all the four sections are same with each of them being [5, 5]. Beautiness of [5, 5] is 1 since there is only one distinct element in this section [5]. Beautiness of the whole collection is B = B_1 + B_2 + B_3 + B_4 = 1 + 1 + 1 + 1 = 4
Submitted Solution:
```
#3500-3400
#https://codeforces.com/problemset/problem/1423/G
N, Q = map(int, input().split())
A = list(map(int, input().split()))[:Q]
a=A.copy()
B = []
result = []
def all_set(a, n):
while len(a)>=n:
B.append(set(a[:n]))
a.pop(0)
for query in range(N):
sets = list(map(int, input().split()))
if sets[0] == 1:
L = sets[1]
R = sets[2]
K = sets[3]
for i in range(L-1,R):
A[i] = K
a=A.copy()
#print(a)
else:
K = sets[1]
#for sub_set in range(len(A)):
all_set(a, K)
result.append(sum([len(i) for i in B]))
#print(sum([len(i) for i in B]))
#B=[]
print(result)
``` | instruction | 0 | 5,232 | 3 | 10,464 |
No | output | 1 | 5,232 | 3 | 10,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sarah has always been a lover of nature, and a couple of years ago she saved up enough money to travel the world and explore all the things built by nature over its lifetime on earth. During this time she visited some truly special places which were left untouched for centuries, from watching icebergs in freezing weather to scuba-diving in oceans and admiring the sea life, residing unseen. These experiences were enhanced with breathtaking views built by mountains over time and left there for visitors to see for years on end. Over time, all these expeditions took a toll on Sarah and culminated in her decision to settle down in the suburbs and live a quiet life.
However, as Sarah's love for nature never faded, she started growing flowers in her garden in an attempt to stay connected with nature. At the beginning she planted only blue orchids, but over time she started using different flower types to add variety to her collection of flowers. This collection of flowers can be represented as an array of N flowers and the i-th of them has a type associated with it, denoted as A_i. Each resident, passing by her collection and limited by the width of his view, can only see K contiguous flowers at each moment in time. To see the whole collection, the resident will look at the first K contiguous flowers A_1, A_2, ..., A_K, then shift his view by one flower and look at the next section of K contiguous flowers A_2, A_3, ..., A_{K+1} and so on until they scan the whole collection, ending with section A_{N-K+1}, ..., A_{N-1}, A_N.
Each resident determines the beautiness of a section of K flowers as the number of distinct flower types in that section. Furthermore, the beautiness of the whole collection is calculated by summing the beautiness values of each contiguous section. Formally, beautiness B_i of a section starting at the i-th position is calculated as B_i = distinct(A_i, A_{i+1}, ..., A_{i+K-1}), and beautiness of the collection B is calculated as B=B_1 + B_2 + ... + B_{N-K+1}.
In addition, as Sarah wants to keep her collection of flowers have a fresh feel, she can also pick two points L and R, dispose flowers between those two points and plant new flowers, all of them being the same type.
You will be given Q queries and each of those queries will be of the following two types:
1. You will be given three integers L, R, X describing that Sarah has planted flowers of type X between positions L and R inclusive. Formally collection is changed such that A[i]=X for all i in range [L.. R].
2. You will be given integer K, width of the resident's view and you have to determine the beautiness value B resident has associated with the collection
For each query of second type print the result – beautiness B of the collection.
Input
First line contains two integers N and Q \;(1 ≤ N, Q ≤ 10^5) — number of flowers and the number of queries, respectively.
The second line contains N integers A_1, A_2, ..., A_N\;(1 ≤ A_i ≤ 10^9) — where A_i represents type of the i-th flower.
Each of the next Q lines describe queries and start with integer T∈\{1, 2\}.
* If T = 1, there will be three more integers in the line L, R, X\;(1 ≤ L, R ≤ N;\; 1 ≤ X ≤ 10^9) — L and R describing boundaries and X describing the flower type
* If T = 2, there will be one more integer in the line K\;(1 ≤ K ≤ N) — resident's width of view
Output
For each query of the second type print the beautiness B of the collection.
Example
Input
5 5
1 2 3 4 5
2 3
1 1 2 5
2 4
1 2 4 5
2 2
Output
9
6
4
Note
Let's look at the example.
Initially the collection is [1, 2, 3, 4, 5]. In the first query K = 3, we consider sections of three flowers with the first being [1, 2, 3]. Since beautiness of the section is the number of distinct flower types in that section, B_1 = 3. Second section is [2, 3, 4] and B_2 = 3. Third section is [3, 4, 5] and B_3 = 3, since the flower types are all distinct. The beautiness value resident has associated with the collection is B = B_1 + B_2 + B_3 = 3 + 3 + 3 = 9.
After the second query, the collection becomes [5, 5, 3, 4, 5].
For the third query K = 4, so we consider sections of four flowers with the first being [5, 5, 3, 4]. There are three distinct flower types [5, 3, 4] in this section, so B_1 = 3. Second section [5, 3, 4, 5] also has 3 distinct flower types, so B_2 = 3. The beautiness value resident has associated with the collection is B = B_1 + B_2 = 3 + 3 = 6
After the fourth query, the collection becomes [5, 5, 5, 5, 5].
For the fifth query K = 2 and in this case all the four sections are same with each of them being [5, 5]. Beautiness of [5, 5] is 1 since there is only one distinct element in this section [5]. Beautiness of the whole collection is B = B_1 + B_2 + B_3 + B_4 = 1 + 1 + 1 + 1 = 4
Submitted Solution:
```
n,m=input().split()
n=int(n)
ans=[]
m=int(m)
result=[]
flowers=list(int(x) for x in input().split())
for i in range(n):
ins=list(int(x) for x in input().split())
k=ins[1]
if(ins[0]==1):
flowers[ins[1]-1:ins[2]]=[5]
else:
j=0
while(j+k<=len(flowers)):
dis=set(flowers[j:j+k])
result.append(len(dis))
j+=1
ans.append(sum(result))
result=[]
for i in ans:
print(i)
``` | instruction | 0 | 5,233 | 3 | 10,466 |
No | output | 1 | 5,233 | 3 | 10,467 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.