text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
#C
def main():
mod=998244353
n=int(input())
Fact=[1] #階乗
for i in range(1,n+1):
Fact.append(Fact[i-1]*i%mod)
Finv=[0]*(n+1) #階乗の逆元
Finv[-1]=pow(Fact[-1],mod-2,mod)
for i in range(n-1,-1,-1):
Finv[i]=Finv[i+1]*(i+1)%mod
def comb(n,r):
if n<r:
return 0
return Fact[n]*Finv[r]*Finv[n-r]%mod
impossible=0
m=1
for k in range(n//2):
impossible+=comb(n,k)*m%mod
impossible%=mod
m*=2
m%=mod
print((pow(3,n,mod)-impossible*2)%mod)
if __name__=='__main__':
main()
```
| 89,900 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
N=int(input())
mod=998244353
FACT=[1]
for i in range(1,N+1):
FACT.append(FACT[-1]*i%mod)
FACT_INV=[pow(FACT[-1],mod-2,mod)]
for i in range(N,0,-1):
FACT_INV.append(FACT_INV[-1]*i%mod)
FACT_INV.reverse()
POW=[1]
for i in range(N):
POW.append(POW[-1]*2%mod)
def Combi(a,b):
return FACT[a]*FACT_INV[b]*FACT_INV[a-b]%mod
SC=0
for i in range(N//2+1,N+1):
SC+=Combi(N,i)*POW[N-i]
print((pow(3,N,mod)-SC*2)%mod)
```
| 89,901 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
MOD = 998244353
N = int(input())
ans = pow(3, N, MOD)
def getInvs(n, MOD):
invs = [1] * (n+1)
for x in range(2, n+1):
invs[x] = (-(MOD//x) * invs[MOD%x]) % MOD
return invs
def getCombNs(n, invs, MOD):
combNs = [1] * (n//2+1)
for x in range(1, n//2+1):
combNs[x] = (combNs[x-1] * (n-x+1) * invs[x]) % MOD
return combNs + combNs[:(n+1)//2][::-1]
invs = getInvs(N, MOD)
combNs = getCombNs(N, invs, MOD)
pow2 = 1
for i in range((N-1)//2+1):
num = combNs[i] * pow2
ans -= num*2 % MOD
ans %= MOD
pow2 *= 2
pow2 %= MOD
print(ans)
```
| 89,902 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
N = int(input())
nn = N + 10
P = 998244353
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % P
C = lambda a, b: fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
ans = pow(3, N, P)
p2 = 2
for i in range(N, N // 2, -1):
ans = (ans - C(N, i) * p2) % P
p2 = p2 * 2 % P
print(ans)
```
| 89,903 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
n=int(input())
pre=[1]*(n//2+200)
pp=[1]*(n+1)
mod=998244353
for i in range(1,n//2+100):
pre[i]=((pre[i-1]*2)%mod)
p=[1]*(n+1)
for i in range(n):
p[i+1]=((p[i]*(i+1))%mod)
pp[-1] = pow(p[-1], mod - 2, mod)
for i in range(2, n + 1):
pp[-i] = int((pp[-i + 1] * (n + 2 - i)) % mod)
tot=1
for i in range(n):
tot*=3
tot%=mod
#print(1)
#print(tot)
cc=0
for i in range(n//2+1,n+1):
c=(((((p[n]*pp[i])%mod)*pp[n-i])%mod)*pre[n-i])%mod
c%=mod
cc+=c
tot-=cc
tot-=cc
tot%=mod
print(tot)
```
| 89,904 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
def prepare(n, MOD):
f = 1
for m in range(1, n + 1):
f *= m
f %= MOD
fn = f
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return fn, invs
n = int(input())
MOD = 998244353
fn, invs = prepare(n, MOD)
ans = pow(3, n, MOD)
impossible = 0
mul = 2
for i in range(n // 2):
tmp = fn * invs[i] * invs[n - i] % MOD * mul
impossible = (impossible + tmp) % MOD
mul = mul * 2 % MOD
print((ans - impossible) % MOD)
```
Yes
| 89,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
import itertools
import os
import sys
from functools import lru_cache
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 998244353
N = int(sys.stdin.readline())
@lru_cache(maxsize=None)
# @debug
def is_ok(s):
if len(s) == 0:
return True
if len(s) == 2:
return s not in ['AB', 'BA']
for i in range(len(s) - 2):
if s[i:i + 2] not in ['AB', 'BA'] and is_ok(s[:i] + s[i + 2:]):
return True
return False
def test(N):
ret = 0
for s in itertools.product('ABC', repeat=N):
s = ''.join(s)
ret += is_ok(s)
return ret
def mod_invs(max, mod):
"""
逆元のリスト 0 から max まで
:param int max:
:param int mod:
"""
invs = [1] * (max + 1)
for x in range(2, max + 1):
invs[x] = (-(mod // x) * invs[mod % x]) % mod
return invs
# print(test(N))
# N = 10 ** 7
# 解説AC
# 偶数番目のAとBを反転して、AAとBB以外を取り除く
# AまたはBが半分より多いときダメなので全体から引く
ans = pow(3, N, MOD)
invs = mod_invs(max=N, mod=MOD)
ncr = 1 # NCr
p2r = 1 # pow(2, N - r, MOD)
for r in range(N, N // 2, -1):
# ans -= comb.ncr(N, r) * pow(2, N - r, MOD) * 2 % MOD
ans -= ncr * p2r * 2 % MOD
ans %= MOD
ncr *= r * invs[N - r + 1]
ncr %= MOD
p2r *= 2
p2r %= MOD
print(ans)
```
Yes
| 89,906 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
n=int(input());l=[0,1];a=0;b=c=1;p=998244353
for i in range(2,n):l+=[l[p%i]*(p-p//i)%p]
for i in range(n,n//2,-1):a+=b*c;b+=b%p;c=c*i*l[n+1-i]%p
print((pow(3,n,p)-2*a)%p)
```
Yes
| 89,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
"""
Writer: SPD_9X2
https://atcoder.jp/contests/agc040/tasks/agc040_c
奇数文字目と偶数文字目がセットで消える
奇数文字目のABを反転すると、AB or BA or AC or BC or CC で消えていいことになる
すなわち、異なる文字の切れ目では必ず消せる
異なる切れ目は必ず存在するので、Cを適当にABに割り振った時に全て消せるかどうかが問題になる
A,Bのみの時に全て消せる条件は 両者の数が等しい事
Cを適切に割り振った時に両者の数を等しくできる必要十分条件は max(a,b) <= N//2
あとはこれを数えればよい→どうやって？
全ての並び方は 3**N ここから補集合を引く？
Aが半数を超える(k個)の時のおき方は、 NCk * (2**(N-k))で求まる
Bの時も同様に。
"""
def modfac(n, MOD):
f = 1
factorials = [1]
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
def modnCr(n,r,mod,fac,inv):
return fac[n] * inv[n-r] * inv[r] % mod
N = int(input())
mod = 998244353
fac,inv = modfac(N+10,mod)
ans = pow(3,N,mod)
tpow = [1]
for i in range(N//2+10):
tpow.append(tpow[-1]*2%mod)
for k in range(N//2+1,N+1):
now = 2 * modnCr(N,k,mod,fac,inv) * tpow[N-k]
ans -= now
ans %= mod
print (ans)
```
Yes
| 89,908 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
import numpy as np
def prepare(n, MOD):
f = 1
for m in range(1, n + 1):
f = f * m % MOD
fn = f
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv = invs[m - 1] = inv * m % MOD
invs = np.array(invs, dtype=np.int64)
return fn, invs
n = int(input())
MOD = 998244353
fn, invs = prepare(n, MOD)
n2 = n // 2
# mul = 1
# muls = [0] * n2
# for i in range(n2):
# mul = muls[i] = mul * 2 % MOD
# mul = 1
# muls = np.zeros(n2, dtype=np.int64)
# for i in range(n2):
# mul = muls[i] = mul * 2 % MOD
muls = np.zeros(1, dtype=np.int64)
muls[0] = 2
while muls.size < n2:
muls = np.append(muls, muls * muls[-1] % MOD)
muls = muls[:n2]
impossibles = invs[:n2] * invs[n:n2:-1] % MOD
impossibles = impossibles * muls % MOD
impossible = sum(list(impossibles)) % MOD * fn
print((pow(3, n, MOD) - impossible) % MOD)
```
No
| 89,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
N = int(input())
MOD = 998244353
ans = 0
d = 1
b = 1
for i in range((N//2)):
ans += d * b
b *= 2
b %= MOD
ans %= MOD
d = ((N-i)*d)%MOD
d = (d*pow(i+1,MOD-2,MOD))%MOD
print((pow(3,N,MOD)-ans*2)%MOD)
```
No
| 89,910 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
MOD = 998244353
MAX_N = 10**7
fac = [1] + [0] * MAX_N
fac_inv = [1] + [0] * MAX_N
mod_pow2_n = [1] + [0] * MAX_N
f = 1
finv = 1
p2 = 1
for i in range(1, MAX_N+1):
# fac[i] = fac[i-1] * i % MOD
f *= i
f %= MOD
fac[i] = f
# Fermat's little theorem says
# a**(p-1) mod p == 1
# then, a * a**(p-2) mod p == 1
# it means a**(p-2) is inverse element
# fac_inv[i] = fac_inv[i-1] * pow(i, MOD-2, MOD) % MOD
finv *= pow(i, MOD-2, MOD)
finv %= MOD
fac_inv[i] = finv
p2 *= 2
p2 %= MOD
mod_pow2_n[i] = p2
def mod_nCr(n, r):
if n < r or n < 0 or r < 0:
return 0
tmp = fac_inv[n-r] * fac_inv[r] % MOD
return tmp * fac[n] % MOD
def single_mod_nCr(n, r):
if n < r or n < 0 or r < 0:
return 0
if r > n - r:
r = n - r
ret = 1
for i in range(r):
ret *= n - i
ret *= pow(i+1, MOD-2, MOD)
ret %= MOD
return ret
n = int(input())
ans = 0
for i in range(n//2+1, n+1):
ans += mod_nCr(n, i) * mod_pow2_n[n-i]
ans %= MOD
print((pow(3, n, MOD) - ans * 2 + MOD)%MOD)
```
No
| 89,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
Submitted Solution:
```
N=int(input())
mod=998244353
FACT=[1]
for i in range(1,N+1):
FACT.append(FACT[-1]*i%mod)
FACT_INV=[pow(FACT[-1],mod-2,mod)]
for i in range(N,0,-1):
FACT_INV.append(FACT_INV[-1]*i%mod)
FACT_INV.reverse()
def Combi(a,b):
if 0<=b<=a:
return FACT[a]*FACT_INV[b]*FACT_INV[a-b]%mod
SC=0
for i in range(N//2+1,N+1):
SC+=Combi(N,i)*pow(2,N-i,mod)
print((pow(3,N,mod)-SC*2)%mod)
```
No
| 89,912 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
"""
Writer: SPD_9X2
https://atcoder.jp/contests/diverta2019-2/tasks/diverta2019_2_e
Mの時、 a1<=a2<=a3…aN
を満たす通り数 X[M] が分かれば解ける(全ての順N!は等しいため)
当然、次のMにはa1から順に更新していくことになる(M+?にね)
Dの時
X[M] = (X[M-1] + X[M-2] + … + X[M-D]) * N
が成立かな
X[0] = 1
N=2
X[0]=1
X[1]=2
X[2]=6
N=3
X[0]=1
X[1]=9
X[M]の更新式
→これが間違ってそう
X[M] = (X[M-1] + X[M-2] + … + X[M-D]) * (1!+2!+3!+…N!)
→エスパーだけどなんか正しそう
X[H-1]を求めてN!を掛ければそれが答え
→サンプル合った！！
"""
import math
N,H,D = map(int,input().split())
mod = 10**9+7
mul = 0
fac = 1
for i in range(1,N+1):
fac *= i
fac %= mod
mul += fac
mul %= mod
X = [1]
nsum = 1
for i in range(H-1):
#print (i,nsum,mul)
X.append(nsum*mul%mod)
nsum += X[-1]
nsum %= mod
if i >= D-1:
nsum -= X[i-D+1]
#print (X)
print (nsum * fac % mod)
```
| 89,913 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
N, H, D = map(int, input().split())
MOD = 10**9 + 7
v = 1
w = 0
for i in range(1, N+1):
v = v * i % MOD
w += v
v %= MOD
w %= MOD
dp = [0]*(H+1)
dp[0] = v
s = 0
for i in range(H):
s += dp[i] % MOD
if i+1 < H:
dp[i+1] = s * w % MOD
else:
dp[i+1] = s % MOD
if i-D+1 >= 0:
s -= dp[i-D+1] % MOD
print(dp[H])
```
| 89,914 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
N, H, D = map(int, input().split())
imos = [0] * (H+2)
ans = [0] * (H+1)
M = 0
f = 1
for i in range(1, N+1):
f = (f * i)%mod
M = (M + f)%mod
imos[1] += f
imos[D+1] -= f
for i in range(1, H):
ans[i] = (ans[i-1] + imos[i])%mod
imos[i+1] = (imos[i+1] + (ans[i] * M)%mod)%mod
if i+D+1 <= H:
imos[i+D+1] = (imos[i+D+1] - (ans[i] * M)%mod)%mod
print((ans[H-1] + imos[H])%mod)
if __name__ == '__main__':
main()
```
| 89,915 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
N, H, D = map(int,input().split())
MOD = 10**9 + 7
fact = [1]
fact_cum = [0]
for i in range(1,N+1):
fact.append((fact[-1]*i)%MOD)
fact_cum.append((fact_cum[-1] + fact[-1])%MOD)
ap = [0] * (H+1)
ap_cum = [0] * (H+1)
ap[0] = 1
ap_cum[0] = 1
for n in range(1,H+1):
x = ap_cum[n-1]
if n > D:
x -=ap_cum[n-D-1]
x *= fact_cum[N]
x %= MOD
ap[n] = x
ap_cum[n] = (ap_cum[n-1] + x)%MOD
ans = ap[H]
ans *= fact[N]
ans %= MOD
ans *= pow(fact_cum[N],MOD-2,MOD)
ans %= MOD
print(ans)
```
| 89,916 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def main():
md = 10 ** 9 + 7
n, h, d = MI()
sum_fact = 0
n_fact = 1
for x in range(1, n + 1):
n_fact *= x
sum_fact += n_fact
n_fact %= md
sum_fact %= md
if h==1:
print(n_fact)
exit()
dp = [0] * (h + 1)
dp[0] = dp[1] = n_fact
s = 0
for i in range(2, h + 1):
if i <= d:
s += dp[i - 1]
dp[i] = s * sum_fact + dp[0]
elif i == d + 1:
s += dp[i - 1]
dp[i] = s * sum_fact
else:
s += dp[i - 1] - dp[i - 1 - d]
dp[i] = s * sum_fact
s %= md
dp[i] %= md
print(dp[-1])
main()
```
| 89,917 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
N, H, D = map(int, input().split())
P, a, s = 10**9+7, 1, 0
for i in range(1, N+1):
a = a*i%P
s = (s+a)%P
X = [a]
for i in range(1, H):
X.append(a*s%P)
a += X[-1]
if i >= D: a -= X[-D-1]
a %= P
print(a)
```
| 89,918 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
N,H,D=map(int,input().split())
mod=10**9+7
table=[1]
num=0
for i in range(1,N+1):
table.append(table[-1]*i%mod)
num=(num+table[-1])%mod
dp=[0]*(H+1)
d_sum=[0]*(H+1)
for i in range(1,D+1):
dp[i]=table[N]
for i in range(1,H+1):
dp[i]=(dp[i]+(d_sum[i-1]-d_sum[max(0,i-D-1)])*num)%mod
d_sum[i]=(dp[i]+d_sum[i-1])%mod
print(dp[H])
```
| 89,919 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
"Correct Solution:
```
N, H, D = map(int, input().split())
MOD = 10 ** 9 + 7
fact = 1
s = 0
for i in range(1, N+1) :
fact = fact * i % MOD
s = (s + fact) % MOD
dp = [0] * H
dp[0] = 1
ret = 1
for i in range(1, H) :
dp[i] = ret * s % MOD
ret = (ret + ret * s) % MOD
if i >= D :
ret = (ret - dp[i - D]) % MOD
print(ret * fact % MOD)
```
| 89,920 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
n, h, d = map(int, input().split())
MOD = 10 ** 9 + 7
fact = [1] * (n + 1)
for i in range(n):
fact[i + 1] = fact[i] * (i + 1)
fact[i + 1] %= MOD
# fact_sum = fact[1] + fact[2] + ... + fact[n]
fact_sum = 0
for i in range(1, n + 1):
fact_sum += fact[i]
fact_sum %= MOD
dp = [0] * (h + 1)
ru = [0] * (h + 2)
dp[0] = 1
ru[1] = 1
for i in range(h):
l = max(i + 1 - d, 0)
dp[i + 1] += (ru[i + 1] - ru[l]) * fact_sum
dp[i + 1] %= MOD
ru[i + 2] = ru[i + 1] + dp[i + 1]
ru[i + 2] %= MOD
print((dp[-1] * fact[n] * pow(fact_sum, MOD - 2, MOD)) % MOD)
```
Yes
| 89,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
N,H,D=map(int,input().split())
mod=10**9+7
const=0
frac=[1]
for i in range(1,N+1):
frac.append((frac[-1]*i)%mod)
const=(const+frac[-1])%mod
dp=[0]*(H+1)
dp[0]=1
dp[1]=frac[-1]
S=dp[1]
for i in range(2,D+1):
dp[i]=const*S+frac[-1]
dp[i]%=mod
S=(S+dp[i])%mod
S=sum(dp[i] for i in range(1,D+1))
S%=mod
for i in range(D+1,H+1):
dp[i]=const*S
dp[i]%=mod
S=(S+dp[i]-dp[i-D])%mod
print(dp[H])
```
Yes
| 89,922 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
N, H, D = map(int,input().split())
MOD = 10**9 + 7
fact = [1]
fact_cum = [0] # 1! to N!
for i in range(1,N+1):
fact.append((fact[-1]*i)%MOD)
fact_cum.append((fact_cum[-1] + fact[-1])%MOD)
dp = [0] * (H+1)
dp_cum = [0] * (H+1)
dp[0] = 1
dp_cum[0] = 1
for n in range(1,H+1):
x = dp_cum[n-1]
if n > D:
x -= dp_cum[n-D-1]
x *= fact_cum[N]
x %= MOD
dp[n] = x
dp_cum[n] = (dp_cum[n-1] + x)%MOD
answer = dp[H]
answer *= fact[N]
answer %= MOD
answer *= pow(fact_cum[N],MOD-2,MOD)
answer %= MOD
print(answer)
```
Yes
| 89,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
n, h, d = map(int, input().split())
MOD = 10 ** 9 + 7
fact, fact_acc = 1, 1
for i in range(2, n + 1):
fact = fact * i % MOD
fact_acc = (fact_acc + fact) % MOD
dp = [0] * (h + 1)
dp[0] = base = fact
for i in range(1, h):
dp[i] = base * fact_acc % MOD
base = (base + dp[i]) % MOD
if i >= d:
base = (base - dp[i - d]) % MOD
print(base)
```
Yes
| 89,924 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
n = int(input())
ga, sa, ba = list(map(int, input().split()))
gb, sb, bb = list(map(int, input().split()))
w_ab = []
v_ab = []
if ga < gb:
w_ab.append(ga)
v_ab.append(gb)
if sa < sb:
w_ab.append(sa)
v_ab.append(sb)
if ba < bb:
w_ab.append(ba)
v_ab.append(bb)
num = (n+1)*(len(w_ab)+1)
dp = [0]*num
for i in range(len(w_ab)):
for j in range(n+1):
if j < w_ab[i]:
dp[(i+1)*(n+1) + j] = dp[i*(n+1) + j]
else:
dp[(i+1)*(n+1) + j] = max(dp[i*(n+1) + j], dp[(i+1)*(n+1) + j - w_ab[i]] + v_ab[i])
ans = 0
length = len(w_ab)
for j in range(n+1):
ans = max(ans, dp[length*(n+1) + j] + n-j)
n = ans
w_ab = []
v_ab = []
if ga > gb:
w_ab.append(gb)
v_ab.append(ga)
if sa > sb:
w_ab.append(sb)
v_ab.append(sa)
if ba > bb:
w_ab.append(bb)
v_ab.append(ba)
num = (n+1)*(len(w_ab)+1)
dp = [0]*num
for i in range(len(w_ab)):
for j in range(n+1):
if j < w_ab[i]:
dp[(i+1)*(n+1) + j] = dp[i*(n+1) + j]
else:
dp[(i+1)*(n+1) + j] = max(dp[i*(n+1) + j], dp[(i+1)*(n+1) + j - w_ab[i]] + v_ab[i])
length = len(w_ab)
ans = 0
for j in range(n+1):
ans = max(ans, dp[length*(n+1) + j] + n-j)
print(ans)
```
No
| 89,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
n, h, d = map(int, input().split())
MOD = 10 ** 9 + 7
if n * h * d >= 10 ** 7:
print(re)
# dp[i][j] := 高さiのブロックが最大高さでj個ある時の通り数
dp = [[0] * (n + 1) for i in range(h + 1)]
dp[0][n] = 1
# O(HDN)
for i in range(h):
# j = 0 -> j = 1 にする
for diff in range(1, d + 1):
if i + 1 - diff < 0:
continue
for cnt in range(1, n + 1):
dp[i + 1][1] += dp[i + 1 - diff][cnt] * cnt
dp[i + 1][1] %= MOD
# j -> j + 1 にする
for j in range(2, n + 1):
dp[i + 1][j] += dp[i + 1][j - 1] * (n - (j - 1))
dp[i + 1][j] %= MOD
print(dp[-1][-1])
```
No
| 89,926 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
n, h, d = map(int, input().split())
MOD = 10 ** 9 + 7
if d != 1:
print(re)
fact = [1] * (n + 1)
for i in range(n):
fact[i + 1] = fact[i] * (i + 1)
fact[i + 1] %= MOD
# fact_sum = fact[1] + fact[2] + ... + fact[n]
fact_sum = 0
for i in range(1, n + 1):
fact_sum += fact[i]
fact_sum %= MOD
dp = [0] * (h + 1)
dp[0] = 1
for i in range(h):
dp[i + 1] = dp[i] * fact_sum
dp[i + 1] %= MOD
print((dp[-1] - dp[-2] * (fact_sum - fact[-1])) % MOD)
```
No
| 89,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529
Submitted Solution:
```
n, h, d = map(int, input().split())
MOD = 10 ** 9 + 7
if n * h + h * d >= 10 ** 7:
print(re)
# dp[i][j] := 高さiのブロックが最大高さでj個ある時の通り数
dp = [[0] * (n + 1) for i in range(h + 1)]
dp[0][n] = 1
# O(HN)
ru = [[0] * (n + 2) for i in range(h + 1)]
ru[0][n + 1] = 1
for i in range(h):
# j = 0 -> j = 1 にする
for diff in range(1, d + 1):
if i + 1 - diff < 0:
continue
dp[i + 1][1] += ru[i + 1 - diff][n + 1]
dp[i + 1][1] %= MOD
# j - 1 -> j にする
for j in range(2, n + 1):
dp[i + 1][j] += dp[i + 1][j - 1] * j
dp[i + 1][j] %= MOD
for j in range(n + 1):
ru[i + 1][j + 1] = ru[i + 1][j] + dp[i + 1][j]
ru[i + 1][j + 1] %= MOD
print(dp[-1][-1] % MOD)
```
No
| 89,928 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
l = sorted(list(map(int,input().split())))
if l == [1, 4, 7, 9]:
print('YES')
else:
print('NO')
```
| 89,929 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
print("YES" if [1, 4, 7, 9] == sorted(map(int, input().split())) else "NO")
```
| 89,930 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
s = input()
print("YES" * (s.count("1") * s.count("9") * s.count("7") * s.count("4")) or "NO")
```
| 89,931 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
print("YNEOS"[sorted(input())!=list(" 1479")::2])
```
| 89,932 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
a=list(map(int,input().split()))
a.sort()
b=[1,4,7,9]
if a==b:
print('YES')
else: print('NO')
```
| 89,933 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
N = input().split()
if set(N) == set("1794"):
print("YES")
else:
print("NO")
```
| 89,934 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
a=set(list(map(int,input().split())))
if a=={1,9,7,4}:
print("YES")
else:
print("NO")
```
| 89,935 |
Provide a correct Python 3 solution for this coding contest problem.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
"Correct Solution:
```
print('YES' if set(input().split())=={'1','9','7','4'} else 'NO')
```
| 89,936 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
print('YES' if set(input().split()) == set(['1', '9', '7', '4']) else 'NO')
```
Yes
| 89,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
*N, = map(int, input().split())
if sorted(N) == [1, 4, 7, 9]:
print("YES")
else:
print("NO")
```
Yes
| 89,938 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
print("YES" if sorted(input().split()) == ['1','4','7','9'] else "NO")
```
Yes
| 89,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
N = sorted(list(map(str, input().split())))
print('YES' if ''.join(N) == '1479' else'NO')
```
Yes
| 89,940 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
import sys
"""テンプレ"""
# 高速
input = sys.stdin.readline
# 1行を空白でリストにする(int)
def intline():
return list(map(int, input().split()))
# 上のstrヴァージョン
def strline():
return list(map(str, input().split()))
# 1列に並んだ数
def intlines(n):
return [int(input() for _ in range(n))]
# 上の文字列ヴァージョン
def lines(n):
return [input() for _ in range(n)]
"""ここからメインコード"""
k = intline().sort()
if k = [1, 4, 7, 9]:print("YES")
else:print("NO")
```
No
| 89,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
s = input()
for i in range(7):
if s[:i] + s[-7 + i:] == "keyence":
print("YES")
exit()
print("NO")
```
No
| 89,942 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
n= sort(list(int,input().split()))
if n == [1,7,9,4]:
print("YES")
else:
print("NO")
```
No
| 89,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO
Submitted Solution:
```
from bisect import bisect
def inpl(): return list(map(int, input().split()))
MOD = 10**9 + 7
N, M = inpl()
A = sorted(inpl())
B = sorted(inpl())
A_set = set(A)
B_set = set(B)
ans = 1
for x in range(N*M, 0, -1):
if (x in A_set) and (x in B_set):
tmp = 1
elif x in A_set:
tmp = max(M - bisect(B, x), 0)%MOD
elif x in B_set:
tmp = max(N - bisect(A, x), 0)%MOD
else:
a = bisect(A, x)
b = bisect(B, x)
tmp = max(x - N*b - M*a + a*b, 0)%MOD
ans = (tmp*ans)%MOD
print(ans)
```
No
| 89,944 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
S = input()
T = input()
S = S * 2
yes = S.find(T) != -1
print('Yes' if yes else 'No')
```
| 89,945 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
s=input()
t=input()
t=t+t
if s in t:
print('Yes')
else:
print('No')
```
| 89,946 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
s = input()
t = input()
s = s + s
if t in s:
print("Yes")
else:
print("No")
```
| 89,947 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
s = input()
ss = input()
ss += ss
if s in ss:
print("Yes")
else:
print("No")
```
| 89,948 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
S = input()
T = input()
if (S+S).count(T)>=1:
print ('Yes')
else:
print('No')
```
| 89,949 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
S = input()
T = input()
TT = T + T
if S in TT:
print("Yes")
else:
print("No")
```
| 89,950 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
s = input()
t = input()
print("Yes" if (s * 2).find(t) >= 0 else "No")
```
| 89,951 |
Provide a correct Python 3 solution for this coding contest problem.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
"Correct Solution:
```
s = input() * 2
t = input()
print("Yes") if t in s else print("No")
```
| 89,952 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
#103b
S = str(input())
T = str(input())
T = T + T
if S in T:
print("Yes")
else:
print("No")
```
Yes
| 89,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
s = input()
t = input()
s2 = s + s
if t in s2:
print("Yes")
else:
print("No")
```
Yes
| 89,954 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
S = input()
T = input()
a = "No"
for n in range(len(S)):
if S[n:]+S[:n]==T:
a = "Yes"
print(a)
```
Yes
| 89,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
S = input()
T = input()
T = T * 2
if T.find(S) != -1:
print('Yes')
else:
print('No')
```
Yes
| 89,956 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
s = input()
t = input()
#s = list(s)
#t = list(t)
for i in range(0,int(len(s)/2)):
s += s
for i in range(len(s),0,-1):
#print(s[i:i+5])
if t == s[i:i+len(s)]:
print("Yes")
exit()
print("No")
```
No
| 89,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
S = input()
T = input()
S_list = [S]
for i in range(len(S)-1):
S_list.append(S[i:]+S[:i])
if T in S_list:
print('Yes')
else:
print('No')
```
No
| 89,958 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
input_x = str(input())
input_y = str(input())
tmp = input_y
ary = []
for i in input_y:
ary.append(i)
mongon = "Yes"
for c in input_x:
if tmp.find(c) != -1:
ary.pop(tmp.find(c))
tmp = "".join(ary)
else:
mongon = "No"
break
print(mongon)
```
No
| 89,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
Submitted Solution:
```
s=list(input())
t=input()
for i in range(len(s)):
s.insert(0,s.pop())
word="".join(s)
if s==t:
print("Yes")
exit()
print("No")
```
No
| 89,960 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
N = int(input())
A1 = list(map(int,input().split()))
A2 = list(map(int,input().split()))
sums = [sum(A1[:i])+sum(A2[i-1:]) for i in range(1,N+1)]
print(max(sums))
```
| 89,961 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
n = int(input())
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
m = 0
for i in range(n):
m = max(m, sum(a1[:i+1])+sum(a2[i:]))
print (m)
```
| 89,962 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
n=int(input())
l=[list(map(int,input().split()))for _ in range(2)]
a=0
for i in range(n):
a=max(a,sum(l[0][:i+1])+sum(l[1][i:]))
print(a)
```
| 89,963 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
n = int(input())
a = [list(map(int,input().split())) for i in range(2)]
get = []
for i in range(n):
get =get+ [sum(a[0][:i+1]) + sum(a[1][i:])]
print(max(get))
```
| 89,964 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
n=int(input())
A_1=list(map(int,input().split()))
A_2=list(map(int,input().split()))
ans=0
for i in range(n):
c=sum(A_1[:i+1])+sum(A_2[i:])
ans=max(ans,c)
print(ans)
```
| 89,965 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
n=int(input())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
mx=0
for i in range(n):
ans=sum(x[:i+1])+sum(y[i:])
if ans>mx:
mx=ans
print(mx)
```
| 89,966 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
b=list(map(int, input().split()))
ans = 0
for i in range(n):
ans = max(ans,sum(a[:i+1])+sum(b[i:n]))
print(ans)
```
| 89,967 |
Provide a correct Python 3 solution for this coding contest problem.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
"Correct Solution:
```
N = int(input())
A = list(map(int, input().split()))
B= list(map(int, input().split()))
m=0
for i in range(N):
s=sum(A[:i+1])+sum(B[i:])
m=max(m, s)
print(m)
```
| 89,968 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
#087_C
n=int(input())
a=[[int(j) for j in input().split()] for _ in range(2)]
print(max([sum(a[0][:(i+1)])+sum(a[1][i:]) for i in range(n)]))
```
Yes
| 89,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
N=int(input())
A1=list(map(int,input().split()))
A2=list(map(int,input().split()))
ans=0
for i in range(1,N+1):
ans=max(ans,sum(A1[0:i]+A2[i-1:N]))
print(ans)
```
Yes
| 89,970 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
n=int(input())
A1 = list(map(int, input().split()))
A2 = list(map(int, input().split()))
m=-1
for i in range(n):
m=max(m, sum(A1[:i+1])+sum(A2[i:]))
print(m)
```
Yes
| 89,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
N = int(input())
A = [list(map(int,input().split())) for k in range(2)]
ans = 0
for x in range(N):
ans = max(ans,sum(A[0][:x+1])+sum(A[1][x:]))
print(ans)
```
Yes
| 89,972 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
a, b, c, x = [int(input()) for i in range(4)]
can_count = 0
for i in range(a+1):
coins_price_500 = i * 500
for j in range(b+1):
coins_price_100 = j * 100
for k in range(c+1):
coins_price_50 = k * 50
if x == coins_price_500 * coins_price_100 * coins_price_50:
can_count += 1
print(can_count)
```
No
| 89,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
def main():
n = int(input())
a_lst1 = list(map(int, input().split()))
a_lst2 = list(map(int, input().split()))
candies_lst = []
tmp = 1
while tmp <= 7:
a1_tmp = a_lst1[:tmp]
a2_tmp = a_lst2[tmp-1:]
a1 = sum(a1_tmp)
a2 = sum(a2_tmp)
tmp += 1
candies = a1 + a2
candies_lst.append(candies)
maximum = max(candies_lst)
print(maximum)
if __name__ == '__main__':
main()
```
No
| 89,974 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
n = int(input())
a = [list(map(int,input().split())) for i in range(2)]
ans = a[0][0] + a[1][-1]
for i in range(n-1):
if sum(a[0][i+1:]) >= sum(a[1][i:n-1]):
ans += a[0][i+1]
else:
ans += sum(a[1][i:n-1])
break
print(ans)
```
No
| 89,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5
Submitted Solution:
```
n=int(input())
a_list=[list(map(int,input().split())) for _ in range(2)]
top_cnts=[]
beneath_cnts=[]
top_cnt = 0
beneath_cnt=sum(a_list[1])
for a in a_list[0]:
top_cnt += a
top_cnts.append(top_cnt)
beneath_cnts.append(beneath_cnt)
beneath_cnt-=a
max_cnt = 0
for i in range(n):
cnt = top_cnts[i]+beneath_cnts[i]
if cnt >max_cnt:
max_cnt=cnt
print(max_cnt)
```
No
| 89,976 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
#72a
x,t = map(int,input().split())
print(max(x-t,0))
```
| 89,977 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
x, t = map(int, input().split())
print(x - min(x, t))
```
| 89,978 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
x,t=map(int,input().split())
print([0,x-t][x-t>0])
```
| 89,979 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
x, t = (int(i) for i in input().split())
print(max(x - t, 0))
```
| 89,980 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
x,t=map(int,input().split())
print(0if x<t else x-t)
```
| 89,981 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
x,t=map(int,input().split())
print("0" if x-t<0 else x-t)
```
| 89,982 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
print(max(eval(input().replace(" ","-")),0))
```
| 89,983 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
"Correct Solution:
```
X,t = map(int,input().split(" "))
print(max(0,X-t))
```
| 89,984 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
a,t=map(int,input().split())
print(max(0,a-t))
```
Yes
| 89,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
A,B = [int(x) for x in input().split()]
print(max(A-B,0))
```
Yes
| 89,986 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
X,t=map(int,input().split())
print(X-t if X>=t else 0)
```
Yes
| 89,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
X,t = map(int,input().split())
print(X - t if X-t>0 else 0)
```
Yes
| 89,988 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
print(input()[0:len(s):2])
```
No
| 89,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
X, t = map(int, input).split())
X -= t
if X < 0:
X = 0
print(X)
```
No
| 89,990 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
xt = list(map(int, input().split()))
print(xt[0]-xt[1])
```
No
| 89,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
Submitted Solution:
```
s = input()
for i in range(0,len(s),2):
print(s[i],end="")
```
No
| 89,992 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600
"Correct Solution:
```
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
MOD = 10**9 + 7
N,X,Y = map(int,readline().split())
CW = (tuple(int(x) for x in line.split()) for line in readlines())
C_to_W = [[] for _ in range(N+1)]
for c,w in CW:
C_to_W[c].append(w)
for c in range(N+1):
C_to_W[c].sort()
C_to_W.sort()
C_to_W = [x for x in C_to_W if x]
min_wt = C_to_W[0][0]
C_to_W = [x for x in C_to_W if x[0]+min_wt <= Y]
if len(C_to_W) <= 1:
print(1)
exit()
comp_size = [0] * (len(C_to_W))
for x in C_to_W[0]:
if x+C_to_W[0][0] <= X or x + C_to_W[1][0] <= Y:
comp_size[0] += 1
for i,arr in enumerate(C_to_W[1:],1):
for x in arr:
if x+min_wt <= Y or x+arr[0] <= X:
comp_size[i] += 1
fact = [1] * (N+1)
for i in range(1,N+1):
fact[i] = fact[i-1] * i % MOD
num = fact[sum(comp_size)]
den = 1
for x in comp_size:
den *= fact[x]
den %= MOD
answer = num * pow(den,MOD-2,MOD) % MOD
print(answer)
```
| 89,993 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600
"Correct Solution:
```
class Combination:
def __init__(self, n_max, mod=10**9+7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1):
f = f * i % mod
fac.append(f)
f = pow(f, mod-2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
import sys
N, X, Y = map(int, input().split())
CW = list(map(int, sys.stdin.read().split()))
C, W = CW[::2], CW[1::2]
mod = 10**9+7
comb = Combination(N+1)
Color_min = [10**10] * (N+1)
Color_argmin = [-1] * (N+1)
Color_2nd_min = [10**10] * (N+1)
all_min = 10**10
all_second_min = 10**10
all_min_color = -1
for i, (c, w) in enumerate(zip(C, W)):
if Color_2nd_min[c] > w:
Color_2nd_min[c] = w
if Color_min[c] > w:
Color_min[c], Color_2nd_min[c] = Color_2nd_min[c], Color_min[c]
Color_argmin[c] = i
for c, w in enumerate(Color_min):
if all_second_min > w:
all_second_min = w
if all_min > w:
all_min, all_second_min = all_second_min, all_min
all_min_color = c
In_cnt = [0] * (N+1)
Out_flag= [0] * (N+1)
for i, (c, w) in enumerate(zip(C, W)):
if (i != Color_argmin[c] and Color_min[c] + w <= X) \
or (Color_2nd_min[c] + w <= X) \
or (c != all_min_color and all_min + w <= Y) \
or (all_second_min + w <= Y):
In_cnt[c] += 1
if all_min + w <= Y:
Out_flag[c] = 1
sum_in_out = 0
ans = 1
for c, f in zip(In_cnt, Out_flag):
if f:
sum_in_out += c
ans = ans * comb.facinv[c] % mod
ans = ans * comb.fac[sum_in_out] % mod
#print(In_cnt)
#print(Out_flag)
print(ans)
```
| 89,994 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600
"Correct Solution:
```
#-----UnionFind-----(0-indexed)
import sys;sys.setrecursionlimit(10**9)
class UnionFind:
def __init__(self,n):
self.n=[-1]*n
self.r=[0]*n
self.siz=n
def find_root(self,x):
if self.n[x]<0:
return x
else:
self.n[x]=self.find_root(self.n[x])
return self.n[x]
def unite(self,x,y):
x=self.find_root(x)
y=self.find_root(y)
if x==y:return
elif self.r[x]>self.r[y]:
self.n[x]+=self.n[y]
self.n[y]=x
else:
self.n[y]+=self.n[x]
self.n[x]=y
if self.r[x]==self.r[y]:
self.r[y]+=1
self.siz-=1
def root_same(self,x,y):
return self.find_root(x)==self.find_root(y)
def count(self,x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
from collections import defaultdict
n,x,y=map(int,input().split())
mod=10**9+7
f=[1]
for i in range(1,n+7):f.append(f[-1]*i%mod)
cw=[list(map(int,input().split()))for _ in range(n)]
if n==1:exit(print(1))
if len(set(c for c,w in cw))==1:exit(print(1))
for i in range(n):cw[i][0]-=1
miw=[10**10]*n
miwi=[0]*n
for i in range(n):
c,w=cw[i]
if miw[c]>w:
miw[c]=w
miwi[c]=i
mminc=miw.index(min(miw))
temp=10**10
for i in range(n):
if i!=mminc:temp=min(temp,miw[i])
sminc=miw.index(temp)
u=UnionFind(n)
for i in range(n):
c,w=cw[i]
if c==mminc:tc=sminc
else:tc=mminc
if miw[c]+w<=x:u.unite(miwi[c],i)
if miw[tc]+w<=y:u.unite(miwi[tc],i)
d=[0]*n
for i in range(n):
if i==u.find_root(i):d[i]=defaultdict(int)
for i in range(n):
c,w=cw[i]
d[u.find_root(i)][c]+=1
ans=1
for i in range(n):
if i==u.find_root(i):
anss=1
co=0
for j in d[i]:
anss*=pow(f[d[i][j]],mod-2,mod)
anss%=mod
co+=d[i][j]
anss*=f[co]
ans=(ans*anss)%mod
print(ans)
```
| 89,995 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600
"Correct Solution:
```
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
def calc_group_num(self):
N = len(self._parent)
ans = 0
for i in range(N):
if self.find_root(i) == i:
ans += 1
return ans
mod = 10**9+7 #出力の制限
N = 2*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
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 )
import sys,bisect
input=sys.stdin.buffer.readline
N,X,Y=map(int,input().split())
cball=[[] for i in range(N)]
ball=[]
color=[-1]*N
for i in range(N):
c,w=map(int,input().split())
ball.append((w,c-1,i))
cball[c-1].append((w,i))
color[i]=c-1
for i in range(N):
cball[i].sort()
ball.sort()
if N==1:
print(1)
exit()
cmin=[10**20 for i in range(N)]
for i in range(N):
if cball[i]:
cmin[i]=min(cball[i][j][0] for j in range(len(cball[i])))
_cmine1=[cmin[i] for i in range(N)]
_cmine2=[cmin[i] for i in range(N)]
for i in range(1,N):
_cmine1[i]=min(_cmine1[i],_cmine1[i-1])
for i in range(N-2,-1,-1):
_cmine2[i]=min(_cmine2[i],_cmine2[i+1])
cmine=[0]*N
cmine[0]=_cmine2[1]
cmine[-1]=_cmine1[N-2]
for i in range(1,N-1):
cmine[i]=min(_cmine1[i-1],_cmine2[i+1])
M=min(ball)
special=-1
for i in range(N):
if cmine[i]!=M[0]:
special=i
uf=UnionFindVerSize(N)
for i in range(N):
if i!=special:
for j in range(len(cball[i])):
if M[0]+cball[i][j][0]<=Y:
uf.unite(cball[i][j][1],M[2])
if j!=0 and cball[i][j][0]+cball[i][0][0]<=X:
uf.unite(cball[i][j][1],cball[i][0][1])
else:
for j in range(len(cball[special])):
if cmine[special]+cball[special][j][0]<=Y:
uf.unite(cball[special][j][1],M[2])
if M[0]+cball[special][j][0]<=X:
uf.unite(cball[special][j][1],M[2])
connect={}
for i in range(N):
root=uf.find_root(i)
if root not in connect:
connect[root]=[]
connect[root].append(i)
ans=1
for root in connect:
cc={}
for i in connect[root]:
if color[i] not in cc:
cc[color[i]]=0
cc[color[i]]+=1
size=len(connect[root])
for C in cc:
ans*=g2[cc[C]]
ans%=mod
ans*=g1[size]
ans%=mod
print(ans)
```
| 89,996 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600
Submitted Solution:
```
N, X, Y = map( int, input().split() )
C = []
W = []
for i in range( N ):
c, w = map( int, input().split() )
C.append( c - 1 )
W.append( w )
c2w = [ [] for i in range( N ) ]
for i in range( N ):
c2w[ C[ i ] ].append( W[ i ] )
for i in range( N ):
c2w[ C[ i ] ].sort()
minw, _minwp = 2e9, -1
for i in range( N ):
if len( c2w[ i ] ) == 0: continue
if minw > c2w[ i ][ 0 ]:
minw = c2w[ i ][ 0 ]
_minwp = i
minw2 = 2e9
for i in range( N ):
if len( c2w[ i ] ) == 0: continue
if i == _minwp: continue
if minw2 > c2w[ i ][ 0 ]:
minw2 = c2w[ i ][ 0 ]
merged = [ False for i in range( N ) ]
hi = [ 1 for i in range( N ) ]
for i in range( N ):
if len( c2w[ i ] ) == 0: continue
lb, ub = 2, len( c2w[ i ] )
while lb <= ub:
mid = lb + ub >> 1
if c2w[ i ][ 0 ] + c2w[ i ][ mid - 1 ] <= X:
hi[ i ] = max( hi[ i ], mid )
lb = mid + 1
else:
ub = mid - 1
lb, ub = 1, len( c2w[ i ] )
www = minw2 if minw != minw2 and c2w[ i ][ 0 ] == minw else minw
while lb <= ub:
mid = lb + ub >> 1
if www + c2w[ i ][ mid - 1 ] <= Y:
hi[ i ] = max( hi[ i ], mid )
merged[ i ] = True
lb = mid + 1
else:
ub = mid - 1
MOD = int( 1e9 + 7 )
fact = [ 1 ]
inv_fact = [ 1 ]
for i in range( 1, N + 1, 1 ):
fact.append( fact[ i - 1 ] * i % MOD )
inv_fact.append( pow( fact[ i ], MOD - 2, MOD ) )
ans = fact[ sum( merged[ i ] * hi[ i ] for i in range( N ) ) ]
for i in range( N ):
if not merged[ i ]: continue
ans = ans * inv_fact[ hi[ i ] ] % MOD
print( ans )
```
No
| 89,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600
Submitted Solution:
```
from collections import defaultdict
mod = 10**9+7
rng = 200100
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
for i in range(1,rng):
finv.append(pow(fctr[i],mod-2,mod))
def cmb(n,k):
if n<0 or k<0:
return 0
else:
return fctr[n]*finv[n-k]*finv[k]%mod
import sys
input = sys.stdin.readline
n,X,Y = map(int,input().split())
cw = [list(map(int,input().split())) for i in range(n)]
cw.sort()
mnls = []
graph = [[] for i in range(n)]
notmn = set()
for i in range(n):
if i == 0 or cw[i-1][0] != cw[i][0]:
mnls.append((i,cw[i][0],cw[i][1]))
else:
if cw[i][1]+mnls[-1][2] <= X:
graph[i].append(mnls[-1][0])
graph[mnls[-1][0]].append(i)
else:
notmn.add(i)
mnls.sort(key = lambda x:x[2])
for i,x in enumerate(mnls):
if i == 0:
continue
if x[2]+mnls[0][2] <= Y:
graph[x[0]].append(mnls[0][0])
graph[mnls[0][0]].append(x[0])
for i in notmn:
if mnls[0][1] != cw[i][0] and mnls[0][2]+cw[i][1] <= Y:
graph[i].append(mnls[0][0])
graph[mnls[0][0]].append(i)
vis = [0 for i in range(n)]
ans = 1
for i in range(n):
if vis[i]:
continue
vis[i] = 1
stack = [i]
color = defaultdict(int)
while stack:
x = stack.pop()
color[cw[x][0]] += 1
for y in graph[x]:
if vis[y] == 0:
vis[y] = 1
stack.append(y)
sm = sum(color.values())
for v in color.values():
ans = ans*cmb(sm,v)%mod
sm -= v
print(ans)
```
No
| 89,998 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600
Submitted Solution:
```
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
def calc_group_num(self):
N = len(self._parent)
ans = 0
for i in range(N):
if self.find_root(i) == i:
ans += 1
return ans
mod = 10**9+7 #出力の制限
N = 2*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
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 )
import sys,bisect
input=sys.stdin.buffer.readline
N,X,Y=map(int,input().split())
cball=[[] for i in range(N)]
ball=[]
color=[-1]*N
for i in range(N):
c,w=map(int,input().split())
ball.append((w,c-1,i))
cball[c-1].append((w,i))
color[i]=c-1
for i in range(N):
cball[i].sort()
ball.sort()
if N==1:
print(1)
exit()
cmin=[10**20 for i in range(N)]
for i in range(N):
if cball[i]:
cmin[i]=min(cball[i][j][0] for j in range(len(cball[i])))
_cmine1=[cmin[i] for i in range(N)]
_cmine2=[cmin[i] for i in range(N)]
for i in range(1,N):
_cmine1[i]=min(_cmine1[i],_cmine1[i-1])
for i in range(N-2,-1,-1):
_cmine2[i]=min(_cmine2[i],_cmine2[i+1])
cmine=[0]*N
cmine[0]=_cmine2[1]
cmine[-1]=_cmine1[N-2]
for i in range(1,N-1):
cmine[i]=min(_cmine1[i-1],_cmine2[i+1])
uf=UnionFindVerSize(N)
for i in range(N):
n=len(cball[i])
for j in range(1,n):
id=bisect.bisect_right(cball[i],(X-cball[i][j][0],10**20))
if i==1:
if id!=0:
for k in range(id):
num1=cball[i][k][1]
num2=cball[i][j][1]
uf.unite(num1,num2)
if id!=0:
num1=cball[i][id-1][1]
num2=cball[i][j][1]
uf.unite(num1,num2)
if cball[i][j][0]+cmine[i]<=Y:
num1=cball[i][j-1][1]
num2=cball[i][j][1]
uf.unite(num1,num2)
for i in range(1,N):
id=bisect.bisect_right(ball,(Y-ball[i][0],10**20))
if i==1:
if id!=0:
for j in range(id):
num1=ball[j][2]
num2=ball[i][2]
uf.unite(num1,num2)
if id!=0:
num1=ball[id-1][2]
num2=ball[i][2]
uf.unite(num1,num2)
connect={}
for i in range(N):
root=uf.find_root(i)
if root not in connect:
connect[root]=[]
connect[root].append(i)
ans=1
for root in connect:
cc={}
for i in connect[root]:
if color[i] not in cc:
cc[color[i]]=0
cc[color[i]]+=1
size=len(connect[root])
for C in cc:
ans*=g2[cc[C]]
ans%=mod
ans*=g1[size]
ans%=mod
print(ans)
```
No
| 89,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.