text stringlengths 216 39.6k | conversation_id int64 219 108k | embedding list | cluster int64 11 11 |
|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
from sys import stdin
line = stdin.readline().strip().split(" ")
a = int(line[0])
b = int(line[1])
c = int(line[2])
rt = (b * b - 4 * a * c) ** 0.5
denom = 2 * a
print((-b + rt) / denom)
print((-b - rt) / denom)
```
No
| 51,750 | [
0.363037109375,
0.0689697265625,
0.0870361328125,
0.026763916015625,
-0.50634765625,
-0.283203125,
-0.1864013671875,
0.25830078125,
0.4140625,
0.88623046875,
0.6015625,
-0.4287109375,
0.03472900390625,
-0.50634765625,
-0.26416015625,
0.1802978515625,
-0.468994140625,
-0.67138671875... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
import math
a, b, c = map(int, input().split(" "))
print((-b + math.sqrt(b**2 - 4 * a * c)) / (2 * a))
print((-b - math.sqrt(b**2 - 4 * a * c)) / (2 * a))
```
No
| 51,751 | [
0.3681640625,
0.1273193359375,
0.0206298828125,
0.08172607421875,
-0.5595703125,
-0.297119140625,
-0.1451416015625,
0.282958984375,
0.432373046875,
0.880859375,
0.66259765625,
-0.4599609375,
0.0982666015625,
-0.58056640625,
-0.1885986328125,
0.2039794921875,
-0.463134765625,
-0.671... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
import math
a, b, c = map(int, input().split())
D = b * b - 4 * a * c
D = math.sqrt(D)
root1 = (-b + D) / 2 * a
root2 = (-b - D) / 2 * a
print (max(root1, root2))
print (min(root1, root2))
```
No
| 51,752 | [
0.369384765625,
0.127685546875,
-0.0021724700927734375,
0.04913330078125,
-0.54736328125,
-0.308837890625,
-0.1046142578125,
0.28515625,
0.45654296875,
0.8837890625,
0.69775390625,
-0.48486328125,
0.09063720703125,
-0.5908203125,
-0.2042236328125,
0.217529296875,
-0.478515625,
-0.6... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
from decimal import *
s=input().split()
a=int(s[0])
b=int(s[1])
c=int(s[2])
disc=Decimal(b*b-4*a*c)
print(Decimal((0-b+disc.sqrt())/(2*a)))
print(Decimal((0-b-disc.sqrt())/(2*a)))
```
No
| 51,753 | [
0.322021484375,
0.055938720703125,
0.032806396484375,
0.03228759765625,
-0.5693359375,
-0.298583984375,
-0.06732177734375,
0.2890625,
0.431884765625,
0.90478515625,
0.63623046875,
-0.50048828125,
0.066162109375,
-0.509765625,
-0.230712890625,
0.21337890625,
-0.454345703125,
-0.6655... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads an integer n and identifies the number of combinations of a, b, c and d (0 ≤ a, b, c, d ≤ 9) which meet the following equality:
a + b + c + d = n
For example, for n = 35, we have 4 different combinations of (a, b, c, d): (8, 9, 9, 9), (9, 8, 9, 9), (9, 9, 8, 9), and (9, 9, 9, 8).
Input
The input consists of several datasets. Each dataset consists of n (1 ≤ n ≤ 50) in a line. The number of datasets is less than or equal to 50.
Output
Print the number of combination in a line.
Example
Input
35
1
Output
4
4
Submitted Solution:
```
while True:
try:
n = int(input())
count = 0
for a in range(10):
for b in range(10):
for c in range(10):
for d in range(10):
if a + b + c + d == n:
count += 1
print(count)
except EOFError:
break
```
Yes
| 52,074 | [
0.5673828125,
-0.1092529296875,
0.125244140625,
0.01273345947265625,
-0.51220703125,
-0.39306640625,
-0.09759521484375,
0.23291015625,
0.157470703125,
0.95458984375,
0.658203125,
0.04345703125,
0.25927734375,
-0.65966796875,
-0.58447265625,
-0.17724609375,
-0.64404296875,
-0.661621... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads an integer n and identifies the number of combinations of a, b, c and d (0 ≤ a, b, c, d ≤ 9) which meet the following equality:
a + b + c + d = n
For example, for n = 35, we have 4 different combinations of (a, b, c, d): (8, 9, 9, 9), (9, 8, 9, 9), (9, 9, 8, 9), and (9, 9, 9, 8).
Input
The input consists of several datasets. Each dataset consists of n (1 ≤ n ≤ 50) in a line. The number of datasets is less than or equal to 50.
Output
Print the number of combination in a line.
Example
Input
35
1
Output
4
4
Submitted Solution:
```
while True:
try:
n = int(input())
except:
exit()
m = 9
c = 0
def loop(n,dep):
l = n - m*(3-dep)
u = n
if (l < 0):l = 0
if (m < u):u = 9
return l,u+1
il,iu= loop(n,0)
for i in range(il,iu):
jl,ju = loop(n-i,1)
for j in range(jl,ju):
ij = i+j
kl,ku = loop(n-ij,2)
for k in range(kl,ku):
c += 1
print(c)
```
Yes
| 52,076 | [
0.56005859375,
-0.11798095703125,
0.110595703125,
0.042633056640625,
-0.556640625,
-0.39208984375,
-0.1951904296875,
0.2244873046875,
0.0599365234375,
0.935546875,
0.68017578125,
-0.017486572265625,
0.165771484375,
-0.7109375,
-0.54443359375,
-0.0384521484375,
-0.6142578125,
-0.639... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads an integer n and identifies the number of combinations of a, b, c and d (0 ≤ a, b, c, d ≤ 9) which meet the following equality:
a + b + c + d = n
For example, for n = 35, we have 4 different combinations of (a, b, c, d): (8, 9, 9, 9), (9, 8, 9, 9), (9, 9, 8, 9), and (9, 9, 9, 8).
Input
The input consists of several datasets. Each dataset consists of n (1 ≤ n ≤ 50) in a line. The number of datasets is less than or equal to 50.
Output
Print the number of combination in a line.
Example
Input
35
1
Output
4
4
Submitted Solution:
```
import sys
def comb(n):
count = 0
for i in range(10):
for j in range(10):
for k in range(10):
for l in range(10):
if i+j+k+l == n:
count += 1
continue
return count
while True:
line = sys.stdin.readline()
if not line: break
n = int(line.rstrip('\r\n'))
print(comb(n))
```
Yes
| 52,077 | [
0.58984375,
-0.2210693359375,
0.095703125,
-0.0439453125,
-0.4560546875,
-0.31982421875,
-0.05377197265625,
0.0215301513671875,
0.271484375,
0.890625,
0.75341796875,
0.0711669921875,
0.05889892578125,
-0.56884765625,
-0.489013671875,
0.0124664306640625,
-0.66943359375,
-0.854003906... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads an integer n and identifies the number of combinations of a, b, c and d (0 ≤ a, b, c, d ≤ 9) which meet the following equality:
a + b + c + d = n
For example, for n = 35, we have 4 different combinations of (a, b, c, d): (8, 9, 9, 9), (9, 8, 9, 9), (9, 9, 8, 9), and (9, 9, 9, 8).
Input
The input consists of several datasets. Each dataset consists of n (1 ≤ n ≤ 50) in a line. The number of datasets is less than or equal to 50.
Output
Print the number of combination in a line.
Example
Input
35
1
Output
4
4
Submitted Solution:
```
import sys
def count(number) :
result = 0
for a in range(10) :
for b in range(10) :
for c in range(10) :
for d in range(10) :
if a + b + c + d == 35 : result += 1
return result
for make in sys.stdin.readlines():
print(count(make))
```
No
| 52,079 | [
0.55908203125,
-0.08551025390625,
0.12078857421875,
0.0222320556640625,
-0.54736328125,
-0.40869140625,
-0.128173828125,
0.24169921875,
0.066650390625,
0.943359375,
0.59375,
-0.0455322265625,
0.2186279296875,
-0.62548828125,
-0.64892578125,
-0.146484375,
-0.60986328125,
-0.69628906... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
for _ in range(int(input())):
input()
a=list(map(int,input().split()))
a=sorted(list(set(a)))
ans=max(a)
n=len(a)
for i in range(n):
x,y,z=0,0,a[i]
for j in reversed(range(i)):
if not y:
if z%a[j]!=0:
y=a[j]
elif not x:
if z%a[j]!=0 and y%a[j]!=0:
x=a[j]
else:
break
ans=max(ans,x+y+z)
print(ans)
```
Yes
| 52,290 | [
0.253662109375,
-0.1385498046875,
0.07891845703125,
-0.1070556640625,
-0.7919921875,
-0.386474609375,
0.1551513671875,
0.29736328125,
0.057403564453125,
0.97119140625,
0.07025146484375,
-0.04266357421875,
0.378173828125,
-0.646484375,
-0.3857421875,
-0.408447265625,
-0.478515625,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
from sys import stdin
from itertools import tee
def input():
return stdin.readline()
def remove_divisors(x, xs):
return [y for y in xs if y%xs != 0]
q = int(input())
for _ in range(q):
n = int(input())
aas = list(set(map(int,input().split())))
aas.sort(reverse=True)
if len(aas) > 2 and aas[1]*2 > aas[0] and aas[2]*2 > aas[0]:
print(sum(aas[0:3]))
continue
ulim2 = list(map(sum, zip(aas[:-1], aas[1:]))) + [0]
ulim3 = list(map(sum, zip(aas[:-2], ulim2[1:]))) + [0,0]
it1 = iter(zip(aas, ulim3, ulim2))
answer = 0
try:
while True:
a, u3, _ = next(it1)
if u3 < answer:
break
it1, it2 = tee(it1)
def f1(i):
b, _, _ = i
return a%b != 0
it2 = filter(f1, it2)
tsum = 0
try:
while True:
b, _, u2 = next(it2)
if u2 < tsum:
break
it2, it3 = tee(it2)
def f2(i):
c, _, _ = i
return b%c != 0
it3 = filter (f2 , it3)
c,_,_ = next(it3, (0,0,0))
tsum = max(tsum, b+c)
except StopIteration:
pass
answer = max(answer, a + tsum)
except StopIteration:
pass
print(answer)
```
Yes
| 52,291 | [
0.20166015625,
-0.13134765625,
0.07550048828125,
-0.10125732421875,
-0.8818359375,
-0.403076171875,
0.05389404296875,
0.2374267578125,
0.0013446807861328125,
0.94091796875,
0.0056610107421875,
-0.07684326171875,
0.327392578125,
-0.6044921875,
-0.34033203125,
-0.413330078125,
-0.48364... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
a = [0, 0] + sorted(set(map(int, input().split())))
ans = a[-1]
for z in range(len(a)-1, 1, -1):
y = z-1
while a[y] > 0 and a[z] % a[y] == 0:
y -= 1
x = y-1
while a[x] > 0 and (a[z] % a[x] == 0 or a[y] % a[x] == 0):
x -= 1
ans = max(ans, a[x]+a[y]+a[z])
print(ans)
```
Yes
| 52,292 | [
0.2327880859375,
-0.134521484375,
0.11480712890625,
-0.10858154296875,
-0.7978515625,
-0.3876953125,
0.1259765625,
0.28173828125,
0.046875,
0.98486328125,
0.05889892578125,
-0.05401611328125,
0.376708984375,
-0.63671875,
-0.380859375,
-0.39990234375,
-0.477783203125,
-0.80029296875... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
# https://codeforces.com/contest/1183/problem/F
def solve(a_s):
a_s = set(a_s)
n = max(a_s)
largest = n
if n // 2 in a_s and n // 3 in a_s and n // 5 in a_s:
largest = n // 2 + n // 3 + n // 5
m = []
for _ in range(3):
if not a_s:
break
n = max(a_s)
a_s = set([j for j in a_s if n % j != 0])
m.append(n)
if sum(m) > largest:
largest = sum(m)
return largest
q = int(input())
for _ in range(q):
n = int(input())
a_s = list(map(int, input().split()))
print(solve(a_s))
```
Yes
| 52,293 | [
0.29638671875,
-0.1383056640625,
0.07080078125,
-0.055755615234375,
-0.7724609375,
-0.427978515625,
0.1534423828125,
0.276123046875,
0.053436279296875,
0.9501953125,
0.055755615234375,
-0.046295166015625,
0.388671875,
-0.65625,
-0.35302734375,
-0.41943359375,
-0.480712890625,
-0.76... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
q = int(input())
for query in range(q):
n = int(input())
l = list(map(int,input().split()))
l.sort()
l.reverse()
if (len(l) > 3 and l[1] == l[0] / 2 and l[2] == l[0] / 3 and l[3] == l[0] / 5) or (len(l) > 4 and l[1] == l[0] / 2 and l[2] == l[0] / 3 and l[3] == l[0] /4 and l[4] == l[0] / 5):
print(l[1] + l[2] + l[3])
else:
nowa = [l[i] for i in range(n) if l[0] % l[i] != 0]
nowa.sort()
nowa.reverse()
if len(nowa) > 0:
part = 0
for i in range(1, len(nowa)):
if nowa[0] % nowa[i] !=0:
part = nowa[i]
break
wyn = l[0] + nowa[0] + part
else:
wyn = l[0]
print(wyn)
if len(l) > 100:
print(l[0],l[1],l[2],l[3])
```
No
| 52,294 | [
0.255859375,
-0.1341552734375,
0.0748291015625,
-0.107177734375,
-0.802734375,
-0.380859375,
0.1461181640625,
0.2998046875,
0.050506591796875,
0.96484375,
0.068603515625,
-0.0399169921875,
0.3720703125,
-0.6455078125,
-0.38916015625,
-0.405517578125,
-0.479736328125,
-0.810546875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
from sys import stdin,stdout
for _ in range(int(stdin.readline())):
n=int(stdin.readline())
l=list(map(int,stdin.readline().split()))
x,y,z=0,0,0
l.sort(reverse=True)
for i in l:
if x==0:
x=i
elif y==0 and x%i:
y=i
elif z==0 and x%i and y%i:
z=i
ans=x+y+z
if ans%30==0 and ans//2 in l and ans//3 in l and ans//5 in l:
ans=(31*ans)//30
print(ans)
```
No
| 52,295 | [
0.2174072265625,
-0.1380615234375,
0.118408203125,
-0.0931396484375,
-0.81396484375,
-0.39208984375,
0.103515625,
0.283203125,
0.021026611328125,
0.97509765625,
0.056243896484375,
-0.0634765625,
0.3583984375,
-0.63427734375,
-0.38525390625,
-0.4130859375,
-0.482421875,
-0.810058593... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
def calcSum(first):
global m
s = m[first]
k = 1
for i in range(first + 1, len(m)):
yes = True
for j in range(first, i):
if m[j] % m[i] == 0:
yes = False
break
if yes:
s += m[i]
k += 1
if k == 3: break
return s
import sys
nnn = int(input())
for _ in range(nnn):
n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().split()))
if n == 1:
print(a[0])
continue
if n == 2:
if a[0]%a[1] == 0 or a[1]%a[0] == 0:
print(max(a))
else:
print(sum(a))
continue
a.sort(reverse = True)
m = [a[0], a[1]]
for i in range(2, len(a)):
yes = True
for j in range(2, i):
if a[j] % a[i] == 0:
yes = False
break
if yes:
m.append(a[i])
if len(m) >= 4:
break
## print(m)
s1 = calcSum(0)
s2 = calcSum(1)
s = max(s1, s2)
if nnn == 16383:
if _>300:
print(m, ' - ', a, '-', s)
else:
print(s)
```
No
| 52,296 | [
0.267333984375,
-0.132080078125,
0.0819091796875,
-0.09783935546875,
-0.787109375,
-0.39306640625,
0.17236328125,
0.299072265625,
0.0863037109375,
0.9580078125,
0.09075927734375,
-0.058685302734375,
0.38330078125,
-0.6552734375,
-0.36865234375,
-0.38134765625,
-0.48291015625,
-0.78... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
Submitted Solution:
```
from sys import stdin
from itertools import tee
def input():
return stdin.readline()
def remove_divisors(x, xs):
return [y for y in xs if y%xs != 0]
q = int(input())
for _ in range(q):
n = int(input())
aas = list(map(int,input().split()))
aas.sort(reverse=True)
if len(aas) > 2 and aas[1]*2 > aas[0] and aas[2]*2 > aas[0]:
print(sum(aas[0:3]))
continue
ulim2 = list(map(sum, zip(aas[:-1], aas[1:]))) + [0]
ulim3 = list(map(sum, zip(aas[:-2], ulim2[1:]))) + [0,0]
it1 = iter(zip(aas, ulim3, ulim2))
answer = 0
try:
while True:
a, u3, _ = next(it1)
if u3 < answer:
break
it1, it2 = tee(it1)
def f1(i):
b, _, _ = i
return a%b != 0
it2 = filter(f1, it2)
tsum = 0
try:
while True:
b, _, u2 = next(it2)
if u2 < tsum:
break
it2, it3 = tee(it2)
def f2(i):
c, _, _ = i
return b%c != 0
it3 = filter (f2 , it3)
c,_,_ = next(it3, (0,0,0))
tsum = max(tsum, b+c)
except StopIteration:
pass
answer = max(answer, a + tsum)
except StopIteration:
pass
print(answer)
```
No
| 52,297 | [
0.20166015625,
-0.13134765625,
0.07550048828125,
-0.10125732421875,
-0.8818359375,
-0.403076171875,
0.05389404296875,
0.2374267578125,
0.0013446807861328125,
0.94091796875,
0.0056610107421875,
-0.07684326171875,
0.327392578125,
-0.6044921875,
-0.34033203125,
-0.413330078125,
-0.48364... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
n,m=map(int,input().split())
a=[]
for i in range(n):
x=input()
a.append(x)
s=list(map(int,input().split()))
c=0
# print(a)
for i in range(m):
m={}
for j in range(n):
if a[j][i] in m:
m[a[j][i]]+=1
else:
m[a[j][i]]=1
# print(m)
v=list(m.values())
c+=max(v)*s[i]
print(c)
```
Yes
| 52,306 | [
0.340087890625,
-0.097900390625,
-0.1898193359375,
0.2239990234375,
-0.8134765625,
-0.36376953125,
0.1988525390625,
0.1171875,
0.06512451171875,
1.0126953125,
0.505859375,
0.07135009765625,
0.246337890625,
-0.481201171875,
-0.2266845703125,
-0.2213134765625,
-0.7587890625,
-0.59716... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
x=input()
x=x.split()
n=int(x[0])
m=int(x[1])
q=[]
k=[]
total=0
for i in range(0,n):
q.append(input())
y=input()
y=y.split()
for i in range(0,m):
k.clear()
for j in q:
k.append(j[i])
a=k.count("A")
b=k.count("B")
c=k.count("C")
d=k.count("D")
e=k.count("E")
z=[a,b,c,d,e]
z.sort(reverse=True)
total+=int(y[i])*int(z[0])
print(total)
```
Yes
| 52,307 | [
0.374755859375,
-0.09686279296875,
-0.10302734375,
0.3251953125,
-0.8828125,
-0.377685546875,
0.2010498046875,
0.125244140625,
0.08258056640625,
1.0068359375,
0.451171875,
0.05023193359375,
0.08892822265625,
-0.480712890625,
-0.28125,
-0.21826171875,
-0.80322265625,
-0.7099609375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
maxsum=0
a,b=map(int, input().split())
tests=[]
for i in range(a):
tests+=[input()]
price=list(map(int, input().split()))
quantity=[0]*b
for i in range(b):
s=''
for j in range(a):
s+=tests[j][i]
maxsum+=price[i]*max(s.count('A'), s.count('B'), s.count('C'), s.count('D'), s.count('E'))
print(maxsum)
```
Yes
| 52,308 | [
0.320068359375,
-0.09161376953125,
-0.053924560546875,
0.2410888671875,
-0.88232421875,
-0.43798828125,
0.30029296875,
0.1241455078125,
0.040740966796875,
0.99755859375,
0.5166015625,
0.1500244140625,
0.2265625,
-0.434814453125,
-0.272705078125,
-0.1328125,
-0.7578125,
-0.656738281... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
R = lambda: map(int,input().split())
n,m = R()
L = []
for i in range(n):
L.append([i for i in input()])
C = list(R())
res = 0
for i in range(m):
f = [0]*5
for j in range(n):
f[ord(L[j][i])-ord('A')] += 1
res += (max(f)*C[i])
print(res)
```
Yes
| 52,309 | [
0.3115234375,
-0.100341796875,
-0.174560546875,
0.36962890625,
-0.876953125,
-0.30908203125,
0.26611328125,
0.14697265625,
0.041839599609375,
0.94970703125,
0.5126953125,
0.01434326171875,
0.1043701171875,
-0.429931640625,
-0.28076171875,
-0.2412109375,
-0.74462890625,
-0.52734375,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
n, m = map(int, input().split())
sp = [list(input()) for _ in range(n)]
a = list(map(int, input().split()))
chet = 0
s = 0
for _ in range(m):
x = set()
for i in range(n):
x.add(sp[i][chet])
s += (n - len(x) + 1) * a[chet]
chet += 1
print(s)
```
No
| 52,310 | [
0.368896484375,
-0.12939453125,
-0.1043701171875,
0.193603515625,
-0.83642578125,
-0.38037109375,
0.1932373046875,
0.126953125,
0.051055908203125,
0.9541015625,
0.479248046875,
0.06292724609375,
0.27734375,
-0.428466796875,
-0.194091796875,
-0.1705322265625,
-0.767578125,
-0.596191... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
from collections import Counter
n, s_length = map(int, input().split())
us = {}
c = Counter()
for i in range(1, n + 1):
string = input()
for i in string:
c[i] += 1
x = [int(i) for i in input().split()]
l = 0
s = 0
for j in c.most_common(s_length):
s += x[l] * j[1]
l += 1
print(s)
```
No
| 52,311 | [
0.346923828125,
-0.09283447265625,
-0.1004638671875,
0.25146484375,
-0.84765625,
-0.322509765625,
0.218994140625,
0.054443359375,
0.09375,
1.00390625,
0.4453125,
0.073486328125,
0.1982421875,
-0.5595703125,
-0.287841796875,
-0.2371826171875,
-0.76513671875,
-0.603515625,
-0.36621... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
from functools import reduce
n,m=input().split()
n=int(n)
m=int(m)
l=[]
num=[]
l1=[]
for i in range(n):
l.append(input())
num=list(map(int, input().split()))
res = list(reduce(lambda i, j: i & j, (set(x) for x in l)))
val=sum(num)
for k in range(len(res)):
l2=[]
for i in range(len(l)):
for j in range(len(l[i])):
if k<len(res) and res[k]==l[i][j]:
l2.append(j)
z=all(x == l2[0] for x in l2)
if z==True:
val+=num[l2[0]]
print(val)
```
No
| 52,312 | [
0.388427734375,
-0.06561279296875,
-0.18115234375,
0.229736328125,
-0.89599609375,
-0.370849609375,
0.1949462890625,
0.10382080078125,
0.05767822265625,
1.0009765625,
0.436279296875,
-0.0292816162109375,
0.119140625,
-0.4775390625,
-0.250732421875,
-0.216064453125,
-0.70556640625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
Submitted Solution:
```
n,m=map(int,input().split())
l=[]
for i in range(n):
s=input()
l.append(s)
a=list(map(int,input().split()))
ans=0
for i in range(len(l[0])):
ctr=0
for j in range(n):
if(l[0][i]==l[j][i]):
ctr+=1
ans+=a[i]*ctr
print(ans)
```
No
| 52,313 | [
0.34326171875,
-0.12176513671875,
-0.1624755859375,
0.2388916015625,
-0.80712890625,
-0.383056640625,
0.212646484375,
0.135498046875,
0.006977081298828125,
1.0029296875,
0.474365234375,
0.10015869140625,
0.2298583984375,
-0.484130859375,
-0.24365234375,
-0.2373046875,
-0.76416015625,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a bag of size n. Also you have m boxes. The size of i-th box is a_i, where each a_i is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if n = 10 and a = [1, 1, 32] then you have to divide the box of size 32 into two parts of size 16, and then divide the box of size 16. So you can fill the bag with boxes of size 1, 1 and 8.
Calculate the minimum number of divisions required to fill the bag of size n.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{18}, 1 ≤ m ≤ 10^5) — the size of bag and the number of boxes, respectively.
The second line of each test case contains m integers a_1, a_2, ... , a_m (1 ≤ a_i ≤ 10^9) — the sizes of boxes. It is guaranteed that each a_i is a power of two.
It is also guaranteed that sum of all m over all test cases does not exceed 10^5.
Output
For each test case print one integer — the minimum number of divisions required to fill the bag of size n (or -1, if it is impossible).
Example
Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Output
2
-1
0
Submitted Solution:
```
t = int(input())
for ijkl in range(t):
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
f = max(a)
f = max(f, n)
number = 1
power = 2
while power <= f:
power = power * 2
number += 1
have = [0 for i in range(number)]
for x in a:
copy = x
deg = 0
while copy > 1:
copy = copy // 2
deg += 1
have[deg] += 1
numbers = [0 for i in range(number)]
for i in range(number):
last = n % 2
numbers[i] = last
n = n // 2
#print(number, have, numbers)
ans = 0
ok = True
for i in range(number):
if numbers[i] == 1:
if have[i] >= 1:
have[i] -= 1
else:
j = i + 1
if j == number:
ok = False
#print(i, j, have)
break
while have[j] == 0:
j += 1
if j == number:
ok = False
#print(i, j)
break
ans += j - i
while j > i:
have[j] -= 1
have[j-1] += 2
j = j - 1
have[i] -= 1
if (i+1 != number):
have[i+1] += have[i] // 2
have[i] = 0
if ok:
print(ans)
else:
print(-1)
```
Yes
| 52,368 | [
0.26025390625,
-0.061553955078125,
0.2705078125,
-0.0914306640625,
-0.65576171875,
-0.369873046875,
-0.0965576171875,
0.242919921875,
0.03717041015625,
0.99365234375,
0.677734375,
0.173095703125,
0.149658203125,
-0.5908203125,
-0.284912109375,
0.303466796875,
-0.412109375,
-0.59619... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a bag of size n. Also you have m boxes. The size of i-th box is a_i, where each a_i is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if n = 10 and a = [1, 1, 32] then you have to divide the box of size 32 into two parts of size 16, and then divide the box of size 16. So you can fill the bag with boxes of size 1, 1 and 8.
Calculate the minimum number of divisions required to fill the bag of size n.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{18}, 1 ≤ m ≤ 10^5) — the size of bag and the number of boxes, respectively.
The second line of each test case contains m integers a_1, a_2, ... , a_m (1 ≤ a_i ≤ 10^9) — the sizes of boxes. It is guaranteed that each a_i is a power of two.
It is also guaranteed that sum of all m over all test cases does not exceed 10^5.
Output
For each test case print one integer — the minimum number of divisions required to fill the bag of size n (or -1, if it is impossible).
Example
Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Output
2
-1
0
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 19:24:32 2020
@author: dennis
"""
import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
import math
def lowest_pair(li):
for i in range(61):
if li.count(i) >= 2:
return i
return -1
def closest_n(li, n):
for i in range(n, len(li)):
if li[i]:
return i
return -1
for _ in range(int(input())):
bag_size, n_boxes = [int(x) for x in input().split()]
boxes = [int(x) for x in input().split()]
# @profile
# def main():
# for _ in range(1):
# bag_size, n_boxes = 35184372088831, 100000
# boxes = [536870912]*n_boxes
log_boxes = [0]*61
for box in boxes:
log_boxes[int(math.log2(box))] += 1
if sum(boxes) < bag_size:
print(-1)
continue
bin_bag = [int(x) for x in bin(bag_size)[2:][::-1]]
divisions = 0
while 1 in bin_bag:
i = bin_bag.index(1)
if log_boxes[i]:
log_boxes[i] -= 1
bin_bag[i] = 0
else:
for j in range(0, i):
n = log_boxes[j]
log_boxes[j] = n%2
log_boxes[j+1] += n//2
if log_boxes[i]:
log_boxes[i] -= 1
bin_bag[i] = 0
else:
while not log_boxes[i]:
n = closest_n(log_boxes, i)
log_boxes[n] -= 1
log_boxes[n-1] += 2
divisions += 1
log_boxes[i] -= 1
bin_bag[i] = 0
print(divisions)
# main()
'''
'''
```
Yes
| 52,369 | [
-0.00443267822265625,
-0.1837158203125,
0.06732177734375,
0.048675537109375,
-0.77685546875,
-0.4189453125,
-0.157958984375,
0.2342529296875,
0.10888671875,
0.84375,
0.59423828125,
-0.0103302001953125,
0.287353515625,
-0.427978515625,
-0.418212890625,
0.251220703125,
-0.418212890625,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a bag of size n. Also you have m boxes. The size of i-th box is a_i, where each a_i is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if n = 10 and a = [1, 1, 32] then you have to divide the box of size 32 into two parts of size 16, and then divide the box of size 16. So you can fill the bag with boxes of size 1, 1 and 8.
Calculate the minimum number of divisions required to fill the bag of size n.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{18}, 1 ≤ m ≤ 10^5) — the size of bag and the number of boxes, respectively.
The second line of each test case contains m integers a_1, a_2, ... , a_m (1 ≤ a_i ≤ 10^9) — the sizes of boxes. It is guaranteed that each a_i is a power of two.
It is also guaranteed that sum of all m over all test cases does not exceed 10^5.
Output
For each test case print one integer — the minimum number of divisions required to fill the bag of size n (or -1, if it is impossible).
Example
Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Output
2
-1
0
Submitted Solution:
```
# -*- coding: utf-8 -*-
import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
from typing import List
"""
created by shhuan at 2020/3/19 14:23
"""
def solve(N, A):
if sum(A) < N:
return -1
nb = 64
needs = [0 for _ in range(nb)]
for i in range(nb):
if N & (1 << i):
needs[i] = 1
have = [0 for _ in range(65)]
for a in A:
b = 0
while a > 0:
a >>= 1
b += 1
have[b - 1] += 1
ans = 0
for i in range(nb):
if have[i] >= needs[i]:
have[i] -= needs[i]
have[i+1] += have[i] // 2
else:
for j in range(i+1, 64):
if have[j] > 0:
have[j] -= 1
for k in range(i, j):
have[k] += 1
ans += j-i
needs[i] = 0
break
if needs[i] > 0:
return -1
return ans
T = int(input())
for ti in range(T):
N, M = map(int, input().split())
A = [int(x) for x in input().split()]
print(solve(N, A))
```
Yes
| 52,370 | [
0.1341552734375,
-0.101318359375,
0.1812744140625,
-0.0170745849609375,
-0.80322265625,
-0.3369140625,
-0.0020427703857421875,
0.252685546875,
0.1376953125,
0.95166015625,
0.705078125,
0.063232421875,
0.2122802734375,
-0.56396484375,
-0.505859375,
0.2548828125,
-0.3388671875,
-0.52... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a bag of size n. Also you have m boxes. The size of i-th box is a_i, where each a_i is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if n = 10 and a = [1, 1, 32] then you have to divide the box of size 32 into two parts of size 16, and then divide the box of size 16. So you can fill the bag with boxes of size 1, 1 and 8.
Calculate the minimum number of divisions required to fill the bag of size n.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{18}, 1 ≤ m ≤ 10^5) — the size of bag and the number of boxes, respectively.
The second line of each test case contains m integers a_1, a_2, ... , a_m (1 ≤ a_i ≤ 10^9) — the sizes of boxes. It is guaranteed that each a_i is a power of two.
It is also guaranteed that sum of all m over all test cases does not exceed 10^5.
Output
For each test case print one integer — the minimum number of divisions required to fill the bag of size n (or -1, if it is impossible).
Example
Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Output
2
-1
0
Submitted Solution:
```
for _ in range(int(input())):
m,n=map(int,input().split())
a=list(map(int,input().split()))
mark=[0]*65
now=1
for indx in range(65):
for i in a:
if(i==now):
mark[indx]+=1
now<<=1
s=bin(m)[2:]
s=s[::-1]
ans=0
flg=1
carry=0
indx=0
for now in s:
if(now=='0'):
carry+=(1<<indx)*(mark[indx])
else:
if(mark[indx]):
carry+=(1<<indx)*(mark[indx]-1)
elif(carry>=(1<<indx)):
carry-=(1<<indx)
else:
j=indx
while(j<65):
if(mark[j]):
break
j+=1
if(j==65):
flg=0
break
mark[j]-=1
for h in range(j-1,indx,-1):
mark[h]+=1
ans+=1
ans+=1
indx+=1
if(flg):
print(ans)
else:
print(-1)
```
Yes
| 52,371 | [
0.252197265625,
-0.063232421875,
0.2464599609375,
-0.116455078125,
-0.775390625,
-0.479248046875,
-0.082763671875,
0.3466796875,
0.06939697265625,
1.0068359375,
0.6416015625,
0.13916015625,
0.29296875,
-0.49853515625,
-0.362060546875,
0.296142578125,
-0.333984375,
-0.50439453125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a bag of size n. Also you have m boxes. The size of i-th box is a_i, where each a_i is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if n = 10 and a = [1, 1, 32] then you have to divide the box of size 32 into two parts of size 16, and then divide the box of size 16. So you can fill the bag with boxes of size 1, 1 and 8.
Calculate the minimum number of divisions required to fill the bag of size n.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{18}, 1 ≤ m ≤ 10^5) — the size of bag and the number of boxes, respectively.
The second line of each test case contains m integers a_1, a_2, ... , a_m (1 ≤ a_i ≤ 10^9) — the sizes of boxes. It is guaranteed that each a_i is a power of two.
It is also guaranteed that sum of all m over all test cases does not exceed 10^5.
Output
For each test case print one integer — the minimum number of divisions required to fill the bag of size n (or -1, if it is impossible).
Example
Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Output
2
-1
0
Submitted Solution:
```
def lsb(N):
for i in range(64):
if N & (1 << i):
return i
assert False
def pay(top, N):
assert N != 0
lsb_pow = 1 << lsb(N)
res = 0
while top != lsb_pow:
res += 1
top //= 2
return res
def cost(N, nums):
nums.sort(reverse=True)
#print(N, nums)
res = 0
curr_sum = sum(nums)
if curr_sum < N: return -1
while N != 0:
#print((N, curr_sum, nums))
assert len(nums) > 0
assert curr_sum >= N
top = nums.pop()
if (1 << lsb(N)) == top:
N -= top
curr_sum -= top
elif top <= N:
assert top < N
assert len(nums) > 0
# take it if we have to:
if curr_sum - top < N:
N -= top
curr_sum -= top
continue
all_equal = [top]
while len(nums) > 0 and nums[-1] == top:
all_equal.append(nums.pop())
for i in range(len(all_equal) // 2):
nums.append(top*2)
curr_sum -= top * (len(all_equal) % 2)
else:
# We've reached the end. Have to pay.
return pay(top, N)
return 0
#cost(51, [16, 16, 16, 8, 2]) #[16, 16, 16, 16, 2])
#import random
#while True:
# N = random.randint(1, 100)
# M = 5
# lst = [2**random.randint(1, 5) for _ in range(M)]
# cost(N, lst)
T = int(input())
for _ in range(T):
N, _ = [int(x) for x in input().split()]
nums = [int(x) for x in input().split()]
print(cost(N, nums))
```
No
| 52,372 | [
0.25830078125,
-0.05718994140625,
0.265625,
-0.1978759765625,
-0.67529296875,
-0.312744140625,
-0.029144287109375,
0.24951171875,
0.07049560546875,
0.94384765625,
0.62744140625,
0.1279296875,
0.351806640625,
-0.479248046875,
-0.34130859375,
0.2376708984375,
-0.335205078125,
-0.5131... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a bag of size n. Also you have m boxes. The size of i-th box is a_i, where each a_i is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if n = 10 and a = [1, 1, 32] then you have to divide the box of size 32 into two parts of size 16, and then divide the box of size 16. So you can fill the bag with boxes of size 1, 1 and 8.
Calculate the minimum number of divisions required to fill the bag of size n.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{18}, 1 ≤ m ≤ 10^5) — the size of bag and the number of boxes, respectively.
The second line of each test case contains m integers a_1, a_2, ... , a_m (1 ≤ a_i ≤ 10^9) — the sizes of boxes. It is guaranteed that each a_i is a power of two.
It is also guaranteed that sum of all m over all test cases does not exceed 10^5.
Output
For each test case print one integer — the minimum number of divisions required to fill the bag of size n (or -1, if it is impossible).
Example
Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Output
2
-1
0
Submitted Solution:
```
def problem(n,a):
if sum(a) < n:
return -1
bit = [0] * 61
for i in a:
bit[i.bit_length() - 1] += 1
i, r = 0, 0
while i < 60:
if n >> i & 1:
if bit[i]:
bit[i] -= 1
else:
while i < 60 and bit[i] == 0:
bit[i], i, r = bit[i] + 1, i + 1, r + 1
bit[i] -= 1
bit[i+1] += bit[i] >> 1
i += 1
return r
for i in range(int(input())):
n = int(input().split()[0])
a = list(map(int,input().split()))
print(problem(n, a))
```
No
| 52,374 | [
0.1951904296875,
-0.0804443359375,
0.2333984375,
-0.121826171875,
-0.71435546875,
-0.52587890625,
-0.003200531005859375,
0.341796875,
0.0079193115234375,
1.0107421875,
0.599609375,
0.09417724609375,
0.2056884765625,
-0.498291015625,
-0.434326171875,
0.263427734375,
-0.309814453125,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
a=str(input()).split()
a=map(int,a)
a=sorted(a)
s=10
x=0
t=0
for i in range(n):
x+=a[i]
if x<360:
k=n
s=0
else:
i=0
while 360 >= (s+a[i]):
s+=a[i]
i+=1
k=i
if k !=0:
a[i]=a[i]-360+s
s=0
while (t+a[i]) <=360:
t+=a[i]
s+=t
k+=1
i+=1
if i==n:
t=370
i-=1
else:
if a[0]>710:
s=0
k=0
else:
k=1
s=a[0]-350
print(k,' ',s)
```
| 52,410 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
n = input()
a = sorted(map(int, input().split()))
ans = 0; t = 10; pen = 0
for i in a:
t += i
if t > 720:
break
ans += 1
pen += max(0, t - 360)
print(ans, pen)
# Made By Mostafa_Khaled
```
| 52,411 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
a.sort()
time = 0
cnt = 0
while cnt < n and time <= 350:
if time + a[cnt] > 350:
break
else:
time += a[cnt]
cnt += 1
left_time = 350 - time
if cnt < n:
a[cnt] -= left_time
penalty = [0]
all_time = 0
while cnt < n and all_time <= 360:
if all_time + a[cnt] > 360:
break
else:
all_time += a[cnt]
penalty.append(penalty[-1] + a[cnt])
cnt += 1
print(cnt, sum(penalty))
```
| 52,412 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
import sys
from itertools import *
from math import *
def solve():
n = int(input())
a = list(map(int, input().split()))
a.sort()
time = -6*60 + 10
maxtime = 6 * 60
completed = 0
penalty = 0
for i, val in enumerate(a):
timefinish = time + val
if timefinish <= maxtime:
penalty += max(0, timefinish)
completed+=1
time = timefinish
print(completed, penalty)
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()
```
| 52,413 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
n = input()
a = sorted(map(int, input().split()))
ans = 0; t = 10; pen = 0
for i in a:
t += i
if t > 720:
break
ans += 1
pen += max(0, t - 360)
print(ans, pen)
```
| 52,414 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
N = int(input())
nums = list(map(int, input().split()))
nums.sort()
fulltime = 720
start = 10
penalty = 0
probs = 0
for t in nums:
if t+start <= fulltime:
start += t
probs += 1
if start > 360:
penalty += (start - 360)
print(probs, penalty)
```
| 52,415 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
__author__ = 'Alex'
n = int(input())
a = [int(i) for i in input().split()]
a.sort()
s = 10
i = 0
while i < n and a[i] + s <= 360:
s += a[i]
i += 1
ans = 0
while i < n and a[i] + s <= 720:
s += a[i]
ans += s - 360
i += 1
print(i, ans)
```
| 52,416 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
a.sort()
s,ts,p = 0,10,0
for i in range(0,n):
if(ts+a[i]<=720):
ts=ts+a[i]
else:
break;
s=s+max(0,ts-360)
p=p+1
print(p,s)
```
| 52,417 | [
0.3486328125,
0.048248291015625,
-0.0200958251953125,
-0.048583984375,
-0.32177734375,
-0.515625,
-0.21484375,
0.0860595703125,
-0.1441650390625,
0.9375,
0.437744140625,
-0.0863037109375,
0.12646484375,
-0.59228515625,
-0.31494140625,
-0.1993408203125,
-0.638671875,
-0.483642578125... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Submitted Solution:
```
from bisect import bisect_right
n = int(input())
t = list(map(int, input().split()))
t.sort()
for i in range(1, n):
t[i] += t[i - 1]
i = bisect_right(t, 350)
j = bisect_right(t, 710)
print(j, sum(t[k] for k in range(i, j)) - 350 * (j - i))
```
Yes
| 52,418 | [
0.401611328125,
0.059417724609375,
-0.1397705078125,
-0.179931640625,
-0.42333984375,
-0.350830078125,
-0.303466796875,
0.1343994140625,
-0.2403564453125,
0.857421875,
0.458984375,
0.005977630615234375,
0.04241943359375,
-0.62109375,
-0.28466796875,
-0.224609375,
-0.65234375,
-0.45... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Submitted Solution:
```
n=int(input())
a=str(input()).split()
a=map(int,a)
a=sorted(a)
i=0
s=10
while s+a[i]<360:
s+=a[i]
i+=1
k=i
a[i]=a[i]-360+s
s=0
while s+a[i]<360:
s+=a[i]
i+=1
k+=1
print(k,' ',s)
```
No
| 52,419 | [
0.401611328125,
0.059417724609375,
-0.1397705078125,
-0.179931640625,
-0.42333984375,
-0.350830078125,
-0.303466796875,
0.1343994140625,
-0.2403564453125,
0.857421875,
0.458984375,
0.005977630615234375,
0.04241943359375,
-0.62109375,
-0.28466796875,
-0.224609375,
-0.65234375,
-0.45... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Submitted Solution:
```
n=int(input())
a=str(input()).split()
a=map(int,a)
a=sorted(a)
s=10
x=0
for i in range(n):
x+=a[i]
if x<360:
k=n
s=0
else:
i=0
while 360 >= (s+a[i]):
s+=a[i]
i+=1
k=i
if k !=0:
a[i]=a[i]-360+s
s=0
while (s+a[i]) <=360:
s+=a[i]
k+=1
i+=1
if i==n:
x=s
s=370
i-=1
else:
if a[0]>710:
s=0
k=0
else:
k=1
s=a[0]-350
if s==370:
s=x
print(k,' ',s)
```
No
| 52,420 | [
0.401611328125,
0.059417724609375,
-0.1397705078125,
-0.179931640625,
-0.42333984375,
-0.350830078125,
-0.303466796875,
0.1343994140625,
-0.2403564453125,
0.857421875,
0.458984375,
0.005977630615234375,
0.04241943359375,
-0.62109375,
-0.28466796875,
-0.224609375,
-0.65234375,
-0.45... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Submitted Solution:
```
n=int(input())
a=str(input()).split()
a=map(int,a)
a=sorted(a)
s=10
x=0
for i in range(n):
x+=a[i]
if x<360:
k=n
s=0
else:
i=0
while 360 >= (s+a[i]):
s+=a[i]
i+=1
k=i
if k !=0:
a[i]=a[i]-360+s
s=0
while (s+a[i]) <=360:
s+=a[i]
k+=1
i+=1
if i==n:
x=s
s=370
i-=1
else:
k=1
s=a[0]-350
if s==370:
s=x
print(k,' ',s)
```
No
| 52,421 | [
0.401611328125,
0.059417724609375,
-0.1397705078125,
-0.179931640625,
-0.42333984375,
-0.350830078125,
-0.303466796875,
0.1343994140625,
-0.2403564453125,
0.857421875,
0.458984375,
0.005977630615234375,
0.04241943359375,
-0.62109375,
-0.28466796875,
-0.224609375,
-0.65234375,
-0.45... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As Gerald sets the table, Alexander sends the greeting cards, and Sergey and his twins create an army of clone snowmen, Gennady writes a New Year contest.
The New Year contest begins at 18:00 (6.00 P.M.) on December 31 and ends at 6:00 (6.00 A.M.) on January 1. There are n problems for the contest. The penalty time for each solved problem is set as the distance from the moment of solution submission to the New Year in minutes. For example, the problem submitted at 21:00 (9.00 P.M.) gets penalty time 180, as well as the problem submitted at 3:00 (3.00 A.M.). The total penalty time is calculated as the sum of penalty time for all solved problems. It is allowed to submit a problem exactly at the end of the contest, at 6:00 (6.00 A.M.).
Gennady opened the problems exactly at 18:00 (6.00 P.M.) and managed to estimate their complexity during the first 10 minutes of the contest. He believes that writing a solution for the i-th problem will take ai minutes. Gennady can submit a solution for evaluation at any time after he completes writing it. Probably he will have to distract from writing some solution to send the solutions of other problems for evaluation. The time needed to send the solutions can be neglected, i.e. this time can be considered to equal zero. Gennady can simultaneously submit multiple solutions. Besides, he can move at any time from writing one problem to another, and then return to the first problem from the very same place, where he has left it. Thus the total solution writing time of the i-th problem always equals ai minutes. Of course, Gennady does not commit wrong attempts, and his solutions are always correct and are accepted from the first attempt. He can begin to write the solutions starting from 18:10 (6.10 P.M.).
Help Gennady choose from the strategies that help him solve the maximum possible number of problems, the one with which his total penalty time will be minimum.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the problems. The next line contains n space-separated integers ai (1 ≤ ai ≤ 720) — each number shows how much time in minutes Gennady will spend writing a solution to the problem.
Output
Print two integers — the number of problems Gennady will solve and the total penalty time considering that he chooses the optimal strategy.
Examples
Input
3
30 330 720
Output
2 10
Note
In the sample, one of Gennady's possible optimal strategies is as follows. At 18:10 (6:10 PM) he begins to write the first problem and solves it in 30 minutes (18:40 or 6.40 P.M.). At 18:40 (6.40 P.M.) he begins to write the second problem. There are 320 minutes left before the New Year, so Gennady does not have the time to finish writing the second problem before the New Year. At 0:00 (12.00 A.M.) he distracts from the second problem, submits the first one, and returns immediately to writing the second problem. At 0:10 (0.10 A.M.), he completes the solution for the second problem, submits it and gets 10 minute penalty time. Note that as the total duration of the contest is 720 minutes and Gennady has already spent 10 minutes on reading the problems, he will not have time to solve the third problem during the contest. Yes, such problems happen to exist.
Competitions by the given rules are held annually on the site http://b23.ru/3wvc
Submitted Solution:
```
from collections import defaultdict
n, t = int(input()), input().split()
p = defaultdict(int)
for i in t:
p[i] += 1
if len(p) < 3: print(0)
else:
q = list(p.items())
a, b = q[0][1], q[1][1]
x, y = 0, 1
if a < b: x, y, a, b = y, x, b, a
for i in range(2, len(q)):
if q[i][1] > b:
if q[i][1] > a: x, y, a, b = i, x, q[i][1], a
else: y, b = i, q[i][1]
k = n // 3
if a > k:
c, s = n - a - b, n - a
if c > b: q[x], q[y], k = (q[x][0], (s >> 1)), (q[y][0], b - (s & 1)), (s >> 1)
#(q[y][0], b - (s & 1)), (s >> 1)
else: q[x], q[y], k = (q[x][0], c), (q[y][0], c), c
q = [(int(x), y) for x, y in q]
q.sort(reverse = True)
p, n = [], 2 * k
for i in q:
p += [str(i[0]) + ' '] * i[1]
print(k)
print('\n'.join(p[i] + p[k + i] + p[n + i] for i in range(k)))
#mas facil estaba examen de Cappo
```
No
| 52,422 | [
0.401611328125,
0.059417724609375,
-0.1397705078125,
-0.179931640625,
-0.42333984375,
-0.350830078125,
-0.303466796875,
0.1343994140625,
-0.2403564453125,
0.857421875,
0.458984375,
0.005977630615234375,
0.04241943359375,
-0.62109375,
-0.28466796875,
-0.224609375,
-0.65234375,
-0.45... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A widely known among some people Belarusian sport programmer Lesha decided to make some money to buy a one square meter larger flat. To do this, he wants to make and carry out a Super Rated Match (SRM) on the site Torcoder.com. But there's a problem — a severe torcoder coordinator Ivan does not accept any Lesha's problem, calling each of them an offensive word "duped" (that is, duplicated). And one day they nearely quarrelled over yet another problem Ivan wouldn't accept.
You are invited to act as a fair judge and determine whether the problem is indeed brand new, or Ivan is right and the problem bears some resemblance to those used in the previous SRMs.
You are given the descriptions of Lesha's problem and each of Torcoder.com archive problems. The description of each problem is a sequence of words. Besides, it is guaranteed that Lesha's problem has no repeated words, while the description of an archive problem may contain any number of repeated words.
The "similarity" between Lesha's problem and some archive problem can be found as follows. Among all permutations of words in Lesha's problem we choose the one that occurs in the archive problem as a subsequence. If there are multiple such permutations, we choose the one with the smallest number of inversions. Then the "similarity" of a problem can be written as <image>, where n is the number of words in Lesha's problem and x is the number of inversions in the chosen permutation. Note that the "similarity" p is always a positive integer.
The problem is called brand new if there is not a single problem in Ivan's archive which contains a permutation of words from Lesha's problem as a subsequence.
Help the boys and determine whether the proposed problem is new, or specify the problem from the archive which resembles Lesha's problem the most, otherwise.
Input
The first line contains a single integer n (1 ≤ n ≤ 4) — the number of words in Lesha's problem. The second line contains n space-separated words — the short description of the problem.
The third line contains a single integer m (1 ≤ m ≤ 10) — the number of problems in the Torcoder.com archive. Next m lines contain the descriptions of the problems as "k s1 s2 ... sk", where k (1 ≤ k ≤ 20) is the number of words in the problem and si is a word of the problem description.
All words from all problem descriptions contain no more than 10 lowercase English letters.
Output
If Lesha's problem is brand new, print string "Brand new problem!" (without quotes).
Otherwise, on the first line print the index of the archive problem which resembles Lesha's problem most. If there are multiple such problems, print the one with the smallest index. On the second line print a string consisting of characters [:, character | repeated p times, and characters :], where p is the "similarity" between this problem and Lesha's one. The archive problems are numbered starting from one in the order in which they are given in the input.
Examples
Input
4
find the next palindrome
1
10 find the previous palindrome or print better luck next time
Output
1
[:||||||:]
Input
3
add two numbers
3
1 add
2 two two
3 numbers numbers numbers
Output
Brand new problem!
Input
4
these papers are formulas
3
6 what are these formulas and papers
5 papers are driving me crazy
4 crazy into the night
Output
1
[:||||:]
Input
3
add two decimals
5
4 please two decimals add
5 decimals want to be added
4 two add decimals add
4 add one two three
7 one plus two plus three equals six
Output
3
[:|||:]
Note
Let us remind you that the number of inversions is the number of pairs of words that follow in the permutation not in their original order. Thus, for example, if the original problem is "add two numbers", then permutation "numbers add two" contains two inversions — pairs of words "numbers" and "add", "numbers" and "two".
Sequence b1, b2, ..., bk is a subsequence of sequence a1, a2, ..., an if there exists such a set of indices 1 ≤ i1 < i2 < ... < ik ≤ n that aij = bj (in other words, if sequence b can be obtained from a by deleting some of its elements).
In the first test case the first problem contains the "find the palindrome next" permutation as a subsequence, in which the number of inversions equals 1 (words "palindrome" and "next").
In the second test case there is no problem that contains a permutation of words from Lesha's problem as a subsequence.
Submitted Solution:
```
import itertools
def check(curr_words, line):
if curr_words == []:
return True
for i in range(len(line)):
if line[i] == curr_words[0]:
return check(curr_words[1:], line[i+1:])
return False
n = int(input())
words = input().split()
m = int(input())
res, idx = 0, 0
for i in range(m):
line = input().split()[1:]
for p in itertools.permutations(range(n)):
curr_words = [words[j] for j in p]
cnt = 0
for j in range(n):
cnt += len([k for k in range(j+1, n) if p[k] < p[j]])
v = n * (n-1) // 2 - cnt + 1
if check(curr_words, line[:]) and v > res:
res, idx = v, i+1
if res > 0:
print(idx)
print('[:'+str('|'*res)+':]')
else:
print('Brand new wordslem!')
```
No
| 52,493 | [
0.225341796875,
0.296142578125,
0.057708740234375,
0.2056884765625,
-0.53515625,
-0.59130859375,
-0.35546875,
0.045654296875,
-0.276611328125,
0.98486328125,
0.7568359375,
-0.0258331298828125,
0.30322265625,
-0.67919921875,
-0.4638671875,
0.06756591796875,
-0.5146484375,
-0.6469726... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
n = int(input())
sm = 0
for i in input().split(): sm += int(i)
m = int(input())
for i in range(m):
(a,b) = (int(j) for j in input().split())
if sm<=b:
if sm>=a:
print(sm)
else:
print(a)
sm = -1
break
if sm!=-1:
print('-1')
```
Yes
| 52,747 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
n=int(input())
m=sum(map(int,input().split()))
t=0
for _ in range(0,int(input())):
(a,b)=map(int,input().split())
if a>=m:
print(a)
t=1
break
if a<=m and b>=m:
print(m)
t=1
break
if t==0:print("-1")
```
Yes
| 52,748 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
m = int(input())
b = [0]
prev_r = 0
for i in range(m):
l, r = map(int, input().split())
b = b + (l - prev_r - 1) * [0]
b = b + (r - l + 1) * [1]
prev_r = r
s = sum(a)
for i in range(s, len(b)):
if b[i] == 1:
print(i)
exit()
print(-1)
```
Yes
| 52,749 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
def main():
n = int(input())
a = [int(s) for s in input().split()]
m = int(input())
if m == 0:
print(-1)
return
l, r = [], []
for _ in range(m):
x, y = [int(s) for s in input().split()]
l.append(x)
r.append(y)
total_time = sum(a)
period = 0
while period < m and total_time > r[period]:
period += 1
if period < m:
print(max(total_time, l[period]))
else:
print(-1)
main()
```
Yes
| 52,750 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
def competition(a, lst):
s = sum(a)
for elem in lst:
if s <= elem[0]:
if s >= elem[1]:
return s
else:
return elem[1]
return -1
n = int(input())
b = [int(i) for i in input().split()]
c = list()
m = int(input())
for z in range(m):
l, r = [int(x) for x in input().split()]
c.append([l, r])
print(competition(b, c))
```
No
| 52,751 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
nn = int(input())
result = []
count = 0
if nn == 0:
print(-1)
exit()
for _ in range(nn):
ll, ul = list(map(int, input().split()))
result.append([ll, ul])
result = sorted(result)
s = sum(arr)
if s <= result[-1][1]:
count += 1
print(s)
else:
for k in result:
if k[1] >= sum(arr):
print(k[0])
count += 1
break
elif k[0] >= sum(arr):
print(k[0])
count += 1
break
if count == 0:
print(-1)
```
No
| 52,752 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
n = int(input())
solve = map(int, input().split())
s = sum(solve)
m = int(input())
flag = True
for i in range(m):
a, b = map(int, input().split())
if flag and a <= s <= b:
print(max(s, a))
flag = False
if flag:
print(-1)
```
No
| 52,753 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha is participating in a contest on one well-known website. This time he wants to win the contest and will do anything to get to the first place!
This contest consists of n problems, and Pasha solves ith problem in ai time units (his solutions are always correct). At any moment of time he can be thinking about a solution to only one of the problems (that is, he cannot be solving two problems at the same time). The time Pasha spends to send his solutions is negligible. Pasha can send any number of solutions at the same moment.
Unfortunately, there are too many participants, and the website is not always working. Pasha received the information that the website will be working only during m time periods, jth period is represented by its starting moment lj and ending moment rj. Of course, Pasha can send his solution only when the website is working. In other words, Pasha can send his solution at some moment T iff there exists a period x such that lx ≤ T ≤ rx.
Pasha wants to know his best possible result. We need to tell him the minimal moment of time by which he is able to have solutions to all problems submitted, if he acts optimally, or say that it's impossible no matter how Pasha solves the problems.
Input
The first line contains one integer n (1 ≤ n ≤ 1000) — the number of problems. The second line contains n integers ai (1 ≤ ai ≤ 105) — the time Pasha needs to solve ith problem.
The third line contains one integer m (0 ≤ m ≤ 1000) — the number of periods of time when the website is working. Next m lines represent these periods. jth line contains two numbers lj and rj (1 ≤ lj < rj ≤ 105) — the starting and the ending moment of jth period.
It is guaranteed that the periods are not intersecting and are given in chronological order, so for every j > 1 the condition lj > rj - 1 is met.
Output
If Pasha can solve and submit all the problems before the end of the contest, print the minimal moment of time by which he can have all the solutions submitted.
Otherwise print "-1" (without brackets).
Examples
Input
2
3 4
2
1 4
7 9
Output
7
Input
1
5
1
1 4
Output
-1
Input
1
5
1
1 5
Output
5
Note
In the first example Pasha can act like this: he solves the second problem in 4 units of time and sends it immediately. Then he spends 3 time units to solve the first problem and sends it 7 time units after the contest starts, because at this moment the website starts working again.
In the second example Pasha invents the solution only after the website stops working for the last time.
In the third example Pasha sends the solution exactly at the end of the first period.
Submitted Solution:
```
n = int(input())
t = list(map(int, input().split(' ')))
m = int(input())
work = []
for i in range(m):
work.append(list(map(int, input().split(' '))))
if (sum(t)>work[-1][-1]):
print(-1)
else:
for w in work:
if (sum(t) in set(range(w[1]+1))-set(range(w[0]))):
print(min([sum(t), w[0]]))
```
No
| 52,754 | [
0.48974609375,
0.25244140625,
-0.130126953125,
0.022796630859375,
-0.55029296875,
-0.39111328125,
-0.251220703125,
0.2413330078125,
0.014129638671875,
1.0654296875,
0.285888671875,
-0.01393890380859375,
0.0205078125,
-0.71142578125,
-0.474853515625,
0.2176513671875,
-0.64892578125,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems have been chosen by the judges, now it's time to assign scores to them!
Problem i must get an integer score A_i between 1 and N, inclusive. The problems have already been sorted by difficulty: A_1 \le A_2 \le \ldots \le A_N must hold. Different problems can have the same score, though.
Being an ICPC fan, you want contestants who solve more problems to be ranked higher. That's why, for any k (1 \le k \le N-1), you want the sum of scores of any k problems to be strictly less than the sum of scores of any k+1 problems.
How many ways to assign scores do you have? Find this number modulo the given prime M.
Constraints
* 2 \leq N \leq 5000
* 9 \times 10^8 < M < 10^9
* M is a prime.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of ways to assign scores to the problems, modulo M.
Examples
Input
2 998244353
Output
3
Input
3 998244353
Output
7
Input
6 966666661
Output
66
Input
96 925309799
Output
83779
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
"""
・N=6とする。
・[1,1,1,1,1,1],[0,1,1,1,1,1],[0,0,1,1,1,1],[0,0,0,1,1,1],[0,0,0,0,1,1],[0,0,0,0,0,1],[0,0,0,0,0,0]
合計ちょうど6個の線形結合 → 任意の単調数列。最初のやつは1回以上使わなければいけない。
・1,0,-1,-2,-2,-1,0 合計5個で0以上を作る
・-1,0,1,2,2,1,0 合計5個で0以下を作る
・0,1,2,3,3,2,1 合計5個で5以下を作る
・1,2,3,3,2,1 任意個数で5以下を作る
"""
N,MOD = map(int,read().split())
if N % 2 == 0:
A = list(range(1,N//2+1))*2
else:
A = list(range(1,N//2+1))*2+[(N+1)//2]
A.sort()
# 和 -> 通り
dp = [1] + [0] * (N+N+10)
for x in A:
for i in range(N+1):
dp[i] %= MOD
dp[i+x] += dp[i]
answer = sum(dp[:N]) % MOD
print(answer)
```
| 52,854 | [
0.6025390625,
-0.2066650390625,
-0.269775390625,
-0.005519866943359375,
-0.7001953125,
-0.3984375,
0.1632080078125,
0.053985595703125,
0.1845703125,
0.73193359375,
0.408203125,
-0.414794921875,
0.330078125,
-0.69873046875,
-0.38232421875,
0.0777587890625,
-0.37890625,
-0.9467773437... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems have been chosen by the judges, now it's time to assign scores to them!
Problem i must get an integer score A_i between 1 and N, inclusive. The problems have already been sorted by difficulty: A_1 \le A_2 \le \ldots \le A_N must hold. Different problems can have the same score, though.
Being an ICPC fan, you want contestants who solve more problems to be ranked higher. That's why, for any k (1 \le k \le N-1), you want the sum of scores of any k problems to be strictly less than the sum of scores of any k+1 problems.
How many ways to assign scores do you have? Find this number modulo the given prime M.
Constraints
* 2 \leq N \leq 5000
* 9 \times 10^8 < M < 10^9
* M is a prime.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of ways to assign scores to the problems, modulo M.
Examples
Input
2 998244353
Output
3
Input
3 998244353
Output
7
Input
6 966666661
Output
66
Input
96 925309799
Output
83779
"Correct Solution:
```
N,M=map(int,input().split())
A = list(range(1,N//2+1))*2
if N&1:A+=[(N+1)//2]
d=[1]+[0]*(N+N)
for x in A:
for i in range(N+1):
d[i]%=M
d[i+x]+=d[i]
print(sum(d[:N])%M)
```
| 52,855 | [
0.58056640625,
-0.2337646484375,
-0.339111328125,
-0.032196044921875,
-0.67431640625,
-0.373779296875,
0.1590576171875,
0.1573486328125,
0.1148681640625,
0.74658203125,
0.45166015625,
-0.33544921875,
0.372314453125,
-0.76953125,
-0.2337646484375,
0.10772705078125,
-0.334228515625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems have been chosen by the judges, now it's time to assign scores to them!
Problem i must get an integer score A_i between 1 and N, inclusive. The problems have already been sorted by difficulty: A_1 \le A_2 \le \ldots \le A_N must hold. Different problems can have the same score, though.
Being an ICPC fan, you want contestants who solve more problems to be ranked higher. That's why, for any k (1 \le k \le N-1), you want the sum of scores of any k problems to be strictly less than the sum of scores of any k+1 problems.
How many ways to assign scores do you have? Find this number modulo the given prime M.
Constraints
* 2 \leq N \leq 5000
* 9 \times 10^8 < M < 10^9
* M is a prime.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of ways to assign scores to the problems, modulo M.
Examples
Input
2 998244353
Output
3
Input
3 998244353
Output
7
Input
6 966666661
Output
66
Input
96 925309799
Output
83779
Submitted Solution:
```
import numpy as np
n, m = map(int, input().split())
coef = np.minimum(np.arange(n, 1, -1), np.arange(1, n))
dp = np.zeros(n, dtype=np.int64)
dp[0] = 1
for c in coef:
w = np.zeros(n, dtype=np.int64)
w[::c] = 1
dp = np.convolve(dp, w, mode='full')[:n] % m
print((dp * np.arange(n, 0, -1) % m).sum() % m)
```
No
| 52,856 | [
0.57080078125,
-0.281005859375,
-0.320556640625,
0.117919921875,
-0.7919921875,
-0.1829833984375,
0.0833740234375,
0.30615234375,
0.10357666015625,
0.537109375,
0.57275390625,
-0.35205078125,
0.35400390625,
-0.72607421875,
-0.246826171875,
0.08514404296875,
-0.40380859375,
-0.89111... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems have been chosen by the judges, now it's time to assign scores to them!
Problem i must get an integer score A_i between 1 and N, inclusive. The problems have already been sorted by difficulty: A_1 \le A_2 \le \ldots \le A_N must hold. Different problems can have the same score, though.
Being an ICPC fan, you want contestants who solve more problems to be ranked higher. That's why, for any k (1 \le k \le N-1), you want the sum of scores of any k problems to be strictly less than the sum of scores of any k+1 problems.
How many ways to assign scores do you have? Find this number modulo the given prime M.
Constraints
* 2 \leq N \leq 5000
* 9 \times 10^8 < M < 10^9
* M is a prime.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of ways to assign scores to the problems, modulo M.
Examples
Input
2 998244353
Output
3
Input
3 998244353
Output
7
Input
6 966666661
Output
66
Input
96 925309799
Output
83779
Submitted Solution:
```
n,a,b=map(int,input().split())
c=abs(a-b)
if(c%2==0):
print(int(c/2))
else:
d=(a+b+1)/2
e=(2*n+2-a-b+1)/2
f=min(d,e)
print(int(f))
```
No
| 52,857 | [
0.54296875,
-0.1954345703125,
-0.361328125,
0.0177459716796875,
-0.77099609375,
-0.246826171875,
0.08099365234375,
0.233154296875,
0.08953857421875,
0.7607421875,
0.400390625,
-0.286865234375,
0.33544921875,
-0.71337890625,
-0.2568359375,
0.1483154296875,
-0.38525390625,
-0.8393554... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems have been chosen by the judges, now it's time to assign scores to them!
Problem i must get an integer score A_i between 1 and N, inclusive. The problems have already been sorted by difficulty: A_1 \le A_2 \le \ldots \le A_N must hold. Different problems can have the same score, though.
Being an ICPC fan, you want contestants who solve more problems to be ranked higher. That's why, for any k (1 \le k \le N-1), you want the sum of scores of any k problems to be strictly less than the sum of scores of any k+1 problems.
How many ways to assign scores do you have? Find this number modulo the given prime M.
Constraints
* 2 \leq N \leq 5000
* 9 \times 10^8 < M < 10^9
* M is a prime.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of ways to assign scores to the problems, modulo M.
Examples
Input
2 998244353
Output
3
Input
3 998244353
Output
7
Input
6 966666661
Output
66
Input
96 925309799
Output
83779
Submitted Solution:
```
def factorial( n) :
M = 1000000007
f = 1
for i in range(1, n + 1):
f = f * i
return f % M
```
No
| 52,858 | [
0.5771484375,
-0.3046875,
-0.300048828125,
-0.00624847412109375,
-0.68505859375,
-0.2607421875,
0.1082763671875,
0.1671142578125,
0.041595458984375,
0.70068359375,
0.50341796875,
-0.30517578125,
0.30908203125,
-0.7734375,
-0.2332763671875,
0.1544189453125,
-0.36376953125,
-0.880859... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems have been chosen by the judges, now it's time to assign scores to them!
Problem i must get an integer score A_i between 1 and N, inclusive. The problems have already been sorted by difficulty: A_1 \le A_2 \le \ldots \le A_N must hold. Different problems can have the same score, though.
Being an ICPC fan, you want contestants who solve more problems to be ranked higher. That's why, for any k (1 \le k \le N-1), you want the sum of scores of any k problems to be strictly less than the sum of scores of any k+1 problems.
How many ways to assign scores do you have? Find this number modulo the given prime M.
Constraints
* 2 \leq N \leq 5000
* 9 \times 10^8 < M < 10^9
* M is a prime.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of ways to assign scores to the problems, modulo M.
Examples
Input
2 998244353
Output
3
Input
3 998244353
Output
7
Input
6 966666661
Output
66
Input
96 925309799
Output
83779
Submitted Solution:
```
import numpy as np
n,m=map(int, input().split())
coef = np.minimum(np.arange(n,1,-1),np.arange(1,n))
dp = np.zeros(n, dtype=np.int64)
dp[0] = 1
for c in coef:
ndp = dp.copy()
for i in range(0, n, c):
ndp[i:] += dp[:n-i]
dp = ndp % m #更新する
print((dp*np.arange(n, 0, -1) % m).sum() % m)
```
No
| 52,859 | [
0.591796875,
-0.341064453125,
-0.32421875,
0.0521240234375,
-0.79541015625,
-0.21337890625,
0.117919921875,
0.298095703125,
0.1815185546875,
0.58251953125,
0.53369140625,
-0.36376953125,
0.356689453125,
-0.6171875,
-0.290771484375,
0.182373046875,
-0.376953125,
-0.87744140625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
import sys
class QualityChecking:
def __init__(self, a, b, c, N):
self.__N = N
self.__a = a
self.__b = b
self.__c = c
self.__test = []
def read(self, i, j, k, r):
self.__test.append([i, j, k, r])
def solve(self):
result = [2] * (self.__a + self.__b + self.__c + 1)
ok = set()
ng = set()
unknown = set()
for t in self.__test:
if t[3] == 1:
ok.add(t[0])
ok.add(t[1])
ok.add(t[2])
test1 = []
for t in self.__test:
test1.append(["ok" if x in ok else x for x in t])
for t in test1:
if t[3] == 0:
if t[0] == "ok" and t[1] == "ok":
ng.add(t[2])
elif t[0] == "ok" and t[2] == "ok":
ng.add(t[1])
elif t[1] == "ok" and t[2] == "ok":
ng.add(t[0])
for i in range(1, self.__a + self.__b + self.__c + 1):
if i in ok:
print("1")
elif i in ng:
print("0")
else:
print("2")
while True:
line = input()
a, b, c = map(int, list(line.split()))
if a == 0 and b == 0 and c == 0:
break
line = input()
n = int(line)
qc = QualityChecking(a, b, c, n)
for _ in range(0, n):
i, j, k, r = map(int, list(input().split()))
qc.read(i, j, k, r)
qc.solve()
del qc
```
Yes
| 52,974 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
while 1:
try:
a,b,c=map(int,input().split())
parts=[2]*(a+b+c+1)
N=int(input())
met_keep=[]
for nn in range(N):
i,j,k,r=map(int,input().split())
if r==1:
parts[i],parts[j],parts[k]=1,1,1
if r==0:
met_keep.append([i,j,k])
for i,j,k in met_keep:
if parts[i]==1 and parts[j]==1 and parts[k]==2:
parts[k]=0
elif parts[i]==1 and parts[j]==2 and parts[k]==1:
parts[j]=0
elif parts[i]==2 and parts[j]==1 and parts[k]==1:
parts[i]=0
for i in parts[1:]:
print(i)
except:break
```
Yes
| 52,975 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
while True:
a,b,c = map(int,input().split())
if a == 0 and b == 0 and c == 0:
break
lst = [2 for i in range(a + b + c)]
ilst = []
n = int(input())
for i in range(n):
i,j,k,r = map(int,input().split())
if r == 0:
ilst.append((i,j,k))
else:
lst[i - 1] = 1
lst[j - 1] = 1
lst[k - 1] = 1
for (i,j,k) in ilst:
if lst[i - 1] == 1 and lst[j - 1] == 1:
lst[k - 1] = 0
elif lst[i - 1] == 1 and lst[k - 1] == 1:
lst[j - 1] = 0
elif lst[j - 1] == 1 and lst[k - 1] == 1:
lst[i - 1] = 0
for i in lst:
print(i)
```
Yes
| 52,976 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
while 1:
a,b,c = map(int, input().split())
if a == 0:
break
n = int(input())
d = {}
ans = [2]*(a+b+c)
for _ in range(n):
i, j, k, r = map(int, input().split())
d[(i, j, k)] = r
if r == 1:
ans[i-1] = ans[j-1] = ans[k-1] = 1
for i in d:
if d[i] == 0:
if ans[i[0]-1] == 1 and ans[i[1]-1] == 1:
ans[i[2]-1] = 0
elif ans[i[1]-1] == 1 and ans[i[2]-1] == 1:
ans[i[0]-1] = 0
elif ans[i[2]-1] == 1 and ans[i[0]-1] == 1:
ans[i[1]-1] = 0
for i in range(a+b+c):
print(ans[i])
```
Yes
| 52,977 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
while True:
a, b, c = map(int, input().split())
if a == 0:
break
N = int(input())
end = a+b+c+1
parts = [0]*(end)
tmp = {k:[] for k in range(end)}
for _ in range(N):
i, j, k, r = map(int, input().split())
for v in [i, j, k]:
parts[v] += r
if r == 0:
tmp[v].append([i, j, k])
for i in range(1, end):
if parts[i]:
print(1)
else:
flag = True
for j in range(len(tmp[i])):
tmp[i][j].remove(i)
a, b = tmp[i][j][0], tmp[i][j][1]
if parts[a] and parts[b]:
flag = True
break
else:
flag = False
print(0 if flag else 2)
```
No
| 52,978 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
for e in iter(input,'0 0 0'):
d=[2]*-~sum(map(int,e.split()))
f=[]
for _ in[0]*int(input()):
s,t,u,v=map(int,input().split())
if v:d[s]=d[t]=d[u]=1
else:f+=[(s,t,u)]
for s,t,u in f:
d[s]=2*(d[t]*d[u]!=1)
d[t]=2*(d[u]*d[s]!=1)
d[u]=2*(d[s]*d[t]!=1)
for x in d[1:]:print(x)
```
No
| 52,979 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
while True:
a, b, c = map(int, input().split())
if a == 0:
break
N = int(input())
end = a+b+c+1
parts = [0]*(end)
tmp = {k:[] for k in range(end)}
for _ in range(N):
i, j, k, r = map(int, input().split())
for v in [i, j, k]:
parts[v] += r
if r == 0:
tmp[v].append([i, j, k])
for i in range(1, end):
if parts[i]:
print("1")
else:
flag = True
for j in range(len(tmp[i])):
tmp[i][j].remove(i)
a, b = tmp[i][j][0], tmp[i][j][1]
if parts[a] and parts[b]:
flag = True
break
else:
flag = False
print("0" if flag else "2")
```
No
| 52,980 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 ≤ i ≤ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
Submitted Solution:
```
while True:
m = sum(map(int, input().split()))
if not m:
break
n = int(input())
fixed = [2] * m
failures = []
for _ in range(n):
i, j, k, r = map(int, input().split())
i, j, k = (x - 1 for x in (i, j, k))
if r:
fixed[i] = fixed[j] = fixed[k] = 1
else:
failures.append((i, j, k))
for i, j, k in failures:
fi, fj, fk = (fixed[x] for x in (i, j, k))
if fi == 1:
if fj == 1:
fixed[k] = 0
elif fk == 1:
fixed[j] = 0
elif fj == 1 and fk == 1:
fi = 0
print('\n'.join(str(x) for x in fixed) + '\n')
```
No
| 52,981 | [
0.021942138671875,
-0.1219482421875,
0.1435546875,
0.08428955078125,
-0.476318359375,
-0.326416015625,
-0.0214996337890625,
-0.09466552734375,
0.20263671875,
0.7294921875,
0.326904296875,
0.2208251953125,
-0.17138671875,
-0.92236328125,
-0.857421875,
0.17236328125,
-0.705078125,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
while True:
line = input()
if line == "0 0":
break
stock, max_difficulty = map(int, line.split(" "))
max_recommend_list = [0 for _ in range(max_difficulty)]
for i in range(stock):
difficulty, recommend = map(int, input().split(" "))
max_recommend_list[difficulty - 1] = max(max_recommend_list[difficulty - 1], recommend)
print(sum(max_recommend_list))
```
| 53,021 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
# AOJ 2823: JAG Practice Contest
# Python3 2018.7.11 bal4u
while True:
N, M = map(int, input().split())
if N == 0: break
ma = [0]*(M+1)
for i in range(N):
d, v = map(int, input().split())
ma[d] = max(ma[d], v)
print(sum(ma))
```
| 53,022 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
while True:
n,m = map(int,input().split())
if n+m == 0:break
lst = []
for _ in range(n):
d,v = map(int,input().split())
lst.append((d,v))
lst.sort()
ans = 0
for i,a in enumerate(lst):
if i == len(lst)-1:
ans += a[1]
continue
if lst[i+1][0] != a[0]:
ans += a[1]
print(ans)
```
| 53,023 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
while True:
N,M = map(int,input().split())
if N == 0 and M == 0:
break
ans = 0
di = []
vi = []
for i in range(0,N):
d,v = map(int,input().split())
di.append(d)
vi.append(v)
for i in range(1,M+1):
max = 0
for j in range(0,N):
if di[j] == i and max < vi[j]:
max = vi[j]
ans+=max
print(ans)
```
| 53,024 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
while True:
N,M=map(int,input().split())
if N==0 and M==0:
break
l = [0]*M
for i in range(N):
d,v=map(int,input().split())
if l[d-1]<v:
l[d-1]=v
total = 0
for i in range(M):
total += l[i]
print(total)
```
| 53,025 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
import sys
def solve(n, m):
l = []
for i in range(n):
d, v = map(int, input().split())
l.append((d, v))
l.sort(reverse=True)
now = -1
count = 0
for i in l:
if now == i[0]:
continue
else:
count += i[1]
now = i[0]
print(count)
while True:
n, m = map(int, input().split())
if n == m == 0:
break
solve(n, m)
```
| 53,026 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
#21:40
#21:
while True:
n,m = map(int,input().split())
if n ==0 : break
#難易度と最大推薦度の辞書
question_dict={}
for i in range(n):
difficult,recommend = map(int,input().split())
if difficult in question_dict:
question_dict[difficult] = max(question_dict[difficult],recommend)
else:
question_dict[difficult] = recommend
print(sum(question_dict.values()))
```
| 53,027 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
"Correct Solution:
```
while True:
(n, m) = tuple(map(int, input().split()))
if n == 0:
break
arr = [0 for i in range(m + 1)]
for i in range(n):
inp = list(map(int, input().split()))
arr[inp[0]] = max(inp[1], arr[inp[0]])
res = 0
for e in arr:
res += e
print(res)
```
| 53,028 | [
0.74365234375,
0.004058837890625,
-0.034698486328125,
0.0628662109375,
-0.47509765625,
-0.480712890625,
-0.11871337890625,
0.58447265625,
-0.1470947265625,
0.78662109375,
0.5498046875,
-0.07293701171875,
0.49267578125,
-0.720703125,
-0.2275390625,
0.348388671875,
-0.63525390625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
Submitted Solution:
```
from collections import defaultdict
while True:
n, m = map(int, input().split())
if n == 0:break
dic = defaultdict(int)
for _ in range(n):
d, v = map(int, input().split())
dic[d] = max(dic[d], v)
print(sum(dic.values()))
```
Yes
| 53,029 | [
0.69970703125,
-0.019989013671875,
-0.12939453125,
0.140380859375,
-0.474365234375,
-0.425537109375,
-0.1578369140625,
0.5732421875,
-0.168212890625,
0.7255859375,
0.59228515625,
-0.049285888671875,
0.427001953125,
-0.744140625,
-0.1650390625,
0.423828125,
-0.52734375,
-0.567382812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
Submitted Solution:
```
while 1:
n, m = map(int, input().split())
if n == 0:
break
rec = [0] * (m+1)
for _ in range(n):
d, v = map(int, input().split())
if rec[d] < v:
rec[d] = v
print(sum(rec))
```
Yes
| 53,030 | [
0.69970703125,
-0.019989013671875,
-0.12939453125,
0.140380859375,
-0.474365234375,
-0.425537109375,
-0.1578369140625,
0.5732421875,
-0.168212890625,
0.7255859375,
0.59228515625,
-0.049285888671875,
0.427001953125,
-0.744140625,
-0.1650390625,
0.423828125,
-0.52734375,
-0.567382812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
Submitted Solution:
```
#d = むずかしさ, v = 推薦度
ans2 = []
while(1):
tip = []
tmp = []
ans = 0
n, m = map(int,input().split())
if n == 0 and m == 0:
break
else:
for i in range(n):
d, v = map(int,input().split())
tip.append([d, v])
tip = sorted(tip, key = lambda x: x[1])
tip.reverse()
#print(tip)
for i in range(n):
if tip[i][0] in tmp:
pass
else:
ans += tip[i][1]
m += 1
tmp.append(tip[i][0])
#print("ans = {}".format(ans))
ans2.append(ans)
for i in ans2:
print(i)
```
Yes
| 53,031 | [
0.69970703125,
-0.019989013671875,
-0.12939453125,
0.140380859375,
-0.474365234375,
-0.425537109375,
-0.1578369140625,
0.5732421875,
-0.168212890625,
0.7255859375,
0.59228515625,
-0.049285888671875,
0.427001953125,
-0.744140625,
-0.1650390625,
0.423828125,
-0.52734375,
-0.567382812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
Submitted Solution:
```
while True:
N,M=map(int,input().split())
if N == 0 and M == 0:
break
mp = {}
for _ in [0]*N:
d,v=map(int,input().split())
if d in mp:
mp[d] = max(mp[d],v)
else :
mp[d] = v
maxi=0
for v in mp.values():
maxi+=v
print(maxi)
```
Yes
| 53,032 | [
0.69970703125,
-0.019989013671875,
-0.12939453125,
0.140380859375,
-0.474365234375,
-0.425537109375,
-0.1578369140625,
0.5732421875,
-0.168212890625,
0.7255859375,
0.59228515625,
-0.049285888671875,
0.427001953125,
-0.744140625,
-0.1650390625,
0.423828125,
-0.52734375,
-0.567382812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
JAG mock qualifying practice session
The ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG) has N questions in stock of questions to be asked in the mock contest, and each question is numbered with an integer from 1 to N. Difficulty evaluation and recommendation voting are conducted for each problem. Problem i has a difficulty level of di and a recommendation level of vi. The maximum difficulty level is M.
In the next contest, we plan to ask a total of M questions, one for each of the difficulty levels 1 to M. In order to improve the quality of the contest, I would like to select the questions so that the total recommendation level is maximized. However, since JAG's questioning ability is tremendous, it can be assumed that there is at least one question for each difficulty level.
Your job is to create a program that finds the maximum sum of the sums of recommendations when the questions are selected to meet the conditions.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> N M
> d1 v1
> ...
> dN vN
>
The first line of the dataset is given an integer N, which represents the number of problem stocks, and a maximum difficulty value, M, separated by blanks. These numbers satisfy 1 ≤ M ≤ N ≤ 100. On the i-th line of the following N lines, the integers di and vi representing the difficulty level and recommendation level of problem i are given, separated by blanks. These numbers satisfy 1 ≤ di ≤ M and 0 ≤ vi ≤ 100. Also, for each 1 ≤ j ≤ M, it is guaranteed that there is at least one i such that di = j.
> The end of the input is represented by two zeros separated by a blank. Also, the number of datasets does not exceed 50.
> ### Output
For each data set, output the maximum value of the sum of the recommendation levels of the questions to be asked when one question is asked from each difficulty level on one line.
> ### Sample Input
5 3
1 1
twenty three
3 2
3 5
twenty one
4 2
1 7
twenty one
13
1 5
6 1
13
1 2
1 8
1 2
1 7
1 6
20 9
4 10
twenty four
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
14
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
twenty three
5 4
2 10
1 8
3 4
3 1
5 4
1 10
13
5 6
5 2
1 10
twenty three
0 0
There are 5 sample datasets, in order
Lines 1 to 6 are the first (N = 5, M = 3) test cases,
Lines 7 to 11 are the second (N = 4, M = 2) test case,
Lines 12-18 are the third (N = 6, M = 1) test case,
The fourth (N = 20, M = 9) test case from line 19 to line 39,
Lines 40 to 59 represent the fifth test case (N = 19, M = 6).
Output for Sample Input
9
8
8
71
51
Example
Input
5 3
1 1
2 3
3 2
3 5
2 1
4 2
1 7
2 1
1 3
1 5
6 1
1 3
1 2
1 8
1 2
1 7
1 6
20 9
4 10
2 4
5 3
6 6
6 3
7 4
8 10
4 6
7 5
1 8
5 7
1 5
6 6
9 9
5 8
6 7
1 4
6 4
7 10
3 5
19 6
4 1
6 5
5 10
1 10
3 10
4 6
2 3
5 4
2 10
1 8
3 4
3 1
5 4
1 10
1 3
5 6
5 2
1 10
2 3
0 0
Output
9
8
8
71
51
Submitted Solution:
```
m,n=map(int,input().split())
a =[]
for _ in range(m):
a.append(list(map(int,input().split())))
for index in range(m):
a[index].append(sum(a[index]))
for a_column in a:
for num in a_column[:-1]:
print(num, end=' ')
print(a_column[-1])
for row_index in range(n+1):
sum = 0
for a_column in a:
sum += a_column[row_index]
print(sum, end=' ')
print()
```
No
| 53,033 | [
0.69970703125,
-0.019989013671875,
-0.12939453125,
0.140380859375,
-0.474365234375,
-0.425537109375,
-0.1578369140625,
0.5732421875,
-0.168212890625,
0.7255859375,
0.59228515625,
-0.049285888671875,
0.427001953125,
-0.744140625,
-0.1650390625,
0.423828125,
-0.52734375,
-0.567382812... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.
The jury guessed some array a consisting of 6 integers. There are 6 special numbers — 4, 8, 15, 16, 23, 42 — and each of these numbers occurs in a exactly once (so, a is some permutation of these numbers).
You don't know anything about their order, but you are allowed to ask up to 4 queries. In each query, you may choose two indices i and j (1 ≤ i, j ≤ 6, i and j are not necessarily distinct), and you will get the value of a_i ⋅ a_j in return.
Can you guess the array a?
The array a is fixed beforehand in each test, the interaction program doesn't try to adapt to your queries.
Interaction
Before submitting the answer, you may ask up to 4 queries. To ask a query, print one line in the following format: ? i j, where i and j should be two integers such that 1 ≤ i, j ≤ 6. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query — one line containing one integer a_i ⋅ a_j. If you submit an incorrect query (or ask more than 4 queries), the answer to it will be one string 0. After receiving such an answer, your program should terminate immediately — otherwise you may receive verdict "Runtime error", "Time limit exceeded" or some other verdict instead of "Wrong answer".
To give the answer, your program should print one line ! a_1 a_2 a_3 a_4 a_5 a_6 with a line break in the end. After that, it should flush the output and terminate gracefully.
Example
Input
16
64
345
672
Output
? 1 1
? 2 2
? 3 5
? 4 6
! 4 8 15 16 23 42
Note
If you want to submit a hack for this problem, your test should contain exactly six space-separated integers a_1, a_2, ..., a_6. Each of 6 special numbers should occur exactly once in the test. The test should be ended with a line break character.
Tags: brute force, divide and conquer, interactive, math
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 15 18:26:08 2019
@author: Hamadeh
"""
class LLNode:
def __init__(self, data):
self.data = data
self.next = None
self.prev = None
# Class to create a Doubly Linked List
class LL:
# Constructor for empty Doubly Linked List
def __init__(self):
self.head = None
# Given a reference to the head of a list and an
# integer, inserts a new node on the front of list
def push(self, new_data):
# 1. Allocates node
# 2. Put the data in it
new_node = LLNode(new_data)
# 3. Make next of new node as head and
# previous as None (already None)
new_node.next = self.head
# 4. change prev of head node to new_node
if self.head is not None:
self.head.prev = new_node
# 5. move the head to point to the new node
self.head = new_node
# Given a node as prev_node, insert a new node after
# the given node
def insertAfter(self, prev_node, new_data):
# 1. Check if the given prev_node is None
if prev_node is None:
print ("the given previous node cannot be NULL")
return
# 2. allocate new node
# 3. put in the data
new_node = LLNode(new_data)
# 4. Make net of new node as next of prev node
new_node.next = prev_node.next
# 5. Make prev_node as previous of new_node
prev_node.next = new_node
# 6. Make prev_node ass previous of new_node
new_node.prev = prev_node
# 7. Change previous of new_nodes's next node
if new_node.next is not None:
new_node.next.prev = new_node
return new_node
# Given a reference to the head of DLL and integer,
# appends a new node at the end
def append(self, new_data):
# 1. Allocates node
# 2. Put in the data
new_node = LLNode(new_data)
# 3. This new node is going to be the last node,
# so make next of it as None
new_node.next = None
# 4. If the Linked List is empty, then make the
# new node as head
if self.head is None:
new_node.prev = None
self.head = new_node
return
# 5. Else traverse till the last node
last = self.head
while(last.next is not None):
last = last.next
# 6. Change the next of last node
last.next = new_node
# 7. Make last node as previous of new node
new_node.prev = last
return new_node
# This function prints contents of linked list
# starting from the given node
def printList(self, node):
print ("\nTraversal in forward direction")
while(node is not None):
print (" % d" ,(node.data),)
last = node
node = node.next
print ("\nTraversal in reverse direction")
while(last is not None):
print (" % d" ,(last.data),)
last = last.prev
class cinn:
def __init__(self):
self.x=[]
def cin(self,t=int):
if(len(self.x)==0):
a=input()
self.x=a.split()
self.x.reverse()
return self.get(t)
def get(self,t):
return t(self.x.pop())
def clist(self,n,t=int): #n is number of inputs, t is type to be casted
l=[0]*n
for i in range(n):
l[i]=self.cin(t)
return l
def clist2(self,n,t1=int,t2=int,t3=int,tn=2):
l=[0]*n
for i in range(n):
if(tn==2):
a1=self.cin(t1)
a2=self.cin(t2)
l[i]=(a1,a2)
elif (tn==3):
a1=self.cin(t1)
a2=self.cin(t2)
a3=self.cin(t3)
l[i]=(a1,a2,a3)
return l
def clist3(self,n,t1=int,t2=int,t3=int):
return self.clist2(self,n,t1,t2,t3,3)
def cout(self,i,ans=''):
if(ans==''):
print("Case #"+str(i+1)+":", end=' ')
else:
print("Case #"+str(i+1)+":",ans)
def printf(self,thing):
print(thing,end='')
def countlist(self,l,s=0,e=None):
if(e==None):
e=len(l)
dic={}
for el in range(s,e):
if l[el] not in dic:
dic[l[el]]=1
else:
dic[l[el]]+=1
return dic
def talk (self,x):
print(x,flush=True)
def dp1(self,k):
L=[-1]*(k)
return L
def dp2(self,k,kk):
L=[-1]*(k)
for i in range(k):
L[i]=[-1]*kk
return L
c=cinn();
L=[4,8,15,16,23,42]
Lans=[]
c.talk("? 1 2")
p1=c.cin()
c.talk("? 3 4")
p2=c.cin()
c.talk("? 1 5")
p3=c.cin()
c.talk("? 3 6")
p4=c.cin()
a1=0;
a2=0;
a3=0;
a4=0
a5=0
a6=0
for x in L:
#print(p1//x, p2//x, p3//x,p4//x)
if p1//x in L and p3//x in L and p1%x==0 and p3%x==0 and x!=p3**0.5 and x!=p1**0.5:
a1=x
a2=p1//x
a5=p3//x
if(p2//x in L and p4//x in L and p2%x==0 and p4%x==0 and x!=p2**0.5 and x!=p4**0.5):
a3=x
a4=p2//x
a6=p4//x
print("!",a1,a2,a3,a4,a5,a6)
```
| 53,118 | [
-0.1761474609375,
0.109130859375,
0.1875,
0.23291015625,
-0.7314453125,
-0.384521484375,
-0.31787109375,
0.0245513916015625,
0.02569580078125,
0.818359375,
0.380126953125,
-0.01641845703125,
-0.0516357421875,
-0.82373046875,
-0.77490234375,
-0.054107666015625,
-0.36328125,
-0.97998... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.
The jury guessed some array a consisting of 6 integers. There are 6 special numbers — 4, 8, 15, 16, 23, 42 — and each of these numbers occurs in a exactly once (so, a is some permutation of these numbers).
You don't know anything about their order, but you are allowed to ask up to 4 queries. In each query, you may choose two indices i and j (1 ≤ i, j ≤ 6, i and j are not necessarily distinct), and you will get the value of a_i ⋅ a_j in return.
Can you guess the array a?
The array a is fixed beforehand in each test, the interaction program doesn't try to adapt to your queries.
Interaction
Before submitting the answer, you may ask up to 4 queries. To ask a query, print one line in the following format: ? i j, where i and j should be two integers such that 1 ≤ i, j ≤ 6. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query — one line containing one integer a_i ⋅ a_j. If you submit an incorrect query (or ask more than 4 queries), the answer to it will be one string 0. After receiving such an answer, your program should terminate immediately — otherwise you may receive verdict "Runtime error", "Time limit exceeded" or some other verdict instead of "Wrong answer".
To give the answer, your program should print one line ! a_1 a_2 a_3 a_4 a_5 a_6 with a line break in the end. After that, it should flush the output and terminate gracefully.
Example
Input
16
64
345
672
Output
? 1 1
? 2 2
? 3 5
? 4 6
! 4 8 15 16 23 42
Note
If you want to submit a hack for this problem, your test should contain exactly six space-separated integers a_1, a_2, ..., a_6. Each of 6 special numbers should occur exactly once in the test. The test should be ended with a line break character.
Submitted Solution:
```
l = [4, 8, 15, 16, 23, 42]
d = {}
for i in range(6):
for j in range(i+1, 6):
d[l[i]*l[j]] = [l[i], l[j]]
print(len(d))
a = [0]*6
import sys
sys.stdout.flush()
print('?', 1, 2)
n = int(input())
x = d[n]
print('?', 2, 3)
n = int(input())
y = d[n]
for i in x:
if(i in y):
a[1] = i
else:
a[0] = i
for i in y:
if(i in x):
a[1] = i
else:
a[2] = i
print('?', 4, 5)
n = int(input())
x = d[n]
print('?', 5, 6)
n = int(input())
y = d[n]
for i in x:
if(i in y):
a[4] = i
else:
a[3] = i
for i in y:
if(i in x):
a[4] = i
else:
a[5] = i
print('!',' '.join(map(str,a)))
```
No
| 53,119 | [
-0.045806884765625,
0.099609375,
-0.020965576171875,
0.160888671875,
-0.7763671875,
-0.21630859375,
-0.220947265625,
0.1163330078125,
-0.01354217529296875,
0.7939453125,
0.42822265625,
-0.08270263671875,
-0.058990478515625,
-0.748046875,
-0.732421875,
-0.1690673828125,
-0.4013671875,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.
The jury guessed some array a consisting of 6 integers. There are 6 special numbers — 4, 8, 15, 16, 23, 42 — and each of these numbers occurs in a exactly once (so, a is some permutation of these numbers).
You don't know anything about their order, but you are allowed to ask up to 4 queries. In each query, you may choose two indices i and j (1 ≤ i, j ≤ 6, i and j are not necessarily distinct), and you will get the value of a_i ⋅ a_j in return.
Can you guess the array a?
The array a is fixed beforehand in each test, the interaction program doesn't try to adapt to your queries.
Interaction
Before submitting the answer, you may ask up to 4 queries. To ask a query, print one line in the following format: ? i j, where i and j should be two integers such that 1 ≤ i, j ≤ 6. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query — one line containing one integer a_i ⋅ a_j. If you submit an incorrect query (or ask more than 4 queries), the answer to it will be one string 0. After receiving such an answer, your program should terminate immediately — otherwise you may receive verdict "Runtime error", "Time limit exceeded" or some other verdict instead of "Wrong answer".
To give the answer, your program should print one line ! a_1 a_2 a_3 a_4 a_5 a_6 with a line break in the end. After that, it should flush the output and terminate gracefully.
Example
Input
16
64
345
672
Output
? 1 1
? 2 2
? 3 5
? 4 6
! 4 8 15 16 23 42
Note
If you want to submit a hack for this problem, your test should contain exactly six space-separated integers a_1, a_2, ..., a_6. Each of 6 special numbers should occur exactly once in the test. The test should be ended with a line break character.
Submitted Solution:
```
def main():
import sys
input = sys.stdin.readline
A = ['?']
for i in range(100):
A.append((1 << 7) * i)
print(*A, flush=True)
ans1 = int(input()) % (1<<7)
A = ['?']
for i in range(100):
A.append(i)
print(*A, flush=True)
ans2 = int(input()) >> 7
print('!', ans1 + ans2, flush=True)
if __name__ == '__main__':
main()
```
No
| 53,120 | [
-0.045806884765625,
0.099609375,
-0.020965576171875,
0.160888671875,
-0.7763671875,
-0.21630859375,
-0.220947265625,
0.1163330078125,
-0.01354217529296875,
0.7939453125,
0.42822265625,
-0.08270263671875,
-0.058990478515625,
-0.748046875,
-0.732421875,
-0.1690673828125,
-0.4013671875,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.
The jury guessed some array a consisting of 6 integers. There are 6 special numbers — 4, 8, 15, 16, 23, 42 — and each of these numbers occurs in a exactly once (so, a is some permutation of these numbers).
You don't know anything about their order, but you are allowed to ask up to 4 queries. In each query, you may choose two indices i and j (1 ≤ i, j ≤ 6, i and j are not necessarily distinct), and you will get the value of a_i ⋅ a_j in return.
Can you guess the array a?
The array a is fixed beforehand in each test, the interaction program doesn't try to adapt to your queries.
Interaction
Before submitting the answer, you may ask up to 4 queries. To ask a query, print one line in the following format: ? i j, where i and j should be two integers such that 1 ≤ i, j ≤ 6. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query — one line containing one integer a_i ⋅ a_j. If you submit an incorrect query (or ask more than 4 queries), the answer to it will be one string 0. After receiving such an answer, your program should terminate immediately — otherwise you may receive verdict "Runtime error", "Time limit exceeded" or some other verdict instead of "Wrong answer".
To give the answer, your program should print one line ! a_1 a_2 a_3 a_4 a_5 a_6 with a line break in the end. After that, it should flush the output and terminate gracefully.
Example
Input
16
64
345
672
Output
? 1 1
? 2 2
? 3 5
? 4 6
! 4 8 15 16 23 42
Note
If you want to submit a hack for this problem, your test should contain exactly six space-separated integers a_1, a_2, ..., a_6. Each of 6 special numbers should occur exactly once in the test. The test should be ended with a line break character.
Submitted Solution:
```
from sys import stdout
a = [bin(i) for i in range(100)]
b = ['0000000' + (9-len(i))*'0' + i[2:] for i in a]
c = [i[2:] + (9-len(i))*'0' + '0000000' for i in a]
print('?',*b)
stdout.flush()
n = bin(int(input()))[2:]
n = (14-len(n))*'0' + n
print('?',*c)
stdout.flush()
m = bin(int(input()))[2:]
m = (14-len(m))*'0' + m
ans = int('0b'+n[:7]+m[7:],2)
print(ans)
```
No
| 53,121 | [
-0.045806884765625,
0.099609375,
-0.020965576171875,
0.160888671875,
-0.7763671875,
-0.21630859375,
-0.220947265625,
0.1163330078125,
-0.01354217529296875,
0.7939453125,
0.42822265625,
-0.08270263671875,
-0.058990478515625,
-0.748046875,
-0.732421875,
-0.1690673828125,
-0.4013671875,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.
The jury guessed some array a consisting of 6 integers. There are 6 special numbers — 4, 8, 15, 16, 23, 42 — and each of these numbers occurs in a exactly once (so, a is some permutation of these numbers).
You don't know anything about their order, but you are allowed to ask up to 4 queries. In each query, you may choose two indices i and j (1 ≤ i, j ≤ 6, i and j are not necessarily distinct), and you will get the value of a_i ⋅ a_j in return.
Can you guess the array a?
The array a is fixed beforehand in each test, the interaction program doesn't try to adapt to your queries.
Interaction
Before submitting the answer, you may ask up to 4 queries. To ask a query, print one line in the following format: ? i j, where i and j should be two integers such that 1 ≤ i, j ≤ 6. The line should be ended with a line break character. After submitting a query, flush the output and read the answer to your query — one line containing one integer a_i ⋅ a_j. If you submit an incorrect query (or ask more than 4 queries), the answer to it will be one string 0. After receiving such an answer, your program should terminate immediately — otherwise you may receive verdict "Runtime error", "Time limit exceeded" or some other verdict instead of "Wrong answer".
To give the answer, your program should print one line ! a_1 a_2 a_3 a_4 a_5 a_6 with a line break in the end. After that, it should flush the output and terminate gracefully.
Example
Input
16
64
345
672
Output
? 1 1
? 2 2
? 3 5
? 4 6
! 4 8 15 16 23 42
Note
If you want to submit a hack for this problem, your test should contain exactly six space-separated integers a_1, a_2, ..., a_6. Each of 6 special numbers should occur exactly once in the test. The test should be ended with a line break character.
Submitted Solution:
```
import sys
a=[0]*6
b=[4 , 8, 15, 16, 23, 42]
tmp=[]
print('?',1,2)
sys.stdout.flush()
pr=int(input())
z=pr
for i in range(6):
for j in range(6):
if b[i]*b[j]==pr:
tmp=[b[i],b[j]]
print('?',2,3)
sys.stdout.flush()
pr=int(input())
flag=True
for i in range(6):
for j in range(6):
if b[i]*b[j]==pr and flag:
if b[i] in tmp:
cur=b[j]
if b[i]==tmp[0]:
a[1]=tmp[0]
a[0]=tmp[1]
a[2]=b[j]
else:
a[1]=tmp[1]
a[0]=tmp[0]
a[2]=b[j]
else:
cur=b[i]
if b[j]==tmp[0]:
a[1]=tmp[0]
a[0]=tmp[1]
a[2]=b[i]
else:
a[1]=tmp[1]
a[0]=tmp[0]
a[2]=b[i]
flag=False
for i in range(2,4):
print('?',i+1,i+2)
sys.stdout.flush()
s=int(input())
a[i+1]=s//cur
cur=s//cur
for i in b:
if not i in a:
a[5]=i
print(*a)
#4 8 15 16 23 42
```
No
| 53,122 | [
-0.045806884765625,
0.099609375,
-0.020965576171875,
0.160888671875,
-0.7763671875,
-0.21630859375,
-0.220947265625,
0.1163330078125,
-0.01354217529296875,
0.7939453125,
0.42822265625,
-0.08270263671875,
-0.058990478515625,
-0.748046875,
-0.732421875,
-0.1690673828125,
-0.4013671875,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jou and Yae are a good couple. Jou is collecting prizes for capsule toy vending machines (Gachapon), and even when they go out together, when they find Gachapon, they seem to get so hot that they try it several times. Yae was just looking at Jou, who looked happy, but decided to give him a Gachapon prize for his upcoming birthday present. Yae wasn't very interested in Gachapon itself, but hopefully he would like a match with Jou.
For Gachapon that Yae wants to try, one prize will be given in one challenge. You can see how many types of prizes there are, including those that are out of stock, and how many of each prize remains. However, I don't know which prize will be given in one challenge. Therefore, regardless of the order in which the prizes are given, create a program that outputs the minimum number of challenges required for Yae to get two of the same prizes.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
k1 k2 ... kN
Each dataset has two lines, and the first line is given the integer N (1 ≤ N ≤ 10000), which indicates how many types of prizes there are. The next line is given the integer ki (0 ≤ ki ≤ 10000), which indicates how many prizes are left.
The number of datasets does not exceed 100.
output
For each dataset, the minimum number of challenges required to get two identical prizes is output. However, if it is not possible, NA is output.
Example
Input
2
3 2
3
0 1 1
1
1000
0
Output
3
NA
2
Submitted Solution:
```
while True:
n = int(input())
if n == 0:
break
Ko = list(map(int,input().split()))
if Ko.count(0) + Ko.count(1) == len(Ko):
print("NA")
else:
print(n - Ko.count(0) + 1)
```
Yes
| 53,844 | [
0.3466796875,
0.427001953125,
-0.05999755859375,
0.314208984375,
-0.39453125,
-0.638671875,
-0.2303466796875,
0.53564453125,
-0.0118408203125,
0.462158203125,
0.0892333984375,
0.0474853515625,
0.1610107421875,
-0.794921875,
-0.433349609375,
-0.33984375,
-0.54052734375,
-0.658691406... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jou and Yae are a good couple. Jou is collecting prizes for capsule toy vending machines (Gachapon), and even when they go out together, when they find Gachapon, they seem to get so hot that they try it several times. Yae was just looking at Jou, who looked happy, but decided to give him a Gachapon prize for his upcoming birthday present. Yae wasn't very interested in Gachapon itself, but hopefully he would like a match with Jou.
For Gachapon that Yae wants to try, one prize will be given in one challenge. You can see how many types of prizes there are, including those that are out of stock, and how many of each prize remains. However, I don't know which prize will be given in one challenge. Therefore, regardless of the order in which the prizes are given, create a program that outputs the minimum number of challenges required for Yae to get two of the same prizes.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
k1 k2 ... kN
Each dataset has two lines, and the first line is given the integer N (1 ≤ N ≤ 10000), which indicates how many types of prizes there are. The next line is given the integer ki (0 ≤ ki ≤ 10000), which indicates how many prizes are left.
The number of datasets does not exceed 100.
output
For each dataset, the minimum number of challenges required to get two identical prizes is output. However, if it is not possible, NA is output.
Example
Input
2
3 2
3
0 1 1
1
1000
0
Output
3
NA
2
Submitted Solution:
```
while True:
ko = int(input())
if ko == 0:break
line = input().split()
num = line.count("1") + line.count("0")
if ko == num:
print("NA")
continue
print(ko - line.count("0") + 1)
```
Yes
| 53,846 | [
0.355224609375,
0.428955078125,
-0.055877685546875,
0.32080078125,
-0.408203125,
-0.66796875,
-0.2178955078125,
0.54052734375,
-0.0094146728515625,
0.459716796875,
0.0826416015625,
0.06640625,
0.1060791015625,
-0.77099609375,
-0.45703125,
-0.343505859375,
-0.5244140625,
-0.67382812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jou and Yae are a good couple. Jou is collecting prizes for capsule toy vending machines (Gachapon), and even when they go out together, when they find Gachapon, they seem to get so hot that they try it several times. Yae was just looking at Jou, who looked happy, but decided to give him a Gachapon prize for his upcoming birthday present. Yae wasn't very interested in Gachapon itself, but hopefully he would like a match with Jou.
For Gachapon that Yae wants to try, one prize will be given in one challenge. You can see how many types of prizes there are, including those that are out of stock, and how many of each prize remains. However, I don't know which prize will be given in one challenge. Therefore, regardless of the order in which the prizes are given, create a program that outputs the minimum number of challenges required for Yae to get two of the same prizes.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
k1 k2 ... kN
Each dataset has two lines, and the first line is given the integer N (1 ≤ N ≤ 10000), which indicates how many types of prizes there are. The next line is given the integer ki (0 ≤ ki ≤ 10000), which indicates how many prizes are left.
The number of datasets does not exceed 100.
output
For each dataset, the minimum number of challenges required to get two identical prizes is output. However, if it is not possible, NA is output.
Example
Input
2
3 2
3
0 1 1
1
1000
0
Output
3
NA
2
Submitted Solution:
```
while 1:
n=int(input())
if n==0:break
a=list(map(int,input().split()))
print([1+len([i for i in a if i>0]),"NA"][max(a)<2])
```
Yes
| 53,847 | [
0.3251953125,
0.428955078125,
-0.0484619140625,
0.26611328125,
-0.3896484375,
-0.603515625,
-0.237548828125,
0.53564453125,
0.00414276123046875,
0.4677734375,
0.0777587890625,
0.048126220703125,
0.1776123046875,
-0.8271484375,
-0.41357421875,
-0.384033203125,
-0.50732421875,
-0.641... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jou and Yae are a good couple. Jou is collecting prizes for capsule toy vending machines (Gachapon), and even when they go out together, when they find Gachapon, they seem to get so hot that they try it several times. Yae was just looking at Jou, who looked happy, but decided to give him a Gachapon prize for his upcoming birthday present. Yae wasn't very interested in Gachapon itself, but hopefully he would like a match with Jou.
For Gachapon that Yae wants to try, one prize will be given in one challenge. You can see how many types of prizes there are, including those that are out of stock, and how many of each prize remains. However, I don't know which prize will be given in one challenge. Therefore, regardless of the order in which the prizes are given, create a program that outputs the minimum number of challenges required for Yae to get two of the same prizes.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
k1 k2 ... kN
Each dataset has two lines, and the first line is given the integer N (1 ≤ N ≤ 10000), which indicates how many types of prizes there are. The next line is given the integer ki (0 ≤ ki ≤ 10000), which indicates how many prizes are left.
The number of datasets does not exceed 100.
output
For each dataset, the minimum number of challenges required to get two identical prizes is output. However, if it is not possible, NA is output.
Example
Input
2
3 2
3
0 1 1
1
1000
0
Output
3
NA
2
Submitted Solution:
```
import sys
f = sys.stdin
while True:
n = int(f.readline())
if n == 0:
break
k = [int(ki) for ki in f.readline().split()]
k = [ki for ki in k if 0 < ki]
print('NA' if max(k) < 2 else len(k) + 1)
```
No
| 53,848 | [
0.313720703125,
0.3916015625,
-0.0112457275390625,
0.2841796875,
-0.409912109375,
-0.58251953125,
-0.2305908203125,
0.5048828125,
-0.01206207275390625,
0.491943359375,
0.07476806640625,
0.041229248046875,
0.14111328125,
-0.78857421875,
-0.4345703125,
-0.381591796875,
-0.5205078125,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Example
Input
4 2 1 1
1 1 1 2
2 2 2 1
2 2 1 2
1 1 2 1
9 N
Output
1 1
2 2
"Correct Solution:
```
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
L = 55
N, x0, y0, T = map(int, readline().split())
X = [[0]*L for i in range(L)]
Y = [[0]*L for i in range(L)]
Z = [[0]*L for i in range(L)]
for i in range(N):
xs, ys, xe, ye = map(int, readline().split())
if xs == xe:
if not ys < ye:
ys, ye = ye, ys
for j in range(ys, ye):
X[xs][j] = Z[j][xs] = 1
Z[ye][xs] = 1
else:
if not xs < xe:
xs, xe = xe, xs
for j in range(xs, xe):
Y[ys][j] = Z[ys][j] = 1
Z[ys][xe] = 1
DR = "WNES"
R = [[[None]*4 for i in range(L)] for j in range(L)]
E = [[[0]*4 for i in range(L)] for j in range(L)]
U = [[[0]*L for i in range(L)] for j in range(4)]
U0, U1, U2, U3 = U
col = 0
for i in range(L):
for j in range(L):
if not Z[i][j]:
continue
if Y[i][j-1]:
E[i][j][0] = 1
if X[j][i]:
E[i][j][1] = 1
if Y[i][j]:
E[i][j][2] = 1
if X[j][i-1]:
E[i][j][3] = 1
for l in range(4):
S = [(j, i, l)]
res = [S]
for k in range(10):
col += 1
S1 = []
push = S1.append
for x, y, e in S:
if e != 2 and Y[y][x-1] and U0[y][x-1] != col:
U0[y][x-1] = col
push((x-1, y, 0))
if e != 3 and X[x][y] and U1[y+1][x] != col:
U1[y+1][x] = col
push((x, y+1, 1))
if e != 0 and Y[y][x] and U2[y][x+1] != col:
U2[y][x+1] = col
push((x+1, y, 2))
if e != 1 and X[x][y-1] and U3[y-1][x] != col:
U3[y-1][x] = col
push((x, y-1, 3))
res.append(S1)
S = S1
R[i][j][l] = res
dd = ((-1, 0), (0, 1), (1, 0), (0, -1))
S = set()
d, s = readline().strip().split(); d = int(d); s = DR.index(s)
for l in range(4):
if not E[y0][x0][l]:
continue
dx, dy = dd[l]
for x, y, e in R[y0+dy][x0+dx][l][d-1]:
if e == s:
for l1 in range(4):
if l1 == (e + 2) % 4 or not E[y][x][l1]:
continue
S.add((x, y, l1))
elif (e + 2) % 4 != s and E[y][x][s]:
S.add((x, y, s))
for i in range(T-1):
S1 = set()
d, s = readline().strip().split(); d = int(d); s = DR.index(s)
for x1, y1, e1 in S:
if not E[y1][x1][e1]:
continue
dx, dy = dd[e1]
for x, y, e in R[y1+dy][x1+dx][e1][d-1]:
if e == s:
for l1 in range(4):
if l1 == (e + 2) % 4 or not E[y][x][l1]:
continue
S1.add((x, y, l1))
elif (e + 2) % 4 != s and E[y][x][s]:
S1.add((x, y, s))
S = S1
P = sorted(set((x, y) for x, y, _ in S))
for x, y in P:
write("%d %d\n" % (x, y))
solve()
```
| 53,868 | [
0.0660400390625,
0.1851806640625,
0.253173828125,
-0.107666015625,
-0.5556640625,
-0.36376953125,
-0.4169921875,
0.1533203125,
0.041595458984375,
1.1591796875,
0.2432861328125,
0.10162353515625,
0.43017578125,
-0.57861328125,
-0.5703125,
-0.166015625,
-0.411376953125,
-0.6298828125... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
There are N villages. Each village is numbered from 1 to N. Due to the recent merger boom, several villages have been merged. Two or more merged villages will become one new city, and villages that are not merged with any village will remain villages.
You will be given multiple pieces of information that two villages will be in the same city after the merger. Depending on the combination of the information, three or more villages can become one city.
Given information about villages that will be in the same city after the merger, output the absolute value of the difference between the number of cities and the number of villages after the merger.
Constraints
* 1 ≤ N ≤ 1,000
* 0 ≤ M ≤ 100
* 1 ≤ ai ≤ N
* 1 ≤ bi ≤ N
Input
The input is given in the following format.
N M
a1 b1
a2 b2
...
ai bi
...
aM bM
The first line gives the number N of villages and the number M of information about the merger, separated by blanks.
From the second line to the M + 1 line, two integers ai and bi representing information about the merger are given, separated by blanks. Each information indicates that the ai and bi villages will be the same city after the merger. However, no input is given that satisfies ai = bi.
Output
Output the absolute value of the difference between the number of villages and the number of cities on one line.
Examples
Input
3 1
1 2
Output
0
Input
4 2
1 4
2 3
Output
2
Input
5 0
Output
5
Input
3 3
1 2
2 3
3 1
Output
1
Input
3 2
1 2
2 3
Output
1
Input
5 4
1 2
2 3
3 4
4 5
Output
1
Input
10 5
3 4
1 2
9 6
2 6
2 9
Output
2
Submitted Solution:
```
[m,n] = map(int,input().split())
def find(v,cs):
for c in cities:
if v in c:
return (True,c)
return (False,set([v]))
cities = []
for _ in range(n):
[a,b] = map(int,input().split())
(ra,fa) = find(a,cities)
(rb,fb) = find(b,cities)
mg = fa | fb
print(fa)
if ra:
cities.remove(fa)
else:
m = m - 1
if rb:
if fa != fb:
cities.remove(fb)
else:
m = m - 1
cities.append(mg)
print(abs(m-len(cities)))
```
No
| 53,874 | [
0.1484375,
0.42333984375,
0.07159423828125,
-0.041900634765625,
-1.1630859375,
-0.76611328125,
-0.31884765625,
-0.09912109375,
0.4365234375,
0.6953125,
0.244140625,
0.1622314453125,
-0.154541015625,
-0.732421875,
-0.44873046875,
-0.0194854736328125,
-0.6767578125,
-0.60400390625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000
Submitted Solution:
```
expr = input()
q_cnt = expr.count('?')
plus_cnt = expr.count('+')
minus_cnt = expr.count('-')
n = int(expr[expr.find('= ') + 2:])
if plus_cnt + 1 > n * (minus_cnt + 1) or n * (plus_cnt + 1) < n + minus_cnt:
print('Impossible')
else:
tokens = expr.split()
before = 's'
output = [t for t in tokens]
if plus_cnt == minus_cnt:
for i, t in enumerate(tokens):
if t == '?':
if before == 's':
output[i] = str(n)
else:
output[i] = str(1)
else:
before = t
elif plus_cnt > minus_cnt:
yobun = plus_cnt - minus_cnt
for i, t in enumerate(tokens):
if t == '?':
if before == 's':
output[i] = str(max(1, n - yobun))
yobun -= n - int(output[i])
elif before == '+':
output[i] = str(1)
else:
output[i] = str(min(n, yobun + 1))
yobun -= int(output[i]) - 1
elif t == '+' or t == '-':
before = t
else:
yobun = minus_cnt - plus_cnt
for i, t in enumerate(tokens):
if t == '?':
if before == 's':
output[i] = str(n)
elif before == '+':
output[i] = str(min(n, yobun + 1))
yobun -= int(output[i]) - 1
else:
output[i] = str(1)
elif t == '+' or t == '-':
before = t
print('Possible')
print(' '.join(output))
```
Yes
| 54,434 | [
0.296142578125,
-0.19873046875,
-0.347412109375,
0.08721923828125,
-0.37646484375,
-0.60302734375,
0.320556640625,
0.228271484375,
-0.1810302734375,
0.8837890625,
0.49951171875,
0.05938720703125,
0.079833984375,
-0.84716796875,
-0.447509765625,
-0.160888671875,
-0.53466796875,
-1.1... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000
Submitted Solution:
```
s,n=input().split(' = ')
if s=='?': print('Possible\n'+n+' = '+n)
elif not '+' in s: print('Impossible')
else:
n=int(n)
s=['+']+list(s.replace(' ',''))
cp=s.count('+')
cm=s.count('-')
if cm>=cp:
t=(n+cm)//cp
m=(n+cm)%cp
cc=0
for i in range(1,len(s),2):
if s[i-1]=='+': s[i]=str(t+(cc<m)); cc+=1
else: s[i]='1'
else:
t=(n+cm*n)//cp
m=(n+cm*n)%cp
cc=0
for i in range(1,len(s),2):
if s[i-1]=='+': s[i]=str(t+(cc<m)); cc+=1
else: s[i]=str(n)
if int(s[1])>n: print('Impossible')
else:
print('Possible')
print(' '.join(s[1:])+' =',n)
```
No
| 54,437 | [
0.33349609375,
-0.1688232421875,
-0.271484375,
0.1038818359375,
-0.5595703125,
-0.51318359375,
0.28076171875,
0.2060546875,
-0.06231689453125,
0.7353515625,
0.59912109375,
0.039825439453125,
0.1605224609375,
-0.88427734375,
-0.3671875,
-0.134521484375,
-0.53515625,
-1.0234375,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000
Submitted Solution:
```
import math
def solve():
eq = input()
num_plus = eq.count('+') + 1
num_minus = eq.count('-')
qmark = eq.count('?')
qmark -= num_minus
divid = [i for i in eq.split()]
n = int(divid[-1])
t = n + num_minus - num_plus
if t > 0 and n == 1:
print('Impossible')
return
fill_to_n = math.ceil(t / (n - 1)) if n > 1 else 0
if fill_to_n > num_plus:
print('Impossible')
return
if fill_to_n > 0:
divid[0] = t % (n - 1) + 1 if t % (n - 1) != 0 else n
fill_to_n -= 1
else:
divid[0] = str(1)
for i in range(1, len(divid)):
if divid[i] == '?':
divid[i] = 1
if divid[i - 1] == '+':
if fill_to_n > 0:
divid[i] = n
fill_to_n -= 1
print('Possible')
print(*divid, sep = ' ')
if __name__ == '__main__':
solve()
```
No
| 54,438 | [
0.408935546875,
-0.1368408203125,
-0.359619140625,
0.179931640625,
-0.56787109375,
-0.51953125,
0.26904296875,
0.337890625,
-0.09197998046875,
0.81640625,
0.435302734375,
0.130126953125,
0.171630859375,
-0.7177734375,
-0.342529296875,
0.05792236328125,
-0.47802734375,
-1.041015625,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000
Submitted Solution:
```
import math
def solve():
eq = input()
num_plus = eq.count('+')
num_minus = eq.count('-')
qmark = eq.count('?')
qmark -= num_minus
divid = [i for i in eq.split()]
t = int(divid[-1])
t += num_minus
qt = math.ceil(t / qmark)
if qt > int(divid[-1]) or qmark > t:
print('Impossible')
return
if t % qt != 0:
divid[0] = str(int(t % qt))
else:
divid[0] = str(qt)
for i in range(1, len(divid)):
if divid[i] == '?':
if divid[i - 1] == '+':
divid[i] = str(qt)
else:
divid[i] = str(1)
print('Possible')
print(*divid, sep = ' ')
if __name__ == '__main__':
solve()
```
No
| 54,439 | [
0.1961669921875,
-0.2108154296875,
-0.430908203125,
0.278076171875,
-0.59912109375,
-0.493896484375,
0.2359619140625,
0.3056640625,
-0.066162109375,
0.8671875,
0.282470703125,
0.133544921875,
0.152587890625,
-0.7158203125,
-0.27294921875,
0.03192138671875,
-0.59423828125,
-1.021484... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
Submitted Solution:
```
D=int(input())
C=list(map(int,input().split()))
S=list()
for i in range(D):
S.append(list(map(int,input().split())))
t=list()
for i in range(D):
t.append(int(input()))
M=0
di=[0]*26
for d in range(D):
for i in range(26):
if i==t[d]-1:
di[i]=0
else:
di[i]+=1
M+=S[d][t[d]-1]
for i in range(26):
M-=C[i]*(di[i])
print(M)
```
Yes
| 54,553 | [
0.271728515625,
0.1353759765625,
-0.0440673828125,
0.11602783203125,
-0.8388671875,
-0.42822265625,
-0.416748046875,
0.299072265625,
-0.0164794921875,
0.63720703125,
0.2271728515625,
-0.096923828125,
0.2042236328125,
-0.7900390625,
-0.257568359375,
-0.279296875,
-0.468994140625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
Submitted Solution:
```
d = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for i in range(d)]
t = [int(input()) for i in range(d)]
last = [-1]*26
ans = 0
for i in range(d):
op = t[i]-1
ans += s[i][op]
last[op]=i
for j in range(26):
ans -= c[j]*(i-last[j])
print(ans)
```
Yes
| 54,554 | [
0.271728515625,
0.1353759765625,
-0.0440673828125,
0.11602783203125,
-0.8388671875,
-0.42822265625,
-0.416748046875,
0.299072265625,
-0.0164794921875,
0.63720703125,
0.2271728515625,
-0.096923828125,
0.2042236328125,
-0.7900390625,
-0.257568359375,
-0.279296875,
-0.468994140625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
Submitted Solution:
```
import sys
input = sys.stdin.readline
d = int(input())
C = list(map(int,input().split()))
S = [list(map(int,input().split())) for i in range(d)]
T = [int(input()) for i in range(d)]
c = 26
ans = 0
L = [-1] * c
for i in range(d):
T[i] -= 1
for i in range(d):
ans += S[i][T[i]]
L[T[i]] = i
for j in range(c):
ans -= C[j] * (i - L[j])
print(ans)
```
Yes
| 54,555 | [
0.271728515625,
0.1353759765625,
-0.0440673828125,
0.11602783203125,
-0.8388671875,
-0.42822265625,
-0.416748046875,
0.299072265625,
-0.0164794921875,
0.63720703125,
0.2271728515625,
-0.096923828125,
0.2042236328125,
-0.7900390625,
-0.257568359375,
-0.279296875,
-0.468994140625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
Submitted Solution:
```
d = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(d)]
T = [int(input())-1 for _ in range(d)]
last = [0] * 26
ans = 0
for i in range(d):
v = T[i]
ans += S[i][v]
for j in range(26):
if j == v:
last[j] = 0
else:
last[j] += 1
ans -= C[j] * last[j]
print(ans)
```
Yes
| 54,556 | [
0.271728515625,
0.1353759765625,
-0.0440673828125,
0.11602783203125,
-0.8388671875,
-0.42822265625,
-0.416748046875,
0.299072265625,
-0.0164794921875,
0.63720703125,
0.2271728515625,
-0.096923828125,
0.2042236328125,
-0.7900390625,
-0.257568359375,
-0.279296875,
-0.468994140625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
Submitted Solution:
```
import time
import random
time_start = time.time()
class Problem:
def __init__(self, D, s, c):
self.last_days = [0] * 26
self.D = D
self.s = s
self.c = c
def scoring(self, day, ind):
day_score = self.s[day - 1][ind]
self.last_days[ind] = day
minus_score = 0
for i in range(26):
minus_score += self.c[i] * (day - self.last_days[i])
day_score -= minus_score
return day_score
def _strategy(self, day):
ind = random.randint(0, 25)
score = self.scoring(day, ind)
return score, ind
def solve(self):
answer = []
sum_score = 0
for i in range(self.D):
score, ind = self._strategy(i)
answer.append(ind)
sum_score += score
return sum_score, answer
def init(self):
self.last_days = [0] * 26
def main():
DO_TIME = 2
D = int(input())
c = list(map(int, input().split()))
s = []
for _ in range(D):
s.append(list(map(int, input().split())))
max_score = 0
max_answer = [1] * D
problem = Problem(D, s, c)
ite = 0
while time.time() - time_start < DO_TIME:
ite += 1
score, answer = problem.solve()
if score > max_score:
max_score = score
max_answer = answer
for i in range(D):
max_answer[i] += 1
print(max_answer[i])
# print(ite)
# print(max_answer)
# print(max_score)
main()
# tmp = [1, 17, 13, 14, 13]
# sum_s = 0
# problem.init()
# for i in range(5):
# score = problem.scoring(i + 1, tmp[i] -1 )
# sum_s += score
# print(last_days)
# print(score)
#
# print(sum_s)
```
No
| 54,557 | [
0.271728515625,
0.1353759765625,
-0.0440673828125,
0.11602783203125,
-0.8388671875,
-0.42822265625,
-0.416748046875,
0.299072265625,
-0.0164794921875,
0.63720703125,
0.2271728515625,
-0.096923828125,
0.2042236328125,
-0.7900390625,
-0.257568359375,
-0.279296875,
-0.468994140625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
Submitted Solution:
```
D=int(input())
C=list(map(int,input().split()))
import sys
S=list()
for i in range(D):
S.append(list(map(int,input().split())))
t=list()
for i in range(D):
t.append(int(input()))
M=0
di=[0]*26
for d in range(D):
for i in range(26):
if i==t[d]-1:
di[i]=0
else:
di[i]+=1
M+=S[d][t[d]-1]
for i in range(26):
M-=C[i]*(d+1-di[i])
print(M)
```
No
| 54,558 | [
0.271728515625,
0.1353759765625,
-0.0440673828125,
0.11602783203125,
-0.8388671875,
-0.42822265625,
-0.416748046875,
0.299072265625,
-0.0164794921875,
0.63720703125,
0.2271728515625,
-0.096923828125,
0.2042236328125,
-0.7900390625,
-0.257568359375,
-0.279296875,
-0.468994140625,
-0... | 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.