text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices. The vertices are numbered 0 through N - 1, and the i-th edge (0 ≤ i < N - 1) comnnects Vertex a_i and b_i. For each pair of vertices u and v (0 ≤ u, v < N), we define the distance d(u, v) as the number of edges in the path u-v.
It is expected that one of the vertices will be invaded by aliens from outer space. Snuke wants to immediately identify that vertex when the invasion happens. To do so, he has decided to install an antenna on some vertices.
First, he decides the number of antennas, K (1 ≤ K ≤ N). Then, he chooses K different vertices, x_0, x_1, ..., x_{K - 1}, on which he installs Antenna 0, 1, ..., K - 1, respectively. If Vertex v is invaded by aliens, Antenna k (0 ≤ k < K) will output the distance d(x_k, v). Based on these K outputs, Snuke will identify the vertex that is invaded. Thus, in order to identify the invaded vertex no matter which one is invaded, the following condition must hold:
* For each vertex u (0 ≤ u < N), consider the vector (d(x_0, u), ..., d(x_{K - 1}, u)). These N vectors are distinct.
Find the minumum value of K, the number of antennas, when the condition is satisfied.
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ a_i, b_i < N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_0 b_0
a_1 b_1
:
a_{N - 2} b_{N - 2}
Output
Print the minumum value of K, the number of antennas, when the condition is satisfied.
Examples
Input
5
0 1
0 2
0 3
3 4
Output
2
Input
2
0 1
Output
1
Input
10
2 8
6 0
4 1
7 6
2 3
8 6
6 9
2 4
5 8
Output
3
Submitted Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(input())
graph = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
s = -1
for n in range(N):
if len(graph[n]) > 1:
s = n
break
checked = [False]*N
def dfs(p, ans):
checked[p] = True
s = 0
t = 0
for np in graph[p]:
if not checked[np]:
exists, ans = dfs(np, ans)
t += 1
if exists:
s += 1
if t <= 1: return (s>0), ans
if s == t: return True, ans
ans += (t-s)-1
return True, ans
def dfs2(s):
ans = 0
S = [0]*N
T = [0]*N
stack = [s]
while stack:
p = stack[-1]
checked[p] = True
for np in graph[p]:
if not checked[np]:
stack.append(np)
break
if stack[-1] != p:
continue
ans += max(T[p] - S[p] - 1, 0)
stack.pop()
if stack:
par = stack[-1]
T[par] += 1
if S[p] > 0 or T[p] > 1:
S[par] += 1
return ans
if s == -1:
ans = 1
else:
#_, ans = dfs(s, 0)
ans = dfs2(s)
print(ans)
```
No
| 101,900 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices. The vertices are numbered 0 through N - 1, and the i-th edge (0 ≤ i < N - 1) comnnects Vertex a_i and b_i. For each pair of vertices u and v (0 ≤ u, v < N), we define the distance d(u, v) as the number of edges in the path u-v.
It is expected that one of the vertices will be invaded by aliens from outer space. Snuke wants to immediately identify that vertex when the invasion happens. To do so, he has decided to install an antenna on some vertices.
First, he decides the number of antennas, K (1 ≤ K ≤ N). Then, he chooses K different vertices, x_0, x_1, ..., x_{K - 1}, on which he installs Antenna 0, 1, ..., K - 1, respectively. If Vertex v is invaded by aliens, Antenna k (0 ≤ k < K) will output the distance d(x_k, v). Based on these K outputs, Snuke will identify the vertex that is invaded. Thus, in order to identify the invaded vertex no matter which one is invaded, the following condition must hold:
* For each vertex u (0 ≤ u < N), consider the vector (d(x_0, u), ..., d(x_{K - 1}, u)). These N vectors are distinct.
Find the minumum value of K, the number of antennas, when the condition is satisfied.
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ a_i, b_i < N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_0 b_0
a_1 b_1
:
a_{N - 2} b_{N - 2}
Output
Print the minumum value of K, the number of antennas, when the condition is satisfied.
Examples
Input
5
0 1
0 2
0 3
3 4
Output
2
Input
2
0 1
Output
1
Input
10
2 8
6 0
4 1
7 6
2 3
8 6
6 9
2 4
5 8
Output
3
Submitted Solution:
```
import sys
readline = sys.stdin.readline
from collections import Counter
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
Edge = [[] for _ in range(N)]
Leaf = [0]*N
for _ in range(N-1):
a, b = map(int, readline().split())
Leaf[a] += 1
Leaf[b] += 1
Edge[a].append(b)
Edge[b].append(a)
root = Leaf.index(1)
P, L = parorder(Edge, root)
C = getcld(P)
dp = [0]*N
countone = [0]*N
for l in L[::-1][:-1]:
p = P[l]
dp[l] += 1 + max(0, countone[l] - 1)
if dp[l] == 1:
countone[p] += 1
dp[p] += dp[l] - 1
dp[root] += 1 + max(0, countone[0] - 1)
print(dp[0])
```
No
| 101,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices. The vertices are numbered 0 through N - 1, and the i-th edge (0 ≤ i < N - 1) comnnects Vertex a_i and b_i. For each pair of vertices u and v (0 ≤ u, v < N), we define the distance d(u, v) as the number of edges in the path u-v.
It is expected that one of the vertices will be invaded by aliens from outer space. Snuke wants to immediately identify that vertex when the invasion happens. To do so, he has decided to install an antenna on some vertices.
First, he decides the number of antennas, K (1 ≤ K ≤ N). Then, he chooses K different vertices, x_0, x_1, ..., x_{K - 1}, on which he installs Antenna 0, 1, ..., K - 1, respectively. If Vertex v is invaded by aliens, Antenna k (0 ≤ k < K) will output the distance d(x_k, v). Based on these K outputs, Snuke will identify the vertex that is invaded. Thus, in order to identify the invaded vertex no matter which one is invaded, the following condition must hold:
* For each vertex u (0 ≤ u < N), consider the vector (d(x_0, u), ..., d(x_{K - 1}, u)). These N vectors are distinct.
Find the minumum value of K, the number of antennas, when the condition is satisfied.
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ a_i, b_i < N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_0 b_0
a_1 b_1
:
a_{N - 2} b_{N - 2}
Output
Print the minumum value of K, the number of antennas, when the condition is satisfied.
Examples
Input
5
0 1
0 2
0 3
3 4
Output
2
Input
2
0 1
Output
1
Input
10
2 8
6 0
4 1
7 6
2 3
8 6
6 9
2 4
5 8
Output
3
Submitted Solution:
```
"""
Writer: SPD_9X2
https://atcoder.jp/contests/apc001/tasks/apc001_e
厳密な照明は難しいが…
直径を取る
直径の端点からbfs
全ての頂点に関して、部分木に少なくとも一つのアンテナを持つかのフラグを管理
子の数をkとする。その内x個がtrueの場合、k-1-x個のアンテナを追加。自分のflagをtrueにする
子がfalseで、子が0 or 1つしかない場合のみfalse継続
簡単な木では最適になることを実験したがどうだろうか…？
"""
from collections import deque
def NC_Dij(lis,start):
ret = [float("inf")] * len(lis)
ret[start] = 0
q = deque([start])
plis = [i for i in range(len(lis))]
while len(q) > 0:
now = q.popleft()
for nex in lis[now]:
if ret[nex] > ret[now] + 1:
ret[nex] = ret[now] + 1
plis[nex] = now
q.append(nex)
return ret,plis,now
N = int(input())
lis = [ [] for i in range(N) ]
for i in range(N-1):
a,b = map(int,input().split())
lis[a].append(b)
lis[b].append(a)
td,tp,stp = NC_Dij(lis,0)
ans = 0
def dfs(v,p):
x = 0
c = 0
retflag = False
for nex in lis[v]:
if nex != p:
c += 1
have = dfs(nex,v)
retflag = have or retflag
if have:
x += 1
if c-1-x > 0:
retflag = True
global ans
ans += max(0,c-1-x)
return retflag
dfs(stp,stp)
print (ans+1)
```
No
| 101,902 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices. The vertices are numbered 0 through N - 1, and the i-th edge (0 ≤ i < N - 1) comnnects Vertex a_i and b_i. For each pair of vertices u and v (0 ≤ u, v < N), we define the distance d(u, v) as the number of edges in the path u-v.
It is expected that one of the vertices will be invaded by aliens from outer space. Snuke wants to immediately identify that vertex when the invasion happens. To do so, he has decided to install an antenna on some vertices.
First, he decides the number of antennas, K (1 ≤ K ≤ N). Then, he chooses K different vertices, x_0, x_1, ..., x_{K - 1}, on which he installs Antenna 0, 1, ..., K - 1, respectively. If Vertex v is invaded by aliens, Antenna k (0 ≤ k < K) will output the distance d(x_k, v). Based on these K outputs, Snuke will identify the vertex that is invaded. Thus, in order to identify the invaded vertex no matter which one is invaded, the following condition must hold:
* For each vertex u (0 ≤ u < N), consider the vector (d(x_0, u), ..., d(x_{K - 1}, u)). These N vectors are distinct.
Find the minumum value of K, the number of antennas, when the condition is satisfied.
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ a_i, b_i < N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_0 b_0
a_1 b_1
:
a_{N - 2} b_{N - 2}
Output
Print the minumum value of K, the number of antennas, when the condition is satisfied.
Examples
Input
5
0 1
0 2
0 3
3 4
Output
2
Input
2
0 1
Output
1
Input
10
2 8
6 0
4 1
7 6
2 3
8 6
6 9
2 4
5 8
Output
3
Submitted Solution:
```
def dps(v, p, links):
lv = links[v]
if not lv:
return 0
cnt0 = 0
ret = 0
for l in lv:
if l == p:
continue
res = dps(l, v, links)
ret += res
if res == 0:
cnt0 += 1
if cnt0:
ret += cnt0 - 1
return ret
def solve(n, links):
if n == 2:
return 1
for i, l in enumerate(links):
if len(l) > 1:
return dps(i, None, links)
n = int(input())
links = [set() for _ in range(n)]
for _ in range(n - 1):
a, b = map(int, input().split())
links[a].add(b)
links[b].add(a)
print(solve(n, links))
```
No
| 101,903 |
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
"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)
```
| 101,904 |
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
"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)
```
| 101,905 |
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
"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)
```
| 101,906 |
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
"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))
```
| 101,907 |
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
"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)
```
| 101,908 |
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
"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)
```
| 101,909 |
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
"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])
```
| 101,910 |
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
"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)
```
| 101,911 |
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))
```
Yes
| 101,912 |
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])
```
Yes
| 101,913 |
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])
```
Yes
| 101,914 |
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)
```
Yes
| 101,915 |
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)
```
No
| 101,916 |
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))
```
No
| 101,917 |
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))
```
No
| 101,918 |
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)
```
No
| 101,919 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
I=input
for i,j in zip(I(),I()+" "):print(i+j,end="")
```
| 101,920 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
O = input()
E = input() + ' '
print(''.join(a + b for a, b in zip(O, E)))
```
| 101,921 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
print(''.join(map(''.join,zip(*open(0)))))
```
| 101,922 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
O = input()
E = input()
s = ''
for a in zip(O,E):s += a[0]+a[1]
if len(O) != len(E):s += O[-1]
print(s)
```
| 101,923 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
o = input()
e = input()
z =''
for i in range(len(e)):
z+=o[i]+e[i]
if len(o) > len(e):
z += o[-1]
print(z)
```
| 101,924 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
A=list(input())
B=list(input())
L=["0"]*(len(A)+len(B))
L[::2]=A
L[1::2]=B
print("".join(L))
```
| 101,925 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
*O,=open(0);print("".join(o+e for o,e in zip(*O)))
```
| 101,926 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
"Correct Solution:
```
O=input();E=input()+' ';print(*[a+b for a,b in zip(O,E)],sep='')
```
| 101,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
o=input()
e=input()
print(''.join(x+y for x,y in zip(list(o),list(e)))+('' if len(o)==len(e) else o[-1]))
```
Yes
| 101,928 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
O = input()
E = input() + " "
for i in range(len(O)): print(O[i]+E[i],end="",sep="")
```
Yes
| 101,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
s=input()
t=input()
ans=""
for i in range(len(t)):
ans+=s[i]+t[i]
if len(s)-len(t):ans+=s[-1]
print(ans)
```
Yes
| 101,930 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
O = list(input())
E = list(input())
for i in range(len(E)):
O.insert(2 * i + 1, E[i])
print("".join(O))
```
Yes
| 101,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
# -*- coding: utf-8 -*-
o = list(input()[::2])
e = list(input()[1::2])
ans = []
while len(o) and len(e):
if len(o):
ans.append(o[0])
del o[0]
if len(e):
ans.append(e[0])
del e[0]
print(''.join(ans))
```
No
| 101,932 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
O = input()
E = input()
a = ''
for i in O:
a += i
for j in E:
a += j
E = E.lstrip(j)
break
print(a)
```
No
| 101,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
o=list(input())
e=list(input())
for x,y in zip(x,y):print(x,y,end="")
```
No
| 101,934 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.
You are given two strings O and E. O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.
Constraints
* O and E consists of lowercase English letters (`a` - `z`).
* 1 \leq |O|,|E| \leq 50
* |O| - |E| is either 0 or 1.
Input
Input is given from Standard Input in the following format:
O
E
Output
Print the original password.
Examples
Input
xyz
abc
Output
xaybzc
Input
atcoderbeginnercontest
atcoderregularcontest
Output
aattccooddeerrbreeggiunlnaerrccoonntteesstt
Submitted Solution:
```
O = input()
E = input()
S = ""
for i,j in zip(O,E):
S += i + j
print(S)
```
No
| 101,935 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
from collections import Counter
X,M = map(int, input().split())
A = list(map(int, input().split()))
C = Counter(A)
P = [0] * M # mod iの数
Q = [0] * M # mod iの同一数字のペアの数
for k,v in C.items():
P[k % M] += v
Q[k % M] += v//2
#print(P)
#print(Q)
ans = 0
for i in range(1,(M+1)//2):
p1, p2 = P[i], P[M-i]
q1, q2 = Q[i], Q[M-i]
if p1 > p2:
p1,p2 = p2,p1
q1,q2 = q2,q1
#print(ans, p1,p2,q1,q2)
ans += p1
ans += min((p2-p1)//2, q2)
ans += P[0] // 2
if M%2 == 0:
ans += P[M//2] // 2
print(ans)
```
| 101,936 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(input())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
N,M = inpl()
xx = inpl()
nums = [0]*M
Pairs = [0]*M
ed = defaultdict(int)
for x in xx:
nums[x%M] += 1
if ed[x] == 0:
ed[x] = 1
else:
Pairs[x%M]+=1
ed[x] = 0
ans = 0
ans += nums[0]//2
if M%2 == 0:
ans += nums[M//2]//2
for i in range(1,M//2):
a = nums[i]
b = nums[M-i]
if a < b:
ans += a + min((b-a)//2,Pairs[M-i])
else:#b < a:
ans += b + min((a-b)//2,Pairs[i])
else:
for i in range(1,M//2+1):
a = nums[i]
b = nums[M-i]
if a < b:
ans += a + min((b-a)//2,Pairs[M-i])
else:#b < a:
ans += b + min((a-b)//2,Pairs[i])
print(ans)
```
| 101,937 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
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 pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n,m = LI()
xc = collections.Counter(LI())
c = collections.defaultdict(int)
d = collections.defaultdict(int)
for x,v in xc.items():
if v % 2 == 1:
c[x % m] += 1
d[x % m] += v
r = d[0] // 2
if m % 2 == 0:
r += d[m // 2] // 2
for i in range(1, (m+1)//2):
t = min(d[i], d[m-i])
r += t
r += (d[i] - max(c[i], t)) // 2
r += (d[m-i] - max(c[m-i], t)) // 2
return r
print(main())
```
| 101,938 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
import collections
n,m=map(int,input().split())
arr=list(map(int,input().split()))
cnt=collections.Counter(arr)
cnt1=collections.defaultdict(int)
cnt2=collections.defaultdict(int)
for key in cnt.keys():
tmp=key%m
val=cnt[key]
if val%2==0:
cnt2[tmp]+=val
else:
cnt1[tmp]+=1
cnt2[tmp]+=val-1
ans=0
for i in range(m):
l=i
r=(m-i)%m
if l>r:
break
elif l==r:
ans+=(cnt1[l]+cnt2[l])//2
else:
ans+=min(cnt1[l],cnt1[r])
if cnt1[l]==cnt1[r]:
ans+=(cnt2[l]+cnt2[r])//2
elif cnt1[l]<cnt1[r]:
cnt1[r]-=cnt1[l]
ans+=min(cnt2[l],cnt1[r])
cnt2[l]=max(0,cnt2[l]-cnt1[r])
ans+=(cnt2[l]+cnt2[r])//2
else:
cnt1[l]-=cnt1[r]
ans+=min(cnt1[l],cnt2[r])
cnt2[r]=max(0,cnt2[r]-cnt1[l])
ans+=(cnt2[l]+cnt2[r])//2
print(ans)
```
| 101,939 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
import math
N, M = map(int, input().split())
X = list(map(int, input().split()))
mod_arr = [{} for i in range(M)]
for x in X:
d = mod_arr[x % M]
if x in d:
d[x] += 1
else:
d[x] = 1
ans = 0
if M == 1:
print(N // 2)
exit()
def calc_only_one(d):
sum_v = sum(d.values())
return sum_v // 2
ans += calc_only_one(mod_arr[0])
# even pattern
if M % 2 == 0:
ans += calc_only_one(mod_arr[M // 2])
def calc_two(d_S, d_T):
res = 0
# print(d1, d2)
"""
if len(d_S) == 0:
for v in d_S.values():
res += v // 2
return res
elif len(d_T) == 0:
for v in d_T.values():
res += v // 2
return res
"""
if sum(d_S.values()) < sum(d_T.values()):
d_S, d_T = d_T, d_S
cnt_S = sum(d_S.values())
cnt_T = sum(d_T.values())
remain_for_pair = cnt_S - cnt_T
max_pair_cnt = sum([v // 2 for v in d_S.values()])
pair_cnt = min(remain_for_pair // 2 , max_pair_cnt)
res = cnt_T + pair_cnt
# print(d_S, d_T)
# print(remain_for_pair, max_pair_cnt, pair_cnt, res)
return res
for i in range(1, math.ceil(M / 2)):
ans += calc_two(mod_arr[i], mod_arr[M - i])
print(ans)
```
| 101,940 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
from collections import Counter
N, M = map(int, input().split())
X = list(map(int, input().split()))
S = [0] * M
MM = [0] * M
for x, n in Counter(X).items():
MM[x%M] += n//2
S[x%M] += n
ans = 0
ans += S[0] // 2
if M%2 == 0:
ans += S[M//2] // 2
for i1 in range(1, 1000000):
i2 = M-i1
if i1 >= i2:
break
s1, s2 = S[i1], S[i2]
if s1 < s2:
ans += s1 + min((s2-s1)//2, MM[i2])
else:
ans += s2 + min((s1-s2)//2, MM[i1])
print(ans)
```
| 101,941 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
import math
N, M = map(int, input().split())
X = list(map(int, input().split()))
mod_arr = [{} for i in range(M)]
for x in X:
d = mod_arr[x % M]
if x in d:
d[x] += 1
else:
d[x] = 1
ans = 0
if M == 1:
print(N // 2)
exit()
def calc_only_one(d):
sum_v = sum(d.values())
return sum_v // 2
ans += calc_only_one(mod_arr[0])
# even pattern
if M % 2 == 0:
ans += calc_only_one(mod_arr[M // 2])
def calc_two(d_S, d_T):
res = 0
if len(d_S) == 0:
for v in d_T.values():
res += v // 2
return res
elif len(d_T) == 0:
for v in d_S.values():
res += v // 2
return res
if sum(d_S.values()) < sum(d_T.values()):
d_S, d_T = d_T, d_S
cnt_S = sum(d_S.values())
cnt_T = sum(d_T.values())
remain_for_pair = cnt_S - cnt_T
max_pair_cnt = sum([v // 2 for v in d_S.values()])
pair_cnt = min(remain_for_pair // 2 , max_pair_cnt)
res = cnt_T + pair_cnt
# print(d_S, d_T)
# print(remain_for_pair, max_pair_cnt, pair_cnt, res)
return res
for i in range(1, math.ceil(M / 2)):
ans += calc_two(mod_arr[i], mod_arr[M - i])
print(ans)
```
| 101,942 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
"Correct Solution:
```
from collections import Counter
n, m = map(int,input().split())
x = list(map(int,input().split()))
data = [[] for i in range(m)]
def mod(x):
return x%m - 1
def insert(x):
y = mod(x)
data[y].append(x)
for i in x:
insert(i)
ans = len(data[m-1])//2
#print(data)
for i in range(m//2):
p = len(data[i])
q = len(data[m-i-2])
if p == q:
if i != m-i-2:
ans += p
else:
ans += p//2
elif p > q:
ans += q
r = (p-q)//2
same = 0
set_i = Counter(data[i])
for keys in set_i:
same +=set_i[keys]//2
#print(set_i)
ans += min(r,same)
else:
ans += p
r = (q-p)//2
set_j = Counter(data[m-i-2])
same = 0
for keys in set_j:
same += set_j[keys] // 2
#print(set_j)
ans += min(r,same)
print(ans)
```
| 101,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
Submitted Solution:
```
from collections import Counter
N, M = map(int, input().split())
Xs = list(map(int, input().split()))
cnt = Counter(Xs)
nums = [0] * M
numSames = [0] * M
for key, num in cnt.items():
k = key%M
nums[k] += num
numSames[k] += num//2
ans = 0
for k in range(M//2+1):
k2 = M-k
if k == 0 or k == k2:
numPair = nums[k]//2
ans += numPair
nums[k] -= numPair*2
else:
numPair = min(nums[k], nums[k2])
ans += numPair
nums[k] -= numPair
nums[k2] -= numPair
for k in range(M):
ans += min(numSames[k], nums[k]//2)
print(ans)
```
Yes
| 101,944 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
Submitted Solution:
```
from collections import Counter
N,M = map(int,input().split())
src = list(map(int,input().split()))
if M == 1:
print(N // 2)
exit()
hist = [0] * M
ctrs = [Counter() for i in range(M)]
for a in src:
hist[a%M] += 1
ctrs[a%M].update([a])
ans = 0
for i in range(1, (M+1)//2):
j = M - i
if hist[j] < hist[i]: i,j = j,i
ans += hist[i]
rem = (hist[j] - hist[i]) // 2
n = sum([v//2 for v in ctrs[j].values()])
ans += min(rem, n)
ans += sum(ctrs[0].values()) // 2
if M%2 == 0:
ans += sum(ctrs[M//2].values()) // 2
print(ans)
```
Yes
| 101,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
Submitted Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,M = map(int,input().split())
X = [int(x) for x in input().split()]
counter = [0] * M
pair_counter = [0] * M
se = set()
for x in X:
r = x%M
counter[r] += 1
if x in se:
pair_counter[r] += 1
se.remove(x)
else:
se.add(x)
answer = 0
for r in range(1,(M+1)//2):
s = M - r
cr,cs = counter[r], counter[s]
pr,ps = pair_counter[r], pair_counter[s]
if cr < cs:
cr,cs = cs,cr
pr,ps = ps,pr
x = cs + min(pr,(cr-cs)//2)
answer += x
# 0とM//2
rs = [0] if M&1 else [0,M//2]
answer += sum(counter[r]//2 for r in rs)
print(answer)
```
Yes
| 101,946 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**10
mod = 10**9 + 7
def f():
n,m = list(map(int, input().split()))
b = [[] for _ in range(m)]
for c in map(int, input().split()):
b[c%m].append(c)
t = 0
for i in range(m//2):
if i+1 > m-i-1:
break
if i+1 == m-i-1:
l = len(b[i+1])
t += l//2
break
l = len(b[i+1])
r = len(b[m-i-1])
if l > r:
t += r
bt = b[i+1]
sa = l-r
else:
t += l
bt = b[m-i-1]
sa = r-l
bt.sort()
lt = 0
i = 0
sa = sa // 2
while i < l-1 and lt < sa:
if bt[i] == bt[i+1]:
lt += 1
i += 2
else:
i += 1
t += lt
l = len(b[0])
t += l//2
return t
print(f())
```
No
| 101,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**10
mod = 10**9 + 7
def f():
n,m = list(map(int, input().split()))
b = [[] for _ in range(m)]
for c in map(int, input().split()):
b[c%m].append(c)
t = 0
for i in range(m):
if i+1 > m-i-1:
break
if i+1 == m-i-1:
l = len(b[i+1])
t += l//2
break
l = len(b[i+1])
r = len(b[m-i-1])
if l > r:
t += r
bt = b[i+1]
sa = l-r
else:
t += l
bt = b[m-i-1]
sa = r-l
bt.sort()
lt = 0
i = 0
sa = sa // 2
while i < l-1 and lt < sa:
if bt[i] == bt[i+1]:
lt += 1
i += 2
else:
i += 1
t += lt
l = len(b[0])
t += l//2
return t
print(f())
```
No
| 101,948 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**10
mod = 10**9 + 7
def f():
n,m = list(map(int, input().split()))
b = [[] for _ in range(m)]
for c in map(int, input().split()):
b[c%m].append(c)
t = 0
for i in range(m//2):
if i+1 == m-i-1:
l = len(b[i+1])
t += l//2
break
l = len(b[i+1])
r = len(b[m-i-1])
if l > r:
t += r
bt = b[i+1]
bt.sort()
sa = l-r
lt = 0
i = 0
while i < l-1 and lt < sa:
if bt[i] == bt[i+1]:
lt += 1
i += 2
else:
i += 1
t += lt
else:
t += l
bt = b[m-i-1]
bt.sort()
sa = r-l
lt = 0
i = 0
while i < r-1 and lt < sa:
if bt[i] == bt[i+1]:
lt += 1
i += 2
else:
i += 1
t += lt
l = len(b[0])
t += l//2
return t
print(f())
```
No
| 101,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is playing with N cards.
The i-th card has an integer X_i on it.
Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:
* The integers on the two cards are the same.
* The sum of the integers on the two cards is a multiple of M.
Find the maximum number of pairs that can be created.
Note that a card cannot be used in more than one pair.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
Output
Print the maximum number of pairs that can be created.
Examples
Input
7 5
3 1 4 1 5 9 2
Output
3
Input
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
Output
6
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**10
mod = 10**9 + 7
def f():
n,m = list(map(int, input().split()))
b = [[] for _ in range(m)]
for c in map(int, input().split()):
b[c%m].append(c)
t = 0
for i in range(1,m):
if i > m-i:
break
if i == m-i:
l = len(b[i])
t += l//2
break
l = len(b[i])
r = len(b[m-i])
if l > r:
t += r
bt = b[i]
sa = l-r
else:
t += l
bt = b[m-i]
sa = r-l
bt.sort()
lt = 0
j = 0
sa = sa // 2
while j < l-1 and lt < sa:
if bt[j] == bt[j+1]:
lt += 1
j += 2
else:
k += 1
t += lt
l = len(b[0])
t += l//2
return t
print(f())
```
No
| 101,950 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
import sys
import math
n = int(input())
for _ in range(n):
xa, ya, ra, xb, yb, rb = map(float, input().split())
distance = math.sqrt((xa-xb)**2 + (ya-yb)**2)
if ra + rb >= distance:
if (distance + ra < rb):
print(-2)
elif (distance + rb < ra):
print(2)
else:
print(1)
else:
print(0)
```
| 101,951 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
for _ in range(int(input())):
x1, y1, r1, x2, y2, r2 = [float(x) for x in input().split()]
distance = ((x1 - x2)**2 + (y1 - y2)**2)**0.5
if distance > r1 + r2:
print(0)
else:
if r1 > r2 and distance + r2 < r1:
print(2)
elif r1 < r2 and distance + r1 < r2:
print(-2)
else:
print(1)
```
| 101,952 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
N=int(input())
for i in range(N):
x1,y1,r1,x2,y2,r2=map(float,input().split())
d=((x1-x2)**2+(y1-y2)**2)**0.5
if r1-r2>d:
if r1==r2+d:
print("1")
else:
print("2")
elif r2-r1>d:
if r2==r1+d:
print("1")
else:
print("-2")
elif d<r1+r2:
print("1")
elif r1+r2==d:
print("1")
elif d>r1+r2:
print("0")
```
| 101,953 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
import math
def aux(v):
[xa,ya,ra,xb,yb,rb] = v
ab = math.sqrt((xb-xa)**2 + (yb-ya)**2)
if ab > ra + rb:
rst = 0
elif ab + rb < ra:
rst = 2
elif ab + ra < rb:
rst = -2
else:
rst = 1
return(rst)
if __name__ == "__main__":
n = int(input())
for i in range(n):
v = list(map(float, input().split()))
print(aux(v))
```
| 101,954 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
from math import sqrt
n = int(input())
while n:
xa, ya, ra, xb, yb, rb = map(float, input().split())
d = sqrt((xb - xa) ** 2 + (yb - ya) ** 2)
if ra > d + rb:
print(2)
elif rb > d + ra:
print(-2)
elif d > ra + rb:
print(0)
else:
print(1)
n -= 1
```
| 101,955 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
import math
num = int(input())
for i in range(num):
lst = list(map(float, input().split()))
xa, ya, ra = lst[0], lst[1], lst[2]
xb, yb, rb = lst[3], lst[4], lst[5]
d = math.sqrt((xa - xb)**2 + (ya - yb)**2)
if ra + rb < d:
print(0)
elif d + min(ra, rb) < max(ra, rb):
if ra < rb:
print(-2)
else:
print(2)
else:
print(1)
```
| 101,956 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
import math
N = int(input())
for i in range(N):
x1,y1,r1,x2,y2,r2 = map(float,input().split())
d = math.sqrt(pow(x1 - x2,2.0) + pow(y1 - y2,2.0))
if d < abs(r2 - r1):
if r1 > r2:
print(2)
else:
print(-2)
elif d <= r1 + r2:
print(1)
else:
print(0)
```
| 101,957 |
Provide a correct Python 3 solution for this coding contest problem.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
"Correct Solution:
```
import math
N = int(input())
for _ in [0]*N:
x1, y1, r1, x2, y2, r2 = map(float, input().split())
dist = math.hypot(x2-x1, y2-y1)
if dist+r2 < r1:
print(2)
elif dist+r1 < r2:
print(-2)
elif dist <= r1+r2:
print(1)
else:
print(0)
```
| 101,958 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import math
N = int(input())
for i in range(N):
ax, ay, ar, bx, by, br = map(float, input().split())
between_center = math.hypot(ax - bx, ay - by)
# ????????£????????????
if between_center > ar + br:
print(0)
# ????????????????????¨
else:
# B in A
if ar > between_center + br:
print(2)
# A in B
elif br > between_center + ar:
print(-2)
else:
print(1)
```
Yes
| 101,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
n = int(input())
for _ in range(n):
xa, ya, ra, xb, yb, rb = map(float, input().split())
if xa - ra < xb - rb and xa + ra > xb + rb and ya - ra < yb - rb and ya + ra > yb + rb:
print(2)
elif xa - ra > xb - rb and xa + ra < xb + rb and ya - ra > yb - rb and ya + ra < yb + rb:
print(-2)
elif (xa - xb)**2 + (ya - yb)**2 <= (ra + rb)**2:
print(1)
else:
print(0)
```
Yes
| 101,960 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
import math
for i in range(int(input())):
xa, ya, ra, xb, yb, rb = list(map(float, input().split()))
d1 = (xa - xb) ** 2 + (ya - yb) ** 2
d2 = (ra + rb) ** 2
dr = (ra-rb) ** 2
if d1 <= d2:
if dr > d1:
print(2 if ra > rb else -2)
else:
print(1)
else:
print(0)
```
Yes
| 101,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
for _ in range(int(input())):
xa, ya, ra, xb, yb, rb = list(map(float,input().split()))
dAB = ((xa - xb) ** 2 + (ya - yb) ** 2) ** 0.5
if ra + rb < dAB:
print('0')
elif dAB + rb < ra:
print('2')
elif dAB + ra < rb:
print('-2')
else:
print('1')
```
Yes
| 101,962 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
import math
num = int(input())
for i in range(num):
ax,ay,ar,bx,by,br = map(float,input().split(' '))
d = (ax - bx)*(ax - bx) + (ay * by)
if d < abs(br - ar):
if ar > br:
print(2)
else:
print(-2)
elif d <= ar + br:
print(1)
else:
print(0)
```
No
| 101,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
# your code goes here
import math
n = int(input())
for i in range(n):
xa, ya, ra, xb, yb, rb = [float(x) for x in input().split(" ")]
distance = math.sqrt((xb-xa)**2 + (yb-ya)**2)
if distance > ra+rb:
print(0)
elif distance <= abs(ra-rb):
if ra > rb:
print(2)
elif ra < rb:
print(-2)
else:
print(1)
elif distance <= ra+rb:
print(1)
```
No
| 101,964 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
import math
count = int(input())
for i in range(count):
x1,y1,r1,x2,y2,r2 =map(float,input().split())
depth=math.sqrt((x1-x2)**2+(y1-y2)**2)
if depth+r2<=r1:
print(2)
elif depth>r1+r2:
print(0)
else:
print(1)
```
No
| 101,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.
Write a program which prints:
* "2" if $B$ is in $A$,
* "-2" if $A$ is in $B$,
* "1" if circumference of $A$ and $B$ intersect, and
* "0" if $A$ and $B$ do not overlap.
You may assume that $A$ and $B$ are not identical.
Input
The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:
$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$
Output
For each dataset, print 2, -2, 1, or 0 in a line.
Example
Input
2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0
Output
2
0
Submitted Solution:
```
import math
N = int(input())
for _ in [0]*N:
x1, y1, r1, x2, y2, r2 = map(float, input().split())
dist = math.sqrt((x1-x2)**2+(y1-y2)**2)
if dist <= abs(r1-r2):
print(2 if r1 > r2 else -2)
elif dist <= r1+r2:
print(1)
else:
print(0)
```
No
| 101,966 |
Provide a correct Python 3 solution for this coding contest problem.
Let's play the game using a bag containing several cards with integers written on it. In each game, participants first declare one of their favorite number n. Then, take out an appropriate number of cards from the bag at a time, and if the sum of the numbers written on those cards is equal to n, you will receive a luxurious prize. After each game, the cards will be returned to the bag.
Create a program that inputs the information of m types of cards in the bag and the number declared by the participants in g games, and outputs how many combinations of cards can receive luxury products in each game. please.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
m
a1 b1
a2 b2
::
am bm
g
n1
n2
::
ng
The number of card types m (1 ≤ m ≤ 7) on the first line, the integer ai (1 ≤ ai ≤ 100) written on the i-type card on the following m line, and the number bi (1 ≤ bi ≤ 10) Are given with a space delimiter.
The next line is given the number of games g (1 ≤ g ≤ 10), and the next g line is given the integer ni (1 ≤ ni ≤ 1,000) declared in game i.
The number of datasets does not exceed 100.
Output
For each input dataset, the i line prints the number of card combinations that will give you a gorgeous prize in Game i.
Example
Input
5
1 10
5 3
10 3
25 2
50 2
4
120
500
100
168
7
1 10
3 10
5 10
10 10
25 10
50 10
100 10
3
452
574
787
0
Output
16
0
12
7
9789
13658
17466
"Correct Solution:
```
while 1:
n=int(input())
if n==0:break
dp=[1]+[0]*3000
for i in range(n):
a,b=map(int,input().split())
for j in range(1001,-1,-1):
for k in range(1,b+1):
dp[j+a*k]+=dp[j]
for _ in range(int(input())):
print(dp[int(input())])
```
| 101,967 |
Provide a correct Python 3 solution for this coding contest problem.
Let's play the game using a bag containing several cards with integers written on it. In each game, participants first declare one of their favorite number n. Then, take out an appropriate number of cards from the bag at a time, and if the sum of the numbers written on those cards is equal to n, you will receive a luxurious prize. After each game, the cards will be returned to the bag.
Create a program that inputs the information of m types of cards in the bag and the number declared by the participants in g games, and outputs how many combinations of cards can receive luxury products in each game. please.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
m
a1 b1
a2 b2
::
am bm
g
n1
n2
::
ng
The number of card types m (1 ≤ m ≤ 7) on the first line, the integer ai (1 ≤ ai ≤ 100) written on the i-type card on the following m line, and the number bi (1 ≤ bi ≤ 10) Are given with a space delimiter.
The next line is given the number of games g (1 ≤ g ≤ 10), and the next g line is given the integer ni (1 ≤ ni ≤ 1,000) declared in game i.
The number of datasets does not exceed 100.
Output
For each input dataset, the i line prints the number of card combinations that will give you a gorgeous prize in Game i.
Example
Input
5
1 10
5 3
10 3
25 2
50 2
4
120
500
100
168
7
1 10
3 10
5 10
10 10
25 10
50 10
100 10
3
452
574
787
0
Output
16
0
12
7
9789
13658
17466
"Correct Solution:
```
while True:
m = int(input())
if m == 0:
break
nums = []
for _ in range(m):
a, b = map(int, input().split())
lst = [a * i for i in range(b + 1)]
nums.append(lst)
"""
dp[x][y] ... x種類目まででyを作る場合の数
dp[x][y] = sum(dp[x - 1][y - wk] for wk in nums[x])
"""
def solve(n):
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(m + 1):
dp[i][0] = 1
for x in range(1, m + 1):
for y in range(1, n + 1):
dp[x][y] = sum([dp[x - 1][y - v] for v in nums[x - 1] if v <= y])
print(dp[m][n])
g = int(input())
for _ in range(g):
solve(int(input()))
```
| 101,968 |
Provide a correct Python 3 solution for this coding contest problem.
Let's play the game using a bag containing several cards with integers written on it. In each game, participants first declare one of their favorite number n. Then, take out an appropriate number of cards from the bag at a time, and if the sum of the numbers written on those cards is equal to n, you will receive a luxurious prize. After each game, the cards will be returned to the bag.
Create a program that inputs the information of m types of cards in the bag and the number declared by the participants in g games, and outputs how many combinations of cards can receive luxury products in each game. please.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
m
a1 b1
a2 b2
::
am bm
g
n1
n2
::
ng
The number of card types m (1 ≤ m ≤ 7) on the first line, the integer ai (1 ≤ ai ≤ 100) written on the i-type card on the following m line, and the number bi (1 ≤ bi ≤ 10) Are given with a space delimiter.
The next line is given the number of games g (1 ≤ g ≤ 10), and the next g line is given the integer ni (1 ≤ ni ≤ 1,000) declared in game i.
The number of datasets does not exceed 100.
Output
For each input dataset, the i line prints the number of card combinations that will give you a gorgeous prize in Game i.
Example
Input
5
1 10
5 3
10 3
25 2
50 2
4
120
500
100
168
7
1 10
3 10
5 10
10 10
25 10
50 10
100 10
3
452
574
787
0
Output
16
0
12
7
9789
13658
17466
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0154
"""
import sys
from sys import stdin
input = stdin.readline
def solve(m, cards, g, guesses):
ans = []
cards.append([0, 0])
cards.sort()
W = max(guesses) + 1
dp = [0] * W
dp[0] = 1
for i in range(1, m+1):
card_num = cards[i][0]
card_rem = cards[i][1]
for j in range(W-1, 0, -1):
for k in range(1, card_rem+1):
if card_num*k <= j:
dp[j] += dp[j-card_num*k]
for gg in guesses:
ans.append(dp[gg])
return ans
def main(args):
# m = 5
# cards = [[1, 10], [5, 3], [10, 3], [25, 2], [50, 2]]
# g = 4
# guesses = [120, 500, 100, 168]
while True:
m = int(input())
if m == 0:
break
cards = []
for _ in range(m):
a, b = map(int, input().split())
cards.append([a, b])
g = int(input())
guesses = [int(input()) for _ in range(g)]
ans = solve(m, cards, g, guesses)
print(*ans, sep='\n')
if __name__ == '__main__':
main(sys.argv[1:])
```
| 101,969 |
Provide a correct Python 3 solution for this coding contest problem.
Let's play the game using a bag containing several cards with integers written on it. In each game, participants first declare one of their favorite number n. Then, take out an appropriate number of cards from the bag at a time, and if the sum of the numbers written on those cards is equal to n, you will receive a luxurious prize. After each game, the cards will be returned to the bag.
Create a program that inputs the information of m types of cards in the bag and the number declared by the participants in g games, and outputs how many combinations of cards can receive luxury products in each game. please.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
m
a1 b1
a2 b2
::
am bm
g
n1
n2
::
ng
The number of card types m (1 ≤ m ≤ 7) on the first line, the integer ai (1 ≤ ai ≤ 100) written on the i-type card on the following m line, and the number bi (1 ≤ bi ≤ 10) Are given with a space delimiter.
The next line is given the number of games g (1 ≤ g ≤ 10), and the next g line is given the integer ni (1 ≤ ni ≤ 1,000) declared in game i.
The number of datasets does not exceed 100.
Output
For each input dataset, the i line prints the number of card combinations that will give you a gorgeous prize in Game i.
Example
Input
5
1 10
5 3
10 3
25 2
50 2
4
120
500
100
168
7
1 10
3 10
5 10
10 10
25 10
50 10
100 10
3
452
574
787
0
Output
16
0
12
7
9789
13658
17466
"Correct Solution:
```
# AOJ 0154 Sum of Cards
# Python3 2018.6.19 bal4u
MAX = 1001
while True:
m = int(input())
if m == 0: break
ab = [0]
for i in range(m):
ab.append(list(map(int, input().split())))
dp = [[0 for j in range(MAX)] for r in range(8)]
dp[0][0] = 1
for i in range(1, m+1):
for j in range(MAX):
if dp[i-1][j] == 0: continue;
s = j
for k in range(ab[i][1], -1, -1):
if s < MAX: dp[i][s] += dp[i-1][j]
s += ab[i][0]
for i in range(int(input())):
print(dp[m][int(input())])
```
| 101,970 |
Provide a correct Python 3 solution for this coding contest problem.
Let's play the game using a bag containing several cards with integers written on it. In each game, participants first declare one of their favorite number n. Then, take out an appropriate number of cards from the bag at a time, and if the sum of the numbers written on those cards is equal to n, you will receive a luxurious prize. After each game, the cards will be returned to the bag.
Create a program that inputs the information of m types of cards in the bag and the number declared by the participants in g games, and outputs how many combinations of cards can receive luxury products in each game. please.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
m
a1 b1
a2 b2
::
am bm
g
n1
n2
::
ng
The number of card types m (1 ≤ m ≤ 7) on the first line, the integer ai (1 ≤ ai ≤ 100) written on the i-type card on the following m line, and the number bi (1 ≤ bi ≤ 10) Are given with a space delimiter.
The next line is given the number of games g (1 ≤ g ≤ 10), and the next g line is given the integer ni (1 ≤ ni ≤ 1,000) declared in game i.
The number of datasets does not exceed 100.
Output
For each input dataset, the i line prints the number of card combinations that will give you a gorgeous prize in Game i.
Example
Input
5
1 10
5 3
10 3
25 2
50 2
4
120
500
100
168
7
1 10
3 10
5 10
10 10
25 10
50 10
100 10
3
452
574
787
0
Output
16
0
12
7
9789
13658
17466
"Correct Solution:
```
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
while True:
m = int(input())
if m == 0:
break
a = [0 for i in range(7)]
b = [0 for i in range(7)]
for i in range(m):
a[i],b[i] = [int(j) for j in input().split()]
dp = [[0 for i in range(1001)] for j in range(8)]
dp[0][0] = 1
for i in range(7):
for j in range(1001):
for k in range(b[i] + 1):
if j + a[i]*k <= 1000:
dp[i+1][j + a[i]*k] += dp[i][j]
g = int(input())
for i in range(g):
n = int(input())
print(dp[m][n])
```
| 101,971 |
Provide a correct Python 3 solution for this coding contest problem.
Let's play the game using a bag containing several cards with integers written on it. In each game, participants first declare one of their favorite number n. Then, take out an appropriate number of cards from the bag at a time, and if the sum of the numbers written on those cards is equal to n, you will receive a luxurious prize. After each game, the cards will be returned to the bag.
Create a program that inputs the information of m types of cards in the bag and the number declared by the participants in g games, and outputs how many combinations of cards can receive luxury products in each game. please.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
m
a1 b1
a2 b2
::
am bm
g
n1
n2
::
ng
The number of card types m (1 ≤ m ≤ 7) on the first line, the integer ai (1 ≤ ai ≤ 100) written on the i-type card on the following m line, and the number bi (1 ≤ bi ≤ 10) Are given with a space delimiter.
The next line is given the number of games g (1 ≤ g ≤ 10), and the next g line is given the integer ni (1 ≤ ni ≤ 1,000) declared in game i.
The number of datasets does not exceed 100.
Output
For each input dataset, the i line prints the number of card combinations that will give you a gorgeous prize in Game i.
Example
Input
5
1 10
5 3
10 3
25 2
50 2
4
120
500
100
168
7
1 10
3 10
5 10
10 10
25 10
50 10
100 10
3
452
574
787
0
Output
16
0
12
7
9789
13658
17466
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
ans = []
while 1:
M = int(readline())
if M == 0:
break
P = [list(map(int, input().split())) for i in range(M)]
memo = {}
def dfs(i, rest):
if i == M:
return rest == 0
key = (i, rest)
if key in memo:
return memo[key]
res = 0
a, b = P[i]
for j in range(0, b+1):
if rest - j*a < 0:
break
res += dfs(i+1, rest - j*a)
memo[key] = res
return res
G = int(input())
for i in range(G):
ans.append(str(dfs(0, int(input()))))
write("\n".join(ans))
write("\n")
```
| 101,972 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's play the game using a bag containing several cards with integers written on it. In each game, participants first declare one of their favorite number n. Then, take out an appropriate number of cards from the bag at a time, and if the sum of the numbers written on those cards is equal to n, you will receive a luxurious prize. After each game, the cards will be returned to the bag.
Create a program that inputs the information of m types of cards in the bag and the number declared by the participants in g games, and outputs how many combinations of cards can receive luxury products in each game. please.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
m
a1 b1
a2 b2
::
am bm
g
n1
n2
::
ng
The number of card types m (1 ≤ m ≤ 7) on the first line, the integer ai (1 ≤ ai ≤ 100) written on the i-type card on the following m line, and the number bi (1 ≤ bi ≤ 10) Are given with a space delimiter.
The next line is given the number of games g (1 ≤ g ≤ 10), and the next g line is given the integer ni (1 ≤ ni ≤ 1,000) declared in game i.
The number of datasets does not exceed 100.
Output
For each input dataset, the i line prints the number of card combinations that will give you a gorgeous prize in Game i.
Example
Input
5
1 10
5 3
10 3
25 2
50 2
4
120
500
100
168
7
1 10
3 10
5 10
10 10
25 10
50 10
100 10
3
452
574
787
0
Output
16
0
12
7
9789
13658
17466
Submitted Solution:
```
from itertools import combinations as C
while True:
m = int(input())
if m==0:break
card = []
total = 0
for _ in range(m):
a, b = map(int, input().split())
card += [a]*b
total += b
g = int(input())
for _ in range(g):
ans = 0
duplicate = []
n = int(input())
for i in range(1, total+1):
for l in list(C(card, i)):
if sum(l)==n and not l in duplicate:
ans += 1
duplicate.append(l)
print(ans)
```
No
| 101,973 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
h1, h2 = map(int, input().split())
k1, k2 = map(int, input().split())
a, b, c, d = map(int, input().split())
H = h1 * a + h2 * b + h1 // 10 * c + h2 // 20 * d
K = k1 * a + k2 * b + k1 // 10 * c + k2 // 20 * d
print('hiroshi' if H>K else 'even' if H==K else 'kenjiro')
```
| 101,974 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
h1,h2 = [int(i) for i in input().split()]
k1,k2 = [int(i) for i in input().split()]
a,b,c,d = [int(i) for i in input().split()]
p1 = a*h1 + c*(h1 // 10) + b*h2 + d*(h2 // 20)
p2 = a*k1 + c*(k1 // 10) + b*k2 + d*(k2 // 20)
if p1 > p2:
print("hiroshi")
elif p1 < p2:
print("kenjiro")
else:
print("even")
```
| 101,975 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
def getScore(i, y):
return i*a+y*b+c*(i//10)+d*(y//20)
h1, h2 = map(int, input().split())
k1, k2 = map(int, input().split())
a, b, c, d = map(int, input().split())
h, k = getScore(h1, h2), getScore(k1, k2)
if h>k:
print('hiroshi')
elif h<k:
print('kenjiro')
else:
print('even')
```
| 101,976 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
h1, h2 = map(int, input().split())
k1, k2 = map(int, input().split())
a, b, c, d = map(int, input().split())
hiroshi = h1*a + h1//10*c + h2*b + h2//20*d
kenjiro = k1*a + k1//10*c + k2*b + k2//20*d
if hiroshi > kenjiro:
print("hiroshi")
elif hiroshi < kenjiro:
print("kenjiro")
else:
print("even")
```
| 101,977 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
hi, hy = map(int, input().split())
ki, ky = map(int, input().split())
a, b, c, d = map(int, input().split())
h = hi * a + hi // 10 * c + hy * b + hy // 20 * d
k = ki * a + ki // 10 * c + ky * b + ky // 20 * d
if h > k: print("hiroshi")
elif h < k: print("kenjiro")
else: print("even")
```
| 101,978 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
h1,h2=map(int,input().split())
k1,k2=map(int,input().split())
a,b,c,d=map(int,input().split())
hp=h1*a+h2*b+(h1//10)*c+(h2//20)*d
kp=k1*a+k2*b+(k1//10)*c+(k2//20)*d
if hp>kp:
print("hiroshi")
elif kp>hp:
print("kenjiro")
else:
print("even")
```
| 101,979 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
h, i = map(int, input().split())
k, l = map(int, input().split())
a, b, c, d = map(int, input().split())
p = h * a + h // 10 * c + i * b + i // 20 * d
q = k * a + k // 10 * c + l * b + l // 20 * d
if p == q:print("even")
else:print("hiroshi" if p > q else "kenjiro")
```
| 101,980 |
Provide a correct Python 3 solution for this coding contest problem.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
"Correct Solution:
```
#標準入力
ha,hb = map(int,input().split())
ka,kb = map(int,input().split())
a,b,c,d = map(int,input().split())
ht,kt = 0,0
#得点の計算
ht = ha * a + hb * b + (ha // 10) * c + (hb // 20) * d
kt = ka * a + kb * b + (ka // 10) * c + (kb // 20) * d
#得点が大きいほう、または引き分けを出力する
if ht > kt:print("hiroshi")
elif ht < kt:print("kenjiro")
elif ht == kt:print("even")
```
| 101,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
h1, h2 = list(map(int, input().split()))
k1, k2 = list(map(int, input().split()))
a,b,c,d = list(map(int, input().split()))
hiro = h1*a + h2*b + (h1//10)*c + (h2//20)*d
ken = k1*a + k2*b + (k1//10)*c + (k2//20)*d
if hiro>ken:
print('hiroshi')
elif ken>hiro:
print('kenjiro')
else:
print('even')
```
Yes
| 101,982 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
[h1, h2] = [int(num) for num in input().split()]
[k1, k2] = [int(num) for num in input().split()]
[a, b, c, d] = [int(num) for num in input().split()]
counth = a * h1 + b * h2 + c * (h1 // 10) + d * (h2 // 20)
countk = a * k1 + b * k2 + c * (k1 // 10) + d * (k2 // 20)
if (counth > countk):
print('hiroshi')
elif (counth < countk):
print('kenjiro')
else:
print('even')
```
Yes
| 101,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
h,i = map(int,input().split(" "))
k,j = map(int,input().split(" "))
a,b,c,d = map(int,input().split(" "))
s=h*a+i*b+(h//10)*c+(i//20)*d
r=k*a+j*b+(k//10)*c+(j//20)*d
if s > r:
print("hiroshi")
elif s == r:
print("even")
else:
print("kenjiro")
```
Yes
| 101,984 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
h1, h2 = map(int,input().split())
k1, k2 = map(int,input().split())
a, b, c, d = map(int,input().split())
if h1 > 9:
hn = int(h1/10)
else:
hn = 0
if h2 > 19:
hm = int(h1/20)
else:
hm = 0
if k1 > 9:
kn = int(k1/10)
else:
kn = 0
if k2 > 19:
km = int(k2/20)
else:
km = 0
h = h1*a + hn*c + h2*b + hm*d
k = k1*a + kn*c + k2*b + km*d
if h<k:
print("kenjiro")
elif k<h:
print("hiroshi")
elif h == k:
print("even")
```
Yes
| 101,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
h1, h2 = map(int, input().split())
k1, k2 = map(int, input().split())
a, b, c, d = map(int, input().split())
H = h1 * a + h2 * b + h1 // 10 * c + h2 // 10 * d
K = k1 * a + k2 * b + k1 // 10 * c + k2 // 10 * d
print('hiroshi' if H>K else 'even' if H==K else 'kenjiro')
```
No
| 101,986 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
h1,h2 = map(int,input().split())
k1,k2 = map(int,input().split())
a,b,c,d = map(int,input().split())
def f(x,y):
return a*x + b*y + c*(x//10) + d*(y//10)
H,K = f(h1,h2), f(k1,k2)
ans = 'even'
if H>K:
ans = 'hiroshi'
elif H<K:
ans = 'kenjiro'
print(ans)
```
No
| 101,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
h, i = map(int, input().split())
k, l = map(int, input().split())
a, b, c, d = map(int, input().split())
p = h * a + h // 10 * c + i * b + i // 10 * d
q = k * a + k // 10 * c + l * b + l // 10 * d
if p == q:print("even")
else:print("hiroshi" if p > q else "kenjiro")
```
No
| 101,988 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The brothers Hiroshi and Kenjiro came to Lake Inawashiro for fishing. The two decided to score as follows and compete with the total score of the fish they caught.
* One char is a point
* One yamame trout b points
* Add c points for every 10 chars
* Add d points for every 20 yamame trout
Create a program to determine which one wins or draws based on the number of fish caught by Hiroshi and Kenjiro.
Input
The input is given in the following format.
h1 h2
k1 k2
a b c d
The first line gives the number of chars h1 (0 ≤ h1 ≤ 100) and the number of yamame trout h2 (0 ≤ h2 ≤ 100) caught by Hiroshi. The second line gives the number of chars k1 (0 ≤ k1 ≤ 100) and the number of yamame trout k2 (0 ≤ k2 ≤ 100) caught by Kenjiro. On the third line, the score for each char is a (1 ≤ a ≤ 100), the score for each yamame trout is b (1 ≤ b ≤ 100), and the additional score for every 10 chars is c (0 ≤ c ≤ 100). ), An additional score d (0 ≤ d ≤ 100) is given for every 20 chars.
Output
If Hiro wins, hiroshi, if Kenjiro wins, kenjiro, and if a tie, even, output on one line.
Examples
Input
5 1
3 1
1 2 5 5
Output
hiroshi
Input
5 1
4 2
1 2 5 5
Output
kenjiro
Input
0 20
10 0
1 1 10 0
Output
even
Submitted Solution:
```
h1,h2=map(int,input().split())
k1,k2=map(int,input().split())
a,b,c,d=map(int,input().split())
e,f,g,h=h1*a,h2*b,k1*a,k2*b
o,n,m,v=h1//10*c,h2//10*d,k1//10*c,k2//10*d
z,y=o+n+e+f,m+v+g+h
if z>y:
print("hiroshi")
elif z<y:
print("kenjiro")
else:
print("even")
```
No
| 101,989 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI City will hold a large-scale exposition.
There are two themes for this exposition, and each of the N exhibition facilities in JOI City will exhibit on one of the two themes.
The location of the facility is represented by plane coordinates (x, y). To move from the facility at position (x, y) to the facility at (x ′, y ′), | x − x ′ | + It takes only | y − y ′ | (for the integer a, | a | represents the absolute value of a). To create a sense of unity within the same theme, and to be interested in only one theme. In order not to make people feel inconvenience, I would like to assign the theme so that the travel time between two facilities exhibiting on the same theme is as short as possible. Unless the same theme is assigned to all exhibition facilities. , How can you divide the theme.
Let M be the maximum travel time between two facilities exhibiting on the same theme. Create a program to find the minimum value of M given the locations of N exhibition facilities.
output
The output consists of only one line. Output the maximum value M of the maximum travel time between two facilities exhibiting on the same theme.
Input / output example
Input example 1
Five
0 0
Ten
-1 -2
0 1
-1 1
Output example 1
3
In this case, for example, one theme for the facility at coordinates (0, 0), (1, 0), (0, 1), and another theme for the facility at (−1, −2), (−1, 1). When one theme is assigned, the travel time between two facilities exhibiting on the same theme is all 3 or less. Since the travel time cannot be all 2 or less, 3 is output.
The above question sentences and the data used for the automatic referee are the question sentences created and published by the Japan Committee for Information Olympics and the test data for scoring.
input
The first line of input contains the number of facilities N (3 ≤ N ≤ 100000 = 105). The first line of input i + 1 (1 ≤ i ≤ N) represents the coordinates of each facility. The two integers xi, yi (| xi | ≤ 100000 = 105, | yi | ≤ 100000 = 105) are separated by blanks. This is where the coordinates of the i-th facility are (xi, yi). It means that there can be no more than one facility at the same coordinates.
Of the scoring data, 40% of the points are N ≤ 2000.
Example
Input
5
0 0
1 0
-1 -2
0 1
-1 1
Output
3
"Correct Solution:
```
# AOJ 0552: Exposition
# Python3 2018.7.1 bal4u
import sys
from sys import stdin
input = stdin.readline
x, y = [], []
n = int(input())
for i in range(n):
a, b = map(int, input().split())
x.append(a+b)
y.append(a-b)
xmin, xmax = min(x), max(x)
ymin, ymax = min(y), max(y)
ans1 = ans2 = 0
for i in range(n):
d1 = max(x[i]-xmin, y[i]-ymin)
d2 = max(xmax-x[i], ymax-y[i])
ans1 = max(ans1, min(d1, d2))
d1 = max(x[i]-xmin, ymax-y[i])
d2 = max(xmax-x[i], y[i]-ymin)
ans2 = max(ans2, min(d1, d2))
print(min(ans1, ans2))
```
| 101,990 |
Provide a correct Python 3 solution for this coding contest problem.
My arm is stuck and I can't pull it out.
I tried to pick up something that had rolled over to the back of my desk, and I inserted my arm while illuminating it with the screen of my cell phone instead of a flashlight, but I accidentally got caught in something and couldn't pull it out. It hurts if you move it forcibly.
What should I do. How can I escape? Do you call for help out loud? I'm embarrassed to dismiss it, but it seems difficult to escape on my own. No, no one should have been within reach. Hold down your impatience and look around. If you can reach that computer, you can call for help by email, but unfortunately it's too far away. After all, do we have to wait for someone to pass by by chance?
No, wait, there is a machine that sends emails. It's already in your hands, rather than within reach. The screen at the tip of my deeply extended hand is blurry and hard to see, but it's a mobile phone I've been using for many years. You should be able to send emails even if you can't see the screen.
Carefully press the button while drawing the screen in your head. Rely on the feel of your finger and type in a message by pressing the number keys many times to avoid making typos. It doesn't convert to kanji, and it should be transmitted even in hiragana. I'm glad I didn't switch to the mainstream smartphones for the touch panel.
Take a deep breath and put your finger on the send button. After a while, my cell phone quivered lightly. It is a signal that the transmission is completed. sigh. A friend must come to help after a while.
I think my friends are smart enough to interpret it properly, but the message I just sent may be different from the one I really wanted to send. The character input method of this mobile phone is the same as the widely used one, for example, use the "1" button to input the hiragana of the "A" line. "1" stands for "a", "11" stands for "i", and so on, "11111" stands for "o". Hiragana loops, that is, "111111" also becomes "a". The "ka" line uses "2", the "sa" line uses "3", ..., and the behavior when the same button is pressed in succession is the same as in the example of "1".
However, this character input method has some annoying behavior. If you do not operate for a while after pressing the number button, the conversion to hiragana will be forced. In other words, if you press "1" three times in a row, it will become "U", but if you press "1" three times after a while, it will become "Ah". To give another example, when you press "111111", the character string entered depends on the interval between the presses, which can be either "a" or "ah ah ah". "111111111111" may be "yes", "yeah ah", or twelve "a". Note that even if you press a different number button, it will be converted to hiragana, so "12345" can only be the character string "Akasatana".
Well, I didn't mean to press the wrong button because I typed it carefully, but I'm not confident that I could press the buttons at the right intervals. It's very possible that you've sent something different than the message you really wanted to send. Now, how many strings may have been sent? Oh, this might be a good way to kill time until a friend comes to help. They will come to help within 5 hours at the latest. I hope it can be solved by then.
Input
The input consists of multiple cases.
Each case is given in the following format.
string
The end of the input is given by the line where the input consists of "#"
string contains up to 100,000 numbers between 0 and 9.
No more than 50 inputs have a string length greater than 10,000.
The test case file size is guaranteed to be 5MB or less.
Also, the number of test cases does not exceed 100.
The characters that can be entered with each number key are as shown in the table below.
Numbers | Enterable characters
--- | ---
1 | Aiueo
2 | Kakikukeko
3 |
4 |
5 | What is it?
6 | Hahifuheho
7 | Mamimumemo
8 | Yayuyo
9 | Larry Lero
0 | Won
Output
Divide how to interpret the sentence by 1000000007 and output the remainder on one line.
Examples
Input
1
11
111111
111111111111
12345
11111111119999999999
11111111113333333333
11111111118888888888
11111111112222222222111111111
11111111110000000000444444444
11224111122411
888888888888999999999999888888888888999999999999999999
666666666666666777333333333338888888888
1111114444441111111444499999931111111222222222222888111111115555
#
Output
1
2
32
1856
1
230400
230400
156480
56217600
38181120
128
26681431
61684293
40046720
Input
1
11
111111
111111111111
12345
11111111119999999999
11111111113333333333
11111111118888888888
11111111112222222222111111111
11111111110000000000444444444
11224111122411
888888888888999999999999888888888888999999999999999999
666666666666666777333333333338888888888
1111114444441111111444499999931111111222222222222888111111115555
Output
1
2
32
1856
1
230400
230400
156480
56217600
38181120
128
26681431
61684293
40046720
"Correct Solution:
```
def f3(n):
a=b=c=0
for _ in range(n):
a,b,c=(a+b+c+1)%100000007,a,b
return a
def f5(n):
a=b=c=d=e=0
for _ in range(n):
a,b,c,d,e=(a+b+c+d+e+1)%100000007,a,b,c,d
return a
while 1:
s=input()
if s=="#":break
ans=1
num="_"
cnt=1
for n in s+"_":
if n==num:
cnt+=1
else:
if num in "80":
ans=ans*f3(cnt)%100000007
else:
ans=ans*f5(cnt)%100000007
num=n
cnt=1
print(ans)
```
| 101,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
My arm is stuck and I can't pull it out.
I tried to pick up something that had rolled over to the back of my desk, and I inserted my arm while illuminating it with the screen of my cell phone instead of a flashlight, but I accidentally got caught in something and couldn't pull it out. It hurts if you move it forcibly.
What should I do. How can I escape? Do you call for help out loud? I'm embarrassed to dismiss it, but it seems difficult to escape on my own. No, no one should have been within reach. Hold down your impatience and look around. If you can reach that computer, you can call for help by email, but unfortunately it's too far away. After all, do we have to wait for someone to pass by by chance?
No, wait, there is a machine that sends emails. It's already in your hands, rather than within reach. The screen at the tip of my deeply extended hand is blurry and hard to see, but it's a mobile phone I've been using for many years. You should be able to send emails even if you can't see the screen.
Carefully press the button while drawing the screen in your head. Rely on the feel of your finger and type in a message by pressing the number keys many times to avoid making typos. It doesn't convert to kanji, and it should be transmitted even in hiragana. I'm glad I didn't switch to the mainstream smartphones for the touch panel.
Take a deep breath and put your finger on the send button. After a while, my cell phone quivered lightly. It is a signal that the transmission is completed. sigh. A friend must come to help after a while.
I think my friends are smart enough to interpret it properly, but the message I just sent may be different from the one I really wanted to send. The character input method of this mobile phone is the same as the widely used one, for example, use the "1" button to input the hiragana of the "A" line. "1" stands for "a", "11" stands for "i", and so on, "11111" stands for "o". Hiragana loops, that is, "111111" also becomes "a". The "ka" line uses "2", the "sa" line uses "3", ..., and the behavior when the same button is pressed in succession is the same as in the example of "1".
However, this character input method has some annoying behavior. If you do not operate for a while after pressing the number button, the conversion to hiragana will be forced. In other words, if you press "1" three times in a row, it will become "U", but if you press "1" three times after a while, it will become "Ah". To give another example, when you press "111111", the character string entered depends on the interval between the presses, which can be either "a" or "ah ah ah". "111111111111" may be "yes", "yeah ah", or twelve "a". Note that even if you press a different number button, it will be converted to hiragana, so "12345" can only be the character string "Akasatana".
Well, I didn't mean to press the wrong button because I typed it carefully, but I'm not confident that I could press the buttons at the right intervals. It's very possible that you've sent something different than the message you really wanted to send. Now, how many strings may have been sent? Oh, this might be a good way to kill time until a friend comes to help. They will come to help within 5 hours at the latest. I hope it can be solved by then.
Input
The input consists of multiple cases.
Each case is given in the following format.
string
The end of the input is given by the line where the input consists of "#"
string contains up to 100,000 numbers between 0 and 9.
No more than 50 inputs have a string length greater than 10,000.
The test case file size is guaranteed to be 5MB or less.
Also, the number of test cases does not exceed 100.
The characters that can be entered with each number key are as shown in the table below.
Numbers | Enterable characters
--- | ---
1 | Aiueo
2 | Kakikukeko
3 |
4 |
5 | What is it?
6 | Hahifuheho
7 | Mamimumemo
8 | Yayuyo
9 | Larry Lero
0 | Won
Output
Divide how to interpret the sentence by 1000000007 and output the remainder on one line.
Examples
Input
1
11
111111
111111111111
12345
11111111119999999999
11111111113333333333
11111111118888888888
11111111112222222222111111111
11111111110000000000444444444
11224111122411
888888888888999999999999888888888888999999999999999999
666666666666666777333333333338888888888
1111114444441111111444499999931111111222222222222888111111115555
#
Output
1
2
32
1856
1
230400
230400
156480
56217600
38181120
128
26681431
61684293
40046720
Input
1
11
111111
111111111111
12345
11111111119999999999
11111111113333333333
11111111118888888888
11111111112222222222111111111
11111111110000000000444444444
11224111122411
888888888888999999999999888888888888999999999999999999
666666666666666777333333333338888888888
1111114444441111111444499999931111111222222222222888111111115555
Output
1
2
32
1856
1
230400
230400
156480
56217600
38181120
128
26681431
61684293
40046720
Submitted Solution:
```
def f3(n):
a=b=c=0
for _ in range(n):
a,b,c=(a+b+c+1)%100000007,a,b
return a
def f5(n):
a=b=c=d=e=0
for _ in range(n):
a,b,c,d,e=(a+b+c+d+e+1)%100000007,a,b,c,d
return a
while 1:
s=input()
if s=="#":break
ans=1
num="_"
cnt=1
for n in s+"_":
if n==num:
cnt+=1
else:
if num in "80":
ans*=f3(cnt)
else:
ans*=f5(cnt)
num=n
cnt=1
print(ans)
```
No
| 101,992 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
My arm is stuck and I can't pull it out.
I tried to pick up something that had rolled over to the back of my desk, and I inserted my arm while illuminating it with the screen of my cell phone instead of a flashlight, but I accidentally got caught in something and couldn't pull it out. It hurts if you move it forcibly.
What should I do. How can I escape? Do you call for help out loud? I'm embarrassed to dismiss it, but it seems difficult to escape on my own. No, no one should have been within reach. Hold down your impatience and look around. If you can reach that computer, you can call for help by email, but unfortunately it's too far away. After all, do we have to wait for someone to pass by by chance?
No, wait, there is a machine that sends emails. It's already in your hands, rather than within reach. The screen at the tip of my deeply extended hand is blurry and hard to see, but it's a mobile phone I've been using for many years. You should be able to send emails even if you can't see the screen.
Carefully press the button while drawing the screen in your head. Rely on the feel of your finger and type in a message by pressing the number keys many times to avoid making typos. It doesn't convert to kanji, and it should be transmitted even in hiragana. I'm glad I didn't switch to the mainstream smartphones for the touch panel.
Take a deep breath and put your finger on the send button. After a while, my cell phone quivered lightly. It is a signal that the transmission is completed. sigh. A friend must come to help after a while.
I think my friends are smart enough to interpret it properly, but the message I just sent may be different from the one I really wanted to send. The character input method of this mobile phone is the same as the widely used one, for example, use the "1" button to input the hiragana of the "A" line. "1" stands for "a", "11" stands for "i", and so on, "11111" stands for "o". Hiragana loops, that is, "111111" also becomes "a". The "ka" line uses "2", the "sa" line uses "3", ..., and the behavior when the same button is pressed in succession is the same as in the example of "1".
However, this character input method has some annoying behavior. If you do not operate for a while after pressing the number button, the conversion to hiragana will be forced. In other words, if you press "1" three times in a row, it will become "U", but if you press "1" three times after a while, it will become "Ah". To give another example, when you press "111111", the character string entered depends on the interval between the presses, which can be either "a" or "ah ah ah". "111111111111" may be "yes", "yeah ah", or twelve "a". Note that even if you press a different number button, it will be converted to hiragana, so "12345" can only be the character string "Akasatana".
Well, I didn't mean to press the wrong button because I typed it carefully, but I'm not confident that I could press the buttons at the right intervals. It's very possible that you've sent something different than the message you really wanted to send. Now, how many strings may have been sent? Oh, this might be a good way to kill time until a friend comes to help. They will come to help within 5 hours at the latest. I hope it can be solved by then.
Input
The input consists of multiple cases.
Each case is given in the following format.
string
The end of the input is given by the line where the input consists of "#"
string contains up to 100,000 numbers between 0 and 9.
No more than 50 inputs have a string length greater than 10,000.
The test case file size is guaranteed to be 5MB or less.
Also, the number of test cases does not exceed 100.
The characters that can be entered with each number key are as shown in the table below.
Numbers | Enterable characters
--- | ---
1 | Aiueo
2 | Kakikukeko
3 |
4 |
5 | What is it?
6 | Hahifuheho
7 | Mamimumemo
8 | Yayuyo
9 | Larry Lero
0 | Won
Output
Divide how to interpret the sentence by 1000000007 and output the remainder on one line.
Examples
Input
1
11
111111
111111111111
12345
11111111119999999999
11111111113333333333
11111111118888888888
11111111112222222222111111111
11111111110000000000444444444
11224111122411
888888888888999999999999888888888888999999999999999999
666666666666666777333333333338888888888
1111114444441111111444499999931111111222222222222888111111115555
#
Output
1
2
32
1856
1
230400
230400
156480
56217600
38181120
128
26681431
61684293
40046720
Input
1
11
111111
111111111111
12345
11111111119999999999
11111111113333333333
11111111118888888888
11111111112222222222111111111
11111111110000000000444444444
11224111122411
888888888888999999999999888888888888999999999999999999
666666666666666777333333333338888888888
1111114444441111111444499999931111111222222222222888111111115555
Output
1
2
32
1856
1
230400
230400
156480
56217600
38181120
128
26681431
61684293
40046720
Submitted Solution:
```
def f3(n):
a=b=c=0
for _ in range(n):
a,b,c=a+b+c+1,a,b
return a
def f5(n):
a=b=c=d=e=0
for _ in range(n):
a,b,c,d,e=a+b+c+d+e+1,a,b,c,d
return a
while 1:
s=input()
if s=="#":break
ans=1
num="_"
cnt=1
for n in s+"_":
if n==num:
cnt+=1
else:
if num in "80":
ans*=f3(cnt)
else:
ans*=f5(cnt)
num=n
cnt=1
print(ans%100000007)
```
No
| 101,993 |
Provide a correct Python 3 solution for this coding contest problem.
During a voyage of the starship Hakodate-maru (see Problem A), researchers found strange synchronized movements of stars. Having heard these observations, Dr. Extreme proposed a theory of "super stars". Do not take this term as a description of actors or singers. It is a revolutionary theory in astronomy.
According to this theory, stars we are observing are not independent objects, but only small portions of larger objects called super stars. A super star is filled with invisible (or transparent) material, and only a number of points inside or on its surface shine. These points are observed as stars by us.
In order to verify this theory, Dr. Extreme wants to build motion equations of super stars and to compare the solutions of these equations with observed movements of stars. As the first step, he assumes that a super star is sphere-shaped, and has the smallest possible radius such that the sphere contains all given stars in or on it. This assumption makes it possible to estimate the volume of a super star, and thus its mass (the density of the invisible material is known).
You are asked to help Dr. Extreme by writing a program which, given the locations of a number of stars, finds the smallest sphere containing all of them in or on it. In this computation, you should ignore the sizes of stars. In other words, a star should be regarded as a point. You may assume the universe is a Euclidean space.
Input
The input consists of multiple data sets. Each data set is given in the following format.
n
x1 y1 z1
x2 y2 z2
...
xn yn zn
The first line of a data set contains an integer n, which is the number of points. It satisfies the condition 4 ≤ n ≤ 30.
The locations of n points are given by three-dimensional orthogonal coordinates: (xi, yi, zi) (i = 1,..., n). Three coordinates of a point appear in a line, separated by a space character.
Each value is given by a decimal fraction, and is between 0.0 and 100.0 (both ends inclusive). Points are at least 0.01 distant from each other.
The end of the input is indicated by a line containing a zero.
Output
For each data set, the radius ofthe smallest sphere containing all given points should be printed, each in a separate line. The printed values should have 5 digits after the decimal point. They may not have an error greater than 0.00001.
Example
Input
4
10.00000 10.00000 10.00000
20.00000 10.00000 10.00000
20.00000 20.00000 10.00000
10.00000 20.00000 10.00000
4
10.00000 10.00000 10.00000
10.00000 50.00000 50.00000
50.00000 10.00000 50.00000
50.00000 50.00000 10.00000
0
Output
7.07107
34.64102
"Correct Solution:
```
def distance(star, position):
return sum([(a - b)**2 for a, b in zip(star, position)])**(1 / 2)
def difference(star, position):
return [(a - b) for a, b in zip(star, position)]
while True:
n = int(input())
if n == 0:
break
stars = [list(map(float, input().split())) for i in range(n)]
position = [sum([s[i] for s in stars]) / len(stars) for i in range(3)]
move_rate = 1
for i in range(3000):
if i % 100 == 0:
move_rate /= 2
index = 0
dis_max = 0
for j, star in enumerate(stars):
dis = distance(star, position)
if dis_max < dis:
dis_max = dis
index = j
diff = difference(stars[index], position)
position = [(position[i] + diff[i] * move_rate) for i in range(3)]
print(format(dis_max, ".5f"))
```
| 101,994 |
Provide a correct Python 3 solution for this coding contest problem.
During a voyage of the starship Hakodate-maru (see Problem A), researchers found strange synchronized movements of stars. Having heard these observations, Dr. Extreme proposed a theory of "super stars". Do not take this term as a description of actors or singers. It is a revolutionary theory in astronomy.
According to this theory, stars we are observing are not independent objects, but only small portions of larger objects called super stars. A super star is filled with invisible (or transparent) material, and only a number of points inside or on its surface shine. These points are observed as stars by us.
In order to verify this theory, Dr. Extreme wants to build motion equations of super stars and to compare the solutions of these equations with observed movements of stars. As the first step, he assumes that a super star is sphere-shaped, and has the smallest possible radius such that the sphere contains all given stars in or on it. This assumption makes it possible to estimate the volume of a super star, and thus its mass (the density of the invisible material is known).
You are asked to help Dr. Extreme by writing a program which, given the locations of a number of stars, finds the smallest sphere containing all of them in or on it. In this computation, you should ignore the sizes of stars. In other words, a star should be regarded as a point. You may assume the universe is a Euclidean space.
Input
The input consists of multiple data sets. Each data set is given in the following format.
n
x1 y1 z1
x2 y2 z2
...
xn yn zn
The first line of a data set contains an integer n, which is the number of points. It satisfies the condition 4 ≤ n ≤ 30.
The locations of n points are given by three-dimensional orthogonal coordinates: (xi, yi, zi) (i = 1,..., n). Three coordinates of a point appear in a line, separated by a space character.
Each value is given by a decimal fraction, and is between 0.0 and 100.0 (both ends inclusive). Points are at least 0.01 distant from each other.
The end of the input is indicated by a line containing a zero.
Output
For each data set, the radius ofthe smallest sphere containing all given points should be printed, each in a separate line. The printed values should have 5 digits after the decimal point. They may not have an error greater than 0.00001.
Example
Input
4
10.00000 10.00000 10.00000
20.00000 10.00000 10.00000
20.00000 20.00000 10.00000
10.00000 20.00000 10.00000
4
10.00000 10.00000 10.00000
10.00000 50.00000 50.00000
50.00000 10.00000 50.00000
50.00000 50.00000 10.00000
0
Output
7.07107
34.64102
"Correct Solution:
```
while True:
n = int(input())
if not n:
break
star = [list(map(float, input().split())) for i in range(n)]
start = [0.0, 0.0, 0.0]
move = 0.5
for _ in range(500):
for j in range(100):
tmpmax = 0
a = 0
for i in range(n):
k = (star[i][0] - start[0]) ** 2 + (star[i][1] - start[1]) ** 2 + (star[i][2] - start[2]) ** 2
if tmpmax < k:
tmpmax = k
a = i
start = [start[i] - (start[i] - star[a][i]) * move for i in range(3)]
move /= 2
tmpmax = 0
for i in range(n):
k = (star[i][0] - start[0]) ** 2 + (star[i][1] - start[1]) ** 2 + (star[i][2] - start[2]) ** 2
if tmpmax < k:
tmpmax = k
print(round(tmpmax ** 0.5, 5))
```
| 101,995 |
Provide a correct Python 3 solution for this coding contest problem.
Example
Input
crc
1
Output
crc
"Correct Solution:
```
from heapq import heappush, heappop
def solve():
S = input()
K = int(input())
L = len(S)
INF = 10**9
cost = [[INF]*(L+1) for i in range(L+1)]
cost[0][L] = 0
ss = []
que = [(0, 0, L)]
while que:
d, a, b = heappop(que)
if cost[a][b] < d:
continue
ss.append((a, b))
if a+1 == b:
if d+1 < cost[a+1][b]:
cost[a+1][b] = d + 1
continue
if S[a] == S[b-1]:
if d+2 < cost[a+1][b-1]:
cost[a+1][b-1] = d + 2
if a+1 < b-1:
heappush(que, (d+2, a+1, b-1))
else:
if d+2 < cost[a+1][b]:
cost[a+1][b] = d + 2
if a+1 < b:
heappush(que, (d+2, a+1, b))
if d+2 < cost[a][b-1]:
cost[a][b-1] = d + 2
if a < b-1:
heappush(que, (d+2, a, b-1))
ln = min(cost[i][i] for i in range(L+1))
ss.reverse()
dp = [[0]*(L+1) for i in range(L+1)]
for i in range(L+1):
if cost[i][i] == ln:
dp[i][i] = 1
for a, b in ss:
d = cost[a][b]
r = 0
if a+1 == b:
if d+1 == cost[a+1][b]:
r = dp[a+1][b]
else:
if S[a] == S[b-1]:
if d+2 == cost[a+1][b-1]:
r = dp[a+1][b-1]
else:
if d+2 == cost[a+1][b]:
r += dp[a+1][b]
if d+2 == cost[a][b-1]:
r += dp[a][b-1]
dp[a][b] = r
if dp[a][b] < K:
print("NONE")
return True
SL = []; SR = []
a = 0; b = L
while a < b:
if a+1 == b:
assert cost[a][b]+1 == cost[a+1][b]
SL.append(S[a])
a += 1
continue
if S[a] == S[b-1]:
assert cost[a][b]+2 == cost[a+1][b-1]
SL.append(S[a])
SR.append(S[b-1])
a += 1; b -= 1
elif S[a] < S[b-1]:
c = (cost[a][b]+2 == cost[a+1][b])
if c and K <= dp[a+1][b]:
SL.append(S[a])
SR.append(S[a])
a += 1
else:
if c:
K -= dp[a+1][b]
SL.append(S[b-1])
SR.append(S[b-1])
b -= 1
else:
c = (cost[a][b]+2 == cost[a][b-1])
if c and K <= dp[a][b-1]:
SL.append(S[b-1])
SR.append(S[b-1])
b -= 1
else:
if c:
K -= dp[a][b-1]
SL.append(S[a])
SR.append(S[a])
a += 1
SR.reverse()
SL.extend(SR)
print("".join(SL))
solve()
```
| 101,996 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
Yamano Mifune Gakuen's 1st grade G group is a class where female students carrying misfortune gather. They face various challenges every day with the goal of being happy.
In their class, they can take practical happiness courses as part of the test of happiness.
From Monday to Friday, there are classes from 1st to Nth, and there are M courses that can be taken.
Subject i starts from the ai period of the day of the week di (di = 0, 1, 2, 3, 4 corresponds to Monday, Tuesday, Wednesday, Thursday, and Friday, respectively), and is performed in consecutive ki frames. The degree of happiness obtained when taking the course is ti.
Each student is free to choose up to L subjects so that they do not overlap each other. How do you choose the subject to get the highest level of happiness? Please find the maximum value of happiness that can be obtained from the information of the given subject.
Constraints
* 2 ≤ N ≤ 8
* 0 ≤ M ≤ 300
* 0 ≤ L ≤ min (N × 5, M)
* 0 ≤ di ≤ 4
* 1 ≤ ai ≤ N
* 1 ≤ ki
* ai + ki --1 ≤ N
* 1 ≤ ti ≤ 100
Input
The input is given in the following format.
N M L
d1 a1 k1 t1
d2 a2 k2 t2
...
dM aM kM tM
The first line is given three integers N, M, L separated by blanks.
The four integers di, ai, ki, and ti are given on the 2nd to M + 1th lines, separated by blanks.
Output
Output the maximum value of the sum of happiness on one line.
Examples
Input
3 7 3
0 1 1 1
0 1 1 2
1 1 3 4
1 1 1 1
1 2 1 2
2 1 1 3
2 2 2 1
Output
9
Input
5 10 5
0 1 1 2
0 2 1 2
0 1 2 3
1 2 1 2
1 4 2 3
2 1 1 1
2 1 1 2
3 3 2 3
4 1 1 2
4 2 1 2
Output
13
"Correct Solution:
```
from itertools import product
n, m, l = map(int, input().split())
subjects = [[] for _ in range(5)]
for _ in range(m):
d, a, k, t = map(int, input().split())
subjects[d].append((a, a + k - 1, t))
for i in range(5):
subjects[i].sort(key=lambda x:x[1])
#各曜日の科目数ごとの最大幸福
def calcDp(i):
#dp[y][x] ... y科目xコマまでの最大幸福
dp = [[0] * (n + 1) for _ in range(n + 1)]
sub = subjects[i]
for init, end, value in sub:
for y in range(n):
new_score = dp[y][init - 1] + value
for x in range(end, n + 1):
dp[y + 1][x] = max(dp[y + 1][x], new_score)
ret = []
for i in range(n + 1):
ret.append(max(dp[i]))
return ret
lst = [calcDp(i) for i in range(5)]
ans = 0
for t in product(range(n + 1), repeat=5):
if sum(t) > l:continue
score = 0
for i, v in enumerate(t):
score += lst[i][v]
ans = max(score, ans)
print(ans)
```
| 101,997 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
Yamano Mifune Gakuen's 1st grade G group is a class where female students carrying misfortune gather. They face various challenges every day with the goal of being happy.
In their class, they can take practical happiness courses as part of the test of happiness.
From Monday to Friday, there are classes from 1st to Nth, and there are M courses that can be taken.
Subject i starts from the ai period of the day of the week di (di = 0, 1, 2, 3, 4 corresponds to Monday, Tuesday, Wednesday, Thursday, and Friday, respectively), and is performed in consecutive ki frames. The degree of happiness obtained when taking the course is ti.
Each student is free to choose up to L subjects so that they do not overlap each other. How do you choose the subject to get the highest level of happiness? Please find the maximum value of happiness that can be obtained from the information of the given subject.
Constraints
* 2 ≤ N ≤ 8
* 0 ≤ M ≤ 300
* 0 ≤ L ≤ min (N × 5, M)
* 0 ≤ di ≤ 4
* 1 ≤ ai ≤ N
* 1 ≤ ki
* ai + ki --1 ≤ N
* 1 ≤ ti ≤ 100
Input
The input is given in the following format.
N M L
d1 a1 k1 t1
d2 a2 k2 t2
...
dM aM kM tM
The first line is given three integers N, M, L separated by blanks.
The four integers di, ai, ki, and ti are given on the 2nd to M + 1th lines, separated by blanks.
Output
Output the maximum value of the sum of happiness on one line.
Examples
Input
3 7 3
0 1 1 1
0 1 1 2
1 1 3 4
1 1 1 1
1 2 1 2
2 1 1 3
2 2 2 1
Output
9
Input
5 10 5
0 1 1 2
0 2 1 2
0 1 2 3
1 2 1 2
1 4 2 3
2 1 1 1
2 1 1 2
3 3 2 3
4 1 1 2
4 2 1 2
Output
13
"Correct Solution:
```
# AOJ 1589 Unhappy Class
# Python3 2018.7.13 bal4u
N, M, L = map(int, input().split())
tbl = [[] for i in range(45)]
for i in range(M):
d, a, k, t = map(int, input().split())
tbl[d*N+a-1].append((k, t))
dp = [[0 for i in range(45)] for j in range(45)]
for da in range(5*N):
for i in range(L+1):
if i < L:
for k, t in tbl[da]:
dp[da+k][i+1] = max(dp[da+k][i+1], dp[da][i]+t)
dp[da+1][i] = max(dp[da+1][i], dp[da][i])
print(dp[5*N][L])
```
| 101,998 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem Statement
Dr. Suposupo developed a programming language called Shipura. Shipura supports only one binary operator ${\tt >>}$ and only one unary function ${\tt S<\ >}$.
$x {\tt >>} y$ is evaluated to $\lfloor x / 2^y \rfloor$ (that is, the greatest integer not exceeding $x / 2^y$), and ${\tt S<} x {\tt >}$ is evaluated to $x^2 \bmod 1{,}000{,}000{,}007$ (that is, the remainder when $x^2$ is divided by $1{,}000{,}000{,}007$).
The operator ${\tt >>}$ is left-associative. For example, the expression $x {\tt >>} y {\tt >>} z$ is interpreted as $(x {\tt >>} y) {\tt >>} z$, not as $x {\tt >>} (y {\tt >>} z)$. Note that these parentheses do not appear in actual Shipura expressions.
The syntax of Shipura is given (in BNF; Backus-Naur Form) as follows:
expr ::= term | expr sp ">>" sp term
term ::= number | "S" sp "<" sp expr sp ">"
sp ::= "" | sp " "
number ::= digit | number digit
digit ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
The start symbol of this syntax is $\tt expr$ that represents an expression in Shipura. In addition, $\tt number$ is an integer between $0$ and $1{,}000{,}000{,}000$ inclusive, written without extra leading zeros.
Write a program to evaluate Shipura expressions.
Input
The input is a sequence of datasets. Each dataset is represented by a line which contains a valid expression in Shipura.
A line containing a single ${\tt \\#}$ indicates the end of the input. You can assume the number of datasets is at most $100$ and the total size of the input file does not exceed $2{,}000{,}000$ bytes.
Output
For each dataset, output a line containing the evaluated value of the expression.
Sample Input
S< S< 12 >> 2 > >
123 >> 1 >> 1
1000000000 >>129
S<S<S<S<S<2>>>>>
S <S< S<2013 >>> 11 >>> 10 >
Output for the Sample Input
81
30
0
294967268
14592400
Example
Input
S< S< 12 >> 2 > >
123 >> 1 >> 1
1000000000 >>129
S<S<S<S<S<2>>>>>
S <S< S<2013 >>> 11 >>> 10 >
#
Output
81
30
0
294967268
14592400
Submitted Solution:
```
import re
S = lambda x: x*x%int(1e9+7)
s = input()
while s != '#':
s = s.replace(' ', '')
s = re.sub(r'>>(\d+)', r'XX\1', s)
s = s.translate(str.maketrans('<>X', '()>'))
print(eval(s))
s = input()
```
No
| 101,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.