input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import math
def factorize(m):
fct = []
b = 2
while b * b <= m:
cnt = 0
while m % b == 0:
m //= b
cnt += 1
if b > 0:
fct.append([b, cnt])
b += 1
if m > 1:
fct.append([m, 1])
return fct
def comb(n, r):
if n < r or n < 0 or r < 0:
return 0
else:
return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))
N, M = list(map(int, input().split()))
ans = 1
M_fct = factorize(M)
for mf in M_fct:
#mf[1]個をN通りに分ける→comb(mf[1]+N-1,mf[1])
ans *= comb(N + mf[1] - 1, mf[1])
print((ans% (10 ** 9 + 7))) | import math
def factorize(m):
fct = []
b = 2
while b * b <= m:
cnt = 0
while m % b == 0:
m //= b
cnt += 1
if cnt > 0:
fct.append(cnt)
b += 1
if m > 1:
fct.append(1)
return fct
def comb(n, r):
if n < r or n < 0 or r < 0:
return 0
else:
return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))
N, M = list(map(int, input().split()))
ans = 1
M_fct = factorize(M)
for mf in M_fct:
#mf[1]個をN通りに分ける→comb(mf[1]+N-1,mf[1])
ans *= comb(N + mf - 1, mf)
ans %= 10**9+7
print(ans) | p03253 |
# encoding: utf-8
import math
N, M = list(map(int, input().split()))
def distribute(pos, full, tmp):
return memo[tmp][pos]
# define search range
p_max = M // 2 # M is prime if M has a factor p (> p_max)
ip_up = max((1, int(math.log2(M)))) # MDE
#### O(MlogM) below (if M has a very large prime factor)
M_tmp = M
ips = []
for p in range(2, p_max + 1):
if M_tmp % p > 0: continue
# how many times M_tmp can be divided
p_tmp = p
for i_p in range(ip_up + 1):
if M_tmp % p_tmp > 0: break
p_tmp = p_tmp * p
# calculate later
ips.append(i_p)
# next
M_tmp = M_tmp // (p_tmp // p)
if M_tmp == 1: break
#### O(Mlog M) above
#### O(N) below
# create memo
## init
if len(ips) > 0: ip_max = max(ips)
else: ip_max = 0
memo = [[None] * N for i in range(ip_max + 1)] # max ip
for j in range(N): memo[0][j] = 1
for i in range(1, ip_max + 1): memo[i][N - 1] = 1
## fill
for i in range(1, ip_max + 1):
sum_tmp = 0
vals = list(memo[i - 1])[::-1]
p_memo = memo[i]
for j, val in enumerate(vals):
sum_tmp += val
p_memo[N - 1 - j] = sum_tmp
#### O(N) above
# calculate ans
ans = 1
for i_p in ips: ans = (ans * distribute(0, i_p, i_p)) % (10 ** 9 + 7)
if M == 1: print((1))
elif ip_max < 1: print(N)
else: print(ans) | # encoding: utf-8
import math
N, M = list(map(int, input().split()))
ips = []
M_tmp = M
for p in range(2, int(math.sqrt(M)) + 1):
if M_tmp % p > 0: continue
for i_p in range(1, 33):
if M_tmp % (p ** (i_p + 1)) > 0: break
ips.append(i_p)
M_tmp = M_tmp // (p ** i_p)
if M_tmp == 1: break
else:
ips.append(1)
#### O(NlogM) below ?
# create memo
## init
if len(ips) > 0: ip_max = max(ips)
else: ip_max = 0
memo = [[None] * N for i in range(ip_max + 1)] # max ip
for j in range(N): memo[0][j] = 1
for i in range(1, ip_max + 1): memo[i][N - 1] = 1
## fill
for i in range(1, ip_max + 1):
sum_tmp = 0
vals = list(memo[i - 1])[::-1]
ptr_memo = memo[i]
for j, val in enumerate(vals):
sum_tmp += val
ptr_memo[N - 1 - j] = sum_tmp
#### O(NlogM) above ?
# calculate ans
ans = 1
for i_p in ips:
ans = (ans * memo[i_p][0]) % (10 ** 9 + 7)
if M == 1: print((1))
elif ip_max < 1: print(N)
else: print(ans) | p03253 |
#!/usr/bin/env python
import collections
from operator import mul
from functools import reduce
N, M = list(map(int, input().split()))
def cmb(n, r):
r = min(r, n-r)
if r==0: return 1
over = reduce(mul, list(range(n, n-r, -1)))
under = reduce(mul, list(range(1, r+1)))
return over // under
ps = []
tmp = M
for m in range(2, M+1):
while tmp % m == 0:
tmp /= m
ps.append(m)
if int(tmp) == 1:
break
ps = collections.Counter(ps)
ans = 1
mod = 10**9+7
for c in list(ps.values()):
ans *= cmb(c+N-1, c) % mod
if ans > mod:
ans %= mod
print(ans)
| #!/usr/bin/env python
import collections
from operator import mul
from functools import reduce
N, M = list(map(int, input().split()))
def cmb(n, r):
r = min(r, n-r)
if r==0: return 1
over = reduce(mul, list(range(n, n-r, -1)))
under = reduce(mul, list(range(1, r+1)))
return over // under
ps = []
tmp = M
for m in range(2, M+1):
while tmp % m == 0:
tmp /= m
ps.append(m)
if int(tmp) == 1:
break
if m*m > M:
if N > 1:
ps.append(M)
break
ps = collections.Counter(ps)
ans = 1
mod = 10**9+7
for c in list(ps.values()):
ans *= cmb(c+N-1, c) % mod
if ans > mod:
ans %= mod
print(ans)
| p03253 |
# coding:utf-8
INF = float('inf')
MOD = 10 ** 9 + 7
def inpl(): return list(map(int, input().split()))
# nの素因数分解を求めるアルゴリズム
def p_factorization(n):
tmp = []
i = 2
cnt = 0
while n > 1:
if n % i == 0:
cnt += 1
n //= i
else:
tmp.append([i, cnt])
i += 1
cnt = 0
tmp.append([i, cnt])
return tmp
# aのp乗を求めるアルゴリズム
# MOD版
# O(logp)
def pow_mod(a, p):
if p == 0: return 1
if p % 2 == 0:
half_p = p // 2
half = pow_mod(a, half_p)
return half * half % MOD
else:
return a * pow_mod(a, p - 1) % MOD
# 組み合わせnCrを求めるアルゴリズム
# 逆元を使って計算
# MOD版
def cmb_mod(n, r):
# 5C3 -> 5C2
if r > n - r: return cmb_mod(n, n - r)
ans_mul = 1
ans_div = 1
for i in range(r):
ans_mul *= n - i
ans_div *= i + 1
ans_mul %= MOD
ans_div %= MOD
# ans_mul / ans_divをしたい
# ans_divの逆元を使って求める
ans = ans_mul * pow_mod(ans_div, MOD - 2) % MOD
return ans
N, M = inpl()
fact = p_factorization(M)
ans = 1
for n, p in fact:
ans *= cmb_mod(N - 1 + p, p)
ans %= MOD
print(ans)
| # coding:utf-8
INF = float('inf')
MOD = 10 ** 9 + 7
def inpl(): return list(map(int, input().split()))
# aのp乗を求めるアルゴリズム
# MOD版
# O(logp)
def pow_mod(a, p):
if p == 0: return 1
if p % 2 == 0:
half_p = p // 2
half = pow_mod(a, half_p)
return half * half % MOD
else:
return a * pow_mod(a, p - 1) % MOD
# 組み合わせnCrを求めるアルゴリズム
# 逆元を使って計算
# MOD版
def cmb_mod(n, r):
# 5C3 -> 5C2
if r > n - r: return cmb_mod(n, n - r)
ans_mul = 1
ans_div = 1
for i in range(r):
ans_mul *= n - i
ans_div *= i + 1
ans_mul %= MOD
ans_div %= MOD
# ans_mul / ans_divをしたい
# ans_divの逆元を使って求める
ans = ans_mul * pow_mod(ans_div, MOD - 2) % MOD
return ans
N, M = inpl()
ans = 1
i = 2
while i * i <= M:
if M % i == 0:
cnt = 0
while M % i == 0:
cnt += 1
M //= i
ans *= cmb_mod(N - 1 + cnt, cnt)
ans %= MOD
i += 1
if M != 1:
ans *= cmb_mod(N - 1 + 1, 1)
ans %= MOD
print(ans)
| p03253 |
N,M = list(map(int,input().split()))
from collections import Counter
def factorize(n):
d = Counter()
m = 2
while m*m <= n:
while n%m == 0:
n //= m
d[m] += 1
m += 1
if n > 1:
d[n] += 1
return d
MOD = 10**9+7
MAX = 2*10**5
fac = [1,1] + [0]*MAX
finv = [1,1] + [0]*MAX
inv = [0,1] + [0]*MAX
for i in range(2,MAX+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
def nhr(n,r):
return ncr(n+r-1, r)
factors = factorize(M)
ans = 1
for v in list(factors.values()):
ans *= nhr(N,v)
ans %= MOD
print(ans)
| N,M = list(map(int,input().split()))
MOD = 10**9+7
from collections import Counter
def factorize(n):
d = Counter()
m = 2
while m*m <= n:
while n%m == 0:
n //= m
d[m] += 1
m += 1
if n > 1:
d[n] += 1
return d
MAXN = N+99
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
def nhr(n,r):
return ncr(n+r-1, r)
factors = factorize(M)
ans = 1
for v in list(factors.values()):
ans *= nhr(N,v)
ans %= MOD
print(ans) | p03253 |
N,M = list(map(int,input().split()))
MOD = 10**9+7
MAXN = N+200
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
def nhr(n,r):
return ncr(n+r-1, r)
from collections import Counter
def factorize(n):
d = Counter()
m = 2
while m*m <= n:
while n%m == 0:
n //= m
d[m] += 1
m += 1
if n > 1:
d[n] += 1
return d
factors = factorize(M)
ans = 1
for v in list(factors.values()):
n = nhr(N,v)
ans *= n
ans %= MOD
print(ans) | N,M = list(map(int,input().split()))
MOD = 10**9+7
MAXN = N+100
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def comb(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
from collections import Counter
def factorize(n):
d = Counter()
m = 2
while m*m <= n:
while n%m == 0:
n //= m
d[m] += 1
m += 1
if n > 1:
d[n] += 1
return d
ans = 1
f = factorize(M)
for v in list(f.values()):
c = comb(N+v-1, v)
ans *= c
ans %= MOD
print(ans) | p03253 |
n,m=list(map(int, input().split()))
def combination(n,r):
r=min(r,n-r)
result=1
for i in range(n-r+1,n+1):
result*=i
for i in range(1,r+1):
result//=i
return result
def factorize(n):
i=2
result={}
while True:
if i**2>n:
break
count=0
while n%i==0:
n//=i
count+= 1
if count!=0:
result[i]=count
i+=1
if n>1:
result[n]=1
return result
ans=1
mod=10**9+7
f=factorize(m)
for i in list(f.values()):
ci=combination(i+n-1,i)%mod
ans=ans*ci%mod
print(ans) | n,m=list(map(int, input().split()))
def combination(n,r):
r=min(r,n-r)
result=1
for i in range(n-r+1,n+1):
result*=i
for i in range(1,r+1):
result//=i
return result
def factorize(n):
f=[]
p=2
cnt=0
while p**2<=n:
while n%p==0:
cnt+=1
n=n//p
if cnt!=0:
f.append([p,cnt])
cnt=0
p+=1
if n!=1:
f.append([n,1])
return f
ans=1
mod=10**9+7
f=factorize(m)
for i in range(len(f)):
k=f[i][1]
ci=combination(k+n-1,k)%mod
ans=ans*ci%mod
print(ans) | p03253 |
N, M = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def prime_counter(n):
ret = []
for i in range(2, int(n / 2) + 2):
count = 0
while n % i == 0:
n /= i
count += 1
if 0 < count:
ret.append(count)
if n == 1:
break
if 1 < n:
ret.append(1)
return ret
def comb(n, r):
r = min(r, n - r)
if r == 0:
return 1
elif r == 1:
return n
return (n % MOD) * pow(r, MOD - 2, MOD) * comb(n - 1, r - 1) % MOD
factnum = prime_counter(M)
ans = 1
for p in factnum:
ans *= comb(p + N - 1, p)
ans %= MOD
print(ans)
| MOD = 10 ** 9 + 7
N, M = list(map(int, input().split()))
f = []
p = 2
while p * p <= M:
if M % p != 0:
p += 1
continue
c = 0
while M % p == 0:
c += 1
M //= p
f.append(c)
p += 1
if M != 1:
f.append(1)
ans = 1
for i in f:
c = 1
for j in range(i):
c = c * (N + j) // (j + 1)
ans = ans * c % MOD
print(ans)
| p03253 |
from math import *
def Prime_Factorization(M):
factor_count_list = []
root_M = int(sqrt(M))
while root_M > 1:
root_M = int(sqrt(M))
for i in range(2, root_M + 1):
e = 0
while M % i == 0:
e += 1
M = M // i
if e > 0:
factor_count_list.append(e)
break
else:
break
if M > root_M:
factor_count_list.append(1)
return factor_count_list
def comb(num_object, num_bar):
return factorial(num_object) // (factorial(num_object - num_bar) * factorial(num_bar))
def all_comb(N, factor_count_list):
ans = 1
for factor in factor_count_list:
ans = (ans * comb(factor + N - 1, factor)) % (10 ** 9 + 7)
return ans
def main():
N, M = list(map(int, input().split()))
factor_count_list = Prime_Factorization(M)
if (factor_count_list == 1):
print(N)
else:
print((all_comb(N, factor_count_list)))
if __name__ == "__main__":
main() | from math import *
def Prime_Factorization(M):
factor_count_list = []
root_M = int(sqrt(M))
while root_M > 1:
root_M = int(sqrt(M))
for i in range(2, root_M + 1):
e = 0
while M % i == 0:
e += 1
M = M // i
if e > 0:
factor_count_list.append(e)
break
else:
break
if M > root_M:
factor_count_list.append(1)
return factor_count_list
def comb(num_object, num_bar):
numerator = 1
for i in range(num_bar):
numerator = (numerator * (num_object - i))
return numerator // factorial(num_bar)
def all_comb(N, factor_count_list):
ans = 1
for factor in factor_count_list:
ans = (ans * comb(factor + N - 1, factor)) % (10 ** 9 + 7)
return ans
def main():
N, M = list(map(int, input().split()))
factor_count_list = Prime_Factorization(M)
print((all_comb(N, factor_count_list)))
if __name__ == "__main__":
main() | p03253 |
from math import factorial
def comb(n, r):
return factorial(n) // factorial(r) // factorial(n - r)
n, m= [int(i) for i in input().split(" ")]
c = []
i = 2
mt = m
while i * i <= mt:
ci = 0
while mt % i == 0:
mt = mt // i
ci += 1
if ci > 0:
c.append(ci)
i += 1
if mt > 1:
c.append(1)
p = 1
for j in range(0, len(c)):
p *= comb(n - 1 + c[j], c[j])
print((p % (10**9 + 7))) | from operator import mul
from functools import reduce
def comb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
n, m= [int(i) for i in input().split(" ")]
c = []
i = 2
mt = m
while i * i <= mt:
ci = 0
while mt % i == 0:
mt = mt // i
ci += 1
if ci > 0:
c.append(ci)
i += 1
if mt > 1:
c.append(1)
p = 1
for j in range(0, len(c)):
p *= comb(n - 1 + c[j], c[j])
print((p % (10**9 + 7))) | p03253 |
N,M = list(map(int,input().split()))
div =[]
for i in range(2,int(M**(1/2))+2):
cur = 0
while M%i==0:
M = M//i
cur += 1
if cur >=1:
div.append(cur)
if M>1: div.append(1)
div.sort()
mod = 10**9+7
frac = [1]*(N+50)
num = len(frac)
for i in range(len(frac)-1):
frac[i+1] = frac[i]*(i+1)%mod
finv = [1] * (N+50)
finv[-1] = pow(frac[-1], mod-2, mod)
for i in range(1, num):
finv[num-1-i] = finv[num-i] * (num-i) % mod
ans = 1
for i in div:
ans = ans * frac[N+i-1]*finv[N-1]*finv[i]%mod
print(ans) | N,M = list(map(int,input().split()))
div = []
for i in range(2,int(M**(1/2))+2):
cur = 0
while M%i==0:
M//=i
cur += 1
if cur >=1:
div.append(cur)
if M>1:div.append(1)
div.sort()
mod = 10**9+7
frac = [1]*(N+50)
num=len(frac)
for i in range(num-1):
frac[i+1] = frac[i]*(i+1)%mod
finv = [1]*(N+50)
finv[-1] = pow(frac[-1],mod-2,mod)
ans = 1
for i in range(1,num):
finv[num-1-i] = finv[num-i]*(num-i)%mod
for i in div:
ans =ans*frac[N+i-1]*finv[N-1]*finv[i]%mod
print(ans) | p03253 |
mod = 10**9 + 7
def factorize(n):
# http://nihaoshijie.hatenadiary.jp/entry/2018/02/03/115759
fct = []
b, e = 2, 0
while b * b <= n:
while n % b == 0:
n = n // b
e = e + 1
if e > 0:
fct.append(e)
b, e = b + 1, 0
if n > 1:
fct.append(1)
return fct
class COMB_MOD():
# http://drken1215.hatenablog.com/entry/2018/06/08/210000
def __init__(self, max_n=510000, mod=10**9+7):
self.fac = [0]*max_n
self.finv = [0]*max_n
self.inv = [0]*max_n
self.fac[0] = self.fac[1] = 1
self.finv[0] = self.finv[1] = 1
self.inv[1] = 1
self.max = max_n
self.mod = mod
self._maesyori()
def _maesyori(self):
for i in range(2,self.max):
self.fac[i] = self.fac[i-1] * i % self.mod
self.inv[i] = self.mod - self.inv[self.mod % i] * (self.mod // i) % self.mod
self.finv[i] = self.finv[i-1] * self.inv[i] % self.mod
def COM(self, n, k):
if n < k : return 0
if n < 0 or k < 0:return 0
return self.fac[n] * (self.finv[k] * self.finv[n-k] % self.mod) % self.mod
n, m = list(map(int,input().split()))
fct = factorize(m)
ans = 1
COM = COMB_MOD()
for cnt in fct:
ans = ans*COM.COM(cnt+n-1, cnt) % mod
print(ans) | from collections import Counter
mod = 10**9 + 7
n, m = list(map(int, input().split()))
def fact(m):
c = Counter()
s = 2
while s**2 <= m:
if m % s:
s += 1
continue
while m % s == 0:
c[s] += 1
m //= s
if m > 1:
c[m] += 1
return c
def comb(n, r):
ret = 1
for i in range(min(r, n-r)):
ret = ret*(n-i)//(i+1)
return ret
ans = 1
for cnt in list(fact(m).values()):
ans = ans*comb(cnt+n-1, cnt) % mod
# for i in range(cnt):
# ans = ans*(cnt+n-1-i)//(i+1)
print((ans % mod)) | p03253 |
N, M = [int(_) for _ in input().split()]
MOD = 10**9+7
def primes(n):
from math import sqrt
mn = int(sqrt(n)) + 2
p = [1] * mn
for x in range(2, mn):
if p[x]:
y = x * x
while y < mn:
p[y] = 0
y += x
return (i for i in range(2, mn) if p[i])
def calc(M):
result = {}
for n in primes(M):
if M % n == 0:
result[n] = 1
M //= n
while M % n == 0:
result[n] += 1
M //= n
if M > 1:
result[M] = 1
return result
def C(x, y):
n = min(y, x - y)
r = 1
for i in range(n):
r = r * (x - i)
for i in range(n):
r = r // (i + 1)
return r
cs = calc(M)
result = 1
for x in list(cs.values()):
result = result * C(N+x-1, N-1) % MOD
print(result)
| N, M = [int(_) for _ in input().split()]
MOD = 10**9+7
def factorize(n):
from math import sqrt
m = int(sqrt(n)) + 1
p = [True] * m
result = {}
for x in range(2, m):
if p[x]:
p[x * 2::x] = [False] * ((m - 1) // x - 1)
i = 0
while 1:
d, q = divmod(n, x)
if q == 0:
n = d
i += 1
result[x] = i
else:
break
if n > 1:
result[n] = 1
return result
def C(x, y):
r = 1
s = 1
for i in range(y):
r *= (x - i)
for i in range(y):
s *= (i + 1)
return (r // s) % MOD
result = 1
for x in list(factorize(M).values()):
result = result * C(N + x - 1, x) % MOD
print(result)
| p03253 |
import math
def prime_factorize(n):
ret = []
# 小さい素数から順に試し割りしていく
for i in range(2, int(math.sqrt(n))+1):
if n % i != 0:
continue
e = 0
while n % i == 0:
e += 1
n //= i
ret += [(i, e)]
if n != 1:
ret += [(n, 1)]
return ret
def extgcd(a, b):
x,y, u,v = 0,1, 1,0
while a != 0:
q, r = b//a, b%a
m, n = x-u*q, y-v*q
b,a, x,y, u,v = a,r, u,v, m,n
g = b
return x, y, g
def modinv(a, m):
x, y, g = extgcd(a, m)
if g != 1:
print ("[+]Inverse does not exist.")
else:
return ((m + x) % m) % m
def mod_comb(n, r, mod):
ans_mul, ans_div = 1, 1
for i in range(r):
ans_mul *= (n-i)
ans_div *= (i+1)
ans_mul %= mod
ans_div %= mod
return ans_mul * modinv(ans_div, mod) % mod
def main():
N, M = list(map(int, input().split()))
v = prime_factorize(M)
MOD = int(10**9+7)
ans = 1
for i in v:
ans *= mod_comb(N+i[1]-1, i[1], MOD)
ans %= MOD
print (ans)
main()
| def prime_factor(n):
ret, p = {}, 2
while p*p <= n:
while n % p == 0:
ret[p] = ret.get(p, 0) + 1
n //= p
p += 1
if n != 1: ret[n] = 1
return ret
def mod_inverse(x, mod):
return pow(x, mod-2, mod)
def mod_comb(n, k, mod):
numer, denom = 1, 1
for i in range(k):
numer = numer * ((n-i) % mod) % mod
denom = denom * ((i+1) % mod) % mod
return numer * mod_inverse(denom, mod) % mod
def main():
n, m = list(map(int, input().split()))
prime = prime_factor(m)
mod = 1000000007
ans = 1
for (p, e) in list(prime.items()):
ans = ans * mod_comb(n+e-1, e, mod) % mod
print(ans)
main() | p03253 |
import math
N, M = list(map(int, input().split()))
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == [] and n != 1:
arr.append([n, 1])
return arr
mod = 10**9 + 7
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, 2*10**5 + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
primes = factorization(M)
# 何箇所に分けるか（cnt以下）,その中でどう分けるか（しきりをどこにおくか（振り分けられないものが出ると選べれないのとおなじになるので、cnt - 選んだ数））
ans = 1
for p, cnt in primes:
tmp = cmb(N+cnt-1, N-1, mod)
ans *= tmp
ans %= mod
print(ans)
| def main():
N, M = list(map(int, input().split()))
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == [] and n != 1:
arr.append([n, 1])
return arr
mod = 10**9 + 7
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, N+100 + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
primes = factorization(M)
# 何箇所に分けるか（cnt以下）,その中でどう分けるか（しきりをどこにおくか（振り分けられないものが出ると選べれないのとおなじになるので、cnt - 選んだ数））
ans = 1
for p, cnt in primes:
tmp = cmb(N+cnt-1, N-1, mod)
ans *= tmp
ans %= mod
print(ans)
main()
| p03253 |
n, m = list(map(int, input().split()))
mod = 1000000007
d = 1
divisor = []
while d * d <= m:
if m % d == 0:
divisor.append(d)
if d != m // d:
divisor.append(m // d)
d += 1
divisor = sorted(divisor)
l = len(divisor)
matrix = [[0] * l for _ in range(l)]
for i in range(l):
for j in range(l):
matrix[i][j] = 1 if divisor[i] % divisor[j] == 0 else 0
dp = [1] * l
t = n - 1
while t > 0:
if t % 2 == 1:
newdp = [0] * l
for i in range(l):
for j in range(l):
newdp[i] = (newdp[i] + matrix[i][j] * dp[j]) % mod
dp = newdp
newmatrix = [[0] * l for _ in range(l)]
for i in range(l):
for j in range(i + 1):
newmatrix[i][j] = sum(matrix[i][k] * matrix[k][j] for k in range(j, i + 1)) % mod
matrix = newmatrix
t //= 2
print((dp[-1]))
| n, m = list(map(int, input().split()))
mod = 1000000007
def cmb(n, k):
ret = 1
for i in range(k):
ret *= n - i
ret //= i + 1
return ret % mod
primes = [2]
for p in range(3, 1000):
if all(p % q for q in primes):
primes.append(p)
ret = 1
for p in primes:
q = 0
while m % p == 0:
m //= p
q += 1
if q > 0:
ret = (ret * cmb(n + q - 1, q)) % mod
if m > 1:
ret = (ret * cmb(n, 1)) % mod
print(ret)
| p03253 |
import sys
sys.setrecursionlimit(100000)
n, m = list(map(int, input().split()))
MOD = 10 ** 9 + 7
if m == 1:
print('1')
exit()
factor = []
temp = 0
x = 2
while m > 1:
if m % x == 0:
m //= x
temp += 1
elif temp > 0:
factor.append(temp)
temp = 0
x += 1
else:
x += 1
factor.append(temp)
nCr = {}
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n;
if (n, r) in nCr: return nCr[(n, r)]
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p;
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
nCr[(n, r)] = result
return result;
ans = 1
for x in factor:
ans *= cmb(x + n - 1, n - 1)
ans %= MOD
print(ans) | n, m = list(map(int, input().split()))
MOD = 10 ** 9 + 7
if m == 1:
print('1')
exit()
factor = []
temp = 0
x = 2
while m > 1:
if m % x == 0:
m //= x
temp += 1
elif temp > 0:
factor.append(temp)
temp = 0
x += 1
else:
x += 1
factor.append(temp)
nCr = {}
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n;
if (n, r) in nCr: return nCr[(n, r)]
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p;
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
nCr[(n, r)] = result
return result;
ans = 1
for x in factor:
ans *= cmb(x + n - 1, n - 1)
ans %= MOD
print(ans) | p03253 |
import math
def nCr(n,r):
return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
N,M = list(map(int,input().split()))
l = [2]
now = 3
while now ** 2 <= M:
flag = True
for i in l:
if now % i == 0:
flag = False
break
if flag:
l.append(now)
now += 2
dic = {}
for i in l:
while M % i == 0:
if i not in dic:
dic[i] = 1
else:
dic[i] += 1
M //= i
if M != 1:
dic[M] = 1
ans = 1
#print (dic)
for i in dic:
ans *= nCr(dic[i] + N - 1,dic[i])
#print (ans)
ans %= (10 ** 9 + 7)
print((ans % (10**9+7)))
| import sys
mod = 1000000007
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else : return power(x, y//2)**2 * x % mod
def div(a, b):
return mul(a, pow(b, mod-2,mod))
ivl = [0]
def inverse_max(a): #下2つを使用する際の下準備
now = 1
for i in range(a):
i += 1
now *= i
now %= mod
ivl.append(now)
def nCr(n,r):
return div(ivl[n] , mul(ivl[n-r] , ivl[r]))
N,M = list(map(int,input().split()))
inverse_max(N + 40)
if N == 1:
print((1))
sys.exit()
l = [2]
now = 3
while now ** 2 <= M:
flag = True
for i in l:
if now % i == 0:
flag = False
break
if flag:
l.append(now)
now += 2
dic = {}
for i in l:
while M % i == 0:
if i not in dic:
dic[i] = 1
else:
dic[i] += 1
M //= i
if M != 1:
dic[M] = 1
ans = 1
#print (dic)
for i in dic:
ans *= nCr(dic[i] + N - 1,dic[i])
#print (ans)
ans %= (10 ** 9 + 7)
print((ans % (10**9+7))) | p03253 |
import math
import collections
Max = 210000
Mod = 1000000007
fac = [0] * Max
finv = [0] * Max
inv = [0] * Max
def COMinit():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, Max):
fac[i] = fac[i-1] * i % Mod
inv[i] = Mod - inv[Mod%i] * (Mod//i) % Mod
finv[i] = finv[i-1] * inv[i] % Mod
def COM(n, k):
if n < 0 or k < 0 or n < k:
return 0
return fac[n] * (finv[k] * finv[n-k] % Mod) % Mod
N, M = list(map(int, input().split()))
prime_count = collections.Counter()
for i in range(2, math.ceil(math.sqrt(M))+1):
while M % i == 0:
M /= i
prime_count[i] += 1
if M > 1:
prime_count[M] += 1
ans = 1
COMinit()
for i, b in list(prime_count.items()):
tmp = COM(b+N-1, N-1)
ans = (ans * tmp) % Mod
print(ans)
| import math
import collections
Mod = 1000000007
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
def COMinit():
for i in range(2, N+111):
fac.append(fac[-1]*i%Mod)
inv.append((-inv[Mod%i] * (Mod//i)) % Mod)
finv.append(finv[-1] * inv[-1] % Mod)
def COM(n, k):
if n < 0 or k < 0 or n < k:
return 0
return fac[n] * (finv[k] * finv[n-k] % Mod) % Mod
N, M = list(map(int, input().split()))
prime_count = collections.Counter()
for i in range(2, math.ceil(math.sqrt(M))+1):
while M % i == 0:
M /= i
prime_count[i] += 1
if M > 1:
prime_count[M] += 1
ans = 1
COMinit()
for i, b in list(prime_count.items()):
tmp = COM(b+N-1, N-1)
ans = (ans * tmp) % Mod
print(ans)
| p03253 |
import math
from collections import Counter
n, m =list(map(int, input().split()))
mod = 10**9+7
prime_count = Counter()
for i in range(2, math.ceil(math.sqrt(m))+1):
while m % i == 0:
m /= i
prime_count[i] += 1
if m > 1:
prime_count[int(m)] += 1
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
ans = 1
for p, q in list(prime_count.items()):
ans *= ncr(q+n-1, n-1, mod)
ans %= mod
print(ans) | import math
from collections import Counter
n, m = list(map(int, input().split()))
prime_count = Counter()
for i in range(2, math.ceil(math.sqrt(m))+1):
while m % i == 0:
m /= i
prime_count[i] += 1
if m > 1:
prime_count[int(m)] += 1
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
p=10**9+7
ans = 1
for k, v in list(prime_count.items()):
ans *= ncr(n-1+v, n-1, p)
ans %= p
print(ans) | p03253 |
import math
from collections import Counter
n, m = list(map(int, input().split()))
prime_count = Counter()
for i in range(2, math.ceil(math.sqrt(m))+1):
while m % i == 0:
m /= i
prime_count[i] += 1
if m > 1:
prime_count[int(m)] += 1
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
p=10**9+7
ans = 1
for k, v in list(prime_count.items()):
ans *= ncr(n-1+v, n-1, p)
ans %= p
print(ans) | import math
from collections import Counter
n, m = list(map(int, input().split()))
prime_count = Counter()
for i in range(2, math.ceil(math.sqrt(m))+1):
while m % i == 0:
m /= i
prime_count[i] += 1
if m > 1:
prime_count[int(m)] += 1
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
p=10**9+7
ans = 1
for k, v in list(prime_count.items()):
ans *= ncr(v+n-1, v, p)
ans %= p
print(ans)
| p03253 |
n,m=list(map(int,input().split()))
i=2
s=[]
while 1<m:
j=0
while m % (i**(j+1))==0:
j+=1
if j:
m//=i**j
s+=[j]
i+=1
a=1
for v in s:
c = 1
for i in range(v):
c = c * (n+i) // (1+i)
a = a * c % (10**9+7)
print(a)
| n,m=list(map(int,input().split()))
i=2
s=[]
while i*i<=m:
j=0
while m % i == 0:
m//=i
j+=1
if j:
s+=[j]
i+=1
a=1
if m > 1:
s+=[1]
for v in s:
c = 1
for i in range(v):
c = c * (n+i) // (1+i)
a = a * c % (10**9+7)
print(a)
| p03253 |
import math
N,M = list(map(int,input().split(" ")))
MOD = 10 ** 9 + 7
def factorize(n):
fct = [] # prime factor
b, e = 2, 0 # base, exponent
while b * b <= n:
while n % b == 0:
n = n // b
e = e + 1
if e > 0:
fct.append((b, e))
b, e = b + 1, 0
if n > 1:
fct.append((n, 1))
return fct
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
ans = 1
fac = factorize(M)
for temp in fac:
num = temp[1]
ans *= combinations_count(num + N - 1,N-1)
ans %= MOD
print(ans)
| import math
N,M = list(map(int,input().split(" ")))
MOD = 10 ** 9 + 7
def factorize(n):
fct = [] # prime factor
b, e = 2, 0 # base, exponent
while b * b <= n:
while n % b == 0:
n = n // b
e = e + 1
if e > 0:
fct.append((b, e))
b, e = b + 1, 0
if n > 1:
fct.append((n, 1))
return fct
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n;
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k]) % MOD
return result % MOD
ans = 1
fac = factorize(M)
for temp in fac:
num = temp[1]
ans *= cmb(num + N - 1,num)
ans %= MOD
print(ans)
| p03253 |
n,m=list(map(int,input().split()))
import math
sosuu=[]
m0=m
i=2
while i**2<=m:
if m0%i==0:
sosuu.append(0)
while m0%i==0:
m0=m0//i
sosuu[-1]=sosuu[-1]+1
i=i+1
if m0>1:
sosuu.append(1)
def c(n,r):
return math.factorial(n)//(math.factorial(r)*math.factorial(n-r))
answer=1
for i in sosuu:
a=c(i+n-1,i)
answer=(answer*a)%(10**9+7)
print(answer)
| n,M=list(map(int,input().split()))
from math import factorial
i=2
c_list=[]
m=M
while not m==1:
count=0
while m%i==0:
m=m//i
count=count+1
if not count==0:
c_list.append(count)
i=i+1
if M==1:
print((1))
else:
INF=10**9+7
Sum=1
for i in c_list:
Sum=Sum*(factorial(n-1+i)//(factorial(n-1)*factorial(i)))
Sum=Sum%INF
print(Sum)
| p03253 |
n,M=list(map(int,input().split()))
from math import factorial
i=2
c_list=[]
m=M
while i**2<=M:
count=0
while m%i==0:
m=m//i
count=count+1
if not count==0:
c_list.append(count)
i=i+1
if not m==1:
c_list.append(1)
if M==1:
print((1))
else:
INF=10**9+7
Sum=1
for i in c_list:
Sum=Sum*(factorial(n-1+i)//(factorial(n-1)*factorial(i)))
Sum=Sum%INF
print(Sum)
| n,M=list(map(int,input().split()))
i=2
c_list=[]
m=M
while i**2<=M:
count=0
while m%i==0:
m=m//i
count=count+1
if not count==0:
c_list.append(count)
i=i+1
if not m==1:
c_list.append(1)
def comb(x,y):
a=1
for i in range(x-y+1,x+1):
a=a*i
b=1
for i in range(1,y+1):
b=b*i
return a//b
if M==1:
print((1))
else:
INF=10**9+7
Sum=1
for i in c_list:
Sum=Sum*comb(i+n-1,i)
Sum=Sum%INF
print(Sum)
| p03253 |
iN,iM = [int(x) for x in input().split()]
iD = 10**9 +7 #法
def fPrimeCounter(iM):
i = 2
iS = int(iM ** 0.5) + 1
aRet = []
while i < iS or iM != 1:
iCounter = 0
while iM % i == 0:
iM = iM // i
iCounter += 1
if 0 < iCounter : aRet.append(iCounter)
i += 1
return aRet
#二分累乗法 iDを法として
def fBiPow(iX,iN,iD):
iY = 1
while iN > 0:
if iN % 2 == 0:
iX = iX * iX % iD
iN = iN // 2
else:
iY = iX * iY % iD
iN = iN - 1
return iY
aP = fPrimeCounter(iM)
if aP == [] :
print((1))
else:
iMax = max(aP) + iN - 1
aM = [1] * (iMax + 1)
#階乗 iD を法とした
for i in range(1,iMax + 1):
aM[i] = aM[i-1] * i % iD
aInvM = [1]* (iMax + 1)
aInvM[iMax] = fBiPow(aM[iMax],iD-2,iD)
#階乗の逆元 iD を法とした
for i in range(iMax,0,-1):
aInvM[i-1] = aInvM[i]*i % iD
iRet = 1
for i in aP:
# i + iN -1 C iN -1
iRet *= aM[i+iN-1] * aInvM[iN-1] * aInvM[i] % iD
iRet %= iD
print(iRet)
|
iN,iM = [int(x) for x in input().split()]
iD = 10**9 +7 #法
def fPrimeCounter(iM):
iS = int(iM ** 0.5) + 1
aRet = []
for i in range(2,iS + 1):
iCounter = 0
while iM % i == 0:
iM = iM / i
iCounter += 1
if 0 < iCounter : aRet.append(iCounter)
if iM == 1 : break
if 1 < iM : aRet.append(1)
return aRet
#二分累乗法 iDを法として
def fBiPow(iX,iN,iD):
iY = 1
while iN > 0:
if iN % 2 == 0:
iX = iX * iX % iD
iN = iN // 2
else:
iY = iX * iY % iD
iN = iN - 1
return iY
aP = fPrimeCounter(iM)
if len(aP) == 0:
print((1))
exit()
iMax = max(aP) + iN - 1
aM = [1] * (iMax + 1)
#階乗 iD を法とした
for i in range(1,iMax + 1):
aM[i] = aM[i-1] * i % iD
aInvM = [1]* (iMax + 1)
aInvM[iMax] = fBiPow(aM[iMax],iD-2,iD)
#階乗の逆元 iD を法とした
for i in range(iMax,0,-1):
aInvM[i-1] = aInvM[i]*i % iD
iRet = 1
for i in aP:
# i + iN -1 C iN -1
iRet *= aM[i+iN-1] * aInvM[iN-1] * aInvM[i] % iD
iRet %= iD
print(iRet)
| p03253 |
from math import factorial
iN,iM = [int(x) for x in input().split()]
iD = 10**9 +7 #法
def fPrimeCounter(iM):
iS = int(iM ** 0.5) + 1
aRet = []
for i in range(2,iS + 1):
iCounter = 0
while iM % i == 0:
iM = iM / i
iCounter += 1
if 0 < iCounter : aRet.append(iCounter)
if iM == 1 : break
if 1 < iM : aRet.append(1)
return aRet
aP = fPrimeCounter(iM)
iRet = 1
for i in aP:
iRet *= (factorial(i+iN-1) // (factorial(iN-1) * factorial(i)) )% iD
iRet %= iD
print(iRet)
|
iN,iM = [int(x) for x in input().split()]
iD = 10**9 +7 #法
def fPrimeCounter(iM):
iS = int(iM ** 0.5) + 1
aRet = []
for i in range(2,iS + 1):
iCounter = 0
while iM % i == 0:
iM /= i
iCounter += 1
if 0 < iCounter : aRet.append(iCounter)
if iM == 1 : break
if 1 < iM : aRet.append(1)
return aRet
def fnCr(iN,iR,iD):
iR = min(iR,iN-iR)
if iR == 0 :
return 1
elif iR == 1 :
return iN
return (iN % iD) * pow(iR,iD-2,iD) * fnCr(iN-1,iR-1,iD) % iD
aP = fPrimeCounter(iM)
#if aP == []:
# print(1)
# exit()
iRet = 1
for i in aP:
# i + iN -1 C iN -1
iRet *= fnCr(i+iN-1,i,iD)
iRet %= iD
print(iRet)
| p03253 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n, m = list(map(int, input().split()))
MOD = 10 ** 9 + 7
factorial = [0] * (10 ** 6 + 1)
inverse = [0] * (10 ** 6 + 1)
factorial[0] = inverse[0] = 1
for i in range(1, 10 ** 6 + 1):
factorial[i] = (factorial[i-1] * i) % MOD
inverse[i] = pow(factorial[i], MOD-2, MOD)
prime_factors = []
total = 0
i = 2
while i ** 2 <= m:
ext = 0
while m % i == 0:
ext += 1
m //= i
if ext:
prime_factors.append((i, ext))
total += ext
i += 1
if m != 1:
prime_factors.append((m, 1))
total += 1
ans = 1
for pf, num in prime_factors:
ans = (ans * (factorial[num + (n-1)] * inverse[num] * inverse[n-1])) % MOD
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n, m = list(map(int, input().split()))
MOD = 10 ** 9 + 7
prime_factors = []
i = 2
while i ** 2 <= m:
ext = 0
while m % i == 0:
ext += 1
m //= i
if ext:
prime_factors.append((i, ext))
i += 1
if m != 1:
prime_factors.append((m, 1))
ans = 1
for pf, num in prime_factors:
denominator = 1
numerator = 1
for i in range(num):
denominator *= (i+1)
numerator *= (num + (n-1)) - i
ans = (ans * (numerator // denominator)) % MOD
print(ans)
| p03253 |
import math
def combination(n,k):
return (math.factorial(n)//math.factorial(k))//math.factorial(n-k)
R = 10**9 + 7
(N, M) = list(map(int,input().split()))
decomposition = []
i = 2
while i * i <= M:
if M % i == 0:
decomposition.append(0)
while M % i ==0:
decomposition[-1] = decomposition[-1] + 1
M = M//i
i = i + 1
if M > 1:
decomposition.append(1)
H = [ combination(N+k-1,k) % R for k in decomposition]
r = 1
for h in H:
r = (r*h) % R
print(r) | import math
R = 10**9 + 7
def combination(n,k):
if 2*k > n:
k = n - k
r = 1
for i in range(n-k+1,n+1):
r = (r*i)
r = (r//math.factorial(k))
return r
(N, M) = list(map(int,input().split()))
decomposition = []
i = 2
while i * i <= M:
if M % i == 0:
decomposition.append(0)
while M % i ==0:
decomposition[-1] = decomposition[-1] + 1
M = M//i
i = i + 1
if M > 1:
decomposition.append(1)
H = [ combination(N+k-1,k) % R for k in decomposition]
r = 1
for h in H:
r = (r*h) % R
print(r) | p03253 |
inpl = lambda: list(map(int,input().split()))
MOD = 10**9 + 7
N, M = inpl()
def factorize(n):
prime_list = []
factorize_list = []
i = 2
while i*i <= n:
for p in prime_list:
if i % p == 0:
break
else:
prime_list.append(i)
k = 0
while n % i == 0:
n //= i
k += 1
factorize_list.append(k)
i += 1
if n > 1:
factorize_list.append(1)
return(factorize_list)
def H(n,k):
h = 1
L = n + k - 1
k = min(n-1,k)
for j in range(k):
h *= L-j
for j in range(k):
h //= j+1
return h
ans = 1
for k in factorize(M):
ans *= H(N,k) % MOD
ans %= MOD
print(ans) | inpl = lambda: list(map(int,input().split()))
MOD = 10**9 + 7
N, M = inpl()
def factorize(n):
factorize_list = []
i = 2
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k > 0:
factorize_list.append(k)
i += 1
if n > 1:
factorize_list.append(1)
return(factorize_list)
def H(n,k):
h = 1
L = n + k - 1
k = min(n-1,k)
for j in range(k):
h *= L-j
for j in range(k):
h //= j+1
return h
ans = 1
for k in factorize(M):
ans *= H(N,k) % MOD
ans %= MOD
print(ans) | p03253 |
import math
def isprime(n):
if(n<2):
return False
for i in range(2,int(n**0.5)+1):
if(n%i==0):
return False
return True
def primelist(n):
return [i for i in range(n) if isprime(i)]
def factor(n):
f = {}
for p in primelist(int(n**0.5)+1):
while(n % p == 0):
f[p] = f.get(p, 0) + 1
n //= p
if(n != 1):
f[n] = 1
return f
# mの各素因数を振り分ける
# 各素因数p(^a)について，nつに振り分ける
# (n+a)! / (n!a!)
n,m=list(map(int, input().split()))
f = factor(m)
ans = 1
for k,v in list(f.items()):
ans *= (math.factorial(n-1+v)//(math.factorial(n-1)*math.factorial(v)))
ans %= (int(1e9+7))
print(ans)
| import math
def factorize(n):
ret={}
i = 2
while n >= i**2:
cnt = 0
while n % i == 0:
n //= i
cnt += 1
if cnt != 0:
ret[i] = cnt
i += 1
if n != 1:
ret[n] = 1
return ret
def combination(n,r):
ret = 1
r = min(r, n-r)
for i in range(n-r+1, n+1):
ret *= i
for i in range(1, r+1):
ret //= i
return ret
# mの各素因数を振り分ける
# 各素因数p(^a)について，nつに振り分ける
# n-1+a C n-1
n,m=list(map(int, input().split()))
f = factorize(m)
ans = 1
for k,v in list(f.items()):
ans *= combination(n-1+v, v)
ans %= (int(1e9+7))
print(ans)
| p03253 |
# 2 6=>4 (1,6)*2,(2,3)*2
# 3 12=>18 (1,1,12)*3,(1,2,6)*6,(1,3,4)*6,(2,2,3)*3
import math
def comb(a,b): # aCb
return math.factorial(a)//math.factorial(a-b)//math.factorial(b)
n,m=list(map(int,input().split()))
divisor={}
tmp=m
# for i in range(2,m+1):
i=2
while i*i<=m:
while tmp%i==0:
tmp//=i
divisor.setdefault(i,0)
divisor[i]+=1
# if tmp==1:
# break
i+=1
if tmp>1:
divisor[tmp]=1
# print(divisor)
cnt=1
for key in divisor:
c=divisor[key]
cnt*=comb(c+n-1,c)
print((cnt%1000000007))
| # うまく効率化できなかった
# 2 6=>4 (1,6)*2,(2,3)*2
# 3 12=>18 (1,1,12)*3,(1,2,6)*6,(1,3,4)*6,(2,2,3)*3
# import math
# def comb(a,b):
# return math.factorial(a)//math.factorial(a-b)//math.factorial(b)
def comb(a,b): # aCb
b=min(b,a-b)
result=1
for i in range(a,a-b,-1):
result*=i
for i in range(1,b+1):
result//=i
return result
n,m=list(map(int,input().split()))
divisor={}
tmp=m
# for i in range(2,m+1):
# while tmp%i==0:
# tmp//=i
# divisor.setdefault(i,0)
# divisor[i]+=1
# if tmp==1:
# break
i=2
while i*i<=m:
while tmp%i==0:
tmp//=i
divisor.setdefault(i,0)
divisor[i]+=1
i+=1
if tmp>1:
divisor[tmp]=1
# print(divisor)
cnt=1
for key in divisor:
c=divisor[key]
cnt*=comb(c+n-1,c)
print((cnt%1000000007))
| p03253 |
def com(n,m):
if(n-m < m):
m=n-m
result=1
mylist=[i for i in range(1,m+1)]
j=1
for i in range(1,m+1):
result*=(n+1-i)
if(j<m):
while(result%mylist[j]==0):
result//=mylist[j]
j+=1
if(j>=m):
break
return result
def yakusuu(i,m):
_i=i
while(i*2<=m):
if(m%i==0):
return i
else:
i+=1
for j in range(_i-1,0,-1):
if(m%j==0):
break
return m//j
N,M=list(map(int,input().split()))
soinsuubunkai={}
tmp=2
i=2
_M=M
while(tmp <=M):
tmp=yakusuu(tmp,M)
if(tmp in soinsuubunkai):
soinsuubunkai[tmp]+=1
else:
soinsuubunkai[tmp]=1
M//=tmp
if(M==1):
break
tmp=1
for k in list(soinsuubunkai.values()):
tmp*=com(k+N-1,k)
tmp%=10**9+7
print(tmp) | def com(n,m):
if(n-m < m):
m=n-m
result=1
mylist=[i for i in range(1,m+1)]
j=1
for i in range(1,m+1):
result*=(n+1-i)
if(j<m):
while(result%mylist[j]==0):
result//=mylist[j]
j+=1
if(j>=m):
break
return result
def yakusuu(i,m):
_i=i
while(i**2<=m):
if(m%i==0):
return i
else:
i+=1
for j in range(_i-1,0,-1):
if(m%j==0):
break
return m//j
N,M=list(map(int,input().split()))
soinsuubunkai={}
tmp=2
i=2
_M=M
while(tmp <=M):
tmp=yakusuu(tmp,M)
if(tmp in soinsuubunkai):
soinsuubunkai[tmp]+=1
else:
soinsuubunkai[tmp]=1
M//=tmp
if(M==1):
break
tmp=1
for k in list(soinsuubunkai.values()):
tmp*=com(k+N-1,k)
tmp%=10**9+7
print(tmp) | p03253 |
from itertools import groupby
from math import factorial
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.append(i)
if n > 1:
factors.append(n)
return factors
def comb(n, r):
return factorial(n) // (factorial(n - r) * factorial(r))
N, M = list(map(int, input().split()))
result = 1
for k, g in groupby(prime_factors(M)):
result = result * comb(len(list(g)) + N - 1, N - 1)
result = result % (10 ** 9 + 7)
print(result)
| import operator as op
from itertools import groupby
from functools import reduce
NN = 10 ** 9 + 7
def prime_factors(n):
i = 2
while i * i <= n:
if n % i:
i += 1
else:
n //= i
yield i
if n > 1:
yield n
def ncr(n, r):
r = min(r, n-r)
numer = reduce(op.mul, list(range(n, n-r, -1)), 1)
denom = reduce(op.mul, list(range(1, r+1)), 1)
return numer // denom
N, M = list(map(int, input().split()))
result = 1
for k, g in groupby(prime_factors(M)):
result = result * ncr(len(list(g)) + N - 1, N - 1)
if result > NN:
result = result % NN
print(result)
| p03253 |
import math
def prime_factor(n):
ass = []
for i in range(2,int(n**0.5)+1):
while n % i==0:
ass.append(i)
n = n//i
if n != 1:
ass.append(n)
return ass
N,M = list(map(int,input().split()))
L = prime_factor(M)
L.append(0)
K = []
cur = L[0]
cnt = 0
for i in range(len(L)):
if cur == L[i]:
cnt += 1
else:
K.append(cnt)
cnt = 1
cur = L[i]
ans = 1
for i in range(len(K)):
n = K[i]+N-1
k = N-1
a = (math.factorial(n))%(10**9+7)
b = (math.factorial(k)%(10**9+7))
c = (math.factorial(n-k)%(10**9+7))
ans *= (a*pow(b*c,10**9+5,10**9+7))%(10**9+7)
print((ans%(10**9+7))) | import math
def prime_factor(n):
ass = []
for i in range(2,int(n**0.5)+1):
while n % i==0:
ass.append(i)
n = n//i
if n != 1:
ass.append(n)
return ass
N,M = list(map(int,input().split()))
L = prime_factor(M)
L.append(0)
K = []
cur = L[0]
cnt = 0
for i in range(len(L)):
if cur == L[i]:
cnt += 1
else:
K.append(cnt)
cnt = 1
cur = L[i]
ans = 1
for i in range(len(K)):
n = K[i]+N-1
k = N-1
cur = 1
for i in range(k+1,n+1):
cur *= i
for j in range(1,n-k+1):
cur = cur//j
ans *= cur%(10**9+7)
print((ans%(10**9+7))) | p03253 |
"""
---アルゴリズム概要---
a1 ~ anの各スロットに、Mの各素因数をいくつ置くか、という問題。
まずは、Mを素因数分解し、それから重複組み合わせの容量で、各素因数ごとに配分パターンを算出。
それらの配分パターンを素因数間でかけ合わせると、答えとなる。
Mの素因数分解は、試し割り法という最もシンプルな方法で行う。
"""
from collections import Counter
import math
N,M = list(map(int,input().split()))
factors = []
while True:
if M % 2 == 0:
M //= 2
factors.append(2)
else:
break
f = 3
while f**2 <= M:
if M % f == 0:
M //= f
factors.append(f)
else:
f += 2
if M != 1:
factors.append(M)
counter = Counter(factors)
ans = 1
for r in list(counter.values()):
ans *= math.factorial(N+r-1)//(math.factorial(N-1)*math.factorial(r))
print((ans%(10**9+7))) | """
---アルゴリズム概要---
Mを構成する素因数を、a1~aNの各スロットにいくつ置くのか、を考える問題。
まずは試し割りによってMを素因数分解。
重複組合せの公式で各素因数の配置パターンを算出し累乗していく。
試し割りは、O(√M)の計算量で処理できる。
√Mを超える素因数は、多くても一つしか存在しないため、√Mを超える値で試し割りをする必要はない。
もし√Mまでの値で試し割りを終えた段階で、Mを素因数分解しきれていなければ、残った商こそが√Mを超える唯一の素因数である。
簡単に証明
もし√Mを超える素因数が２つ存在しているとしよう。
それらは、(√M + α)と(√M + β)というふうに表すことができる。
この２つの積は明らかにMの値を超えてしまう。つまり前提に矛盾する。
したがって、√Mを超える素因数は多くても一つ
"""
from collections import Counter
import math
N,M = list(map(int,input().split()))
factors = []
while M%2 == 0:
M//=2
factors.append(2)
f = 3
while f**2 <= M:
while M%f==0:
M//=f
factors.append(f)
f+=2
if M!=1:
factors.append(M)
factors = Counter(factors)
ans = 1
for k in list(factors.values()):
ans *= math.factorial(k+N-1)//(math.factorial(N-1)*math.factorial(k))
print((ans%(10**9+7))) | p03253 |
import math
N, M = list(map(int, input().split(' ')))
MOD = int(1e9 + 7)
primes = []
if M % 2 == 0:
primes.append(2)
def is_prime(n):
for i in range(len(primes)):
if n % primes[i] == 0:
return False
return True
for i in range(3, int(1e5)):
if is_prime(i):
primes.append(i)
seeds = []
for p in primes:
while M % p == 0:
seeds.append(p)
M = M // p
def comb(n, k):
ans = 1
for i in range(1, k + 1):
ans = (ans * (n + 1 - i) // i)
return ans
ans = comb(len(seeds)-1, N-1)
# !!! 24=(2^a1 * 3^b1) * (2^a2 * 3^b2) * ... | sum(a) = 3, sub(b) = 1, len(a) = 4
# aのパターン数は 3,0,0,0 = ooo|||, 2,1,0,0 = oo|o|| なので並び替えのパターン数で
# (sum(a) + 分ける数)! / (sum(a)! * 分ける数!) = (6!/(3!3!)) = 20
# b にも同じことをして 1,0,0,0 = o||| = (1+3)!/(1!*3!) = 4
# 24を4つに分けるパターンは 20 * 4 = 80?
# (a+b)!/(a!b!) = (a+b)Ca = (a+b)Cb
ans = 1
hogehoge = set(seeds)
for i in hogehoge:
a_ct = seeds.count(i)
ans = (ans * comb(a_ct + N-1, min(a_ct, N-1))) % MOD
print(ans)
| N, M = list(map(int, input().split(' ')))
MOD = int(1e9 + 7)
primes = []
if M % 2 == 0:
primes.append(2)
seeds = []
p = 2
while M > 1:
while M % p == 0:
seeds.append(p)
M = M // p
if p*p > M:
if M != 1:
seeds.append(M)
M = 0
p += 1
def comb(n, k):
ans = 1
for i in range(1, k + 1):
ans = (ans * (n + 1 - i) // i)
return ans
ans = 1
hogehoge = set(seeds)
for i in hogehoge:
a_ct = seeds.count(i)
ans = (ans * comb(a_ct + N-1, min(a_ct, N-1))) % MOD
print(ans)
| p03253 |
from itertools import groupby
N, M = list(map(int, input().split()))
mod = 10 ** 9 + 7
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
def make_table(n, mod=10 ** 9 + 7):
N = n
# 元テーブル
g1 = [0] * (N + 1)
g1[0] = 1
g1[1] = 1
# 逆元テーブル
g2 = [0] * (N + 1)
g2[0] = 1
g2[1] = 1
# 逆元テーブル計算用テーブル
inverse = [0] * (N + 1)
inverse[0] = 0
inverse[1] = 1
for i in range(2, N + 1):
g1[i] = (g1[i - 1] * i) % mod
inverse[i] = (-inverse[mod % i] * (mod // i)) % mod
g2[i] = (g2[i - 1] * inverse[i]) % mod
return g1, g2
def main():
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
p = [len(list(j)) for i, j in groupby(prime_factorize(M))]
g1, g2 = make_table(10 ** 6, mod)
answer = 1
for i in p:
answer *= cmb(i + N - 1, N - 1, mod)
answer %= mod
print(answer)
if __name__ == '__main__':
main()
| from itertools import groupby
from operator import mul
from functools import reduce
N, M = list(map(int, input().split()))
mod = 10 ** 9 + 7
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
def cmb(n, r):
r = min(n - r, r)
if r == 0:
return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def main():
p = [len(list(j)) for i, j in groupby(prime_factorize(M))]
answer = 1
for i in p:
answer *= cmb(i + N - 1, N - 1)
answer %= mod
print(answer)
if __name__ == '__main__':
main()
| p03253 |
def d_factorization(N, M):
def prime_factorization_dict(n):
if n == 1:
return {2: 0} # 1は素数の0乗の積とみなす
i = 2
table = {}
while i**2 <= n:
table[i] = 0
while n % i == 0:
table[i] += 1
n //= i
if table[i] == 0:
table.pop(i)
i += 1
if n > 1:
table[n] = 1
return table
class Combination(object):
def __init__(self, n, mod):
self.mod = mod
# フェルマーの小定理による組合せの計算
self.factorial = [1] * (n + 1) # 0!からn!の結果を格納
for k in range(1, n):
self.factorial[k + 1] = (self.factorial[k] * (k + 1)) % mod
# k!のmodにおける逆元を計算
self.fact_inv = [1] * (n + 1)
self.fact_inv[n] = pow(self.factorial[n], mod - 2, mod)
for k in reversed(list(range(1, n + 1))):
self.fact_inv[k - 1] = (self.fact_inv[k] * k) % mod
def comb(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return (self.factorial[n] * self.fact_inv[r] * self.fact_inv[n - r]) % self.mod
def comb_with_repetition(self, n, r):
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.comb(n + r - 1, r)
MOD = 10**9 + 7
prime_m = prime_factorization_dict(M)
c = Combination(max(prime_m.values()) + N - 1, MOD)
ans = 1
for b in list(prime_m.values()):
ans = (ans * c.comb_with_repetition(N, b)) % MOD
return ans
N, M = [int(i) for i in input().split()]
print((d_factorization(N, M))) | def d_factorization(MOD=10**9 + 7):
N, M = [int(i) for i in input().split()]
def prime_factorization_dict(n):
if n == 1:
return {2: 0} # 1は素数の0乗の積とみなす
i, table = 2, {}
while i**2 <= n:
table[i] = 0
while n % i == 0:
table[i] += 1
n //= i
if table[i] == 0:
table.pop(i)
i += 1
if n > 1:
table[n] = 1
return table
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ['mod', 'factorial', 'inverse']
def __init__(self, max_val_arg: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_val_arg + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_val_arg, 0, -1):
inv_append((inv[-1] * i) % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
def combination_with_repetition(self, n, r):
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.combination(n + r - 1, r)
prime_m = prime_factorization_dict(M)
h = Combination(max(prime_m.values()) + N - 1).combination_with_repetition
ans = 1
for b in list(prime_m.values()):
ans = (ans * h(N, b)) % MOD
return ans
print((d_factorization())) | p03253 |
def d_factorization(MOD=10**9 + 7):
N, M = [int(i) for i in input().split()]
def prime_factorization_dict(n):
if n == 1:
return {2: 0} # 1は素数の0乗の積とみなす
i, table = 2, {}
while i**2 <= n:
table[i] = 0
while n % i == 0:
table[i] += 1
n //= i
if table[i] == 0:
table.pop(i)
i += 1
if n > 1:
table[n] = 1
return table
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ['mod', 'factorial', 'inverse']
def __init__(self, max_val_arg: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_val_arg + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_val_arg, 0, -1):
inv_append((inv[-1] * i) % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
def combination_with_repetition(self, n, r):
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.combination(n + r - 1, r)
prime_m = prime_factorization_dict(M)
h = Combination(max(prime_m.values()) + N - 1).combination_with_repetition
ans = 1
for b in list(prime_m.values()):
ans = (ans * h(N, b)) % MOD
return ans
print((d_factorization())) | def d_factorization(MOD=10**9 + 7):
N, M = [int(i) for i in input().split()]
def prime_factorization_dict(n):
if n == 1:
return {2: 0} # 1は素数の0乗の積とみなす
i, table = 2, {}
while i**2 <= n:
table[i] = 0
while n % i == 0:
table[i] += 1
n //= i
if table[i] == 0:
table.pop(i)
i += 1
if n > 1:
table[n] = 1
return table
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ['mod', 'factorial', 'inverse']
def __init__(self, max_val_arg: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_val_arg + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_val_arg, 0, -1):
inv_append((inv[-1] * i) % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
def combination_with_repetition(self, n, r):
return self.combination(n + r - 1, r)
prime_m = prime_factorization_dict(M)
h = Combination(max(prime_m.values()) + N - 1).combination_with_repetition
ans = 1
for b in list(prime_m.values()):
ans = (ans * h(N, b)) % MOD
return ans
print((d_factorization())) | p03253 |
import collections
import math
n,m=list(map(int,input().split()))
flag=0
P=[]
p=m
while flag==0:
cur=p
for i in range(2,int(p**0.5)+1):
if p%i==0:
P.append(i)
p//=i
break
if p==cur:
P.append(p)
flag=1
c=collections.Counter(P)
Primes=set(P)
def f(i):
return math.factorial(i)
def fn(i):
return f(n+i-1)//(f(n-1)*f(i))%(10**9+7)
ans=1
for p in Primes:
ans*=fn(c[p])
ans%=(10**9+7)
print((1 if m==1 else ans))
| import sys
input=lambda: sys.stdin.readline().rstrip()
mod=10**9+7
n,m=list(map(int,input().split()))
n_max=2*(10**5+1)
F,FI=[0]*(n_max+1),[0]*(n_max+1)
F[0],FI[0]=1,1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
FI[n_max-1]=pow(F[n_max-1],mod-2,mod)
for i in reversed(list(range(n_max-1))):
FI[i]=(FI[i+1]*(i+1))%mod
def comb(x,y):
return (F[x]*FI[x-y]*FI[y])%mod
pf={}
for i in range(2,int(m**0.5)+1):
while m%i==0:
pf[i]=pf.get(i,0)+1
m//=i
if m>1:
pf[m]=1
ans=1
for k in list(pf.keys()):
ans=(ans*comb(n-1+pf[k],pf[k]))%mod
print(ans) | p03253 |
import math
def factoring(n,dict_count = {}):
sup = math.floor(pow(n,1/2))
n_new = n
for i in range(2,sup + 1):
if n % i == 0:
n_new = n // i
if i in dict_count:
dict_count[i] += 1
else:
dict_count[i] = 1
break
if n == n_new:
if n_new in dict_count:
dict_count[n_new] += 1
else:
dict_count[n_new] = 1
return sorted(list(dict_count.items()))
return factoring(n_new,dict_count)
# 組み合わせ n_C_r
import math
def comb(n,r):
return math.factorial(n) // (math.factorial(n-r) * math.factorial(r))
N,M = list(map(int,input().split()))
if M == 1:
print((1))
exit()
ans = 1
for a,b in factoring(M):
ans *= comb(b+N-1,b)
ans %= 10**9 + 7
print(ans) | # 素因数分解 ソート済みリスト (素因数,指数)
import math
def factoring(n,dict_count = {}):
sup = math.floor(pow(n,1/2))
n_new = n
for i in range(2,sup + 1):
if n % i == 0:
n_new = n // i
if i in dict_count:
dict_count[i] += 1
else:
dict_count[i] = 1
break
if n == n_new:
if n_new in dict_count:
dict_count[n_new] += 1
else:
dict_count[n_new] = 1
return sorted(list(dict_count.items()))
return factoring(n_new,dict_count)
def comb(n,r):
r = min(r,n-r)
result = 1
for i in range(n-r+1,n+1):
result *= i
for i in range(1,r+1):
result //= i
return result
N,M = list(map(int,input().split()))
if M == 1:
print((1))
exit()
ans = 1
for a,b in factoring(M):
ans *= comb(b+N-1,b)
ans %= 10**9 + 7
print(ans) | p03253 |
from collections import defaultdict
n,m=list(map(int,input().split()))
mod=10**9+7
kaidan=[1]*(2*10**5+1)
gyaku=[1]*(2*10**5+1)
for i in range(1, 2*10**5):
kaidan[i]=i*kaidan[i-1] % mod
gyaku[i]=pow(kaidan[i],mod-2,mod)
def comb(a,b):
if a>0 and b>0 and a-b>0:
return (kaidan[a] * gyaku[b]*gyaku[a-b])%mod
elif a==0 or b==0 or a-b==0:
return 1
else:
return 0
soin=defaultdict(int)
while m>=2:
for i in range(2,int(n**.5)+5):
while m%i==0 and m!=0:
m//=i
soin[i]+=1
if m==1:
break
L=list(soin.values())
ans=1
for l in L:
ans*=comb(l+n-1,l)
ans%=mod
print(ans) | from collections import defaultdict
n,m=list(map(int,input().split()))
mod=10**9+7
kaidan=[1]*(2*10**5+1)
gyaku=[1]*(2*10**5+1)
for i in range(1, 2*10**5):
kaidan[i]=i*kaidan[i-1] % mod
gyaku[i]=pow(kaidan[i],mod-2,mod)
def comb(a,b):
if a>0 and b>0 and a-b>0:
return (kaidan[a] * gyaku[b]*gyaku[a-b])%mod
elif a==0 or b==0 or a-b==0:
return 1
else:
return 0
def fctr1(n):
f=[]
c=0
r=int(n**0.5)
for i in range(2,r+2):
while n%i==0:
c+=1
n=n//i
if c!=0:
f.append([i,c])
c=0
if n!=1:
f.append([n,1])
return f
# soin=defaultdict(int)
# while m>=2:
# for i in range(2,int(n**.5)+5):
# while m%i==0 and m!=0:
# m//=i
# soin[i]+=1
# if m==1:
# break
L=list(fctr1(m))
ans=1
for a,l in L:
ans*=comb(l+n-1,l)
ans%=mod
print(ans) | p03253 |
import sys
sys.setrecursionlimit(10**9)
def mi(): return list(map(int,input().split()))
def ii(): return int(eval(input()))
def isp(): return input().split()
def deb(text): print(("-------\n{}\n-------".format(text)))
INF=10**20
class Counting():
def __init__(self,maxim,mod):
maxim += 1
self.mod = mod
self.fact = [0]*maxim
self.fact[0] = 1
for i in range(1,maxim):
self.fact[i] = self.fact[i-1] * i % mod
self.invfact = [0]*maxim
self.invfact[maxim-1] = pow(self.fact[maxim-1],mod-2,mod)
for i in reversed(list(range(maxim-1))):
self.invfact[i] = self.invfact[i+1] * (i+1) % mod
def nCk(self,n,r):
if n < 0 or n < r: return 0
return self.fact[n] * self.invfact[r] * self.invfact[n-r] % self.mod
def nPk(self,n,r):
if n < 0 or n < r: return 0
return self.fact[n] * self.invfact[n-r] % self.mod
def main():
N,M=mi()
MOD=10**9+7
if N == 1:
print((1))
exit()
def prime_array(n):
a = []
b = set()
while n % 2 == 0:
a.append(2)
b.add(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
b.add(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
b.add(n)
return a,b
P,P_set = prime_array(M)
P_count = {p:0 for p in P_set}
for p in P:
P_count[p] += 1
ans = 1
counting = Counting(3*10**5+10,MOD)
for p,e in list(P_count.items()):
ans *= counting.nCk(e+N-1,e)
ans %= MOD
print((ans % MOD))
if __name__ == "__main__":
main() | import sys
sys.setrecursionlimit(10**9)
def mi(): return list(map(int,input().split()))
def ii(): return int(eval(input()))
def isp(): return input().split()
def deb(text): print(("-------\n{}\n-------".format(text)))
INF=10**20
class Counting():
def __init__(self,maxim,mod):
maxim += 1
self.mod = mod
self.fact = [0]*maxim
self.fact[0] = 1
for i in range(1,maxim):
self.fact[i] = self.fact[i-1] * i % mod
self.invfact = [0]*maxim
self.invfact[maxim-1] = pow(self.fact[maxim-1],mod-2,mod)
for i in reversed(list(range(maxim-1))):
self.invfact[i] = self.invfact[i+1] * (i+1) % mod
def nCk(self,n,r):
if n < 0 or n < r: return 0
return self.fact[n] * self.invfact[r] * self.invfact[n-r] % self.mod
def nPk(self,n,r):
if n < 0 or n < r: return 0
return self.fact[n] * self.invfact[n-r] % self.mod
def main():
N,M=mi()
MOD=10**9+7
if N == 1:
print((1))
exit()
def prime_factorize(n):
P = []
P_set = set()
while n % 2 == 0:
P.append(2)
P_set.add(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
P.append(f)
P_set.add(f)
n //= f
else:
f += 2
if n != 1:
P.append(n)
P_set.add(n)
P_count = {p:0 for p in P_set}
for p in P: P_count[p] += 1
return P_count
ans = 1
counting = Counting(3*10**5+10,MOD)
for p,e in list(prime_factorize(M).items()):
ans *= counting.nCk(e+N-1,e)
ans %= MOD
print((ans % MOD))
if __name__ == "__main__":
main() | p03253 |
import sys
N = int(eval(input()))
N = list(map(int,input().split()))
C= 1
if N==0:
print((0))
sys.exit()
for i in N:
C = C*i
if C > (10 ** 18):
C=-1
print(C) | def mul2():
n = int(eval(input()))
a = list(map(int, input().split()))
if 0 in a:
return 0
ans = 1
for i in a:
ans *= i
if ans > 1000000000000000000:
return -1
return ans
print((mul2())) | p02658 |
# ABC169 B Multiplication 2
from collections import deque
n = int(eval(input()))
a_list = deque([int(x) for x in input().split()])
ans = 1
for i in range(n):
ans *= a_list.popleft()
if ans > 10**18:
print("-1")
else:
print(ans) | # ABC169 B Multiplication 2
from collections import deque
n = int(eval(input()))
a_list = [int(x) for x in input().split()]
if min(a_list) == 0:
print("0")
else:
a_dq = deque(a_list)
ans = 1
for i in range(n):
ans *= a_dq.popleft()
if ans > 10**18:
break
if ans > 10**18:
print("-1")
else:
print(ans) | p02658 |
import sys
sys.setrecursionlimit(10000000)
input=sys.stdin.readline
n = int(eval(input()))
l = list(map(int,input().split()))
a=10**18
ans=1
for i in l:
ans*=i
if ans > a:print((-1));exit()
print(ans) | import sys
sys.setrecursionlimit(10000000)
input=sys.stdin.readline
n = int(eval(input()))
l = list(map(int,input().split()))
if 0 in l:print((0));exit()
a=10**18
ans=1
for i in l:
ans*=i
if ans > a:print((-1));exit()
print(ans) | p02658 |
N = int(eval(input()))
A=[int(i) for i in input().split()]
answer=1
for i in range(N):
answer = answer*A[i]
if answer>10**18:
print((-1))
else:
print(answer) | N = int(eval(input()))
A=[int(i) for i in input().split()]
answer=1
if 0 in A:
print((0))
else:
for i in range(N):
answer = answer*A[i]
if answer>10**18:
print((-1))
break
else:
print(answer) | p02658 |
N = int(eval(input()))
A = list(map(int, input().split()))
x = 1
for i in A:
x *= i
if x > 10**18:
print((-1))
else:
print(x) | N = int(eval(input()))
A = list(map(int, input().split()))
x = 1
if 0 in A:
print((0))
else:
for i in A:
x *= i
if x > 10**18:
break
if x > 10**18:
print((-1))
else:
print(x) | p02658 |
import sys
n = int(eval(input()))
a = list(map(int,input().split()))
c = 1
for i in range(n):
c *= a[i]
if (c > (10**18)):
print("-1")
sys.exit()
else:
print(c)
| import sys
n = int(eval(input()))
a = list(map(int,input().split()))
c = 1
for i in range(n):
if(a[i] == 0):
print("0")
sys.exit()
else:
for i in range(n):
c *= a[i]
if (c > (10**18)):
print("-1")
sys.exit()
print(c)
| p02658 |
n = int(input().strip())
arr = list(map(int, input().strip().split()))
ans = 1
for num in arr:
ans *= num
if ans > 10**18:
print((-1))
else:
print(ans)
|
n = int(input().strip())
arr = list(map(int, input().strip().split()))
arr.sort()
ans = 1
for num in arr:
ans *= num
if ans > 10**18:
print((-1))
exit(0)
print(ans)
| p02658 |
from sys import stdin
input = stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 1
for ta in a:
ans *= ta
if (ans > 10 ** 18):
print((-1))
else:
print(ans)
| from sys import stdin
input = stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 1
flag = True
for ta in a:
ans *= ta
if (ans > 10 ** 18):
flag = False
ans = 1
if (flag or ans == 0):
print(ans)
else:
print((-1))
| p02658 |
from functools import reduce
n=int(eval(input()))
anums=list(map(int,input().split()))
res=reduce(lambda x,y:x*y,anums,1)
print((res if res<=10**18 else -1))
| def main():
n=int(eval(input()))
anums=list(map(int,input().split()))
res=1
if 0 in anums:
return 0
for anum in anums:
res*=anum
if res>10**18:
return -1
return res
print((main())) | p02658 |
n = int(eval(input()))
multi = list(map(int,input().split()))
result = 1
for i in multi:
result = result * i
if (result > 10**18):
print((-1))
else:
print(result) | n = int(eval(input()))
multi = list(map(int,input().split()))
result = 1
if 0 in multi:
result = 0
print((0))
exit()
for i in range(n):
result = result * multi[i]
if (result > 10**18):
result = -1
break
print(result) | p02658 |
N = int(eval(input()))
A = list(map(int, input().split()))
P = 1
for i in range(N):
P = P * A[i]
if P <= 1e18:
print(P)
else:
print((-1)) | N = int(eval(input()))
A = list(map(int, input().split()))
newA = sorted(A)
P = 1
flag = 0
for i in range(N):
P = P * newA[i]
if P == 0:
print(P)
flag = 1
break
elif P > 1e18:
print((-1))
flag = 1
break
if flag == 0:
print(P) | p02658 |
from functools import reduce
n = int(eval(input()))
a = list(map(int, input().split()))
ans = reduce(lambda x,y:x*y,a)
print((ans if ans <= 10**18 else '-1')) | n = int(eval(input()))
a = list(map(int, input().split()))
b = [i for i in a if i != 1]
ans = 1
if len(b) < 100:
for i in range(len(b)):
ans *= b[i]
else:
ans = 10**18+1
if 0 in b:
ans = 0
print((ans if ans <= 10**18 else '-1')) | p02658 |
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 1
for i in A:
ans *= i
if ans <= 1000000000000000000:
print(ans)
else:
print('-1') | def main ():
N = int(eval(input()))
A = list(map(int,input(). split ()))
if 0 in A:
print((0))
return
prod = 1
for a in A:
prod *= a
if prod > 1000000000000000000:
print((-1))
return
print(prod)
main () | p02658 |
import collections
N=int(eval(input()))
A=list(map(int, input().split()))
A_dict=collections.Counter(A)
ANS=1
for key, value in list(A_dict.items()):
ANS=ANS*(key**value)
if ANS>10**18:
print("-1")
else:
print(ANS)
| import collections
import sys
N=int(eval(input()))
A=list(map(int, input().split()))
A_dict=collections.Counter(A)
ANS=1
if 0 in list(A_dict.keys()):
print("0")
sys.exit()
for key, value in list(A_dict.items()):
ANS=ANS*(key**value)
if ANS>10**18:
print((-1))
sys.exit()
print(ANS)
| p02658 |
n = int(eval(input()))
values =list(map(int, input().split()))
a=1
for i in range(n):
a=a*values[i]
if a<= 10**18:
print(a)
else:
print((-1)) | n = int(eval(input()))
values =list(map(int, input().split()))
a=1
t = 10**18
for i in range(n):
if values[i] == 0:
a = 0
break
if a > t:
continue
else:
a=a*values[i]
if a <= t:
print(a)
else:
print((-1)) | p02658 |
# -*- coding: utf-8 -*-
n = int(eval(input()))
nums = list(map(int, input().split()))
ans = 1
for i in range(n):
ans *= nums[i]
if ans > 10 ** 18:
print((-1))
exit()
print(ans)
| # -*- coding: utf-8 -*-
n = int(eval(input()))
nums = sorted(list(map(int, input().split())))
ans = 1
for i in range(n):
ans *= nums[i]
if ans == 0:
print((0))
exit()
if ans > 10 ** 18:
print((-1))
exit()
print(ans)
| p02658 |
N = int(eval(input()))
a = [int(i) for i in input().split(" ")]
res=1
xx=10**18
for i in a:
res*=i
if res>xx:
print((-1))
else:
print(res) | N = int(eval(input()))
a = [int(i) for i in input().split(" ")]
res=1
xx=10**18
f=0
a.sort()
for i in a:
res*=i
if res>xx:
f=1
print((-1))
break
if f==0:
print(res) | p02658 |
N = int(eval(input()))
A = list(map(int, input().split()))
SUM = 1
flag = 0
for a in A:
SUM = SUM*a
if SUM > 10**18:
print((-1))
else:
print(SUM) | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
ans = 1
for x in A:
ans *= x
if ans > 10 ** 18:
ans = -1
break
print(ans)
| p02658 |
n = int(eval(input()))
data = [int(x) for x in input().split()]
answer = 1
for x in data:
answer *= x
if answer <= 1e+18:
print(answer)
else:
print((-1)) | n = int(eval(input()))
data = [int(x) for x in input().split()]
if 0 in data:
print((0))
exit(
)
answer = 1
for x in data:
answer *= x
if answer > 1e+18:
answer = -1
break
print(answer) | p02658 |
N = int(eval(input()))
A_ls = list(map(int, input().split()))
mul = 1
for i in A_ls:
mul *= i
if mul > 10**18:
print((-1))
else:
print(mul) | n = int(eval(input()))
a = list(map(int,input().split()))
a.sort()
ans = 1
if a[0] == 0:
print((0))
else:
for i in range(len(a)):
ans *= a[i]
if ans > 10**18:
print("-1")
exit()
elif i == len(a)-1:
print(ans) | p02658 |
N = int(eval(input()))
A = list(map(int, input().split()))
result = 1
for i in A:
result *= i
if result > 10**18:
print((-1))
else:
print(result) | def main():
N = int(eval(input()))
A = list(map(int, input().split()))
if 0 in A:
print((0))
return
num = 1
max_num = 10**18
for i in A:
num *= i
if num > max_num:
print((-1))
return
print(num)
main() | p02658 |
eval(input());ans,limit=1,10**18
for i in map(int,input().split()):
ans*=i
print(([ans,-1][ans>limit])) | eval(input());ans,a=1,[*list(map(int,input().split()))]
if 0 in a:
print((0))
else:
for i in a:
ans*=i
if ans>10**18:
print((-1));break
else:
print(ans) | p02658 |
def main():
N = int(eval(input()))
A_list = [A for A in input().split()]
A_list = list(map(int, A_list))
#print(A_list)
A_list.sort()
#print(A_list)
ans = 1
for a in A_list :
ans = ans * a
if ans == 0 :
break
if ans > 10 ** 18 :
ans = -1
print(ans)
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
A_list = [A for A in input().split()]
A_list = list(map(int, A_list))
#print(A_list)
A_list.sort()
#print(A_list)
ans = 1
for a in A_list :
ans = ans * a
if ans == 0 :
break
elif ans > 10 ** 18 :
ans = -1
break
print(ans)
if __name__ == '__main__':
main()
| p02658 |
N = eval(input())
A = list(map(int, input().split()))
answer = 1
for Ai in A:
answer *= Ai
if answer > 10 ** 18:
answer = -1
print(answer)
| N = eval(input())
A = list(map(int, input().split()))
haz_zero = 0 in A
if haz_zero:
print((0))
exit()
answer = 1
for Ai in A:
answer *= Ai
if answer > 10 ** 18:
answer = -1
break
print(answer)
| p02658 |
n = int(eval(input()));
a = list(map(int, input().split()));
ok = True;
ans = 1;
for val in a:
ans *= val;
if(ans > 1e18):
ok = False;
if(ok):
print(ans);
else:
print((-1));
| n = int(eval(input()));
a = list(map(int, input().split()));
ok = True;
ans = 1;
a.sort();
for val in a:
ans *= val;
if(ans > 1e18):
ok = False;
break;
elif(ans == 0):
break;
if(ok):
print(ans);
else:
print((-1));
| p02658 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 1
flag_0 = False
for a_i in a:
if a_i == 0:
flag_0 = True
break
ans *= a_i
if ans > 10**18:
ans = -1
if flag_0 == True:
print((0))
elif ans <0:
print((-1))
else:
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
ans = 1
flag_0 = False
if 0 in a:
print((0))
else:
for a_i in a:
ans *= a_i
if ans > 10**18:
ans = -1
break
print(ans) | p02658 |
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 1
for i in range(N):
ans = ans * A[i]
if ans > 10**18:
print((-1))
else:
print(ans)
| N = int(eval(input()))
A = list(map(int,input().split()))
ans = 1
if 0 in A:
print((0))
else:
for i in range(N):
ans = ans * A[i]
if ans > 10**18:
print((-1))
break
else:
print(ans)
| p02658 |
from sys import exit
ii = lambda : int(eval(input()))
mi = lambda : list(map(int,input().split()))
li = lambda : list(map(int,input().split()))
n= ii()
a= li()
ans=1
for i in range(n):
ans *= a[i]
if ans > 10**18:
ans = -1
print(ans) | from sys import exit
import math
ii = lambda : int(eval(input()))
mi = lambda : list(map(int,input().split()))
li = lambda : list(map(int,input().split()))
n= ii()
a= li()
ans=1
a.sort()
a.reverse()
if a[-1] == 0:
print((0))
exit()
for i in range(n):
ans *= a[i]
if ans > 10**18:
print((-1))
exit()
elif a[i] == 0:
print((0))
exit()
print(ans)
| p02658 |
import sys
from operator import mul
from functools import reduce
t = 10**18
n=int(eval(input()))
li = list(map(int,input().split()))
if li.count(0) >= 1:
print((0))
sys.exit()
ans = reduce(mul,li)
if ans > t:
print((-1))
else:
print(ans) | import sys
t = 10**18
n=int(eval(input()))
li = list(map(int,input().split()))
if li.count(0) >= 1:
print((0))
sys.exit()
ans = 1
for i in range(n):
ans = ans*li[i]
if ans > t:
print((-1))
sys.exit()
print(ans) | p02658 |
N=int(eval(input()))
A=[]
A=list(map(int,input().split()))
L=10**18
S=1
for i in range(N):
S=S*A[i]
if S<=L:
print(S)
else:
print("-1")
| N=int(eval(input()))
A=[]
A=list(map(int,input().split()))
A.sort(reverse=True)
L=10**18
S=1
if A[N-1]==0:
print("0")
else:
for i in range(N):
S=S*A[i]
if S>L:
print("-1")
break
if S<=L:
print(S)
| p02658 |
n=int(eval(input()))
a=list(map(int,input().split()))
ans=1
for i in range(n):
ans*=a[i]
if ans<=10**18:
print(ans)
else:
print((-1)) | n=int(eval(input()))
a=list(map(int,input().split()))
a.sort()
ans=1
for i in range(n):
ans*=a[i]
if ans==0 or ans>10**18:
break
if ans<=10**18:
print(ans)
else:
print((-1)) | p02658 |
N = int(eval(input()))
Nums = input().split()
A = 1
break_flag = 0
for i in range(N):
A*=int(Nums[i])
if A > 10**18:
A = -1
break_flag = 1
if A == 0:
break_flag = 2
if break_flag == 1:
print((-1))
else:
print(A) | N = int(eval(input()))
Nums = input().split()
AA = set(Nums)
if '0' in AA:
print((0))
else:
A = 1
for i in range(N):
A*=int(Nums[i])
if A > 10**18:
A = -1
break
print(A) | p02658 |
eval(input())
r = 1
for x in input().split():
r = max(-1, r * int(x))
if r > 1e18:
r = -1
print(r)
| eval(input())
r = 1
for x in map(int, input().split()):
if x == 0:
r = 0
break
if r > 0:
r *= x
if r > 1e18:
r = -1
print(r) | p02658 |
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 1
if 0 in A:
ans = 0
N = 0
for i in range(N):
ans *= A[i]
if ans > 10**18:
ans = -1
break
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
ans = 1
if 0 in A:
print((0))
exit()
for i in range(N):
ans *= A[i]
if ans > 10**18:
print((-1))
exit()
print(ans)
| p02658 |
N = int(eval(input()))
li = [int(s) for s in input().split()]
import functools
import operator
result = functools.reduce(operator.mul, li)
if result > 10**18:
print((-1))
else:
print(result) | import sys
N = int(eval(input()))
Line = [int(s) for s in input().split()]
Line.sort()
ans = 1
for i in Line:
ans = ans*i
if ans > 10**18:
print("-1")
exit()
elif ans == 0:
print("0")
exit()
print(ans) | p02658 |
def multiplication():
# 入力
N = int(eval(input()))
A = list(map(int, input().split()))
# 計算処理
multi = 1
for i in range(N):
multi = multi * A[i]
# 10^18比較
if multi > 10 ** 18:
return -1
else:
return multi
result = multiplication()
print(result) | def multiplication():
# 入力
N = int(eval(input()))
A = list(map(int, input().split()))
# かける数に0があるか確認
if 0 in A:
return 0
# 計算処理
multi = 1
for i in range(N):
multi = multi * A[i]
# 10^18比較
if multi > 10 ** 18:
return -1
return multi
result = multiplication()
print(result) | p02658 |
import sys
# sys.setrecursionlimit(10**10)
N = int(sys.stdin.readline().rstrip())
# S = sys.stdin.readline().rstrip()
# N, K = map(int, sys.stdin.readline().rstrip().split())
A = list(map(int, sys.stdin.readline().rstrip().split()))
ans = 1
for a in A:
ans *= a
if ans > 10 **18:
print((-1))
else:
print(ans) | import sys
# sys.setrecursionlimit(10**10)
N = int(sys.stdin.readline().rstrip())
# S = sys.stdin.readline().rstrip()
# N, K = map(int, sys.stdin.readline().rstrip().split())
A = list(map(int, sys.stdin.readline().rstrip().split()))
if 0 in A:
print((0))
exit()
ans = 1
for a in A:
ans *= a
if ans > 10 **18:
print((-1))
exit()
else:
print(ans) | p02658 |
n = int(eval(input()))
l = list(map(int, input().split()))
ans = 1
for i in range(n):
ans *= l[i]
if ans <= 10**18:
print(ans)
else:
print((-1)) | n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
if l[0] == 0:
print((0))
exit()
ans = 1
for i in range(n):
ans *= l[i]
if ans > 10**18:
print((-1))
exit()
print(ans) | p02658 |
n = int(eval(input()))
a = list(map(int,input().split()))
sum = 1
for i in a:
if i == 0:
sum = 0
break
sum = sum * i
if sum > 10**18:
print((-1))
else:
print(sum)
| n = int(eval(input()))
a = list(map(int,input().split()))
sum = 1
if 0 in a:
sum = 0
else:
for i in a:
sum = sum * i
if sum > 10**18:
sum = -1
break
print(sum)
| p02658 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, *a = list(map(int, read().split()))
val=1
for x in a:
val*=x
print((val if val<=10**18 else '-1')) |
def main ():
N = int(eval(input()))
A = list(map(int,input().split()))
if 0 in A:
print((0))
return
prod = 1
for a in A:
prod *= a
if prod > 1000000000000000000:
print((-1))
return
print(prod)
return
main ()
| p02658 |
n = eval(input())
n = int(n)
a = input().split()
b = 1
for i in a:
b *= int(i)
if (b > 1000000000000000000):
print ("-1")
else:
print (b)
| n = eval(input())
n = int(n)
a = input().split()
b = 1
if '0' in a:
print ("0")
else:
for i in a:
b *= int(i)
if (b > 1000000000000000000):
print ("-1")
break
if (b <= 1000000000000000000):
print (b)
| p02658 |
_ = eval(input())
inp = list(map(int, input().split()))
of = False
re = 1
for a in inp:
re *= a
if (re - 1) // (10**18) > 0:
re = -1
print(re)
| _ = eval(input())
inp = list(map(int, input().split()))
re = 1
for a in inp:
re = re * a
if re > (10**18):
of = True
re = -1
break
for a in inp:
if a == 0:
re = 0
print(re)
| p02658 |
p=1
l=eval(input())
num=input().split()
for n in num:
p*=int(n)
mx=pow(10,18)
if(p>mx):
print("-1")
else:
print(p) | p=1
mx=1000000000000000000
n=int(eval(input()))
num=input().split()
z=num.count('0')
if(z!=0):
print('0')
else:
for i in num:
p*=int(i)
if(p>mx):
p=-1
break
print(p) | p02658 |
eval(input())
a=1
for i in input().split():
a*=int(i)
print(([a,-1][a>1000000000000000000])) | eval(input())
a=1
d=1000000000000000000
for i in input().split():
a=min(a*int(i), d+1)
print(([a,-1][a>d])) | p02658 |
eval(input())
a=1
d=1000000000000000000
for i in input().split():
a=min(a*int(i),d+1)
print(([a,-1][a>d])) | eval(input())
a=1
d=eval('1'+'0'*18)
for i in input().split():
a=min(a*int(i),d+1)
print(([a,-1][a>d])) | p02658 |
eval(input());a=1;d=eval('1'+'0'*18)
for i in input().split():a=min(a*int(i),d+1)
print(([a,-1][a>d])) | a=1;d=eval('1'+'0'*18)
for i in open(0).read().split()[1:]:a=min(a*int(i),d+1)
print(([a,-1][a>d])) | p02658 |
eval(input());a=1
for i in input().split():a*=int(i);a=[-1,a][0<=a<=eval('1'+'0'*18)]
print(a) | eval(input());a=1
for i in input().split():a*=int(i);a=[-1,a][0<=a<=10**18]
print(a) | p02658 |
eval(input());a=1
for i in input().split():a*=int(i);a=[-1,a][0<=a<=10**18]
print(a) | a=1
for i in[*open(0)][1].split():a*=int(i);a=[-1,a][0<=a<=10**18]
print(a) | p02658 |
a=1;d=10**18
for i in[*open(0)][1].split():a=min(a*int(i),d+1)
print(([a,-1][a>d])) | a=1
for i in[*open(0)][1].split():a*=int(i);a=[-1,a][-2<a-1<1e18]
print(a) | p02658 |
_,b=open(0);a=1
for i in b.split():a*=int(i);a=[-1,a][-1<a<=1e18]
print(a) | a=1
for i in[*open(0)][1].split():a=[-1,a:=a*int(i)][-1<a<=1e18]
print(a) | p02658 |
n=int(eval(input()))
a=list(map(int,input().split()))
ans=1
for i in a:
ans*=i
if a.count(0)==0 and ans>10**18:
print((-1))
exit()
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
ans=1
a=sorted(a)
for i in a:
ans*=i
if i==0:
print((0))
exit()
elif ans>10**18:
print((-1))
exit()
print(ans)
| p02658 |
n=int(eval(input()))
a=list(map(int,input().split()))
b=1
for i in range(n):
b=b*a[i]
if b>10**18:
print((-1))
else:
print(b) | n=int(eval(input()))
a=list(map(int,input().split()))
b=1
for i in range(n):
if a[i]==0:
b=0
for i in range(n):
b=b*a[i]
if b>10**18:
b=-1
break
print(b) | p02658 |
import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**20
ri = lambda : int(eval(input()))
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
n = ri()
a = rl()
ans=1
for i in a:
ans*=i
if ans>10**18:
print((-1))
else:
print(ans) | import sys
#import time
import copy
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**20
ri = lambda : int(eval(input()))
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
n = ri()
a = rl()
ans=1
flag=False
for i in a:
ans*=i
if ans>10**18:
flag=True
break
zero=False
for i in a:
if i==0:
zero=True
break
if zero:
print((0))
elif flag:
print((-1))
else:
print(ans) | p02658 |
n= int(eval(input()))
a=list(map(int,input().split()))
ans=1
for i in range(n):
ans=ans*a[i]
if ans<=(10**18):
print(ans)
else:
print((-1)) | n= int(eval(input()))
a=list(map(int,input().split()))
a.sort()
ans=1
for i in a:
ans=ans*i
if ans>(10**18):
print((-1))
break
elif ans==0:
print(ans)
break
if ans<=(10**18)and ans!=0:
print(ans) | p02658 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
for i in range(N):
ans *= A[i]
if ans > 1e18:
ans = -1
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
if 0 in A:
print((0))
exit()
ans = 1
for i in range(N):
ans *= A[i]
if ans > 1e18:
ans = -1
break
print(ans) | p02658 |
import functools
import operator
N = int(eval(input()))
A = list(map(int, input().split()))
answer = functools.reduce(operator.mul, A)
if answer > 1000000000000000000:
print('-1')
else:
print(answer) | N = int(eval(input()))
A = list(map(int, input().split()))
if A.count(0) >= 1:
print((0))
exit()
answer = 1
for _ in A:
answer *= _
if answer > 1000000000000000000:
print('-1')
exit()
print(answer)
| p02658 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.