message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 219 108k | cluster float64 11 11 | __index_level_0__ int64 438 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 998244351) — the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer — the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} ≡ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2. | instruction | 0 | 66,565 | 11 | 133,130 |
Tags: combinatorics, dp, probabilities
Correct Solution:
```
import sys
from itertools import chain
readline = sys.stdin.readline
MOD = 998244353
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N = int(readline())
LR = [tuple(map(int, readline().split())) for _ in range(N)]
LR = [(a-1, b) for a, b in LR]
LR2 = LR[:]
ml = LR[-1][0]
res = 0
for i in range(N-2, -1, -1):
l, r = LR[i]
if r <= ml:
break
l = max(ml, l)
ml = l
LR[i] = (l, r)
else:
Z = list(chain(*LR))
Z2, Dc = compress(Z)
NN = len(Z2)
seglen = [0] + [n - p for p, n in zip(Z2, Z2[1:])]
hc = [[0]*(N+3) for _ in range(NN)]
for j in range(NN):
hc[j][0] = 1
for k in range(1, N+3):
hc[j][k] = hc[j][k-1]*pow(k, MOD-2, MOD)*(seglen[j]-1+k)%MOD
mask = [[[True]*NN]]
dp = [[[0]*(N+1) for _ in range(NN+1)] for _ in range(N+1)]
Dp = [[1]*(NN+1)] + [[0]*(NN+1) for _ in range(N)]
for i in range(1, N+1):
mask2 = [False]*NN
l, r = LR[i-1]
dl, dr = Dc[l], Dc[r]
for j in range(dr, dl, -1):
mask2[j] = True
mm = [[m1&m2 for m1, m2 in zip(mask[-1][idx], mask2)] for idx in range(i)] + [mask2]
mask.append(mm)
for j in range(NN):
for k in range(1, i+1):
if mask[i][i-k+1][j]:
dp[i][j][k] = Dp[i-k][j+1]*hc[j][k]%MOD
for j in range(NN-1, -1, -1):
res = Dp[i][j+1]
if dl < j <= dr:
for k in range(1, i+1):
res = (res + dp[i][j][k])%MOD
Dp[i][j] = res
res = Dp[N][0]
for l, r in LR2:
res = res*(pow(r-l, MOD-2, MOD))%MOD
print(res)
``` | output | 1 | 66,565 | 11 | 133,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 998244351) — the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer — the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} ≡ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2. | instruction | 0 | 66,566 | 11 | 133,132 |
Tags: combinatorics, dp, probabilities
Correct Solution:
```
from bisect import bisect_left
M = 998244353
def pw(x, y):
if y == 0:
return 1
res = pw(x, y//2)
res = res * res % M
if y % 2 == 1:
res = res * x % M
return res
def cal(x, y):
y += x - 1
res = 1
for i in range(1, x + 1):
res = res * (y - i + 1)
res = res * pw(i, M - 2) % M
return res % M
n = int(input())
a = []
b = []
res = 1
for i in range(n):
a.append(list(map(int, input().split())))
res = res * (a[-1][1] + 1 - a[-1][0]) % M
b.append(a[-1][0])
b.append(a[-1][1] + 1)
b = set(b)
b = sorted(list(b))
g = [b[i + 1] - b[i] for i in range(len(b) - 1)]
for i in range(n):
a[i][0] = bisect_left(b, a[i][0])
a[i][1] = bisect_left(b, a[i][1] + 1)
a = a[::-1]
f = [[0 for _ in range(len(b))] for __ in range(n)]
for i in range(a[0][0], len(b)):
if i == 0:
f[0][i] = g[i]
else:
if i < a[0][1]:
f[0][i] = (f[0][i - 1] + g[i]) % M
else:
f[0][i] = f[0][i - 1]
for i in range(1, n):
for j in range(a[i][0], len(b)):
if j > 0:
f[i][j] = f[i][j - 1]
if j < a[i][1]:
for k in range(i, -1, -1):
if a[k][1] <= j or j < a[k][0]:
break
if k == 0 or j != 0:
tmp = cal(i - k + 1, g[j])
if k > 0:
f[i][j] += f[k - 1][j - 1] * tmp % M
else:
f[i][j] += tmp
f[i][j] %= M
#print(f)
#print(f[n - 1][len(b) - 1], res)
print(f[n - 1][len(b) - 1] * pw(res, M - 2) % M)
``` | output | 1 | 66,566 | 11 | 133,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 998244351) — the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer — the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} ≡ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2.
Submitted Solution:
```
import sys
input = sys.stdin.readline
mod=998244353
n=int(input())
LR=[list(map(int,input().split())) for i in range(n)]
RMIN=1<<31
ALL=1
for l,r in LR:
ALL=ALL*pow(r-l+1,mod-2,mod)%mod
for i in range(n):
if LR[i][1]>RMIN:
LR[i][1]=RMIN
RMIN=min(RMIN,LR[i][1])
LMAX=-1
for i in range(n-1,-1,-1):
if LR[i][0]<LMAX:
LR[i][0]=LMAX
LMAX=max(LMAX,LR[i][0])
compression=[]
for l,r in LR:
compression.append(l)
compression.append(r+1)
compression=sorted(set(compression))
co_dict={a:ind for ind,a in enumerate(compression)}
LEN=len(compression)-1
DP=[[0]*LEN for i in range(n)]
for i in range(co_dict[LR[0][0]],co_dict[LR[0][1]+1]):
x=compression[i+1]-compression[i]
now=x
#print(i,x)
for j in range(n):
if LR[j][0]<=compression[i] and LR[j][1]+1>=compression[i+1]:
DP[j][i]=now
else:
break
now=now*(x+j+1)*pow(j+2,mod-2,mod)%mod
#print(DP)
for i in range(1,n):
SUM=DP[i-1][LEN-1]
for j in range(LEN-2,-1,-1):
if LR[i][0]<=compression[j] and LR[i][1]+1>=compression[j+1]:
x=SUM*(compression[j+1]-compression[j])%mod
#print(x)
now=x
for k in range(i,n):
if LR[k][0]<=compression[j] and LR[k][1]+1>=compression[j+1]:
DP[k][j]=(DP[k][j]+now)%mod
else:
break
now=now*(x+k-i+1)*pow(k-i+2,mod-2,mod)%mod
SUM+=DP[i-1][j]
print(sum(DP[-1])*ALL%mod)
``` | instruction | 0 | 66,567 | 11 | 133,134 |
No | output | 1 | 66,567 | 11 | 133,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 998244351) — the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer — the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} ≡ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2.
Submitted Solution:
```
import sys
from itertools import chain
readline = sys.stdin.readline
MOD = 998244353
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N = int(readline())
LR = [tuple(map(int, readline().split())) for _ in range(N)]
LR = [(a-1, b) for a, b in LR]
LR2 = LR[:]
ml = LR[-1][0]
res = 0
for i in range(N-2, -1, -1):
l, r = LR[i]
if r < ml:
break
l = max(ml, l)
ml = l
LR[i] = (l, r)
else:
Z = list(chain(*LR))
Z2, Dc = compress(Z)
NN = len(Z2)
seglen = [0] + [n - p for p, n in zip(Z2, Z2[1:])]
hc = [[0]*(N+3) for _ in range(NN)]
for j in range(NN):
hc[j][0] = 1
for k in range(1, N+3):
hc[j][k] = hc[j][k-1]*pow(k, MOD-2, MOD)*(seglen[j]-1+k)%MOD
dp = [[[0]*(N+1) for _ in range(NN+1)] for _ in range(N)]
dl0, dr0 = Dc[LR[0][0]], Dc[LR[0][1]]
mask = [False]*NN
for j in range(dr0, dl0, -1):
dp[0][j][1] = seglen[j]%MOD
mask[j] = True
Dp = [[0]*(NN+1) for _ in range(N)]
for j in range(NN-1, 0, -1):
Dp[0][j] = (Dp[0][j+1] + dp[0][j][1])%MOD
for i in range(1, N):
mask2 = [False]*NN
l, r = LR[i]
dl, dr = Dc[l], Dc[r]
for j in range(dr, dl, -1):
mask2[j] = True
mask = [m1&m2 for m1, m2 in zip(mask, mask2)]
for j in range(NN):
for k in range(1, N+1):
res = 0
if k == i+1 and mask[j]:
res = hc[j][k]%MOD
if k <= i:
res = (res + Dp[i-k][j+1]*hc[j][k])%MOD
dp[i][j][k] = res
for j in range(NN):
res = 0
if dl < j <= dr:
for k in range(1, N+1):
res = (res + dp[i][j][k])%MOD
Dp[i][j] = res
res = 0
for j in range(NN):
res = (res + Dp[N-1][j])%MOD
for l, r in LR2:
res = res*(pow(r-l, MOD-2, MOD))%MOD
print(res)
``` | instruction | 0 | 66,568 | 11 | 133,136 |
No | output | 1 | 66,568 | 11 | 133,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 998244351) — the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer — the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} ≡ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2.
Submitted Solution:
```
import sys
from itertools import chain
readline = sys.stdin.readline
MOD = 998244353
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N = int(readline())
LR = [tuple(map(int, readline().split())) for _ in range(N)]
LR = [(a-1, b) for a, b in LR]
LR2 = LR[:]
ml = LR[-1][0]
res = 0
for i in range(N-2, -1, -1):
l, r = LR[i]
if r <= ml:
break
l = max(ml, l)
ml = l
LR[i] = (l, r)
else:
Z = list(chain(*LR))
Z2, Dc = compress(Z)
NN = len(Z2)
seglen = [0] + [n - p for p, n in zip(Z2, Z2[1:])]
hc = [[0]*(N+3) for _ in range(NN)]
for j in range(NN):
hc[j][0] = 1
for k in range(1, N+3):
hc[j][k] = hc[j][k-1]*pow(k, MOD-2, MOD)*(seglen[j]-1+k)%MOD
dp = [[[0]*(N+1) for _ in range(NN+1)] for _ in range(N)]
dl0, dr0 = Dc[LR[0][0]], Dc[LR[0][1]]
mask = [False]*NN
for j in range(dr0, dl0, -1):
dp[0][j][1] = seglen[j]%MOD
mask[j] = True
mask = [[mask]]
Dp = [[0]*(NN+1) for _ in range(N)]
for j in range(NN-1, 0, -1):
Dp[0][j] = (Dp[0][j+1] + dp[0][j][1])%MOD
for i in range(1, N):
mask2 = [False]*NN
l, r = LR[i]
dl, dr = Dc[l], Dc[r]
for j in range(dr, dl, -1):
mask2[j] = True
mm = [[m1&m2 for m1, m2 in zip(mask[-1][idx], mask2)] for idx in range(i)] + [mask2]
mask.append(mm)
for j in range(NN):
for k in range(1, N+1):
res = 0
if k == i+1 and mask[i][i+1-k][j]:
res = hc[j][k]%MOD
if k <= i and mask[i][i+1-k][j]:
res = (res + Dp[i-k][j+1]*hc[j][k])%MOD
dp[i][j][k] = res
for j in range(NN):
res = 0
if dl < j <= dr:
for k in range(1, N+1):
res = (res + dp[i][j][k])%MOD
Dp[i][j] = res
res = 0
for j in range(NN):
res = (res + Dp[N-1][j])%MOD
for l, r in LR2:
res = res*(pow(r-l, MOD-2, MOD))%MOD
print(res)
``` | instruction | 0 | 66,569 | 11 | 133,138 |
No | output | 1 | 66,569 | 11 | 133,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 998244351) — the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer — the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} ≡ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2.
Submitted Solution:
```
import sys
from itertools import chain
readline = sys.stdin.readline
MOD = 998244353
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N = int(readline())
LR = [tuple(map(int, readline().split())) for _ in range(N)]
LR = [(a-1, b) for a, b in LR]
Z = list(chain(*LR))
Z2, Dc = compress(Z)
NN = len(Z2)
seglen = [0] + [n - p for p, n in zip(Z2, Z2[1:])]
hc = [[0]*(N+3) for _ in range(NN)]
for j in range(NN):
hc[j][0] = 1
for k in range(1, N+3):
hc[j][k] = hc[j][k-1]*pow(k, MOD-2, MOD)*(seglen[j]-1+k)
dp = [[[0]*(N+1) for _ in range(NN+1)] for _ in range(N)]
dl0, dr0 = Dc[LR[0][0]], Dc[LR[0][1]]
mask = [False]*NN
for j in range(dr0, dl0, -1):
dp[0][j][1] = seglen[j]%MOD
mask[j] = True
Dp = [[0]*(NN+1) for _ in range(N)]
for j in range(NN-1, 0, -1):
Dp[0][j] = (Dp[0][j+1] + dp[0][j][1])%MOD
for i in range(1, N):
mask2 = [False]*NN
for j in range(NN):
mask2[j] = True
mask = [m1&m2 for m1, m2 in zip(mask, mask2)]
for j in range(NN):
for k in range(1, N+1):
res = 0
if k == i+1 and mask[j]:
res = hc[j][k]
if k <= i:
res = (res + Dp[i-k][j+1]*hc[j][k])%MOD
dp[i][j][k] = res
l, r = LR[i]
dl, dr = Dc[l], Dc[r]
for j in range(NN):
res = 0
if dl < j <= dr:
for k in range(1, N+1):
res = (res + dp[i][j][k])%MOD
Dp[i][j] = res
res = 0
for j in range(NN):
res = (res + Dp[N-1][j])%MOD
for l, r in LR:
res = res*(pow(r-l, MOD-2, MOD))%MOD
print(res)
``` | instruction | 0 | 66,570 | 11 | 133,140 |
No | output | 1 | 66,570 | 11 | 133,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2050 Conference, some people from the competitive programming community meet together and are going to take a photo. The n people form a line. They are numbered from 1 to n from left to right. Each of them either holds a cardboard with the letter 'C' or a cardboard with the letter 'P'.
Let C=\\{c_1,c_2,...,c_m\} (c_1<c_2<… <c_m) be the set of people who hold cardboards of 'C'. Let P=\\{p_1,p_2,...,p_k\} (p_1<p_2<… <p_k) be the set of people who hold cardboards of 'P'. The photo is good if and only if it satisfies the following constraints:
1. C∪ P=\{1,2,...,n\}
2. C∩ P =∅ .
3. c_i-c_{i-1}≤ c_{i+1}-c_i(1< i <m).
4. p_i-p_{i-1}≥ p_{i+1}-p_i(1< i <k).
Given an array a_1,…, a_n, please find the number of good photos satisfying the following condition: $$$∑_{x∈ C} a_x < ∑_{y∈ P} a_y.$$$
The answer can be large, so output it modulo 998 244 353. Two photos are different if and only if there exists at least one person who holds a cardboard of 'C' in one photo but holds a cardboard of 'P' in the other.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 200 000). Description of the test cases follows.
The first line of each test case contains a single integer n (1≤ n≤ 200 000).
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 200 000.
Output
For each test case, output the answer modulo 998 244 353 in a separate line.
Example
Input
3
5
2 1 2 1 1
4
9 2 2 2
1
998244353
Output
10
7
1
Note
For the first test case, there are 10 possible good photos satisfying the condition: PPPPP, CPPPP, PCPPP, CCPPP, PCCPP, PCPCP, PPPPC, CPPPC, PCPPC, PPPCC.
For the second test case, there are 7 possible good photos satisfying the condition: PPPP, PCPP, PCCP, PPPC, PCPC, PPCC, PCCC.
Submitted Solution:
```
MOD = 998244353
def main():
num_cases = int(input())
for case_num in range(1, num_cases + 1):
solve(case_num)
def solve(case_num):
# Code here
n = int(input())
A = [int(x) for x in input().split()]
sol = 1
sc = 0
sp = sum(A)
for i in range(n):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += i // 2
# C at end
sc = A[-1]
sp = sum(A) - A[-1]
for i in range(n - 3):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += i // 2
# P at beginning
if n >= 3:
sc = A[1] + A[2]
sp = sum(A) - sc
if sc < sp:
for i in range(1, n):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += (i - 1) // 2
# C at end AND P at beginning
if n > 3:
sc = A[1] + A[2] + A[-1]
sp = sum(A) - sc
for i in range(1, n - 3):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += (i - 1) // 2
print(sol % MOD)
if __name__ == '__main__':
main()
``` | instruction | 0 | 66,683 | 11 | 133,366 |
No | output | 1 | 66,683 | 11 | 133,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2050 Conference, some people from the competitive programming community meet together and are going to take a photo. The n people form a line. They are numbered from 1 to n from left to right. Each of them either holds a cardboard with the letter 'C' or a cardboard with the letter 'P'.
Let C=\\{c_1,c_2,...,c_m\} (c_1<c_2<… <c_m) be the set of people who hold cardboards of 'C'. Let P=\\{p_1,p_2,...,p_k\} (p_1<p_2<… <p_k) be the set of people who hold cardboards of 'P'. The photo is good if and only if it satisfies the following constraints:
1. C∪ P=\{1,2,...,n\}
2. C∩ P =∅ .
3. c_i-c_{i-1}≤ c_{i+1}-c_i(1< i <m).
4. p_i-p_{i-1}≥ p_{i+1}-p_i(1< i <k).
Given an array a_1,…, a_n, please find the number of good photos satisfying the following condition: $$$∑_{x∈ C} a_x < ∑_{y∈ P} a_y.$$$
The answer can be large, so output it modulo 998 244 353. Two photos are different if and only if there exists at least one person who holds a cardboard of 'C' in one photo but holds a cardboard of 'P' in the other.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 200 000). Description of the test cases follows.
The first line of each test case contains a single integer n (1≤ n≤ 200 000).
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 200 000.
Output
For each test case, output the answer modulo 998 244 353 in a separate line.
Example
Input
3
5
2 1 2 1 1
4
9 2 2 2
1
998244353
Output
10
7
1
Note
For the first test case, there are 10 possible good photos satisfying the condition: PPPPP, CPPPP, PCPPP, CCPPP, PCCPP, PCPCP, PPPPC, CPPPC, PCPPC, PPPCC.
For the second test case, there are 7 possible good photos satisfying the condition: PPPP, PCPP, PCCP, PPPC, PCPC, PPCC, PCCC.
Submitted Solution:
```
MOD = 998244353
def main():
num_cases = int(input())
for case_num in range(1, num_cases + 1):
solve(case_num)
def solve(case_num):
# Code here
n = int(input())
A = [int(x) for x in input().split()]
sol = 1
sc = 0
sp = sum(A)
for i in range(n):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += i // 2
# C at end
sc = A[-1]
sp = sum(A) - A[-1]
for i in range(n - 3):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += i // 2
# P at beginning
if n >= 3:
sc = A[1] + A[2]
sp = sum(A) - sc
if sc < sp:
for i in range(1, n):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += (i - 1) // 2
# C at end AND P at beginning
if n > 3:
sc = A[1] + A[2] + A[-1]
sp = sum(A) - sc
for i in range(1, n - 3):
if sc + A[i] < sp - A[i]:
sol += 1
else:
sol += max((i - 2) // 2, 0)
print(sol % MOD)
if __name__ == '__main__':
main()
``` | instruction | 0 | 66,684 | 11 | 133,368 |
No | output | 1 | 66,684 | 11 | 133,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2050 Conference, some people from the competitive programming community meet together and are going to take a photo. The n people form a line. They are numbered from 1 to n from left to right. Each of them either holds a cardboard with the letter 'C' or a cardboard with the letter 'P'.
Let C=\\{c_1,c_2,...,c_m\} (c_1<c_2<… <c_m) be the set of people who hold cardboards of 'C'. Let P=\\{p_1,p_2,...,p_k\} (p_1<p_2<… <p_k) be the set of people who hold cardboards of 'P'. The photo is good if and only if it satisfies the following constraints:
1. C∪ P=\{1,2,...,n\}
2. C∩ P =∅ .
3. c_i-c_{i-1}≤ c_{i+1}-c_i(1< i <m).
4. p_i-p_{i-1}≥ p_{i+1}-p_i(1< i <k).
Given an array a_1,…, a_n, please find the number of good photos satisfying the following condition: $$$∑_{x∈ C} a_x < ∑_{y∈ P} a_y.$$$
The answer can be large, so output it modulo 998 244 353. Two photos are different if and only if there exists at least one person who holds a cardboard of 'C' in one photo but holds a cardboard of 'P' in the other.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 200 000). Description of the test cases follows.
The first line of each test case contains a single integer n (1≤ n≤ 200 000).
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 200 000.
Output
For each test case, output the answer modulo 998 244 353 in a separate line.
Example
Input
3
5
2 1 2 1 1
4
9 2 2 2
1
998244353
Output
10
7
1
Note
For the first test case, there are 10 possible good photos satisfying the condition: PPPPP, CPPPP, PCPPP, CCPPP, PCCPP, PCPCP, PPPPC, CPPPC, PCPPC, PPPCC.
For the second test case, there are 7 possible good photos satisfying the condition: PPPP, PCPP, PCCP, PPPC, PCPC, PPCC, PCCC.
Submitted Solution:
```
from bisect import bisect,bisect_left
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
seen.add(u)
for v,w in graph[u]:
if v not in d or d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
res=[]
for k in nums:
i=bisect.bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
mod=998244353
t=N()
for i in range(t):
n=N()
a=RLL()
ans=1
pre=A(n)
suf=A(n)
pre[0]=a[0]
suf[-1]=a[-1]
for i in range(1,n):
pre[i]=pre[i-1]+a[i]
for i in range(n-2,-1,-1):
suf[i]=suf[i+1]+a[i]
for i in range(n-1,0,-1):
if suf[i]<pre[i-1]:
ans+=1
else:
break
if n>=5:
for i in range(1,n-3):
if pre[i]+a[-1]<suf[i+1]-a[-1]:
ans+=1
for i in range(n-2,2,-1):
if suf[i]+a[0]>pre[i-1]-a[0]:
ans+=1
if n>1:
i=n-1
res=suf[i]-pre[i-1]
if res>0:
j=i
ans+=n-1
else:
j=n-3
while j>=0:
res+=a[j]*2
if res>0:
break
while j<0:
j+=2
while i>0:
if res>0:
while j+2<=i and res-2*a[j]>0:
j+=2
ans+=1+j//2
res+=2*a[i-1]
i-=2
j=min(j,i)
else:
res+=2*a[i-1]
i-=2
if n>2:
i=n-2
res=suf[i]-pre[i-1]
if res>0:
j=i
ans+=n-1
else:
j=i-2
while j>=0:
res+=a[j]*2
if res>0:
break
while j<0:
j+=2
while i>0:
if res>0:
while j+2<=i and res-2*a[j]>0:
j+=2
ans+=1+j//2
res+=2*a[i-1]
i-=2
j=min(j,i)
else:
res+=2*a[i-1]
i-=2
ans%=mod
print(ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
'''
``` | instruction | 0 | 66,685 | 11 | 133,370 |
No | output | 1 | 66,685 | 11 | 133,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the 2050 Conference, some people from the competitive programming community meet together and are going to take a photo. The n people form a line. They are numbered from 1 to n from left to right. Each of them either holds a cardboard with the letter 'C' or a cardboard with the letter 'P'.
Let C=\\{c_1,c_2,...,c_m\} (c_1<c_2<… <c_m) be the set of people who hold cardboards of 'C'. Let P=\\{p_1,p_2,...,p_k\} (p_1<p_2<… <p_k) be the set of people who hold cardboards of 'P'. The photo is good if and only if it satisfies the following constraints:
1. C∪ P=\{1,2,...,n\}
2. C∩ P =∅ .
3. c_i-c_{i-1}≤ c_{i+1}-c_i(1< i <m).
4. p_i-p_{i-1}≥ p_{i+1}-p_i(1< i <k).
Given an array a_1,…, a_n, please find the number of good photos satisfying the following condition: $$$∑_{x∈ C} a_x < ∑_{y∈ P} a_y.$$$
The answer can be large, so output it modulo 998 244 353. Two photos are different if and only if there exists at least one person who holds a cardboard of 'C' in one photo but holds a cardboard of 'P' in the other.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 200 000). Description of the test cases follows.
The first line of each test case contains a single integer n (1≤ n≤ 200 000).
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 200 000.
Output
For each test case, output the answer modulo 998 244 353 in a separate line.
Example
Input
3
5
2 1 2 1 1
4
9 2 2 2
1
998244353
Output
10
7
1
Note
For the first test case, there are 10 possible good photos satisfying the condition: PPPPP, CPPPP, PCPPP, CCPPP, PCCPP, PCPCP, PPPPC, CPPPC, PCPPC, PPPCC.
For the second test case, there are 7 possible good photos satisfying the condition: PPPP, PCPP, PCCP, PPPC, PCPC, PPCC, PCCC.
Submitted Solution:
```
import sys
input=sys.stdin.buffer.readline
mod=998244353
for t in range(int(input())):
N=int(input())
A=list(map(int,input().split()))
if N==1:
print(1)
continue
ANS=0
C=[0]*(N+1)
C2=[[0,0] for i in range(N+1)]
for i in range(N):
C[i+1]=C[i]+A[i]
for j in range(2):
if (i^j)&1:
C2[i+1][j]=C2[i][j]+A[i]
else:
C2[i+1][j]=C2[i][j]
for i in range(N+1):
if i>1 and i<N-1:
if C[i]*2!=C[N]:
ANS+=2
for l in range(2):
for r in range(N-1,N+1):
x=(A[0] if l else 0)-(A[-1] if r==N-1 else 0)
for i in range(l,r):
L,R=i-1,r+1
while L<R:
X=(L+R+1)>>1
if x+(C[r]-C[l])-((C[i]-C[l])+(C2[min(X,r)][(i&1)^1]-C2[i][(i&1)^1]))*2>0:
L=X
else:
R=min(R-1,X)
ANS+=R-L+1
print((ANS>>1)%mod)
``` | instruction | 0 | 66,686 | 11 | 133,372 |
No | output | 1 | 66,686 | 11 | 133,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of T seconds (for example, T = 60 seconds = 1 min and T = 86400 seconds = 1 day). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for n seconds. We know the number of queries to this resource at at each moment of time t (1 ≤ t ≤ n). Let's formulate the following algorithm of calculating the mean with exponential decay. Let c be some real number, strictly larger than one.
// setting this constant value correctly can adjust
// the time range for which statistics will be calculated
double c = some constant value;
// as the result of the algorithm's performance this variable will contain
// the mean number of queries for the last
// T seconds by the current moment of time
double mean = 0.0;
for t = 1..n: // at each second, we do the following:
// at is the number of queries that came at the last second;
mean = (mean + at / T) / c;
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant c correctly will make the value of mean not very different from the real mean value ax at t - T + 1 ≤ x ≤ t.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given n values at, integer T and real number c. Also, you are given m moments pj (1 ≤ j ≤ m), where we are interested in the mean value of the number of queries for the last T seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula <image>. The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula <image>, where approx is the approximate value, obtained by the second algorithm, and real is the exact value obtained by the first algorithm.
Input
The first line contains integer n (1 ≤ n ≤ 2·105), integer T (1 ≤ T ≤ n) and real number c (1 < c ≤ 100) — the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient c of the work of approximate algorithm. Number c is given with exactly six digits after the decimal point.
The next line contains n integers at (1 ≤ at ≤ 106) — the number of queries to the service at each moment of time.
The next line contains integer m (1 ≤ m ≤ n) — the number of moments of time when we are interested in the mean number of queries for the last T seconds.
The next line contains m integers pj (T ≤ pj ≤ n), representing another moment of time for which we need statistics. Moments pj are strictly increasing.
Output
Print m lines. The j-th line must contain three numbers real, approx and error, where:
* <image> is the real mean number of queries for the last T seconds;
* approx is calculated by the given algorithm and equals mean at the moment of time t = pj (that is, after implementing the pj-th iteration of the cycle);
* <image> is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10 - 4. It is recommended to print the numbers with at least five digits after the decimal point.
Examples
Input
1 1 2.000000
1
1
1
Output
1.000000 0.500000 0.500000
Input
11 4 1.250000
9 11 7 5 15 6 6 6 6 6 6
8
4 5 6 7 8 9 10 11
Output
8.000000 4.449600 0.443800
9.500000 6.559680 0.309507
8.250000 6.447744 0.218455
8.000000 6.358195 0.205226
8.250000 6.286556 0.237993
6.000000 6.229245 0.038207
6.000000 6.183396 0.030566
6.000000 6.146717 0.024453
Input
13 4 1.250000
3 3 3 3 3 20 3 3 3 3 3 3 3
10
4 5 6 7 8 9 10 11 12 13
Output
3.000000 1.771200 0.409600
3.000000 2.016960 0.327680
7.250000 5.613568 0.225715
7.250000 5.090854 0.297813
7.250000 4.672684 0.355492
7.250000 4.338147 0.401635
3.000000 4.070517 0.356839
3.000000 3.856414 0.285471
3.000000 3.685131 0.228377
3.000000 3.548105 0.182702
Submitted Solution:
```
#------------------Important Modules------------------#
from sys import stdin,stdout
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import *
from random import *
input=stdin.readline
prin=stdout.write
from random import sample
from collections import Counter,deque
from fractions import *
from math import sqrt,ceil,log2,gcd,cos,pi
#dist=[0]*(n+1)
mod=10**9+7
mod2=998244353
"""
class DisjSet:
def __init__(self, n):
self.rank = [1] * n
self.parent = [i for i in range(n)]
def find(self, x):
if (self.parent[x] != x):
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
xset = self.find(x)
yset = self.find(y)
if xset == yset:
return
if self.rank[xset] < self.rank[yset]:
self.parent[xset] = yset
elif self.rank[xset] > self.rank[yset]:
self.parent[yset] = xset
else:
self.parent[yset] = xset
self.rank[xset] = self.rank[xset] + 1
"""
def ps(n):
cp=0;lk=0;arr={}
lk=0;ap=n
cc=0
while n%2==0:
n=n//2
cc=1
if cc==1:
lk+=1
for ps in range(3,ceil(sqrt(n))+1,2):
#print(ps)
cc=0
while n%ps==0:
n=n//ps
cc=1
lk+=1 if cc==1 else 0
if n!=1:
lk+=1
if lk==1:
return [False,0]
#print(arr)
return [True,lk]
#count=0
#dp=[[0 for i in range(m)] for j in range(n)]
#[int(x) for x in input().strip().split()]
def gcd(x, y):
while(y):
x, y = y, x % y
return x
# Driver Code
def factorials(n,r):
#This calculates ncr mod 10**9+7
slr=n;dpr=r
qlr=1;qs=1
mod=10**9+7
for ip in range(n-r+1,n+1):
qlr=(qlr*ip)%mod
for ij in range(1,r+1):
qs=(qs*ij)%mod
#print(qlr,qs)
ans=(qlr*modInverse(qs))%mod
return ans
def modInverse(b):
qr=10**9+7
return pow(b, qr - 2,qr)
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
def power(arr):
listrep = arr
subsets = []
for i in range(2**len(listrep)):
subset = []
for k in range(len(listrep)):
if i & 1<<k:
subset.append(listrep[k])
subsets.append(subset)
return subsets
def pda(n) :
list=[];su=0
for i in range(1, int(sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
list.append(i)
su+=i
else :
list.append(n//i);list.append(i)
su+=i;su+=n//i
# The list will be printed in reverse
return su
def dis(xa,ya,xb,yb):
return sqrt((xa-xb)**2+(ya-yb)**2)
#### END ITERATE RECURSION ####
#===============================================================================================
#----------Input functions--------------------#
def ii():
return int(input())
def ilist():
return [float(x) for x in input().strip().split()]
def islist():
return list(map(str,input().split().rstrip()))
def inp():
return input().strip()
def google(test,ans):
return "Case #"+str(test)+": "+str(ans);
def overlap(x1,y1,x2,y2):
if x2>y1:
return y1-x2
if y1>y2:
return y2-x2
return y1-x2;
###-------------------------CODE STARTS HERE--------------------------------###########
def dist(x1,y1,x2,y2):
return sqrt((x1-x2)**2+(y1-y2)**2)
def sieve(n):
ans=[i+1 for i in range(n+1)]
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
#ans[p]+=p;
if (prime[p] == True):
#ans[p]=p;
for i in range(p * p, n+1, p):
prime[i] = False
ans[i]+=p
if i//p!=p:
ans[i]+=i//p
p += 1
#print(ans[18])
#ans=[i+1 for i in ans]
ans[0]=0;ans[1]=1
dicts={}
for j in range(n+1):
dicts[ans[j]]=j
#ans=[]
return dicts
def prod(arr):
n=len(arr)
k=1
for j in range(n):
k*=arr[j]
return k
#########################################################################################
#t=int(input())
t=1
#ans=sieve(10**7)
for p in range(t):
n,t,c=ilist()
n=int(n);t=int(t)
arr=ilist()
arr=[int(i) for i in arr]
m=ii()
mrr=ilist()
mrr=[int(i) for i in mrr]
sums=[0]*(n+1)
approx=[0]*n
mean=0
for i in range(n):
sums[i+1]=sums[i]+arr[i]
mean=(mean+arr[i]/t)/c
approx[i]=mean
for j in range(m):
real=0
if mrr[j]-t>=0:
real=(sums[mrr[j]]-sums[mrr[j]-t])/t
else:
real=sums[mrr[j]]
app=approx[mrr[j]-1]
print(real,app,abs(app-real)/real)
``` | instruction | 0 | 66,779 | 11 | 133,558 |
Yes | output | 1 | 66,779 | 11 | 133,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of T seconds (for example, T = 60 seconds = 1 min and T = 86400 seconds = 1 day). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for n seconds. We know the number of queries to this resource at at each moment of time t (1 ≤ t ≤ n). Let's formulate the following algorithm of calculating the mean with exponential decay. Let c be some real number, strictly larger than one.
// setting this constant value correctly can adjust
// the time range for which statistics will be calculated
double c = some constant value;
// as the result of the algorithm's performance this variable will contain
// the mean number of queries for the last
// T seconds by the current moment of time
double mean = 0.0;
for t = 1..n: // at each second, we do the following:
// at is the number of queries that came at the last second;
mean = (mean + at / T) / c;
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant c correctly will make the value of mean not very different from the real mean value ax at t - T + 1 ≤ x ≤ t.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given n values at, integer T and real number c. Also, you are given m moments pj (1 ≤ j ≤ m), where we are interested in the mean value of the number of queries for the last T seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula <image>. The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula <image>, where approx is the approximate value, obtained by the second algorithm, and real is the exact value obtained by the first algorithm.
Input
The first line contains integer n (1 ≤ n ≤ 2·105), integer T (1 ≤ T ≤ n) and real number c (1 < c ≤ 100) — the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient c of the work of approximate algorithm. Number c is given with exactly six digits after the decimal point.
The next line contains n integers at (1 ≤ at ≤ 106) — the number of queries to the service at each moment of time.
The next line contains integer m (1 ≤ m ≤ n) — the number of moments of time when we are interested in the mean number of queries for the last T seconds.
The next line contains m integers pj (T ≤ pj ≤ n), representing another moment of time for which we need statistics. Moments pj are strictly increasing.
Output
Print m lines. The j-th line must contain three numbers real, approx and error, where:
* <image> is the real mean number of queries for the last T seconds;
* approx is calculated by the given algorithm and equals mean at the moment of time t = pj (that is, after implementing the pj-th iteration of the cycle);
* <image> is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10 - 4. It is recommended to print the numbers with at least five digits after the decimal point.
Examples
Input
1 1 2.000000
1
1
1
Output
1.000000 0.500000 0.500000
Input
11 4 1.250000
9 11 7 5 15 6 6 6 6 6 6
8
4 5 6 7 8 9 10 11
Output
8.000000 4.449600 0.443800
9.500000 6.559680 0.309507
8.250000 6.447744 0.218455
8.000000 6.358195 0.205226
8.250000 6.286556 0.237993
6.000000 6.229245 0.038207
6.000000 6.183396 0.030566
6.000000 6.146717 0.024453
Input
13 4 1.250000
3 3 3 3 3 20 3 3 3 3 3 3 3
10
4 5 6 7 8 9 10 11 12 13
Output
3.000000 1.771200 0.409600
3.000000 2.016960 0.327680
7.250000 5.613568 0.225715
7.250000 5.090854 0.297813
7.250000 4.672684 0.355492
7.250000 4.338147 0.401635
3.000000 4.070517 0.356839
3.000000 3.856414 0.285471
3.000000 3.685131 0.228377
3.000000 3.548105 0.182702
Submitted Solution:
```
__author__ = 'ruckus'
n, T, c = input().split()
n = int(n)
T = int(T)
c = float(c)
a = list(map(int, input().split()))
m = int(input())
q = list(map(int, input().split()))
res_a = 0
real = 0
maxi_q = max(q)
q_n = 0
for i in range(q[-1]):
res_a = (res_a + a[i] / T) / c
real += a[i]
if q[q_n] == i+1:
q_n += 1
r = real/T
print(r, res_a, abs(r-res_a)/r)
if i > T:
real -= a[i-T+1]
``` | instruction | 0 | 66,780 | 11 | 133,560 |
No | output | 1 | 66,780 | 11 | 133,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of T seconds (for example, T = 60 seconds = 1 min and T = 86400 seconds = 1 day). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for n seconds. We know the number of queries to this resource at at each moment of time t (1 ≤ t ≤ n). Let's formulate the following algorithm of calculating the mean with exponential decay. Let c be some real number, strictly larger than one.
// setting this constant value correctly can adjust
// the time range for which statistics will be calculated
double c = some constant value;
// as the result of the algorithm's performance this variable will contain
// the mean number of queries for the last
// T seconds by the current moment of time
double mean = 0.0;
for t = 1..n: // at each second, we do the following:
// at is the number of queries that came at the last second;
mean = (mean + at / T) / c;
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant c correctly will make the value of mean not very different from the real mean value ax at t - T + 1 ≤ x ≤ t.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given n values at, integer T and real number c. Also, you are given m moments pj (1 ≤ j ≤ m), where we are interested in the mean value of the number of queries for the last T seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula <image>. The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula <image>, where approx is the approximate value, obtained by the second algorithm, and real is the exact value obtained by the first algorithm.
Input
The first line contains integer n (1 ≤ n ≤ 2·105), integer T (1 ≤ T ≤ n) and real number c (1 < c ≤ 100) — the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient c of the work of approximate algorithm. Number c is given with exactly six digits after the decimal point.
The next line contains n integers at (1 ≤ at ≤ 106) — the number of queries to the service at each moment of time.
The next line contains integer m (1 ≤ m ≤ n) — the number of moments of time when we are interested in the mean number of queries for the last T seconds.
The next line contains m integers pj (T ≤ pj ≤ n), representing another moment of time for which we need statistics. Moments pj are strictly increasing.
Output
Print m lines. The j-th line must contain three numbers real, approx and error, where:
* <image> is the real mean number of queries for the last T seconds;
* approx is calculated by the given algorithm and equals mean at the moment of time t = pj (that is, after implementing the pj-th iteration of the cycle);
* <image> is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10 - 4. It is recommended to print the numbers with at least five digits after the decimal point.
Examples
Input
1 1 2.000000
1
1
1
Output
1.000000 0.500000 0.500000
Input
11 4 1.250000
9 11 7 5 15 6 6 6 6 6 6
8
4 5 6 7 8 9 10 11
Output
8.000000 4.449600 0.443800
9.500000 6.559680 0.309507
8.250000 6.447744 0.218455
8.000000 6.358195 0.205226
8.250000 6.286556 0.237993
6.000000 6.229245 0.038207
6.000000 6.183396 0.030566
6.000000 6.146717 0.024453
Input
13 4 1.250000
3 3 3 3 3 20 3 3 3 3 3 3 3
10
4 5 6 7 8 9 10 11 12 13
Output
3.000000 1.771200 0.409600
3.000000 2.016960 0.327680
7.250000 5.613568 0.225715
7.250000 5.090854 0.297813
7.250000 4.672684 0.355492
7.250000 4.338147 0.401635
3.000000 4.070517 0.356839
3.000000 3.856414 0.285471
3.000000 3.685131 0.228377
3.000000 3.548105 0.182702
Submitted Solution:
```
#!/usr/bin/python3.5
import math
mean=[0.0]*200010
real=[0.0]*200010
n,T,c=input().split()
n=int(n)
T=int(T)
c=float(c)
t=T
a=[0]+[int(x) for x in input().split()]
for i in range(1,n+1):
mean[i]=(mean[i-1]+(a[i]//T))/c
real[i]=real[i-1]+a[i]
m=int(input())
q=[int(x) for x in input().split()]
for i in range(m):
r=(real[q[i]]-real[q[i]-t])//T
ap=mean[q[i]]
print('{:.6f} {:.6f} {:.6f}'.format(r,ap,math.fabs(ap-r)/r))
``` | instruction | 0 | 66,781 | 11 | 133,562 |
No | output | 1 | 66,781 | 11 | 133,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of T seconds (for example, T = 60 seconds = 1 min and T = 86400 seconds = 1 day). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for n seconds. We know the number of queries to this resource at at each moment of time t (1 ≤ t ≤ n). Let's formulate the following algorithm of calculating the mean with exponential decay. Let c be some real number, strictly larger than one.
// setting this constant value correctly can adjust
// the time range for which statistics will be calculated
double c = some constant value;
// as the result of the algorithm's performance this variable will contain
// the mean number of queries for the last
// T seconds by the current moment of time
double mean = 0.0;
for t = 1..n: // at each second, we do the following:
// at is the number of queries that came at the last second;
mean = (mean + at / T) / c;
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant c correctly will make the value of mean not very different from the real mean value ax at t - T + 1 ≤ x ≤ t.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given n values at, integer T and real number c. Also, you are given m moments pj (1 ≤ j ≤ m), where we are interested in the mean value of the number of queries for the last T seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula <image>. The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula <image>, where approx is the approximate value, obtained by the second algorithm, and real is the exact value obtained by the first algorithm.
Input
The first line contains integer n (1 ≤ n ≤ 2·105), integer T (1 ≤ T ≤ n) and real number c (1 < c ≤ 100) — the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient c of the work of approximate algorithm. Number c is given with exactly six digits after the decimal point.
The next line contains n integers at (1 ≤ at ≤ 106) — the number of queries to the service at each moment of time.
The next line contains integer m (1 ≤ m ≤ n) — the number of moments of time when we are interested in the mean number of queries for the last T seconds.
The next line contains m integers pj (T ≤ pj ≤ n), representing another moment of time for which we need statistics. Moments pj are strictly increasing.
Output
Print m lines. The j-th line must contain three numbers real, approx and error, where:
* <image> is the real mean number of queries for the last T seconds;
* approx is calculated by the given algorithm and equals mean at the moment of time t = pj (that is, after implementing the pj-th iteration of the cycle);
* <image> is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10 - 4. It is recommended to print the numbers with at least five digits after the decimal point.
Examples
Input
1 1 2.000000
1
1
1
Output
1.000000 0.500000 0.500000
Input
11 4 1.250000
9 11 7 5 15 6 6 6 6 6 6
8
4 5 6 7 8 9 10 11
Output
8.000000 4.449600 0.443800
9.500000 6.559680 0.309507
8.250000 6.447744 0.218455
8.000000 6.358195 0.205226
8.250000 6.286556 0.237993
6.000000 6.229245 0.038207
6.000000 6.183396 0.030566
6.000000 6.146717 0.024453
Input
13 4 1.250000
3 3 3 3 3 20 3 3 3 3 3 3 3
10
4 5 6 7 8 9 10 11 12 13
Output
3.000000 1.771200 0.409600
3.000000 2.016960 0.327680
7.250000 5.613568 0.225715
7.250000 5.090854 0.297813
7.250000 4.672684 0.355492
7.250000 4.338147 0.401635
3.000000 4.070517 0.356839
3.000000 3.856414 0.285471
3.000000 3.685131 0.228377
3.000000 3.548105 0.182702
Submitted Solution:
```
#input
n,T,c = map(float,input().split(' '))
n = int(n)
T = int(T)
a = list(map(int,input().split(' ')))
m = int(input())
p = list(map(int,input().split(' ')))
#fucntions
def approx(x) :
total = 0.0
for i in range(x) :
total = (total+a[i]/T)/c
return total
def real(x) :
return sum(a[:x])/x
def error(a,r) :
return abs(a-r)/r
#main
mm = 1.000000
for i in p :
print(real(i),approx(i),error(approx(i),real(i)))
``` | instruction | 0 | 66,782 | 11 | 133,564 |
No | output | 1 | 66,782 | 11 | 133,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of T seconds (for example, T = 60 seconds = 1 min and T = 86400 seconds = 1 day). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for n seconds. We know the number of queries to this resource at at each moment of time t (1 ≤ t ≤ n). Let's formulate the following algorithm of calculating the mean with exponential decay. Let c be some real number, strictly larger than one.
// setting this constant value correctly can adjust
// the time range for which statistics will be calculated
double c = some constant value;
// as the result of the algorithm's performance this variable will contain
// the mean number of queries for the last
// T seconds by the current moment of time
double mean = 0.0;
for t = 1..n: // at each second, we do the following:
// at is the number of queries that came at the last second;
mean = (mean + at / T) / c;
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant c correctly will make the value of mean not very different from the real mean value ax at t - T + 1 ≤ x ≤ t.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given n values at, integer T and real number c. Also, you are given m moments pj (1 ≤ j ≤ m), where we are interested in the mean value of the number of queries for the last T seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula <image>. The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula <image>, where approx is the approximate value, obtained by the second algorithm, and real is the exact value obtained by the first algorithm.
Input
The first line contains integer n (1 ≤ n ≤ 2·105), integer T (1 ≤ T ≤ n) and real number c (1 < c ≤ 100) — the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient c of the work of approximate algorithm. Number c is given with exactly six digits after the decimal point.
The next line contains n integers at (1 ≤ at ≤ 106) — the number of queries to the service at each moment of time.
The next line contains integer m (1 ≤ m ≤ n) — the number of moments of time when we are interested in the mean number of queries for the last T seconds.
The next line contains m integers pj (T ≤ pj ≤ n), representing another moment of time for which we need statistics. Moments pj are strictly increasing.
Output
Print m lines. The j-th line must contain three numbers real, approx and error, where:
* <image> is the real mean number of queries for the last T seconds;
* approx is calculated by the given algorithm and equals mean at the moment of time t = pj (that is, after implementing the pj-th iteration of the cycle);
* <image> is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10 - 4. It is recommended to print the numbers with at least five digits after the decimal point.
Examples
Input
1 1 2.000000
1
1
1
Output
1.000000 0.500000 0.500000
Input
11 4 1.250000
9 11 7 5 15 6 6 6 6 6 6
8
4 5 6 7 8 9 10 11
Output
8.000000 4.449600 0.443800
9.500000 6.559680 0.309507
8.250000 6.447744 0.218455
8.000000 6.358195 0.205226
8.250000 6.286556 0.237993
6.000000 6.229245 0.038207
6.000000 6.183396 0.030566
6.000000 6.146717 0.024453
Input
13 4 1.250000
3 3 3 3 3 20 3 3 3 3 3 3 3
10
4 5 6 7 8 9 10 11 12 13
Output
3.000000 1.771200 0.409600
3.000000 2.016960 0.327680
7.250000 5.613568 0.225715
7.250000 5.090854 0.297813
7.250000 4.672684 0.355492
7.250000 4.338147 0.401635
3.000000 4.070517 0.356839
3.000000 3.856414 0.285471
3.000000 3.685131 0.228377
3.000000 3.548105 0.182702
Submitted Solution:
```
#!/usr/bin/python3.5
import math
mean=[0.0]*200010
real=[0.0]*200010
n,T,c=input().split()
n=int(n)
T=int(T)
c=float(c)
t=T
a=[0]+[int(x) for x in input().split()]
for i in range(1,n+1):
mean[i]=(mean[i-1]+(a[i]//T))/c
real[i]=real[i-1]+a[i]
m=int(input())
q=[int(x) for x in input().split()]
for i in range(m):
r=(real[q[i]]-real[q[i]-t])/T
ap=mean[q[i]]
print('{:.6f} {:.6f} {:.6f}'.format(r,ap,math.fabs(ap-r)/r))
``` | instruction | 0 | 66,783 | 11 | 133,566 |
No | output | 1 | 66,783 | 11 | 133,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob watches TV every day. He always sets the volume of his TV to b. However, today he is angry to find out someone has changed the volume to a. Of course, Bob has a remote control that can change the volume.
There are six buttons (-5, -2, -1, +1, +2, +5) on the control, which in one press can either increase or decrease the current volume by 1, 2, or 5. The volume can be arbitrarily large, but can never be negative. In other words, Bob cannot press the button if it causes the volume to be lower than 0.
As Bob is so angry, he wants to change the volume to b using as few button presses as possible. However, he forgets how to do such simple calculations, so he asks you for help. Write a program that given a and b, finds the minimum number of presses to change the TV volume from a to b.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 1 000). Then the descriptions of the test cases follow.
Each test case consists of one line containing two integers a and b (0 ≤ a, b ≤ 10^{9}) — the current volume and Bob's desired volume, respectively.
Output
For each test case, output a single integer — the minimum number of presses to change the TV volume from a to b. If Bob does not need to change the volume (i.e. a=b), then print 0.
Example
Input
3
4 0
5 14
3 9
Output
2
3
2
Note
In the first example, Bob can press the -2 button twice to reach 0. Note that Bob can not press -5 when the volume is 4 since it will make the volume negative.
In the second example, one of the optimal ways for Bob is to press the +5 twice, then press -1 once.
In the last example, Bob can press the +5 once, then press +1.
Submitted Solution:
```
# -*- coding: utf-8 -*-
t = int(input().strip())
for i in range(t):
a, b = map(int, input().strip().split())
d = abs(a-b)
if d % 5 == 3 or d % 5 == 4:
print(d // 5 + 2)
else:
print(d // 5 + 1)
``` | instruction | 0 | 67,402 | 11 | 134,804 |
No | output | 1 | 67,402 | 11 | 134,805 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob watches TV every day. He always sets the volume of his TV to b. However, today he is angry to find out someone has changed the volume to a. Of course, Bob has a remote control that can change the volume.
There are six buttons (-5, -2, -1, +1, +2, +5) on the control, which in one press can either increase or decrease the current volume by 1, 2, or 5. The volume can be arbitrarily large, but can never be negative. In other words, Bob cannot press the button if it causes the volume to be lower than 0.
As Bob is so angry, he wants to change the volume to b using as few button presses as possible. However, he forgets how to do such simple calculations, so he asks you for help. Write a program that given a and b, finds the minimum number of presses to change the TV volume from a to b.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 1 000). Then the descriptions of the test cases follow.
Each test case consists of one line containing two integers a and b (0 ≤ a, b ≤ 10^{9}) — the current volume and Bob's desired volume, respectively.
Output
For each test case, output a single integer — the minimum number of presses to change the TV volume from a to b. If Bob does not need to change the volume (i.e. a=b), then print 0.
Example
Input
3
4 0
5 14
3 9
Output
2
3
2
Note
In the first example, Bob can press the -2 button twice to reach 0. Note that Bob can not press -5 when the volume is 4 since it will make the volume negative.
In the second example, one of the optimal ways for Bob is to press the +5 twice, then press -1 once.
In the last example, Bob can press the +5 once, then press +1.
Submitted Solution:
```
from sys import stdin
t=int(stdin.readline().rstrip())
while t>0:
a,b=map(int,stdin.readline().split())
c=0
k=0
if a==b:
print(0)
elif a>b:
k=a-b
else:
k=b-a
if k>=5:
c+=k//5
k=k%5
if k>=2:
c+=k//2
k=k%2
if k>=1:
c+=k
k=0
print(c)
t-=1
``` | instruction | 0 | 67,404 | 11 | 134,808 |
No | output | 1 | 67,404 | 11 | 134,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's consider an n × n square matrix, consisting of digits one and zero.
We'll consider a matrix good, if it meets the following condition: in each row of the matrix all ones go in one group. That is, each row of the matrix looks like that 00...0011...1100...00 (or simply consists of zeroes if it has no ones).
You are given matrix a of size n × n, consisting of zeroes and ones. Your task is to determine whether you can get a good matrix b from it by rearranging the columns or not.
Input
The first line contains integer n (1 ≤ n ≤ 500) — the size of matrix a.
Each of n following lines contains n characters "0" and "1" — matrix a. Note that the characters are written without separators.
Output
Print "YES" in the first line, if you can rearrange the matrix columns so as to get a good matrix b. In the next n lines print the good matrix b. If there are multiple answers, you are allowed to print any of them.
If it is impossible to get a good matrix, print "NO".
Examples
Input
6
100010
110110
011001
010010
000100
011001
Output
YES
011000
111100
000111
001100
100000
000111
Input
3
110
101
011
Output
NO
Submitted Solution:
```
print('NO')
``` | instruction | 0 | 67,579 | 11 | 135,158 |
No | output | 1 | 67,579 | 11 | 135,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's consider an n × n square matrix, consisting of digits one and zero.
We'll consider a matrix good, if it meets the following condition: in each row of the matrix all ones go in one group. That is, each row of the matrix looks like that 00...0011...1100...00 (or simply consists of zeroes if it has no ones).
You are given matrix a of size n × n, consisting of zeroes and ones. Your task is to determine whether you can get a good matrix b from it by rearranging the columns or not.
Input
The first line contains integer n (1 ≤ n ≤ 500) — the size of matrix a.
Each of n following lines contains n characters "0" and "1" — matrix a. Note that the characters are written without separators.
Output
Print "YES" in the first line, if you can rearrange the matrix columns so as to get a good matrix b. In the next n lines print the good matrix b. If there are multiple answers, you are allowed to print any of them.
If it is impossible to get a good matrix, print "NO".
Examples
Input
6
100010
110110
011001
010010
000100
011001
Output
YES
011000
111100
000111
001100
100000
000111
Input
3
110
101
011
Output
NO
Submitted Solution:
```
print("NO")
``` | instruction | 0 | 67,580 | 11 | 135,160 |
No | output | 1 | 67,580 | 11 | 135,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,797 | 11 | 135,594 |
Tags: brute force, implementation
Correct Solution:
```
p, x, y = map(int, input().split())
def check(s):
i = (s // 50) % 475
for t in range(25):
i = (i * 96 + 42) % 475
if 26 + i == p:
return True
return False
for up in range(500):
for down in range(500):
if x + 100 * up - 50 * down >= y and check(x + 100 * up - 50 * down):
print(up)
exit()
assert(False)
``` | output | 1 | 67,797 | 11 | 135,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,798 | 11 | 135,596 |
Tags: brute force, implementation
Correct Solution:
```
p, x, y = map(int, input().split())
k = (x - y) // 50
d = x // 50 - k
n = 1 - k
while 1:
i = d % 475
for j in range(25):
i = (i * 96 + 42) % 475
if i == p - 26:
print((n > 0) * n // 2)
exit()
n += 1
d += 1
``` | output | 1 | 67,798 | 11 | 135,597 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,799 | 11 | 135,598 |
Tags: brute force, implementation
Correct Solution:
```
import itertools
p, x, y = map(int, input().split())
d = (x - y) // 50
p -= 26
i0 = x // 50 % 475
for k in itertools.count(-d):
i = (i0 + k) % 475
for _ in range(25):
i = (i * 96 + 42) % 475
if i == p:
print(max(0, (k + 1) // 2))
exit()
``` | output | 1 | 67,799 | 11 | 135,599 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,800 | 11 | 135,600 |
Tags: brute force, implementation
Correct Solution:
```
def f(n):
i = (n // 50) % 475
for j in range(25):
i = (i * 96 + 42) % 475
if i + 26 == p:
return True
return False
p, x, y = map(int, input().split())
k = 0
can = False
i = x
while i - 50 >= y:
i -= 50
if f(i):
print(0)
can = True
break
if not can:
for i in range(x, x + 30001, 50):
if f(i):
print(k)
break
if not (i - x) % 100:
k += 1
``` | output | 1 | 67,800 | 11 | 135,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,801 | 11 | 135,602 |
Tags: brute force, implementation
Correct Solution:
```
#Problem: https://codeforces.com/contest/807/problem/B
p, x, y = map(int, input().split())
def check(s):
i = (s // 50) % 475
for t in range(25):
i = (i * 96 + 42) % 475
if 26 + i == p:
return True
return False
for up in range(500):
for down in range(500):
if x + 100 * up - 50 * down >= y and check(x + 100 * up - 50 * down):
print(up)
exit()
``` | output | 1 | 67,801 | 11 | 135,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,802 | 11 | 135,604 |
Tags: brute force, implementation
Correct Solution:
```
p, x, y = map(int, input().split())
cur = x
while cur - 50 >= y:
cur -= 50
def gen(s):
i = (s // 50) % 475
res = []
for _ in range(25):
i = (i * 96 + 42) % 475
res.append(26 + i)
return res
while p not in gen(cur):
cur += 50
print((max(cur - x, 0) + 99) // 100)
``` | output | 1 | 67,802 | 11 | 135,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,803 | 11 | 135,606 |
Tags: brute force, implementation
Correct Solution:
```
p, x, y = map(int, input().split())
z = (x - y) // 50
d = x // 50 - z
n = 1 - z
while 1:
i = d % 475
for j in range(25):
i = (i * 96 + 42) % 475
if i == p - 26:
print((n > 0) * n // 2)
exit()
n += 1
d += 1
``` | output | 1 | 67,803 | 11 | 135,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt. | instruction | 0 | 67,804 | 11 | 135,608 |
Tags: brute force, implementation
Correct Solution:
```
def calc_T_shirt_winner_places(s):
"""
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
"""
i = (s // 50) % 475
i_indices = set()
for j in range(25):
i = (i * 96 + 42) % 475
i_indices.add(26 + i)
return i_indices
def reachable_by_unsuccessful_hacks(wanted_place, orig_score, min_place):
score = orig_score
while score >= min_place:
if wanted_place in calc_T_shirt_winner_places(score):
return True
score -= 50
if wanted_place in calc_T_shirt_winner_places(score) and score >= min_place:
return True
return False
def calc_number_of_successful_hacks_needed(wanted_place, orig_score):
hacks = 0
score_by_50, score_by_100 = orig_score + 50, orig_score + 100
while True:
hacks += 1
if (score_by_50 >= min_place and wanted_place in calc_T_shirt_winner_places(score_by_50)) or (score_by_100 >= min_place and wanted_place in calc_T_shirt_winner_places(score_by_100)):
return hacks
score_by_50 += 100
score_by_100 += 100
codecraft_place, curr_score, min_place = [int(p) for p in input().split()]
if reachable_by_unsuccessful_hacks(codecraft_place, curr_score, min_place):
print(0)
else:
print(calc_number_of_successful_hacks_needed(codecraft_place, curr_score))
``` | output | 1 | 67,804 | 11 | 135,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
p, x, y = map(int, input().split())
def ok_numbers(s):
i = (s // 50) % 475
ret = set([])
for _ in range(25):
i = (i * 96 + 42) % 475
ret.add(i + 26)
return ret
# lower
lo_x = x
while lo_x >= y:
if p in ok_numbers(lo_x):
print(0)
exit()
lo_x -= 50
# upper
cnt = 1
while True:
if p in ok_numbers(x + 50) or p in ok_numbers(x + 100):
print(cnt)
exit()
cnt += 1
x += 100
``` | instruction | 0 | 67,805 | 11 | 135,610 |
Yes | output | 1 | 67,805 | 11 | 135,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
def Ts(rank,score):
#print(score)
arr = []
i = (score // 50) % 475
for x in range(25):
i = (i * 96 + 42) % 475
arr.append(26 + i)
#print(rank,arr)
if rank in arr:
#print("yes")
return False
else:
#print("No")
return True
rank,cur,need = map(int,input().split())
t_cur = cur
while(cur-50 >= need ):
cur-=50
while( Ts(rank,cur)):
cur+=50
#print("#########################",cur)
cur-=t_cur
cur+=50
if(cur<0):
ans = 0
else:
ans = cur//100
print(ans)
``` | instruction | 0 | 67,806 | 11 | 135,612 |
Yes | output | 1 | 67,806 | 11 | 135,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
def winner(x,y):
for i in y:
if x == i:
return True
return False
def IsWinner(p,s): #Place and score
i = (s//50) % 475
for j in range(25):
i = (i * 96 + 42) % 475
if p==(i+26):
return True
return False
line = input()
p = int(line.split()[0])
x = int(line.split()[1])
y = int(line.split()[2])
a_up = 0
a = -1
found = False
cs = x
while(cs>=y):
if IsWinner(p,cs):
a = 0
break
if IsWinner(p,cs+50):
a = 1
cs = cs - 50
cs = x
if (a==-1):
while(True):
a_up = a_up+1
cs = cs + 100
if IsWinner(p,cs) or IsWinner(p,cs-50):
a = a_up
break
print(a)
``` | instruction | 0 | 67,807 | 11 | 135,614 |
Yes | output | 1 | 67,807 | 11 | 135,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
def ps2(low,high):
global flag
if flag:
t=-1
for i in range(low,high+1):
t+=1
i= (i)%475
for _ in range(25):
i=(i*96+42)%475
r=i+26
if r == p:
result.append(t)
flag=False
break
if flag == False:
break
def ps1(low,high):
global flag
if flag:
t=-1
for i in range(high,low-1,-1):
t+=1
jjj=i
i= (i)%475
for _ in range(25):
i=(i*96+42)%475
r=i+26
if r == p:
result.append(t)
flag=False
break
if flag == False:
break
p,x,y=map(int,input().split())
result=[]
if x < y:
mid=y
if y % 50 != 0:
mid+=1
#high=99**9
mid//=50
high=99999999990
flag=True
ps2(mid,high)
tt=mid-(x//50)
for i in range(len(result)):
p=result[i]
if p % 2 == 0:
result[i]=int(p/2)
else:
result[i]=int((p+1)/2)
print(min(result)+tt)
else:
low=y
mid=x
#high=99**9
low //=50
mid //=50
if (x-y) % 50 != 0:
low+=1
high=99999999990
#1
flag=True
ps1(low,mid)
if len(result) > 0:
print(0)
else:
#2
flag=True
ps2(mid,high)
for i in range(len(result)):
p=result[i]
if p % 2 == 0:
result[i]=int(p/2)
else:
result[i]=int((p+1)/2)
print(min(result))
``` | instruction | 0 | 67,808 | 11 | 135,616 |
Yes | output | 1 | 67,808 | 11 | 135,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
import math
p, x, y = map(int,input().split())
origx = x
target = 0
while True:
global target
winners = set()
i = y // 50 % 475
for z in range(25):
i = (i * 96 + 42) % 475
winners.add(26+i)
if p in winners:
target = y
break
y+=50
if target < origx:
print(0)
else:
print(math.ceil((target-x)/100))
``` | instruction | 0 | 67,809 | 11 | 135,618 |
No | output | 1 | 67,809 | 11 | 135,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
p , x , y = map(int , input().split())
Tshirt = []
s = 0
hk = 0
suchk = 0
while(x < y):
hk += 1
x += 100
def genT():
# Tshirt = []
s = x
i = (s // 50) % 475
for j in range(25):
i = (i * 96 + 42) % 475
Tshirt.append(26 + i)
# print(Tshirt)
genT()
if(p in Tshirt):
print(suchk)
exit(0)
orgx = x
while(x >= y):
Tshirt = []
x -= 50
genT()
if(p in Tshirt):
print(suchk)
exit(0)
x = orgx
while(not (p in Tshirt)):
Tshirt = []
hk += 1
if(hk % 2 == 1): suchk += 1
x += 50
genT()
print(suchk)
``` | instruction | 0 | 67,810 | 11 | 135,620 |
No | output | 1 | 67,810 | 11 | 135,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
def mp(): return map(int,input().split())
def lt(): return list(map(int,input().split()))
def pt(x): print(x)
def ip(): return input()
def it(): return int(input())
def sl(x): return [t for t in x]
def spl(x): return x.split()
def aj(liste, item): liste.append(item)
def bin(x): return "{0:b}".format(x)
def listring(l): return ' '.join([str(x) for x in l])
def ptlist(l): print(' '.join([str(x) for x in l]))
p,x,y = mp()
z = x
i = (z//50) % 475
a = []
for _ in range(25):
i = (i*96+42) % 475
a.append(26+i)
while z > y and not p in a:
z -= 50
i = (z//50) % 475
a = []
for _ in range(25):
i = (i*96+42) % 475
a.append(26+i)
if p in a:
print("0")
else:
bl = True
t = 1
while bl:
z = x+t*100
i = (z//50) % 475
a = []
for _ in range(25):
i = (i*96+42) % 475
a.append(26+i)
if p in a:
bl = False
else:
z = x+t*100-50
i = (z//50) % 475
a = []
for _ in range(25):
i = (i*96+42) % 475
a.append(26+i)
if p in a:
bl = False
else:
t += 1
pt(t)
``` | instruction | 0 | 67,811 | 11 | 135,622 |
No | output | 1 | 67,811 | 11 | 135,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago the Codecraft-17 contest was held on Codeforces. The top 25 participants, and additionally random 25 participants out of those who got into top 500, will receive a Codeforces T-shirt.
Unfortunately, you didn't manage to get into top 25, but you got into top 500, taking place p.
Now the elimination round of 8VC Venture Cup 2017 is being held. It has been announced that the Codecraft-17 T-shirt winners will be chosen as follows. Let s be the number of points of the winner of the elimination round of 8VC Venture Cup 2017. Then the following pseudocode will be executed:
i := (s div 50) mod 475
repeat 25 times:
i := (i * 96 + 42) mod 475
print (26 + i)
Here "div" is the integer division operator, "mod" is the modulo (the remainder of division) operator.
As the result of pseudocode execution, 25 integers between 26 and 500, inclusive, will be printed. These will be the numbers of places of the participants who get the Codecraft-17 T-shirts. It is guaranteed that the 25 printed integers will be pairwise distinct for any value of s.
You're in the lead of the elimination round of 8VC Venture Cup 2017, having x points. You believe that having at least y points in the current round will be enough for victory.
To change your final score, you can make any number of successful and unsuccessful hacks. A successful hack brings you 100 points, an unsuccessful one takes 50 points from you. It's difficult to do successful hacks, though.
You want to win the current round and, at the same time, ensure getting a Codecraft-17 T-shirt. What is the smallest number of successful hacks you have to do to achieve that?
Input
The only line contains three integers p, x and y (26 ≤ p ≤ 500; 1 ≤ y ≤ x ≤ 20000) — your place in Codecraft-17, your current score in the elimination round of 8VC Venture Cup 2017, and the smallest number of points you consider sufficient for winning the current round.
Output
Output a single integer — the smallest number of successful hacks you have to do in order to both win the elimination round of 8VC Venture Cup 2017 and ensure getting a Codecraft-17 T-shirt.
It's guaranteed that your goal is achievable for any valid input data.
Examples
Input
239 10880 9889
Output
0
Input
26 7258 6123
Output
2
Input
493 8000 8000
Output
24
Input
101 6800 6500
Output
0
Input
329 19913 19900
Output
8
Note
In the first example, there is no need to do any hacks since 10880 points already bring the T-shirt to the 239-th place of Codecraft-17 (that is, you). In this case, according to the pseudocode, the T-shirts will be given to the participants at the following places:
475 422 84 411 453 210 157 294 146 188 420 367 29 356 398 155 102 239 91 133 365 312 449 301 343
In the second example, you have to do two successful and one unsuccessful hack to make your score equal to 7408.
In the third example, you need to do as many as 24 successful hacks to make your score equal to 10400.
In the fourth example, it's sufficient to do 6 unsuccessful hacks (and no successful ones) to make your score equal to 6500, which is just enough for winning the current round and also getting the T-shirt.
Submitted Solution:
```
L = [set() for _ in range(475)]
for i in range(475):
x = i
for j in range(25):
x = (x*96 + 42)%475
L[i].add(26+x)
p, x, y = map(int, input().split())
s = x
l = y
ans = 10**9
while s >= l:
if p in L[(s//50)%475]:
ans = 0
break
s -= 50
off = 0
while x < y:
x += 100
off += 1
s = x//50
t = set()
i = 0
while len(t) != 475:
if p in L[s%475] or p in L[(s+1)%475]:
ans = min(ans, off+i)
break
t.add(s%475)
t.add((s-1)%475)
i += 1
s += 2
print(ans)
``` | instruction | 0 | 67,812 | 11 | 135,624 |
No | output | 1 | 67,812 | 11 | 135,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
from operator import itemgetter
R = lambda:map(int, input().split())
n, m = R()
a = list(R())
b = [0] * n
for i in R():
b[i - 1] = 1
a = sorted(enumerate(a), key=itemgetter(1), reverse=True)
s = sum(x for i, x in a if b[i] != 1)
for i, x in a:
if b[i] == 1:
s += s if s > x else x
print(s)
# Made By Mostafa_Khaled
``` | instruction | 0 | 68,486 | 11 | 136,972 |
Yes | output | 1 | 68,486 | 11 | 136,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
n, m = map(int, input().split())
prices = list(map(int, input().split()))
normal = []
auct = []
q = list(map(int, input().split()))
sum = 0
for i in range(n):
if i + 1 in q:
auct.append(prices[i])
else:
sum += prices[i]
auct = sorted(auct, reverse=True)
for elem in auct:
sum += max(elem, sum)
print(sum)
``` | instruction | 0 | 68,487 | 11 | 136,974 |
Yes | output | 1 | 68,487 | 11 | 136,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
import sys
from itertools import *
from math import *
MAX = 10000000
def solve():
n, m = map(int, input().split())
quest = list(map(int, input().split()))
auctindex = set(map(int, input().split()))
aucts = list()
firstsum = 0
for i, q in enumerate(quest):
if (i + 1) not in auctindex:
firstsum+= q
else:
aucts.append(q)
aucts.sort(reverse = True)
for val in aucts:
firstsum += max(firstsum, val)
print(firstsum)
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()
``` | instruction | 0 | 68,488 | 11 | 136,976 |
Yes | output | 1 | 68,488 | 11 | 136,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=1000000007
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n,m=value()
a=array()
have=set(array())
need=[]
ans=0
for i in range(n):
if(i+1 not in have): ans+=a[i]
else: need.append(a[i])
need.sort(reverse=True)
for i in need:
if(ans<=i): ans+=i
else: ans*=2
print(ans)
``` | instruction | 0 | 68,489 | 11 | 136,978 |
Yes | output | 1 | 68,489 | 11 | 136,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
n, m = input().split()
znac=input().split()
nay=input().split()
ayc=[]
summ=0
obi = []
for i in range(int(n)):
if str(i+1) in nay:
ayc.append(znac[i])
else:
obi.append(znac[i])
nayk=reversed(sorted(ayc))
for i in obi:
summ+=int(i)
for i in nayk:
if summ<int(i):
summ+=int(i)
else:
summ+=summ
print(summ)
``` | instruction | 0 | 68,490 | 11 | 136,980 |
No | output | 1 | 68,490 | 11 | 136,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
n , m = map(int,input().split())
que =list(map(int,input().split()))
#print(que)
auc = list(map(int,input().split()))
s = sum(que)
for i in auc:
s-=que[i-1]
auc.sort(reverse=True)
for i in auc:
if que[i-1]<s:
s*=2
else:
s+=que[i-1]
print(s)
``` | instruction | 0 | 68,491 | 11 | 136,982 |
No | output | 1 | 68,491 | 11 | 136,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
n, m = input().split()
znac=input().split()
nay=input().split()
ayc=[]
summ=0
obi = []
for i in range(int(n)):
if str(i+1) in nay:
ayc.append(znac[i])
else:
obi.append(znac[i])
nayk=sorted(ayc)[::-1]
for i in obi:
summ+=int(i)
for i in nayk:
if summ<int(i):
summ+=int(i)
else:
summ+=summ
print(summ)
``` | instruction | 0 | 68,492 | 11 | 136,984 |
No | output | 1 | 68,492 | 11 | 136,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100; m ≤ min(n, 30)) — the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 107) — the prices of the questions. The third line contains m distinct integers bi (1 ≤ bi ≤ n) — the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem — the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
Submitted Solution:
```
n_m_input = input()
n = int(n_m_input.split(" ")[0])
m = int(n_m_input.split(" ")[1])
temp_input = input()
main_list = [int(i) for i in temp_input.split(" ")]
temp_input = input()
float_up_list = [int(i) for i in temp_input.split(" ")]
sum = sum(main_list)
float_up_marks = []
for i in range(len(float_up_list)) :
sum = sum - main_list[float_up_list[i]-1]
float_up_marks.append(main_list[float_up_list[i]-1])
float_up_marks.sort()
while len(float_up_marks) > 0 :
if sum > float_up_marks[0] :
sum = sum * 2
float_up_marks.pop(0)
else :
sum = sum + float_up_marks[-1]
float_up_marks.pop()
print(sum)
``` | instruction | 0 | 68,493 | 11 | 136,986 |
No | output | 1 | 68,493 | 11 | 136,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The All-Berland National Olympiad in Informatics has just ended! Now Vladimir wants to upload the contest from the Olympiad as a gym to a popular Codehorses website.
Unfortunately, the archive with Olympiad's data is a mess. For example, the files with tests are named arbitrary without any logic.
Vladimir wants to rename the files with tests so that their names are distinct integers starting from 1 without any gaps, namely, "1", "2", ..., "n', where n is the total number of tests.
Some of the files contain tests from statements (examples), while others contain regular tests. It is possible that there are no examples, and it is possible that all tests are examples. Vladimir wants to rename the files so that the examples are the first several tests, all all the next files contain regular tests only.
The only operation Vladimir can perform is the "move" command. Vladimir wants to write a script file, each of the lines in which is "move file_1 file_2", that means that the file "file_1" is to be renamed to "file_2". If there is a file "file_2" at the moment of this line being run, then this file is to be rewritten. After the line "move file_1 file_2" the file "file_1" doesn't exist, but there is a file "file_2" with content equal to the content of "file_1" before the "move" command.
Help Vladimir to write the script file with the minimum possible number of lines so that after this script is run:
* all examples are the first several tests having filenames "1", "2", ..., "e", where e is the total number of examples;
* all other files contain regular tests with filenames "e + 1", "e + 2", ..., "n", where n is the total number of all tests.
Input
The first line contains single integer n (1 ≤ n ≤ 105) — the number of files with tests.
n lines follow, each describing a file with test. Each line has a form of "name_i type_i", where "name_i" is the filename, and "type_i" equals "1", if the i-th file contains an example test, and "0" if it contains a regular test. Filenames of each file are strings of digits and small English letters with length from 1 to 6 characters. The filenames are guaranteed to be distinct.
Output
In the first line print the minimum number of lines in Vladimir's script file.
After that print the script file, each line should be "move file_1 file_2", where "file_1" is an existing at the moment of this line being run filename, and "file_2" — is a string of digits and small English letters with length from 1 to 6.
Examples
Input
5
01 0
2 1
2extra 0
3 1
99 0
Output
4
move 3 1
move 01 5
move 2extra 4
move 99 3
Input
2
1 0
2 1
Output
3
move 1 3
move 2 1
move 3 2
Input
5
1 0
11 1
111 0
1111 1
11111 0
Output
5
move 1 5
move 11 1
move 1111 2
move 111 4
move 11111 3
Submitted Solution:
```
n = int(input())
top = set()
bottom = set()
for i in range(n):
name, type = input().split()
if type == '1':
top.add(name)
else:
bottom.add(name)
a = len(top)
b = len(bottom)
sa = set(str(i) for i in range(1, a + 1))
q = sa & top
sa -= q
top -= q
sb = set(str(i) for i in range(a + 1, b + a + 1))
q = sb & bottom
sb -= q
bottom -= q
if sa | sb == set():
print(0)
exit(0)
c = len(sa | sb)
if sa - bottom | sb - top == set():
x, y = top.pop(), '0' * 7
c += 1
print(c)
print('move', x, y)
top.add(y)
else:
print(c)
while not (len(sa) == 0 and len(sb) == 0):
if len(top & sb) > 0 and len(sa - bottom) > 0:
x, y = set(top & sb).pop(), set(sa - bottom).pop()
print('move', x, y)
top.remove(x)
sa.remove(y)
elif len(bottom & sa) > 0 and len(sb - top) > 0:
x, y = set(bottom & sa).pop(), set(sb - top).pop()
print('move', x, y)
bottom.remove(x)
sb.remove(y)
elif len(top) > 0:
x, y = top.pop(), sa.pop()
print('move', x, y)
else:
x, y = bottom.pop(), sb.pop()
print('move', x, y)
``` | instruction | 0 | 68,634 | 11 | 137,268 |
No | output | 1 | 68,634 | 11 | 137,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The All-Berland National Olympiad in Informatics has just ended! Now Vladimir wants to upload the contest from the Olympiad as a gym to a popular Codehorses website.
Unfortunately, the archive with Olympiad's data is a mess. For example, the files with tests are named arbitrary without any logic.
Vladimir wants to rename the files with tests so that their names are distinct integers starting from 1 without any gaps, namely, "1", "2", ..., "n', where n is the total number of tests.
Some of the files contain tests from statements (examples), while others contain regular tests. It is possible that there are no examples, and it is possible that all tests are examples. Vladimir wants to rename the files so that the examples are the first several tests, all all the next files contain regular tests only.
The only operation Vladimir can perform is the "move" command. Vladimir wants to write a script file, each of the lines in which is "move file_1 file_2", that means that the file "file_1" is to be renamed to "file_2". If there is a file "file_2" at the moment of this line being run, then this file is to be rewritten. After the line "move file_1 file_2" the file "file_1" doesn't exist, but there is a file "file_2" with content equal to the content of "file_1" before the "move" command.
Help Vladimir to write the script file with the minimum possible number of lines so that after this script is run:
* all examples are the first several tests having filenames "1", "2", ..., "e", where e is the total number of examples;
* all other files contain regular tests with filenames "e + 1", "e + 2", ..., "n", where n is the total number of all tests.
Input
The first line contains single integer n (1 ≤ n ≤ 105) — the number of files with tests.
n lines follow, each describing a file with test. Each line has a form of "name_i type_i", where "name_i" is the filename, and "type_i" equals "1", if the i-th file contains an example test, and "0" if it contains a regular test. Filenames of each file are strings of digits and small English letters with length from 1 to 6 characters. The filenames are guaranteed to be distinct.
Output
In the first line print the minimum number of lines in Vladimir's script file.
After that print the script file, each line should be "move file_1 file_2", where "file_1" is an existing at the moment of this line being run filename, and "file_2" — is a string of digits and small English letters with length from 1 to 6.
Examples
Input
5
01 0
2 1
2extra 0
3 1
99 0
Output
4
move 3 1
move 01 5
move 2extra 4
move 99 3
Input
2
1 0
2 1
Output
3
move 1 3
move 2 1
move 3 2
Input
5
1 0
11 1
111 0
1111 1
11111 0
Output
5
move 1 5
move 11 1
move 1111 2
move 111 4
move 11111 3
Submitted Solution:
```
def print_all():
print(top)
print(free_top)
print(busy_top)
print(bottom)
print(free_bottom)
print(busy_bottom)
n = int(input())
top = set()
bottom = set()
for i in range(n):
name, type = input().split()
if type == '1':
top.add(name)
else:
bottom.add(name)
top_order = set(str(i) for i in range(1, len(top) + 1))
bottom_order = set(str(i) for i in range(len(top) + 1, len(bottom) + len(top) + 1))
q = top_order & top
top_order -= q
top -= q
q = bottom_order & bottom
bottom_order -= q
bottom -= q
busy_top = top_order & bottom
free_top = top_order - bottom
busy_bottom = bottom_order & top
free_bottom = bottom_order - top
if len(top_order | bottom_order) == 0:
print(0)
exit(0)
if len(free_bottom) + len(free_top) == 0:
x, y = busy_top.pop(), 'rft330'
free_top.add(x)
top.remove(x)
top.add(y)
print(len(top_order) + len(bottom_order) + 1)
print('move', x, y)
else:
print(len(top_order) + len(bottom_order))
qw = min(len(busy_bottom), len(busy_top))
if len(free_top) > 0 and qw > 0:
x = free_top.pop()
for i in range(min(len(busy_bottom), len(busy_top))):
x, y = busy_bottom.pop(), x
free_bottom.add(x)
top.remove(x)
print('move', x, y)
x, y = busy_top.pop(), x
free_top.add(x)
bottom.remove(x)
print('move', x, y)
qw = min(len(busy_bottom), len(busy_top))
if len(free_bottom) > 0 and qw > 0:
x = free_bottom.pop()
for i in range(min(len(busy_bottom), len(busy_top))):
x, y = busy_top.pop(), x
free_top.add(x)
bottom.remove(x)
print('move', x, y)
x, y = busy_bottom.pop(), x
free_bottom.add(x)
top.remove(x)
print('move', x, y)
if len(busy_bottom) == 0:
print(len(bottom))
print(len(free_bottom))
assert(len(bottom) == len(free_bottom))
for i in range(len(bottom)):
print('move', bottom.pop(), free_bottom.pop())
free_top |= busy_top
busy_top.clear()
print(len(top))
print(len(free_top))
assert(len(top) == len(free_top))
for i in range(len(top)):
print('move', top.pop(), free_top.pop())
if len(busy_top) == 0:
print_all()
assert(len(top) == len(free_top))
for i in range(len(free_top)):
print('move', top.pop(), free_top.pop())
free_bottom |= busy_bottom
busy_bottom.clear()
assert(len(bottom) == len(free_bottom))
for i in range(len(bottom)):
print('move', bottom.pop(), free_bottom.pop())
``` | instruction | 0 | 68,635 | 11 | 137,270 |
No | output | 1 | 68,635 | 11 | 137,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The All-Berland National Olympiad in Informatics has just ended! Now Vladimir wants to upload the contest from the Olympiad as a gym to a popular Codehorses website.
Unfortunately, the archive with Olympiad's data is a mess. For example, the files with tests are named arbitrary without any logic.
Vladimir wants to rename the files with tests so that their names are distinct integers starting from 1 without any gaps, namely, "1", "2", ..., "n', where n is the total number of tests.
Some of the files contain tests from statements (examples), while others contain regular tests. It is possible that there are no examples, and it is possible that all tests are examples. Vladimir wants to rename the files so that the examples are the first several tests, all all the next files contain regular tests only.
The only operation Vladimir can perform is the "move" command. Vladimir wants to write a script file, each of the lines in which is "move file_1 file_2", that means that the file "file_1" is to be renamed to "file_2". If there is a file "file_2" at the moment of this line being run, then this file is to be rewritten. After the line "move file_1 file_2" the file "file_1" doesn't exist, but there is a file "file_2" with content equal to the content of "file_1" before the "move" command.
Help Vladimir to write the script file with the minimum possible number of lines so that after this script is run:
* all examples are the first several tests having filenames "1", "2", ..., "e", where e is the total number of examples;
* all other files contain regular tests with filenames "e + 1", "e + 2", ..., "n", where n is the total number of all tests.
Input
The first line contains single integer n (1 ≤ n ≤ 105) — the number of files with tests.
n lines follow, each describing a file with test. Each line has a form of "name_i type_i", where "name_i" is the filename, and "type_i" equals "1", if the i-th file contains an example test, and "0" if it contains a regular test. Filenames of each file are strings of digits and small English letters with length from 1 to 6 characters. The filenames are guaranteed to be distinct.
Output
In the first line print the minimum number of lines in Vladimir's script file.
After that print the script file, each line should be "move file_1 file_2", where "file_1" is an existing at the moment of this line being run filename, and "file_2" — is a string of digits and small English letters with length from 1 to 6.
Examples
Input
5
01 0
2 1
2extra 0
3 1
99 0
Output
4
move 3 1
move 01 5
move 2extra 4
move 99 3
Input
2
1 0
2 1
Output
3
move 1 3
move 2 1
move 3 2
Input
5
1 0
11 1
111 0
1111 1
11111 0
Output
5
move 1 5
move 11 1
move 1111 2
move 111 4
move 11111 3
Submitted Solution:
```
import random
def genTemp():
sl = ""
firstTime = True
while firstTime or sl in pre or sl in post:
sl = ""
firstTime = False
for i in range(6):
sl += chr(random.randint(ord("a"), ord("z")))
return sl
n = int(input())
e = 0
pre = set()
post = set()
for i in range(n):
name, tp = input().split()
if tp == "1":
e += 1
pre.add(name)
else:
post.add(name)
temp = genTemp()
preAns = {str(x) for x in range(1, e + 1)}
postAns = {str(x) for x in range(e + 1, n + 1)}
preMissing = preAns - pre
postMissing = postAns - post
preToChange = pre - preAns
postToChange= post - postAns
preFree = preMissing - postToChange
postFree = postMissing - preToChange
preWrong = preToChange - postMissing
postWrong = preToChange - postMissing
ans = []
while postFree or preFree:
if preFree:
if preWrong:
x = preWrong.pop()
preToChange.discard(x)
else:
x = preToChange.pop()
y = preFree.pop()
ans.append(("move", x, y))
preMissing.discard(y)
if x in postAns:
postFree.add(x)
else:
if postWrong:
x = postWrong.pop()
postToChange.discard(x)
else:
x = postToChange.pop()
y = postFree.pop()
ans.append(("move", x, y))
postMissing.discard(y)
if x in preAns:
preFree.add(x)
while preToChange and postToChange:
# bad, using temp
x = preToChange.pop()
y = postToChange.pop()
ans.append(("move", x, temp))
ans.append(("move", y, x))
ans.append(("move", temp, y))
preMissing.discard(y)
postMissing.discard(x)
print(len(ans))
for tup in ans:
print(*tup)
``` | instruction | 0 | 68,636 | 11 | 137,272 |
No | output | 1 | 68,636 | 11 | 137,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The All-Berland National Olympiad in Informatics has just ended! Now Vladimir wants to upload the contest from the Olympiad as a gym to a popular Codehorses website.
Unfortunately, the archive with Olympiad's data is a mess. For example, the files with tests are named arbitrary without any logic.
Vladimir wants to rename the files with tests so that their names are distinct integers starting from 1 without any gaps, namely, "1", "2", ..., "n', where n is the total number of tests.
Some of the files contain tests from statements (examples), while others contain regular tests. It is possible that there are no examples, and it is possible that all tests are examples. Vladimir wants to rename the files so that the examples are the first several tests, all all the next files contain regular tests only.
The only operation Vladimir can perform is the "move" command. Vladimir wants to write a script file, each of the lines in which is "move file_1 file_2", that means that the file "file_1" is to be renamed to "file_2". If there is a file "file_2" at the moment of this line being run, then this file is to be rewritten. After the line "move file_1 file_2" the file "file_1" doesn't exist, but there is a file "file_2" with content equal to the content of "file_1" before the "move" command.
Help Vladimir to write the script file with the minimum possible number of lines so that after this script is run:
* all examples are the first several tests having filenames "1", "2", ..., "e", where e is the total number of examples;
* all other files contain regular tests with filenames "e + 1", "e + 2", ..., "n", where n is the total number of all tests.
Input
The first line contains single integer n (1 ≤ n ≤ 105) — the number of files with tests.
n lines follow, each describing a file with test. Each line has a form of "name_i type_i", where "name_i" is the filename, and "type_i" equals "1", if the i-th file contains an example test, and "0" if it contains a regular test. Filenames of each file are strings of digits and small English letters with length from 1 to 6 characters. The filenames are guaranteed to be distinct.
Output
In the first line print the minimum number of lines in Vladimir's script file.
After that print the script file, each line should be "move file_1 file_2", where "file_1" is an existing at the moment of this line being run filename, and "file_2" — is a string of digits and small English letters with length from 1 to 6.
Examples
Input
5
01 0
2 1
2extra 0
3 1
99 0
Output
4
move 3 1
move 01 5
move 2extra 4
move 99 3
Input
2
1 0
2 1
Output
3
move 1 3
move 2 1
move 3 2
Input
5
1 0
11 1
111 0
1111 1
11111 0
Output
5
move 1 5
move 11 1
move 1111 2
move 111 4
move 11111 3
Submitted Solution:
```
def print_all():
print(top)
print(free_top)
print(busy_top)
print(bottom)
print(free_bottom)
print(busy_bottom)
n = int(input())
top = set()
bottom = set()
for i in range(n):
name, type = input().split()
if type == '1':
top.add(name)
else:
bottom.add(name)
top_order = set(str(i) for i in range(1, len(top) + 1))
bottom_order = set(str(i) for i in range(len(top) + 1, len(bottom) + len(top) + 1))
q = top_order & top
top_order -= q
top -= q
q = bottom_order & bottom
bottom_order -= q
bottom -= q
busy_top = top_order & bottom
free_top = top_order - bottom
busy_bottom = bottom_order & top
free_bottom = bottom_order - top
if len(top_order | bottom_order) == 0:
print(0)
exit(0)
if len(free_bottom) + len(free_top) == 0:
x, y = busy_top.pop(), 'rft330'
free_top.add(x)
bottom.remove(x)
bottom.add(y)
print(len(top_order) + len(bottom_order) + 1)
print('move', x, y)
else:
print(len(top_order) + len(bottom_order))
qw = min(len(busy_bottom), len(busy_top))
if len(free_top) > 0 and qw > 0:
x = free_top.pop()
for i in range(min(len(busy_bottom), len(busy_top))):
x, y = busy_bottom.pop(), x
free_bottom.add(x)
top.remove(x)
print('move', x, y)
x, y = busy_top.pop(), x
free_top.add(x)
bottom.remove(x)
free_bottom.remove(y)
print('move', x, y)
qw = min(len(busy_bottom), len(busy_top))
if len(free_bottom) > 0 and qw > 0:
x = free_bottom.pop()
for i in range(min(len(busy_bottom), len(busy_top))):
x, y = busy_top.pop(), x
bottom.remove(x)
print('move', x, y)
x, y = busy_bottom.pop(), x
free_bottom.add(x)
top.remove(x)
print('move', x, y)
if len(busy_bottom) == 0:
for i in range(len(bottom)):
print('move', bottom.pop(), free_bottom.pop())
free_top |= busy_top
busy_top.clear()
for i in range(len(top)):
print('move', top.pop(), free_top.pop())
elif len(busy_top) == 0:
for i in range(len(top)):
print('move', top.pop(), free_top.pop())
free_bottom |= busy_bottom
busy_bottom.clear()
for i in range(len(bottom)):
print('move', bottom.pop(), free_bottom.pop())
``` | instruction | 0 | 68,637 | 11 | 137,274 |
No | output | 1 | 68,637 | 11 | 137,275 |
Provide a correct Python 3 solution for this coding contest problem.
Example
Input
3
()(()((
))()()(()
)())(())
Output
Yes | instruction | 0 | 68,889 | 11 | 137,778 |
"Correct Solution:
```
def solve():
N = int(input())
T0 = []
T1 = []
su = 0
for i in range(N):
s = input()
a = 0
for c in s:
if c == '(':
a += 1
elif a > 0:
a -= 1
b = 0
for c in reversed(s):
if c == ')':
b += 1
elif b > 0:
b -= 1
if b < a:
T0.append((b, a))
else:
T1.append((a, b))
su += a - b
if su != 0:
print("No")
return
def check(T, N):
U = [0]*N
cur = 0
for i in range(N):
k = -1; e = (-1000, -1000)
for j in range(N):
if U[j]:
continue
b, a = T[j]
if b <= cur:
ne = (a-b, b)
if e < ne:
k = j
e = ne
if k == -1:
return 0
b, a = T[k]
U[k] = 1
cur += a-b
return 1
if check(T0, len(T0)) and check(T1, len(T1)):
print("Yes")
else:
print("No")
solve()
``` | output | 1 | 68,889 | 11 | 137,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once upon a time a child got a test consisting of multiple-choice questions as homework. A multiple-choice question consists of four choices: A, B, C and D. Each choice has a description, and the child should find out the only one that is correct.
Fortunately the child knows how to solve such complicated test. The child will follow the algorithm:
* If there is some choice whose description at least twice shorter than all other descriptions, or at least twice longer than all other descriptions, then the child thinks the choice is great.
* If there is exactly one great choice then the child chooses it. Otherwise the child chooses C (the child think it is the luckiest choice).
You are given a multiple-choice questions, can you predict child's choose?
Input
The first line starts with "A." (without quotes), then followed the description of choice A. The next three lines contains the descriptions of the other choices in the same format. They are given in order: B, C, D. Please note, that the description goes after prefix "X.", so the prefix mustn't be counted in description's length.
Each description is non-empty and consists of at most 100 characters. Each character can be either uppercase English letter or lowercase English letter, or "_".
Output
Print a single line with the child's choice: "A", "B", "C" or "D" (without quotes).
Examples
Input
A.VFleaKing_is_the_author_of_this_problem
B.Picks_is_the_author_of_this_problem
C.Picking_is_the_author_of_this_problem
D.Ftiasch_is_cute
Output
D
Input
A.ab
B.abcde
C.ab
D.abc
Output
C
Input
A.c
B.cc
C.c
D.c
Output
B
Note
In the first sample, the first choice has length 39, the second one has length 35, the third one has length 37, and the last one has length 15. The choice D (length 15) is twice shorter than all other choices', so it is great choice. There is no other great choices so the child will choose D.
In the second sample, no choice is great, so the child will choose the luckiest choice C.
In the third sample, the choice B (length 2) is twice longer than all other choices', so it is great choice. There is no other great choices so the child will choose B.
Submitted Solution:
```
s1=input()
s2=input()
s3=input()
s4=input()
l1=len(s1)-2
l2=len(s2)-2
l3=len(s3)-2
l4=len(s4)-2
ll=[[l1,"A"],[l2,"B"],[l3,"C"],[l4,"D"]]
ll.sort()
if(ll[0][0]<=ll[1][0]/2 and ll[-1][0]>=ll[-2][0]*2):
print("C")
elif(ll[0][0]<=ll[1][0]/2):
print(ll[0][1])
elif(ll[-1][0]>=ll[-2][0]*2):
print(ll[-1][1])
else:
print("C")
``` | instruction | 0 | 69,337 | 11 | 138,674 |
Yes | output | 1 | 69,337 | 11 | 138,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once upon a time a child got a test consisting of multiple-choice questions as homework. A multiple-choice question consists of four choices: A, B, C and D. Each choice has a description, and the child should find out the only one that is correct.
Fortunately the child knows how to solve such complicated test. The child will follow the algorithm:
* If there is some choice whose description at least twice shorter than all other descriptions, or at least twice longer than all other descriptions, then the child thinks the choice is great.
* If there is exactly one great choice then the child chooses it. Otherwise the child chooses C (the child think it is the luckiest choice).
You are given a multiple-choice questions, can you predict child's choose?
Input
The first line starts with "A." (without quotes), then followed the description of choice A. The next three lines contains the descriptions of the other choices in the same format. They are given in order: B, C, D. Please note, that the description goes after prefix "X.", so the prefix mustn't be counted in description's length.
Each description is non-empty and consists of at most 100 characters. Each character can be either uppercase English letter or lowercase English letter, or "_".
Output
Print a single line with the child's choice: "A", "B", "C" or "D" (without quotes).
Examples
Input
A.VFleaKing_is_the_author_of_this_problem
B.Picks_is_the_author_of_this_problem
C.Picking_is_the_author_of_this_problem
D.Ftiasch_is_cute
Output
D
Input
A.ab
B.abcde
C.ab
D.abc
Output
C
Input
A.c
B.cc
C.c
D.c
Output
B
Note
In the first sample, the first choice has length 39, the second one has length 35, the third one has length 37, and the last one has length 15. The choice D (length 15) is twice shorter than all other choices', so it is great choice. There is no other great choices so the child will choose D.
In the second sample, no choice is great, so the child will choose the luckiest choice C.
In the third sample, the choice B (length 2) is twice longer than all other choices', so it is great choice. There is no other great choices so the child will choose B.
Submitted Solution:
```
Astr = input()
Bstr = input()
Cstr = input()
Dstr = input()
A_len = len(Astr[2:])
B_len = len(Bstr[2:])
C_len = len(Cstr[2:])
D_len = len(Dstr[2:])
arr = [A_len, B_len, C_len, D_len]
det = "ABCD"
last_det = []
for i in range(4):
last_arr = arr.copy()
last_arr.pop(i)
if arr[i] >= 2 * last_arr[0] and arr[i] >= 2 * last_arr[1] and arr[i] >= 2 * last_arr[2]:
last_det.append(det[i])
for j in range(4):
last_arr = arr.copy()
last_arr.pop(j)
if arr[j] <= 1 / 2 * last_arr[0] and arr[j] <= 1 / 2 * last_arr[1] and arr[j] <= 1 / 2 * last_arr[2]:
last_det.append(det[j])
if len(last_det) == 1:
print(last_det[0])
else:
print("C")
``` | instruction | 0 | 69,338 | 11 | 138,676 |
Yes | output | 1 | 69,338 | 11 | 138,677 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.