message stringlengths 2 22.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 145 109k | cluster float64 9 9 | __index_level_0__ int64 290 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,365 | 9 | 98,730 |
Tags: math
Correct Solution:
```
import sys
import math
n, k, M, D = list(map(int,sys.stdin.readline().strip().split(' ')))
maxsf = 0
for d in range(D):
x = int(math.floor(n//(k*d+1)))
maxsf = max(maxsf, min(M,x)*(d+1))
print(maxsf)
``` | output | 1 | 49,365 | 9 | 98,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,366 | 9 | 98,732 |
Tags: math
Correct Solution:
```
n, k, m, d = map(int, input().split())
ans = int(0)
for i in range(1, d + 1):
l, r, mid = 1, m + 1, 0
while l + 1 < r:
mid = (l + r) // 2
if (n - mid) // (k * mid) < i - 1:
r = mid
else:
l = mid
if (n - l) // (k * l) < i - 1:
break
ans = max(ans, l * i)
print(ans)
``` | output | 1 | 49,366 | 9 | 98,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,367 | 9 | 98,734 |
Tags: math
Correct Solution:
```
candies, people, m, d = [int(i) for i in input().split(' ')]
max_score = 0
for t in range(d):
x = candies // (people * t + 1)
x = min(x, m)
score = (t+1) * x
if score > max_score:
max_score = score
print(max_score)
``` | output | 1 | 49,367 | 9 | 98,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,368 | 9 | 98,736 |
Tags: math
Correct Solution:
```
n,k,M,D = [int(x) for x in input().split()]
tim = min(D,n//(M*k))
ans = M*tim
if tim!=D and n-M*tim*k >= M:
ans += M
for tim in range(1,D+1):
x = n//(k*tim)
if x<=M:
val = x*tim
if n-x*tim*k>=x and tim!=D:
val += x
ans = max(ans,val)
if tim!=D:
x = n//(k*tim+1)
if x<=M:
ans = max(ans,x*(tim+1))
print(ans)
``` | output | 1 | 49,368 | 9 | 98,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,369 | 9 | 98,738 |
Tags: math
Correct Solution:
```
numCandies, numPeople, maxiCandies, maxiTurn = map(int, input().split())
ans = 0
for turn in range(1, maxiTurn + 1):
maxi = maxiCandies
maxi = min(maxi, numCandies // ((turn - 1) * numPeople + 1))
if maxi == 0:
continue
if turn != (numCandies // maxi + numPeople - 1) // numPeople:
continue
x = maxi * (turn - 1) + maxi
ans = max(ans, x)
print(ans)
``` | output | 1 | 49,369 | 9 | 98,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,370 | 9 | 98,740 |
Tags: math
Correct Solution:
```
n,k,M,D=map(int,input().split())
ans=0
for d in range(1,D+1):
ans=max(ans,min(n//(k*d-k+1),M)*d);
print(ans)
``` | output | 1 | 49,370 | 9 | 98,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,371 | 9 | 98,742 |
Tags: math
Correct Solution:
```
n, k, m, d0 = list(map(int, input().split()))
ans = 0
for d in range(1, d0 + 1):
x = min(m, n // ((d - 1) * k + 1));
if (x == 0):
continue
new_d = ((n // x) + k - 1) // k
if (d != new_d):
continue
ans = max(ans, x * d)
print(ans)
``` | output | 1 | 49,371 | 9 | 98,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time. | instruction | 0 | 49,372 | 9 | 98,744 |
Tags: math
Correct Solution:
```
import sys
import math
[n, k, M, D] = list(map(int, sys.stdin.readline().split(" ")))
best = min(n, M)
for d in range(D):
ppl = d * k + 1
x = min(n // ppl, M)
best = max(best, x * (d + 1))
print(best)
``` | output | 1 | 49,372 | 9 | 98,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
n, k, M, D = map(int, input().split())
res = 0
for cnt in range(D):
res = max(res, (cnt + 1) * (min(M, n // (k * cnt + 1))))
print(res)
``` | instruction | 0 | 49,373 | 9 | 98,746 |
Yes | output | 1 | 49,373 | 9 | 98,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
n, k, m, d=map(int,input().split(' '))
t = n//m
res=0
i = 1
while(True):
kk = k*i
if(kk>=t):
res = i*min(m,n)
break
i+=1
for j in range(i,d):
kk = k*j
res = max(res,(n//(kk+1))*(j+1))
print(res)
``` | instruction | 0 | 49,374 | 9 | 98,748 |
Yes | output | 1 | 49,374 | 9 | 98,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
N, K, M, D = input().split(' ')
N = int(N)
K = int(K)
M = int(M)
D = int(D)
ans = -1
for d in range(1, D+1):
numDivisors = K * (d - 1) + 1
candiesPer = N // numDivisors
if candiesPer == 0:
continue
if candiesPer > M:
candiesPer = M
if (N // (candiesPer * K) > D):
candiesPer = N // (D * K)
ans = max(ans, candiesPer * d)
# }
print(ans)
``` | instruction | 0 | 49,375 | 9 | 98,750 |
Yes | output | 1 | 49,375 | 9 | 98,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
n, k, m, d = map(int, input().split())
res = 0
for i in range(1, d + 1):
x = n // ((i - 1) * k + 1)
x = min(x, m)
if (x == 0):
continue
if ((((n // x) - 1) // k + 1) != i):
continue
res = max(res, i * x)
print(int(res))
``` | instruction | 0 | 49,376 | 9 | 98,752 |
Yes | output | 1 | 49,376 | 9 | 98,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
n,k,M,D = [int(x) for x in input().split()]
ans = M
for tim in range(1,D+1):
x = n//k//tim
if x<=M :
val = x*tim
if n-x*tim*k>=x and tim!=D:
val += x
ans = max(ans,val)
if tim!=D:
x = n//(k*tim+1)
if x<=M:
val = x*tim
if n-x*tim>=x:
val += x
ans = max(ans,val)
print(ans)
``` | instruction | 0 | 49,377 | 9 | 98,754 |
No | output | 1 | 49,377 | 9 | 98,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
from sys import stdin
def main():
n,k,M,D = [int(x) for x in stdin.readline().rstrip().split()]
D = min(D,1000)
res = 0
if D > 1 :
for x in range(2,D+1):
res = max(M, (x*n)//((x-1)*(k+1)) )
elif D == 1:
res = M
print(str(res))
if __name__ == '__main__':
main()
``` | instruction | 0 | 49,378 | 9 | 98,756 |
No | output | 1 | 49,378 | 9 | 98,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
n, k, M, D = map(int, input().strip().split())
answer = 0
for now in range(D, 0, -1):
xmin = n // (now * k)
if n % (now * k) != 0: xmin += 1
if xmin > M: break
xmax = 0
if now - 1 == 0: xmax = M
else:
xmax = n // ((now - 1) * k)
if n % ((now - 1) * k) == 0:
xmax -= 1
xmax = min(xmax, M)
answer = max(answer, xmax * now)
print(answer)
``` | instruction | 0 | 49,379 | 9 | 98,758 |
No | output | 1 | 49,379 | 9 | 98,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
k people want to split n candies between them. Each candy should be given to exactly one of them or be thrown away.
The people are numbered from 1 to k, and Arkady is the first of them. To split the candies, Arkady will choose an integer x and then give the first x candies to himself, the next x candies to the second person, the next x candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by x) will be thrown away.
Arkady can't choose x greater than M as it is considered greedy. Also, he can't choose such a small x that some person will receive candies more than D times, as it is considered a slow splitting.
Please find what is the maximum number of candies Arkady can receive by choosing some valid x.
Input
The only line contains four integers n, k, M and D (2 ≤ n ≤ 10^{18}, 2 ≤ k ≤ n, 1 ≤ M ≤ n, 1 ≤ D ≤ min{(n, 1000)}, M ⋅ D ⋅ k ≥ n) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.
Output
Print a single integer — the maximum possible number of candies Arkady can give to himself.
Note that it is always possible to choose some valid x.
Examples
Input
20 4 5 2
Output
8
Input
30 9 4 1
Output
4
Note
In the first example Arkady should choose x = 4. He will give 4 candies to himself, 4 candies to the second person, 4 candies to the third person, then 4 candies to the fourth person and then again 4 candies to himself. No person is given candies more than 2 times, and Arkady receives 8 candies in total.
Note that if Arkady chooses x = 5, he will receive only 5 candies, and if he chooses x = 3, he will receive only 3 + 3 = 6 candies as well as the second person, the third and the fourth persons will receive 3 candies, and 2 candies will be thrown away. He can't choose x = 1 nor x = 2 because in these cases he will receive candies more than 2 times.
In the second example Arkady has to choose x = 4, because any smaller value leads to him receiving candies more than 1 time.
Submitted Solution:
```
n, k, M, D = map(int, input().split())
def f (x):
ans = n // (x * k)
if n % (x * k) >= x:
ans += 1
return ans
def calc(d):
l = 1
r = M + 1
while r - l > 1:
md = (l + r) // 2
if f(md) < d:
r = md
else:
l = md
return l
best = -1
def sol (d):
r = calc(d)
return f(r) * r
for dd in range(1, D + 1):
best = max(best, sol(dd))
print(best)
``` | instruction | 0 | 49,380 | 9 | 98,760 |
No | output | 1 | 49,380 | 9 | 98,761 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,678 | 9 | 99,356 |
Tags: binary search, greedy, implementation
Correct Solution:
```
n = int(input())
str = input()
aux = []
x =''
y =''
for i in str:
if( i == "1"):
x += i
if(y != ''):
aux.append(y)
y =''
if( i == "2"):
y += i
if(x != ''):
aux.append(x)
x = ''
if(y != ''):
aux.append(y)
if(x != ''):
aux.append(x)
maior = 0
for i in range(len(aux)-1):
cont = 0
if(len(aux[i]) > len(aux[i + 1])):
cont = len(aux[i + 1]) * 2
if(len(aux[i]) <= len(aux[i + 1])):
cont = len(aux[i]) * 2
if(cont > maior):
maior = cont
print(maior)
``` | output | 1 | 49,678 | 9 | 99,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,679 | 9 | 99,358 |
Tags: binary search, greedy, implementation
Correct Solution:
```
n = int(input())
l = input().split()
l = [int(i) for i in l]
k = []
comp = 1
for i in range(1,n) :
if l[i] == l[i-1] :
comp += 1
else :
k += [comp]
comp = 1
k += [comp]
maxi = min(k[0],k[1])
for i in range(1,len(k)-1) :
if min(k[i],k[i+1]) > maxi :
maxi = min(k[i],k[i+1])
print(maxi*2)
``` | output | 1 | 49,679 | 9 | 99,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,680 | 9 | 99,360 |
Tags: binary search, greedy, implementation
Correct Solution:
```
from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil,floor,log,log2,sqrt,gcd,factorial,pow,pi
from bisect import bisect_left
def binNumber(n,size=4):
return bin(n)[2:].zfill(size)
def iar():
return list(map(int,input().split()))
def ini():
return int(input())
def isp():
return map(int,input().split())
def sti():
return str(input())
def par(a):
print(' '.join(list(map(str,a))))
def tdl(outerListSize,innerListSize,defaultValue = 0):
return [[defaultValue]*innerListSize for i in range(outerListSize)]
def sts(s):
s = list(s)
s.sort()
return ''.join(s)
class pair:
def __init__(self,f,s):
self.fi = f
self.se = s
def __lt__(self,other):
return (self.fi,self.se) < (other.fi,other.se)
# ========= /\ /| |====/|
# | / \ | | / |
# | /____\ | | / |
# | / \ | | / |
# ========= / \ ===== |/====|
# code
def BinarySearch(a, x):
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
else:
return -1
if __name__ == "__main__":
n = ini()
a = iar()
a1s = []
a1e = []
a2s = []
a2e = []
i = 0
while i < n:
if a[i] == 1:
a1s.append(i)
while i < n:
if a[i] == 1:
i += 1
else:
break
a1e.append(i)
continue
if a[i] == 2:
a2s.append(i)
while i < n:
if a[i] == 2:
i += 1
else:
break
a2e.append(i)
ma = -1
for i in range(len(a1s)):
j = BinarySearch(a2e,a1s[i])
if j != -1:
ma = max(ma , min(a2e[j]-a2s[j] , a1e[i]-a1s[i]))
for i in range(len(a1s)):
j = BinarySearch(a2s,a1e[i])
if j != -1:
ma = max(ma , min(a2e[j]-a2s[j] , a1e[i]-a1s[i]))
for i in range(len(a2s)):
j = BinarySearch(a1e,a2s[i])
if j != -1:
ma = max(ma , min(a1e[j]-a1s[j] , a2e[i]-a2s[i]))
for i in range(len(a2s)):
j = BinarySearch(a1s,a2e[i])
if j != -1:
ma = max(ma , min(a1e[j]-a1s[j] , a2e[i]-a2s[i]))
#print(a1s,a1e,a2s,a2e)
print(ma*2)
``` | output | 1 | 49,680 | 9 | 99,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,681 | 9 | 99,362 |
Tags: binary search, greedy, implementation
Correct Solution:
```
n=int(input())
sushi=[int(x) for x in input().split()]
sushi.append(3)
tot=[]
counter=1
for i in range(1,n+1):
if sushi[i]==sushi[i-1]:
counter+=1
else:
tot.append(counter)
counter=1
answer=0
for i in range(1,len(tot)):
answer=max(answer,min(tot[i],tot[i-1])*2)
print(answer)
``` | output | 1 | 49,681 | 9 | 99,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,682 | 9 | 99,364 |
Tags: binary search, greedy, implementation
Correct Solution:
```
n = int(input())
l = [int(x) for x in input().split()]
currentflavor = l[0]
currentstreak = 0
laststreak = 0
bestval = 0
for x in l:
if x == currentflavor:
currentstreak += 1
else:
bestval = max(bestval,min(currentstreak,laststreak))
laststreak = currentstreak
currentstreak = 1
currentflavor = x
bestval = max(bestval,min(currentstreak,laststreak))
print(2*bestval)
``` | output | 1 | 49,682 | 9 | 99,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,683 | 9 | 99,366 |
Tags: binary search, greedy, implementation
Correct Solution:
```
from sys import exit, setrecursionlimit
setrecursionlimit(10**6)
inn = lambda: input().strip()
mapp_m1 = lambda: map(lambda x: int(x)-1, inn().split(" "))
mapp = lambda: map(int, inn().split(" "))
N = int(inn())
sushi = list(mapp())
sushi.append("dummy")
before = None
long = 0
zipp = []
for a in sushi:
if a != before:
zipp.append(long)
before = a
long = 1
elif a == before:
long += 1
answer = 0
for i in range(len(zipp)-1):
answer = max(answer, min(zipp[i], zipp[i+1]))
print(answer*2)
``` | output | 1 | 49,683 | 9 | 99,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,684 | 9 | 99,368 |
Tags: binary search, greedy, implementation
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
b = 1
e = []
for i in range(len(l)-1):
if (l[i] == l[i+1]):
b+=1
else:
e.append(b)
b = 1
e.append(b)
h = 0
for j in range(len(e)-1):
h = max(h,min(e[j],e[j+1]))
print(2*h)
``` | output | 1 | 49,684 | 9 | 99,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | instruction | 0 | 49,685 | 9 | 99,370 |
Tags: binary search, greedy, implementation
Correct Solution:
```
n = int(input())
arr = [int(x) for x in input().split()]
arr.append(0)
new_arr = []
cur = 1
for i in range(1, n + 1):
if arr[i] == arr[i-1]:
cur += 1
else:
new_arr.append(cur)
cur = 1
best_answer = 0
for i in range(len(new_arr) - 1):
best_answer = max(
best_answer,
min(new_arr[i], new_arr[i + 1])
)
print(2 * best_answer)
``` | output | 1 | 49,685 | 9 | 99,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
s=[1]
la=a[0]
for i in a[1:]:
if la==i:s[-1]+=1
else:
s.append(1)
la=i
m=0
for i in range(len(s)-1):
m=max(m,min(s[i],s[i+1]))
print(m*2)
``` | instruction | 0 | 49,686 | 9 | 99,372 |
Yes | output | 1 | 49,686 | 9 | 99,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
def solve(arr):
count_list = []
cont=1
for i in range(1,len(arr)):
if arr[i] == arr[i-1]:
cont+=1
else:
count_list.append(cont)
cont=1
count_list.append(cont)
#print(count_list)
ans=0
for i in range(1,len(count_list)):
ans = max(ans, min(count_list[i-1], count_list[i])*2)
return ans
n = input()
arr = input().split(' ')
#print(arr)
print(solve(arr))
``` | instruction | 0 | 49,687 | 9 | 99,374 |
Yes | output | 1 | 49,687 | 9 | 99,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
n = int(input())
p = [int(x) for x in input().split()]
dp = [i for i in range(n)]
for i in range(1,n):
if p[i] == p[i-1]:
dp[i]= dp[i-1]
def check(m):
ln = m*2
for i in range(n-ln+1):
if dp[i+m-1] <= i and dp[i+ln-1] == i+m:
return True
return False
l,r = 1,n//2
res = 2
while l <= r:
m = (r-l)//2 + l
if check(m):
res = m*2
l = m+1
else:
r = m-1
print(res)
``` | instruction | 0 | 49,688 | 9 | 99,376 |
Yes | output | 1 | 49,688 | 9 | 99,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
a = int(input())
b = [int(i) for i in input().split()]
i1 = 0
i2 = 0
ans = 0
p = b[0]
flag = False
for i in range(a):
if b[i] == p and flag:
ans = max(ans, 2 * min(i1, i2))
p = 3 - p
i1 = i2
i2 = 1
elif b[i] != p:
flag = True
i2 += 1
else:
i1 += 1
ans = max(ans, 2 * min(i1, i2))
print(ans)
``` | instruction | 0 | 49,689 | 9 | 99,378 |
Yes | output | 1 | 49,689 | 9 | 99,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
n = int(input())
l = list()
last_ch = ''
for ch in input().split():
if last_ch == '' or last_ch != ch:
l.append(1)
last_ch = ch
else:
l[-1] += 1
max_len = 0
for idx in range(1, len(l)):
if l[idx-1] == l[idx] and l[idx] > max_len:
max_len = l[idx]
print(max_len*2)
``` | instruction | 0 | 49,690 | 9 | 99,380 |
No | output | 1 | 49,690 | 9 | 99,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
counter = 1
mas = [-1 for k in range(n)]
cnt = 0
for i in range(0, n):
if i == (n-1):
mas[cnt] = counter
cnt += 1
continue;
if a[i] == a[i + 1]:
counter += 1
else:
mas[cnt] = counter
cnt+=1
counter = 1
max = -1
for k in range(0, n-1):
if mas[k] <= mas[k+1]:
if max < (mas[k]*2):
max = mas[k]*2
print(max)
``` | instruction | 0 | 49,691 | 9 | 99,382 |
No | output | 1 | 49,691 | 9 | 99,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
try:
n = int(input())
nums = list(map(int,input().split()))
last = -1
largest = 0
count= [0]*3
for i in range(n):
count[nums[i]]+=1
if nums[i]!= last:
largest = max(largest,2*min(count[1],count[2]))
count[nums[i]]=1
last = nums[i]
print(largest)
except Exception as e:
print(e)
``` | instruction | 0 | 49,692 | 9 | 99,384 |
No | output | 1 | 49,692 | 9 | 99,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
Submitted Solution:
```
n = int(input())
t = [int(x) for x in input().split()]
start = t.index(t[0] % 2 + 1)
number = t[start]
l1 = start
l2 = 0
largest = 0
for i in range(start, n):
if t[i] == number:
l2 += 1
else:
if min(l1, l2) > largest:
largest = min(l1, l2)
number = number % 2 + 1
l1 = l2
l2 = 0
if min(l1, l2) > largest:
largest = min(l1, l2)
print(largest*2)
``` | instruction | 0 | 49,693 | 9 | 99,386 |
No | output | 1 | 49,693 | 9 | 99,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,818 | 9 | 99,636 |
Tags: math
Correct Solution:
```
t=int(input())
for _ in range(t):
n,a,b,c,d=map(int,input().split())
if (a+b)*n>=(c-d) and (a-b)*n<=(c+d):
print('YES')
else:
print('NO')
``` | output | 1 | 49,818 | 9 | 99,637 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,819 | 9 | 99,638 |
Tags: math
Correct Solution:
```
def sample(n,a,b,c,d):
mi=a-b
ma=a+b
mi=n*mi
ma=n*ma
to_min=c-d
to_max=c+d
flag=0
if(ma<to_min):
flag=1
if(ma>to_min):
if(mi>to_max):
flag=1
if(flag==1):
return "No"
else:
return "Yes"
t=int(input())
for i in range(t):
n,a,b,c,d=map(int,input().split())
print(sample(n,a,b,c,d))
``` | output | 1 | 49,819 | 9 | 99,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,820 | 9 | 99,640 |
Tags: math
Correct Solution:
```
T = int(input())
for t in range(T):
N, A, B, C, D = [int(i) for i in input().split()]
if (A-B)*N > C+D or (A+B)*N < C-D:
print('No')
else:
print('Yes')
``` | output | 1 | 49,820 | 9 | 99,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,821 | 9 | 99,642 |
Tags: math
Correct Solution:
```
t = int(input())
for i in range(0, t):
n, a, b, c, d = [int(x) for x in input().split()]
min_grain = n * (a - b)
max_grain = n * (a + b)
min_sum = c - d
max_sum = c + d
if (min_grain <= min_sum) and (max_grain >= max_sum):
x = 1
elif (min_grain <= min_sum) and ((max_grain <= max_sum) and (max_grain >= min_sum)):
x = 1
elif ((min_grain >= min_sum) and (min_grain <= max_sum)) and (max_grain >= max_sum):
x = 1
elif (min_grain >= min_sum) and (max_grain <= max_sum):
x = 1
else:
x = 0
if x == 1:
print("YES")
else:
print("NO")
``` | output | 1 | 49,821 | 9 | 99,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,822 | 9 | 99,644 |
Tags: math
Correct Solution:
```
n=int(input())
for i in range(n):
s=[int(x) for x in input().split()]
m=s[0]
a=s[1]
b=s[2]
c=s[3]
d=s[4]
if ((m*(a+b))<(c-d)) or ((m*(a-b))>(c+d)):
print('No')
else:
print('Yes')
``` | output | 1 | 49,822 | 9 | 99,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,823 | 9 | 99,646 |
Tags: math
Correct Solution:
```
t = int(input())
for i in range(t):
n, a, b, c, d = map(int, input().split())
if n*(a-b) > c+d or n*(a+b) < c-d:
print('No')
else:
print('Yes')
``` | output | 1 | 49,823 | 9 | 99,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,824 | 9 | 99,648 |
Tags: math
Correct Solution:
```
for _ in range(int(input())):
n, a, b, c, d = tuple(map(int, input().split()))
if (a - b) * n > c + d or (a + b) * n < c - d:
print('No')
else:
print('Yes')
``` | output | 1 | 49,824 | 9 | 99,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | instruction | 0 | 49,825 | 9 | 99,650 |
Tags: math
Correct Solution:
```
for _ in range(int(input())):
n,a,b,c,d = map(int,input().split())
if (a-b)*n > c+d or (a+b)*n < (c-d):
print("No")
else:
print("Yes")
``` | output | 1 | 49,825 | 9 | 99,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
def main():
T = int(input())
for t in range(T):
n,a,b,c,d = list(map(int,input().split()))
pos = True
if((a-b)*n>(c+d)):
pos = False
elif((a-b)*n < (c-d)) and ((c-d)-(a-b)*n) > 2*b*n:
pos = False
print("YES") if pos else print("NO")
if __name__ == "__main__":
main()
``` | instruction | 0 | 49,826 | 9 | 99,652 |
Yes | output | 1 | 49,826 | 9 | 99,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n,a,b,c,d=map(int,input().split())
if n*(a-b)>=c-d and n*(a-b)<=c+d:
print('Yes')
elif n*(a+b)>=c-d and n*(a+b)<=c+d:
print('Yes')
elif n*(a-b)<c-d and n*(a+b)>c+d:
print('Yes')
else:
print("No")
``` | instruction | 0 | 49,827 | 9 | 99,654 |
Yes | output | 1 | 49,827 | 9 | 99,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
for t in range(int(input())):
n = list(map(int,input().split()))
mig = n[0]*(n[1]-n[2])
mag = n[0]*(n[1]+n[2])
lis=[mig,mag]
mip = n[3]-n[4]
mapa = n[3]+n[4]
org =[mip,mapa]
if min(lis)>max(org) or max(lis)<min(org) :
print('No')
else:
print('Yes')
``` | instruction | 0 | 49,828 | 9 | 99,656 |
Yes | output | 1 | 49,828 | 9 | 99,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
n=int(input())
for i in range(n):
n,a,b,c,d=map(int,input().split())
if (a-b)*n>=(c-d) and (a-b)*n<=(c+d):
print("YES")
elif (a+b)*n>=(c-d) and (a+b)*n<=(c+d):
print("YES")
elif (a-b)*n>=(c-d) and (a+b)*n<=(c+d):
print("YES")
elif (a+b)*n>=(c-d) and (a-b)*n<=(c+d):
print("YES")
else:
print("NO")
``` | instruction | 0 | 49,829 | 9 | 99,658 |
Yes | output | 1 | 49,829 | 9 | 99,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
for _ in range(int(input())):
s,l,m,n,o = map(int,input().split())
if(s*(l-m) > n+o):
if(s*(l+m) < n-o):
print("Yes")
else:
print ("No")
``` | instruction | 0 | 49,830 | 9 | 99,660 |
No | output | 1 | 49,830 | 9 | 99,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
t=int(input())
for i in range(t):
n,a,b,c,d=[int(i) for i in input().split()]
g1=a-b
g2=a+b
b1=c-d
b2=c+d
if g1*n>=b1 and g1*n<=b2:
print("YES")
elif g2*n>=b1 and g2*n<=b2:
print('YES')
else:
print("NO")
``` | instruction | 0 | 49,831 | 9 | 99,662 |
No | output | 1 | 49,831 | 9 | 99,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
def f(n,a,b,c,d):
flag=False
p=c-d
q=c+d
if p<=n*(a-b)<=q:
flag=True
elif p<=n*(a+b)<=q:
flag=True
return flag
t=int(input())
for w in range(t):
v=list(map(int,input().strip().split()))
n=v[0]
a=v[1]
b=v[2]
c=v[3]
d=v[4]
if f(n,a,b,c,d):
print("Yes")
else:
print("No")
``` | instruction | 0 | 49,832 | 9 | 99,664 |
No | output | 1 | 49,832 | 9 | 99,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
Submitted Solution:
```
t = int(input())
while t > 0:
t -= 1
n, a, b, c, d = map(int, input().split())
if c - d <= n * (a - b) <= c + d or c - d <= n * (a + b) <= c + d:
print('yes')
else:
print('no')
``` | instruction | 0 | 49,833 | 9 | 99,666 |
No | output | 1 | 49,833 | 9 | 99,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Bubble Cup hypothesis stood unsolved for 130 years. Who ever proves the hypothesis will be regarded as one of the greatest mathematicians of our time! A famous mathematician Jerry Mao managed to reduce the hypothesis to this problem:
Given a number m, how many polynomials P with coefficients in set {\{0,1,2,3,4,5,6,7\}} have: P(2)=m?
Help Jerry Mao solve the long standing problem!
Input
The first line contains a single integer t (1 ≤ t ≤ 5⋅ 10^5) - number of test cases.
On next line there are t numbers, m_i (1 ≤ m_i ≤ 10^{18}) - meaning that in case i you should solve for number m_i.
Output
For each test case i, print the answer on separate lines: number of polynomials P as described in statement such that P(2)=m_i, modulo 10^9 + 7.
Example
Input
2
2 4
Output
2
4
Note
In first case, for m=2, polynomials that satisfy the constraint are x and 2.
In second case, for m=4, polynomials that satisfy the constraint are x^2, x + 2, 2x and 4. | instruction | 0 | 50,689 | 9 | 101,378 |
Tags: bitmasks, constructive algorithms, dp, math
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
MOD = 10 ** 9 + 7
memo = dict()
def solve(m):
if m not in memo:
if m < 0:
memo[m] = 0
if m == 0:
memo[m] = 1
half = m//2
memo[m] = (solve(half) + solve(half - 1) + solve(half - 2) + solve(half - 3)) % MOD
return memo[m]
t = int(input())
out = []
for m in map(int, input().split()):
#out.append(solve(m))
v = m//2
u = v//2
w = (v-u)
out.append((u*w+u+w+1)%MOD)
print('\n'.join(map(str,out)))
``` | output | 1 | 50,689 | 9 | 101,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Bubble Cup hypothesis stood unsolved for 130 years. Who ever proves the hypothesis will be regarded as one of the greatest mathematicians of our time! A famous mathematician Jerry Mao managed to reduce the hypothesis to this problem:
Given a number m, how many polynomials P with coefficients in set {\{0,1,2,3,4,5,6,7\}} have: P(2)=m?
Help Jerry Mao solve the long standing problem!
Input
The first line contains a single integer t (1 ≤ t ≤ 5⋅ 10^5) - number of test cases.
On next line there are t numbers, m_i (1 ≤ m_i ≤ 10^{18}) - meaning that in case i you should solve for number m_i.
Output
For each test case i, print the answer on separate lines: number of polynomials P as described in statement such that P(2)=m_i, modulo 10^9 + 7.
Example
Input
2
2 4
Output
2
4
Note
In first case, for m=2, polynomials that satisfy the constraint are x and 2.
In second case, for m=4, polynomials that satisfy the constraint are x^2, x + 2, 2x and 4.
Submitted Solution:
```
from math import *
T = int(input())
n = map(int, input().split())
for i in n:
print(int(floor(floor(i / 2 + 2) ** 2 / 2) / 2))
``` | instruction | 0 | 50,691 | 9 | 101,382 |
No | output | 1 | 50,691 | 9 | 101,383 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.