text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
"Correct Solution:
```
n,a,b,k=map(int,input().split())
p=998244353
def getinv(n):
inv=[0]*(n+1)
for i in range(1,n+1):
inv[i]=pow(i,p-2,p)
return inv
def getnCr(n):
inv=getinv(n)
nCr=[0]*(n+1)
nCr[0]=1
for i in range(1,n+1):
nCr[i]=(nCr[i-1]*(n-i+1)*inv[i])%p
return nCr
def solve(n,a,b,k):
ans=0
nCr=getnCr(n)
for i in range(n+1):
if (k-a*i)<0 or (k-a*i)%b!=0:
continue
j=(k-a*i)//b
if a*i+b*j==k and 0<=j<=n:
ans+= nCr[i]*nCr[j]
ans%=p
return ans
print(solve(n,a,b,k))
```
| 95,100 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
"Correct Solution:
```
def combs_mod(n,k,mod):
#nC0からnCkまで
inv = [1]*(k+1)
for i in range(1,k+1):
inv[i] = pow(i,mod-2,mod)
ans = [1]*(k+1)
for i in range(1,k+1):
ans[i] = ans[i-1]*(n+1-i)*inv[i]%mod
return ans
def solve():
mod = 998244353
N, A, B, K = map(int, input().split())
com = combs_mod(N,N,mod)
ans = 0
for x in range(N+1):
if (K-A*x)%B==0:
y = (K-A*x)//B
if y>=0 and y<=N:
ans += com[x]*com[y]
ans %= mod
return ans
print(solve())
```
| 95,101 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
"Correct Solution:
```
n,a,b,k = map(int,input().split())
mod = 998244353
def factorial(N, MOD, r=True):
fact = [1] * (N + 1)
rfact = [1] * (N + 1)
r = 1
for i in range(1, N + 1):
fact[i] = r = r * i % MOD
rfact[N] = r = pow(fact[N], MOD - 2, MOD)
for i in range(N, 0, -1):
rfact[i - 1] = r = r * i % MOD
if r:
return fact, rfact
else:
return fact, rfact
fact,rfact = factorial(n,mod)
def comb(n, k): # 上のfactorialと併用
return fact[n] * rfact[k] * rfact[n - k] % mod
ans = 0
for x in range(n+1):
if k-a*x >= 0 and (k-a*x)%b == 0:
y = (k-a*x)//b
if y <= n:
ans += comb(n,x) * comb(n,y)
ans %= mod
print(ans)
```
| 95,102 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
"Correct Solution:
```
N, A, B, K = map(int, input().split())
maxAB = max(A, B)
minAB = min(A, B)
ans = 0
def cmb(n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
mod = 998244353 # 問題によって変える、ここは素数でないとうまく動かない
N_cmb = 0
N_cmb += N # 入力の制約によって変えるところ、nCrの計算で欲しいnの最大値
fac = [1, 1] # 階乗テーブル
finv = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for ZZZ in range(2, N_cmb + 1):
fac.append((fac[-1] * ZZZ) % mod)
inverse.append(mod-inverse[mod % ZZZ]*(mod//ZZZ) % mod)
finv.append((finv[-1] * inverse[-1]) % mod)
for i in range(min(N+1, K//maxAB+1)):
j = (K - maxAB * i) // minAB
if (K - maxAB * i) % minAB == 0 and 0 <= j <= N:
#print(i, j)
ans += cmb(N, i) * cmb(N, j) % mod
ans %= mod
print(ans)
```
| 95,103 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
"Correct Solution:
```
M=998244353;n,A,B,K=map(int,input().split());F=[1];a=0
for i in range(n):F+=[F[-1]*(n-i)*pow(i+1,M-2,M)%M]
for i in range(n+1):
q,r=divmod(K-i*A,B)
if(r==0)&(0<=q<=n):a+=F[i]*F[q]
print(a%M)
```
| 95,104 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
"Correct Solution:
```
M=998244353;n,A,B,K=map(int,input().split());F=[1];a=0
for i in range(n):F+=[F[-1]*(n-i)*pow(i+1,M-2,M)%M]
for i in range(n+1):
r=K-i*A
if(r%B==0)&(0<=r//B<=n):a+=F[i]*F[r//B]
print(a%M)
```
| 95,105 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
"Correct Solution:
```
MOD = 998244353
n, a, b, k = map(int, input().split())
fac = [1] * (n + 1)
for i in range(n):
fac[i + 1] = fac[i] * (i + 1) % MOD
def comb(n, k):
return fac[n] * pow(fac[n - k], MOD - 2, MOD) * pow(fac[k], MOD - 2, MOD)
ans = 0
for x in range(n + 1):
if k - x * a < 0 or (k - x * a) % b:
continue
y = (k - x * a) // b
if n < y:
continue
ans += (comb(n, x) * comb(n, y)) % MOD
print(ans % MOD)
```
| 95,106 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
mod = 998244353
def extgcd(a, b, c):
x, y, u, v, k, l = 1, 0, 0, 1, a, b
while l != 0:
x, y, u, v = u, v, x - u * (k // l), y - (k // l)
k, l = l, k % l
if c == 1:
return x
elif c == 2:
return y
elif c == 3:
return k
def inved(x):
return extgcd(x, mod, 1)
fact = [1 for i in range(300001)]
invf = [1 for i in range(300001)]
for i in range(300000):
fact[i+1] = (fact[i] * (i + 1)) % mod
invf[300000] = inved(fact[300000])
for i in range(300000, 0, -1):
invf[i-1] = (invf[i] * i) % mod
#--------------------------------------------------#
N, A, B, K = map(int, input().split())
g = extgcd(A, B, 3)
uppern = (fact[N] * fact[N]) % mod
S = 0
if K % g != 0:
S = 0
else:
left = max(-((B*N-K)//A), 0)
right = min(K // A, N)
for i in range(left, right + 1):
if (K - A * i) % B == 0:
l = (K - A * i) // B
prod = (invf[i] * invf[N-i]) % mod
prod *= (invf[l] * invf[N-l]) % mod
prod %= mod
prod *= uppern
prod %= mod
S += prod
S %= mod
print(S)
```
Yes
| 95,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
def fib(n, p):
F = [1] * (n + 1)
for i in range(2, n + 1):
F[i] = F[i - 1] * i % p
return F
def finv(F, p):
N = len(F) - 1
Finv = list(F)
Finv[-1] = pow(F[-1], p - 2, p)
for i in range(N - 1, -1, -1):
Finv[i] = Finv[i + 1] * (i + 1) % p
return Finv
def comb(F, Finv, n, a, p):
return F[n] * Finv[a] * Finv[n - a] % p
N, A, B, K = map(int, input().split())
p = 998244353
F = fib(N, p)
Finv = finv(F, p)
cnt = 0
for a in range(min(N + 1, K // A + 1)):
_A = A * a
if _A > K:
continue
if (K - _A) % B > 0:
continue
b = (K - _A) // B
if b > N:
continue
cnt += comb(F, Finv, N, a, p) * comb(F, Finv, N, b, p)
cnt %= p
print(cnt)
```
Yes
| 95,108 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
N,A,B,K = map(int,input().split())
MOD = 998244353
MAXN = N+5
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def comb(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = 0
for a in range(N+1):
if (K-a*A)%B: continue
b = (K-a*A)//B
ans += comb(N,a) * comb(N,b)
ans %= MOD
print(ans)
```
Yes
| 95,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
# https://beta.atcoder.jp/contests/agc025/tasks/agc025_b
from functools import reduce
import operator as op
MOD = 998244353
mod_inv = [0, 1]
def init_mod_inv(n):
for i in range(2, n + 1):
ans = MOD - (MOD // i) * mod_inv[MOD % i] % MOD
mod_inv.append(ans)
def main():
n, a, b, k = map(int, input().split())
init_mod_inv(n)
nCr = [0] * (n + 1)
nCr[0] = 1
for i in range(1, n+1):
nCr[i] = (nCr[i - 1] * (n - i + 1) * mod_inv[i]) % MOD
ways = 0
for x in range(0, n + 1):
yb = k - a * x
if yb >= 0 and yb % b == 0 and yb // b <= n:
ways += nCr[x] * nCr[yb // b]
ways %= MOD
print(ways)
if __name__ == "__main__":
main()
```
Yes
| 95,110 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
MOD = 998244353
def nCk(n, k):
if n == k:
return 1
if n-k<k:
k = n-k
cc = 1
for _ in range(k):
cc *= n
cc %= MOD
n -= 1
for i in range(2, k+1):
cc *= pow(i, MOD-2, MOD)
cc %= MOD
return cc
n, a, b, k = map(int, input().split())
ans = 0
for i in range(n):
rc = i
if k - a*rc < 0:
break
if (k-a*rc)%b != 0:
continue
bc = (k-a*rc)//b
ans += (nCk(n, rc) * nCk(n, bc)) % MOD
ans %= MOD
print(ans)
```
No
| 95,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
from scipy.misc import comb
from fractions import gcd
n, a, b, k = map(int, input().split())
a, b = max(a, b), min(a, b)
q = 998244353
n_ = n % q
d = gcd(a, b)
ans = 0
j = -1
for i in range(min(n, k // a) + 1):
res = k - i * a
#if res < 0:
# break
if res % b == 0:
j = i
break
if j == -1:
print(0)
exit()
for i in range(j, min(n, k // a) + 1, b // d):
res = k - i * a
ans += (comb(n_, i % q, True) * comb(n_, (res // b) % q, True)) % q
print(ans)
```
No
| 95,112 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
def gcd(a,b):
if a > b:
n,m = a,b
else:
n,m = b,a
while m > 0:
t = n % m
n = m
m = t
return n
def gcd_3(a,b,c):
return gcd(gcd(a,b),c)
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
N,A,B,K = map(int,input().split())
g = gcd_3(A,B,K)
A = A // g
B = B // g
K = K // g
mod = 998244353 #出力の制限
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
n0,m0=-1,-1
for i in range(K//A + 1):
if (K - A*i) % B == 0:
n0,m0 = i, (K - A*i)//B
break
k = 0
while k*B + n0 <= N and m0 - k*A >= 0:
n,m = k*B + n0, m0 - k*A
for green in range(min(n,m)+1):
red = n - green
blue = m - green
if (red + green + blue) * g > N:
continue
ans = (ans + cmb(N,red,mod) * cmb(N-red,blue,mod) * cmb(N-red-blue,green,mod)) % mod
k += 1
print(ans)
```
No
| 95,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 ≤ N ≤ 3×10^5
* 1 ≤ A,B ≤ 3×10^5
* 0 ≤ K ≤ 18×10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
Submitted Solution:
```
import math
S = []
def selectG(key):
for i in range(int(key / g) + 1):
if i > N:
braek
selectR(key - g * i, i)
def selectR(key, G):
for i in range(int(key / r) + 1):
if i + G > N:
break
selectB(key - r * i, G, i)
def selectB(key, G, R):
if key % b == 0:
S.append([G, R, int(key / b)])
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
N, A, B, K = map(int, input().split())
r = A
g = A + B
b = B
if r > b:
r, b = b, r
n = N
selectG(K)
count = 0
cnt = 1
for i in S:
for j in i:
cnt *= combinations_count(n, j)
n -= j
n = N
count += cnt
cnt = 1
print(count % 998244353)
```
No
| 95,114 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
import sys
readline = sys.stdin.readline
class Node:
def __init__(self, sigma, depth):
self.end = False
self.child = [None] * sigma
self.depth = depth
def __setitem__(self, i, x):
self.child[i] = x
def __getitem__(self, i):
return self.child[i]
sigma = 2
root = Node(sigma, 0)
def add_trie(S):
vn = root
for cs in S:
if vn[cs] is None:
vn[cs] = Node(sigma, vn.depth + 1)
vn = vn[cs]
vn.end = True
ans = 0
N, L = map(int, readline().split())
for _ in range(N):
S = list(map(int, readline().strip()))
add_trie(S)
cnt = 0
stack = [root]
while stack:
vn = stack.pop()
for i in range(2):
if vn[i] is None:
r = L - vn.depth
cnt ^= -r&r
else:
stack.append(vn[i])
print('Alice' if cnt else 'Bob')
```
| 95,115 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
N, L = map(int, input().split())
make = lambda:[None, None, 0]
root = make()
def construct(s):
n = root
for i in s:
if n[i] is None:
n[i] = n = make()
else:
n = n[i]
n[2] = 1
for i in range(N):
s = map(int, input())
construct(s)
caps = {}
st = [(root, 0, 0)]
while st:
n, i, l = st.pop()
if i:
if n[1] is None:
caps[L - l] = caps.get(L - l, 0) + 1
else:
if not n[1][2]:
st.append((n[1], 0, l+1))
else:
st.append((n, 1, l))
if n[0] is None:
caps[L - l] = caps.get(L - l, 0) + 1
else:
if not n[0][2]:
st.append((n[0], 0, l+1))
ans = 0
for v in caps:
k = caps[v]
if k % 2 == 0:
continue
v -= 1
r = 1
while v % 4 == 3:
v //= 4
r *= 4
if v % 4 == 1:
ans ^= r * 2
else:
ans ^= r
print('Alice' if ans else 'Bob')
```
| 95,116 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
from collections import defaultdict
def solve(l, ss):
xor = 0
for d in range(min(ss), l + 1):
sl = ss[d]
sl.sort()
while sl:
s = sl.pop()
ps = s[:-1]
ss[d + 1].append(ps)
if s[-1] == '1' and sl and sl[-1][:-1] == ps:
sl.pop()
else:
xor ^= d & -d
del ss[d]
return xor
n, l = map(int, input().split())
ss = defaultdict(list)
for s in (input() for _ in range(n)):
ss[l - len(s) + 1].append(s)
print('Alice' if solve(l, ss) else 'Bob')
```
| 95,117 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
import sys
sys.setrecursionlimit(100000)
def dfs(cur, dep=0):
if cur == -1:
x = l - dep
return x & -x
return dfs(trie[cur][0], dep + 1) ^ dfs(trie[cur][1], dep + 1)
n, l = map(int, input().split())
trie = [[-1, -1] for _ in range(100001)]
idx = 1
for s in (input() for _ in range(n)):
cur = 0
for c in map(int, s):
if trie[cur][c] == -1:
trie[cur][c] = idx
idx += 1
cur = trie[cur][c]
xor = dfs(trie[0][0]) ^ dfs(trie[0][1])
print('Alice' if xor else 'Bob')
```
| 95,118 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
import sys
#from collections import defaultdict
sys.setrecursionlimit(10**6)
def input():
return sys.stdin.readline()[:-1]
n, l = map(int, input().split())
ss = [list(input())[::-1] for _ in range(n)]
def addTree(tree, sentence):
if not sentence:
return None
if sentence[-1] not in tree:
tree[sentence[-1]] = {}
p = sentence.pop()
tree[p] = addTree(tree[p], sentence)
return tree
def createTree(sentences):
tree = {}
for sentence in sentences:
tree = addTree(tree, sentence)
return tree
tree = createTree(ss)
#print(tree)
grundy = 0
def dfs(cur, level):
global grundy
if cur is None:
return
elif len(cur) == 1:
grundy ^= (l-level) & (-l+level)
for k in cur.keys():
dfs(cur[k], level+1)
return
dfs(tree, 0)
if grundy == 0:
print("Bob")
else:
print("Alice")
```
| 95,119 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
import sys
sys.setrecursionlimit(1000000)
def getGrundyNumber(x):
ans = 1
while x % (ans * 2) == 0:
ans *= 2
return ans
def dfs(iT, Hgt):
num = 0
for c in Trie[iT]:
if c != -1:
dfs(c, Hgt - 1)
num += 1
if num == 1:
Hgts[Hgt - 1] = Hgts.get(Hgt - 1, 0) + 1
N, L = map(int, input().split())
Ss = [input() for i in range(N)]
# トライ木を作成する
Trie = [[-1, -1]]
for S in Ss:
iT = 0
for c in map(int, S):
if Trie[iT][c] == -1:
Trie += [[-1, -1]]
Trie[iT][c] = len(Trie) - 1
iT = Trie[iT][c]
# 子が１つの頂点を探す
Hgts = {}
dfs(0, L + 1)
# Grundy数のXORを求める
ans = 0
for Hgt, num in Hgts.items():
if num % 2:
ans ^= getGrundyNumber(Hgt)
if ans:
print('Alice')
else:
print('Bob')
```
| 95,120 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
def main():
import sys
input = sys.stdin.readline
class TreiNode:
def __init__(self, char_num, depth):
self.end = False
self.child = [None] * char_num
self.depth = depth
def __setitem__(self, i, x):
self.child[i] = x
def __getitem__(self, i):
return self.child[i]
class Trei:
def __init__(self, char_num):
self.root = TreiNode(char_num, 0)
self.char_num = char_num
def add(self, S):
v = self.root
for s in S:
if v[s] is None:
v[s] = TreiNode(self.char_num, v.depth + 1)
v = v[s]
v.end = True
def exist(self, S):
v = self.root
for s in S:
if v[s] is None:
return False
v = v[s]
if v.end:
return True
else:
return False
N, L = map(int, input().split())
T = Trei(2)
for _ in range(N):
S = input().rstrip('\n')
S = [int(s) for s in S]
T.add(S)
g = 0
st = [T.root]
while st:
v = st.pop()
for i in range(2):
if v[i] is None:
d = L - v.depth
g ^= d & -d
else:
st.append(v[i])
if g:
print('Alice')
else:
print('Bob')
if __name__ == '__main__':
main()
```
| 95,121 |
Provide a correct Python 3 solution for this coding contest problem.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
"Correct Solution:
```
import sys
from collections import deque
sys.setrecursionlimit(10000)
INF = float('inf')
N, L = list(map(int, input().split()))
S = set()
for _ in range(N):
S.add(input())
# 追加できるのが 01... だけで
# L が 4 とすると
# 01: 次はない
# 010: 011 がある
# 011: 010 がある
# 0100: 011, 0101 がある
# 0101: 011, 0100
# 0110: 010, 0111
# 0111: 010, 0110
# 候補の長さと L だけによって次の候補の長さと数が決まる
def grundy(size):
"""
:param int size: 候補の長さ
:return:
"""
# gs = {0}
# g = 0
# for sz in range(size + 1, L + 1):
# g ^= grundy(sz)
# gs.add(g)
#
# i = 0
# while i in gs:
# i += 1
# return i
i = 1
while (L - size + 1) % i == 0:
i *= 2
return i // 2
# S の各要素からトライ木つくる
trie = {}
for s in S:
t = trie
for c in s:
if c not in t:
t[c] = {}
t = t[c]
# 候補文字列の長さのリスト
ok_size_list = []
children = deque()
children.append((trie, 0))
while len(children) > 0:
node, size = children.popleft()
# 0 か 1 か片方しか行けなかったら、行けない方は S の prefix にならない
# 両方行けない場合はどう追加しても S のいずれかが prefix になってしまうからダメ
if len(node) == 1:
ok_size_list.append(size + 1)
for c, child in node.items():
children.append((child, size + 1))
g = 0
for size in ok_size_list:
g ^= grundy(size)
if g != 0:
print('Alice')
else:
print('Bob')
```
| 95,122 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
import sys
readline = sys.stdin.readline
class Node:
def __init__(self, sigma, depth):
self.end = False
self.child = [None] * sigma
self.depth = depth
def __setitem__(self, i, x):
self.child[i] = x
def __getitem__(self, i):
return self.child[i]
class Trie():
def __init__(self, sigma):
self.sigma = sigma
self.root = Node(sigma, 0)
def add(self, S):
vn = self.root
for cs in S:
if vn[cs] is None:
vn[cs] = Node(self.sigma, vn.depth + 1)
vn = vn[cs]
vn.end = True
ans = 0
N, L = map(int, readline().split())
Tr = Trie(2)
for _ in range(N):
S = list(map(int, readline().strip()))
Tr.add(S)
cnt = 0
stack = [Tr.root]
while stack:
vn = stack.pop()
for i in range(2):
if vn[i] is None:
r = L - vn.depth
cnt ^= -r&r
else:
stack.append(vn[i])
print('Alice' if cnt else 'Bob')
```
Yes
| 95,123 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
import sys
sys.setrecursionlimit(2 * 10 ** 5)
class TrieNode:
def __init__(self, char):
self.char = char
self.nextnode = dict()
self.is_indict = False
class Trie:
def __init__(self, charset):
self.charset = charset
self.root = TrieNode('')
def add(self, a_str):
node = self.root
for i, char in enumerate(a_str):
if char not in node.nextnode:
node.nextnode[char] = TrieNode(char)
node = node.nextnode[char]
if i == len(a_str) - 1:
node.is_indict = True
def dfs(self, node, dep):
ret, cnt = 0, 0
if node.is_indict:
return 0
for s in '01':
if s not in node.nextnode:
cnt += 1
else:
ret ^= self.dfs(node.nextnode[s], dep + 1)
height = L - dep
if cnt % 2:
power2 = 0
while height > 0 and height % 2 == 0:
power2 += 1
height //= 2
ret ^= 2 ** power2
return ret
def debug_output(self, node, now):
print(node.char, list(node.nextnode.items()), node.is_indict, now)
if node.is_indict:
print(now)
for n in node.nextnode.values():
self.debug_output(n, now + n.char)
N, L = map(int, input().split())
T = Trie('01')
for _ in range(N):
T.add(input())
# T.debug_output(T.root, '')
print("Alice" if T.dfs(T.root, 0) else "Bob")
```
Yes
| 95,124 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
from functools import cmp_to_key
def f(s, t):
m = min(len(s), len(t))
if s[:m] > t[:m]:
return 1
elif s[:m] < t[:m]:
return -1
else:
if len(s) > len(t):
return -1
else:
return 1
def ms(s, t):
i = 0
for c1, c2 in zip(s, t):
if c1 != c2:
return i
i += 1
return i
def xxor(x):
if x & 3 == 0:
return x
if x & 3 == 1:
return 1
if x & 3 == 2:
return x + 1
if x & 3 == 3:
return 0
def gray(x):
return x ^ (x // 2)
n, l = map(int, input().split())
s = [input() for _ in range(n)]
s.sort(key=cmp_to_key(f))
g = gray(l) ^ gray(l - len(s[0]))
for i in range(n - 1):
b = ms(s[i], s[i + 1]) + 1
g ^= gray(l - b + 1) ^ gray(l - b)
t = len(s[i + 1]) - b
g ^= gray(l - b) ^ gray(l - b - t)
if g == 0:
print('Bob')
else:
print('Alice')
```
Yes
| 95,125 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**9)
from collections import deque
class Node:
def __init__(self,depth):
self.depth=depth
self.left=None
self.right=None
def insert(node,s):
n=node
for i in range(len(s)):
t=s[i]
if t=='0':
if n.left is None:
n.left=Node(i+1)
n=n.left
else:
if n.right is None:
n.right=Node(i+1)
n=n.right
class Trie:
def __init__(self):
self.root=Node(0)
def insert(self,s:str):
insert(self.root,s)
n,l=map(int,input().split())
S=[input().strip() for _ in range(n)]
trie=Trie()
for s in S:
trie.insert(s)
Data=[]
q=deque([trie.root])
def dfs(node):
if node.right is None and node.left is None:
return
if node.right is None or node.left is None:
Data.append(l-node.depth)
if node.right:
q.append(node.right)
if node.left:
q.append(node.left)
while q:
dfs(q.popleft())
xor=0
def Grundy(n):
ret=1
while n%2==0:
n//=2
ret*=2
return ret
for i in Data:
xor^=Grundy(i)
print('Alice' if xor else 'Bob')
```
Yes
| 95,126 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
from collections import defaultdict
n, l = map(int, input().split())
nums = defaultdict(set)
for s in (input() for _ in range(n)):
nums[l - len(s) + 1].add(int(s, 2) + (1 << len(s)))
xor = 0
for i in range(min(nums), l + 1):
ni = nums[i]
for k in ni:
if k ^ 1 not in ni:
xor ^= i & -i
nums[i + 1].add(k // 2)
del nums[i]
print('Alice' if xor else 'Bob')
```
No
| 95,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
import sys
sys.setrecursionlimit(2 * 10 ** 5)
class TrieNode:
def __init__(self, char):
self.char = char
self.nextnode = dict()
self.is_indict = False
class Trie:
def __init__(self, charset):
self.charset = charset
self.root = TrieNode('')
def add(self, a_str):
node = self.root
for i, char in enumerate(a_str):
if char not in node.nextnode:
node.nextnode[char] = TrieNode(char)
node = node.nextnode[char]
if i == len(a_str) - 1:
node.is_indict = True
def dfs(self, node, dep):
ret, cnt = 0, 0
for s in '01':
if s not in node.nextnode:
cnt += 1
else:
ret ^= self.dfs(node.nextnode[s], dep + 1)
dep += 1
if cnt % 2:
power2 = 0
while dep > 0 and dep % 2 == 0:
power2 += 1
dep //= 2
ret ^= 2 ** power2
return ret
def debug_output(self, node, now):
print(node.char, list(node.nextnode.items()), node.is_indict, now)
if node.is_indict:
print(now)
for n in node.nextnode.values():
self.debug_output(n, now + n.char)
N, L = map(int, input().split())
T = Trie('01')
for _ in range(N):
T.add(input())
# T.debug_output(T.root, '')
print("Alice" if T.dfs(T.root, 0) else "Bob")
```
No
| 95,128 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
n,l = map(int,input().split())
s = [input() for _ in range(n)]
s2 = [(len(si),si) for si in s]
s2.sort()
max_d = s2[-1][0]
cnt = [0] * (max_d+1)
done = set()
stack = []
for i in range(max_d,-1,-1):
next = set()
while(stack):
sj = stack.pop()
if(not (sj + '0') in done):
cnt[max_d-len(sj)] += 1
if(not (sj + '1') in done):
cnt[max_d-len(sj)] += 1
if(len(sj)>0):
next.add(sj[:-1])
done.add(sj)
if(s2):
while(s2[-1][0] == i):
_,sj = s2.pop()
if(len(sj)>0):
next.add(sj[:-1])
done.add(sj)
if(len(s2)==0):
break
stack = list(next)
cnt_odd = 0
bef = cnt[0]
for ci in cnt[1:]:
ci %= 2
if(bef==0)&(ci==1):
cnt_odd += 1
bef = ci
if(cnt_odd%2==0):
print('Bob')
else:
print('Alice')
```
No
| 95,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
* Each string in S has a length between 1 and L (inclusive) and consists of the characters `0` and `1`.
* Any two distinct strings in S are prefix-free.
We have a good string set S = \\{ s_1, s_2, ..., s_N \\}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
* Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^{18}
* s_1, s_2, ..., s_N are all distinct.
* { s_1, s_2, ..., s_N } is a good string set.
* |s_1| + |s_2| + ... + |s_N| \leq 10^5
Input
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
Output
If Alice will win, print `Alice`; if Bob will win, print `Bob`.
Examples
Input
2 2
00
01
Output
Alice
Input
2 2
00
11
Output
Bob
Input
3 3
0
10
110
Output
Alice
Input
2 1
0
1
Output
Bob
Input
1 2
11
Output
Alice
Input
2 3
101
11
Output
Bob
Submitted Solution:
```
def main():
import sys
from collections import defaultdict
input = sys.stdin.readline
mod = 10**9+7
mod2 = 10**9+9
mod3 = 998244353
N, L = map(int, input().split())
dic = defaultdict(int)
dic2 = defaultdict(int)
dic3 = defaultdict(int)
h_list = []
h2_list = []
h3_list = []
pair = {}
pair2 = {}
pair3 = {}
M = 0
for _ in range(N):
s = input().rstrip('\n')
h = 0
h2 = 0
h3 = 0
for i in range(len(s)):
M += 1
h = (h*1007 + int(s[i]) + 1) % mod
pair[h] = (h + 1)%mod if s[i] == '0' else (h-1)%mod
h2 = (h2 * 2009 + int(s[i]) + 1) % mod2
pair2[h2] = (h2 + 1)%mod2 if s[i] == '0' else (h2-1)%mod2
h3 = (h3 * 3001 + int(s[i]) + 1) % mod3
pair3[h3] = (h3 + 1) % mod3 if s[i] == '0' else (h3 - 1) % mod3
dic[h] = i+1
dic2[h2] = i+1
dic[h3] = i+1
h_list.append(h)
h2_list.append(h2)
h3_list.append(h3)
g = 0
seen = defaultdict(int)
seen2 = defaultdict(int)
seen3 = defaultdict(int)
for i in range(M):
s, s2, s3 = h_list[i], h2_list[i], h3_list[i]
if seen[s] and seen2[s2] and seen3[s3]:
continue
t = pair[s]
t2 = pair2[s2]
t3 = pair3[s3]
if not (dic[t] and dic2[t2] and dic3[t3]):
if not seen[s]:
tmp = L - dic[s] + 1
elif not seen[s2]:
tmp = L - dic2[s2] + 1
else:
tmp = L - dic3[s3] + 1
cnt = 0
while tmp % 2 == 0:
tmp //= 2
cnt += 1
g ^= (2**cnt)
#print(g, s, s2, t, t2, dic[t], dic2[t2])
seen[s] = 1
seen2[s2] = 1
seen3[s3] = 1
if g:
print('Alice')
else:
print('Bob')
if __name__ == '__main__':
main()
```
No
| 95,130 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
from heapq import*
X,Y,Z=map(int,input().split());N=X+Y+Z;A=[];p=[];q=[];L=[0];R=[0]
for _ in[0]*N:A.append([int(e)for e in input().split()])
A.sort(key=lambda a:a[0]-a[1])
for i in range(N):
L+=[L[i]+A[i][1]];heappush(p,A[i][1]-A[i][2]);R+=[R[i]+A[-1-i][0]];heappush(q,A[~i][0]-A[~i][2])
if i>=Y:L[i+1]-=heappop(p)
if i>=X:R[i+1]-=heappop(q)
print(max(L[i]+R[~i]for i in range(Y,N-X+1)))
```
| 95,131 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
import heapq
if __name__ == '__main__':
X, Y, Z = list(map(int, input().split()))
A = []
B = []
C = []
N = X + Y + Z
for i in range(N):
tmp_a, tmp_b, tmp_c = list(map(int, input().split()))
A.append(tmp_a)
B.append(tmp_b)
C.append(tmp_c)
gold_minus_silver = [(a - b, a, b, c) for (a, b, c) in zip(A, B, C)]
gold_minus_silver.sort()
# print(gold_minus_silver)
# 左側
left_side = []
for i in range(0, Y):
heapq.heappush(left_side, (
gold_minus_silver[i][2] - gold_minus_silver[i][3], gold_minus_silver[i][2], gold_minus_silver[i][3]))
left_max = [0 for i in range(Z + 1)]
for i in range(0, Y):
left_max[0] += left_side[i][1]
left_bronze = []
for K in range(1, Z + 1):
heapq.heappush(left_side, (gold_minus_silver[K + Y - 1][2] - gold_minus_silver[K + Y - 1][3],
gold_minus_silver[K + Y - 1][2],
gold_minus_silver[K + Y - 1][3]))
left_max[K] = left_max[K - 1] + gold_minus_silver[K + Y - 1][2]
bronze = heapq.heappop(left_side)
left_max[K] += (bronze[2] - bronze[1])
# print(left_max)
# 右側
right_side = []
for i in range(Y + Z, N):
heapq.heappush(right_side, (gold_minus_silver[i][1] - gold_minus_silver[i][3], gold_minus_silver[i][1],
gold_minus_silver[i][3]))
right_max = [0 for i in range(Z + 1)]
for i in range(0, X):
right_max[Z] += right_side[i][1]
right_bronze = []
for K in range(Z - 1, -1, -1):
heapq.heappush(right_side, (gold_minus_silver[K + Y][1] - gold_minus_silver[K + Y][3],
gold_minus_silver[K + Y][1],
gold_minus_silver[K + Y][3]))
right_max[K] = right_max[K + 1] + gold_minus_silver[K + Y][1]
bronze = heapq.heappop(right_side)
right_max[K] += (bronze[2] - bronze[1])
# print(right_max)
ans = 0
for i in range(0, Z + 1):
if ans < left_max[i] + right_max[i]:
ans = left_max[i] + right_max[i]
print(ans)
```
| 95,132 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
import sys
from heapq import heappush, heappushpop
X, Y, Z = map(int, input().split())
xyz = sorted([list(map(int,l.split()))for l in sys.stdin],key=lambda x:x[0]-x[1])
uq = []
cy = 0
for x, y, z in xyz[:Y]:
heappush(uq, y - z)
cy += y
Ly = [cy]
for x, y, z in xyz[Y:Y+Z]:
cy += y - heappushpop(uq, y - z)
Ly += [cy]
lq = []
cx = 0
for x, y, z in xyz[-X:]:
heappush(lq, x - z)
cx += x
Lx = [cx]
for x, y, z in xyz[Y+Z-1:Y-1:-1]:
cx += x - heappushpop(lq, x - z)
Lx += [cx]
print(max(map(sum, zip(Lx, Ly[::-1]))))
```
| 95,133 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
from heapq import*;X,Y,Z=map(int,input().split());N=X+Y+Z;A=[];q1=[];q2=[];L=[0];R=[0]
for _ in[0]*N:A.append([int(e)for e in input().split()])
A.sort(key=lambda a:a[0]-a[1])
for i in range(N):
L+=[L[i]+A[i][1]];heappush(q1,A[i][1]-A[i][2]);R+=[R[i]+A[-1-i][0]];heappush(q2,A[~i][0]-A[~i][2])
if i>=Y:L[i+1]-=heappop(q1)
if i>=X:R[i+1]-=heappop(q2)
print(max(L[i]+R[~i]for i in range(Y,N-X+1)))
```
| 95,134 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
from heapq import*
X,Y,Z=map(int,input().split());N=X+Y+Z;A=[];q1=[];q2=[];L=[0];R=[0]
for _ in[0]*N:A.append([int(e)for e in input().split()])
A.sort(key=lambda a:a[0]-a[1])
for i in range(N):
L+=[L[i]+A[i][1]];heappush(q1,A[i][1]-A[i][2]);R+=[R[i]+A[-1-i][0]];heappush(q2,A[~i][0]-A[~i][2])
if i>=Y:L[i+1]-=heappop(q1)
if i>=X:R[i+1]-=heappop(q2)
print(max(L[i]+R[~i]for i in range(Y,N-X+1)))
```
| 95,135 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
import heapq
X,Y,Z = map(int,input().split())
N = X+Y+Z
src = [tuple(map(int,input().split())) for i in range(N)]
src.sort(key=lambda x:x[0]-x[1])
l_opt = [0]*(N+1)
r_opt = [0]*(N+1)
silver = bronze = 0
q_sb = []
heapq.heapify(q_sb)
for i,(g,s,b) in enumerate(src):
heapq.heappush(q_sb, (s-b, s, b))
silver += s
if i >= Y:
_, s2, b2 = heapq.heappop(q_sb)
silver -= s2
bronze += b2
l_opt[i+1] = silver + bronze
gold = bronze = 0
q_gb = []
heapq.heapify(q_gb)
for i,(g,s,b) in enumerate(reversed(src)):
heapq.heappush(q_gb, (g-b, g, b))
gold += g
if i >= X:
_, g2, b2 = heapq.heappop(q_gb)
gold -= g2
bronze += b2
r_opt[N-1-i] = gold + bronze
ans = 0
for l,r in list(zip(l_opt, r_opt))[Y:Y+Z+1]:
ans = max(ans, l+r)
print(ans)
```
| 95,136 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
from heapq import heapify, heappushpop
from itertools import accumulate
X, Y, Z, *ABC = map(int, open(0).read().split())
P = sorted(zip(*[iter(ABC)] * 3), key=lambda t: t[0] - t[1])
G = sum(t[0] for t in P[-X:])
S = sum(t[1] for t in P[:Y])
C = sum(t[2] for t in P[Y:-X])
Qg = [a - c for a, b, c in P[-X:]]
heapify(Qg)
B = [0] + [a - c - heappushpop(Qg, a - c) for a, b, c in reversed(P[Y:-X])]
Qs = [b - c for a, b, c in P[:Y]]
heapify(Qs)
F = [0] + [b - c - heappushpop(Qs, b - c) for a, b, c in P[Y:-X]]
print(G + S + C + max(a + b for a, b in zip(accumulate(F), reversed(list(accumulate(B))))))
```
| 95,137 |
Provide a correct Python 3 solution for this coding contest problem.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
"Correct Solution:
```
X, Y, Z = map(int, input().split())
ans = 0
BC = []
for _ in range(X+Y+Z):
a, b, c = map(int, input().split())
ans += a
BC.append([b-a, c-a])
BC.sort(key=lambda x: x[1]-x[0])
import heapq
q = []
an = 0
for b, _ in BC[:Y]:
heapq.heappush(q, b)
an += b
A = [an]
for b, _ in BC[Y:-Z]:
heapq.heappush(q, b)
an += b
b_ = heapq.heappop(q)
an -= b_
A.append(an)
q = []
an = 0
for _, c in BC[-Z:]:
heapq.heappush(q, c)
an += c
A[-1] += an
for i, (_, c) in enumerate(BC[-Z-1:Y-1:-1], 2):
heapq.heappush(q, c)
an += c
c_ = heapq.heappop(q)
an -= c_
A[-i] += an
print(ans + max(A))
```
| 95,138 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
import heapq,sys
input=sys.stdin.readline
X,Y,Z=map(int,input().split())
N=X+Y+Z
coin=[tuple(map(int,input().split())) for i in range(N)]
coin.sort(key=lambda x:x[0]-x[1])
y=[0]*N
S=0
n=0
que=[]
for i in range(N):
val=coin[i][1]-coin[i][2]
if Y>n:
heapq.heappush(que,val)
S+=val
n+=1
y[i]=S
else:
if que[0]<val:
S+=val-que[0]
heapq.heappop(que)
heapq.heappush(que,val)
y[i]=S
x=[0]*N
S=0
n=0
que=[]
for i in range(N-1,-1,-1):
val=coin[i][0]-coin[i][2]
if X>n:
heapq.heappush(que,val)
S+=val
n+=1
x[i]=S
else:
if que[0]<val:
S+=val-que[0]
heapq.heappop(que)
heapq.heappush(que,val)
x[i]=S
base=sum(coin[i][2] for i in range(N))
ans=-1
for i in range(N):
if i>=Y-1 and N-(i+1)>=X:
temp=base+x[i+1]+y[i]
ans=max(ans,temp)
print(ans)
```
Yes
| 95,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
import heapq
x, y, z = [int(item) for item in input().split()]
gsb = []
for i in range(x + y + z):
gsb.append([int(item) for item in input().split()])
gsb.sort(key=lambda x: x[0] - x[1], reverse=True)
g_sum = sum(item[0] for item in gsb[:x])
s_sum = sum(item[1] for item in gsb[x+z:x+y+z])
b_sum = sum(item[2] for item in gsb[x:x+z])
gb_pq = [a - c for a, b, c in gsb[:x]]
sb_pq = [b - c for a, b, c in gsb[x+z:x+y+z]]
heapq.heapify(gb_pq)
heapq.heapify(sb_pq)
ans_gb = [0]
gb_total_delta = 0
for a, b, c in gsb[x:x+z]:
new_gb = a - c
small_gb = heapq.heappushpop(gb_pq, new_gb)
gb_total_delta += new_gb - small_gb
ans_gb.append(gb_total_delta)
ans_sb = [0]
sb_total_delta = 0
for a, b, c in gsb[x:x+z][::-1]:
new_sb = b - c
small_sb = heapq.heappushpop(sb_pq, new_sb)
sb_total_delta += new_sb - small_sb
ans_sb.append(sb_total_delta)
ans_sb.reverse()
max_delta = 0
for gb, sb in zip(ans_gb, ans_sb):
max_delta = max(max_delta, gb + sb)
print(g_sum + s_sum + b_sum + max_delta)
```
Yes
| 95,140 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
import sys
input = sys.stdin.readline
from heapq import heappush, heappushpop
"""
銅貨の集合を固定すると、金-銀でソートして貪欲に金をとることになる
逆に金-銀でソートしておくと、金が埋まるまでは金or銅の2択
最後にとる金の番号X+nをfix → 手前は金-銅で貪欲 → queueで管理できる
"""
X,Y,Z = map(int,input().split())
ABC = [[int(x) for x in input().split()] for _ in range(X+Y+Z)]
ABC.sort(key = lambda x: x[0]-x[1],reverse=True)
q = []
sum_a = 0
sum_c = 0
for a,b,c in ABC[:X]:
# 金を入れる。銅-金の優先度
heappush(q,(a-c,a))
sum_a += a
A = [0] * (Z+1)
LC = [0] * (Z+1)
A[0] = sum_a
for i,(a,b,c) in enumerate(ABC[X:X+Z],1):
sum_a += a
x,del_a = heappushpop(q,(a-c,a))
sum_a -= del_a
sum_c += del_a-x
A[i] = sum_a
LC[i] = sum_c
ABC_rev = ABC[::-1]
q = []
sum_b = 0
sum_c = 0
for a,b,c in ABC_rev[:Y]:
heappush(q,(b-c,b))
sum_b += b
B = [0] * (Z+1)
RC = [0] * (Z+1)
B[0] += sum_b
for i,(a,b,c) in enumerate(ABC_rev[Y:Y+Z],1):
sum_b += b
x,del_b = heappushpop(q,(b-c,b))
sum_b -= del_b
sum_c += del_b-x
B[i] = sum_b
RC[i] = sum_c
answer = max(sum(x) for x in zip(A,LC,B[::-1],RC[::-1]))
print(answer)
```
Yes
| 95,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
from heapq import heappushpop
import sys
X, Y, Z = map(int, sys.stdin.readline().split())
N = X+Y+Z
ABC = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
ABC.sort(key = lambda x: x[0] - x[1], reverse = True)
GB = [None]*N
Q = [a - c for a, _, c in ABC[:X]]
Q.sort()
gs = sum(a for a, _, _ in ABC[:X])
GB[X-1] = gs
for i, (a, b, c) in enumerate(ABC[X:X+Z], X):
gs += - heappushpop(Q, a - c) + a
GB[i] = gs
SB = [None]*N
Q = [b - c for _, b, c in ABC[X+Z:]]
Q.sort()
ss = sum(b for _, b, _ in ABC[X+Z:])
SB[-Y-1] = ss
for i, (a, b, c) in enumerate(ABC[X+Z-1:X-1:-1], 1):
i = -Y - i
ss += - heappushpop(Q, b - c) + b
SB[i-1] = ss
print(max(i + j for i, j in zip(GB[X-1:X+Z], SB[X-1:X+Z])))
```
Yes
| 95,142 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
# encoding:utf-8
def main():
N, K = list(map(int, input().split()))
nums = list(map(int, input().split()))
max_num = max(nums)
min_num = min(nums)
# 最大値が越えてたらだめ
if K > max_num:
return("IMPOSSIBLE")
decomp_min = decomp(min_num)
for x in decomp_min:
res = [y % x for y in nums]
# 共通因子を持ってなかったらだめ
if max(res) == min(res):
if K % min_num > 0:
return("IMPOSSIBLE")
else:
return("POSSIBLE")
def decomp(n):
i = 2
table = [n]
while i * i <= n:
if n % i == 0:
table.append(int(i))
i += 1
return(table)
if __name__ == '__main__':
print(main())
```
No
| 95,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
import heapq
x, y, z = [int(item) for item in input().split()]
gsb = []
for i in range(x + y + z):
gsb.append([int(item) for item in input().split()])
gsb.sort(key=lambda x: x[0] - x[1], reverse=True)
g_sum = sum(item[0] for item in gsb[:x])
s_sum = sum(item[1] for item in gsb[x+z:x+y+z])
b_sum = sum(item[2] for item in gsb[x:x+z])
gb_pq = [a - c for a, b, c in gsb[:x]]
sb_pq = [b - c for a, b, c in gsb[x+z:x+y+z]]
heapq.heapify(gb_pq)
heapq.heapify(sb_pq)
ans_gb = [0]
gb_total_delta = 0
for a, b, c in gsb[x:x+z]:
new_gb = a - c
small_gb = heapq.heappushpop(gb_pq, new_gb)
gb_total_delta += new_gb - small_gb
ans_gb.append(gb_total_delta)
ans_sb = [0]
sb_total_delta = 0
for a, b, c in gsb[x:x+z][::-1]:
new_sb = b - c
small_sb = heapq.heappushpop(sb_pq, new_sb)
sb_total_delta = new_sb - small_sb
ans_sb.append(sb_total_delta)
ans_sb.reverse()
max_delta = 0
for gb, sb in zip(ans_gb, ans_sb):
max_delta = max(max_delta, gb + sb)
print(g_sum + s_sum + b_sum + max_delta)
```
No
| 95,144 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
X, Y, Z = map(int, input().split())
N = X + Y + Z
a = []
a_ordered = []
for _ in range(N):
a_i = list(map(int, input().split()))
a.append(a_i)
a_ordered.append((a_i[0] - a_i[1], a_i[0], a_i[1], a_i[2]))
a_ordered.sort(key=lambda x: x[0])
max_value = 0
for k in range(Y, N - X):
a_left = a_ordered[:k]
a_left_ordered = []
for i, v in enumerate(a_left):
a_left_ordered.append((v[2] - v[3], v[2], v[3]))
a_left_ordered.sort(key=lambda x: x[0])
left_value = 0
for i, v in enumerate(a_left_ordered):
if i < k - Y:
left_value += v[2]
else:
left_value += v[1]
a_right = a_ordered[k:N]
a_right_ordered = []
for i, v in enumerate(a_right):
a_right_ordered.append((v[1] - v[3], v[1], v[3]))
a_right_ordered.sort(key=lambda x: x[0])
right_value = 0
for i, v in enumerate(a_right_ordered):
if i < N - k - X:
right_value += v[2]
else:
right_value += v[1]
total_value = left_value + right_value
#print(total_value)
if max_value < total_value:
max_value = total_value
print(max_value)
```
No
| 95,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are X+Y+Z people, conveniently numbered 1 through X+Y+Z. Person i has A_i gold coins, B_i silver coins and C_i bronze coins.
Snuke is thinking of getting gold coins from X of those people, silver coins from Y of the people and bronze coins from Z of the people. It is not possible to get two or more different colors of coins from a single person. On the other hand, a person will give all of his/her coins of the color specified by Snuke.
Snuke would like to maximize the total number of coins of all colors he gets. Find the maximum possible number of coins.
Constraints
* 1 \leq X
* 1 \leq Y
* 1 \leq Z
* X+Y+Z \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* 1 \leq C_i \leq 10^9
Input
Input is given from Standard Input in the following format:
X Y Z
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{X+Y+Z} B_{X+Y+Z} C_{X+Y+Z}
Output
Print the maximum possible total number of coins of all colors he gets.
Examples
Input
1 2 1
2 4 4
3 2 1
7 6 7
5 2 3
Output
18
Input
3 3 2
16 17 1
2 7 5
2 16 12
17 7 7
13 2 10
12 18 3
16 15 19
5 6 2
Output
110
Input
6 2 4
33189 87907 277349742
71616 46764 575306520
8801 53151 327161251
58589 4337 796697686
66854 17565 289910583
50598 35195 478112689
13919 88414 103962455
7953 69657 699253752
44255 98144 468443709
2332 42580 752437097
39752 19060 845062869
60126 74101 382963164
Output
3093929975
Submitted Solution:
```
import math
def sum_coin(a,b):
#転置して該当列を合算
temp1 = list(map(list, zip(*a)))
temp2 = list(map(list, zip(*b)))
coins = sum(temp1[2][:Y]) + sum(temp1[3][Y:]) + sum(temp2[3][:(-X)]) + sum(temp2[1][(-X):])
return coins
###入力###
input1 = input("").split(" ")
X = int(input1[0])
Y = int(input1[1])
Z = int(input1[2])
N = X + Y + Z
temp = [ input() for _ in range(N) ]
matrix = [None]*N
for i in range(N):
a = int(temp[i].split(" ")[0])
b = int(temp[i].split(" ")[1])
c = int(temp[i].split(" ")[2])
matrix[i] = [i, a, b, c, (a-b), (b-c), (c-a)]
###処理###
matrix.sort(key=lambda k: k[4]) #(金-銀)で昇順ソート
#print(matrix)
head = sorted(matrix[:Y], key=lambda k: k[5], reverse=True) #(銀-銅)で降順ソート
tail = sorted(matrix[Y:], key=lambda k: k[6], reverse=True) #(銅-金)で降順ソート
#print("head:",head)
#print("tail:",tail)
result = sum_coin(head, tail)
#print("coins",result)
# Y<=k<=(N-X)の中でコイン最大値を求める
for k in range(Y,N-X):
#print("k",k)
#headにmatrix[Y+1]を追加
if head[0][5] < matrix[k][5]:
p = 0
elif head[-1][5] > matrix[k][5]:
p = len(head) - 1
else:
#二分探索
start = 0
last = len(head) - 1
p = last
while (last-start) > 1:
j = math.ceil((start+last)/2)
#print("j",j)
if head[j][5] < matrix[k][5] :
last = j
elif head[j][5] > matrix[k][5]:
start = j
else:
p = j
break
p = last
head.insert(p,matrix[k])
#tailからmatrix[Y+1]を削除
tail.pop(tail.index(matrix[k]))
#print("head:",head)
#print("tail:",tail)
coins = sum_coin(head, tail)
#print("coins",coins)
#暫定１位更新
if result < coins:
result = coins
###出力###
print(result)
```
No
| 95,146 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
graph = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
def check():
stack = [0]
checked = [False]*N
need = [[] for _ in range(N)]
Parent = [-1]*N
while stack:
p = stack.pop()
if p >= 0:
checked[p] = True
stack.append(~p)
for np in graph[p]:
if not checked[np]:
Parent[np] = p
stack.append(np)
else:
p = ~p
if len(need[p]) == 0:
need[Parent[p]].append(A[p])
elif len(need[p]) == 1:
if need[p][0] != A[p]:
return False
need[Parent[p]].append(A[p])
else:
kmax = sum(need[p])
kmin = max(max(need[p]), (kmax+1)//2)
if not kmin <= A[p] <= kmax:
return False
if p == 0 and kmax-2*(kmax-A[p]) != 0:
return False
need[Parent[p]].append(kmax-2*(kmax-A[p]))
return True
print("YES" if check() else "NO")
```
| 95,147 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
def dfs(v, p, aaa):
if len(links[v]) == 1:
return aaa[v]
children = []
for u in links[v]:
if u == p:
continue
result = dfs(u, v, aaa)
if result == -1:
return -1
children.append(result)
if len(children) == 1:
if aaa[v] != children[0]:
return -1
return children[0]
c_sum = sum(children)
c_max = max(children)
o_max = c_sum - c_max
if o_max >= c_max:
max_pairs = c_sum // 2
else:
max_pairs = o_max
min_remain = c_sum - max_pairs
if not min_remain <= aaa[v] <= c_sum:
return -1
return aaa[v] * 2 - c_sum
def solve(n, aaa, links):
if n == 2:
return aaa[0] == aaa[1]
# 葉でない頂点探し
s = 0
while len(links[s]) == 1:
s += 1
return dfs(s, -1, aaa) == 0
n = int(input())
aaa = list(map(int, input().split()))
links = [set() for _ in range(n)]
for line in sys.stdin:
a, b = map(int, line.split())
a -= 1
b -= 1
links[a].add(b)
links[b].add(a)
print('YES' if solve(n, aaa, links) else 'NO')
```
| 95,148 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
N = int(input())
A = list(map(int,input().split()))
AB = [tuple(map(int,input().split())) for i in range(N-1)]
es = [[] for _ in range(N)]
for a,b in AB:
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
r = -1
for i in range(N):
if len(es[i]) > 1:
r = i
break
if r == -1:
assert N==2
print('YES' if A[0]==A[1] else 'NO')
exit()
def dfs(v,p=-1):
if len(es[v]) == 1:
return A[v]
s = mxc = 0
for to in es[v]:
if to==p: continue
c = dfs(to,v)
s += c
mxc = max(mxc,c)
pair = s - A[v]
ret = s - pair*2
if pair < 0 or ret < 0 or (mxc*2 > s and pair > s - mxc):
print('NO')
exit()
return ret
print('YES' if dfs(r)==0 else 'NO')
```
| 95,149 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
N = int(input())
A = [int(x) for x in input().split()]
UV = [[int(x)-1 for x in row.split()] for row in sys.stdin.readlines()]
if N == 2:
x,y = A
answer = 'YES' if x == y else 'NO'
print(answer)
exit()
graph = [[] for _ in range(N)]
for u,v in UV:
graph[u].append(v)
graph[v].append(u)
def dfs(v,parent=None):
x = A[v]
if len(graph[v]) == 1:
return x
s = 0
for w in graph[v]:
if w == parent:
continue
ret = dfs(w,v)
if ret == None:
return None
if x < ret:
return None
s += ret
if 2*x-s > s:
return None
if 2*x < s:
return None
return 2*x-s
v=0
while len(graph[v]) == 1:
v += 1
ret = dfs(v)
bl = (ret == 0)
answer = 'YES' if bl else 'NO'
print(answer)
```
| 95,150 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def readln(ch):
_res = list(map(int,str(input()).split(ch)))
return _res
n = int(input())
a = readln(' ')
e = [set([]) for i in range(0,n+1)]
for i in range(1,n):
s = readln(' ')
e[s[0]].add(s[1])
e[s[1]].add(s[0])
rt = 1
now = n
v = [0 for i in range(0,n+1)]
q = v[:]
q[now] = rt
v[rt] = 1
for i in range(1,n):
s = q[n-i+1]
for p in e[s]:
if v[p] == 0:
v[p] = 1
now = now - 1
q[now] = p
res = 'YES'
up = [0 for i in range(0,n+1)]
for i in range(1,n+1):
k = q[i]
if len(e[k]) == 1:
sum = a[k-1]
else:
sum = a[k-1] * 2
up[k] = sum
for son in e[k]:
up[k] = up[k] - up[son]
if up[son] > a[k-1] and len(e[k]) > 1: res = 'NO'
if up[k] < 0:
res = 'NO'
if len(e[k]) > 1 and up[k] > a[k-1]:
res = 'NO'
if up[rt] != 0 : res = 'NO'
print(res)
```
| 95,151 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
def get_par(tree: list, root: int) -> list:
"""根付き木の頂点それぞれの親を求める"""
n = len(tree)
visited = [False] * n
visited[root] = True
par = [-1] * n
stack = [root]
while stack:
v = stack.pop()
for nxt_v in tree[v]:
if visited[nxt_v]:
continue
visited[nxt_v] = True
stack.append(nxt_v)
par[nxt_v] = v
return par
def topological_sort(tree: list, root) -> list:
"""根付き木をトポロジカルソートする"""
n = len(tree)
visited = [False] * n
visited[root] = True
tp_sorted = [root]
stack = [root]
while stack:
v = stack.pop()
for nxt_v in tree[v]:
if visited[nxt_v]:
continue
visited[nxt_v] = True
stack.append(nxt_v)
tp_sorted.append(nxt_v)
return tp_sorted
n = int(input())
a = list(map(int, input().split()))
edges = [list(map(int, input().split())) for i in range(n - 1)]
tree = [[] for i in range(n)]
for u, v in edges:
u -= 1
v -= 1
tree[u].append(v)
tree[v].append(u)
# rootには葉以外を選ぶ
root = -1
for v in range(n):
if len(tree[v]) != 1:
root = v
break
# 頂点2つのときはrootを葉として選べない
if root == -1:
if a[0] == a[1]:
print("YES")
else:
print("NO")
exit()
par = get_par(tree, root)
tp_sorted = topological_sort(tree, root)
stn_cnt = [[] for _ in range(n)]
# 葉から探索
is_YES = True
for v in tp_sorted[::-1]:
if not stn_cnt[v]:
par_v = par[v]
stn_cnt[par_v].append(a[v])
continue
sum_cnt = sum(stn_cnt[v])
max_cnt = max(stn_cnt[v])
if sum_cnt < a[v]:
is_YES = False
break
cnt1 = 2 * a[v] - sum_cnt
cnt2 = sum_cnt - a[v]
if v == root and cnt1 != 0:
is_YES = False
break
if cnt1 < 0:
is_YES = False
break
if cnt2 < 0 or min(sum_cnt - max_cnt, sum_cnt // 2) < cnt2:
is_YES = False
break
par_v = par[v]
stn_cnt[par_v].append(cnt1)
if is_YES:
print("YES")
else:
print("NO")
```
| 95,152 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
a = list(map(int, input().split()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n-1):
u,v = map(int, input().split())
u -= 1
v -= 1
ns[u].add(v)
ns[v].add(u)
def sub(u, p):
if len(ns[u])==1 and p in ns[u]:
return a[u]
ub = 0
mv = 0
msum = 0
for v in ns[u]:
if p==v:
continue
val = sub(v, u)
if val is None:
return None
mv = max(mv, val)
msum += val
lb = max(mv, msum//2)
if not (lb<=a[u]<=msum):
# print(u,lb, msum, mv)
return None
else:
return a[u] - (msum-a[u])
if n==2:
if a[0]==a[1]:
print("YES")
else:
print("NO")
else:
if len(ns[0])>1:
ans = sub(0, -1)
else:
ans = sub(list(ns[0])[0], -1)
if ans is None or ans!=0:
print("NO")
else:
print("YES")
```
| 95,153 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
"Correct Solution:
```
def examA():
N = I()
A = LI()
ans = "YES"
cur = 0
for a in A:
if a%2==1:
cur +=1
if cur%2==1:
ans = "NO"
print(ans)
return
def examB():
N = I()
A = LI()
ans = "YES"
sumA = sum(A)
oneA = (1+N)*N//2
if sumA%oneA!=0:
ans = "NO"
ope = sumA//oneA
#各Aについて何回始点としたか二分探索
cur = 0
for i in range(N):
now = ope - (A[i]-A[i-1])
if now%N!=0 or now<0:
# print(now,i)
ans = "NO"
break
cur += now//N
if cur!=ope:
ans = "NO"
print(ans)
return
def examC():
N = I()
A = LI()
V = [[]for _ in range(N)]
for i in range(N-1):
a, b = LI()
V[a-1].append(b-1)
V[b-1].append(a-1)
s = -1
for i,v in enumerate(V):
if len(v)>1:
s = i
break
if s==-1:
if A[0]==A[1]:
print("YES")
else:
print("NO")
return
def dfs(s,p):
flag = 1
rep = 0
maxA = 0
for v in V[s]:
if v==p:
continue
cur,next = dfs(v,s)
if maxA<cur:
maxA = cur
rep += cur
flag *= next
if len(V[s])==1:
return A[s],flag
if (rep+1)//2>A[s] or rep<A[s] or maxA>A[s]:
flag = 0
#print(s,rep)
rep -= (rep-A[s])*2
return rep,flag
rep,flag = dfs(s,-1)
if rep!=0:
flag = 0
if flag:
print("YES")
else:
print("NO")
return
from decimal import Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 1<<60
_ep = 10**(-16)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examC()
```
| 95,154 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
A = LI()
graph = [[] for _ in range(n)]
for u, v in LIR(n - 1):
graph[u - 1] += [v - 1]
graph[v - 1] += [u - 1]
if n == 2:
x, y = A
answer = 'YES' if x == y else 'NO'
print(answer)
exit()
def dfs(v, parent=None):
x = A[v]
if len(graph[v]) == 1:
return x
s = 0
for w in graph[v]:
if w == parent:
continue
ret = dfs(w, v)
if ret == None:
return None
if x < ret:
print('NO')
exit()
s += ret
if 2 * x - s > s:
print('NO')
exit()
if 2 * x < s:
print('NO')
exit()
return 2 * x - s
v=0
while len(graph[v]) == 1:
v += 1
if not dfs(v):
print('YES')
else:
print('NO')
```
Yes
| 95,155 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
a = [0] + list(map(int,readline().split()))
data = list(map(int,read().split()))
links = [[] for _ in range(n+1)]
it = iter(data)
for ai,bi in zip(it,it):
links[ai].append(bi)
links[bi].append(ai)
links[0].append(1)
links[1].append(0)
tp = []
parent = [-1] * (n+1)
stack = [0]
while(stack):
i = stack.pop()
for j in links[i]:
if(parent[i]==j):
continue
parent[j] = i
stack.append(j)
tp.append(j)
tp = tp[::-1]
come = [[] for _ in range(n+1)]
for i in tp:
if(len(come[i])==0):
# print(i)
# print(parent[i])
# print(a[i])
# print(come[parent[i]])
# print('--')
come[parent[i]].append(a[i])
continue
up = 2*a[i] - sum(come[i])
if(up < 0)|(max(up,max(come[i])) > a[i]):
print('NO')
exit()
come[parent[i]].append(up)
# print(come)
if(len(come[1]) > 1)&(come[0][0] == 0):
print('YES')
elif(len(come[1]) == 1)&(come[0][0] == a[1]):
print('YES')
else:
print('NO')
```
Yes
| 95,156 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
A = (0, ) + tuple(map(int, readline().split()))
m = map(int, read().split())
G = [[] for _ in range(N + 1)]
for a, b in zip(m, m):
G[a].append(b)
G[b].append(a)
def dfs_order(G, root=1):
parent = [0] * (N + 1)
order = []
stack = [root]
while stack:
x = stack.pop()
order.append(x)
for y in G[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
return parent, order
def main(N, A, G):
if N == 2:
return A[1] == A[2]
degree = [len(x) for x in G]
root = degree.index(max(degree))
parent, order = dfs_order(G, root)
# 上に伸ばすパスの個数
dp = [0] * (N + 1)
for v in order[::-1]:
if degree[v] == 1:
dp[v] = A[v]
continue
p = parent[v]
nums = [dp[w] for w in G[v] if v != p]
x = sum(nums)
y = max(nums)
pair = x - A[v]
if pair < 0 or pair > x - y or pair > x // 2:
return False
dp[v] = x - 2 * pair
return dp[root] == 0
print('YES' if main(N, A, G) else 'NO')
```
Yes
| 95,157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**6)
N=int(input())
A=[int(i) for i in input().split()]
G=[[] for i in range(N)]
for i in range(N-1):
a,b=map(int,input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
Visited=[False]*N
B=[0]*N
def B_map(x):
C=[]
S=0
Visited[x]=True
for i in G[x]:
if not Visited[i]:
res=B_map(i)
S+=res
C.append(res)
if len(C)==0:
B[x]=A[x]
elif len(C)==1:
if A[x]==S:
B[x]=S
else:
print("NO")
exit()
else:
if 0<=S-A[x]<=min(S-max(C),S//2) and 2*A[x]-S>=0:
B[x]=2*A[x]-S
else:
print("NO")
exit()
return B[x]
B_map(0)
if len(G[0])==1:
if B[0]!=A[0]:
print("NO")
exit()
else:
if B[0]!=0:
print("NO")
exit()
print("YES")
```
Yes
| 95,158 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(input())
a = list(map(int, input().split()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(n-1):
u,v = map(int, input().split())
u -= 1
v -= 1
ns[u].add(v)
ns[v].add(u)
def sub(u, p):
if len(ns[u])==1 and p in ns[u]:
return a[u]
ub = 0
mv = 0
msum = 0
for v in ns[u]:
if p==v:
continue
val = sub(v, u)
if val is None:
return None
mv = max(mv, val)
msum += val
lb = max(mv, msum//2)
if not (lb<=a[u]<=msum):
# print(u,lb, msum, mv)
return None
else:
return a[u] - (msum-a[u])
if n==2:
if a[0]==a[1]:
print("YES")
else:
print("NO")
else:
if len(ns[0])>1:
ans = sub(0, -1)
else:
ans = sub(list(ns[0])[0], -1)
if ans is None or ans!=0:
print("NO")
else:
print("YES")
```
No
| 95,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
N = int(input())
A = [int(n) for n in input().split()]
edges = {n+1:[] for n in range(N)}
for n in range(N-1):
a, b = [int(n) for n in input().split()]
edges[a].append(b)
edges[b].append(a)
ends = [k for k, v in edges.items() if len(v)==1]
roots = set()
def search(past, p):
dest = edges[p]
if len(dest) == 1:
past.append(p)
roots.update(past)
else :
for i in range(dest):
if dest[i] != past[-1]:
past.append(p)
search(past, dest[i])
for end in ends:
search([end], edges[end][0])
# 全ての基底ベクトルはendsに収納されたので、このベクトルがはる空間にAが含まれるかどうかを検索したいだけの人生だった（敗北）
```
No
| 95,160 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
n = I()
a = LI()
if n == 2:
if a[0] == a[1]:
return 'YES'
return 'NO'
e = collections.defaultdict(list)
for _ in range(n-1):
b,c = LI_()
e[b].append(c)
e[c].append(b)
def f(c,p):
t = []
ac = a[c]
for b in e[c]:
if b == p:
continue
res = f(b,c)
if not res:
return
t.append(res)
if not t:
return ac
tm = max(t)
ts = sum(t)
mi = tm*2 - ts
tt = ac-(ts-ac)
if not (mi <= ac <= ts):
return
return tt
for i in range(n):
if len(e[i]) == 1:
continue
r = f(i,-1)
if r == 0:
return 'YES'
break
return 'NO'
print(main())
```
No
| 95,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Currently, there are A_i stones placed on vertex i. Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:
* Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices. Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.
Note that the operation cannot be performed if there is a vertex with no stone on the path.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i,b_i ≦ N
* 0 ≦ A_i ≦ 10^9
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If it is possible to remove all the stones from the vertices, print `YES`. Otherwise, print `NO`.
Examples
Input
5
1 2 1 1 2
2 4
5 2
3 2
1 3
Output
YES
Input
3
1 2 1
1 2
2 3
Output
NO
Input
6
3 2 2 2 2 2
1 2
2 3
1 4
1 5
4 6
Output
YES
Submitted Solution:
```
def examA():
N = I()
A = LI()
ans = "YES"
cur = 0
for a in A:
if a%2==1:
cur +=1
if cur%2==1:
ans = "NO"
print(ans)
return
def examB():
N = I()
A = LI()
ans = "YES"
sumA = sum(A)
oneA = (1+N)*N//2
if sumA%oneA!=0:
ans = "NO"
ope = sumA//oneA
#各Aについて何回始点としたか二分探索
cur = 0
for i in range(N):
now = ope - (A[i]-A[i-1])
if now%N!=0 or now<0:
# print(now,i)
ans = "NO"
break
cur += now//N
if cur!=ope:
ans = "NO"
print(ans)
return
def examC():
N = I()
A = LI()
V = [[]for _ in range(N)]
for i in range(N-1):
a, b = LI()
V[a-1].append(b-1)
V[b-1].append(a-1)
s = -1
for i,v in enumerate(V):
if len(v)>1:
s = i
break
def dfs(s,p):
flag = 1
rep = 0
for v in V[s]:
if v==p:
continue
cur,next = dfs(v,s)
rep += cur
flag *= next
if len(V[s])==1:
rep = A[s]
if rep==0:
return 0,flag
if (rep+1)//2>A[s] or rep<A[s]:
flag = 0
#print(s,rep)
rep -= (rep-A[s])*2
return rep,flag
rep,flag = dfs(s,-1)
if rep!=0:
flag = 0
if flag:
print("YES")
else:
print("NO")
return
from decimal import Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 1<<60
_ep = 10**(-16)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examC()
```
No
| 95,162 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
"""
全体のxorが不変量。
N-1数が127のときに等号
"""
T = int(input())
ND = [[int(x) for x in input().split()] for _ in range(T)]
answer = []
for N,D in ND:
x = 127 * (N-1)
if N&1:
x += D
else:
x += 127^D
answer.append(x)
print('\n'.join(map(str,answer)))
```
| 95,163 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
def read():
return int(input())
def reads(sep=None):
return list(map(int, input().split(sep)))
def main():
t = read()
for _ in range(t):
n, d = reads()
if n == 1:
print(d)
elif n % 2 == 0:
print(127*(n-1) + (d^127))
else:
print(127*(n-1) + d)
# 3, 1 [1] -> [126, 127] -> [127, 1, 127]
# 4,108 [108] -> [19, 127] -> [127, 127, 108] -> [127, 127, 127, 19]
main()
```
| 95,164 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
for i in range(int(input())):
n,d=map(int,input().split())
print([(n-1)*127+d,n*127-d][n%2==0])
```
| 95,165 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
t=int(input())
for i in range(t):
n,d=map(int,input().split())
ans=127*(n-1)
if n%2==1:
ans+=d
else:
ans+=127^d
print(ans)
```
| 95,166 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
T = int(input())
ts = [tuple(map(int,input().split())) for i in range(T)]
def solve(n,d):
if n%2:
return d + 127*(n-1)
else:
return 127*n - d
for n,d in ts:
print(solve(n,d))
```
| 95,167 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
T = int(input())
for _ in range(T):
n, d = map(int, input().split())
print(127*(n-1) + (d if n%2==1 else 127-d))
```
| 95,168 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
def solve(N_t, D_t):
ans = D_t
for i in range(N_t - 1):
ans -= D_t
ans += 127
D_t = 127 ^ D_t
ans += D_t
return ans
T = int(input())
for i in range(T):
N_t, D_t = map(int, input().split())
print(solve(N_t, D_t))
```
| 95,169 |
Provide a correct Python 3 solution for this coding contest problem.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
"Correct Solution:
```
N=int(input())
for i in range(N):
A,B=map(int,input().split())
if A%2==1:
ans=B+127*(A-1)
else:
ans=127*A-B
print(ans)
```
| 95,170 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
N,T=0,0
for i in range(int(input())):
N,T=map(int,input().split())
if N&1==0:
T^=127
print(T+(N-1)*127)
```
Yes
| 95,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
def inpl(): return list(map(int, input().split()))
for _ in range(int(input())):
N, D = inpl()
ans = 0
for i in range(7):
D, m = divmod(D, 2)
ans += (N-(N%2!=m))*(2**i)
print(ans)
```
Yes
| 95,172 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
T = int(input())
for _ in range(T):
N,D = map(int,input().split())
if N%2==0:
print(N*127-D)
else:
print((N-1)*127+D)
```
Yes
| 95,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
n = int(input())
for _ in range(n):
i,j = (int(k) for k in input().split())
if i%2==0: print(127*i-j)
else: print(127*(i-1)+j)
```
Yes
| 95,174 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
T = int(input())
ts = [tuple(map(int,input().split())) for i in range(T)]
def solve(n,d):
if n%2:
return d + 127*(n-1)
else:
tmp = 0
for a in range(128):
tmp = max(tmp, a + a^d)
return tmp - d + 127*(n-2)
for n,d in ts:
print(solve(n,d))
```
No
| 95,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
T = int(input())
for _ in range(T):
N,D = map(int,input().split())
cookie = [D]
while len(cookie)<N:
cookie.sort()
cookie = cookie[1:] + [127-cookie[0],127]
print(sum(cookie))
```
No
| 95,176 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
N,T=0,0
for i in range(int(input())):
N,T=map(int,input().split())
if N&1:
T^=127
print(T+(N-1)*127)
```
No
| 95,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A professor invented Cookie Breeding Machine for his students who like cookies very much.
When one cookie with the taste of x is put into the machine and a non-negative integer y less than or equal to 127 is input on the machine, it consumes the cookie and generates two cookies with the taste of y and (x XOR y).
Here, XOR represents Bitwise Exclusive OR.
At first, there is only one cookie and the taste of it is D .
Find the maximum value of the sum of the taste of the exactly N cookies generated after the following operation is conducted N-1 times.
1. Put one of the cookies into the machine.
2. Input a non-negative integer less than or equal to 127 on the machine.
Constraints
* 1 \leq T \leq 1000
* 1 \leq N_t \leq 1000 (1 \leq t \leq T)
* 1 \leq D_t \leq 127 (1 \leq t \leq T)
Input
The input is given from Standard Input in the following format:
T
N_1 D_1
:
N_T D_T
The input consists of multiple test cases. An Integer T that represents the number of test cases is given on line 1.
Each test case is given on the next T lines.
In the t-th test case ( 1 \leq t \leq T ), N_t that represents the number of cookies generated through the operations and D_t that represents the taste of the initial cookie are given separated by space.
Output
For each test case, print the maximum value of the sum of the taste of the N cookies generated through the operations on one line.
Example
Input
3
3 1
4 108
1 10
Output
255
400
10
Submitted Solution:
```
from heapq import heappush, heappop
T = int(input())
for i in range(T):
N, D = map(int, input().split())
ans = D
h = []
heappush(h,D)
for _ in range(N - 1):
k = heappop(h)
z = bin(k)[2:].zfill(7)
t = int(z,2)
heappush(h,t)
ans += (127 + t - k)
print(ans)
```
No
| 95,178 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
def f(a):
for x in ['o','x']:
if a[0::4].count(x)==3 or a[2:7:2].count(x)==3:return x
for i in range(3):
if a[i*3:i*3+3].count(x)==3 or a[i::3].count(x)==3:return x
return 'd'
while 1:
try:print(f(input()))
except:break
```
| 95,179 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
import sys
for line in sys.stdin.readlines():
l = [s for s in line.rstrip()]
answer = 'd'
for i in range(3):
if l[i] == l[i+3] == l[i+6]:
if l[i] == 'o':
answer = 'o'
elif l[i] == 'x':
answer = 'x'
for i in range(0,8,3):
if l[i] == l[i+1] == l[i+2]:
if l[i] == 'o':
answer = 'o'
elif l[i] == 'x':
answer = 'x'
if l[0] == l[4] == l[8] or l[2] == l[4] == l[6]:
if l[4] == 'o':
answer = 'o'
elif l[4] == 'x':
answer = 'x'
print(answer)
```
| 95,180 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
def f(s):
for t in ['o', 'x']:
if s[::4].count(t) == 3 or s[2:7:2].count(t) == 3:
return t
for i in range(3):
if s[i::3].count(t) == 3 or s[3 * i:3 * i + 3].count(t) == 3:
return t
return 'd'
while 1:
try:
print(f(input()))
except:
break
```
| 95,181 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
ok = [[0,4,8], [2,4,6], [0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8]]
while True:
try:
s = input()
except EOFError:
break
flag = False
for i in ok:
if s[i[0]] == s[i[1]] == s[i[2]] and s[i[0]] != 's':
print(s[i[0]])
flag = True
break
if flag:
continue
print("d")
```
| 95,182 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
while True:
try:
ban = input()
except EOFError:
break
s = [ban[:3], ban[3:6], ban[6:]]
s += map(''.join, zip(*s))
s += [ban[0]+ban[4]+ban[8]] + [ban[2]+ban[4]+ban[6]]
if 'ooo' in s:
print('o')
elif 'xxx' in s:
print('x')
else:
print('d')
```
| 95,183 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
import sys
f = sys.stdin
vlines = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]
for line in f:
result = 'd'
for v in vlines:
if 's' != line[v[0]] and line[v[0]]== line[v[1]] == line[v[2]]:
result = line[v[0]]
break
print(result)
```
| 95,184 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
# AOJ 0066 Tic Tac Toe
# Python3 2018.6.15 bal4u
def check(a):
for koma in ['o', 'x']:
for i in range(3):
if a[i:9:3].count(koma) == 3 or a[3*i:3*i+3].count(koma) == 3: return koma
if a[0:9:4].count(koma) == 3 or a[2:7:2].count(koma) == 3: return koma
return 'd'
while True:
try: print(check(list(input())))
except EOFError: break
```
| 95,185 |
Provide a correct Python 3 solution for this coding contest problem.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
import re
def is_win(A, B, C, sign):
if A[0] == A[1] == A[2] == sign or B[0] == B[1] == B[2] == sign or C[0] == C[1] == C[2] == sign:
return True
elif A[0] == B[0] == C[0] == sign or A[1] == B[1] == C[1] == sign or A[2] == B[2] == C[2] == sign:
return True
elif A[0] == B[1] == C[2] == sign or A[2] == B[1] == C[0] == sign:
return True
else:
return False
for s in sys.stdin:
s = s.strip()
A = s[0:3]
B = s[3:6]
C = s[6:9]
if is_win(A, B, C, 'o'):
print('o')
elif is_win(A, B, C, 'x'):
print('x')
else:
print('d')
```
| 95,186 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
table = [[0 for i in range(3)] for j in range(3)]
S = N[l]
ans = "d"
for i in range(9):
if S[i] == "o":
table[i // 3][i % 3] = 1
elif S[i] == "x":
table[i // 3][i % 3] = -1
for i in range(3):
s = 0
for j in range(3):
s += table[i][j]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
for i in range(3):
s = 0
for j in range(3):
s += table[j][i]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
s = table[0][0] + table[1][1] + table[2][2]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
s = table[0][2] + table[1][1] + table[2][0]
if s == 3:
ans = "o"
elif s == -3:
ans = "x"
print(ans)
```
Yes
| 95,187 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
import sys
[
print('o' if 'ooo' in b else ('x' if 'xxx' in b else 'd'))
for b in [
[
"".join([l[i] for i in t])
for t in [(0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6)]
]
for l in (
list(s.strip())
for s in sys.stdin
)
]
]
```
Yes
| 95,188 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
while True:
try:
hoge = input()
except:
break
ans = "d"
for i in range(3):
if "ooo" == hoge[i*3:i*3+3] or "ooo" == hoge[i::3]:
ans = "o"
break
elif "xxx" == hoge[i*3:i*3+3] or "xxx" == hoge[i::3]:
ans = "x"
break
if hoge[0::4] == "ooo" or hoge[2:7:2] == "ooo":
ans = "o"
elif hoge[0::4] == "xxx" or hoge[2:7:2] == "xxx":
ans = "x"
print(ans)
```
Yes
| 95,189 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
while True:
try:
k = list(input())
ans = 'd'
lst1 = [k[:3], k[3:6], k[6:]]
lst2 = [k[::3], k[1::3], k[2::3]]
if k[4] != 's':
if k[0] == k[4] and k[4] == k[8]:
ans = k[4]
elif k[2] == k[4] and k[4] == k[6]:
ans = k[4]
for i in lst1:
if i.count('o') == 3:
ans = 'o'
elif i.count('x') == 3:
ans = 'x'
else:
pass
for i in lst2:
if i.count('o') == 3:
ans = 'o'
elif i.count('x') == 3:
ans = 'x'
else:
pass
print(ans)
except EOFError:
break
```
Yes
| 95,190 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
import sys
board = []
board_list = []
result = []
for line in sys.stdin:
line = line.rstrip('\n')
board.append(line)
l_num = len(board)
print(board)
def check(num):
if board_list[num][0] == board_list[num][1] == board_list[num][2]:
if board_list[num][0] == 'o':
return 'o'
elif board_list[num][0] == 'x':
return 'x'
if board_list[0][num] == board_list[1][num] == board_list[2][num]:
if board_list[0][num] == 'o':
return 'o'
elif board_list[0][num] == 'x':
return 'x'
if board_list[0][0] == board_list[1][1] == board_list[2][2]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
if board_list[0][2] == board_list[1][1] == board_list[2][0]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
return'd'
for i in board:
board_list = [(a + b + c) for (a, b, c) in zip(i[::3], i[1::3], i[2::3])]
print(board_list)
for j in range(3):
if check(j) != "d":
print(check(j))
break
elif j == 2:
print(check(j))
```
No
| 95,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
ok = [{0,4,8}, {2,4,6}, {0,1,2}, {3,4,5}, {6,7,8}, {0,3,6}, {1,4,7}, {2,5,8}]
while True:
s = input()
if len(s) == 0:
break
maru = set()
batu = set()
for i in range(9):
if s[i] == 'o':
maru.add(i)
elif s[i] == 'x':
batu.add(i)
flag = False
for i in ok:
if len(i - maru) == 0:
print("o")
flag = True
break
elif len(i - batu) == 0:
print("x")
flag = True
break
if flag:
continue
print("d")
```
No
| 95,192 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
ok = [[0,4,8], [2,4,6], [0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8]]
while True:
s = input()
if len(s) == 0:
break
maru = []
batu = []
for i in range(9):
if s[i] == 'o':
maru.append(i)
elif s[i] == 'x':
batu.append(i)
flag = False
for i in ok:
if i == maru:
print("o")
flag = True
break
elif i ==batu:
print("x")
flag = True
break
if flag:
continue
print("d")
```
No
| 95,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tic-tac-toe is a game in which you win when you put ○ and × alternately in the 3 × 3 squares and line up ○ or × in one of the vertical, horizontal, and diagonal lines (Fig.). 1 to Fig. 3)
<image> | <image> | <image>
--- | --- | ---
Figure 1: ○ wins | Figure 2: × wins | Figure 3: Draw
In tic-tac-toe, ○ and × alternately fill the squares, and the game ends when either one is lined up. Therefore, as shown in Fig. 4, it is impossible for both ○ and × to be aligned. No improbable aspect is entered.
<image>
---
Figure 4: Impossible phase
Please create a program that reads the board of tic-tac-toe and outputs the result of victory or defeat.
Input
The input consists of multiple datasets. For each data set, one character string representing the board is given on one line. The character strings on the board are represented by o, x, and s in half-width lowercase letters for ○, ×, and blanks, respectively, and are arranged in the order of the squares in the figure below.
<image>
The number of datasets does not exceed 50.
Output
For each data set, output o in half-width lowercase letters if ○ wins, x in lowercase half-width letters if × wins, and d in lowercase half-width letters if it is a draw.
Example
Input
ooosxssxs
xoosxsosx
ooxxxooxo
Output
o
x
d
Submitted Solution:
```
def check(num):
if board_list[num][0] == board_list[num][1] == board_list[num][2]:
if board_list[num][0] == 'o':
return 'o'
elif board_list[num][0] == 'x':
return 'x'
if board_list[0][num] == board_list[1][num] == board_list[2][num]:
if board_list[0][num] == 'o':
return 'o'
elif board_list[0][num] == 'x':
return 'x'
if board_list[0][0] == board_list[1][1] == board_list[2][2]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
if board_list[0][2] == board_list[1][1] == board_list[2][0]:
if board_list[0][0] == 'o':
return 'o'
elif board_list[0][0] == 'x':
return 'x'
return 'd'
if __name__ == '__main__':
board = input()
board_list = [(a + b + c) for (a, b, c) in zip(board[::3], board[1::3],
board[2::3])]
for i in range(3):
result = check(i)
if result != "d":
break
print(result)
```
No
| 95,194 |
Provide a correct Python 3 solution for this coding contest problem.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
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:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
"Correct Solution:
```
roll = [
(0,1,2,3,4,5),
(1,5,2,3,0,4),
(2,1,5,0,4,3),
(3,1,0,5,4,2),
(4,0,2,3,5,1),
(5,4,2,3,1,0)]
def zero_move_to_left(xi):
r = roll[xi.index(0)]
return [xi[ri] for ri in r]
def sort_middle_face(xi):
m = xi[1:-1]
min_m = min(m)
while m[0] != min_m:
m = [m[1],m[3],m[0],m[2]]
return xi[:1] + m + xi[-1:]
import sys
f = sys.stdin
str2i = {'Blue':0, 'Cyan':1, 'Green':2, 'Magenta':3, 'Red':4, 'Yellow':5}
import collections
while True:
n = int(f.readline())
if n == 0:
break
c = collections.Counter()
for i in range(n):
xi = [str2i[w] for w in f.readline().split()]
xi = zero_move_to_left(xi)
xi = sort_middle_face(xi)
c[tuple(xi)] += 1
print(n - len(c))
```
| 95,195 |
Provide a correct Python 3 solution for this coding contest problem.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
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:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
"Correct Solution:
```
# AOJ 0198 Trouble in Shinagawa's Artifacts
# Python3 2018.6.20 bal4u
r = [ \
[0,1,2,3,4,5,6], [0,1,3,5,2,4,6], [0,1,4,2,5,3,6], [0,1,5,4,3,2,6], \
[0,2,6,3,4,1,5], [0,2,3,1,6,4,5], [0,2,1,4,3,6,5], [0,2,4,6,1,3,5], \
[0,3,1,2,5,6,4], [0,3,2,6,1,5,4], [0,3,5,1,6,2,4], [0,3,6,5,2,1,4], \
[0,4,1,5,2,6,3], [0,4,2,1,6,5,3], [0,4,5,6,1,2,3], [0,4,6,2,5,1,3], \
[0,5,1,3,4,6,2], [0,5,3,6,1,4,2], [0,5,4,1,6,3,2], [0,5,6,4,3,1,2], \
[0,6,2,4,3,5,1], [0,6,3,2,5,4,1], [0,6,5,3,4,2,1], [0,6,4,5,2,3,1]]
def same(x, y):
t = ['']*7
for i in range(24):
for j in range(1, 7): t[j] = a[y][r[i][j]]
if a[x] == t: return True
return False
while True:
n = int(input())
if n == 0: break
f = [0]*n
a = [['' for j in range(7)] for i in range(n)]
for i in range(n):
s = list(input().split())
for j in range(6): a[i][j+1] = s[j]
for i in range(n):
if f[i] == 1: continue
for j in range(i+1, n):
if same(i, j): f[j] = 1
print(sum(f))
```
| 95,196 |
Provide a correct Python 3 solution for this coding contest problem.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
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:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
"Correct Solution:
```
import copy
class Dice:
def __init__(self, a, b, c, d, e, f):
self.top = a
self.front = b
self.right = c
self.left = d
self.behind = e
self.bottom = f
def S(self):
self.top, self.front, self.behind, self.bottom = self.behind, self.top, self.bottom, self.front
def N(self):
self.behind, self.top, self.bottom, self.front = self.top, self.front, self.behind, self.bottom
def E(self):
self.top, self.bottom, self.left, self.right = self.left, self.right, self.bottom, self.top
def W(self):
self.left, self.right, self.bottom, self.top = self.top, self.bottom, self.left, self.right
def spin(self):
self.left, self.behind, self.right, self.front = self.front, self.left, self.behind, self.right
def __eq__(self, _dice2):
dice2 = copy.deepcopy(_dice2)
for i in range(4):
if self._eqaul(dice2):
return True
dice2.spin()
dice2 = copy.deepcopy(_dice2)
dice2.N()
dice2.N()
for i in range(4):
if self._eqaul(dice2):
return True
dice2.spin()
dice2 = copy.deepcopy(_dice2)
dice2.N()
for i in range(4):
if self._eqaul(dice2):
return True
dice2.spin()
dice2 = copy.deepcopy(_dice2)
dice2.E()
for i in range(4):
if self._eqaul(dice2):
return True
dice2.spin()
dice2 = copy.deepcopy(_dice2)
dice2.W()
for i in range(4):
if self._eqaul(dice2):
return True
dice2.spin()
dice2 = copy.deepcopy(_dice2)
dice2.S()
for i in range(4):
if self._eqaul(dice2):
return True
dice2.spin()
return False
def _eqaul(self, dice2):
return self.front == dice2.front and self.behind == dice2.behind and self.left == dice2.left and self.right == dice2.right and self.top == dice2.top and self.bottom == dice2.bottom
def __repr__(self):
return ",".join([str(object=i) for i in (self.top, self.front, self.right, self.left, self.behind, self.bottom)])
while True:
n=int(input())
if n==0:
break
dices=[]
for i in range(n):
c=input().split(" ")
dice=Dice(*c)
if (dice in dices)==False:
dices.append(dice)
print(n-len(dices))
```
| 95,197 |
Provide a correct Python 3 solution for this coding contest problem.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
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:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
"Correct Solution:
```
D = [
(1, 5, 2, 3, 0, 4), # 'U'
(3, 1, 0, 5, 4, 2), # 'R'
(4, 0, 2, 3, 5, 1), # 'D'
(2, 1, 5, 0, 4, 3), # 'L'
]
p_dice = (0, 0, 0, 1, 1, 2, 2, 3)*3
def rotate_dice(L0):
L = L0[:]
for k in p_dice:
yield L
L[:] = (L[e] for e in D[k])
while 1:
N = int(input())
if N == 0:
break
res = []
for i in range(N):
cube = input().split()
for dice in rotate_dice(cube):
if dice in res:
break
else:
res.append(cube)
print(N - len(res))
```
| 95,198 |
Provide a correct Python 3 solution for this coding contest problem.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
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:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
"Correct Solution:
```
class Dice:
same_dice_index = ((0, 1, 2, 3, 4, 5), (0, 2, 4, 1, 3, 5), (0, 3, 1, 4, 2, 5),
(0, 4, 3, 2, 1, 5), (1, 0, 3, 2, 5, 4), (1, 2, 0, 5, 3, 4),
(1, 3, 5, 0, 2, 4), (1, 5, 2, 3, 0, 4), (2, 0, 1, 4, 5, 3),
(2, 1, 5, 0, 4, 3), (2, 4, 0, 5, 1, 3), (2, 5, 4, 1, 0, 3),
(3, 0, 4, 1, 5, 2), (3, 1, 0, 5, 4, 2), (3, 4, 5, 0, 1, 2),
(3, 5, 1, 4, 0, 2), (4, 0, 2, 3, 5, 1), (4, 2, 5, 0, 3, 1),
(4, 3, 0, 5, 2, 1), (4, 5, 3, 2, 0, 1), (5, 1, 3, 2, 4, 0),
(5, 2, 1, 4, 3, 0), (5, 3, 4, 1, 2, 0), (5, 4, 2, 3, 1, 0))
def __init__(self, str_list):
self.faces = str_list
def is_same(self, dice):
for i in Dice.same_dice_index:
for n, j in enumerate(i):
if dice.faces[n] != self.faces[j]:
break
else:
return True
return False
def is_unique(self, dices_list):
for i in dices_list:
if self.is_same(i):
return False
return True
def solve():
from sys import stdin
f_i = stdin
ans_list = []
while True:
n = int(f_i.readline())
if n == 0:
break
dices = [Dice(f_i.readline().split()) for i in range(n)]
ans = 0
while dices:
tmp_dices = []
d1 = dices.pop()
for d2 in dices:
if d1.is_same(d2):
ans += 1
else:
tmp_dices.append(d2)
dices = tmp_dices
ans_list.append(ans)
print('\n'.join(map(str, ans_list)))
solve()
```
| 95,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.