input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# -*- coding:utf-8 -*-
import itertools
N, P = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = 0
odd = [ tmp for tmp in a if tmp%2 != 0]
even = [ tmp for tmp in a if tmp%2 == 0]
if P == 0:
ans += 1
b = sum([ len(list(itertools.combinations(odd,tmp))) for tmp in range(2, len(odd)+1, 2) ])
else:
b = sum([ len(list(itertools.combinations(odd,tmp))) for tmp in range(1, len(odd)+1, 2) ])
c = [ len(list(itertools.combinations(even, tmp))) for tmp in range(1, len(even)+1) ]
factor = 0
for tmp in c:
ans += tmp*b
factor += tmp
else:
if P == 0:
ans += b+factor
else:
ans += b
print(ans) | # -*- coding:utf-8 -*-
import itertools, math
N, P = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = 0
odd = [ tmp for tmp in a if tmp%2 != 0]
even = [ tmp for tmp in a if tmp%2 == 0]
d = math.factorial(len(odd))
e = math.factorial(len(even))
if P == 0:
ans += 1
b = sum([ (d//math.factorial(len(odd)-tmp))//math.factorial(tmp) for tmp in range(2, len(odd)+1, 2) ])
else:
b = sum([ (d//math.factorial(len(odd)-tmp))//math.factorial(tmp) for tmp in range(1, len(odd)+1, 2) ])
c = [ (e//math.factorial(len(even)-tmp))//math.factorial(tmp) for tmp in range(1, len(even)+1) ]
for tmp in c:
ans += tmp*b
else:
if P == 0:
ans += b+sum(c)
else:
ans += b
print(ans) | p03665 |
import functools
import math
@functools.lru_cache()
def combinations(n, r):
return math.factorial(n) / math.factorial(r) / math.factorial(n - r)
def main():
n, p = list(map(int, input().split()))
a = tuple([int(x) % 2 for x in input().split()])
if n == 1 and a[0] % 2 != p:
print((0))
return 0
t = len(tuple([x for x in a if x == 1]))
f = n - t
count = 0
if p == 0:
for i in range(t + 1):
if i % 2 == 0:
c = 0
for j in range(f + 1):
c += combinations(f, j)
count += combinations(t, i) * c
else:
for i in range(t + 1):
if i % 2 == 1:
c = 0
for j in range(f + 1):
c += combinations(f, j)
count += combinations(t, i) * c
print((int(count)))
return 0
if __name__ == '__main__':
main()
| import math
def comb(n, r):
return math.factorial(n) / math.factorial(r) / math.factorial(n - r)
def main():
n, p = list(map(int, input().split()))
a = tuple([int(x) % 2 for x in input().split()])
if n == 1 and a[0] % 2 != p:
print((0))
return 0
t = len(tuple([x for x in a if x == 1]))
f = n - t
f_comb = 0
for j in range(f + 1):
f_comb += comb(f, j)
t_comb = 0
if p == 0:
for i in range(t + 1):
if i % 2 == 0:
t_comb += comb(t, i)
else:
for i in range(t + 1):
if i % 2 == 1:
t_comb += comb(t, i)
print((int(t_comb * f_comb)))
return 0
if __name__ == '__main__':
main()
| p03665 |
N,P=list(map(int, input().split()))
*A,=list(map(int, input().split()))
even=sum(1 for a in A if a&1==0)
odd =sum(1 for a in A if a&1==1)
def comb(n, r):
p, q = 1, 1
for i in range(min(r,n-r)):
p *= n-i
q *= i+1
return p // q
ans=0
for i in range(P,odd+1,2):
ans+=comb(odd, i)
ans *= 1<<even
print(ans) | N,P=list(map(int, input().split()))
*A,=list(map(int, input().split()))
odd=sum(1 for a in A if a&1)
if odd==0:
if P==1:
print((0))
else:
print((1<<N))
else:
print((1<<(N-1))) | p03665 |
#AGC017A
def f():
res=1
for x in a:
if x%2==0:
res*=1
else:
res=0
return res
return res
n,p=list(map(int,input().split()))
a=list(map(int,input().split()))
if f()==1 and p==0:
print(2**n)
elif f()==1 and p==1:
print(0)
else:
print(2**(n-1))
| def f():
for x in a:
if x%2==0:
continue
else:
return False
return True
n,p=list(map(int,input().split()))
a=list(map(int,input().split()))
if f()==True and p==0:
print(2**n)
elif f()==True and p==1:
print(0)
else:
print(2**(n-1))
| p03665 |
n, p = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [[0] * 2 for _ in range(n + 1)]
dp[0][0] = 1
for i, e in enumerate(a, 1):
if e % 2:
dp[i][0] = dp[i-1][0] + dp[i-1][1]
dp[i][1] = dp[i-1][1] + dp[i-1][0]
else:
dp[i][0] = dp[i-1][0] * 2
dp[i][1] = dp[i-1][1] * 2
print((dp[n][p]))
| n, p = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [[0] * 2 for _ in range(n + 1)]
dp[0][0] = 1
for i, e in enumerate(a, 1):
for j in range(2):
r = e % 2
dp[i][j] = dp[i-1][j] + dp[i-1][(j-r)%2]
print((dp[n][p]))
| p03665 |
n,p = list(map(int,input().split()))
an = [int(i) for i in input().split()]
dpo = [0]*n
dpe = [0]*n
if an[0] % 2 == 0:
dpe[0] = 2
else:
dpo[0] = 1
dpe[0] = 1
for i in range(1,n):
if an[i] % 2 == 0:
dpe[i] = dpe[i-1] * 2
dpo[i] = dpo[i-1] * 2
else:
dpe[i] = dpe[i-1] + dpo[i-1]
dpo[i] = dpo[i-1] + dpe[i-1]
if p:
print((dpo[n-1]))
else:
print((dpe[n-1])) | n,p = list(map(int,input().split()))
an = [int(i) for i in input().split()]
x = 0
for i in an:
x |= i%2
if x:
print((2**(n-1)))
else:
if p:
print((0))
else:
print((2**n)) | p03665 |
from math import factorial
def cmb(n,r):
return factorial(n)//(factorial(n-r)*factorial(r))
n,p=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[A[i]%2 for i in range(n)]
cnt=A.count(0)
B=2**cnt
ans=0
for i in range(p,n-cnt+1,2):
ans +=cmb(n-cnt,i)
print((ans*B)) | from math import factorial
def cmb(n,r):
return factorial(n)//(factorial(n-r)*factorial(r))
n,p=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[A[i]%2 for i in range(n)]
cnt=A.count(0)
ans=0
for i in range(p,n-cnt+1,2):
ans +=cmb(n-cnt,i)
print((ans*(2**cnt))) | p03665 |
from math import factorial
def cmb(n,r):
return factorial(n)//(factorial(n-r)*factorial(r))
n,p=list(map(int,input().split()))
A=list(map(int,input().split()))
A=[A[i]%2 for i in range(n)]
cnt=A.count(0)
ans=0
for i in range(p,n-cnt+1,2):
ans +=cmb(n-cnt,i)
print((ans*(2**cnt))) | from math import factorial
n,p=list(map(int,input().split()))
A=list(map(int,input().split()))
a,b=0,0
for i in A:
if i%2==0:a +=1
else:b +=1
cnt=0 if p==1 else 1
for i in range(p,b+1,2):
if i==0:continue
cnt +=factorial(b)//(factorial(i)*factorial(b-i))
print((cnt*(2**a))) | p03665 |
from collections import Counter
def combination(n, r): # nCrを求める
r = min(n-r, r)
result = 1
for i in range(n, n-r, -1):
result *= i
for i in range(1, r+1):
result //= i
return result
n,p = list(map(int,input().split()))
a =list(map(int,input().split()))
for i in range(n):
a[i] = a[i]%2
b = Counter(a)
c = b[1]
d = b[0]
ans = 0
if p ==0:
for i in range(0,c+1,2):
ans += combination(c,i)
else:
for i in range(1,c+1,2):
ans += combination(c, i)
ans *= 2**d
print(ans) | n, m = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [i%2 for i in a]
if sum(a)>0:print((2**(n-1)))
else:
if m == 0:print((2**n))
else:print((0)) | p03665 |
n,p=list(map(int,input().split()))
a=[int(x)%2 for x in input().split()]
even=0
for aa in a:
if aa%2==0:
even+=1
if even==n:
if p==0:
print((2**n))
else:
print((0))
else:
print((2**(n-1)))
| n,p=list(map(int,input().split()))
a=list(map(int,input().split()))
even=0
for aa in a:
if aa%2==0:
even+=1
if even==n:
if p==0:
print((2**n))
exit(0)
else:
print((0))
exit(0)
print((2**(n-1)))
| p03665 |
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right #func(リスト,値)
from heapq import heapify, heappop, heappush
from math import *
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
N,P = mint()
A = lint()
even = len([a for a in A if a%2==0])
odd = N-even
if odd==0:
print(0 if P else 2**N)
else:
print(2**(N-1))
| import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right #func(リスト,値)
from heapq import heapify, heappop, heappush
from math import *
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
N,P = mint()
A = lint()
odd = len([a for a in A if a%2!=0])
if odd==0:
print(0 if P else 2**N)
else:
print(2**(N-1))
| p03665 |
import sys
readline = sys.stdin.readline
S = list(map(ord, readline().strip()))
N = len(S)
S = [None] + S + [None]
K = int(readline())
if N == 1:
ans = 1
elif N == 2:
ans = 1
if S[1] == S[2]:
ans = 2
if K:
ans = 2
else:
dp1 = [[0]*(K+1) for _ in range(N+2)]
dp2 = [[0]*(K+1) for _ in range(N+2)]
for i in range(1, N+1):
dp1[i][0] = 1
for i in range(1, N):
dp2[i][0] = 1
if S[i] == S[i+1]:
dp2[i][0] = 2
elif K:
dp2[i][1] = 2
for s in range(3, N+1):
dp3 = [[0]*(K+1) for _ in range(N+2)]
for i in range(1, N-s+2):
j = i+s-1
if S[i] == S[j]:
for k in range(K+1):
dp3[i][k] = max(dp2[i+1][k], dp2[i][k], 2+dp1[i+1][k])
else:
dp3[i][0] = max(dp2[i+1][0], dp2[i][0], dp2[i+1][0])
for k in range(1, K+1):
dp3[i][k] = max(dp2[i+1][k], dp2[i][k], dp1[i+1][k], 2+dp1[i+1][k-1])
dp1 = [k[:] for k in dp2]
dp2 = [k[:] for k in dp3]
ans = max(dp3[1][k] for k in range(K+1))
print(ans)
'''
MLEした
dp = [[[0]*(K+1) for _ in range(N+2)] for _ in range(N+2)]
for i in range(1, N+1):
dp[i][i][0] = 1
for i in range(1, N):
dp[i][i+1][0] = 1
if S[i] == S[i+1]:
dp[i][i+1][0] = 2
elif K:
dp[i][i+1][1] = 2
for s in range(3, N+1):
for i in range(1, N-s+2):
j = i+s-1
if S[i] == S[j]:
for k in range(K+1):
dp[i][j][k] = max(dp[i+1][j][k], dp[i][j-1][k], 2+dp[i+1][j-1][k])
else:
dp[i][j][0] = max(dp[i+1][j][0], dp[i][j-1][0], dp[i+1][j-1][0])
for k in range(1, K+1):
dp[i][j][k] = max(dp[i+1][j][k], dp[i][j-1][k], dp[i+1][j-1][k], 2+dp[i+1][j-1][k-1], dp[i+1][j-1][k])
print(max(dp[1][N][k] for k in range(K+1)))
''' | import sys
readline = sys.stdin.readline
S = list(map(ord, readline().strip()))
N = len(S)
S = [None] + S + [None]
K = int(readline())
if N == 1:
ans = 1
elif N == 2:
ans = 1
if S[1] == S[2]:
ans = 2
if K:
ans = 2
else:
dp1 = [[0]*(K+1) for _ in range(N+2)]
dp2 = [[0]*(K+1) for _ in range(N+2)]
for i in range(1, N+1):
dp1[i][0] = 1
for i in range(1, N):
dp2[i][0] = 1
if S[i] == S[i+1]:
dp2[i][0] = 2
elif K:
dp2[i][1] = 2
for s in range(3, N+1):
dp3 = [[0]*(K+1) for _ in range(N+2)]
for i in range(1, N-s+2):
j = i+s-1
if S[i] == S[j]:
for k in range(K+1):
dp3[i][k] = max(dp2[i+1][k], dp2[i][k], 2+dp1[i+1][k])
else:
dp3[i][0] = max(dp2[i+1][0], dp2[i][0], dp2[i+1][0])
for k in range(1, K+1):
dp3[i][k] = max(dp2[i+1][k], dp2[i][k], dp1[i+1][k], 2+dp1[i+1][k-1])
'''
dp1 = [k[:] for k in dp2]
dp2 = [k[:] for k in dp3]
'''
dp1 = dp2[:]
dp2 = dp3[:]
ans = max(dp3[1][k] for k in range(K+1))
print(ans)
'''
MLEした
dp = [[[0]*(K+1) for _ in range(N+2)] for _ in range(N+2)]
for i in range(1, N+1):
dp[i][i][0] = 1
for i in range(1, N):
dp[i][i+1][0] = 1
if S[i] == S[i+1]:
dp[i][i+1][0] = 2
elif K:
dp[i][i+1][1] = 2
for s in range(3, N+1):
for i in range(1, N-s+2):
j = i+s-1
if S[i] == S[j]:
for k in range(K+1):
dp[i][j][k] = max(dp[i+1][j][k], dp[i][j-1][k], 2+dp[i+1][j-1][k])
else:
dp[i][j][0] = max(dp[i+1][j][0], dp[i][j-1][0], dp[i+1][j-1][0])
for k in range(1, K+1):
dp[i][j][k] = max(dp[i+1][j][k], dp[i][j-1][k], dp[i+1][j-1][k], 2+dp[i+1][j-1][k-1], dp[i+1][j-1][k])
print(max(dp[1][N][k] for k in range(K+1)))
''' | p03430 |
# ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)
def get_fact(lim):
# compute a toble of factorials (1-idx)
fact = [1] * (lim + 1)
x = 1
for i in range(1, lim + 1):
x = (x * i) % MOD
fact[i] = x
return fact
def get_inv(lim):
# compute a toble of inverse factorials (1-idx)
inv = [1] * (lim + 1)
inv[lim] = pow(fact[lim], MOD - 2, MOD)
x = inv[lim]
for i in range(lim - 1, 0, -1):
x = (x * (i + 1)) % MOD
inv[i] = x
return inv
def comb(n: int, r: int) -> int:
# compute nCr (n! / r!(n - r)!)
return fact[n] * inv[n - r] * inv[r]
def main():
global MOD, fact, inv
H, W, A, B = tuple(map(int, input().split()))
MOD = 10 ** 9 + 7
fact = get_fact(H + W)
inv = get_inv(H + W)
ans = 0
for i in range(B, W):
ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | # ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)
def get_fact(lim):
# compute a toble of factorials (1-idx)
fact = [1] * (lim + 1)
x = 1
for i in range(1, lim + 1):
x = (x * i) % MOD
fact[i] = x
return fact
def get_inv(lim):
# compute a toble of inverse factorials (1-idx)
inv = [1] * (lim + 1)
inv[lim] = pow(fact[lim], MOD - 2, MOD)
x = inv[lim]
for i in range(lim - 1, 0, -1):
x = (x * (i + 1)) % MOD
inv[i] = x
return inv
def comb(n: int, r: int) -> int:
# compute nCr (n! / r!(n - r)!)
return fact[n] * inv[n - r] * inv[r]
def main():
global MOD, fact, inv
H, W, A, B = tuple(map(int, input().split()))
MOD = 10 ** 9 + 7
fact = get_fact(H + W)
inv = get_inv(H + W)
ans = 0
x, y = H - A - 1, W + A - 2
for i in range(B, W):
ans += comb(x + i, i) * comb(y - i, A - 1)
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | p04040 |
"""
fast way to compute a combination using inverse factorials
O(N) to construct tables -> O(1) to compute each combination
"""
def get_factorials(limit: int, MOD: int) -> list:
"""Compute a mod table of factorials (1-indexed)."""
factorials = [0] * (limit + 1)
factorials[0] = 1
x = 1
for i in range(1, limit + 1):
x = (x * i) % MOD
factorials[i] = x
return factorials
def mod_comb_with_pow(n: int, k: int, MOD: int) -> int:
"""Compute nCr % MOD using pow()."""
return fact[n] * pow(fact[k], MOD - 2, MOD) * pow(fact[n - k], MOD - 2, MOD) % MOD
# e.g. ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)
def main():
global fact, inv
H, W, A, B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
fact = get_factorials(H + W, MOD)
x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables
f = lambda i: mod_comb_with_pow(x + i, i, MOD) * mod_comb_with_pow(y - i, a, MOD)
ans = sum(f(i) for i in range(B, W)) % MOD
print(ans)
if __name__ == "__main__":
main()
| """
fast way to compute a combination using inverse factorials
O(N) to construct tables -> O(1) to compute each combination
"""
def get_fact_and_inv(limit: int, MOD: int) -> tuple:
"""Compute mod tables of factorials and inverse factorials (1-indexed)."""
factorials = [0] * (limit + 1)
factorials[0] = 1
x = 1
for i in range(1, limit + 1):
x = (x * i) % MOD
factorials[i] = x
inverse_factorials = [1] * (limit + 1)
inverse_factorials[-1] = pow(factorials[-1], MOD - 2, MOD)
x = inverse_factorials[-1]
for i in range(limit - 1, 0, -1):
x = (x * (i + 1)) % MOD
inverse_factorials[i] = x
return factorials, inverse_factorials
def mod_comb(n: int, r: int, MOD: int) -> int:
"""Compute nCr % MOD using a mod table of inverse factorials."""
return fact[n] * inv[r] * inv[n - r] % MOD
# e.g. ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)
def main():
global fact, inv
H, W, A, B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
fact, inv = get_fact_and_inv(H + W, MOD)
x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables
f = lambda i: mod_comb(x + i, i, MOD) * mod_comb(y - i, a, MOD) % MOD
ans = sum(f(i) for i in range(B, W)) % MOD
print(ans)
if __name__ == "__main__":
main()
| p04040 |
"""
fast way to compute a combination using inverse factorials
O(N) to construct tables -> O(1) to compute each combination
"""
def get_fact_and_inv(limit: int, MOD: int) -> tuple:
"""Compute mod tables of factorials and inverse factorials (1-indexed)."""
factorials = [0] * (limit + 1)
factorials[0] = 1
x = 1
for i in range(1, limit + 1):
x = (x * i) % MOD
factorials[i] = x
inverse_factorials = [1] * (limit + 1)
inverse_factorials[-1] = pow(factorials[-1], MOD - 2, MOD)
x = inverse_factorials[-1]
for i in range(limit - 1, 0, -1):
x = (x * (i + 1)) % MOD
inverse_factorials[i] = x
return factorials, inverse_factorials
def mod_comb(n: int, r: int, MOD: int) -> int:
"""Compute nCr % MOD using a mod table of inverse factorials."""
return fact[n] * inv[r] * inv[n - r] % MOD
# e.g. ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)
def main():
global fact, inv
H, W, A, B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
fact, inv = get_fact_and_inv(H + W, MOD)
x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables
f = lambda i: mod_comb(x + i, i, MOD) * mod_comb(y - i, a, MOD) % MOD
ans = sum(f(i) for i in range(B, W)) % MOD
print(ans)
if __name__ == "__main__":
main()
| """
fast way to compute a combination using inverse factorials
O(N) to construct tables -> O(1) to compute each combination
"""
def get_fact_and_inv(limit: int, MOD: int) -> tuple:
"""Compute mod tables of factorials and inverse factorials (1-indexed)."""
factorials = [0] * (limit + 1)
factorials[0] = 1
x = 1
for i in range(1, limit + 1):
x = x * i % MOD
factorials[i] = x
inverse_factorials = [1] * (limit + 1)
inverse_factorials[-1] = pow(factorials[-1], MOD - 2, MOD)
x = inverse_factorials[-1]
for i in range(limit - 1, 0, -1):
x = x * (i + 1) % MOD
inverse_factorials[i] = x
return factorials, inverse_factorials
def mod_comb(n: int, r: int, MOD: int) -> int:
"""Compute nCr % MOD using a mod table of inverse factorials."""
return fact[n] * inv[r] * inv[n - r] % MOD
# e.g. ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)
def main():
global fact, inv
H, W, A, B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
fact, inv = get_fact_and_inv(H + W, MOD)
x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables
f = lambda i: mod_comb(x + i, i, MOD) * mod_comb(y - i, a, MOD)
ans = sum(f(i) for i in range(B, W)) % MOD
print(ans)
if __name__ == "__main__":
main()
| p04040 |
BIG = (10 ** 9) + 7
f_list = [1] * 200000
f_r_list = [1] * 200000
for i in range(199999):
f_list[i + 1] = int((f_list[i] * (i + 2)) % BIG)
def power(n, x):
if x == 1:
return n
elif x % 2 == 0:
return power(int((n * n) % BIG), int(x / 2))
else:
return int((n * power(n, x - 1)) % BIG)
for i in range(200000):
f_r_list[i] = power(f_list[i], BIG - 2)
def comb(n, r):
if n == 0 or r == 0 or n == r:
return 1
else:
return (((f_list[n - 1] * f_r_list[n - r - 1]) % BIG) * f_r_list[r - 1]) % BIG
h, w, a, b = list(map(int, input().split()))
ans = 0
for i in range(h - a):
ans = int((ans + int((comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)) % BIG)) % BIG)
print((int(ans))) | BIG = (10 ** 9) + 7
f_list = [1] * 200000
f_r_list = [1] * 200000
for i in range(199999):
f_list[i + 1] = int((f_list[i] * (i + 2)) % BIG)
def power(n, x):
if x == 1:
return n
elif x % 2 == 0:
return power(int((n * n) % BIG), int(x / 2))
else:
return int((n * power(n, x - 1)) % BIG)
f_r_list[-1] = power(f_list[-1], BIG - 2)
for i in range(2, 200001):
f_r_list[-i] = int((f_r_list[-i + 1] * (200002 - i)) % BIG)
def comb(n, r):
if n == 0 or r == 0 or n == r:
return 1
else:
return (((f_list[n - 1] * f_r_list[n - r - 1]) % BIG) * f_r_list[r - 1]) % BIG
h, w, a, b = list(map(int, input().split()))
ans = 0
for i in range(h - a):
ans = int((ans + int((comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)) % BIG)) % BIG)
print((int(ans))) | p04040 |
from sys import stdin, stdout, stderr, setrecursionlimit
from functools import lru_cache
setrecursionlimit(10**7)
mod = 10**9 + 7
def solve():
def binom(n, k):
res = (modfact[n] * factinv[k]) % mod
res = (res * factinv[n - k]) % mod
return res
h, w, a, b = list(map(int, input().split()))
ans = 0
modfact = [1] * (h + w)
factinv = [1] * (h + w)
for i in range(1, h + w):
modfact[i] = (i * modfact[i - 1]) % mod
factinv[i] = (pow(i, mod - 2, mod) * factinv[i - 1]) % mod
for i in range(h - a):
ans += (binom(b + i - 1, i) * binom(w + h - b - i - 2, h - i - 1)) % mod
ans %= mod
print(ans)
'''
@lru_cache(maxsize=None)
def binom(n, k):
res = (modfact(n) * factinv(k)) % mod
res = (res * factinv(n - k)) % mod
return res
@lru_cache(maxsize=None)
def modfact(n):
if n == 0:
return 1
return (n * modfact(n - 1)) % mod
@lru_cache(maxsize=None)
def factinv(n):
if n == 0:
return 1
return (pow(n, mod - 2, mod) * factinv(n - 1)) % mod
'''
if __name__ == '__main__':
solve() | from sys import stdin, stdout, stderr
mod = 10**9 + 7
def solve():
def binom(n, k):
res = (modfact[n] * factinv[k]) % mod
res = (res * factinv[n - k]) % mod
return res
h, w, a, b = list(map(int, input().split()))
ans = 0
modfact = [1] * (h + w)
factinv = [1] * (h + w)
inv = [1] * (h + w)
for i in range(2, h + w):
modfact[i] = (i * modfact[i - 1]) % mod
inv[i] = (-(mod // i) * inv[mod % i]) % mod
factinv[i] = (inv[i] * factinv[i - 1]) % mod
for i in range(h - a):
ans += (binom(b + i - 1, i) * binom(w + h - b - i - 2, h - i - 1)) % mod
ans %= mod
print(ans)
if __name__ == '__main__':
solve() | p04040 |
from sys import stdin, stdout, stderr
mod = 10**9 + 7
def solve():
def binom(n, k):
res = (modfact[n] * factinv[k]) % mod
res = (res * factinv[n - k]) % mod
return res
h, w, a, b = list(map(int, input().split()))
ans = 0
modfact = [1] * (h + w)
factinv = [1] * (h + w)
inv = [1] * (h + w)
for i in range(2, h + w):
modfact[i] = (i * modfact[i - 1]) % mod
inv[i] = (-(mod // i) * inv[mod % i]) % mod
factinv[i] = (inv[i] * factinv[i - 1]) % mod
for i in range(h - a):
ans += (binom(b + i - 1, i) * binom(w + h - b - i - 2, h - i - 1)) % mod
ans %= mod
print(ans)
if __name__ == '__main__':
solve() | from sys import stdin, stdout, stderr
mod = 10**9 + 7
def solve():
def binom(n, k):
res = (modfact[n] * factinv[k]) % mod
res = (res * factinv[n - k]) % mod
return res
h, w, a, b = list(map(int, input().split()))
ans = 0
modfact = [1] * (h + w)
factinv = [1] * (h + w)
inv = [1] * (h + w)
for i in range(2, h + w):
modfact[i] = (i * modfact[i - 1]) % mod
factinv[h + w - 1] = pow(modfact[h + w - 1], mod - 2, mod)
for i in range(h + w - 2, 0, -1):
factinv[i] = (factinv[i + 1] * (i + 1)) % mod
for i in range(h - a):
ans += (binom(b + i - 1, i) * binom(w + h - b - i - 2, h - i - 1)) % mod
ans %= mod
print(ans)
if __name__ == '__main__':
solve() | p04040 |
# -*- coding: utf-8 -*-
"""
Created on Sun Jun 24 18:23:54 2018
ITP22C
@author: maezawa
"""
from collections import deque
n, q = list(map(int, input().split()))
a = [deque() for _ in range(n)]
for i in range(q):
c = list(map(int, input().split()))
if c[0] == 0:
if a[c[1]]:
if a[c[1]][-1] < c[2]:
a[c[1]].append(c[2])
elif a[c[1]][0] > c[2]:
a[c[1]].appendleft(c[2])
else:
left = 0
right = len(a[c[1]])-1
while right - left > 1:
mid = (right + left)//2
if a[c[1]][mid] < c[2]:
left = mid
else:
right = mid
a[c[1]].insert(right, c[2])
else:
a[c[1]].append(c[2])
elif c[0] == 1:
if a[c[1]]:
print((a[c[1]][-1]))
else:
if a[c[1]]:
a[c[1]].pop()
| import heapq
n, q = list(map(int, input().split()))
a = [[] for _ in range(n)]
for i in range(q):
c = list(map(int, input().split()))
if c[0] == 0:
heapq.heappush(a[c[1]],-c[2])
elif c[0] == 1:
if a[c[1]]:
print((-a[c[1]][0]))
else:
if a[c[1]]:
heapq.heappop(a[c[1]])
| p02437 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
s = str(input().rstrip('\n'))
print(("NO" if s.count("x") >= 8 else "YES"))
if __name__ == '__main__':
solve()
| import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
s = str(input().rstrip('\n'))
print(("YES" if s.count("x") < 8 else "NO"))
if __name__ == '__main__':
solve()
| p03024 |
N,X=list(map(int,input().split()))
above=[0]*N
now=0
data=[0]*N
for i in range(N):
b,l,u=list(map(int,input().split()))
above[i]=(i,b*l+(X-b)*u)
data[i]=(b,l,u)
now-=l*b
above.sort(key=lambda x:x[1],reverse=True)
used=set()
ans=0
idx=0
for i in range(N):
if now+above[i][1]<0:
now+=above[i][1]
used|={above[i][0]}
ans+=X
idx=i+1
else:
break
base=ans
ans+=X
now*=-1
for i in range(N):
b,l,u=data[i]
if i in used:
now0=now+b*l+(X-b)*u
M=base-X
else:
now0=now
M=base
for i in range(idx,N):
if now0+above[i][1]<0:
now+=above[i][1]
if now0<=b*l:
ans=min(ans,M+(now0+l-1)//l)
elif now0<=b*l+(X-b)*u:
ans=min(ans,M+b+(now0-b*l+u-1)//u)
print(ans) | N,X=list(map(int,input().split()))
data=[0]*N
A=[0]*N
zero=0
for i in range(N):
b,l,u=list(map(int,input().split()))
zero-=l*b
data[i]=(b,l,u)
A[i]=(i,(X-b)*u+b*l)
A.sort(key=lambda x:x[1],reverse=True)
S=[0]*N
idx=[0]*N
for i,a in enumerate(A):
S[i]=S[i-1]+a[1]
idx[a[0]]=i
def check(k):
q=k//X
r=k-q*X
for i in range(N):
b,l,u=data[i]
if q==0:
now=zero
elif idx[i]<q:
now=zero+S[q]-A[idx[i]][1]
else:
now=zero+S[q-1]
if r<=b:
now+=r*l
else:
now+=(r-b)*u+b*l
if now>=0:
return True
return False
Mincan=N*X
Maxcant=-1
c=(1,2)
while True:
if Maxcant+1==Mincan:
ans=Mincan
break
x=N*X*c[0]//c[1]
if check(x):
if Mincan>x:
Mincan=x
c=(c[0]*2-1,c[1]*2)
else:
if Maxcant<x:
Maxcant=x
c=(c[0]*2+1,c[1]*2)
print(ans) | p03019 |
import sys
from bisect import bisect_left
from itertools import accumulate
from operator import itemgetter
n, x = list(map(int, input().split()))
exams = []
norma = 0
for i, line in enumerate(sys.stdin):
b, l, u = list(map(int, line.split()))
exams.append((u * x - b * (u - l), b, l, u, i))
norma += b * l
exams_sorted = sorted(exams, reverse=True)
exams_acc = list(accumulate(list(map(itemgetter(0), exams_sorted))))
exams_loc = {i: loc for loc, i in enumerate(map(itemgetter(4), exams_sorted))}
# print(norma)
# print(exams_sorted)
# print(exams_acc)
ans = 10 ** 10
base_loc = bisect_left(exams_acc, norma)
base_ans = base_loc * x
base_remain_norma = norma - exams_acc[base_loc - 1] if base_loc > 0 else norma
# print(f'base_remain_norma:{base_remain_norma}')
for d, b, l, u, i in exams:
exam_loc = exams_loc[i]
if base_loc <= exam_loc:
curr_ans = base_ans
curr_remain_norma = base_remain_norma
else:
tmp_norma = norma + d
tmp_loc = bisect_left(exams_acc, tmp_norma)
curr_ans = (tmp_loc - 1) * x
curr_remain_norma = tmp_norma - exams_acc[tmp_loc - 1]
if curr_remain_norma <= b * l:
extra = (curr_remain_norma - 1) // l + 1
else:
extra = (curr_remain_norma + b * (u - l) - 1) // u + 1
# print(d, b, l, u, i)
# print(f'exl:{exam_loc} {int(base_loc <= exam_loc)} norma:{curr_remain_norma} curans:{curr_ans} '
# f'extra:{extra}')
if extra > x:
continue
ans = min(ans, curr_ans + extra)
print(ans)
| import sys
n, x = list(map(int, input().split()))
exams = []
norma = 0
for i, line in enumerate(sys.stdin):
b, l, u = list(map(int, line.split()))
exams.append((u * x - b * (u - l), b, l, u, i))
norma += b * l
exams_sorted = sorted(exams, reverse=True)
remain_norma = norma
sub_d = -1
i = 0
used = set()
for i, (d, b, l, u, ei) in enumerate(exams_sorted):
if remain_norma < d:
sub_d = d
break
remain_norma -= d
used.add(ei)
if sub_d == -1:
print((n * x))
exit()
base_ans = i * x
base_remain_norma = remain_norma
ans = 10 ** 10
for d, b, l, u, i in exams:
if i in used:
curr_remain_norma = base_remain_norma + d - sub_d
else:
curr_remain_norma = base_remain_norma
if curr_remain_norma <= b * l:
extra = (curr_remain_norma - 1) // l + 1
else:
extra = (curr_remain_norma + b * (u - l) - 1) // u + 1
if extra > x:
continue
ans = min(ans, base_ans + extra)
print(ans)
| p03019 |
n, x = list(map(int, input().split()))
B = 0
blu = []
for i in range(n):
b, l, u = list(map(int, input().split()))
blu.append((b, l, u, x*u-b*u+b*l))
B += b*l
blu.sort(key=lambda x: x[3], reverse=True)
ans = n*x
for i in range(n):
ok = n*x
ng = -1
while ok-ng>1:
A = 0
tB = B
mid = (ok+ng)//2
k = mid//x
t = mid%x
for j in range(n):
if j!=i and k>0:
A += x*blu[j][2]
tB += blu[j][0]*(blu[j][2]-blu[j][1])
k -= 1
elif k<=0:
break
if t!=0:
if t<=blu[i][0]:
A += t*blu[i][1]
else:
A += t*blu[i][2]
tB += blu[i][0]*(blu[i][2]-blu[i][1])
if A>=tB:
ok = mid
else:
ng = mid
ans = min(ans, ok)
print(ans) | n, x = list(map(int, input().split()))
B = 0
blu = []
s = [0 for i in range(n)]
for i in range(n):
b, l, u = list(map(int, input().split()))
blu.append((b, l, u, x*u-b*u+b*l))
B += b*l
blu.sort(key=lambda x: x[3], reverse=True)
for i in range(n):
if i==0:
s[i] = blu[i][3]
else:
s[i] = s[i-1] + blu[i][3]
ok = n*x
ng = -1
while ok-ng>1:
A = 0
mid = (ok+ng)//2
k = mid//x
t = mid%x
for i in range(n):
if t<=blu[i][0]:
rm = t*blu[i][1]
else:
rm = t*blu[i][2] - blu[i][0]*(blu[i][2]-blu[i][1])
if k==0:
A = max(A, rm)
elif i<k:
A = max(A, s[k]-blu[i][3]+rm)
else:
A = max(A, s[k-1]+rm)
if A>=B:
ok = mid
else:
ng = mid
print(ok) | p03019 |
N, X = list(map(int, input().split()))
items = []
for i in range(N):
b, l, u = list(map(int, input().split()))
items.append((b, l, u, u * (X - b), - b * l))
items = sorted(items, key=lambda x: -(x[3] - x[4]))
def f(num):
cnt = num // X
mod = num % X
point = 0
for i in range(cnt):
point += items[i][3]
for i in range(cnt, N):
point += items[i][4]
if mod == 0:
if point >= 0:
return True
else:
return False
else:
tmp = -float("inf")
for i, tmp2 in enumerate(items):
b, l, u, d1, d2 = tmp2
if mod >= b:
mul = u * (mod - b)
else:
mul = l * (mod - b)
if i < cnt:
tmp = max(tmp, point - d1 + mul + items[cnt][3] - items[cnt][4])
else:
tmp = max(tmp, point - d2 + mul)
if tmp >= 0:
return True
else:
return False
ok = N * X + 1
ng = - 1
while (ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
print(ok)
| N, X = list(map(int, input().split()))
items = []
for i in range(N):
b, l, u = list(map(int, input().split()))
items.append((b, l, u, u * (X - b), - b * l))
items = sorted(items, key=lambda x: -(x[3] - x[4]))
def f(num):
cnt = num // X
mod = num % X
point = 0
for i in range(cnt):
point += items[i][3]
for i in range(cnt, N):
point += items[i][4]
if mod == 0:
if point >= 0:
return True
else:
return False
else:
tmp = -float("inf")
for i in range(N):
b, l, u, d1, d2 = items[i]
if mod >= b:
mul = u * (mod - b)
else:
mul = l * (mod - b)
if i < cnt:
tmp = max(tmp, point - d1 + mul + items[cnt][3] - items[cnt][4])
else:
tmp = max(tmp, point - d2 + mul)
if tmp >= 0:
return True
else:
return False
ok = N * X + 1
ng = - 1
while (ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
print(ok)
| p03019 |
import sys
input = sys.stdin.readline
N,X=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(N)]
A.sort(key=lambda x:x[2]*(X-x[0])+x[0]*x[1],reverse=True)
ALL=[a[2]*(X-a[0])+a[0]*a[1] for a in A]
from itertools import accumulate
SUM=[0]+list(accumulate(ALL))
MAX=0
MINUS=0
for a,r,l in A:
MAX+=a
MINUS+=a*r
OUT=-1
def binsearch(score):
alluse=score//X
rest=score-alluse*X
for ri in range(N):
plus=0
if rest<A[ri][0]:
plus+=rest*A[ri][1]
else:
plus+=rest*A[ri][2]+A[ri][0]*A[ri][1]-A[ri][0]*A[ri][2]
if alluse<=ri:
plus+=SUM[alluse]
else:
plus+=SUM[alluse+1]-ALL[ri]
#print(score,ri,plus)
if plus>=MINUS:
return 1
return 0
while MAX-OUT>1:
mid=(MAX+OUT)//2
x=binsearch(mid)
if x==1:
MAX=mid
else:
OUT=mid
print(MAX)
| import sys
input = sys.stdin.readline
N,X=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(N)]
A.sort(key=lambda x:x[2]*(X-x[0])+x[0]*x[1],reverse=True)
ALL=[a[2]*(X-a[0])+a[0]*a[1] for a in A]
from itertools import accumulate
SUM=[0]+list(accumulate(ALL))
MAX=0
MINUS=0
for a,r,l in A:
MAX+=a
MINUS+=a*r
OUT=-1
def binsearch(score):
alluse=score//X
rest=score-alluse*X
for ri in range(N):
plus=0
b,l,u=A[ri]
if rest<b:
plus+=rest*l
else:
plus+=rest*u+b*l-b*u
if alluse<=ri:
plus+=SUM[alluse]
else:
plus+=SUM[alluse+1]-ALL[ri]
#print(score,ri,plus)
if plus>=MINUS:
return 1
return 0
while MAX-OUT>1:
mid=(MAX+OUT)//2
if binsearch(mid)==1:
MAX=mid
else:
OUT=mid
print(MAX) | p03019 |
import sys
import math
readline = sys.stdin.readline
N, X = list(map(int, input().split()))
q_array = []
score_needed = 0
for i in range(N):
b, l, u = list(map(int, readline().split()))
q_array.append([b, l, u, b * l + (X - b) * u])
score_needed += b * l
q_array = sorted(q_array, key=lambda x: -x[3])
ans = 0
# print(q_array)
for i in range(N):
if q_array[i][3] <= score_needed:
ans += X
score_needed -= q_array[i][3]
if score_needed == 0:
break
else:
study_min = X
# print(score_needed)
for j in range(i, N):
b, l, u, s = q_array[j]
if score_needed > s:
break
yobun = s - score_needed
if score_needed <= b * l:
study_min = min(study_min, math.ceil(score_needed / l))
else:
study_min = min(study_min, b + math.ceil(
(score_needed - b * l) / u))
for k in range(i):
b, l, u, s = q_array[k]
needed = s - yobun
if score_needed <= b * l:
study_min = min(study_min, math.ceil(needed / l))
else:
study_min = min(study_min, b + math.ceil(
(needed - b * l) / u))
ans += study_min
break
print(ans) | import sys
readline = sys.stdin.readline
N, X = list(map(int, input().split()))
q_array = []
s_array = []
score_needed = 0
for i in range(N):
b, l, u = list(map(int, readline().split()))
q_array.append([b, l, u, b * l + (X - b) * u])
s_array.append(b * l + (X - b) * u)
score_needed += b * l
q_array = sorted(q_array, key=lambda x: -x[3])
s_array = sorted(s_array, key=lambda x: -x)
sum_array = []
ss = 0
for s in s_array:
ss += s
sum_array.append(ss)
ans_min = 0
ans_max = N * X
if score_needed == 0:
print((0))
exit()
while ans_max - ans_min > 1:
ans = (ans_min + ans_max) // 2
use_all = ans // X
use_part = ans % X
# print(use_all, use_part)
score_get_max = 0
score_tmp = 0
if use_part == 0:
score_get_max = sum_array[use_all - 1]
else:
score_get_max = 0
score_tmp = 0
for q in q_array:
b, l, u, s = q
score_tmp = 0
if use_part <= b:
score_tmp = use_part * l
else:
score_tmp = (b * l + (use_part - b) * u)
if use_all > 0:
if s_array[use_all - 1] <= s:
score_tmp += (sum_array[use_all] - s)
else:
score_tmp += sum_array[use_all - 1]
score_get_max = max(score_get_max, score_tmp)
# print(ans, score_get_max)
if score_get_max >= score_needed:
ans_max = ans
else:
ans_min = ans
print(ans_max)
| p03019 |
class Combination:
'''MOD上の
計算量：階乗・逆元テーブルの作成O(N)
nCkを求めるO(1)'''
def __init__(self, n, MOD):
self.fact = [1] * (n + 1)
for i in range(1, n + 1):
self.fact[i] = self.fact[i-1] * i % MOD
self.inv_fact = [pow(self.fact[i], MOD - 2, MOD) for i in range(n + 1)]
self.MOD = MOD
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
def inverse_factorial(self, k):
"""k!の逆元を求める O(1)"""
return self.inv_fact[k]
def permutation(self, k, r):
"""kPrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[r]) % self.MOD
def combination(self, k, r):
"""kCrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
h, w, n = list(map(int, input().split()))
info = [(1, 1)] + [tuple(map(int, input().split())) for i in range(n)] + [(h, w)]
n += 2
MOD = 10**9 + 7
comb = Combination(w+h+1, MOD)
dp = {}
dp[0] = (0, 1)
def solve(ind):
if ind in dp:
return dp[ind]
i, j = info[ind]
dp0 = 0
dp1 = 0
for ind2 in range(n):
if ind2 == ind:
continue
pi, pj = info[ind2]
if pi <= i and pj <= j:
tmp = comb.combination((i+j)-(pi+pj), i-pi)
dp0 += tmp * solve(ind2)[1] % MOD
dp1 += tmp * solve(ind2)[0] % MOD
dp[ind] = (dp0, dp1)
return dp[ind]
for i in range(n):
solve(i)
print(((dp[n-1][0] - dp[n-1][1]) % MOD))
| class Combination:
def __init__(self, n, MOD):
self.fact = [1] * (n + 1)
for i in range(1, n + 1):
self.fact[i] = self.fact[i-1] * i % MOD
self.inv_fact = [pow(self.fact[i], MOD - 2, MOD) for i in range(n + 1)]
self.MOD = MOD
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
def inverse_factorial(self, k):
"""k!の逆元を求める O(1)"""
return self.inv_fact[k]
def permutation(self, k, r):
"""kPrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[r]) % self.MOD
def combination(self, k, r):
"""kCrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
h, w, n = list(map(int, input().split()))
info = [(1, 1)] + [tuple(map(int, input().split())) for i in range(n)] + [(h, w)]
info = sorted(info)
n += 2
MOD = 10**9 + 7
comb = Combination(w+h+1, MOD)
dp = {}
dp[0] = (0, 1)
def solve(ind):
if ind in dp:
return dp[ind]
i, j = info[ind]
dp0 = 0
dp1 = 0
for ind2 in range(n):
if ind2 == ind:
continue
pi, pj = info[ind2]
if pi <= i and pj <= j:
tmp = comb.combination((i+j)-(pi+pj), i-pi)
dp0 += tmp * solve(ind2)[1] % MOD
dp1 += tmp * solve(ind2)[0] % MOD
dp[ind] = (dp0, dp1)
return dp[ind]
for i in range(n):
solve(i)
print(((dp[n-1][0] - dp[n-1][1]) % MOD))
| p03184 |
# coding: utf-8
# Your code here!
SIZE=300000; MOD=10**9+7 #ここを変更する
inv = [0]*(SIZE+1)# inv[j] = j^{-1} mod MOD
fac = [0]*(SIZE+1)# fac[j] = j! mod MOD
finv = [0]*(SIZE+1)# finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2,SIZE+1):
inv[i] = MOD -(MOD//i)*inv[MOD%i]%MOD
fac[i] = fac[i-1]*i%MOD
finv[i]= finv[i-1]*inv[i]%MOD
def choose(n,r): # nCk mod MOD の計算
if 0 <= r <= n:
return (fac[n]*finv[r]%MOD)*finv[n-r]%MOD
else:
return 0
h,w,n = [int(i) for i in input().split()]
xy = [[1,1]]+[[int(i) for i in input().split()] for _ in range(n)]
dp = [0]*(n+1)
dp[0] = 1
xy.sort(key=lambda x: x[1])
xy.sort(key=lambda x: x[0])
#print(xy)
for i in range(1,n+1):
x,y = xy[i]
for j in range(i):
xj,yj = xy[j]
dp[i] -= choose(x - xj + y-yj, y-yj)*dp[j]
dp[i] %= MOD
ans = 0
#print(dp)
for i,dpi in enumerate(dp):
x,y=xy[i]
ans += choose(h-x + w-y, w-y) * dpi
ans %= MOD
print(ans)
| # coding: utf-8
# Your code here!
SIZE=300000; MOD=10**9+7 #ここを変更する
inv = [0]*(SIZE+1)# inv[j] = j^{-1} mod MOD
fac = [0]*(SIZE+1)# fac[j] = j! mod MOD
finv = [0]*(SIZE+1)# finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2,SIZE+1):
inv[i] = MOD -(MOD//i)*inv[MOD%i]%MOD
fac[i] = fac[i-1]*i%MOD
finv[i]= finv[i-1]*inv[i]%MOD
def choose(n,r): # nCk mod MOD の計算
if 0 <= r <= n:
return (fac[n]*finv[r]%MOD)*finv[n-r]%MOD
else:
return 0
h,w,n = [int(i) for i in input().split()]
xy = [[1,1]]+[[int(i) for i in input().split()] for _ in range(n)]
dp = [0]*(n+1)
dp[0] = 1
xy.sort()
#print(xy)
for i in range(1,n+1):
x,y = xy[i]
for j in range(i):
xj,yj = xy[j]
dp[i] -= choose(x - xj + y-yj, y-yj)*dp[j]
dp[i] %= MOD
ans = 0
#print(dp)
for i,dpi in enumerate(dp):
x,y=xy[i]
ans += choose(h-x + w-y, w-y) * dpi
ans %= MOD
print(ans)
| p03184 |
str1 , str2 = input().split(" ")
str3 = str2+str1
print(str3) | #---Strings
S, T = map(str, input().split(" "))
print(T, S, sep="")
| p02817 |
def main():
S,T = input().split()
print(("{}{}".format(T,S)))
main() | S,T = input().split()
print((T+S)) | p02817 |
S=list(input().split())
a=S[1]+S[0]
print(a) | S,T=input().split()
print((T+S)) | p02817 |
import sys
S,T = input().split()
if not ( S.islower() and T.islower() ): sys.exit()
if not ( 1 <= len(S) <= 100 and 1 <= len(S) <= 100 ): sys.exit()
print(T,end='')
print(S)
| import sys
S,T = input().split()
if not ( S.islower() and T.islower() ): sys.exit()
if not ( 1 <= len(S) <= 100 and 1 <= len(S) <= 100 ): sys.exit()
print(T,S,sep='')
| p02817 |
s,t=list(map(str,input().split()))
print((t+s))
| s,t=input().split()
print((t+s)) | p02817 |
S, T = input().split()
S = str(S)
T = str(T)
print((T+S)) | def funk(S,T):
return T+S
S,T = input().split()
print((funk(S,T))) | p02817 |
A, B = input().split()
print((B+A)) | S, T = input().split()
print((T+S)) | p02817 |
import sys
#import numpy as np
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split())) # applies to numbers only
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
S, T = input().split()
print((T+S))
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
S, T = sr().split()
answer = T + S
print(answer)
# 39 | p02817 |
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s, t = list(map(str, readline().rstrip().decode('utf-8').split()))
print((t + s))
if __name__ == '__main__':
solve()
| import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
s, t = list(map(str, str(input().rstrip('\n')).split()))
print((t + s))
if __name__ == '__main__':
solve()
| p02817 |
b, c = list(map(str, input().split()))
print((c+b)) | s,t=list(map(str,input().split()))
print((t+s)) | p02817 |
a, b = list(map(str, input().split()))
print(('{}{}'.format(b, a))) | str_l = list(map(str, input().split()))
print((''.join(list(reversed(str_l))))) | p02817 |
eval(input());print((sum([i-1 for i in list(map(int,input().split()))]))) | print((-int(eval(input()))+sum(map(int,input().split())))) | p03294 |
n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a)-len(a))) | n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a)-n)) | p03294 |
N = int(eval(input()))
L = list([x - 1 for x in list(map(int,input().split()))])
print((sum(L))) | N = eval(input())
print((sum(list([x - 1 for x in list(map(int,input().split()))]))))
| p03294 |
import math
class Sieve:
"""Sieve of Eratosthenes.
List primes up to n.
"""
def __init__(self, n):
self.__prime = []
self.__is_prime = [i >= 2 for i in range(n + 1)]
for i in range(2, int(math.sqrt(n)) + 1):
if self.__is_prime[i]:
for j in range(i * i, n + 1, i):
self.__is_prime[j] = False
for i in range(2, n + 1):
if self.__is_prime[i]:
self.__prime.append(i)
def prime(self):
return self.__prime
def is_prime(self, n):
return self.__is_prime[n]
if __name__ == '__main__':
N = int(eval(input())) # 2 <= N <= 3000
a = list(map(int, input().split())) # 2 <= ai <= 100000
b = [ai for ai in a]
p = Sieve(100000).prime() # len = 9952
prime_to_power = [0 for _ in range(p[-1] + 1)]
for i in range(len(a)):
for prime in p:
power = 0
while b[i] % prime == 0:
b[i] /= prime
power += 1
prime_to_power[prime] = max(prime_to_power[prime], power)
if b[i] == 1:
break
lcm = 1
for i in range(len(prime_to_power)):
lcm *= i ** prime_to_power[i]
m = lcm - 1
ans = 0
for ai in a:
ans += m % ai
print(ans)
| import math
class Sieve:
"""Sieve of Eratosthenes.
List primes up to n.
"""
def __init__(self, n):
self.__prime = []
self.__is_prime = [i >= 2 for i in range(n + 1)]
for i in range(2, int(math.sqrt(n)) + 1):
if self.__is_prime[i]:
for j in range(i * i, n + 1, i):
self.__is_prime[j] = False
for i in range(2, n + 1):
if self.__is_prime[i]:
self.__prime.append(i)
def prime(self):
return self.__prime
def is_prime(self, n):
return self.__is_prime[n]
def bf(N, a):
p = Sieve(max(a) + 1).prime() # len <= 9952
prime_to_power = {}
for prime in p:
prime_to_power[prime] = 0
for i in range(N):
ai = a[i]
for prime in p:
power = 0
while ai % prime == 0:
ai //= prime
power += 1
prime_to_power[prime] = max(prime_to_power[prime], power)
lcm = 1
for prime in prime_to_power:
lcm *= prime ** prime_to_power[prime]
m = lcm - 1
ans = 0
for ai in a:
ans += m % ai
return ans
def al(N, a):
return sum(a) - len(a)
if __name__ == '__main__':
N = int(eval(input())) # 2 <= N <= 3000
a = list(map(int, input().split())) # 2 <= ai <= 100000
# print(bf(N, a))
print((al(N, a))) | p03294 |
def main():
n, *a = list(map(int, open(0).read().split()))
ans = sum(a) - n
print(ans)
if __name__ == '__main__':
main()
| print((-int(eval(input()))+sum(map(int, input().split())))) | p03294 |
# 最大公約数を求める関数
def gcd(a,b):
rem = a % b
while rem != 0:
a = b
b = rem
rem = a % b
return b
# 最小公倍数を求める関数
def lcm(a,b):
return (a*b)/gcd(a,b)
n = int(eval(input()))
a = list(map(int, input().split()))
m = lcm(a[0],a[1])
for i in range(1,len(a)):
m = lcm(m,a[i])
res = int(sum([(m-1) % e for e in a]))
print(res) | n = int(eval(input()))
res = sum(list(map(int, input().split()))) - n
print(res) | p03294 |
n = int(eval(input()))
a = [ int(x) for x in input().split(" ") ]
s = 0
for i in a:
s += i - 1
print(s)
| N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in a:
ans += i-1
print(ans)
| p03294 |
# author: kagemeka
# created: 2019-11-08 15:54:47(JST)
### modules
## from standard library
import sys
# import collections
# import math
# import string
# import bisect
# import re
# import itertools
# import statistics
import functools
# import operator
## from external libraries
# import scipy.special # if use comb function on AtCoder,
# import scipy.misc # select scipy.misc.comb (old version)
# import numpy as np
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def main():
n, *a = (int(x) for x in sys.stdin.read().split())
m = functools.reduce(lcm, a)
f = sum([(m - 1) % a[i] for i in range(n)])
print(f)
if __name__ == "__main__":
# execute only if run as a script
main()
| # author: kagemeka
# created: 2019-11-08 15:54:47(JST)
### modules
## from standard library
import sys
# import collections
# import math
# import string
# import bisect
# import re
# import itertools
# import statistics
# import functools
# import operator
## from external libraries
# import scipy.special # if use comb function on AtCoder,
# import scipy.misc # select scipy.misc.comb (old version)
# import numpy as np
def main():
n, *a = (int(x) for x in sys.stdin.read().split())
# editorial より
f = sum(a) - n
print(f)
if __name__ == "__main__":
# execute only if run as a script
main()
| p03294 |
n=int(eval(input()))
a=[int(x) for x in input().split()]
print((sum(a)-n)) | def main():
N = int(eval(input()))
A = list(map(int,input().split()))
print((sum(A) - N))
if __name__ == "__main__":
main() | p03294 |
N = int(eval(input()))
a =list(map(int, input().split()))
ans = 0
a_all = 1
for i in range(N):
a_all = a_all*a[i]
for i in range(N):
ans += (a_all -1) % a[i]
print(ans) | N = int(eval(input()))
a = [int(i) for i in input().split()]
ans = sum(a) - N
print(ans) | p03294 |
N=int(eval(input()))
A=list([int(x)-1 for x in input().split()])
print((sum(A))) | N=int(eval(input()))
A=list(map(int,input().split()))
print((sum(A)-N)) | p03294 |
N = int(eval(input()))
A = list([int(x) - 1 for x in input().split()])
print((sum(A)))
| N = int(eval(input()))
A = list(map(int, input().split()))
ans = sum(A) - N
print(ans)
| p03294 |
N = int(eval(input()))
a = list(map(int, input().split()))
print((sum([i-1 for i in a])))
| N = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a)-N))
| p03294 |
def gcd(x,y):
r=x%y
return gcd(y,r) if r else y
def lcm(x, y):
return (x * y) // gcd(x, y)
n=int(eval(input()))
A=list(map(int,input().split()))
k=1
for i in A:
k=lcm(k,i)
def f(n):
return sum(list([n%x for x in A]))
print((f(k-1))) | n=int(eval(input()))
A=list(map(int,input().split()))
print((sum(A)-n))
| p03294 |
from functools import reduce
n = (int)(eval(input()))
a = (list)(list(map(int, input().split())))
def gcd(a, b):
# a>b
while(b):
c = a % b
a = b
b = c
return a
def calcMod(a, m):
return sum([m % v for v in a])
def lcm(a, b):
return a*b/gcd(a, b)
def lcm_list(l):
g = reduce(lcm, l)
return g
print((calcMod(a, (int)(lcm_list(a)-1))))
| from functools import reduce
n = (int)(eval(input()))
a = (list)(list(map(int, input().split())))
def gcd(a, b):
# a>b
while(b):
c = a % b
a = b
b = c
return a
def calcMod(a, m):
return sum([m % v for v in a])
def lcm(a, b):
return a*b/gcd(a, b)
def lcm_list(l):
g = reduce(lcm, l)
return g
def mul(a, b):
return a*b
#print(calcMod(a, (int)(lcm_list(a)-1)))
print((calcMod(a, reduce(mul, a)-1)))
| p03294 |
from functools import reduce
n = (int)(eval(input()))
a = (list)(list(map(int, input().split())))
def gcd(a, b):
# a>b
while(b):
c = a % b
a = b
b = c
return a
def calcMod(a, m):
return sum([m % v for v in a])
def lcm(a, b):
return a*b/gcd(a, b)
def lcm_list(l):
g = reduce(lcm, l)
return g
def mul(a, b):
return a*b
#print(calcMod(a, (int)(lcm_list(a)-1)))
print((calcMod(a, reduce(mul, a)-1)))
| from functools import reduce
n = (int)(eval(input()))
a = (list)(list(map(int, input().split())))
def calcMod(a, m):
return sum([m % v for v in a])
def mul(a, b):
return a*b
print((calcMod(a, reduce(mul, a)-1)))
| p03294 |
from functools import reduce
n = (int)(eval(input()))
a = (list)(list(map(int, input().split())))
def calcMod(a, m):
return sum([m % v for v in a])
def mul(a, b):
return a*b
print((calcMod(a, reduce(mul, a)-1)))
| from functools import reduce
n = (int)(eval(input()))
a = (list)(list(map(int, input().split())))
def calcMod(a, m):
return sum([m % v for v in a])
def mul(a, b):
return a*b
#print(calcMod(a, reduce(mul, a)-1))
print((sum(a)-n))
| p03294 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
ans = 0
for a in map(int, input().split()):
ans += a
print((ans - N)) | N = int(eval(input()))
print((sum(map(int, input().split())) - N))
| p03294 |
N = int(eval(input()))
A = [int(zz) for zz in input().split()]
print((sum(A)-N))
| N = int(eval(input()))
print((sum([int(i)-1 for i in input().split()])))
| p03294 |
n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a) - n)) | i = input;i();print((sum([int(x)-1 for x in i().split()])))
| p03294 |
N=int(eval(input()))
a = list(map(int,input().split()))
print((sum(a)-len(a))) | N=int(eval(input()))
a = list(map(int,input().split()))
print((sum(a)-N)) | p03294 |
n = int(eval(input()))
A = [int(i) for i in input().strip().split()]
print((sum(A) - n))
| import sys
def input():
return sys.stdin.readline().strip()
# sys.setrecursionlimit(100000)
def main():
n = int(input().strip())
A = [int(i) for i in input().split()]
print((sum(A) - n))
return
if __name__ == "__main__":
main()
| p03294 |
# モジュールのインポート
import fractions
# 標準入力を取得
N = int(eval(input()))
a = list(map(int, input().split()))
# 求解処理
ans = sum(a) - N
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(eval(input()))
a = list(map(int, input().split()))
return N, a
def main(N: int, a: list) -> None:
"""
メイン処理.
Args:\n
N (int): 正整数の数(2 <= N <= 3000)
a (list): 正整数(2 <= a_i <= 10^5)
"""
# 求解処理
ans = sum(a) - N
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, a = get_input()
# メイン処理
main(N, a)
| p03294 |
N = eval(input())
a = list(map(int, input().split()))
summ = 1
for i in a:
summ *= i
summ2 = 0
for i in a:
summ2 += (summ-1)% i
print(summ2) | N = eval(input())
a = list(map(int, input().split()))
summ2 = sum(a) - int(N)
print(summ2) | p03294 |
#ABC 103
#最小公倍数
from functools import reduce
#a,bの最大公約数
def gcd(a, b):
while b:
a, b = b, a % b
return a
#a,bの最小公倍数
def lcm_base(a, b):
return a * b // gcd (a, b)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)
N=int(eval(input()))
A = [int(j) for j in input().split()]
ans = 0
for a in A:
ans+=(lcm(*A)-1)%a
print(ans) | #ABC 103
import functools
import operator
N=int(eval(input()))
A = [int(j) for j in input().split()]
result = functools.reduce(operator.mul, A)
ans = 0
for a in A:
ans+=(result-1)%a
print(ans) | p03294 |
import sys
import itertools
input = sys.stdin.readline
N = int(eval(input()))
li = [int(i) for i in input().split()]
sum = 0
for i in range(N) :
sum += li[i]- 1
print(sum)
| #template
def inputlist(): return [int(k) for k in input().split()]
#template
N = int(eval(input()))
A = inputlist()
print((sum(A)-N)) | p03294 |
from collections import defaultdict
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChar():
return eval(input())
def readChars():
return input().split()
n = readInt()
a = readInts()
ma = max(a)
ans = 0
seki = 1
for i in a:
seki*=i
for i in a:
ans += (seki-1)%i
print(ans) | from collections import defaultdict
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChar():
return eval(input())
def readChars():
return input().split()
n = readInt()
a = readInts()
ans = 0
for i in a:
ans+=i-1
print(ans) | p03294 |
n = int(eval(input()))
a = list(map(int, input().split()))
x = 1
for i in a:
x *= i
ans = 0
for i in a:
ans += (x - 1) % i
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a) - len(a))) | p03294 |
n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a) - len(a))) | n = int(eval(input()))
a = list(map(int, input().split()))
print((sum([x - 1 for x in a]))) | p03294 |
# -*- coding: utf-8 -*-
from functools import reduce
N = int(eval(input()))
aN = list(map(int, input().split()))
def gcd(a, b):
while b > 0:
a, b = b, a%b
return a
def lcm_base(x, y):
return (x * y) // gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
def f(num, aN):
sum1 = 0
for i in range(len(aN)):
sum1 += num % aN[i]
return sum1
# リストの最小公倍数-1を関数fの引数にする
lcm = lcm_list(aN)
print((f(lcm-1, aN))) | # -*- coding: utf-8 -*-
N = int(eval(input()))
aN = list(map(int, input().split()))
print((sum(aN)-N)) | p03294 |
eval(input())
numbers = tuple(map(int, input().split(' ')))
print((sum([n - 1 for n in numbers])))
| N = int(eval(input()))
print((sum(tuple(map(int, input().split(' ')))) - N))
| p03294 |
n=int(eval(input()))
a=list(map(int,input().split()))
c=0
for i in range(n):
c+=a[i]-1
print(c) | n=eval(input())
print((sum([i-1 for i in list(map(int,input().split()))]))) | p03294 |
import math
n = eval(input())
a = input().split()
N = int(n)
ans_list = []
ann = []
ana = 1
for j in range(N):
ana = ana * int(a[j])
ana = ana -1
for i in range(N):
ans = 0
for k in range(i+1):
ans += int(ana % int(a[k]))
ans_list.append(ans)
ans_list.sort()
ans_list.reverse()
print((str(ans_list[0])))
| import math
n = eval(input())
a = input().split()
N = int(n)
ans_list = []
ann = []
ana = 1
for j in range(N):
ana = ana * int(a[j])
ana = ana -1
ans = 0
for k in range(N):
ans += int(ana % int(a[k]))
ans_list.append(ans)
ans_list.sort()
ans_list.reverse()
print((str(ans_list[0])))
| p03294 |
n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a)-len(a))) | N = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a)-N)) | p03294 |
def gcd(a, b):
if a < b:
a, b = b, a
if b == 0:
return a
c = a % b
return gcd(b, c)
def lcm(x, y):
return (x * y) // gcd(x, y)
N = int(eval(input()))
A = []
s = input().split(" ")
for i in range(N):
A.append(int(s[i]))
tmp=lcm(A[0],A[1]);
i = 2
while i < N:
tmp = lcm(tmp, A[i]);
i += 1
# print(tmp)
tmp = tmp - 1;
ans=0;
for i in range(N):
ans = ans + tmp % A[i];
print(ans) | N = int(eval(input()))
print((sum(list(map(int, input().split(" "))))-N)) | p03294 |
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
for i in range(N):
ans += A[i] - 1
print(ans) | import math
N = int(eval(input()))
A = list(map(int,input().split()))
A = list([int(math.copysign(x-1, x)) for x in A])
print((sum(A))) | p03294 |
n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a)-n)) | n = int(eval(input()))
a = list(map(int, input().split()))
a = list([x-1 for x in a])
print((sum(a)))
| p03294 |
import typing
n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(x : int, y : int):
x, y = min(x, y), max(x, y)
while True:
mod = y % x
if mod == 0:
break
y = x
x = mod
return x
lcm = a[0]
for i in range(1, n):
lcm = lcm * a[i] // gcd(lcm, a[i])
res = 0
for i in range(n):
res += (lcm - 1) % a[i]
print(res) | n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(x, y):
x, y = min(x, y), max(x, y)
while True:
mod = y % x
if mod == 0:
break
y = x
x = mod
return x
lcm = a[0]
for i in range(1, n):
lcm = lcm * a[i] // gcd(lcm, a[i])
res = 0
for i in range(n):
res += (lcm - 1) % a[i]
print(res) | p03294 |
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int,input().split()))
#aをすべてかけて1を引いた整数をmにすればよい
print((sum(list([x-1 for x in a])))) | # -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int,input().split()))
#aをすべてかけて1を引いた整数をmにすればよい
print((sum(a)-len(a))) | p03294 |
#coding:utf-8
n = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return (a * b) // gcd(a, b)
def func(x, A):
ans = 0
for y in A:
ans += x%y
return ans
def hoge(A):
B = []
for i in range(len(A)-1):
for j in range(len(A)-i-1):
tmp = lcm(A[i], A[i+1+j])
if tmp not in B: B.append(tmp)
return B
max_lcm = 0
B = []
for i in range(n-1):
for j in range(n-i-1):
tmp = lcm(A[i], A[i+1+j])
if tmp not in B: B.append(tmp)
while(len(B) > 1):
B = hoge(B)
print((func(B[0]-1, A)))
| n = int(eval(input()))
A = list(map(int, input().split()))
print((sum(A) - n)) | p03294 |
N = int(eval(input()))
A = list(map(int, input().split()))
def gcd(x,y):#ユークリッドの互除法
if y > x:
x, y = y, x
while y != 0:
x, y = y, x % y
if y == 0:
return x
def lcm(x,y):
return x * y / gcd(x,y)
m = 1
for i in range(N):
m = lcm(m, A[i])
count = 0
for i in range(N):
count += (m - 1) % A[i]
print((int(count))) | N = int(eval(input()))
A = list(map(int, input().split()))
count = 0
for i in range(N):
count += A[i] - 1
print(count) | p03294 |
n = int(eval(input()))
print((sum(list(map(int, input().split()))) - n))
| def slove():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
a = list(map(int, input().rstrip('\n').split()))
t = 0
for i in range(n):
t += (a[i] - 1)
print(t)
if __name__ == '__main__':
slove()
| p03294 |
# ans
N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(N):
ans += a[i] - 1
print(ans) | N = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a) - N)) | p03294 |
from functools import reduce
n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
ans = 0
for x in a:
ans += (reduce(lcm, a) - 1) % x
print(ans) | from functools import reduce
n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
x = reduce(lcm, a) - 1
ans = 0
for i in a:
ans += x % i
print(ans) | p03294 |
from functools import reduce
n = int(eval(input()))
a = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
x = reduce(lcm, a) - 1
ans = 0
for i in a:
ans += x % i
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a)-n)) | p03294 |
eval(input())
A = list(map(int, input().split()))
ans = 0
x = 1
for a in A:
x *= a
for a in A:
ans += (x-1)%a
print(ans)
| def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
A = inpl()
print((sum(A)-N)) | p03294 |
input = open(0).read
N, *an = [int(i) - 1 for i in input().split()]
N += 1
def main():
print((sum(an)))
return
main()
| def main():
N, *a = [int(i) - 1 for i in open(0).read().split()]
print((sum(a)))
return
main()
| p03294 |
print((-int(eval(input()))+sum(map(int,input().split())))) | eval(input());print((sum([x-1 for x in list(map(int,input().split()))]))) | p03294 |
# coding: utf-8
def gcd(n1, n2):
if n1 < n2:
n1, n2 = n2, n1
while n1 % n2 != 0:
rest = n1 % n2
n1, n2 = n2, rest
return n2
def lcm(n1, n2):
return n1 * n2 // gcd(n1, n2)
def getM(alist):
nLcm = lcm(alist[0], alist[1])
for i in range(2, len(alist)):
nLcm = lcm(nLcm, alist[i])
return nLcm-1
def f(m, alist):
t_sum = 0
for ai in alist:
t_sum += m % ai
return t_sum
if __name__ == "__main__":
N = int(eval(input()))
alist = [int(x) for x in input().split(" ")]
print((f(getM(alist), alist)))
| #coding: utf-8
if __name__ == "__main__":
N = int(eval(input()))
alist = [int(x)-1 for x in input().split(" ")]
print((sum(alist)))
| p03294 |
def gcd(a, b):
if(a < b):
a, b = b, a
while b:
a, b = b, a % b
return a
def lcm(a,b):
return a*b / gcd(a,b)
n = int(eval(input()))
a = list(map(int, input().split()))
nums = 1
for i in range(n):
nums = lcm(nums, a[i])
ans = 0
for i in a:
ans += (nums - 1) % i
print((int(ans)))
| n = int(eval(input()))
a = list(map(int, input().split()))
nums = a[0]
for num in a:
if(nums % num != 0):
nums *= num
ans = 0
nums -= 1
for i in a:
ans += nums % i
print(ans) | p03294 |
def main():
"""
2 <= N <= 10^3
2 <= ai <= 10^5
非負整数 m に対して
f(m) = (m mod a1) + (m mod a2) + (m mod aN)
f_max
mの制約は問題文中には直接記述されていない
"""
N = int(input())
*A, = map(int, input().split())
ans = f(N, A)
print(ans)
def f(N, A):
"""
直感: 最小公倍数,最大公約数
最小公倍数のm ならすべてのaで割り切れる
つまり最小公倍数-1 ならすべてのaについて m mod ai = ai - 1
m=a_MAX-1, (m mod a_MAX) が最大
ただし他のa=a_MAX-1 の場合、f(m)は小さくなってしまう
aiに対して1 <= m <= a_Max-1 をすべて試す: 10^5 * 3 * 10^3 => TLE
"""
try:
# py3.5
from math import gcd
except:
from fractions import gcd
def lcm(x, y):
return x * y // gcd(x, y)
m1 = lcm(A[0], A[1])
for a in A[2:]:
m1 = lcm(m1, a)
m = m1 - 1
ans = sum(m % a for a in A)
return ans
def WA(N, A):
ans = 0
m_max = max(A) * 2 - 1
for m in range(1, m_max):
mods = [m % a for a in A]
tmp = sum(mods)
print(*(mods + [tmp]), sep="\t")
ans = max(ans, tmp)
return ans
if __name__ == '__main__':
main()
| def main():
"""
2 <= N <= 10^3
2 <= ai <= 10^5
非負整数 m に対して
f(m) = (m mod a1) + (m mod a2) + (m mod aN)
f_max
mの制約は問題文中には直接記述されていない
"""
N = int(input())
*A, = map(int, input().split())
ans = editorial(N, A)
print(ans)
def f(N, A):
"""
直感: 最小公倍数,最大公約数
最小公倍数のm ならすべてのaで割り切れる
つまり最小公倍数-1 ならすべてのaについて m mod ai = ai - 1
m=a_MAX-1, (m mod a_MAX) が最大
ただし他のa=a_MAX-1 の場合、f(m)は小さくなってしまう
aiに対して1 <= m <= a_Max-1 をすべて試す: 10^5 * 3 * 10^3 => TLE
"""
try:
# py3.5
from math import gcd
except:
from fractions import gcd
def lcm(x, y):
return x * y // gcd(x, y)
m1 = lcm(A[0], A[1])
for a in A[2:]:
m1 = lcm(m1, a)
m = m1 - 1
ans = sum(m % a for a in A)
return ans
def editorial(N, A):
"""
lcm を求めなくても、ai - 1 であることはわかるので
lcm を計算しなくてよい
"""
return sum(a - 1 for a in A)
def WA(N, A):
ans = 0
m_max = max(A) * 2 - 1
for m in range(1, m_max):
mods = [m % a for a in A]
tmp = sum(mods)
print(*(mods + [tmp]), sep="\t")
ans = max(ans, tmp)
return ans
if __name__ == '__main__':
main()
| p03294 |
import math
n = int(eval(input()))
a = list(map(int, input().split()))
common_num = 1
for num in a:
common_num = (common_num * num) // math.gcd(common_num, num)
total = 0
for num in a:
total += (common_num - 1) % num
print(total)
| # 合計が最大になるのは、余りが各aにおいてa-1となるとき。
n = int(eval(input()))
a = list(map(int, input().split()))
# 各aから1ずつ引くをn繰り返しているため。
ans = sum(a) - n
print(ans) | p03294 |
def gcd(a, b):
return a if b == 0 else gcd(b, a % b)
def lcm(a, b):
return a * b // gcd(a, b)
N = int(eval(input()))
A = list(map(int, input().split()))
l = 0
for i in range(1, len(A)):
l = lcm(A[i - 1], A[i])
ans = l - 1
ans = sum(A) - len(A)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
ans = sum(A) - len(A)
print(ans)
| p03294 |
n = int(eval(input()))
A = sorted(list(map(int,input().split())))
print((sum([n-1 for n in A]))) | n = int(eval(input()))
print((sum(map(int,input().split()))-n)) | p03294 |
N=int(eval(input()))
A=list(map(int,input().split()))
all=0
for i in range(N):
all+=A[i]
print((all-N)) | N=int(eval(input()))
A=list(map(int,input().split()))
all=sum(A)
print((all-N))
| p03294 |
def gcd(i,j):
a=max(i,j)
b=min(i,j)
if a%b==0:
return b
else:
return gcd(b,a%b)
def lcm(i,j):
return i*j//gcd(i,j)
N=int(eval(input()))
A=list(map(int,input().split()))
l=lcm(A[0],A[1])
for i in range(2,N):
l=lcm(l,A[i])
ans=0
for i in A:
ans+=(l-1)%i
print(ans)
| N=int(eval(input()))
A=list(map(int,input().split()))
print((sum(A)-N))
| p03294 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
m = 1
for i in range(n):
m = m*a[i]
m -= 1
for i in range(n):
ans += m%a[i]
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
print((sum(a) - n)) | p03294 |
n=int(eval(input()))
xl=[list(map(int,input().split())) for _ in range(n)]
xl.sort(key=lambda x: x[0])
ans=0
for i in range(n):
xi,li=xl[i]
cnt=1
for j in range(n):
xj,lj=xl[j]
if xi+li<=xj-lj:
cnt+=1
xi=xj
li=lj
ans=max(ans,cnt)
print(ans)
| n=int(eval(input()))
xl=[list(map(int,input().split())) for _ in range(n)]
xl.sort(key=lambda x: x[0])
cnt=0
nx,nl=xl[0]
for i in range(1,n):
x,l=xl[i]
if nx+nl<=x-l:
nx=x
nl=l
else:
cnt+=1
if nx+nl>=x+l:
nx=x
nl=l
print((n-cnt)) | p02796 |
H = int(eval(input()))
x = [[float('inf')]*2 for i in range(H)]
for i in range(H):
X, L = list(map(int, input().split()))
x[i][0] = X - L
x[i][1] = X + L
from operator import itemgetter
sf = sorted(x, key=itemgetter(1))
ans = 0
last = float('inf')*-1
for i in range(H):
if last <= sf[i][0]:
ans += 1
last = sf[i][1]
print(ans)
| N = int(eval(input()))
S = []
for i in range(N):
xi, li = list(map(int, input().split()))
S.append([xi - li, xi + li])
from operator import itemgetter
S = sorted(S, key=itemgetter(1))
ans = 0
last = -1*float('Inf')
for si in S:
if si[0] >= last:
ans += 1
last = si[1]
print(ans) | p02796 |
import math
import sys
m=10**9 + 7
sys.setrecursionlimit(1000010)
INF=10 ** 10
N = int(eval(input()))
XL = sorted([list(map(int,input().split())) for _ in range(N)])
# print(N,XL)
DP = [ INF for _ in range(N+1)]
DP[0] = -INF
for i in range(N):
#print(DP)
(x,l) = XL[i]
# print(x,l)
for j in range(1,N+1):
if DP[j-1] > x -l:
break
if ( DP[j-1]<= x -l and x + l < DP[j]):
DP[j] = x + l
#print(DP)
for i in range(2,N+1):
if DP[i] == INF:
print((i-1))
exit(0)
print(N)
| import math
import sys
m=10**9 + 7
sys.setrecursionlimit(1000010)
INF=10 ** 10
N = int(eval(input()))
XL = [list(map(int,input().split())) for _ in range(N)]
XLs =sorted([ [xl[0]+xl[1],xl[0]-xl[1]] for xl in XL ])
# print(N,XL,XLs)
t = -INF
n = 0
for xl in XLs:
if t <= xl[1]:
t = xl[0]
n = n + 1
print(n)
| p02796 |
n = int(eval(input()))
dat = []
for _ in range(n):
x, l = list(map(int, input().split()))
# 0 1 2 3 4co 5
dat.append([x, l, x-l, x+l, 0 , []])
dat.sort(key = lambda x: x[1], reverse=True)
#print(dat)
res = []
res_safe = []
def do_count():
for i in range(n):
#print("i={0}".format(i))
c = 0
m = []
for j in range(i+1, n):
#print("j={0}".format(j))
if dat[j][3] <= dat[i][2] or dat[i][3] <= dat[j][2]:
pass
else:
dat[i][5].append(dat[j])
dat[j][5].append(dat[i])
dat[i][4] += 1
dat[j][4] += 1
do_count()
dat.sort(key = lambda x: (x[4], x[1]), reverse=True)
#print(dat)
for i in range(n):
if dat[i][4] == 0:
res.append(dat[i])
continue
#print("node {0}: kill".format(i))
for node in dat[i][5]:
#print(node[5])
for x in range(len(node[5])):
if node[5][x] == dat[i]:
node[4] -= 1
del node[5][x]
#print("!!!!")
#print(res)
print((len(res)))
| n = int(eval(input()))
dat = []
for _ in range(n):
x, l =list(map(int, input().split()))
dat.append([x-l, x+l])
dat.sort(key=lambda x: x[1])
#print(dat)
prevr = -99999999999999999
res = 0
for i in range(n):
if dat[i][0] >= prevr:
prevr = dat[i][1]
res += 1
print(res)
| p02796 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.