message
stringlengths 2
16.2k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 575
109k
| cluster
float64 16
16
| __index_level_0__
int64 1.15k
217k
|
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves working out. He is now exercising N times.
Before he starts exercising, his power is 1. After he exercises for the i-th time, his power gets multiplied by i.
Find Snuke's power after he exercises N times. Since the answer can be extremely large, print the answer modulo 10^{9}+7.
Constraints
* 1 ≤ N ≤ 10^{5}
Input
The input is given from Standard Input in the following format:
N
Output
Print the answer modulo 10^{9}+7.
Examples
Input
3
Output
6
Input
10
Output
3628800
Input
100000
Output
457992974
Submitted Solution:
```
import math
print(math.factorial(int(input().strip()))%1000000007)
```
|
instruction
| 0
| 101,059
| 16
| 202,118
|
Yes
|
output
| 1
| 101,059
| 16
| 202,119
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves working out. He is now exercising N times.
Before he starts exercising, his power is 1. After he exercises for the i-th time, his power gets multiplied by i.
Find Snuke's power after he exercises N times. Since the answer can be extremely large, print the answer modulo 10^{9}+7.
Constraints
* 1 ≤ N ≤ 10^{5}
Input
The input is given from Standard Input in the following format:
N
Output
Print the answer modulo 10^{9}+7.
Examples
Input
3
Output
6
Input
10
Output
3628800
Input
100000
Output
457992974
Submitted Solution:
```
#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
def main():
n = int(input())
mod = 10**9+7
power=1
for i in range(1,n+1):
power*=i%mod
print(power%mod)
if __name__=="__main__":
main()
```
|
instruction
| 0
| 101,060
| 16
| 202,120
|
No
|
output
| 1
| 101,060
| 16
| 202,121
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves working out. He is now exercising N times.
Before he starts exercising, his power is 1. After he exercises for the i-th time, his power gets multiplied by i.
Find Snuke's power after he exercises N times. Since the answer can be extremely large, print the answer modulo 10^{9}+7.
Constraints
* 1 ≤ N ≤ 10^{5}
Input
The input is given from Standard Input in the following format:
N
Output
Print the answer modulo 10^{9}+7.
Examples
Input
3
Output
6
Input
10
Output
3628800
Input
100000
Output
457992974
Submitted Solution:
```
n= int(input())
cnt = 1
for i in range(1,n+1):
cnt *= i
print(cnt%(10**9+7))
```
|
instruction
| 0
| 101,061
| 16
| 202,122
|
No
|
output
| 1
| 101,061
| 16
| 202,123
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves working out. He is now exercising N times.
Before he starts exercising, his power is 1. After he exercises for the i-th time, his power gets multiplied by i.
Find Snuke's power after he exercises N times. Since the answer can be extremely large, print the answer modulo 10^{9}+7.
Constraints
* 1 ≤ N ≤ 10^{5}
Input
The input is given from Standard Input in the following format:
N
Output
Print the answer modulo 10^{9}+7.
Examples
Input
3
Output
6
Input
10
Output
3628800
Input
100000
Output
457992974
Submitted Solution:
```
n = int(input())
rslt = 1
while n > 1:
rslt *= n
n -= 1
print(rslt%(10**9+7))
```
|
instruction
| 0
| 101,062
| 16
| 202,124
|
No
|
output
| 1
| 101,062
| 16
| 202,125
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves working out. He is now exercising N times.
Before he starts exercising, his power is 1. After he exercises for the i-th time, his power gets multiplied by i.
Find Snuke's power after he exercises N times. Since the answer can be extremely large, print the answer modulo 10^{9}+7.
Constraints
* 1 ≤ N ≤ 10^{5}
Input
The input is given from Standard Input in the following format:
N
Output
Print the answer modulo 10^{9}+7.
Examples
Input
3
Output
6
Input
10
Output
3628800
Input
100000
Output
457992974
Submitted Solution:
```
# B - Training Camp
def main():
n = int(input())
ans = 1
for i in range(1, n+1):
ans *= i
else:
print(ans%(10**9+7))
if __name__ == '__main__':
main()
```
|
instruction
| 0
| 101,063
| 16
| 202,126
|
No
|
output
| 1
| 101,063
| 16
| 202,127
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,904
| 16
| 203,808
|
"Correct Solution:
```
A, B, C, D, E, F = map(int, input().split())
Swater, sugar, percent = 100*A, 0, 0
for k in range(F//(100*A) + 1):
for l in range(F//(100*B) + 1):
if k == 0 and l == 0:
continue
M = k*A + l*B
if 100 * M > F:
continue
for x in range(M*E//C + 1):
for y in range(M*E//D + 1):
S = C*x + D*y
if 100*M+S > F:
continue
if S > M*E:
continue
t = 100*S / (100*M+S)
if t > percent:
percent = t
Swater = 100*M+S
sugar = S
print(Swater, sugar)
```
|
output
| 1
| 101,904
| 16
| 203,809
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,905
| 16
| 203,810
|
"Correct Solution:
```
a, b, c, d, e, f = map(int, input().split())
res = (100 * a, 0)
for aa in range(0, f + 1, 100 * a):
for bb in range(0, f + 1, 100 * b):
w = aa + bb
if w == 0 or w >= f:
continue
r = f - w
for cc in range(0, r + 1, c):
for dd in range(0, r + 1, d):
s = cc + dd
t = w + s
if t > f or 100 * s > e * w:
continue
if s * res[0] > res[1] * t:
res = (t, s)
print(*res)
```
|
output
| 1
| 101,905
| 16
| 203,811
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,906
| 16
| 203,812
|
"Correct Solution:
```
a,b,c,d,e,f = map(int, input().split())
water, suger = 0,0
dense = 0
waters = set()
sugers = set()
for i in range(0,31,a):
for j in range(i,31,b):
waters.add(j*100)
for i in range(0,f//2+1,c):
for j in range(i,f//2+1,d):
sugers.add(j)
waters = sorted(list(waters))
sugers = sorted(list(sugers))
for w in waters:
for s in sugers:
sw = w+s
if sw > f or s > (w//100)*e or sw == 0:
continue
if s / (s+w) >= dense:
water,suger = sw,s
dense = s / (s+w)
print(water,suger)
```
|
output
| 1
| 101,906
| 16
| 203,813
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,907
| 16
| 203,814
|
"Correct Solution:
```
a,b,c,d,e,f=map(int,input().split())
waterL=[]
ac=0
while a*100*ac<=f:
bc=0
while a*100*ac+b*100*bc<=f:
waterL.append(a*100*ac+b*100*bc)
bc += 1
ac += 1
waterL.remove(0)
ma=0
ms=0
mw=0
for w in waterL:
lim=w/100*e
cc=0
while c*cc<=lim and c*cc+w<=f:
dc=0
while cc*c+dc*d<=lim and c*cc+d*dc+w<=f:
s=c*cc+d*dc
per=s/(w+s)
if per>=ma:
ma=per
ms=s
mw=w
dc += 1
cc += 1
print(int(ms+mw),int(ms))
```
|
output
| 1
| 101,907
| 16
| 203,815
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,908
| 16
| 203,816
|
"Correct Solution:
```
A, B, C, D, E, F = map(int, input().split())
ans_sw = 1
ans_s = 0
for a in range(F//(100*A)+1):
for b in range(F//(100*B)+1):
if 100*A*a + 100*B*b > F or 100*A*a+100*B*b == 0:
continue
for c in range((A*a+B*b)*E+1):
for d in range((A*a+B*b)*E+1):
sw = 100*A*a+100*B*b+C*c+D*d
s = C*c+D*d
if 0 < sw <= F and s <= (A*a+B*b)*E and ans_s/ans_sw < s/sw:
ans_s = s
ans_sw = sw
if ans_sw == 1:
print(100*A ,0)
else:
print(ans_sw, ans_s)
```
|
output
| 1
| 101,908
| 16
| 203,817
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,909
| 16
| 203,818
|
"Correct Solution:
```
import sys
sys.setrecursionlimit(65536)
a,b,c,d,e,f=map(int, input().split())
def memoize(f):
memo = {}
def g(*args):
if args not in memo:
memo[args] = f(*args)
return memo[args]
return g
@memoize
def search(w, s):
if 100*w+s > f:
return (-1, w, s)
if s > e * w or w == 0:
return max(search(a+w, s), search(b+w, s))
else:
return max(search(w, s+c), search(w, s+d), (100*s/(100*w+s), w, s))
_,w,s=search(0, 0)
print(100*w+s, s)
```
|
output
| 1
| 101,909
| 16
| 203,819
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,910
| 16
| 203,820
|
"Correct Solution:
```
A, B, C, D, E, F = map(int, input().split())
water = set()
sugar = set()
for i in range(0, F+1, 100*A):
for j in range(0, F+1-A, 100*B):
water.add(i+j)
for i in range(0, F+1, C):
for j in range(0, F+1-C, D):
sugar.add(i+j)
per = -1
for w in water:
for s in sugar:
ws = w+s
# 砂糖水の質量合計はFg以下 and 砂糖が溶け残らない
if 0 < ws <= F and s <= w*E // 100:
if s/(ws) > per:
per = s/(ws)
ans = ws, s
print(ans[0], ans[1])
```
|
output
| 1
| 101,910
| 16
| 203,821
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
|
instruction
| 0
| 101,911
| 16
| 203,822
|
"Correct Solution:
```
A,B,C,D,E,F=map(int,input().split())
w=set()
s=set()
for i in range(31):
for j in range(16):
if 100*(A*i+B*j)<=F:
w.add(100*(A*i+B*j))
for i in range(1501):
for j in range(751):
if C*i+D*j<=F/2:
s.add(C*i+D*j)
w=list(w)
w.sort()
del w[0]
s=list(s)
s.sort()
M=-1
for i in w:
for j in range(len(s)-1,-1,-1):
if s[j]*100<=E*i:
if s[j]>M*i and i+s[j]<=F:
W,S=i,s[j]
M=s[j]/i
print(W+S,S)
```
|
output
| 1
| 101,911
| 16
| 203,823
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
a,b,c,d,e,f = map(int, input().split(' '))
w = 0
s = 0
ratio = 0
for i in range((f // (b*100))+1):
for j in range(((f-(i*b*100))//(a*100))+1):
if i == 0 and j == 0:
continue
smax = min(f-(j*a+i*b)*100,(j*a+i*b)*e)
sm = 0
for k in range((smax//d)+1):
sm = max(sm, k*d+c*((smax-(k*d))//c))
if ratio <= sm/((j*a+i*b)*100+sm):
ratio = sm/((j*a+i*b)*100+sm)
w = (j*a+i*b)*100
s = sm
print("%i %i" %(w+s,s))
```
|
instruction
| 0
| 101,912
| 16
| 203,824
|
Yes
|
output
| 1
| 101,912
| 16
| 203,825
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
a,b,c,d,e,f=map(int,input().split())
ans,con = [0]*2, 0
for i in range(f//100+1):
#操作1,2はどちらか片方だけで良い.両方やると濃度が下がる?
if i%a==0 or i%b==0:
w=i*100 #水の量を基準にして, 砂糖の量を決めていく.
x=min(f-w, i*e) # 残り加えられる砂糖の量
s=0
# 砂糖を操作3で加える
for j in range(x//c+1):
s3 = j*c
#操作4も織り交ぜて, 砂糖の最大値を見つける.
s=max(s, s3+((x-s3)//d)*d)
if w!=0: #ゼロ割回避
if con<=(100*s)/(w+s):
ans = [w,s]
con = (100*s)/(w+s)
print(sum(ans), ans[1])
```
|
instruction
| 0
| 101,913
| 16
| 203,826
|
Yes
|
output
| 1
| 101,913
| 16
| 203,827
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
A, B, C, D, E, F = map(int,input().split())
a = set()
for i in range(0, F+1, 100*A):
for j in range(0, F+1-i, 100*B):
a.add(i+j)
b = set()
for i in range(0, F+1, C):
for j in range(0, F+1-i, D):
b.add(i+j)
tmp = -1
for aa in a:
for bb in b:
if(0 < aa+bb <= F and bb <= aa*E//100):
if(tmp < bb/(aa+bb)):
ans = aa+bb, bb
tmp = bb/(aa+bb)
print(ans[0], ans[1])
```
|
instruction
| 0
| 101,914
| 16
| 203,828
|
Yes
|
output
| 1
| 101,914
| 16
| 203,829
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
A,B,C,D,E,F = map(int,input().split())
W = set()
for i in range(0,F+1,100*A):
for j in range(0,F+1-i,100*B):
W.add(i+j)
S = set()
for i in range(0,F+1,C):
for j in range(0,F+1-i,D):
S.add(i+j)
rate = 0
for w in W:
for s in S:
if 0 < w+s <= F and s/(w+s) <= E/(E+100):
if s/(w+s) >= rate:
rate= s/(w+s)
res1,res2 = w+s,s
print(res1,res2)
```
|
instruction
| 0
| 101,915
| 16
| 203,830
|
Yes
|
output
| 1
| 101,915
| 16
| 203,831
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
A,B,C,D,E,F=map(int,input().split())
satoumizu=1
satou=0
for a in range(31):
for b in range(16):
for c in range(F-100*A*a-100*B*b):
for d in range(F-100*A*a-100*B*b-C*c):
if a==0 and b==0 and c==0 and d==0:
continue
if E*(A*a+B*b)>=C*c+D*d and 100*(A*a+B*b)+C*c+D*d<=F:
if (C*c+D*d)/(100*(A*a+B*b)+C*c+D*d)>satou/satoumizu:
satoumizu=100*(A*a+B*b)+C*c+D*d
satou=C*c+D*d
print(satoumizu,satou)
```
|
instruction
| 0
| 101,916
| 16
| 203,832
|
No
|
output
| 1
| 101,916
| 16
| 203,833
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
import sys
a, b, c, d, e, f = map(int, input().split())
water_pattern = []
for i in range(f+1):
for j in range(f+1):
x = a*i*100 + b*j*100
if x <= f:
water_pattern.append(x)
sugar_pattern = []
for i in range(f+1):
for j in range(f+1):
y = c*i + d*j
if y <= f:
sugar_pattern.append(y)
sugarwater_max = -1
sugar_max = -1
concentration = 0
for i in range(len(water_pattern)):
for j in range(len(sugar_pattern)):
if i == 0 and j == 0:
continue
else:
sugarwater = water_pattern[i] + sugar_pattern[j]
if (water_pattern[i]/100) * e >= sugar_pattern[j] and sugarwater <= f:
if sugarwater_max == -1 and sugar_max == -1:
sugarwater_max = sugarwater
sugar_max = sugar_pattern[j]
concentration = 100 * sugar_pattern[j] / sugarwater
else:
if concentration < 100 * sugar_pattern[j] / sugarwater:
sugarwater_max = sugarwater
sugar_max = sugar_pattern[j]
concentration = 100 * sugar_pattern[j] / sugarwater
print("{} {}".format(sugarwater_max, sugar_max))
```
|
instruction
| 0
| 101,917
| 16
| 203,834
|
No
|
output
| 1
| 101,917
| 16
| 203,835
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
a, b, c, d, e, f = map(int, input().split())
w = {0}
s = {0}
for i in range(f+1):
for j in range(f+1):
x = 100 * (a * i + b * j)
if x <= f:
w.add(x)
for i in range(f+1):
for j in range(f+1):
y = c * i + d * j
if y <= f:
s.add(y)
s_list = list(s)
s_list.sort()
w_list = list(w)
w_list.sort()
c_ans = 0
s_ans = 0
w_ans = 0
for i in range(1, len(w_list)):
for j in range(1, len(s_list)):
z = 100 * s_list[j] / (s_list[j] + w_list[i])
sum = w_list[i] + s_list[j]
if z <= 100 * e / (e + 100) and z > c_ans and sum <= f:
c_ans = z
w_ans = w_list[i]
s_ans = s_list[j]
print(str(w_ans + s_ans) + " " + str(s_ans))
```
|
instruction
| 0
| 101,918
| 16
| 203,836
|
No
|
output
| 1
| 101,918
| 16
| 203,837
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
Submitted Solution:
```
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
A, B, C, D, E, F = map(int, input().split())
if C > D:
C, D = D, C
mx_rate = 0
ans_water = 0
ans_sugar = 0
for i in range(31):
for j in range(31):
total = (i * A + j * B) * 100
if total > F:
continue
sugar_limit = min(F - total, (total // 100) * E)
if sugar_limit > 0:
for k in range(sugar_limit // C + 1):
sugar_total = k * C
if sugar_total < sugar_limit:
sugar_total += ((sugar_limit - sugar_total) // D) * D
rate = 100 * sugar_total / (sugar_total + total)
if rate > mx_rate:
mx_rate = rate
ans_water = total + sugar_total
ans_sugar = sugar_total
print(ans_water, ans_sugar)
```
|
instruction
| 0
| 101,919
| 16
| 203,838
|
No
|
output
| 1
| 101,919
| 16
| 203,839
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are A slimes lining up in a row. Initially, the sizes of the slimes are all 1.
Snuke can repeatedly perform the following operation.
* Choose a positive even number M. Then, select M consecutive slimes and form M / 2 pairs from those slimes as follows: pair the 1-st and 2-nd of them from the left, the 3-rd and 4-th of them, ..., the (M-1)-th and M-th of them. Combine each pair of slimes into one larger slime. Here, the size of a combined slime is the sum of the individual slimes before combination. The order of the M / 2 combined slimes remain the same as the M / 2 pairs of slimes before combination.
Snuke wants to get to the situation where there are exactly N slimes, and the size of the i-th (1 ≤ i ≤ N) slime from the left is a_i. Find the minimum number of operations required to achieve his goal.
Note that A is not directly given as input. Assume A = a_1 + a_2 + ... + a_N.
Constraints
* 1 ≤ N ≤ 10^5
* a_i is an integer.
* 1 ≤ a_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the minimum number of operations required to achieve Snuke's goal.
Examples
Input
2
3 3
Output
2
Input
4
2 1 2 2
Output
2
Input
1
1
Output
0
Input
10
3 1 4 1 5 9 2 6 5 3
Output
10
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
counter = 0
current = 0
uneven = 0
unevenOld = 0
while current < len(a):
unevenOld = uneven
uneven = 0
while a[current] > 1:
nex = current + 1
uneven = 0
while nex < n and uneven < 1:
if a[nex] % 2 == 1:
uneven = 1
if a[nex] == 1:
break
a[nex] = (a[nex] + 1) // 2
nex += 1
if a[current] % 2 == 0:
if unevenOld > 0:
unevenOld -= 1
counter -= 1
else:
uneven += 1
a[current] = (a[current]+1) // 2
counter += 1
#print(" ".join(list(map(str, a))))
current += 1
print(counter)
```
|
instruction
| 0
| 102,800
| 16
| 205,600
|
No
|
output
| 1
| 102,800
| 16
| 205,601
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,475
| 16
| 206,950
|
"Correct Solution:
```
from functools import lru_cache
n, a = int(input()), list(map(int, input().split()))
@lru_cache(maxsize=None)
def f(x, y, l, r):
if r - l + 1 <= 2:
return 0
return min(a[i] * (x + y) + f(x, x + y, l, i) + f(x + y, y, i, r) for i in range(l + 1 , r))
print(a[0] + a[-1] + f(1, 1, 0, n - 1))
```
|
output
| 1
| 103,475
| 16
| 206,951
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,476
| 16
| 206,952
|
"Correct Solution:
```
"""
https://atcoder.jp/contests/agc035/tasks/agc035_d
毎回1枚カードが減り、寄与が2倍になる
両端のカードは消せない → 寄与は1倍のまま
端から2枚目のカードしか選ばなくていいみたいなの無いかな？
端から2枚目を選ぶと、1つは端の寄与になり、もう一つは動の寄与になる
つまり、動の寄与の総和は変化しない
そうでないのを選ぶと、動の寄与に2倍かかる
→ 2**18 になっていい感じのオーダーにはなる
検証：
5枚で真ん中を最初に選ぶべきなのを作れるか？
0,X,Y,Z,0
0,X+Y,Y+Z,0
0,X+2Y+Z,Y+Z
X+2Y+Z,X+3Y+2Z
→2X+3Y+3Z or 3X+3Y+2Z (真ん中を選んだ場合)
0,X,Y,Z,0
X,X+Y,Z,0 → X,X+Y+Z,Z → 2X+Y+Z,X+Y+2Z → 3X+2Y+3Z
2X+Y,X+Y+Z,0 → 3X+2Y+Z,X+Y+Z → 4X+3Y+2Z
すなわち、真ん中を選んだ方がいい場合もある…
最後まで残した数は2倍だけの寄与で済む
最後まで残す数を決め打ちする？
最後の数で左右を分ける
→さらにその区間で最後に残すやつは3倍の寄与で済む
1 4 3 5 2 5 3 4 1
→こんな感じ
あとは分割統治で、
ある点で区切った場合の左右の最小を足して上に返せばよい
計算量は？
長さ1の場合1
2の場合 1+1 = 2
3の場合 2+1+1+2 = 6
4の場合 6+
dp[0] = 0
dp[1] = 1
dp[n] = 2*(dp[n-1]+dp[n-2]…+dp[0])
dp[16] = 9565938 なので十分可能
"""
from sys import stdin
def want(l,r,lb,rb):
if l > r:
return 0
elif l == r:
return A[l] * (lb+rb)
nmin = float("inf")
for i in range(l,r+1):
nmin = min(nmin , A[i]*(lb+rb) + want(l,i-1,lb,lb+rb) + want(i+1,r,lb+rb,rb) )
return nmin
N = int(stdin.readline())
A = list(map(int,stdin.readline().split()))
print (A[0] + A[-1] + want(1,N-2,1,1) )
```
|
output
| 1
| 103,476
| 16
| 206,953
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,477
| 16
| 206,954
|
"Correct Solution:
```
from functools import lru_cache
def solve(n, aaa):
@lru_cache(maxsize=None)
def search_min(li, ri, lc, rc):
w = ri - li
if w == 1:
return 0
lrc = lc + rc
if w == 2:
return aaa[li + 1] * lrc
if w == 3:
a1, a2 = aaa[li + 1], aaa[li + 2]
return (a1 + a2) * lrc + min(a1 * lc, a2 * rc)
ret = min(aaa[i] * lrc + search_min(li, i, lc, lrc) + search_min(i, ri, lrc, rc) for i in range(li + 1, ri))
return ret
return search_min(0, n - 1, 1, 1) + aaa[0] + aaa[-1]
n = int(input())
aaa = list(map(int, input().split()))
print(solve(n, aaa))
```
|
output
| 1
| 103,477
| 16
| 206,955
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,478
| 16
| 206,956
|
"Correct Solution:
```
from functools import lru_cache
N = int(input())
A = list(map(int, input().split()))
@lru_cache(maxsize=None)
def dfs(l, r, wl, wr):
if r <= l + 1:
return 0
v = min(dfs(l, m, wl, wl+wr) + dfs(m, r, wl+wr, wr) + A[m] * (wl+wr) for m in range(l+1, r))
return v
print(dfs(0, N-1, 1, 1) + A[0] + A[N-1])
```
|
output
| 1
| 103,478
| 16
| 206,957
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,479
| 16
| 206,958
|
"Correct Solution:
```
from functools import lru_cache
N = int(input())
A = list(map(int, input().split()))
@lru_cache(None)
def f(l, r, xl, xr):
if l+1 == r:
return xl * A[l] + xr * A[r]
tmp = float("inf")
for m in range(l+1, r):
v = f(l, m, xl, xl+xr) + f(m, r, xl+xr, xr) - (xl+xr) * A[m]
tmp = min(tmp, v)
return tmp
print(f(0, N-1, 1, 1))
```
|
output
| 1
| 103,479
| 16
| 206,959
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,480
| 16
| 206,960
|
"Correct Solution:
```
# ikatakosさんの提出を見てlru_cacheなるものを知った。
# まだまだ知らないことがたくさんありますね。
from functools import lru_cache
N = int(input())
A = [int(i) for i in input().split()]
@lru_cache(maxsize=None)
def rec(l, r, xl, xr) :
if l + 1 == r :
return 0
return min(rec(l, m, xl, xl+xr)+rec(m, r, xl+xr, xr)+A[m]*(xl+xr) for m in range(l+1, r))
print(A[0] + rec(0, N-1, 1, 1) + A[N-1])
```
|
output
| 1
| 103,480
| 16
| 206,961
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,481
| 16
| 206,962
|
"Correct Solution:
```
from functools import lru_cache
def solve(n, aaa):
@lru_cache(maxsize=None)
def search_min(li, ri, lc, rc):
w = ri - li
base = aaa[li] * lc
if w == 1:
return base
lrc = lc + rc
if w == 2:
return base + aaa[li + 1] * lrc
if w == 3:
a1, a2 = aaa[li + 1], aaa[li + 2]
return base + (a1 + a2) * lrc + min(a1 * lc, a2 * rc)
ret = min(search_min(li, i, lc, lrc) + search_min(i, ri, lrc, rc) for i in range(li + 1, ri))
return ret
return search_min(0, n - 1, 1, 1) + aaa[-1]
n = int(input())
aaa = list(map(int, input().split()))
print(solve(n, aaa))
```
|
output
| 1
| 103,481
| 16
| 206,963
|
Provide a correct Python 3 solution for this coding contest problem.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
|
instruction
| 0
| 103,482
| 16
| 206,964
|
"Correct Solution:
```
N=int(input())
A=list(map(int,input().split()))
memo={}
def dp(i,j,L,R):
if (i,j,L,R) in memo:
return memo[(i,j,L,R)]
if i==j:
memo[(i,j,L,R)]=0
memo[(i,j,L,R)]=(L+R)*A[i]
return (L+R)*A[i]
elif i>j:
return 0
ans=10**18
for k in range(i,j+1):
test=dp(i,k-1,L,L+R)+dp(k+1,j,L+R,R)+A[k]*(L+R)
ans=min(ans,test)
memo[(i,j,L,R)]=0
memo[(i,j,L,R)]=ans
return ans
res=dp(1,N-2,1,1)
print(res+A[0]+A[-1])
```
|
output
| 1
| 103,482
| 16
| 206,965
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
Submitted Solution:
```
#YouTube
import sys
sys.setrecursionlimit(10**6)
def kukan(l,r,el=1,er=1):
em=el+er
if l+1==r:
return 0
if l+2==r:
return a[l+1]*em
t=(l,r,el,er)
if t in memo:
return memo[t]
re=10**11
for m in range(l+1,r):
tmp=kukan(l,m,el,em)+kukan(m,r,em,er)+a[m]*em
if tmp<re:
re=tmp
memo[t]=re
return re
n=int(input())
a=list(map(int,input().split()))
memo={}
print(a[0]+kukan(0,n-1)+a[-1])
```
|
instruction
| 0
| 103,483
| 16
| 206,966
|
Yes
|
output
| 1
| 103,483
| 16
| 206,967
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
AtCoder A
"""
import sys, math, random
import numpy as np
# N = int(input())
# A = list(map(int,input().split())) # N row 1 column
# A = [int(input()) for _ in range(N)] # 1 row N column
# S = str(input()) # str(input()) == input() -> 'abc'
# S = list(input()) # abc -> ['a','b','c']
# S.replace('ABC','X') # "testABCABC" -> "testXX"
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
# def main():
# N=I()
# A= list(map(int,input().split()))
# A=np.asarray(A)
# while len(A)>2:
# print(A)
# i=np.argmin(A[1:len(A)-1])
# i=i+1
# print(i)
# A[i-1]+=A[i]
# A[i+1]+=A[i]
# A=np.delete(A,i)
# print(A[0]+A[1])
# print(A,B)
def main():
N=I()
a= list(map(int,input().split()))
A=np.asarray(a)
B=np.asarray(a)
while len(A)>2:
# print(A)
b=np.argmin(B[1:len(B)-1])
a=np.argmin(A[1:len(A)-1])
if B[b+1]<A[a+1]:
i=b+1
else:
i=a+1
# i=i+1
# print(i)
A[i-1]+=A[i]
A[i+1]+=A[i]
A=np.delete(A,i)
B=np.delete(B,i)
print(A[0]+A[1])
# print(A,B)
if __name__ == "__main__":
main()
```
|
instruction
| 0
| 103,484
| 16
| 206,968
|
No
|
output
| 1
| 103,484
| 16
| 206,969
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
for i in range(n - 2):
k = a.index(min(a[1:len(a) - 1]))
p = a[k]
a[k - 1] += p
a[k + 1] += p
del a[k]
print(sum(a))
```
|
instruction
| 0
| 103,485
| 16
| 206,970
|
No
|
output
| 1
| 103,485
| 16
| 206,971
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
Submitted Solution:
```
import sys
import numpy as np
N = int(input())
A = np.array(list(map(int, input().split())))
NN = N
# N = 2になるまで繰り返す
if N >= 5:
for n in range(N-5):
m = np.min(A[1:NN-1])
sum3i = np.max(A)*3+1
p = np.argmin(A[1:NN-1])
p += 1
dd = min([NN-p+1, p])
for i in range(1,NN-1):
if A[i] == m:
sum3 = A[i-1] + A[i+1]
if sum3 < sum3i:
sum3i = sum3
p = i
elif sum3 == sum3i:
d = min([NN-i-1, i])
if d < dd:
dd = d
p = i
#print(A[1:NN-1])
#p = np.argmin(A[1:NN-1])
#p = int(p+1)
A[p-1] += A[p]
A[p+1] += A[p]
A = np.delete(A,p)
NN -= 1
B = np.zeros(5)
B[0] = A[0] + 3*A[1] + 2*A[2] + 3*A[3] + A[4]
B[1] = A[0] + 4*A[1] + 3*A[2] + 2*A[3] + A[4]
B[2] = A[0] + 2*A[1] + 5*A[2] + 3*A[3] + A[4]
B[3] = A[0] + 3*A[1] + 5*A[2] + 2*A[3] + A[4]
B[4] = A[0] + 2*A[1] + 3*A[2] + 4*A[3] + A[4]
print(int(np.min(B)))
else:
for n in range(N-2):
m = np.min(A[1:NN-1])
sum3i = np.max(A)*3+1
p = np.argmin(A[1:NN-1])
p += 1
dd = min([NN-p+1, p])
for i in range(1,NN-1):
if A[i] == m:
sum3 = A[i-1] + A[i+1]
if sum3 < sum3i:
sum3i = sum3
p = i
elif sum3 == sum3i:
d = min([NN-i-1, i])
if d < dd:
dd = d
p = i
#print(A[1:NN-1])
#p = np.argmin(A[1:NN-1])
#p = int(p+1)
A[p-1] += A[p]
A[p+1] += A[p]
A = np.delete(A,p)
NN -= 1
print(np.sum(A))
```
|
instruction
| 0
| 103,486
| 16
| 206,972
|
No
|
output
| 1
| 103,486
| 16
| 206,973
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a stack of N cards, each of which has a non-negative integer written on it. The integer written on the i-th card from the top is A_i.
Snuke will repeat the following operation until two cards remain:
* Choose three consecutive cards from the stack.
* Eat the middle card of the three.
* For each of the other two cards, replace the integer written on it by the sum of that integer and the integer written on the card eaten.
* Return the two cards to the original position in the stack, without swapping them.
Find the minimum possible sum of the integers written on the last two cards remaining.
Constraints
* 2 \leq N \leq 18
* 0 \leq A_i \leq 10^9 (1\leq i\leq N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible sum of the integers written on the last two cards remaining.
Examples
Input
4
3 1 4 2
Output
16
Input
6
5 2 4 1 6 9
Output
51
Input
10
3 1 4 1 5 9 2 6 5 3
Output
115
Submitted Solution:
```
N = int(input())
A = [int(v) for v in input().split()][::-1]
while len(A) > 2:
ans = [(i, a+c+b+b) for i, (a, b, c) in enumerate(zip(A[:-2], A[1:-1], A[2:]))]
m = ans[0][1]
i = ans[0][0]
for a in ans[1:]:
if a[1] < m:
m = a[1]
i = a[0]
A = A[:i] + [A[i]+A[i+1], A[i+2]+A[i+1]] + A[i+3:]
print(A[0] + A[1])
```
|
instruction
| 0
| 103,487
| 16
| 206,974
|
No
|
output
| 1
| 103,487
| 16
| 206,975
|
Provide a correct Python 3 solution for this coding contest problem.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
|
instruction
| 0
| 104,240
| 16
| 208,480
|
"Correct Solution:
```
U = 2*10**5
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z %= MOD
z *= fact_inv[n-k]
z %= MOD
return z
B, W = map(int, input().split())
p = 0
q = 0
for i in range(1, B+W+1):
ans = 1 - p + q
ans %= MOD
ans *= pow(2, MOD-2, MOD)
ans %= MOD
print(ans)
p += comb(i-1, B-1) * pow(pow(2, i, MOD), MOD-2, MOD) % MOD
p %= MOD
q += comb(i-1, W-1) * pow(pow(2, i, MOD), MOD-2, MOD) % MOD
q %= MOD
```
|
output
| 1
| 104,240
| 16
| 208,481
|
Provide a correct Python 3 solution for this coding contest problem.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
|
instruction
| 0
| 104,241
| 16
| 208,482
|
"Correct Solution:
```
MOD = 10**9+7
MAX = 2*(10**5)+1
fac = [1 for i in range(MAX)]
finv = [1 for i in range(MAX)]
inv = [1 for i in range(MAX)]
b,w = map(int,input().split())
if (b >= w):
flag = 0
else:
flag = 1
b,w = w,b
for i in range(2,MAX):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD - inv[MOD%i]*(MOD // i)%MOD
finv[i]=finv[i-1]*inv[i]%MOD
def com(n,k):
if(n < k): return 0
return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD
def pow(n,k,m):#n^k mod m
ans = 1
while k>0:
if(k & 1):ans = (ans*n) % m
n = (n*n)%m
k >>= 1
return ans
for i in range(w):
print(inv[2])
p1 = 1
p2 = 0
for i in range(1,w+1):
p2 = (p2+ com(w,i)) % MOD
deno = pow(inv[2],w,MOD)
denodeno = pow(2,w,MOD)
for i in range(b-w):
p1 = (p1*2)%MOD
deno = (deno* inv[2]) % MOD
denodeno = (denodeno*2) % MOD
if(flag == 0):print(((p1+p2)*deno)%MOD)
else : print(((denodeno-p1-p2)*deno)%MOD)
p2 = (p2*2-com(w+i,i+1)) % MOD
p1 = (p1+com(w+i,i+1)) % MOD
p2 -= 1
for i in range(b+1,b+w+1):
p1 *= 2
deno = (deno* inv[2]) % MOD
denodeno = (denodeno*2) % MOD
if(flag == 0):print(((p1+p2)*deno)%MOD)
else : print(((denodeno-p1-p2)*deno)%MOD)
p1 = (p1+com(i-1,w-1)) % MOD
p2 = (p2*2-com(i-1,w-1)-com(i-1,i-b)) % MOD
```
|
output
| 1
| 104,241
| 16
| 208,483
|
Provide a correct Python 3 solution for this coding contest problem.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
|
instruction
| 0
| 104,242
| 16
| 208,484
|
"Correct Solution:
```
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**9)
mod=10**9+7
b,w=map(int,input().split())
n=b+w
def power(x,n):
if n==0:
return 1
elif n%2:
return power(x,n//2)**2*x%mod
else:
return power(x,n//2)**2%mod
def modinv(n):
return power(n,mod-2)
factorial=[1]
for i in range(1,n+1):
factorial.append(factorial[i-1]*i%mod)
inverse=[0]*(n+1)
inverse[-1]=modinv(factorial[-1])
for i in range(n)[::-1]:
inverse[i]=inverse[i+1]*(i+1)%mod
def comb(n,r):
if n<r or r<0:
return 0
return factorial[n]*inverse[r]*inverse[n-r]%mod
Pb,Pw=[0]*n,[0]*n
inv2=modinv(2)
P=[1]*(n+1)
for i in range(1,n+1):
P[i]=P[i-1]*inv2%mod
for i in range(1,n):
Pb[i]=(Pb[i-1]+comb(i-1,b-1)*P[i])%mod
Pw[i]=(Pw[i-1]+comb(i-1,w-1)*P[i])%mod
for i in range(n):
print((1-Pb[i]+Pw[i])*inv2%mod)
```
|
output
| 1
| 104,242
| 16
| 208,485
|
Provide a correct Python 3 solution for this coding contest problem.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
|
instruction
| 0
| 104,243
| 16
| 208,486
|
"Correct Solution:
```
from collections import defaultdict
B,W = map(int,input().split())
mod = 10**9+7
fact = [0]*(10**6+1)
fact[0] = 1
for i in range(10**6):
fact[i+1] = fact[i]*(i+1)%mod
def comb_(n,k):
return fact[n]*pow(fact[k],mod-2,mod)*pow(fact[n-k],mod-2,mod)*pow(2,(n+1)*(mod-2),mod)%mod
f_B = defaultdict(lambda:pow(2,mod-2,mod))
f_W = defaultdict(lambda:pow(2,mod-2,mod))
g = defaultdict(lambda:pow(2,W*(mod-2),mod))
for i in range(B,B+W):
f_B[i+1] = f_B[i]-comb_(i-1,B-1)*pow(2,mod-2,mod)
f_B[i+1] %= mod
for i in range(W,B+W):
f_W[i+1] = f_W[i]-comb_(i-1,W-1)*pow(2,mod-2,mod)
f_W[i+1] %= mod
for i in range(W+1,B+W):
g[i+1] = g[i] + comb_(i-1,W-1)
g[i+1] %= mod
for i in range(1,B+W+1):
if i < W+1:
print(f_B[i])
else:
print((f_B[i]+f_W[i]+g[i]-pow(2,mod-2,mod))%mod)
```
|
output
| 1
| 104,243
| 16
| 208,487
|
Provide a correct Python 3 solution for this coding contest problem.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
|
instruction
| 0
| 104,244
| 16
| 208,488
|
"Correct Solution:
```
B,W=map(int,input().split())
N=B+W+2
mod=10**9+7
table=[1]*(N+3)
t=1
for i in range(1,N+3):
t*=i
t%=mod
table[i]=t
rtable=[1]*(N+3)
t=1
for i in range(1,N+3):
t*=pow(i,mod-2,mod)
t%=mod
rtable[i]=t
p=[0]*(B+W+1)
q=[0]*(B+W+1)
t=pow(2,mod-2,mod)
for i in range(W,B+W+1):
if i==W:
p[i]=pow(t,i,mod)
else:
p[i]=(p[i-1]+table[i-1]*rtable[W-1]*rtable[i-W]*pow(t,i,mod))%mod
#(table[i]*rtable[W]*table[i-W]*pow(t,i,mod))%mod
for i in range(B,B+W+1):
if i==B:
q[i]=pow(t,i,mod)
else:
q[i]=(q[i-1]+table[i-1]*rtable[B-1]*rtable[i-B]*pow(t,i,mod))%mod
#print(p,q)
for i in range(B+W):
ans=((1+p[i]-q[i])*pow(2,mod-2,mod))%mod
print(ans)
```
|
output
| 1
| 104,244
| 16
| 208,489
|
Provide a correct Python 3 solution for this coding contest problem.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
|
instruction
| 0
| 104,245
| 16
| 208,490
|
"Correct Solution:
```
b,w=map(int,input().split())
dp=[0]*(b+w)
dp[0]=1/2
mod=pow(10,9)+7
def cmb(n,r,mod):
if (r<0 or r>n):
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
g1=[1,1] # g1[i]=i! % mod :階乗
g2=[1,1] # g2[i]=(i!)^(-1) % mod :階乗の逆元
inverse=[0,1]
for i in range(2,b+w+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
t1,t2=0,0
for i in range(1,1+b+w):
t=pow(2,mod-2,mod)
if i-b>0:
t1*=2
t1%=mod
t1+=cmb(i-2,b-1,mod)
t1%=mod
tmp=t1*pow(2,mod-1-i,mod)
tmp%=mod
t-=tmp
t%=mod
if i-w>0:
t2*=2
t2%=mod
t2+=cmb(i-2,w-1,mod)
t2%=mod
tmp=t2*pow(2,mod-1-i,mod)
tmp%=mod
t+=tmp
t%=mod
print(t)
```
|
output
| 1
| 104,245
| 16
| 208,491
|
Provide a correct Python 3 solution for this coding contest problem.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
|
instruction
| 0
| 104,246
| 16
| 208,492
|
"Correct Solution:
```
b,w = map(int,input().split())
flg = 0
if b>w:
flg = 1
b,w = w,b
elif b == w:
for _ in range(b+w):
print(500000004)
exit()
mod = 10**9+7
rng = 200100
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
def inv(a):
return pow(a,mod-2,mod)
def cmb(n,k):
if n<0 or k<0:
return 0
else:
return fctr[n]*inv(fctr[n-k])*inv(fctr[k])%mod
ans = [500000004]*b
nume = pow(2,b-1,mod)
domi = pow(2,b,mod)
for i in range(b+1,b+w+1):
domi = domi*2%mod
nume = nume*2-cmb(i-2,i-b-1)
if i >= w:
nume += cmb(i-2,i-w-1)
nume %= mod
x = nume*inv(domi)%mod
if flg:
ans.append(mod+1-x)
else:
ans.append(x)
print(*ans,sep="\n")
```
|
output
| 1
| 104,246
| 16
| 208,493
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
Submitted Solution:
```
Q = 10**9+7
def getInv(N):#Qはmod
inv = [0] * (N + 1)
inv[0] = 1
inv[1] = 1
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q%i]) % Q
return inv
B, W = map( int, input().split())
Z = getInv(B+W)
I = [1]*(B+W+1)
for i in range(1,B+W+1):
I[i] = (I[i-1]*Z[i])%Q
F = [1]*(B+W+1)
for i in range(1,B+W+1):
F[i] = F[i-1]*i%Q
w = 0
b = 0
for i in range(1,B+W+1):
if i - 1 < B and i - 1 < W:
print(I[2])
# elif i - 1 == W and i - 1< B:
# w = pow(I[2],i-1,Q)
# print(((1 - w)%Q*I[2]%Q + w)%Q)
elif i - 1 >= W and i - 1< B: #i > B
w += F[i-2]*I[i-1-W]%Q*I[W-1]%Q*pow(I[2],i-1,Q)%Q
w %= Q
print(((1 - w)%Q*I[2]%Q + w)%Q)
# elif i - 1 == B and i - 1 < W:
# b = pow(I[2],i-1,Q)
# print((1-b)%Q*I[2]%Q)
elif i - 1 >= B and i - 1 < W: #i > W
b += F[i-2]*I[i-1-B]%Q*I[B-1]%Q*pow(I[2],i-1,Q)%Q
b %= Q
print((1-b)%Q*I[2]%Q)
# elif i - 1 == B and i - 1 == W:
# w = pow(I[2],i-1,Q)
# b = pow(I[2],i-1,Q)
# print(((1 - w - b)%Q*I[2]%Q + w)%Q)
else:
w += F[i-2]*I[i-1-W]%Q*I[W-1]%Q*pow(I[2],i-1,Q)%Q
w %= Q
b += F[i-2]*I[i-1-B]%Q*I[B-1]%Q*pow(I[2],i-1,Q)%Q
b %= Q
print(((1 - w - b)%Q*I[2]%Q + w)%Q)
```
|
instruction
| 0
| 104,250
| 16
| 208,500
|
Yes
|
output
| 1
| 104,250
| 16
| 208,501
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
Submitted Solution:
```
B, W = list(map(int, input().split()))
MOD = 10**9+7
def MakeCombList(n,r, MOD): #iCrをi=0...nまで
ret = []
for i in range(n):
if i < r:
ret = ret+[0]
elif i == r:
ret = ret+[1]
else:
ret = ret+[ int(ret[-1]*(i)/(i-r)) % MOD]
return ret
combB1 = MakeCombList(B+W, B-1, MOD)
combW1 = MakeCombList(B+W, W-1, MOD)
pow2list = [1]
y_pi = 0 #i回目までにBを食べ尽くした確率piの分子
y_qi = 0 #i回目までにWを食べ尽くした確率qiの分子
for i in range(B+W):
pow2list += [pow2list[-1]*2 %MOD]
y_pi = 0 if i < B else 2*y_pi + combB1[i-1]
y_qi = 0 if i < W else 2*y_qi + combW1[i-1]
xi = pow2list[i+1]
yi = (pow2list[i]-y_pi+y_qi) % MOD
z = yi*pow(xi, MOD-2, MOD) % MOD
#print("{}/{}: {}".format(yi,xi,z))
print(z)
```
|
instruction
| 0
| 104,252
| 16
| 208,504
|
No
|
output
| 1
| 104,252
| 16
| 208,505
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
Submitted Solution:
```
from functools import lru_cache
import sys
sys.setrecursionlimit(2*10**5)
# 入力
B, W = map(int, input().split())
# ModInt定義
MOD = 10**9 + 7
def mod_operator(ope):
def operate(self, other):
return (
ModInt(ope(self.x, other.x)) if isinstance(other, ModInt) else
ModInt(ope(self.x, other))
)
return operate
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
def __repr__(self):
return str(self.x)
__add__ = mod_operator(lambda x, y: x + y)
__radd__ = __add__
__sub__ = mod_operator(lambda x, y: x - y)
__rsub__ = __sub__
__mul__ = mod_operator(lambda x, y: x * y)
__rmul__ = __mul__
__truediv__ = mod_operator(lambda x, y: x * pow(y, MOD - 2, MOD))
__rtruediv__ = __truediv__
__pow__ = mod_operator(lambda x, y: pow(x, y, MOD))
__rpow__ = __pow__
# 最初にm個あったチョコレートについて、i番目までにすべて食べきる確率と確率の計算に必要な二項係数を返す
@lru_cache(maxsize=None)
def p(i, m):
if i < m:
return ModInt(0), ModInt(0)
elif i == m:
return ModInt(1) / ModInt(2**i), ModInt(1)
else:
x, y = p(i - 1, m)
c = y * (i - 1) / (i - m)
return x + c / 2**i, c
# i番目の解は i-1番目までに白チョコレートが枯渇している確率 +
# i-1番目までにどちらのチョコレートも枯渇しない確率 / 2
ans = '\n'.join(
str((1 + p(i - 1, W)[0] - p(i - 1, B)[0]) / 2)
for i in range(1, B + W + 1)
)
# 出力
print(ans)
```
|
instruction
| 0
| 104,254
| 16
| 208,508
|
No
|
output
| 1
| 104,254
| 16
| 208,509
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132
Submitted Solution:
```
B, W = list(map(int, input().split()))
mod = 1000000007
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def power(x, y):
#print(x,y)
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y/2)**2 % mod
else : return power(x, y//2)**2 * x % mod
def div(a, b):
return mul(a, power(b, mod-2))
#from fractions import gcd
#B-1列目
B_1 = [0]*(B) + [1]*(W+1)
for i in range(B, W+B):
#print(i)
B_1[i+1]=(B_1[i]*(i))//(i-B+1)
#print(B_1)
#print(B_1)
#B列目
B_0 = [0]*(B) + [1]*(W+1)
for i in range(B, W+B):
B_0[i+1]=B_0[i]*2 + B_1[i+1]
#print(B_0)
#W-1列目
W_1 = [0]*(W) + [1]*(B+1)
for i in range(W, W+B):
W_1[i+1]=W_1[i]*(i)//(i-W+1)
#print(W_1)
#W列目
W_0 = [0]*(W) + [1]*(B+1)
for i in range(W, W+B):
W_0[i+1]=W_0[i]*2 + W_1[i+1]
#print(W_0)
#分母
log2M = [i for i in range(W+B)]
#print(log2M)
for i in range(B+W):
b = B_0[i]
w = W_0[i]
log2m = log2M[i]
#print(b,w,log2m)
while not b%2 and not w%2 and log2m:
b=b//2
w=w//2
log2m-=1
#print(b,w,log2m)
#print(2**log2m - b + w)
#print(2**(log2m+1))
# (2**(log2m+1) -b + w) /2**(log2m+1) = y/x
# answer = y / x (mod)
p = power(2, (mod-2)*(log2m+1))
a = (mul(power(2,log2m),p) - mul(b,p) + mul(w,p))%mod
print(a)
```
|
instruction
| 0
| 104,255
| 16
| 208,510
|
No
|
output
| 1
| 104,255
| 16
| 208,511
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke lives on an infinite two-dimensional plane. He is going on an N-day trip. At the beginning of Day 1, he is at home. His plan is described in a string S of length N. On Day i(1 ≦ i ≦ N), he will travel a positive distance in the following direction:
* North if the i-th letter of S is `N`
* West if the i-th letter of S is `W`
* South if the i-th letter of S is `S`
* East if the i-th letter of S is `E`
He has not decided each day's travel distance. Determine whether it is possible to set each day's travel distance so that he will be back at home at the end of Day N.
Constraints
* 1 ≦ | S | ≦ 1000
* S consists of the letters `N`, `W`, `S`, `E`.
Input
The input is given from Standard Input in the following format:
S
Output
Print `Yes` if it is possible to set each day's travel distance so that he will be back at home at the end of Day N. Otherwise, print `No`.
Examples
Input
SENW
Output
Yes
Input
NSNNSNSN
Output
Yes
Input
NNEW
Output
No
Input
W
Output
No
|
instruction
| 0
| 104,325
| 16
| 208,650
|
"Correct Solution:
```
from collections import Counter
a=Counter(set(list(input().strip())))
if a["N"]==a["S"] and a["E"]==a["W"]:
print("Yes")
else:
print("No")
```
|
output
| 1
| 104,325
| 16
| 208,651
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke lives on an infinite two-dimensional plane. He is going on an N-day trip. At the beginning of Day 1, he is at home. His plan is described in a string S of length N. On Day i(1 ≦ i ≦ N), he will travel a positive distance in the following direction:
* North if the i-th letter of S is `N`
* West if the i-th letter of S is `W`
* South if the i-th letter of S is `S`
* East if the i-th letter of S is `E`
He has not decided each day's travel distance. Determine whether it is possible to set each day's travel distance so that he will be back at home at the end of Day N.
Constraints
* 1 ≦ | S | ≦ 1000
* S consists of the letters `N`, `W`, `S`, `E`.
Input
The input is given from Standard Input in the following format:
S
Output
Print `Yes` if it is possible to set each day's travel distance so that he will be back at home at the end of Day N. Otherwise, print `No`.
Examples
Input
SENW
Output
Yes
Input
NSNNSNSN
Output
Yes
Input
NNEW
Output
No
Input
W
Output
No
|
instruction
| 0
| 104,326
| 16
| 208,652
|
"Correct Solution:
```
S=input()
D={s:False for s in ["N","W","S","E"]}
for s in S:
D[s]=True
if (D["N"]==D["S"]) and (D["W"]==D["E"]):
print("Yes")
else:
print("No")
```
|
output
| 1
| 104,326
| 16
| 208,653
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke lives on an infinite two-dimensional plane. He is going on an N-day trip. At the beginning of Day 1, he is at home. His plan is described in a string S of length N. On Day i(1 ≦ i ≦ N), he will travel a positive distance in the following direction:
* North if the i-th letter of S is `N`
* West if the i-th letter of S is `W`
* South if the i-th letter of S is `S`
* East if the i-th letter of S is `E`
He has not decided each day's travel distance. Determine whether it is possible to set each day's travel distance so that he will be back at home at the end of Day N.
Constraints
* 1 ≦ | S | ≦ 1000
* S consists of the letters `N`, `W`, `S`, `E`.
Input
The input is given from Standard Input in the following format:
S
Output
Print `Yes` if it is possible to set each day's travel distance so that he will be back at home at the end of Day N. Otherwise, print `No`.
Examples
Input
SENW
Output
Yes
Input
NSNNSNSN
Output
Yes
Input
NNEW
Output
No
Input
W
Output
No
|
instruction
| 0
| 104,327
| 16
| 208,654
|
"Correct Solution:
```
S = input()
Ns = bool(S.count('N'))
Ss = bool(S.count('S'))
Es = bool(S.count('E'))
Ws = bool(S.count('W'))
if (Ns ^ Ss) or (Es ^ Ws): print('No')
else: print('Yes')
```
|
output
| 1
| 104,327
| 16
| 208,655
|
Provide a correct Python 3 solution for this coding contest problem.
Snuke lives on an infinite two-dimensional plane. He is going on an N-day trip. At the beginning of Day 1, he is at home. His plan is described in a string S of length N. On Day i(1 ≦ i ≦ N), he will travel a positive distance in the following direction:
* North if the i-th letter of S is `N`
* West if the i-th letter of S is `W`
* South if the i-th letter of S is `S`
* East if the i-th letter of S is `E`
He has not decided each day's travel distance. Determine whether it is possible to set each day's travel distance so that he will be back at home at the end of Day N.
Constraints
* 1 ≦ | S | ≦ 1000
* S consists of the letters `N`, `W`, `S`, `E`.
Input
The input is given from Standard Input in the following format:
S
Output
Print `Yes` if it is possible to set each day's travel distance so that he will be back at home at the end of Day N. Otherwise, print `No`.
Examples
Input
SENW
Output
Yes
Input
NSNNSNSN
Output
Yes
Input
NNEW
Output
No
Input
W
Output
No
|
instruction
| 0
| 104,328
| 16
| 208,656
|
"Correct Solution:
```
S = input()
ans = True
if ('S' in S) ^ ('N' in S):
ans = False
if ('W' in S) ^ ('E' in S):
ans = False
if ans:
print('Yes')
else:
print('No')
```
|
output
| 1
| 104,328
| 16
| 208,657
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.