problem_id
stringlengths 6
6
| buggy_code
stringlengths 8
526k
⌀ | fixed_code
stringlengths 12
526k
⌀ | labels
listlengths 0
15
⌀ | buggy_submission_id
int64 1
1.54M
⌀ | fixed_submission_id
int64 2
1.54M
⌀ | user_id
stringlengths 10
10
⌀ | language
stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p02768
|
n,a,b=list(map(int,input().split()))
#2^n-nCa-nCbを求めればいい。ただし100000007で割ったあまりでなくてはならない
#まずは2^nを求める
def pow(x,n,m):
if n==0:
return 1
res=pow(x*x%m,n//2,m)
if n%2==1:
res=res*x%m
return res
#コンビネーションを求める
c=max(a,b)
inv=[0 for i in range(c+1)]
finv=[0 for i in range(c+1)]
inv[1]=1
finv[0]=finv[1]=1
for i in range(2,c+1):
#iの逆数を求める。
#mod p=1000000007の世界で逆元を求める
#p=(p//a)*a+(p%a)
#mod pをとると a=-(p//a)*(p%a)^-1
inv[i]=1000000007-(1000000007//i)*inv[1000000007%i]%1000000007
finv[i]=finv[i-1]*inv[i]%1000000007
def kaizyou(k):
num=1
for i in range(n-k+1,n+1):
num=num*i%1000000007
return num
def combinations(k):
return kaizyou(k)*finv[k]%1000000007
print(pow(2,n,1000000007)-combinations(a)-combinations(b)-1)
|
n,a,b=list(map(int,input().split()))
#2^n-nCa-nCbを求めればいい。ただし100000007で割ったあまりでなくてはならない
#まずは2^nを求める
def pow(x,n,m):
if n==0:
return 1
res=pow(x*x%m,n//2,m)
if n%2==1:
res=res*x%m
return res
#コンビネーションを求める
c=max(a,b)
inv=[0 for i in range(c+1)]
finv=[0 for i in range(c+1)]
inv[1]=1
finv[0]=finv[1]=1
for i in range(2,c+1):
#iの逆数を求める。
#mod p=1000000007の世界で逆元を求める
#p=(p//a)*a+(p%a)
#mod pをとると a=-(p//a)*(p%a)^-1
inv[i]=1000000007-(1000000007//i)*inv[1000000007%i]%1000000007
finv[i]=finv[i-1]*inv[i]%1000000007
def kaizyou(k):
num=1
for i in range(n-k+1,n+1):
num=num*i%1000000007
return num
def combinations(k):
return kaizyou(k)*finv[k]%1000000007
print((pow(2,n,1000000007)-combinations(a)-combinations(b)-1)%1000000007)
|
[
"call.arguments.change",
"call.arguments.add"
] | 563,865
| 563,867
|
u437351386
|
python
|
p02768
|
def combination(n, r, m):
res = 1
r = min(r, n - r)
for i in range(r):
res = res * (n - i) % m
res = res * pow(i + 1, m - 2, m) % m
return res
mod = 10**9 + 7
n, a, b = map(int, input().split())
total = pow(2, n, mod) - 1
total -= (combination(n, a, mod) + combination(n, b, mod)) % mod
print(total)
|
def combination(n, r, m):
res = 1
r = min(r, n - r)
for i in range(r):
res = res * (n - i) % m
res = res * pow(i + 1, m - 2, m) % m
return res
mod = 10**9 + 7
n, a, b = map(int, input().split())
total = pow(2, n, mod) - 1
total -= (combination(n, a, mod) + combination(n, b, mod)) % mod
print(total % mod)
|
[
"expression.operation.binary.add"
] | 563,906
| 563,907
|
u158995862
|
python
|
p02768
|
class Factorial():
def __init__(self, mod=10**9 + 7):
self.mod = mod
self._factorial = [1]
self._size = 1
self._factorial_inv = [1]
self._size_inv = 1
def __call__(self, n):
return self.fact(n)
def fact(self, n):
''' n! % mod '''
if n >= self.mod:
return 0
self._make(n)
return self._factorial[n]
def _make(self, n):
if n >= self.mod:
n = self.mod
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
def fact_inv(self, n):
''' n!^-1 % mod '''
if n >= self.mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
self._make(n)
if self._size_inv < n+1:
self._factorial_inv += [-1] * (n+1-self._size_inv)
self._size_inv = n+1
if self._factorial_inv[n] == -1:
self._factorial_inv[n] = self.modinv(self._factorial[n])
return self._factorial_inv[n]
@staticmethod
def xgcd(a, b):
'''
Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
'''
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(self, n):
g, x, _ = self.xgcd(n, self.mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % self.mod
def comb(self, n, r):
''' nCr % mod '''
if r > n:
return 0
t = self(n)*self.fact_inv(n-r) % self.mod
return t*self.fact_inv(r) % self.mod
def comb_(self, n, r):
'''
nCr % mod
when r is not large and n is too large
'''
c = 1
for i in range(1, r+1):
c *= (n-i+1) * self.fact_inv(i)
c %= self.mod
return c
def comb_with_repetition(self, n, r):
''' nHr % mod '''
t = self(n+r-1)*self.fact_inv(n-1) % self.mod
return t*self.fact_inv(r) % self.mod
def perm(self, n, r):
''' nPr % mod '''
if r > n:
return 0
return self(n)*self.fact_inv(n-r) % self.mod
mod = 10**9 + 7
n, a, b = map(int, input().split())
comb = Factorial().comb_
print((pow(2, n, mod) - comb(n, a) - comb(n, b) - 1) % mod)
|
class Factorial():
def __init__(self, mod=10**9 + 7):
self.mod = mod
self._factorial = [1]
self._size = 1
self._factorial_inv = [1]
self._size_inv = 1
def __call__(self, n):
return self.fact(n)
def fact(self, n):
''' n! % mod '''
if n >= self.mod:
return 0
self._make(n)
return self._factorial[n]
def _make(self, n):
if n >= self.mod:
n = self.mod
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
def fact_inv(self, n):
''' n!^-1 % mod '''
if n >= self.mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
self._make(n)
if self._size_inv < n+1:
self._factorial_inv += [-1] * (n+1-self._size_inv)
self._size_inv = n+1
if self._factorial_inv[n] == -1:
self._factorial_inv[n] = self.modinv(self._factorial[n])
return self._factorial_inv[n]
@staticmethod
def xgcd(a, b):
'''
Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
'''
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(self, n):
g, x, _ = self.xgcd(n, self.mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % self.mod
def comb(self, n, r):
''' nCr % mod '''
if r > n:
return 0
t = self(n)*self.fact_inv(n-r) % self.mod
return t*self.fact_inv(r) % self.mod
def comb_(self, n, r):
'''
nCr % mod
when r is not large and n is too large
'''
c = 1
for i in range(1, r+1):
c *= (n-i+1) * self.modinv(i)
c %= self.mod
return c
def comb_with_repetition(self, n, r):
''' nHr % mod '''
t = self(n+r-1)*self.fact_inv(n-1) % self.mod
return t*self.fact_inv(r) % self.mod
def perm(self, n, r):
''' nPr % mod '''
if r > n:
return 0
return self(n)*self.fact_inv(n-r) % self.mod
mod = 10**9 + 7
n, a, b = map(int, input().split())
comb = Factorial().comb_
print((pow(2, n, mod) - comb(n, a) - comb(n, b) - 1) % mod)
|
[
"identifier.change",
"expression.operation.binary.change"
] | 563,910
| 563,912
|
u417365712
|
python
|
p02768
|
def cmb(n, r, mod):
c=1
for i in range(1, r+1):
c = (c * (n-i+1) * pow(i, mod-2, mod)) % mod
return c
n, a, b = map(int, inputs[0]().split())
MOD = 10**9 + 7
print((pow(2, n, MOD) - cmb(n, a, MOD) - cmb(n, b, MOD) - 1) % MOD)
|
def cmb(n, r, mod):
c=1
for i in range(1, r+1):
c = (c * (n-i+1) * pow(i, mod-2, mod)) % mod
return c
n, a, b = map(int, input().split())
MOD = 10**9 + 7
print((pow(2, n, MOD) - cmb(n, a, MOD) - cmb(n, b, MOD) - 1) % MOD)
|
[
"assignment.value.change",
"call.arguments.change",
"io.output.change"
] | 563,913
| 563,914
|
u417365712
|
python
|
p02768
|
def cmb(n, r, p):
r = min(r, n - r)
upper = 1
for i in range(n, n - r, -1):
upper = (upper * i) % p
lower = 1
for i in range(1, r + 1):
lower = (lower * i) % p
# フェルマーの小定理よりp素数ならupper**(p-2)は逆元
return (upper * pow(lower, p - 2, p)) % p
mod = pow(10, 9) + 7
n, a, b = map(int, input().split())
ans = pow(2, n, mod) - 1 - cmb(n, a, mod) - cmb(n, b, mod)
print(ans)
|
def cmb(n, r, p):
r = min(r, n - r)
upper = 1
for i in range(n, n - r, -1):
upper = (upper * i) % p
lower = 1
for i in range(1, r + 1):
lower = (lower * i) % p
# フェルマーの小定理よりp素数ならupper**(p-2)は逆元
return (upper * pow(lower, p - 2, p)) % p
mod = pow(10, 9) + 7
n, a, b = map(int, input().split())
ans = (pow(2, n, mod) - 1 - cmb(n, a, mod) - cmb(n, b, mod))%mod
print(ans)
|
[
"assignment.change"
] | 563,917
| 563,918
|
u011062360
|
python
|
p02768
|
n,a,b = map(int, input().split())
MOD = 10**9 + 7
allpair = pow(2,n,MOD)
def combo(n,k):
c = 1
for i in range(k):
c *= n - i
c %= MOD
d = 1
for i in range(1, k+1):
d *= i
d %= MOD
return (c * pow(d, mod-2, MOD)) % MOD
print((allpair - combo(n, a) - combo(n, b) - 1) % MOD)
|
n,a,b = map(int, input().split())
MOD = 10**9 + 7
allpair = pow(2,n,MOD)
def combo(n,k):
c = 1
for i in range(k):
c *= n - i
c %= MOD
d = 1
for i in range(1, k+1):
d *= i
d %= MOD
return (c * pow(d, MOD-2, MOD)) % MOD
print((allpair - combo(n, a) - combo(n, b) - 1) % MOD)
|
[
"identifier.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 563,950
| 563,952
|
u922487073
|
python
|
p02768
|
N,a,b=map(int,input().split())
MOD=10**9+7
def comb(n,k):
tmp=1
for i in range(n-k+1,n+1):
tmp*=i
tmp%=MOD
for i in range(1,k+1):
tmp*=pow(i,MOD-2,MOD)
tmp%=MOD
return tmp
ans = pow(2,N,MOD) - 1 - comb(N,a) - comb(N,b)
print(ans)
|
N,a,b=map(int,input().split())
MOD=10**9+7
def comb(n,k):
tmp=1
for i in range(n-k+1,n+1):
tmp*=i
tmp%=MOD
for i in range(1,k+1):
tmp*=pow(i,MOD-2,MOD)
tmp%=MOD
return tmp
ans = pow(2,N,MOD) - 1 - comb(N,a) - comb(N,b)
print(ans%MOD)
|
[
"expression.operation.binary.add"
] | 563,965
| 563,967
|
u506858457
|
python
|
p02768
|
n,a,b=map(int,input().split())
mod=10**9+7
def comb(n,k,mod):
if k>n-k:
k=n-k
c=1
for i in range(n-k+1,n+1):
c*=i
c%=mod
d=1
for i in range(1,k+1):
d*=i
d%=mod
return (c*pow(d,mod-2,mod))%mod
ans=pow(2,n,mod)-comb(n,a,mod)-comb(n,b,mod)
print(ans%mod)
|
n,a,b=map(int,input().split())
mod=10**9+7
def comb(n,k,mod):
if k>n-k:
k=n-k
c=1
for i in range(n-k+1,n+1):
c*=i
c%=mod
d=1
for i in range(1,k+1):
d*=i
d%=mod
return (c*pow(d,mod-2,mod))%mod
ans=pow(2,n,mod)-1-comb(n,a,mod)-comb(n,b,mod)
print(ans%mod)
|
[
"assignment.change"
] | 563,982
| 563,985
|
u333700164
|
python
|
p02768
|
n,a,b = map(int,input().split())
mod = 10**9+7
def comb(N,x):
numerator = 1
for i in range(N-x+1,N+1):
numerator = numerator *i%mod
denominator = 1
for j in range(1,x+1):
denominator = denominator *i%mod
d = pow(denominator,mod-2,mod)
return (numerator*d)%mod
al = pow(2,n,mod)-1
ac =comb(n,a)
bc =comb(n,b)
print((al-ac-bc)%mod)
|
n,a,b = map(int,input().split())
mod = 10**9+7
def comb(N,x):
numerator = 1
for i in range(N-x+1,N+1):
numerator = numerator *i%mod
denominator = 1
for j in range(1,x+1):
denominator = denominator *j%mod
d = pow(denominator,mod-2,mod)
return (numerator*d)%mod
al = pow(2,n,mod)-1
ac =comb(n,a)
bc =comb(n,b)
print((al-ac-bc)%mod)
|
[
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 564,090
| 564,091
|
u288430479
|
python
|
p02768
|
# return x^{-1} % mod
# it take O(log{mod})
def mod_inverse(x, mod):
return pow(x, mod-2, mod)
# return nCk % mod
# it take O(k)
def mod_comb(n, k, mod):
numer, denom = 1, 1
for i in range(k):
# numer: 分子, denom: 分母
numer = numer * ((n-i) % mod) % mod
denom = denom * ((i+1) % mod) % mod
return numer * mod_inverse(denom) % mod
n, a, b = map(int, input().split())
ans = pow(2, n, mod) - 1
ans = (ans - mod_comb(n, a, mod)) % mod
ans = (ans - mod_comb(n, b, mod)) % mod
print( (ans + mod) % mod )
|
# return x^{-1} % mod
# it takes O(log{mod})
def mod_inverse(x, mod):
return pow(x, mod-2, mod)
# return nCk % mod
# it takes O(k)
def mod_comb(n, k, mod):
numer, denom = 1, 1
for i in range(k):
# numer: 分子, denom: 分母
numer = numer * ((n-i) % mod) % mod
denom = denom * ((i+1) % mod) % mod
return numer * mod_inverse(denom, mod) % mod
n, a, b = map(int, input().split())
mod = 1000000007
ans = pow(2, n, mod) - 1
ans = (ans - mod_comb(n, a, mod)) % mod
ans = (ans - mod_comb(n, b, mod)) % mod
print( (ans + mod) % mod )
|
[
"call.arguments.add"
] | 564,102
| 564,103
|
u813098295
|
python
|
p02768
|
# return x^{-1} % mod
# it take O(log{mod})
def mod_inverse(x, mod):
return pow(x, mod-2, mod)
# return nCk % mod
# it take O(k)
def mod_comb(n, k, mod):
numer, denom = 1, 1
for i in range(k):
# numer: 分子, denom: 分母
numer = numer * ((n-i) % mod) % mod
denom = denom * ((i+1) % mod) % mod
return numer * mod_inverse(denom) % mod
n, a, b = map(int, input().split())
ans = pow(2, n, mod) - 1
ans = (ans - mod_comb(n, a, mod)) % mod
ans = (ans - mod_comb(n, b, mod)) % mod
print( (ans + mod) % mod )
|
# return x^{-1} % mod
# it take O(log{mod})
def mod_inverse(x, mod):
return pow(x, mod-2, mod)
# return nCk % mod
# it take O(k)
def mod_comb(n, k, mod):
numer, denom = 1, 1
for i in range(k):
# numer: 分子, denom: 分母
numer = numer * ((n-i) % mod) % mod
denom = denom * ((i+1) % mod) % mod
return numer * mod_inverse(denom, mod) % mod
n, a, b = map(int, input().split())
mod = 1000000007
ans = pow(2, n, mod) - 1
ans = (ans - mod_comb(n, a, mod)) % mod
ans = (ans - mod_comb(n, b, mod)) % mod
print( (ans + mod) % mod )
|
[
"call.arguments.add"
] | 564,102
| 564,104
|
u813098295
|
python
|
p02768
|
m=10**9+7
n,a,b=map(int,input().split())
def comb(n,r,m):
x,y=1,1
for i in range(r):
x*=n-1
y*=n+1
x%=m
y%=m
return int(x * pow(y, m-2, m))
ans = pow(2, n, m)-comb(n, a, m) - comb(n, b, m)
print(ans%m)
|
m=10**9+7
n,a,b=map(int,input().split())
def comb(n,r,m):
x,y=1,1
for i in range(r):
x*=n-i
y*=i+1
x%=m
y%=m
return int(x * pow(y, m-2, m))
ans = pow(2, n, m)-1-comb(n, a, m) - comb(n, b, m)
print(ans%m)
|
[
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change",
"identifier.change"
] | 564,111
| 564,112
|
u880480312
|
python
|
p02768
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def combinations_mod(n, r, mod=1000000007):
"""Returns nCr in mod."""
r = min(r, n - r)
combs = 1
for i, j in zip(range(n - r + 1, n + 1), range(1, r + 1)):
combs *= (i % mod) * pow(j, mod - 2, mod)
combs %= mod
return combs
def main():
n, a, b = NMI()
all = pow_mod(2, n, MOD) - 1
ans = all - combinations_mod(n, a) - combinations_mod(n, b)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def combinations_mod(n, r, mod=1000000007):
"""Returns nCr in mod."""
r = min(r, n - r)
combs = 1
for i, j in zip(range(n - r + 1, n + 1), range(1, r + 1)):
combs *= (i % mod) * pow(j, mod - 2, mod)
combs %= mod
return combs
def main():
n, a, b = NMI()
all = pow(2, n, MOD) - 1
ans = all - combinations_mod(n, a) - combinations_mod(n, b)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
|
[
"assignment.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 564,125
| 564,126
|
u607075479
|
python
|
p02768
|
def modpow(a, n, p):
if n == 0:
return 1
elif n == 1:
return a % p
if n % 2 == 1:
return (a * modpow(a, n-1, p)) % p
tmp = modpow(a, n//2, p)
return (tmp * tmp) % p
def modfactrial(a, p):
ret = 1
for i in (a, 1, -1):
ret = ret * i % p
return ret
def main():
mod = 10 ** 9 + 7
n, a, b = map(int, input().split())
# まずは繰り返し2乗法によって全部の組み合わせを求める
# すべての組み合わせは、花を選ぶ/選ばないで組み合わせを決めれる
ans = (modpow(2, n, mod) - 1) % mod
# a本選んだときの数を引く
c_a = 1
for i in range(n, n-a, -1):
c_a *= i
c_a %= mod
c_a *= modpow(modfactrial(a, mod), mod-2, mod)
ans -= c_a
ans %= mod
# b本選んだときの数を引く
c_b = 1
for i in range(n, n-b, -1):
c_b *= i
c_b %= mod
c_b *= modpow(modfactrial(b, mod), mod-2, mod)
ans -= c_b
ans %= mod
print(ans)
if __name__ == "__main__":
main()
|
def modpow(a, n, p):
if n == 0:
return 1
elif n == 1:
return a % p
if n % 2 == 1:
return (a * modpow(a, n-1, p)) % p
tmp = modpow(a, n//2, p)
return (tmp * tmp) % p
def modfactrial(a, p):
ret = 1
for i in range(a, 1, -1):
ret = ret * i % p
return ret
def main():
mod = 10 ** 9 + 7
n, a, b = map(int, input().split())
# まずは繰り返し2乗法によって全部の組み合わせを求める
# すべての組み合わせは、花を選ぶ/選ばないで組み合わせを決めれる
ans = (modpow(2, n, mod) - 1) % mod
# a本選んだときの数を引く
c_a = 1
for i in range(n, n-a, -1):
c_a *= i
c_a %= mod
c_a *= modpow(modfactrial(a, mod), mod-2, mod)
ans -= c_a
ans %= mod
# b本選んだときの数を引く
c_b = 1
for i in range(n, n-b, -1):
c_b *= i
c_b %= mod
c_b *= modpow(modfactrial(b, mod), mod-2, mod)
ans -= c_b
ans %= mod
print(ans)
if __name__ == "__main__":
main()
|
[
"call.add",
"control_flow.loop.range.bounds.step.change"
] | 564,127
| 564,128
|
u426649993
|
python
|
p02768
|
n,a,b = map(int,input().split())
m = 10**9+7
def nCr(n_, r_, m_):
c = min(r_ , n_ - r_)
bunshi = 1
bunbo = 1
for i in range(1,c+1):
bunshi = bunchi * (n_+1-i) % m_
bunbo = bunbo * i % m_
return bunshi * pow(bunbo, m_-2, m_) % m_
ans = pow(2,n,m)-1
ans -= nCr(n,a,m)
ans %= m
ans -= nCr(n,b,m)
ans %= m
print(ans)
|
n,a,b = map(int,input().split())
m = 10**9+7
def nCr(n_, r_, m_):
c = min(r_ , n_ - r_)
bunshi = 1
bunbo = 1
for i in range(1,c+1):
bunshi = bunshi * (n_+1-i) % m_
bunbo = bunbo * i % m_
return bunshi * pow(bunbo, m_-2, m_) % m_
ans = pow(2,n,m)-1
ans -= nCr(n,a,m)
ans %= m
ans -= nCr(n,b,m)
ans %= m
print(ans)
|
[
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 564,138
| 564,139
|
u227085629
|
python
|
p02768
|
from scipy.special import comb
n, a, b = map(int, input().split())
MOD = 10**9+7
all_c = pow(2, n, MOD)-1
a_c = 1
b_c = 1
for i in range(n-a+1, n+1):
a_c *= i
a_c %= MOD
for i in range(1, a+1):
a_c *= pow(i, MOD-2, MOD)
a_c %= MOD
for i in range(n-b+1, n+1):
b_c *= i
b_c %= MOD
for i in range(1, b+1):
b_c *= pow(i, MOD-2, MOD)
b_c %= MOD
ans = (all_c - a_c - b_c) % MOD
print(ans)
|
n, a, b = map(int, input().split())
MOD = 10**9+7
all_c = pow(2, n, MOD)-1
a_c = 1
b_c = 1
for i in range(n-a+1, n+1):
a_c *= i
a_c %= MOD
for i in range(1, a+1):
a_c *= pow(i, MOD-2, MOD)
a_c %= MOD
for i in range(n-b+1, n+1):
b_c *= i
b_c %= MOD
for i in range(1, b+1):
b_c *= pow(i, MOD-2, MOD)
b_c %= MOD
ans = (all_c - a_c - b_c) % MOD
print(ans)
|
[] | 564,186
| 564,187
|
u538632589
|
python
|
p02768
|
n,a,b = map(int,input().split())
lim = 10**9+7
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * pow(a, mod-2, mod) % mod
return res
print((pow(2,n,lim)-combination(n,a)-combination(n,b)-1) % lim)
|
n,a,b = map(int,input().split())
lim = 10**9+7
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * pow(i+1, mod-2, mod) % mod
return res
print((pow(2,n,lim)-combination(n,a)-combination(n,b)-1) % lim)
|
[
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 564,188
| 564,189
|
u349091349
|
python
|
p02768
|
n,a,b = map(int,input().split())
lim = 10**9+7
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
print((pow(2,n,p)-combination(n,a)-combination(n,b)-1) % lim)
|
n,a,b = map(int,input().split())
lim = 10**9+7
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
print((pow(2,n,lim)-combination(n,a)-combination(n,b)-1) % lim)
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 564,190
| 564,191
|
u349091349
|
python
|
p02768
|
mod = 10 ** 9 + 7
def f(n, r):
X = 1
Y = 1
for i in range(r):
X *= n - i # nCr の分子
X %= mod
Y *= i + 1 # nCr の分母
Y %= mod
# フェルマーの小定理より (X/Y)%mod = X*Y^(mod - 2) % mod
return X * pow(Y, mod - 2, mod) % mod
N, A, B = map(int, input().split())
res = pow(2, N, mod) - 1
for i in [A, B]:
res -= f(N, i)
print(res)
|
mod = 10 ** 9 + 7
def f(n, r):
X = 1
Y = 1
for i in range(r):
X *= n - i # nCr の分子
X %= mod
Y *= i + 1 # nCr の分母
Y %= mod
# フェルマーの小定理より (X/Y)%mod = X*Y^(mod - 2) % mod
return X * pow(Y, mod - 2, mod) % mod
N, A, B = map(int, input().split())
res = pow(2, N, mod) - 1
for i in [A, B]:
res -= f(N, i)
print(res % mod)
|
[
"expression.operation.binary.add"
] | 564,207
| 564,208
|
u339199690
|
python
|
p02768
|
# coding: utf-8
MOD = 10**9+7
# 二分累積法による a^n mod の計算
def modpow(a, n):
res = 1
while n > 0:
if n & 1:
res = res * a % MOD
a = a * a % MOD
n >>= 1
return res
# nCr mod.p (n <= 10**6)
MAX = 1000010
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):
res = 1
for i in range(k):
res = res * (n-i) % MOD
return res * finv[k] % MOD
COMinit()
n, a, b = map(int, input().split())
tot = modpow(2, 10**9) - 1
ans = (tot - COM(n,a) - COM(n,b)) % MOD
print(ans)
|
# coding: utf-8
MOD = 10**9+7
# 二分累積法による a^n mod の計算
def modpow(a, n):
res = 1
while n > 0:
if n & 1:
res = res * a % MOD
a = a * a % MOD
n >>= 1
return res
# nCr mod.p (n <= 10**6)
MAX = 1000010
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):
res = 1
for i in range(k):
res = res * (n-i) % MOD
return res * finv[k] % MOD
COMinit()
n, a, b = map(int, input().split())
tot = modpow(2,n) - 1
ans = (tot - COM(n,a) - COM(n,b)) % MOD
print(ans)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 564,214
| 564,215
|
u707808519
|
python
|
p02768
|
n,a,b = map(int,input().split())
def comb(n,r,mod=10**9+7):
a=1
b=1
r = min(r,n-r)
for i in range(r):
a = a*(n-i)%mod
b = b*(i+1)%mod
return a*pow(b,mod-2,mod)%mod
ans = pow(2,n,10**9+7)-1 - comb(n,a) - comb(n,b)
if ans < 0: ans += 10**9+7
print(ans)
|
n,a,b = map(int,input().split())
def comb(n,r,mod=10**9+7):
a=1
b=1
r = min(r,n-r)
for i in range(r):
a = a*(n-i)%mod
b = b*(i+1)%mod
return a*pow(b,mod-2,mod)%mod
ans = pow(2,n,10**9+7)-1 - comb(n,a) - comb(n,b)
ans %= 10**9+7
print(ans)
|
[
"expression.operator.change"
] | 564,254
| 564,255
|
u882209234
|
python
|
p02768
|
n, a, b = map(int, input().split())
from operator import mul
from functools import reduce
import math
flg = (a == n-b)
rep = math.ceil(n/2)
MOD = 10**9+7
memo = 0
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
if p == 0:
return 1
if p % 2 == 0:
half = modpow(a, p//2, mod)
return half*half % mod
else:
return a * modpow(a, p-1, mod) % mod
from operator import mul
from functools import reduce
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mod_mul, range(n, n - r, -1), 1)
denom = reduce(mod_mul, range(1, r + 1), 1)
return numer*pow(denom, MOD-2, MOD)%MOD
def mod_mul(a, b):
return mul(a%MOD, b%MOD)%MOD
s = 0
ans = modpow(2, n, MOD)-1
if flg:
ans = ans - combinations_count(n, a)
else:
ans = (ans - combinations_count(n,a))%MOD - combinations_count(n,b)
print(ans%MOD)
|
n, a, b = map(int, input().split())
from operator import mul
from functools import reduce
import math
flg = (a == n-b)
rep = math.ceil(n/2)
MOD = 10**9+7
memo = 0
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
if p == 0:
return 1
if p % 2 == 0:
half = modpow(a, p//2, mod)
return half*half % mod
else:
return a * modpow(a, p-1, mod) % mod
from operator import mul
from functools import reduce
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mod_mul, range(n, n - r, -1), 1)
denom = reduce(mod_mul, range(1, r + 1), 1)
return numer*pow(denom, MOD-2, MOD)%MOD
def mod_mul(a, b):
return mul(a%MOD, b%MOD)%MOD
s = 0
ans = modpow(2, n, MOD)-1
if flg:
ans = ans - 2*combinations_count(n, a)%MOD
else:
ans = (ans - combinations_count(n,a))%MOD - combinations_count(n,b)
print(ans%MOD)
|
[
"assignment.change"
] | 564,258
| 564,259
|
u959340534
|
python
|
p02768
|
n, a, b = map(int, input().split())
from operator import mul
from functools import reduce
import math
flg = (a == n-b)
rep = math.ceil(n/2)
MOD = 10**9+7
memo = 0
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
if p == 0:
return 1
if p % 2 == 0:
half = modpow(a, p//2, mod)
return half*half % mod
else:
return a * modpow(a, p-1, mod) % mod
from operator import mul
from functools import reduce
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mod_mul, range(n, n - r, -1), 1)
denom = reduce(mod_mul, range(1, r + 1), 1)
return numer*pow(denom, MOD-2, MOD)%MOD
def mod_mul(a, b):
return mul(a%MOD, b%MOD)%MOD
s = 0
ans = modpow(2, n, MOD)+1
if flg:
ans = ans - combinations_count(n, a)
else:
ans = (ans - combinations_count(n,a))%MOD - combinations_count(n,b)
print(ans%MOD)
|
n, a, b = map(int, input().split())
from operator import mul
from functools import reduce
import math
flg = (a == n-b)
rep = math.ceil(n/2)
MOD = 10**9+7
memo = 0
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
if p == 0:
return 1
if p % 2 == 0:
half = modpow(a, p//2, mod)
return half*half % mod
else:
return a * modpow(a, p-1, mod) % mod
from operator import mul
from functools import reduce
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mod_mul, range(n, n - r, -1), 1)
denom = reduce(mod_mul, range(1, r + 1), 1)
return numer*pow(denom, MOD-2, MOD)%MOD
def mod_mul(a, b):
return mul(a%MOD, b%MOD)%MOD
s = 0
ans = modpow(2, n, MOD)-1
if flg:
ans = ans - 2*combinations_count(n, a)%MOD
else:
ans = (ans - combinations_count(n,a))%MOD - combinations_count(n,b)
print(ans%MOD)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 564,260
| 564,259
|
u959340534
|
python
|
p02768
|
n, a, b = map(int, input().split())
from operator import mul
from functools import reduce
import math
flg = (a == n-b)
rep = math.ceil(n/2)
MOD = 10**9+7
memo = 0
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
if p == 0:
return 1
if p % 2 == 0:
half = modpow(a, p//2, mod)
return half*half % mod
else:
return a * modpow(a, p-1, mod) % mod
from operator import mul
from functools import reduce
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mod_mul, range(n, n - r, -1), 1)
denom = reduce(mod_mul, range(1, r + 1), 1)
return numer*pow(denom, MOD-2, MOD)%MOD
def mod_mul(a, b):
return mul(a%MOD, b%MOD)%MOD
s = 0
ans = modpow(2, n, MOD)
if flg:
ans = ans - combinations_count(n, a)
else:
ans = (ans - combinations_count(n,a))%MOD - combinations_count(n,b)
print(ans%MOD)
|
n, a, b = map(int, input().split())
from operator import mul
from functools import reduce
import math
flg = (a == n-b)
rep = math.ceil(n/2)
MOD = 10**9+7
memo = 0
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
if p == 0:
return 1
if p % 2 == 0:
half = modpow(a, p//2, mod)
return half*half % mod
else:
return a * modpow(a, p-1, mod) % mod
from operator import mul
from functools import reduce
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mod_mul, range(n, n - r, -1), 1)
denom = reduce(mod_mul, range(1, r + 1), 1)
return numer*pow(denom, MOD-2, MOD)%MOD
def mod_mul(a, b):
return mul(a%MOD, b%MOD)%MOD
s = 0
ans = modpow(2, n, MOD)-1
if flg:
ans = ans - 2*combinations_count(n, a)%MOD
else:
ans = (ans - combinations_count(n,a))%MOD - combinations_count(n,b)
print(ans%MOD)
|
[
"assignment.change"
] | 564,261
| 564,259
|
u959340534
|
python
|
p02768
|
import math
def modpow(a, n , mod):
res = 1
while n > 0:
if n & 1:
res = res * a % mod
a = a*a % mod
n >>= 1
return res
def calcp(n,j,mod):
res = 1
for i in range(n,n-j,-1):
res = res * i %mod
return res
def main():
n,a,b = list(map(int, input().split()))
MOD = 10**9+7
NMAX = 2*10**5
fact = [0 for i in range(NMAX+5)]
fact[0] = 1
invfact = [0 for i in range(NMAX+5)]
invfact[0] = 1
for i in range(NMAX):
fact[i+1] = (fact[i]*(i+1))%(MOD)
invfact[NMAX] = pow(fact[NMAX], MOD-2, MOD)
for i in range(NMAX-1,0,-1):
invfact[i] = (invfact[i+1] * (i+1)) % MOD
ans = modpow(2,n,MOD)-1
pa = calcp(n,a,MOD)*invfact[a]%MOD
pb = calcp(n,b,MOD)*invfact[b]%MOD
ans = ans - pa - pb;
if ans < 0:
ans += MOD
print(ans)
main()
|
import math
def modpow(a, n , mod):
res = 1
while n > 0:
if n & 1:
res = res * a % mod
a = a*a % mod
n >>= 1
return res
def calcp(n,j,mod):
res = 1
for i in range(n,n-j,-1):
res = res * i %mod
return res
def main():
n,a,b = list(map(int, input().split()))
MOD = 10**9+7
NMAX = 2*10**5
fact = [0 for i in range(NMAX+5)]
fact[0] = 1
invfact = [0 for i in range(NMAX+5)]
invfact[0] = 1
for i in range(NMAX):
fact[i+1] = (fact[i]*(i+1))%(MOD)
invfact[NMAX] = pow(fact[NMAX], MOD-2, MOD)
for i in range(NMAX-1,0,-1):
invfact[i] = (invfact[i+1] * (i+1)) % MOD
ans = modpow(2,n,MOD)-1
pa = calcp(n,a,MOD)*invfact[a]%MOD
pb = calcp(n,b,MOD)*invfact[b]%MOD
ans = ans - pa - pb;
while ans < 0:
ans += MOD
print(ans)
main()
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,284
| 564,285
|
u582847048
|
python
|
p02768
|
n,a,b = map(int,input().split())
mod = 10**9 + 7
aue,bue = 1,1
for i in range(a):
aue = aue * (n-i) % mod
for i in range(b):
bue = bue * (n-i) % mod
asita,bsita = 1,1
for i in range(1,a+1):
asita = asita*i %mod
for i in range(1,b+1):
bsita = bsita*i %mod
at = aue * pow(asita,mod-2,mod)
bt = bue * pow(bsita,mod-2,mod)
print(at)
ans = (pow(2,n,mod) - 1 -at -bt)%mod
print(ans)
|
n,a,b = map(int,input().split())
mod = 10**9 + 7
aue,bue = 1,1
for i in range(a):
aue = aue * (n-i) % mod
for i in range(b):
bue = bue * (n-i) % mod
asita,bsita = 1,1
for i in range(1,a+1):
asita = asita*i %mod
for i in range(1,b+1):
bsita = bsita*i %mod
at = aue * pow(asita,mod-2,mod)
bt = bue * pow(bsita,mod-2,mod)
ans = (pow(2,n,mod) - 1 -at -bt)%mod
print(ans)
|
[
"call.remove"
] | 564,286
| 564,287
|
u920204936
|
python
|
p02768
|
mod = int(1e9) + 7
n, a, b = map(int, input().split())
def aaa(base, n):
# base = 2
ans = 1
nn = n
while True:
# print(base, nn)
if nn == 0:
break
if nn % 2 == 0:
base = base ** 2
base = base % mod
nn /= 2
else:
ans *= base
ans = ans % mod
nn -= 1
return ans
xn = aaa(2, n)
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, power(b, mod-2))
def fac(start, length, mod):
x = 1
for k in range(start, start + length):
x *= k
x %= mod
return x
aa = fac(n - a + 1 , a, mod)
aaa = fac(1, a, mod)
xa = div(aa, aaa)
if aa == 0:
if aaa == 0:
xa = 1
bb = fac(n - b + 1 , b, mod)
bbb = fac(1, b, mod)
xb = div(bb, bbb)
if bb == 0:
if bbb == 0:
xb = 1
x = xn - xa - xb - 1
if x < 0:
x += mod
print(x)
|
mod = int(1e9) + 7
n, a, b = map(int, input().split())
def aaa(base, n):
# base = 2
ans = 1
nn = n
while True:
# print(base, nn)
if nn == 0:
break
if nn % 2 == 0:
base = base ** 2
base = base % mod
nn /= 2
else:
ans *= base
ans = ans % mod
nn -= 1
return ans
xn = aaa(2, n)
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, power(b, mod-2))
def fac(start, length, mod):
x = 1
for k in range(start, start + length):
x *= k
x %= mod
return x
aa = fac(n - a + 1 , a, mod)
aaa = fac(1, a, mod)
xa = div(aa, aaa)
if aa == 0:
if aaa == 0:
xa = 1
bb = fac(n - b + 1 , b, mod)
bbb = fac(1, b, mod)
xb = div(bb, bbb)
if bb == 0:
if bbb == 0:
xb = 1
x = xn - xa - xb - 1
x = x % mod
if x < 0:
x += mod
print(x)
|
[
"assignment.add"
] | 564,300
| 564,301
|
u242196904
|
python
|
p02768
|
#156d
n,a,b = map(int, input().split())
##############################################
#https://tane-no-blog.com/976/
mod = pow(10, 9) + 7
def comb(N, x):
#n*(n-1)*…*(n-1+1)を計算
numerator = 1
for i in range(N-x+1, N+1):
numerator = numerator * i % mod
#a!を計算
denominator = 1
for j in range(1, x+1):
denominator = denominator * j % mod
#最後の項 a!**((10**9+7)-2)を計算
d = pow(denominator, mod-2, mod)
return numerator * d
################################
comb_all = pow(2,n,MOD_BY) - 1 #(2**n) - 1
comb_a = comb(n,a)
comb_b = comb(n,b)
#print(comb_all,comb_a,comb_b)
print((comb_all-comb_a-comb_b)%MOD_BY)
|
#156d
n,a,b = map(int, input().split())
##############################################
#https://tane-no-blog.com/976/
mod = pow(10, 9) + 7
def comb(N, x):
#n*(n-1)*…*(n-1+1)を計算
numerator = 1
for i in range(N-x+1, N+1):
numerator = numerator * i % mod
#a!を計算
denominator = 1
for j in range(1, x+1):
denominator = denominator * j % mod
#最後の項 a!**((10**9+7)-2)を計算
d = pow(denominator, mod-2, mod)
return numerator * d
################################
comb_all = pow(2,n,mod) - 1 #(2**n) - 1
comb_a = comb(n,a)
comb_b = comb(n,b)
#print(comb_all,comb_a,comb_b)
print((comb_all-comb_a-comb_b)%mod)
|
[
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 564,314
| 564,315
|
u314089899
|
python
|
p02768
|
# https://atcoder.jp/contests/abc156/submissions/10277689
# コンテスト中に通せたけどmodintクラスで実装してみる
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
class ModInt:
def __init__(self, x, MOD=10 ** 9 + 7):
self.mod = MOD
self.x = x if x < MOD else x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x + other.x, self.mod)
else:
return ModInt(self.x + other, self.mod)
def __sub__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x - other.x, self.mod)
else:
return ModInt(self.x - other, self.mod)
def __mul__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x * other.x, self.mod)
else:
return ModInt(self.x * other, self.mod)
def __truediv__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x * pow(other.x, self.mod - 2, self.mod))
else:
return ModInt(self.x * pow(other, self.mod - 2, self.mod))
def __pow__(self, other):
if isinstance(other, ModInt):
return ModInt(pow(self.x, other.x, self.mod))
else:
return ModInt(pow(self.x, other, self.mod))
__radd__ = __add__
def __rsub__(self, other): # 演算の順序が逆
if isinstance(other, ModInt):
return ModInt(other.x - self.x, self.mod)
else:
return ModInt(other - self.x, self.mod)
__rmul__ = __mul__
def __rtruediv__(self, other):
if isinstance(other, ModInt):
return ModInt(other.x * pow(self.x, self.mod - 2, self.mod))
else:
return ModInt(other * pow(self.x, self.mod - 2, self.mod))
def __rpow__(self, other):
if isinstance(other, ModInt):
return ModInt(pow(other.x, self.x, self.mod))
else:
return ModInt(pow(other, self.x, self.mod))
def combination_mod(n, r, mod):
if r > n:
return 0 # このような通りの数は無いため便宜上こう定義する
r = min(r, n - r)
nf = rf = 1
for i in range(r):
nf = nf * (n - i) % mod
rf = rf * (i + 1) % mod
return nf * pow(rf, mod - 2, mod) % mod
def combination(n, r):
if r > n:
return 0 # このような通りの数は無いため便宜上こう定義する
r = min(r, n - r)
nf = rf = ModInt(1)
for i in range(r):
nf = nf * (n - i)
rf = rf * (i + 1)
return nf / rf
# すべての通り(2^n-1)からnCa,nCbを引けば良い
MOD = 10**9 + 7
n, a, b = read_ints()
# tmp = pow(2, n, MOD) - 1
# ans = tmp - combination_mod(n, a, MOD) - combination_mod(n, b, MOD)
# print(ans % MOD)
tmp = ModInt(2)**n - 1
ans = tmp - combination(n, a) - combination(n, b)
print(ans)
|
# https://atcoder.jp/contests/abc156/submissions/10277689
# コンテスト中に通せたけどmodintクラスで実装してみる
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
class ModInt:
def __init__(self, x, MOD=10 ** 9 + 7):
self.mod = MOD
self.x = x if 0 <= x < MOD else x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x + other.x, self.mod)
else:
return ModInt(self.x + other, self.mod)
def __sub__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x - other.x, self.mod)
else:
return ModInt(self.x - other, self.mod)
def __mul__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x * other.x, self.mod)
else:
return ModInt(self.x * other, self.mod)
def __truediv__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x * pow(other.x, self.mod - 2, self.mod))
else:
return ModInt(self.x * pow(other, self.mod - 2, self.mod))
def __pow__(self, other):
if isinstance(other, ModInt):
return ModInt(pow(self.x, other.x, self.mod))
else:
return ModInt(pow(self.x, other, self.mod))
__radd__ = __add__
def __rsub__(self, other): # 演算の順序が逆
if isinstance(other, ModInt):
return ModInt(other.x - self.x, self.mod)
else:
return ModInt(other - self.x, self.mod)
__rmul__ = __mul__
def __rtruediv__(self, other):
if isinstance(other, ModInt):
return ModInt(other.x * pow(self.x, self.mod - 2, self.mod))
else:
return ModInt(other * pow(self.x, self.mod - 2, self.mod))
def __rpow__(self, other):
if isinstance(other, ModInt):
return ModInt(pow(other.x, self.x, self.mod))
else:
return ModInt(pow(other, self.x, self.mod))
def combination_mod(n, r, mod):
if r > n:
return 0 # このような通りの数は無いため便宜上こう定義する
r = min(r, n - r)
nf = rf = 1
for i in range(r):
nf = nf * (n - i) % mod
rf = rf * (i + 1) % mod
return nf * pow(rf, mod - 2, mod) % mod
def combination(n, r):
if r > n:
return 0 # このような通りの数は無いため便宜上こう定義する
r = min(r, n - r)
nf = rf = ModInt(1)
for i in range(r):
nf = nf * (n - i)
rf = rf * (i + 1)
return nf / rf
# すべての通り(2^n-1)からnCa,nCbを引けば良い
MOD = 10**9 + 7
n, a, b = read_ints()
# tmp = pow(2, n, MOD) - 1
# ans = tmp - combination_mod(n, a, MOD) - combination_mod(n, b, MOD)
# print(ans % MOD)
tmp = ModInt(2)**n - 1
ans = tmp - combination(n, a) - combination(n, b)
print(ans)
|
[] | 564,321
| 564,322
|
u179169725
|
python
|
p02768
|
import math
MOD = 10 ** 9 + 7
def cmb(n, r):
total = 1
for i in range(r):
total *= (n - i) % MOD
return total * pow(math.factorial(r), MOD - 2, MOD) % MOD
def calc(n, r):
ret = 1
for i in range(r):
ret = ret * (n - i) % MOD
return ret * pow(factorial(r), MOD - 2, MOD) % MOD
if __name__ == '__main__':
n, a, b = list(map(int, input().split(" ")))
total = pow(2, n, MOD)
a_total = calc(n, a)
b_total = calc(n, b)
print((total - a_total - b_total - 1) % MOD)
|
import math
MOD = 10 ** 9 + 7
def cmb(n, r):
total = 1
for i in range(r):
total *= (n - i) % MOD
return total * pow(math.factorial(r), MOD - 2, MOD) % MOD
def calc(n, r):
ret = 1
for i in range(r):
ret = ret * (n - i) % MOD
return ret * pow(math.factorial(r), MOD - 2, MOD) % MOD
if __name__ == '__main__':
n, a, b = list(map(int, input().split(" ")))
total = pow(2, n, MOD)
a_total = calc(n, a)
b_total = calc(n, b)
print((total - a_total - b_total - 1) % MOD)
|
[] | 564,345
| 564,346
|
u644224332
|
python
|
p02768
|
n, a, b = map(int, input().split())
a, b = min(a, n-a), min(b, n-b)
mod = 10**9 +7
def my_pow(num, p, mod):
if p==0:
return 1
elif p%2==0:
return (my_pow(num, p//2, mod)**2)%mod
else:
return (my_pow(num, p-1, mod)*num)%mod
def comb(num, r, mod):
r = min(r, num-r)
y = 1
for i in range(num-r+1, num+1):
y = (y*i)%mod
x = 1
for i in range(1, r+1):
x = (x*i)%mod
return (y*my_pow(x, mod-2, mod))%mod
result = my_pow(2, n, mod)-1 -comb(n, a, mod) -comb(n, b, mod)
if result < 0:
result += mod
print(result)
|
n, a, b = map(int, input().split())
a, b = min(a, n-a), min(b, n-b)
mod = 10**9 +7
def my_pow(num, p, mod):
if p==0:
return 1
elif p%2==0:
return (my_pow(num, p//2, mod)**2)%mod
else:
return (my_pow(num, p-1, mod)*num)%mod
def comb(num, r, mod):
r = min(r, num-r)
y = 1
for i in range(num-r+1, num+1):
y = (y*i)%mod
x = 1
for i in range(1, r+1):
x = (x*i)%mod
return (y*my_pow(x, mod-2, mod))%mod
result = my_pow(2, n, mod)-1 -comb(n, a, mod) -comb(n, b, mod)
while result < 0:
result += mod
print(result)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,347
| 564,348
|
u413165887
|
python
|
p02768
|
import sys
def alg_combination_mod(n, r, mod):
r = min(n - r, r)
if r == 0:
return 1
else:
denominator = 1
for i in range(n, n - r, -1):
denominator = (denominator * i) % mod
molecule = 1
for i in range(1, r + 1):
molecule = (molecule * i) % mod
return denominator * pow(molecule, mod - 2, mod) % mod
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
all_cnt = pow(2, n, mod) + mod
a_cnt = alg_combination_mod(n, a, mod)
b_cnt = alg_combination_mod(n, b, mod)
print(all_cnt - a_cnt - b_cnt - 1)
if __name__ == '__main__':
solve()
|
import sys
def alg_combination_mod(n, r, mod):
r = min(n - r, r)
if r == 0:
return 1
else:
denominator = 1
for i in range(n, n - r, -1):
denominator = (denominator * i) % mod
molecule = 1
for i in range(1, r + 1):
molecule = (molecule * i) % mod
return denominator * pow(molecule, mod - 2, mod) % mod
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
all_cnt = pow(2, n, mod)
a_cnt = alg_combination_mod(n, a, mod)
b_cnt = alg_combination_mod(n, b, mod)
print((all_cnt - a_cnt - b_cnt - 1) % mod)
if __name__ == '__main__':
solve()
|
[
"expression.operation.binary.remove",
"call.arguments.change",
"call.arguments.add"
] | 564,373
| 564,374
|
u753803401
|
python
|
p02768
|
import sys
def alg_combination_mod(n, r, mod):
r = min(n - r, r)
if r == 0:
return 1
else:
denominator = 1
for i in range(n, n - r, -1):
denominator = (denominator * i) % mod
molecule = 1
for i in range(1, r + 1):
molecule = (molecule * i) % mod
return denominator * pow(molecule, mod - 2, mod) % mod
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
all_cnt = pow(2, n, mod) + mod
a_cnt = alg_combination_mod(n, a, mod)
b_cnt = alg_combination_mod(n, b, mod)
print(all_cnt - a_cnt - b_cnt - 1)
if __name__ == '__main__':
solve()
|
import sys
def alg_combination_mod(n, r, mod):
r = min(n - r, r)
if r == 0:
return 1
else:
denominator = 1
for i in range(n, n - r, -1):
denominator = (denominator * i) % mod
molecule = 1
for i in range(1, r + 1):
molecule = (molecule * i) % mod
return denominator * pow(molecule, mod - 2, mod) % mod
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
all_cnt = pow(2, n, mod) + mod
a_cnt = alg_combination_mod(n, a, mod)
b_cnt = alg_combination_mod(n, b, mod)
print((all_cnt - a_cnt - b_cnt - 1) % mod)
if __name__ == '__main__':
solve()
|
[
"call.arguments.change",
"call.arguments.add"
] | 564,373
| 564,376
|
u753803401
|
python
|
p02768
|
import sys, math
def input():
return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial
from bisect import bisect_left # bisect_left(list, value)
#from fractions import gcd
enu = enumerate
sys.setrecursionlimit(10**7)
n, a, b = map(int, input().split())
mod = 10**9 + 7
def cmb(n, r, p):
r = min(n - r, r)
if r == 0:
return 1
over = 1
for i in range(n, n - r, -1):
over = over * i % p
under = 1
for i in range(1, r + 1):
under = under * i % p
inv = pow(under, p - 2, p)
return over * inv % p
cnt = pow(2, n, mod)
ng1 = cmb(n, a, mod)
ng2 = cmb(n, b, mod)
res = cnt - ng1 - ng2 - 1
print(res)
|
import sys, math
def input():
return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial
from bisect import bisect_left # bisect_left(list, value)
#from fractions import gcd
enu = enumerate
sys.setrecursionlimit(10**7)
n, a, b = map(int, input().split())
mod = 10**9 + 7
def cmb(n, r, p):
r = min(n - r, r)
if r == 0:
return 1
over = 1
for i in range(n, n - r, -1):
over = over * i % p
under = 1
for i in range(1, r + 1):
under = under * i % p
inv = pow(under, p - 2, p)
return over * inv % p
cnt = pow(2, n, mod)
ng1 = cmb(n, a, mod)
ng2 = cmb(n, b, mod)
res = (cnt - ng1 - ng2 - 1) % mod
print(res)
|
[
"assignment.change"
] | 564,380
| 564,381
|
u625729943
|
python
|
p02768
|
n,a,b=map(int,input().split())
def combination(n, a, mod):
bunshi = 1
bunbo = 1
for i in range(a):
bunshi *= n-i
bunshi = bunshi%mod
bunbo *= a-i
bunbo = bunbo%mod
return bunshi*pow(bunbo, mod-2, mod)%mod
mod = 100000007
answer = pow(2, n, mod)
answer -= 1
answer -= combination(n, a, mod)
answer -= combination(n, b, mod)
print(answer%mod)
|
n,a,b=map(int,input().split())
def combination(n, a, mod):
bunbo = 1
bunshi = 1
for i in range(a):
bunshi *= n-i
bunshi = bunshi%mod
bunbo *= a-i
bunbo = bunbo%mod
return bunshi*pow(bunbo, mod-2, mod)%mod
mod = 1000000007
answer = pow(2, n, mod)
answer -= 1
answer -= combination(n, a, mod)
answer -= combination(n, b, mod)
print(answer%mod)
|
[
"assignment.variable.change",
"identifier.change",
"literal.number.integer.change",
"assignment.value.change"
] | 564,382
| 564,383
|
u257018224
|
python
|
p02768
|
n,a,b=map(int,input().split())
def combination(n, a, mod):
bunshi = 1
bunbo = 1
for i in range(a):
bunshi *= n-i
bunshi = bunshi%mod
bunbo *= a-i
bunbo = bunbo%mod
return bunshi*pow(bunbo, mod-2, mod)%mod
mod = 100000007
answer = pow(2, n, mod)
answer -= 1
answer -= combination(n, a, mod)
answer -= combination(n, b, mod)
print(answer%mod)
|
n, a, b = map(int, input().split())
def combination(n, a, mod):
bunbo = 1
bunshi = 1
for i in range(a):
bunshi *= n-i
bunshi = bunshi%mod
bunbo *= a-i
bunbo = bunbo%mod
return bunshi*pow(bunbo, mod-2, mod)%mod
mod = 1000000007
answer = pow(2, n, mod)
answer -= 1
answer -= combination(n, a, mod)
answer -= combination(n, b, mod)
print(answer%mod)
|
[
"assignment.variable.change",
"identifier.change",
"literal.number.integer.change",
"assignment.value.change"
] | 564,382
| 564,384
|
u257018224
|
python
|
p02768
|
from functools import reduce
def perm(n, k, p):
ret = 1
for i in range(n, n-k-1, -1):
ret = (ret * i)%p
return ret
def comb(n, k, p):
"""power_funcを用いて(nCk) mod p を求める"""
a = perm(n, k, p)
b = perm(k, k, p)
return (a*pow(b, p-2, p))%p
n, a, b = map(int, input().split())
MOD = 10**9 + 7
print((pow(2,n,MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD))%MOD)
|
from functools import reduce
def perm(n, k, p):
ret = 1
for i in range(n, n-k, -1):
ret = (ret * i)%p
return ret
def comb(n, k, p):
"""power_funcを用いて(nCk) mod p を求める"""
a = perm(n, k, p)
b = perm(k, k, p)
return (a*pow(b, p-2, p))%p
n, a, b = map(int, input().split())
MOD = 10**9 + 7
print((pow(2,n,MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD))%MOD)
|
[
"expression.operation.binary.remove"
] | 564,389
| 564,390
|
u667084803
|
python
|
p02768
|
def factorial_mod(a, M):
ans = 1
for i in range(a,1,-1):
ans = (ans * i) % M
return ans
def test(n, a, M):
ans = 1
for i in range(a):
ans = (ans * (n-i)) % M
return ans
def combination_mod(n,a,M):
tmp = factorial_mod(a,M)
tmp = pow(tmp, M-2, M)
ans = test(n,a,M) * tmp % M
return ans
def output(n,a,b):
M = 10**9+7
ans = (pow(2,n,M) - 1 - combination_mod(n,a,M) - combination_mod(n,b,M)) % M
return ans
n, a, b = map(int, input().split())
print(output(a,b,c))
|
def factorial_mod(a, M):
# return a!(mod M)
ans = 1
for i in range(a,1,-1):
ans = (ans * i) % M
return ans
def test(n, a, M):
# return (nCaの分子) % M
ans = 1
for i in range(a):
ans = (ans * (n-i)) % M
return ans
def combination_mod(n,a,M):
# return nCa % M
tmp = factorial_mod(a,M)
tmp = pow(tmp, M-2, M)
ans = test(n,a,M) * tmp % M
return ans
def output(n,a,b):
M = 10**9+7
ans = (pow(2,n,M) - 1 - combination_mod(n,a,M) - combination_mod(n,b,M)) % M
return ans
n, a, b = map(int, input().split())
print(output(n,a,b))
|
[
"call.arguments.add",
"call.arguments.change"
] | 564,393
| 564,394
|
u549278479
|
python
|
p02768
|
import math
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
def COMint():
fac[0]=1
fac[1]=1
finv[0]=1
finv[1]=1
inv[1]=1
for i in range(2,N+1):
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<k:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
MOD=10**9+7
#繰り返し２乗法を使う場合
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n,a,b=[int(x) for x in input().split()]
ans1 = pow(2,n,MOD)
N = n
a1=combination(n,a)
b1 = combination(n,b)
if ans1-a1%MOD-b1%MOD<0:
print(((ans1-a1%MOD-b1%MOD)%MOD+MOD)%MOD)
else:
print(ans1-a1%MOD-b1%MOD)
|
import math
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
def COMint():
fac[0]=1
fac[1]=1
finv[0]=1
finv[1]=1
inv[1]=1
for i in range(2,N+1):
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<k:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
MOD=10**9+7
#繰り返し２乗法を使う場合
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n,a,b=[int(x) for x in input().split()]
ans1 = pow(2,n,MOD)
N = n
a1=combination(n,a)
b1 = combination(n,b)
if ans1-a1%MOD-b1%MOD<0:
print(((ans1-a1%MOD-b1%MOD)%MOD+MOD)%MOD-1)
else:
print(ans1-a1%MOD-b1%MOD-1)
|
[
"expression.operation.binary.add"
] | 564,415
| 564,416
|
u466331465
|
python
|
p02768
|
MOD = 10**9+7
def pow(a, b):
res = 1
while b:
if b & 1: res = res * a % MOD
a = a**2 % MOD
b >>= 1
return res
n, a, b = list(map(int, input().split()))
ans = pow(2, n)-1
for X in [a, b]:
x = 1
y = 1
for i in range(X):
x = x * (n-i) % MOD
y = y * (i+1) % MOD
t = x * pow(y, MOD-2) % MOD
ans -= t
if ans < 0: ans += MOD
print(ans)
|
MOD = 10**9+7
def pow(a, b):
res = 1
while b:
if b & 1: res = res * a % MOD
a = a**2 % MOD
b >>= 1
return res
n, a, b = list(map(int, input().split()))
ans = pow(2, n)-1
for X in [a, b]:
x = 1
y = 1
for i in range(X):
x = x * (n-i) % MOD
y = y * (i+1) % MOD
t = x * pow(y, MOD-2) % MOD
ans -= t
while ans < 0: ans += MOD
print(ans)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,423
| 564,424
|
u721316601
|
python
|
p02768
|
import sys
from collections import deque, Counter, defaultdict
from math import gcd
input = lambda: sys.stdin.readline().rstrip()
def eprint(s):
sys.stderr.write('DEBUG: {}'.format(s))
return
def comb(n,r,mod):
p,q=1,1
for i in range(r):
p=p*(n-i)%mod
q=q*(i+1)%mod
return p*pow(q,mod-2,mod)%mod
def main():
n,a,b = map(int, input().split())
#a,bの制約がなければ，2^n - 1通りだけ使える
# 2^n ^ nCa - nCb
mod = 10**9 +7
nca = comb(n,a,mod)
ncb = comb(n,b,mod)
print(pow(2,n,mod)-(nca+ncb)%mod-1)
return
if __name__ == '__main__':
main()
|
import sys
from collections import deque, Counter, defaultdict
from math import gcd
input = lambda: sys.stdin.readline().rstrip()
def eprint(s):
sys.stderr.write('DEBUG: {}'.format(s))
return
def comb(n,r,mod):
p,q=1,1
for i in range(r):
p=p*(n-i)%mod
q=q*(i+1)%mod
return p*pow(q,mod-2,mod)%mod
def main():
n,a,b = map(int, input().split())
#a,bの制約がなければ，2^n - 1通りだけ使える
# 2^n ^ nCa - nCb
mod = 10**9 +7
nca = comb(n,a,mod)
ncb = comb(n,b,mod)
print((pow(2,n,mod)-(nca+ncb)%mod) % mod-1)
return
if __name__ == '__main__':
main()
|
[
"call.arguments.change"
] | 564,438
| 564,439
|
u593934357
|
python
|
p02768
|
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = []
mod = 10**9+7
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])
result %= mod
return result
def power_func(a,n,p):
bi=str(format(n,"b"))
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
n, a, b = map(int, input().split())
mod = 10**9+7
ALL = power_func(2,n,mod)-1
A = cmb(n, a)%mod
B = cmb(n, b)%mod
ans = ALL-A-B
if ans < 0:
ans = mod + ans
print(ans)
|
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = []
mod = 10**9+7
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])
result %= mod
return result
def power_func(a,n,p):
bi=str(format(n,"b"))
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
n, a, b = map(int, input().split())
mod = 10**9+7
ALL = power_func(2,n,mod)-1
A = cmb(n,a)
B = cmb(n, b)
ans = ALL-A-B
while ans < 0:
ans = mod + ans
print(ans)
|
[
"expression.operation.binary.remove",
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,456
| 564,457
|
u686713618
|
python
|
p02768
|
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = []
mod = 10**9+7
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])
result %= mod
return result
def power_func(a,n,p):
bi=str(format(n,"b"))
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
n, a, b = map(int, input().split())
mod = 10**9+7
ALL = power_func(2,n,mod)-1
A = cmb(n, a)
B = cmb(n, b)
ans = ALL-A-B
if ans < 0:
ans = mod + ans
print(ans)
|
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = []
mod = 10**9+7
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])
result %= mod
return result
def power_func(a,n,p):
bi=str(format(n,"b"))
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
n, a, b = map(int, input().split())
mod = 10**9+7
ALL = power_func(2,n,mod)-1
A = cmb(n,a)
B = cmb(n, b)
ans = ALL-A-B
while ans < 0:
ans = mod + ans
print(ans)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,458
| 564,457
|
u686713618
|
python
|
p02768
|
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = []
mod = 10**9+7
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])
result %= mod
return result
def power_func(a,n,p):
bi=str(format(n,"b"))
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
n, a, b = map(int, input().split())
mod = 10**9+7
ALL = power_func(2,n,mod)-1
A = cmb(n,a)
B = cmb(n, b)
ans = ALL-A-B
if ans < 0:
ans = mod + ans
print(ans)
|
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = []
mod = 10**9+7
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])
result %= mod
return result
def power_func(a,n,p):
bi=str(format(n,"b"))
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
n, a, b = map(int, input().split())
mod = 10**9+7
ALL = power_func(2,n,mod)-1
A = cmb(n,a)
B = cmb(n, b)
ans = ALL-A-B
while ans < 0:
ans = mod + ans
print(ans)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,459
| 564,457
|
u686713618
|
python
|
p02768
|
n, a, b = map(int, input().split())
m = 10**9+7
def cmb(r):
N = 1
R = 1
for i in range(r):
N = N*(n - i) % m
R = R*(i+1) % m
return N*pow(R, m-2, m)%m
ans = pow(2, n, m) - ((cmb(a) + cmb(b) + 1)%m)
print(ans)
|
n, a, b = map(int, input().split())
m = 10**9+7
def cmb(r):
N = 1
R = 1
for i in range(r):
N = N*(n - i) % m
R = R*(i+1) % m
return N*pow(R, m-2, m)%m
ans = (pow(2, n, m) - ((cmb(a) + cmb(b) + 1)%m))%m
print(ans)
|
[
"assignment.change"
] | 564,460
| 564,461
|
u700805562
|
python
|
p02768
|
def pow2(n, mod):
p = 2
r = 1
while n:
if n % 2:
r = r * p % mod
p = (p * p) % mod
n //= 2
return r
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
def nCr(n, r, mod):
t = 1
r = min(r, n - r)
for i in range(n - r + 1, n + 1):
t = t * i % mod
return t * g2[r] % mod
def prep(n, mod):
for i in range(2, n):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
def main():
n, a, b = list(map(int, input().split()))
aod = 10 ** 9 + 7
prep(2 * (10 ** 5), mod)
print((pow2(n, mod) - 1 - nCr(n, a, mod) - nCr(n, b, mod))% mod)
main()
|
def pow2(n, mod):
p = 2
r = 1
while n:
if n % 2:
r = r * p % mod
p = (p * p) % mod
n //= 2
return r
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
def nCr(n, r, mod):
t = 1
r = min(r, n - r)
for i in range(n - r + 1, n + 1):
t = t * i % mod
return t * g2[r] % mod
def prep(n, mod):
for i in range(2, n):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
def main():
n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
prep(2 * (10 ** 5) + 1, mod)
print((pow2(n, mod) - 1 - nCr(n, a, mod) - nCr(n, b, mod))% mod)
main()
|
[
"assignment.variable.change",
"identifier.change"
] | 564,492
| 564,493
|
u858742833
|
python
|
p02768
|
n,a,b=map(int,input().split())
def combination(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = (numer*(n1-i)) % mod
denom = (denom*i) % mod
return numer * pow(denom, mod-2, mod) % mod
mod=10**9+7
print((pow(2,n,mod) - combination(n,a,mod) - combination(n,b,mod))%mod)
|
n,a,b=map(int,input().split())
def combination(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = (numer*(n1-i)) % mod
denom = (denom*i) % mod
return numer * pow(denom, mod-2, mod) % mod
mod=10**9+7
print((pow(2,n,mod)- 1 - combination(n,a,mod) - combination(n,b,mod))%mod)
|
[
"expression.operation.binary.add"
] | 564,504
| 564,505
|
u951480280
|
python
|
p02768
|
from scipy.special import comb
n,a,b=map(int,input().split())
MOD=10**9+7
def pos(x, n, m):
if n == 0:
return 1
res = pos(x*x%m, n//2, m)
if n%2 == 1:
res = res*x%m
return res
def comb(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
k=min(n-k,k)
ans=1
inv=[1]*(k+1)
if k>=1:
ans*=(n-k+1)%MOD
for i in range(2,k+1):
inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD
ans=ans*(n-k+i)*inv[i]%MOD
return ans
na=comb(n,a)
nb=comb(n,b)
ans=(pos(2,n,MOD)-na-nb-1)%MOD
print(ans)
|
n,a,b=map(int,input().split())
MOD=10**9+7
def pos(x, n, m):
if n == 0:
return 1
res = pos(x*x%m, n//2, m)
if n%2 == 1:
res = res*x%m
return res
def comb(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
k=min(n-k,k)
ans=1
inv=[1]*(k+1)
if k>=1:
ans*=(n-k+1)%MOD
for i in range(2,k+1):
inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD
ans=ans*(n-k+i)*inv[i]%MOD
return ans
na=comb(n,a)
nb=comb(n,b)
ans=(pos(2,n,MOD)-na-nb-1)%MOD
print(ans)
|
[] | 564,510
| 564,511
|
u511379665
|
python
|
p02768
|
def binary(n):
return bin(n)[2:]
# バイナリ法
def pow_by_binary_exponentiation(a, x, n): # a^x mod n
x = [int(b) for b in binary(x)]
y = a
for i in range(1, len(x)):
y = (y**2) % n
if x[i] == 1:
y = (y * a) % n
return y
# mを法とするaの乗法的逆元
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nCr mod m
# modinvが必要
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9 + 7):
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i + 1, mod) % mod
return res
n, a, b = map(int, input().split())
mod = 10**9 + 7
S = pow_by_binary_exponentiation(2, n, mod) - 1
A = combination(n, a, mod)
B = combination(n, b, mod)
ans = S -A -B
if ans < 0:
ans += mod
print(ans)
|
def binary(n):
return bin(n)[2:]
# バイナリ法
def pow_by_binary_exponentiation(a, x, n): # a^x mod n
x = [int(b) for b in binary(x)]
y = a
for i in range(1, len(x)):
y = (y**2) % n
if x[i] == 1:
y = (y * a) % n
return y
# mを法とするaの乗法的逆元
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nCr mod m
# modinvが必要
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9 + 7):
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i + 1, mod) % mod
return res
n, a, b = map(int, input().split())
mod = 10**9 + 7
S = pow_by_binary_exponentiation(2, n, mod) - 1
A = combination(n, a, mod)
B = combination(n, b, mod)
ans = (S - A - B) % mod
if ans < 0:
ans += mod
print(ans % mod)
|
[
"assignment.change",
"expression.operation.binary.add"
] | 564,529
| 564,530
|
u815878613
|
python
|
p02768
|
n,a,b=map(int,input().split())
m=10**9+7
def com(n,k,m):
p,q=1,1
for i in range(n-k+1,n+1):
p*=i
p%=m
for i in range(1,k+1):
q*=i
q%=m
return p*pow(q,m-2,m)%m
ca,cb=com(n,a,m),com(n,b,m)
ans=(pow(2,n,m)-1-ca-cb)%m
|
n,a,b=map(int,input().split())
m=10**9+7
def com(n,k,m):
p,q=1,1
for i in range(n-k+1,n+1):
p*=i
p%=m
for i in range(1,k+1):
q*=i
q%=m
return p*pow(q,m-2,m)%m
ca,cb=com(n,a,m),com(n,b,m)
ans=(pow(2,n,m)-1-ca-cb)%m
print(ans)
|
[
"call.add"
] | 564,552
| 564,553
|
u393512980
|
python
|
p02768
|
n,a,b=map(int,input().split())
m=10**9+7
def com(n,k,m):
p,q=1,1
for i in range(n-k+1,n+1):
p*=i
p%=m
for i in range(1,k+1):
q*=i
q%=m
return p*pow(q,m-2,m)%m
ca,cb=com(n,a,m),com(n,b,m)
ans=(pow(2,n,m)-ca-cb)%m
|
n,a,b=map(int,input().split())
m=10**9+7
def com(n,k,m):
p,q=1,1
for i in range(n-k+1,n+1):
p*=i
p%=m
for i in range(1,k+1):
q*=i
q%=m
return p*pow(q,m-2,m)%m
ca,cb=com(n,a,m),com(n,b,m)
ans=(pow(2,n,m)-1-ca-cb)%m
print(ans)
|
[
"call.add"
] | 564,555
| 564,553
|
u393512980
|
python
|
p02768
|
n, a, b = map(int, input().split())
mod = 10**9 + 7
a = min(a, n-a)
b = min(b, n-b)
com = [1] * (max(a, b) + 1)
for i in range(1,len(com)):
com[i] = (com[i-1] * pow(i, mod-2, mod) * (n-i+1)) % mod
print(pow(2, n, mod) - 1 - com[a] - com[b])
|
#!/usr/bin/env python3
n, a, b = map(int, input().split())
mod = 10**9 + 7
a = min(a, n-a)
b = min(b, n-b)
com = [1] * (max(a, b) + 1)
for i in range(1,len(com)):
com[i] = (com[i-1] * pow(i, mod-2, mod) * (n-i+1)) % mod
print((pow(2, n, mod) + mod - 1 - com[a] - com[b]) % mod)
|
[
"call.arguments.change",
"call.arguments.add"
] | 564,571
| 564,572
|
u552357043
|
python
|
p02768
|
n, a, b = map(int, input().split())
mod = 10**9 + 7
a = min(a, n-a)
b = min(b, n-b)
com = [1] * (max(a, b) + 1)
for i in range(1,len(com)):
com[i] = (com[i-1] * pow(i, mod-2, mod) * (n-i+1)) % mod
print(pow(2, n, mod) - 1 - com[a] - com[b])
|
n, a, b = map(int, input().split())
mod = 10**9 + 7
a = min(a, n-a)
b = min(b, n-b)
com = [1] * (max(a, b) + 1)
for i in range(1,len(com)):
com[i] = (com[i-1] * pow(i, mod-2, mod) * (n-i+1)) % mod
print((pow(2, n, mod) - 1 - com[a] - com[b] + mod) % mod)
|
[
"call.arguments.change",
"call.arguments.add"
] | 564,571
| 564,574
|
u552357043
|
python
|
p02768
|
n, a, b = list(map(int, input().split()))
mod = 10**9 + 7
import time
start = time.time()
# xの逆元を求める。フェルマーの小定理より、 x の逆元は x ^ (mod - 2) に等しい。計算時間はO(log(mod))程度。
# https://qiita.com/Yaruki00/items/fd1fc269ff7fe40d09a6
def modinv(x):
return pow(x, mod-2, mod)
modinv_table = [-1] * (b+1)
for i in range(1, b+1):
modinv_table[i] = modinv(i)
end = time.time()
# print("time: ", end - start)
def binomial_coefficients2(n, k):
ans = 1
for i in range(k):
ans *= n-i
ans *= modinv_table[i + 1]
ans %= mod
return ans
# (2 ** n - 1) - nCa - nCb
ans = power(2, n) - 1
ans -= (binomial_coefficients2(n, a) + binomial_coefficients2(n, b))
print(ans % mod)
# print(binomial_coefficients2 (5, 2) % mod)
|
n, a, b = list(map(int, input().split()))
mod = 10**9 + 7
import time
start = time.time()
# xの逆元を求める。フェルマーの小定理より、 x の逆元は x ^ (mod - 2) に等しい。計算時間はO(log(mod))程度。
# https://qiita.com/Yaruki00/items/fd1fc269ff7fe40d09a6
def modinv(x):
return pow(x, mod-2, mod)
modinv_table = [-1] * (b+1)
for i in range(1, b+1):
modinv_table[i] = modinv(i)
end = time.time()
# print("time: ", end - start)
def binomial_coefficients2(n, k):
ans = 1
for i in range(k):
ans *= n-i
ans *= modinv_table[i + 1]
ans %= mod
return ans
# (2 ** n - 1) - nCa - nCb
ans = pow(2, n, mod) - 1
ans -= (binomial_coefficients2(n, a) + binomial_coefficients2(n, b))
print(ans % mod)
# print(binomial_coefficients2 (5, 2) % mod)
|
[
"assignment.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 564,579
| 564,580
|
u162612857
|
python
|
p02768
|
def loop_pow(x,n,mod):
if n==0:
return 1
if n%2==0:
t=loop_pow(x,n//2,mod)
return (t*t)%mod
return x*loop_pow(x,n-1,mod)%mod
def com(N,K,mod):
n=N
k=K
up=1
down=1
for _ in range(K):
up*=n
up%=mod
n-=1
for _ in range(K):
down*=k
down%=mod
k-=1
down=loop_pow(down,10**9+5,mod)
return up*down%mod
def main():
N,a,b=map(int,input().split())
mod=10**9+7
t=loop_pow(2,N,mod)-1-com(N,a,mod)-com(N,b,mod)
print(t)
if __name__=="__main__":
main()
|
def loop_pow(x,n,mod):
if n==0:
return 1
if n%2==0:
t=loop_pow(x,n//2,mod)
return (t*t)%mod
return x*loop_pow(x,n-1,mod)%mod
def com(N,K,mod):
n=N
k=K
up=1
down=1
for _ in range(K):
up*=n
up%=mod
n-=1
for _ in range(K):
down*=k
down%=mod
k-=1
down=loop_pow(down,10**9+5,mod)
return up*down%mod
def main():
N,a,b=map(int,input().split())
mod=10**9+7
t=(loop_pow(2,N,mod)-1-com(N,a,mod)-com(N,b,mod))%mod
print(t)
if __name__=="__main__":
main()
|
[
"assignment.change"
] | 564,585
| 564,586
|
u079022693
|
python
|
p02768
|
n, a, b = map(int, input().split())
law = 10 ** 9 + 7
def fermat(n, r, law):
x = 1
y = 1
for i in range(r):
x = x * (n - i) % law
y = y * (i + 1) % law
ans = x * pow(y, law - 2, law)
return ans
print((pow(2,n,law)- fermat(n,a,law)-fermat(n,b,law))%law)
|
n, a, b = map(int, input().split())
law = 10 ** 9 + 7
def fermat(n, r, law):
x = 1
y = 1
for i in range(r):
x = x * (n - i) % law
y = y * (i + 1) % law
ans = x * pow(y, law - 2, law) % law
return ans
print((pow(2,n,law)- fermat(n,a,law)-fermat(n,b,law)-1)%law)
|
[
"assignment.change",
"expression.operation.binary.add"
] | 564,623
| 564,624
|
u809816772
|
python
|
p02768
|
n, a, b = list(map(int, input().split()))
mod = 10**9 + 7
def choose(n, a):
x = 1
y = 1
for i in range(1, a + 1):
x = (x * (n - i + 1)) % mod
y = (y * i) % mod
return (x * pow(y, mod - 2, mod)) % mod
print(pow(2, n, mod) - 1 - ((choose(n, a) + choose(n, b)) % mod))
|
n, a, b = list(map(int, input().split()))
mod = 10**9 + 7
def choose(n, a):
x = 1
y = 1
for i in range(1, a + 1):
x = (x * (n - i + 1)) % mod
y = (y * i) % mod
return (x * pow(y, mod - 2, mod)) % mod
print((pow(2, n, mod) - 1 - choose(n, a) - choose(n, b)) % mod )
|
[
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"io.output.change"
] | 564,634
| 564,635
|
u639340617
|
python
|
p02768
|
#d
n,a,b = map(int,input().split())
def power(x, n, mod):
"""
x**n mod in O(log n)
"""
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K = K * x % mod
x = x ** 2 % mod
n = (n - 1) // 2
else:
x = x ** 2 % mod
n = n // 2
return K * x % mod
def nCrMOD(a,b,m):
c = 1
for i in range(b):
c = c * (a - i) % m
c = c * modinv(i + 1,m) % m
return c
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
def modinv(a, m):
(inv, q, gcd_val) = egcd(a, m)
return inv % m
m=10*9+7
ans = power(2,n,m) -1 - nCrMOD(n,a,m) -nCrMOD(n,b,m)
print(ans%m)
|
#d
n,a,b = map(int,input().split())
def power(x, n, mod):
"""
x**n mod in O(log n)
"""
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K = K * x % mod
x = x ** 2 % mod
n = (n - 1) // 2
else:
x = x ** 2 % mod
n = n // 2
return K * x % mod
def nCrMOD(a,b,m):
c = 1
for i in range(b):
c = c * (a - i) % m
c = c * modinv(i + 1,m) % m
return c
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
def modinv(a, m):
(inv, q, gcd_val) = egcd(a, m)
return inv % m
m=10**9+7
ans = power(2,n,m) -1 - nCrMOD(n,a,m) -nCrMOD(n,b,m)
print(ans%m)
|
[
"assignment.value.change",
"expression.operation.binary.change"
] | 564,651
| 564,652
|
u586759271
|
python
|
p02768
|
n, a, b = map(int, input().split())
MOD = 1000000007
def combination(n, r):
r = min(r, n - r)
num = 1
den = 1
for i in range(1, r + 1):
num = (num * (n + 1 - i)) % MOD
den = (den * i) % MOD
return num * pow(den, MOD - 2, MOD) % MOD
def func(a, n, p):
bi = str(format(n, "b"))
res = 1
for i in range(len(bi)):
res = (res * res) % p
if bi[i] == "1":
res = (res * a) % p
return res
s = func(2, n, MOD) - 1
xa = combination(n, a)
xb = combination(n, b)
p = (s - xa - xb)
if p < 0:
print(p + MOD)
else:
print(p)
|
n, a, b = map(int, input().split())
MOD = 1000000007
def combination(n, r):
r = min(r, n - r)
num = 1
den = 1
for i in range(1, r + 1):
num = (num * (n + 1 - i)) % MOD
den = (den * i) % MOD
return num * pow(den, MOD - 2, MOD) % MOD
def func(a, n, p):
bi = str(format(n, "b"))
res = 1
for i in range(len(bi)):
res = (res * res) % p
if bi[i] == "1":
res = (res * a) % p
return res
s = func(2, n, MOD) - 1
xa = combination(n, a)
xb = combination(n, b)
p = (s - xa - xb) % MOD
if p < 0:
print(p + MOD)
else:
print(p)
|
[
"assignment.change"
] | 564,728
| 564,729
|
u137542041
|
python
|
p02768
|
import math
z = 10**9 + 7
n, a, b = [int(i) for i in input().split()]
r = pow(2, n, z)
def c(m):
x = 1
for i in range(n-m+1, n+1):
x = x*i % z
return (x * pow(math.factorial(m), z-2, z)) % z
r = (r - c(a) - c(b)) % z
print(r)
|
import math
z = 10**9 + 7
n, a, b = [int(i) for i in input().split()]
r = pow(2, n, z) - 1
def c(m):
x = 1
for i in range(n-m+1, n+1):
x = x*i % z
return (x * pow(math.factorial(m), z-2, z)) % z
r = (r - c(a) - c(b)) % z
print(r)
|
[
"assignment.change"
] | 564,752
| 564,753
|
u871509659
|
python
|
p02768
|
n, a, b = [int(i) for i in input().split()]
mod = 10**9+7
def func_156d(n, r):
r =min(r, n-r)
numerator = 1
denominator = 1
for i in range(n-r+1, n+1):
numerator = numerator * i % mod
for i in range(1, r+1):
denominator = denominator * i % mod
return numerator * pow(denominator, mod-2, mod) %mod
print(pow(2, n, mod) -1 - func_156d(n,a) - func_156d(n,b) %mod)
|
n, a, b = [int(i) for i in input().split()]
mod = 10**9+7
def func_156d(n, r):
r =min(r, n-r)
numerator = 1
denominator = 1
for i in range(n-r+1, n+1):
numerator = numerator * i % mod
for i in range(1, r+1):
denominator = denominator * i % mod
return numerator * pow(denominator, mod-2, mod) %mod
print((pow(2, n, mod) -1 - func_156d(n,a) - func_156d(n,b) + 2*mod) %mod )
|
[
"call.arguments.change"
] | 564,773
| 564,774
|
u840310460
|
python
|
p02768
|
n,a,b = map(int,input().split())
mod = 10**9+7
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
sum = pow(2,n,mod)
case = combination(n,a,mod) + combination(n,b,mod) + 1
ans = sum-case
if ans < 0 :
ans += mod
print(ans)
|
n,a,b = map(int,input().split())
mod = 10**9+7
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
sum = pow(2,n,mod)
case = combination(n,a,mod) + combination(n,b,mod) + 1
ans = sum-case
while ans < 0 :
ans += mod
print(ans)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,802
| 564,803
|
u397384480
|
python
|
p02768
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
ans = pow(2, n, MOD)-combination_with_mod(n, a)-combination_with_mod(n, b)-combination_with_mod(n, 0)
if ans < 0:
print(MOD+ans)
else:
print(ans%MOD)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
ans = pow(2, n, MOD)-combination_with_mod(n, a)-combination_with_mod(n, b)-combination_with_mod(n, 0)
if ans < 0:
print((MOD+ans)%MOD)
else:
print(ans%MOD)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
[
"call.arguments.change",
"call.arguments.add"
] | 564,807
| 564,808
|
u386819480
|
python
|
p02768
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
ans = pow(2, n, MOD)-combination_with_mod(n, a)-combination_with_mod(n, b)-combination_with_mod(n, 0)
if ans < 0:
print(MOD+ans)
else:
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
ans = pow(2, n, MOD)-combination_with_mod(n, a)-combination_with_mod(n, b)-combination_with_mod(n, 0)
if ans < 0:
print((MOD+ans)%MOD)
else:
print(ans%MOD)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
[
"call.arguments.change"
] | 564,809
| 564,808
|
u386819480
|
python
|
p02768
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
def power_func(a,n,p):
bi=str(format(n,"b"))#2進表現に
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
ans = 0
ans = power_func(2, n, MOD)
ans = ans-combination_with_mod(n,a)-combination_with_mod(n, b)-combination_with_mod(n,0)
if ans < 0:
print(MOD+ans)
else:
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
def power_func(a,n,p):
bi=str(format(n,"b"))#2進表現に
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
ans = 0
ans = power_func(2, n, MOD)
ans = ans-combination_with_mod(n, a)-combination_with_mod(n, b)-combination_with_mod(n, 0)
if ans < 0:
print((MOD+ans)%MOD)
else:
print(ans%MOD)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
[
"call.arguments.change"
] | 564,810
| 564,811
|
u386819480
|
python
|
p02768
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
def power_func(a,n,p):
bi=str(format(n,"b"))#2進表現に
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
ans = 0
ans = power_func(2, n, MOD)
# print(mod_inv(ans, MOD))
# print(ans)
# for i in range(1,n+1):
# ans += combination_with_mod(n, i)
ans = ans-combination_with_mod(n,a)-combination_with_mod(n, b)-combination_with_mod(n,0)
if ans < 0:
print(MOD+ans)
else:
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
# sys.setrecursionlimit(10000000)
INF = 1<<32
# import numpy as np
MOD = 1000000007 # type: int
def solve(n: int, a: int, b: int):
def combination_with_mod(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
def power_func(a,n,p):
bi=str(format(n,"b"))#2進表現に
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
ans = 0
ans = power_func(2, n, MOD)
ans = ans-combination_with_mod(n, a)-combination_with_mod(n, b)-combination_with_mod(n, 0)
if ans < 0:
print((MOD+ans)%MOD)
else:
print(ans%MOD)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = int(next(tokens)) # type: int
b = int(next(tokens)) # type: int
solve(n, a, b)
if __name__ == '__main__':
main()
|
[
"call.arguments.change"
] | 564,812
| 564,811
|
u386819480
|
python
|
p02768
|
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
def choose(n, r, mod):
r = min(r, n - r)
x = 1
y = 1
for i in range(r):
x = x * (n - i) % mod
y = y * (i + 1) % mod
y = pow(y, -2, mod)
return x * y % mod
ans = pow(2, n, mod) - 1 - choose(n, a, mod) - choose(n, b, mod)
while ans < 0:
ans += mod
print(ans)
|
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
def choose(n, r, mod):
r = min(r, n - r)
x = 1
y = 1
for i in range(r):
x = x * (n - i) % mod
y = y * (i + 1) % mod
y = pow(y, mod-2, mod)
return x * y % mod
ans = pow(2, n, mod) - 1 - choose(n, a, mod) - choose(n, b, mod)
while ans < 0:
ans += mod
print(ans)
|
[
"call.arguments.change"
] | 564,819
| 564,820
|
u118211443
|
python
|
p02768
|
#コンビネーション。
def comb(n,m,p=10**9+7):
if n < m : return 0
if n < 0 or m < 0:return 0
m = min(m, n-m)
top = bot = 1
for i in range(m):
top = top*(n-i) % p
bot = bot*(i+1) % p
bot = pow(bot, p-2, p)
return top*bot % p
#累乗
def mpow(x: int, k: int, MOD=1000000007) -> int:
res = 1
y = x
while (k):
if(k % 2 == 1):
res = (res * y) % MOD
y = (y ** 2) % MOD
k = k // 2
return res
[n,a,b] = list(map(int,input().split()))
CA = comb(n,a,10**9+7)
CB = comb(n,b,10**9+7)
X = mpow(2,n,10**9+7)
output = X-CA-CB-1
if output<0:
output += 10**9+7
print(output)
|
#コンビネーション。
def comb(n,m,p=10**9+7):
if n < m : return 0
if n < 0 or m < 0:return 0
m = min(m, n-m)
top = bot = 1
for i in range(m):
top = top*(n-i) % p
bot = bot*(i+1) % p
bot = pow(bot, p-2, p)
return top*bot % p
#累乗
def mpow(x: int, k: int, MOD=1000000007) -> int:
res = 1
y = x
while (k):
if(k % 2 == 1):
res = (res * y) % MOD
y = (y ** 2) % MOD
k = k // 2
return res
[n,a,b] = list(map(int,input().split()))
CA = comb(n,a,10**9+7)
CB = comb(n,b,10**9+7)
X = mpow(2,n,10**9+7)
output = X-CA-CB-1
while output<0:
output += 10**9+7
print(output)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 564,885
| 564,886
|
u208713671
|
python
|
p02768
|
n,a,b=map(int,input().split())
mod=10**9+7
P = 10**9 + 7
N = 200001
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
def power_func(a,n,p):
bi=str(format(n,"b"))#2進表現に
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
def comb(x):
res=1
for i in range(n-x+1,n+1):
res*=i
res=res%mod
for i in range(1,x+1):
res*=inv_t[i]
res=res%mod
return res
al=power_func(2,n,mod)
print((al-comb(a)-comb(b))%mod)
|
n,a,b=map(int,input().split())
mod=10**9+7
P = 10**9 + 7
N = 200001
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
def power_func(a,n,p):
bi=str(format(n,"b"))#2進表現に
res=1
for i in range(len(bi)):
res=(res*res) %p
if bi[i]=="1":
res=(res*a) %p
return res
def comb(x):
res=1
for i in range(n-x+1,n+1):
res*=i
res=res%mod
for i in range(1,x+1):
res*=inv_t[i]
res=res%mod
return res
al=power_func(2,n,mod)-1
print((al-comb(a)-comb(b))%mod)
|
[
"assignment.change"
] | 564,905
| 564,906
|
u459798349
|
python
|
p02768
|
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
N,a,b = inpl()
def calc(N,x):
ret = 1
for i in range(N-x+1,N+1):
ret *= i
ret %= mod
for i in range(1, x+1):
ret *= pow(i,mod-2,mod)
ret %= mod
return ret%mod
ans = pow(2,N,mod)-1 - calc(a) - calc(b)
print(ans%mod)
|
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
N,a,b = inpl()
def calc(x):
ret = 1
for i in range(N-x+1,N+1):
ret *= i
ret %= mod
for i in range(1, x+1):
ret *= pow(i,mod-2,mod)
ret %= mod
return ret%mod
ans = pow(2,N,mod)-1 - calc(a) - calc(b)
print(ans%mod)
|
[] | 564,916
| 564,917
|
u333945892
|
python
|
p02769
|
mod_val = 10**9+7
n, k = map(int, input().split())
factorials = [1]*(n+1) # values 0 to n
for i in range(2, n+1):
factorials[i] = (factorials[i-1]*i)%mod_val
def mod_binomial(a, b):
numerator = factorials[a]
denominator = (factorials[b]*factorials[a-b])%mod_val
invert = pow(denominator, mod_val-2, mod_val)
return (numerator*invert)%mod_val
partial = 0
# m is number of rooms with no people
for m in range(min(k+1, n-1)):
# m places within n to place the 'no people' rooms
# put n-(n-m) people in n-m rooms (n-m) must be placed to be non-empty
partial = (partial + (mod_binomial(n, m) * mod_binomial(n-1, m))%mod_val)%mod_val
print(partial)
|
mod_val = 10**9+7
n, k = map(int, input().split())
factorials = [1]*(n+1) # values 0 to n
for i in range(2, n+1):
factorials[i] = (factorials[i-1]*i)%mod_val
def mod_binomial(a, b):
numerator = factorials[a]
denominator = (factorials[b]*factorials[a-b])%mod_val
invert = pow(denominator, mod_val-2, mod_val)
return (numerator*invert)%mod_val
partial = 0
# m is number of rooms with no people
for m in range(min(k+1, n)):
# m places within n to place the 'no people' rooms
# put n-(n-m) people in n-m rooms (n-m) must be placed to be non-empty
partial = (partial + (mod_binomial(n, m) * mod_binomial(n-1, m))%mod_val)%mod_val
print(partial)
|
[
"expression.operation.binary.remove"
] | 564,945
| 564,946
|
u460375306
|
python
|
p02769
|
n,k = map(int,input().split())
mod = 10**9 + 7
fact = [1]
finv = [1]
for i in range(1, 2*n):
fact.append((fact[i-1] * i) % mod)
finv.append(pow(fact[i], mod-2, mod))
if n-1 <= k:
print((fact[2*n-1] * finv[n] * finv[n-1]) % mod)
ans = 0
for i in range(k+1):
ans += fact[n] * finv[n-i] * finv[i] * fact[n-1] * finv[n-1-i] * finv[i]
ans %= mod
print(ans)
|
n,k = map(int,input().split())
mod = 10**9 + 7
fact = [1]
finv = [1]
for i in range(1, 2*n):
fact.append((fact[i-1] * i) % mod)
finv.append(pow(fact[i], mod-2, mod))
if n-1 <= k:
print((fact[2*n-1] * finv[n] * finv[n-1]) % mod)
exit()
ans = 0
for i in range(k+1):
ans += fact[n] * finv[n-i] * finv[i] * fact[n-1] * finv[n-1-i] * finv[i]
ans %= mod
print(ans)
|
[
"call.add"
] | 564,951
| 564,952
|
u934868410
|
python
|
p02769
|
N, K = list(map(int, input().split()))
p = 10**9+7
size = 2*2*10**5
def binom(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, size + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
res = 0
for i in range(min(K, N)):
res += (binom(N, i, p) * binom(N-1, N-i-1, p)) % p
print(res % p)
|
N, K = list(map(int, input().split()))
p = 10**9+7
size = 2*2*10**5
def binom(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, size + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
res = 0
for i in range(min(K, N)+1):
res += (binom(N, i, p) * binom(N-1, N-i-1, p)) % p
print(res % p)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 564,953
| 564,954
|
u892305365
|
python
|
p02769
|
n, k = map(int, input().split())
c1 = 1
c2 = 1
mod = 10**9+7
ans = 0
for i in range(min(n, k+1)):
ans += c1 * c2
c1 *= (n-i) * pow(i+1, mod-2, mod)
c1 %= mod
c2 *= (n-i-1) * pow(i+1, mod-2, mod)
c2 %= mod
print(ans)
|
n, k = map(int, input().split())
c1 = 1
c2 = 1
mod = 10**9+7
ans = 0
for i in range(min(n, k+1)):
ans += c1 * c2
c1 *= (n-i) * pow(i+1, mod-2, mod)
c1 %= mod
c2 *= (n-i-1) * pow(i+1, mod-2, mod)
c2 %= mod
print(ans%mod)
|
[
"expression.operation.binary.add"
] | 564,979
| 564,980
|
u875541136
|
python
|
p02769
|
mod=10**9+7
comb1=1
comb2=1
N,K=map(int,input().split())
k=min(K,N-1)
x=0
for i in range(k):
comb1=(comb1*(N-i)*pow(i+1,mod-2,mod))%(mod)
comb2=(comb2*(N-1-i)*pow(i+1,mod-2,mod))%(mod)
x+=(comb1*comb2)%(mod)
print(x%(mod))
|
mod=10**9+7
comb1=1
comb2=1
N,K=map(int,input().split())
k=min(K,N-1)
x=0
for i in range(k):
comb1=(comb1*(N-i)*pow(i+1,mod-2,mod))%(mod)
comb2=(comb2*(N-1-i)*pow(i+1,mod-2,mod))%(mod)
x+=(comb1*comb2)%(mod)
print((x+1)%(mod))
|
[
"call.arguments.change"
] | 564,981
| 564,982
|
u387774811
|
python
|
p02769
|
n,k=map(int,input().split())
mod=10**9+7
U = 4*10**5+1
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U],MOD-2,MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n,k):
if k < 0 or k > n:
return 0
x = fact[n]
x *= fact_inv[k]
x %= MOD
x *= fact_inv[n-k]
x %= MOD
return x
if n-1<=k:
print(comb(2*n-1,n-1))
else:
ans=0
for i in range(1,1+k):
ans+=comb(n,i)*comb(n-1,n-i-1)
ans%=mod
print(ans)
|
n,k=map(int,input().split())
mod=10**9+7
U = 4*10**5+1
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U],MOD-2,MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n,k):
if k < 0 or k > n:
return 0
x = fact[n]
x *= fact_inv[k]
x %= MOD
x *= fact_inv[n-k]
x %= MOD
return x
if n-1<=k:
print(comb(2*n-1,n-1))
else:
ans=0
for i in range(1+k):
ans+=comb(n,i)*comb(n-1,n-i-1)
ans%=mod
print(ans)
|
[
"call.arguments.change"
] | 564,989
| 564,990
|
u350248178
|
python
|
p02769
|
from sys import stdin
def prepare(n, p):
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, n + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
return fact, factinv
def cmb(n, r, p, fact, factinv):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
def get_result(data):
n, k = data
mod = 10**9+7
fact, factinv = prepare(n, mod)
ans = 0
for m in range(n):
# xHy = x+y−1Cx−1
ans += (cmb(n, m, mod, fact, factinv) * cmb(n-1, n-m-1, mod, fact, factinv)) % mod
ans %= mod
return ans
if __name__ == '__main__':
data = list(map(int, stdin.readline().split(' ')))
result = get_result(data)
print(result)
|
from sys import stdin
def prepare(n, p):
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, n + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
return fact, factinv
def cmb(n, r, p, fact, factinv):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
def get_result(data):
n, k = data
mod = 10**9+7
fact, factinv = prepare(n, mod)
ans = 0
for m in range(n):
# xHy = x+y−1Cx−1
if m <= k:
ans += (cmb(n, m, mod, fact, factinv) * cmb(n-1, n-m-1, mod, fact, factinv)) % mod
ans %= mod
return ans
if __name__ == '__main__':
data = list(map(int, stdin.readline().split(' ')))
result = get_result(data)
print(result)
|
[
"control_flow.branch.if.add"
] | 564,999
| 565,000
|
u659302753
|
python
|
p02769
|
n, k = map(int, input().split())
mod = 10**9+7
k = min([k, n-1])
ans = 0
key = 1
for i in range(k):
ans += key
ans %= mod
key = (((key*(n-i)%mod)*(n-i-1)%mod)*pow(pow(i+1, mod-2, mod), 2, mod))%mod
print(ans)
|
n, k = map(int, input().split())
mod = 10**9+7
k = min([k, n-1])
ans = 0
key = 1
for i in range(k+1):
ans += key
ans %= mod
key = (((key*(n-i)%mod)*(n-i-1)%mod)*pow(pow(i+1, mod-2, mod), 2, mod))%mod
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 565,001
| 565,002
|
u021548497
|
python
|
p02769
|
class Combinatorics:
def __init__(self, N, mod):
'''
Preprocess for calculating binomial coefficients nCr (0 <= r <= n, 0 <= n <= N)
over the finite field Z/(mod)Z.
Input:
N (int): maximum n
mod (int): a prime number. The order of the field Z/(mod)Z over which nCr is calculated.
'''
self.mod = mod
self.fact = {i: None for i in range(N+1)} # n!
self.inverse = {i: None for i in range(1, N+1)} # inverse of n in the field Z/(MOD)Z
self.fact_inverse = {i: None for i in range(N+1)} # inverse of n! in the field Z/(MOD)Z
# preprocess
self.fact[0] = self.fact[1] = 1
self.fact_inverse[0] = self.fact_inverse[1] = 1
self.inverse[1] = 1
for i in range(2, N+1):
self.fact[i] = i * self.fact[i-1] % self.mod
q, r = divmod(self.mod, i)
self.inverse[i] = (- (q % self.mod) * self.inverse[r]) % self.mod
self.fact_inverse[i] = self.inverse[i] * self.fact_inverse[i-1] % self.mod
def perm(self, n, r):
'''
Calculate nPr = n! / (n-r)! % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return (self.fact[n] * self.fact_inverse[n-r]) % self.mod
def binom(self, n, r):
'''
Calculate nCr = n! /(r! (n-r)!) % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return self.fact[n] * (self.fact_inverse[r] * self.fact_inverse[n-r] % self.mod) % self.mod
def hom(self, n, r):
'''
Calculate nHr = {n+r-1}Cr % mod.
Assign r objects to one of n classes.
Arrangement of r circles and n-1 partitions:
o o o | o o | | | o | | | o o | | o
'''
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.binom(n + r - 1, r)
MOD = 10**9 + 7
N, K = map(int, input().split())
com = Combinatorics(N, MOD)
ans = 0
for i in range(max(0, N - K), N+1):
ans += (com.binom(N, i) * com.hom(N-i, i)) % MOD
ans %= MOD
print(ans)
|
class Combinatorics:
def __init__(self, N, mod):
'''
Preprocess for calculating binomial coefficients nCr (0 <= r <= n, 0 <= n <= N)
over the finite field Z/(mod)Z.
Input:
N (int): maximum n
mod (int): a prime number. The order of the field Z/(mod)Z over which nCr is calculated.
'''
self.mod = mod
self.fact = {i: None for i in range(N+1)} # n!
self.inverse = {i: None for i in range(1, N+1)} # inverse of n in the field Z/(MOD)Z
self.fact_inverse = {i: None for i in range(N+1)} # inverse of n! in the field Z/(MOD)Z
# preprocess
self.fact[0] = self.fact[1] = 1
self.fact_inverse[0] = self.fact_inverse[1] = 1
self.inverse[1] = 1
for i in range(2, N+1):
self.fact[i] = i * self.fact[i-1] % self.mod
q, r = divmod(self.mod, i)
self.inverse[i] = (- (q % self.mod) * self.inverse[r]) % self.mod
self.fact_inverse[i] = self.inverse[i] * self.fact_inverse[i-1] % self.mod
def perm(self, n, r):
'''
Calculate nPr = n! / (n-r)! % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return (self.fact[n] * self.fact_inverse[n-r]) % self.mod
def binom(self, n, r):
'''
Calculate nCr = n! /(r! (n-r)!) % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return self.fact[n] * (self.fact_inverse[r] * self.fact_inverse[n-r] % self.mod) % self.mod
def hom(self, n, r):
'''
Calculate nHr = {n+r-1}Cr % mod.
Assign r objects to one of n classes.
Arrangement of r circles and n-1 partitions:
o o o | o o | | | o | | | o o | | o
'''
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.binom(n + r - 1, r)
MOD = 10**9 + 7
N, K = map(int, input().split())
com = Combinatorics(N, MOD)
ans = 0
for i in range(min(K, N-1) + 1):
ans += (com.binom(N, i) * com.hom(N-i, i)) % MOD
ans %= MOD
print(ans)
|
[
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change",
"control_flow.loop.range.bounds.upper.change",
"identifier.replace.add",
"literal.replace.remove",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change"
] | 565,013
| 565,014
|
u497046426
|
python
|
p02769
|
#input
n, k = map(int, input().split())
#output
mod = pow(10, 9) + 7
n_ = 3*10**5
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
if n <= k-1:
print(cmb(2*n-1, n))
else:
answer = 0
for m in range(k+1):
answer += cmb(n, m)*cmb(n-1, m) % mod
answer %= mod
print(answer)
|
#input
n, k = map(int, input().split())
#output
mod = pow(10, 9) + 7
n_ = 4*10**5 + 5
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
if n <= k-1:
print(cmb(2*n-1, n))
else:
answer = 0
for m in range(k+1):
answer += cmb(n, m)*cmb(n-1, m) % mod
answer %= mod
print(answer)
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 565,027
| 565,028
|
u461454424
|
python
|
p02769
|
#input
n, k = map(int, input().split())
#output
mod = pow(10, 9) + 7
n_ = 2*10**5 + 3
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
if n <= k-1:
print(cmb(2*n-1, n))
else:
answer = 0
for m in range(k+1):
answer += cmb(n, m)*cmb(n-1, m) % mod
answer %= mod
print(answer)
|
#input
n, k = map(int, input().split())
#output
mod = pow(10, 9) + 7
n_ = 4*10**5 + 5
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
if n <= k-1:
print(cmb(2*n-1, n))
else:
answer = 0
for m in range(k+1):
answer += cmb(n, m)*cmb(n-1, m) % mod
answer %= mod
print(answer)
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 565,029
| 565,028
|
u461454424
|
python
|
p02769
|
#input
n, k = map(int, input().split())
#output
mod = pow(10, 9) + 7
n_ = 2*10**5
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
if n <= k-1:
print(cmb(2*n-1, n))
else:
answer = 0
for m in range(k+1):
answer += cmb(n, m)*cmb(n-1, m) % mod
answer %= mod
print(answer)
|
#input
n, k = map(int, input().split())
#output
mod = pow(10, 9) + 7
n_ = 4*10**5 + 5
fun = [1]*(n_+1)
for i in range(1,n_+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
if n <= 0 or r < 0 or r > n: return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
if n <= k-1:
print(cmb(2*n-1, n))
else:
answer = 0
for m in range(k+1):
answer += cmb(n, m)*cmb(n-1, m) % mod
answer %= mod
print(answer)
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 565,030
| 565,028
|
u461454424
|
python
|
p02769
|
MOD = 10**9 + 7
inpl = lambda: list(map(int,input().split()))
def inv_mod(a, p=10**9+7):
p = abs(p)
a %= p
stack = []
p0 = p
while a > 1:
d, a, p = p//a, p%a, a
stack.append(d)
x, y = 1, 0
while stack:
d = stack.pop()
x, y = y-d*x, x
return x % p0
n, k = inpl()
if k >= n:
k = n-1
ans = 1
t = 1
print(k)
for i in range(k):
t *= (n-1-i)*(n-i)
t %= MOD
j = inv_mod(i+1)
t *= j*j % MOD
ans += t
ans %= MOD
print(ans)
|
MOD = 10**9 + 7
inpl = lambda: list(map(int,input().split()))
def inv_mod(a, p=10**9+7):
p = abs(p)
a %= p
stack = []
p0 = p
while a > 1:
d, a, p = p//a, p%a, a
stack.append(d)
x, y = 1, 0
while stack:
d = stack.pop()
x, y = y-d*x, x
return x % p0
n, k = inpl()
if k >= n:
k = n-1
ans = 1
t = 1
for i in range(k):
t *= (n-1-i)*(n-i)
t %= MOD
j = inv_mod(i+1)
t *= j*j % MOD
ans += t
ans %= MOD
print(ans)
|
[
"call.remove"
] | 565,141
| 565,142
|
u894258749
|
python
|
p02769
|
def xgcd(a, b):
x0, y0, x1, y1 = 1, 0, 0, 1
while b != 0:
q, a, b = a // b, b, a % b
x0, x1 = x1, x0 - q * x1
y0, y1 = y1, y0 - q * y1
return a, x0, y0
def invmod(a, m):
g, x, y = xgcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
n, k = map(int, input().split())
c = 10**9 + 7
if k >= n-1:
a = 2*n - 1
ans = a
temp = a
for i in range(1, n-1):
temp = temp*(a-i) % c
temp = temp*invmod(i+1, c) % c
print(temp)
else:
temp1 = n
temp2 = n-1
ans = 1 + (temp1 * temp2) % c
for i in range(1, k):
temp1 = temp1*(n-i) % c
temp2 = temp2*(n-i-1) % c
inv = invmod(i+1, c)
temp1 = temp1*inv % c
temp2 = temp2*inv % c
ans += temp1 * temp2 % c
print(ans)
|
def xgcd(a, b):
x0, y0, x1, y1 = 1, 0, 0, 1
while b != 0:
q, a, b = a // b, b, a % b
x0, x1 = x1, x0 - q * x1
y0, y1 = y1, y0 - q * y1
return a, x0, y0
def invmod(a, m):
g, x, y = xgcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
n, k = map(int, input().split())
c = 10**9 + 7
if k >= n-1:
a = 2*n - 1
ans = a
temp = a
for i in range(1, n-1):
temp = temp*(a-i) % c
temp = temp*invmod(i+1, c) % c
print(temp)
else:
temp1 = n
temp2 = n-1
ans = 1 + (temp1 * temp2) % c
for i in range(1, k):
temp1 = temp1*(n-i) % c
temp2 = temp2*(n-i-1) % c
inv = invmod(i+1, c)
temp1 = temp1*inv % c
temp2 = temp2*inv % c
ans += (temp1 * temp2) % c
print(ans%c)
|
[
"expression.operation.binary.add"
] | 565,147
| 565,148
|
u486065927
|
python
|
p02769
|
def modpow(a, n, mod):
res = 1
while n > 0:
if n & 1:
res = res * a % mod
a = a * a % mod
n >>= 1
return res
n, k = map(int, input().split())
MOD = 1000000007
if n-1 > k:
ans = 1
com1 = 1
com2 = 1
for i in range(k):
com1 = com1 * (n-1-i) * modpow(i+1, MOD-2, MOD) % MOD
com2 = com2 * (n-i) * modpow(i+1, MOD-2, MOD) % MOD
ans += com1 * com2
print(ans)
else:
ans = 1
for i in range(n-1):
ans = ans * (n*2-1-i) * modpow(i+1, MOD-2, MOD) % MOD
print(ans)
|
def modpow(a, n, mod):
res = 1
while n > 0:
if n & 1:
res = res * a % mod
a = a * a % mod
n >>= 1
return res
n, k = map(int, input().split())
MOD = 1000000007
if n-1 > k:
ans = 1
com1 = 1
com2 = 1
for i in range(k):
com1 = com1 * (n-1-i) * modpow(i+1, MOD-2, MOD) % MOD
com2 = com2 * (n-i) * modpow(i+1, MOD-2, MOD) % MOD
ans += com1 * com2
print(ans % MOD)
else:
ans = 1
for i in range(n-1):
ans = ans * (n*2-1-i) * modpow(i+1, MOD-2, MOD) % MOD
print(ans % MOD)
|
[
"expression.operation.binary.add"
] | 565,161
| 565,162
|
u137913818
|
python
|
p02769
|
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
mod = 10**9 + 7
N = 2 * 10**5 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
def modPow(a, n, mod):
if n == 1:
return a
if n % 2 == 1:
return (a * (modPow(a, n//2, mod) ** 2)) % mod
else:
return (modPow(a, n//2, mod) ** 2) % mod
def modInverse(a, p):
# calculates the modular multiplicative of a mod m.
# (assuming p is prime).
return modPow(a, p-2, p)
def modBinomial(n, k, p):
# calculates C(n,k) mod p (assuming p is prime).
numerator = 1 # n * (n-1) * ... * (n-k+1)
for i in range(k):
numerator = (numerator * (n-i)) % p
denominator = 1 # k!
for i in range(1, k+1):
denominator = (denominator * i) % p
# numerator / denominator mod p.
return (numerator * modInverse(denominator, p)) % p
n, k = map(int,(input().split()))
if n <= k:
print(modBinomial(2*n-1,n,mod))
exit()
ans = 0
if k % 2 == 0:
ans += 1
for i in range(1,k+1):
ans = (ans + cmb(n,i,mod) * cmb(n-1,i,mod)) % mod
print(ans)
|
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
mod = 10**9 + 7
N = 2 * 10**5 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
def modPow(a, n, mod):
if n == 1:
return a
if n % 2 == 1:
return (a * (modPow(a, n//2, mod) ** 2)) % mod
else:
return (modPow(a, n//2, mod) ** 2) % mod
def modInverse(a, p):
# calculates the modular multiplicative of a mod m.
# (assuming p is prime).
return modPow(a, p-2, p)
def modBinomial(n, k, p):
# calculates C(n,k) mod p (assuming p is prime).
numerator = 1 # n * (n-1) * ... * (n-k+1)
for i in range(k):
numerator = (numerator * (n-i)) % p
denominator = 1 # k!
for i in range(1, k+1):
denominator = (denominator * i) % p
# numerator / denominator mod p.
return (numerator * modInverse(denominator, p)) % p
n, k = map(int,(input().split()))
if n <= k:
print(modBinomial(2*n-1,n,mod))
exit()
ans = 0
if k != 1:
ans += 1
for i in range(1,k+1):
ans = (ans + cmb(n,i,mod) * cmb(n-1,i,mod)) % mod
print(ans)
|
[] | 565,171
| 565,172
|
u886633618
|
python
|
p02769
|
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2] != 1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
return [w[0],w[1]]
def mod_inv(a,mod):
x = extgcd(a,mod)[0]
return (mod + x % mod)% mod
def comb(n,k,mod):
c = 1
for i in range(k):
c = c*(n-i)%mod
c = c*mod_inv(i+1,mod)%mod
return c
n,k = map(int,input().split())
mod = 10**9+7
if k >= n-1:
print(comb(n+n-1,n,mod))
else:
ans = 0
c = 1
c2 = 1
for i in range(k):
c = c*(n-1-i)%mod
c2 = c2*(n-i)%mod
c = c*mod_inv(i+1,mod)%mod
c2 = c2*(mod_inv(i+1,mod))%mod
ans += c*c2
ans %= mod
if k % 2 == 0:
ans += 1
print(ans)
|
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2] != 1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
return [w[0],w[1]]
def mod_inv(a,mod):
x = extgcd(a,mod)[0]
return (mod + x % mod)% mod
def comb(n,k,mod):
c = 1
for i in range(k):
c = c*(n-i)%mod
c = c*mod_inv(i+1,mod)%mod
return c
n,k = map(int,input().split())
mod = 10**9+7
if k >= n-1:
print(comb(n+n-1,n,mod))
else:
ans = 0
c = 1
c2 = 1
for i in range(k):
c = c*(n-1-i)%mod
c2 = c2*(n-i)%mod
c = c*mod_inv(i+1,mod)%mod
c2 = c2*(mod_inv(i+1,mod))%mod
ans += c*c2
ans %= mod
if k > 1:
ans += 1
print(ans)
|
[] | 565,173
| 565,174
|
u918935103
|
python
|
p02769
|
#coding:utf-8
class Combination:
def __init__(self,N,P=10**9+7):
if N > 10**7:
self.fact = lambda x: x * self.fact(x-1) % P if x > 2 else 2
self.perm = lambda x, r: x * self.perm(x-1,r-1) % P if r > 0 else 1
self.cmb = lambda n,r: (self.perm(n,min(n-r,r)) * pow(self.fact(min(n-r,r)) ,P-2 ,P) % P) if r > 0 else 1
else:
self.__fact = [1] * (N+1)
self.__inv = [1] * (N+1)
self.__inv_fact = [1] * (N+1)
for i in range(2,N+1):
self.__fact[i] = self.__fact[i-1] * i % P
self.__inv[i] = - self.__inv[P%i] * (P//i) % P
self.__inv_fact[i] = self.__inv_fact[i-1] * self.__inv[i] % P
self.fact = lambda n: self.__fact[n]
self.perm = lambda n,r: self.__fact[n] * self.__inv_fact[n-r] % P
self.cmb = lambda n,r: (self.__fact[n] * self.__inv_fact[n-r] * self.__inv_fact[r] % P) if r > 0 else 1
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
from collections import deque
n,k = LMIIS()
cmb = Combination(2*n)
ans = 1
for i in range(1,min(n,k+1)):
ans = ans + cmb.cmb(n,i) * cmb.cmb(n-1,i) % MOD
print(ans)
if __name__ == '__main__':
main()
|
#coding:utf-8
class Combination:
def __init__(self,N,P=10**9+7):
if N > 10**7:
self.fact = lambda x: x * self.fact(x-1) % P if x > 2 else 2
self.perm = lambda x, r: x * self.perm(x-1,r-1) % P if r > 0 else 1
self.cmb = lambda n,r: (self.perm(n,min(n-r,r)) * pow(self.fact(min(n-r,r)) ,P-2 ,P) % P) if r > 0 else 1
else:
self.__fact = [1] * (N+1)
self.__inv = [1] * (N+1)
self.__inv_fact = [1] * (N+1)
for i in range(2,N+1):
self.__fact[i] = self.__fact[i-1] * i % P
self.__inv[i] = - self.__inv[P%i] * (P//i) % P
self.__inv_fact[i] = self.__inv_fact[i-1] * self.__inv[i] % P
self.fact = lambda n: self.__fact[n]
self.perm = lambda n,r: self.__fact[n] * self.__inv_fact[n-r] % P
self.cmb = lambda n,r: (self.__fact[n] * self.__inv_fact[n-r] * self.__inv_fact[r] % P) if r > 0 else 1
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
from collections import deque
n,k = LMIIS()
cmb = Combination(2*n)
ans = 1
for i in range(1,min(n,k+1)):
ans = (ans + cmb.cmb(n,i) * cmb.cmb(n-1,i)) % MOD
print(ans)
if __name__ == '__main__':
main()
|
[] | 565,044
| 565,045
|
u043048943
|
python
|
p02769
|
N, K = map(int, input().split())
MOD = 10**9 + 7
MAX_N = 10**6 + 5
fact = [0]*(MAX_N)
fact_inv = [0]*(MAX_N)
fact[0] = 1
for i in range(MAX_N-1):
fact[i+1] = fact[i]*(i+1) % MOD
fact_inv[-1] = pow(fact[-1], MOD-2, MOD)
for i in range(MAX_N-2, -1, -1):
fact_inv[i] = fact_inv[i+1]*(i+1) % MOD
def comb(n, k):
return fact[n]*fact_inv[k] % MOD * fact_inv[n-k] % MOD
if K >= N:
print(comb(2*N-1, N-1))
exit()
ans = 1
for i in range(1, K+1):
ans += comb(N, i)*comb(N-1, i) % MOD
print(ans)
|
N, K = map(int, input().split())
MOD = 10**9 + 7
MAX_N = 10**6 + 5
fact = [0]*(MAX_N)
fact_inv = [0]*(MAX_N)
fact[0] = 1
for i in range(MAX_N-1):
fact[i+1] = fact[i]*(i+1) % MOD
fact_inv[-1] = pow(fact[-1], MOD-2, MOD)
for i in range(MAX_N-2, -1, -1):
fact_inv[i] = fact_inv[i+1]*(i+1) % MOD
def comb(n, k):
return fact[n]*fact_inv[k] % MOD * fact_inv[n-k] % MOD
if K >= N:
print(comb(2*N-1, N-1))
exit()
ans = 1
for i in range(1, K+1):
ans += comb(N, i)*comb(N-1, i) % MOD
ans %= MOD
print(ans)
|
[] | 565,048
| 565,049
|
u503228842
|
python
|
p02769
|
n, k = map(int, input().split())
mod = 10 ** 9 + 7
def comb(n, r):
if n < r:return 0
if n < 0 or k < 0:return 0
return fa[n] * fi[r] % mod * fi[n - r] % mod
fa = [1] * (n + 1)
fi = [1] * (n + 1)
for i in range(1, n + 1):
fa[i] = fa[i - 1] * i % mod
fi[i] = pow(fa[i], mod - 2, mod)
ans = 0
for i in range(min(k, n - 1) + 1):
ans += comb(n, i) * comb(n - 1, i) % mod
print(ans)
|
n, k = map(int, input().split())
mod = 10 ** 9 + 7
def comb(n, r):
if n < r:return 0
if n < 0 or k < 0:return 0
return fa[n] * fi[r] % mod * fi[n - r] % mod
fa = [1] * (n + 1)
fi = [1] * (n + 1)
for i in range(1, n + 1):
fa[i] = fa[i - 1] * i % mod
fi[i] = pow(fa[i], mod - 2, mod)
ans = 0
for i in range(min(k, n - 1) + 1):
ans += comb(n, i) * comb(n - 1, i) % mod
print(ans % mod)
|
[
"expression.operation.binary.add"
] | 565,053
| 565,054
|
u923270446
|
python
|
p02769
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
M = 10**9+7
N = 4*10**5+3 # 必要なテーブルサイズ
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
n,k = map(int, input().split())
M = 10**9+7
if k<n:
ans = 0
for p in range(k+1):
ans += cmb(n,p,M) * cmb(n-1+p, p, M)
ans %= M
else:
ans = cmb(2*n-1,n,M)
print(ans)
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
M = 10**9+7
N = 4*10**5+3 # 必要なテーブルサイズ
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
n,k = map(int, input().split())
M = 10**9+7
if k<n:
ans = 0
for p in range(k+1):
ans += cmb(n,p,M) * cmb(n-1, p, M)
ans %= M
else:
ans = cmb(2*n-1,n,M)
print(ans)
|
[
"expression.operation.binary.remove"
] | 565,059
| 565,060
|
u535803878
|
python
|
p02769
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
M = 10**9+7
N = 4*10**5+3 # 必要なテーブルサイズ
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
n,k = map(int, input().split())
M = 10**9+7
if k<n:
ans = 0
for p in range(k+1):
ans += cmb(n,p,M) * cmb(n-1+p, p)
ans %= M
else:
ans = cmb(2*n-1,n,M)
print(ans)
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
M = 10**9+7
N = 4*10**5+3 # 必要なテーブルサイズ
def cmb(n, r, M):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r]) % M
g1 = [None] * (N+1) # 元テーブル
g2 = [None] * (N+1) #逆元テーブル
inverse = [None] * (N+1) #逆元テーブル計算用テーブル
g1[0] = g1[1] = g2[0] = g2[1] = 1
inverse[0], inverse[1] = [0, 1]
for i in range( 2, N + 1 ):
g1[i] = ( g1[i-1] * i ) % M
inverse[i] = ( -inverse[M % i] * (M//i) ) % M # ai+b==0 mod M <=> i==-b*a^(-1) <=> i^(-1)==-b^(-1)*aより
g2[i] = (g2[i-1] * inverse[i]) % M
n,k = map(int, input().split())
M = 10**9+7
if k<n:
ans = 0
for p in range(k+1):
ans += cmb(n,p,M) * cmb(n-1, p, M)
ans %= M
else:
ans = cmb(2*n-1,n,M)
print(ans)
|
[
"expression.operation.binary.remove",
"call.arguments.add"
] | 565,061
| 565,060
|
u535803878
|
python
|
p02769
|
N,K=map(int, input().split())
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
n= 2*10 ** 5 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p) 階乗のmod
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, n + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
#0の数
zeros=min(K, N-1)
ans=0
for i in range(1,zeros+1):
ans+=(cmb(N,i,p)*cmb(i+N-i-1, i, p))%p
#print(pow(N-i, i, p))
ans%=p
print(ans)
|
N,K=map(int, input().split())
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
n= 2*10 ** 5 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p) 階乗のmod
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, n + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
#0の数
zeros=min(K, N-1)
ans=1
for i in range(1,zeros+1):
ans+=(cmb(N,i,p)*cmb(i+N-i-1, i, p))%p
#print(pow(N-i, i, p))
ans%=p
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 565,066
| 565,067
|
u784022244
|
python
|
p02769
|
m=10**9+7;f=[1];n,k=map(int,input().split())
for i in range(10**6):f+=[f[i]*(i+1)%m]
def c(a,b):return f[a]*pow(f[b],m-2,m)*pow(f[a-b],m-2,m)%m
s=c(n*2-1,n-1)
if k>n-2:print(s)
else:print(s+(m-sum(c(n-1,i)*c(n,n-i)for i in range(n-1,k,-1))%m)%m)
|
m=10**9+7;f=[1];n,k=map(int,input().split())
for i in range(10**6):f+=[f[i]*(i+1)%m]
def c(a,b):return f[a]*pow(f[b],m-2,m)*pow(f[a-b],m-2,m)%m
s=c(n*2-1,n-1)
if k>n-2:print(s)
else:print((s+(m-sum(c(n-1,i)*c(n,n-i)for i in range(n-1,k,-1))%m))%m)
|
[
"call.arguments.change"
] | 565,068
| 565,069
|
u227082700
|
python
|
p02769
|
class Cmb:
def __init__(self, N, mod=10**9+7):
self.fact = [1,1]
self.fact_inv = [1,1]
self.inv = [0,1]
""" 階乗を保存する配列を作成 """
for i in range(2, N+1):
self.fact.append((self.fact[-1]*i) % mod)
self.inv.append((-self.inv[mod%i] * (mod//i))%mod)
self.fact_inv.append((self.fact_inv[-1]*self.inv[i])%mod)
""" 関数として使えるように、callで定義 """
def __call__(self, n, r, mod=10**9+7):
if (r<0) or (n<r):
return 0
r = min(r, n-r)
return self.fact[n] * self.fact_inv[r] * self.fact_inv[n-r] % mod
n,k = map(int,input().split())
mod = 10**9+7
c = Cmb(N=n)
ans = 0
for l in range(min(k+1, n)):
tmp = c(n,l)*c(n-1, n-l-1)
ans += tmp%mod
print(ans)
|
class Cmb:
def __init__(self, N, mod=10**9+7):
self.fact = [1,1]
self.fact_inv = [1,1]
self.inv = [0,1]
""" 階乗を保存する配列を作成 """
for i in range(2, N+1):
self.fact.append((self.fact[-1]*i) % mod)
self.inv.append((-self.inv[mod%i] * (mod//i))%mod)
self.fact_inv.append((self.fact_inv[-1]*self.inv[i])%mod)
""" 関数として使えるように、callで定義 """
def __call__(self, n, r, mod=10**9+7):
if (r<0) or (n<r):
return 0
r = min(r, n-r)
return self.fact[n] * self.fact_inv[r] * self.fact_inv[n-r] % mod
n,k = map(int,input().split())
mod = 10**9+7
c = Cmb(N=n)
ans = 0
for l in range(min(k+1, n)):
tmp = c(n,l)*c(n-1, n-l-1)
ans += tmp%mod
print(ans%mod)
|
[
"expression.operation.binary.add"
] | 565,074
| 565,075
|
u672475305
|
python
|
p02769
|
n, k = map( int, input().split() )
mod = 10 ** 9 + 7
numer = [ 1 ] * ( n + 1 )
demon = [ 1 ] * ( n + 1 )
for i in range( 1, n + 1 ):
numer[ i ] = numer[ i - 1 ] * i % mod
demon[ n ] = pow( numer[ n ], mod - 2, mod )
for i in range( n, 0, -1 ):
demon[ i - 1 ] = ( demon[ i ] * i ) % mod
def nCr( n, r ):
if r < 1:
return 1
return ( numer[ n ] * demon[ r ] % mod ) * demon[ n - r ] % mod
ans = 0
for i in range( min( k, n - 1) + 1 ):
ans = ( ans + nCr( n, i ) * nCr( n - 1, i - 1 )) % mod
print( ans )
|
n, k = map( int, input().split() )
mod = 10 ** 9 + 7
numer = [ 1 ] * ( n + 1 )
demon = [ 1 ] * ( n + 1 )
for i in range( 1, n + 1 ):
numer[ i ] = numer[ i - 1 ] * i % mod
demon[ n ] = pow( numer[ n ], mod - 2, mod )
for i in range( n, 0, -1 ):
demon[ i - 1 ] = ( demon[ i ] * i ) % mod
def nCr( n, r ):
if r < 1:
return 1
return ( numer[ n ] * demon[ r ] % mod ) * demon[ n - r ] % mod
ans = 0
for i in range( min( k, n - 1) + 1 ):
ans = ( ans + nCr( n, i ) * nCr( n - 1, i )) % mod
print( ans )
|
[
"expression.operation.binary.remove"
] | 565,079
| 565,080
|
u699008198
|
python
|
p02769
|
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
#文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
#文字列として取得
def ST(): return sys.stdin.readline().rstrip()
def LST(): return sys.stdin.readline().rstrip().split()
def LST2(N): return [sys.stdin.readline().rstrip().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)
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
mod = MOD #出力の制限
N = 5*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N,K = MI()
ans = cmb(2*N-1,N-1,MOD)
if K<N-1:
for i in range(K+1,N):
ans -= cmb(N,i,MOD)*cmb(N-1,i,MOD)
print(ans)
|
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
#文字列を一文字ずつ数字に変換、'5678'を[5,6,7,8]とできる
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
#文字列として取得
def ST(): return sys.stdin.readline().rstrip()
def LST(): return sys.stdin.readline().rstrip().split()
def LST2(N): return [sys.stdin.readline().rstrip().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)
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
mod = MOD #出力の制限
N = 5*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N,K = MI()
ans = cmb(2*N-1,N-1,MOD)
if K<N-1:
for i in range(K+1,N):
ans -= cmb(N,i,MOD)*cmb(N-1,i,MOD)
print(ans%MOD)
|
[
"expression.operation.binary.add"
] | 565,081
| 565,082
|
u380995377
|
python
|
p02769
|
n, k = map(int,input().split())
mod = 10**9+7
#nCrをmodで割った余りを求める。Nに最大値を入れて使用。
N = n
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def cmb(n,r,mod):
if r<0 or r>n :
return 0
r = min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
for i in range(2,N+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ans = 0
for i in range(min(n-1,k)+1):
di = cmb(n,i,mod)*cmb(n-1,i,mod)%mod
print(di)
ans = (ans+di)%mod
print(ans)
|
n, k = map(int,input().split())
mod = 10**9+7
#nCrをmodで割った余りを求める。Nに最大値を入れて使用。
N = n
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def cmb(n,r,mod):
if r<0 or r>n :
return 0
r = min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
for i in range(2,N+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ans = 0
for i in range(min(n-1,k)+1):
di = cmb(n,i,mod)*cmb(n-1,i,mod)%mod
ans = (ans+di)%mod
print(ans)
|
[
"call.remove"
] | 565,084
| 565,085
|
u169350228
|
python
|
p02769
|
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10 ** 9 + 7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
if n < r:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n + 1):
fac.append(fac[i - 1] * i % self.mod)
facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n + 1)
modinv[1] = 1
for i in range(2, n + 1):
modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod
return modinv
def main():
N, K = map(int, input().split())
comb = Combination(n_max=10 ** 5 * 2 + 10)
if N <= K:
ans = comb(2 * N - 1, N)
else:
if K == 1:
ans = comb(N, 1) * comb(N - 1, 1)
else:
ans = 0
# mはゼロとなる数
for m in range(K + 1):
ans += comb(N, m) * comb(N - 1, m)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
|
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10 ** 9 + 7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
if n < r:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n + 1):
fac.append(fac[i - 1] * i % self.mod)
facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n + 1)
modinv[1] = 1
for i in range(2, n + 1):
modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod
return modinv
def main():
N, K = map(int, input().split())
comb = Combination(n_max=10 ** 5 * 4 + 10)
if N <= K:
ans = comb(2 * N - 1, N)
else:
if K == 1:
ans = comb(N, 1) * comb(N - 1, 1)
else:
ans = 0
# mはゼロとなる数
for m in range(K + 1):
ans += comb(N, m) * comb(N - 1, m)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
|
[
"literal.number.integer.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 565,097
| 565,098
|
u346812984
|
python
|
p02769
|
# -*- coding: utf-8 -*-
class FactMod():
'''
modの値が素数の時のfactと組み合わせを求める
フェルマーの小定理を用いているため、modが素数以外の時は使えない
'''
def __init__(self, n, mod):
'''
コンストラクタ
f:nまでの i!の値を 配列に入れる
inv: (i!)^-1 の値を配列に入れる
'''
self.mod = mod
self.f = [1]*(n+1)
for i in range(1, n+1):
self.f[i] = self.f[i-1]*i % mod
self.inv = [pow(self.f[-1], mod-2, mod)]
for i in range(1, n+1)[::-1]:
self.inv.append(self.inv[-1]*i % mod)
self.inv.reverse()
def fact(self, n):
'''
n!の値を返す
'''
return self.f[n]
def comb(self, n, r):
'''
nCrの値を返す
'''
ret = self.f[n] * self.inv[n-r]*self.inv[r]
ret %= self.mod
return ret
def perm(self, n, r):
"""
nPrの値を返す
"""
ret = self.f[n] * self.inv[n-r]
ret %= self.mod
return ret
N,K = map(int,input().split())
ans=0
MOD=10**9+7
F= FactMod(N,MOD)
for k in range(0,min(N,K+1)):
ans += F.comb(N,k)*F.comb(N-1,k)%MOD
print(ans)
|
# -*- coding: utf-8 -*-
class FactMod():
'''
modの値が素数の時のfactと組み合わせを求める
フェルマーの小定理を用いているため、modが素数以外の時は使えない
'''
def __init__(self, n, mod):
'''
コンストラクタ
f:nまでの i!の値を 配列に入れる
inv: (i!)^-1 の値を配列に入れる
'''
self.mod = mod
self.f = [1]*(n+1)
for i in range(1, n+1):
self.f[i] = self.f[i-1]*i % mod
self.inv = [pow(self.f[-1], mod-2, mod)]
for i in range(1, n+1)[::-1]:
self.inv.append(self.inv[-1]*i % mod)
self.inv.reverse()
def fact(self, n):
'''
n!の値を返す
'''
return self.f[n]
def comb(self, n, r):
'''
nCrの値を返す
'''
ret = self.f[n] * self.inv[n-r]*self.inv[r]
ret %= self.mod
return ret
def perm(self, n, r):
"""
nPrの値を返す
"""
ret = self.f[n] * self.inv[n-r]
ret %= self.mod
return ret
N,K = map(int,input().split())
ans=0
MOD=10**9+7
F= FactMod(N,MOD)
for k in range(0,min(N,K+1)):
ans += F.comb(N,k)*F.comb(N-1,k)%MOD
ans%=MOD
print(ans)
|
[] | 565,133
| 565,134
|
u375616706
|
python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.