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 8
values |
|---|---|---|---|---|---|---|---|
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
|
p02768
|
def modpow(a,b,mod):
ans=1
a=a%mod
while b>0:
if b%2==1:
ans=(ans*a)%mod
a=(a**2)%mod
b=b//2
return ans
N,A,B=map(int,input().split())
ans=modpow(2,N,10**9+7)-1
c=1
d=1
for i in range(A):
c=(c*(N-i))%(10**9+7)
for i in range(A):
d=(d*(i+1))%(10**9+7)
d=modpow(d,10**9+5,10**9+7)
ans-=(c*d)%(10**9+7)
c=1
d=1
for i in range(B):
c=(c*(N-i))%(10**9+7)
for i in range(B):
d=(d*(i+1))%(10**9+7)
d=modpow(d,10**9+5,10**9+7)
ans-=(c*d)%(10**9+7)
if ans<0:
ans+=10**9+7
print(ans)
|
def modpow(a,b,mod):
ans=1
a=a%mod
while b>0:
if b%2==1:
ans=(ans*a)%mod
a=(a**2)%mod
b=b//2
return ans
N,A,B=map(int,input().split())
ans=modpow(2,N,10**9+7)-1
c=1
d=1
for i in range(A):
c=(c*(N-i))%(10**9+7)
for i in range(A):
d=(d*(i+1))%(10**9+7)
d=modpow(d,10**9+5,10**9+7)
ans-=(c*d)%(10**9+7)
c=1
d=1
for i in range(B):
c=(c*(N-i))%(10**9+7)
for i in range(B):
d=(d*(i+1))%(10**9+7)
d=modpow(d,10**9+5,10**9+7)
ans-=(c*d)%(10**9+7)
while ans<0:
ans+=10**9+7
print(ans)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 565,212
| 565,213
|
u444082822
|
python
|
p02769
|
import sys
input = sys.stdin.readline
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 = 10 ** 5+15 # N は必要分だけ用意する
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)
def solve():
n,k = (int(i) for i in input().split())
mod = 10**9+7
if n-k <= 1:
#任意の部屋に移動可能
comba = 1
inva = 1
for i in range(1,n+1):
comba *= (n+i-1)
inva *= i
comba %= mod
inva %= mod
comba *= pow(inva,10**9+5,mod)
comba %= mod
print(comba)
else:
#n <= 2**10^5
#k <= 2**10^5
ans = 0
for i in range(0,k+1):
ans += cmb(n,i,mod)*cmb(n-1,i,mod)
ans %= mod
print(ans)
solve()
|
import sys
input = sys.stdin.readline
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+2 # N は必要分だけ用意する
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)
def solve():
n,k = (int(i) for i in input().split())
mod = 10**9+7
if n-k <= 1:
#任意の部屋に移動可能
comba = 1
inva = 1
for i in range(1,n+1):
comba *= (n+i-1)
inva *= i
comba %= mod
inva %= mod
comba *= pow(inva,10**9+5,mod)
comba %= mod
print(comba)
else:
#n <= 2**10^5
#k <= 2**10^5
ans = 0
for i in range(0,k+1):
ans += cmb(n,i,mod)*cmb(n-1,i,mod)
ans %= mod
print(ans)
solve()
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 565,224
| 565,225
|
u950708010
|
python
|
p02769
|
n,k=map(int,input().split())
mod=10**9+7
n_max=4*(10**5+1)
F,FI=[0]*(n_max+1),[0]*(n_max+1)
F[0],FI[0]=1,1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
FI[n_max-1]=pow(F[n_max-1],mod-2,mod)
for i in reversed(range(n_max-1)):
FI[i]=(FI[i+1]*(i+1))%mod
def comb(x,y):
return (F[x]*FI[x-y]*FI[y])%mod
if k>=n-1:
print(comb(2*n-1,n))
else:
ans=1
for i in range(k):
ans=ans+(comb(n,i+1)*comb(n-1,i+1))%mod
print(ans)
|
n,k=map(int,input().split())
mod=10**9+7
n_max=4*(10**5+1)
F,FI=[0]*(n_max+1),[0]*(n_max+1)
F[0],FI[0]=1,1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
FI[n_max-1]=pow(F[n_max-1],mod-2,mod)
for i in reversed(range(n_max-1)):
FI[i]=(FI[i+1]*(i+1))%mod
def comb(x,y):
return (F[x]*FI[x-y]*FI[y])%mod
if k>=n-1:
print(comb(2*n-1,n))
else:
ans=1
for i in range(k):
ans=(ans+comb(n,i+1)*comb(n-1,i+1))%mod
print(ans)
|
[] | 565,238
| 565,239
|
u969190727
|
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 = 10**6
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 = map(int, input().split())
MOD = 10**9+7
n = max(N,K)
ans = 0
for i in range(max(1,N-n),N+1):
m = cmb(N,i,MOD)
m *= cmb(N-1,i-1, MOD)
ans += m
ans %= 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 = 10**6
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 = map(int, input().split())
MOD = 10**9+7
n = min(N,K)
ans = 0
for i in range(max(1,N-n),N+1):
m = cmb(N,i,MOD)
m *= cmb(N-1,i-1, MOD)
ans += m
ans %= MOD
print(ans)
|
[
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 565,248
| 565,249
|
u476604182
|
python
|
p02769
|
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
def inv(x):
return pow(x, MOD-2, MOD)
def nPk(n,k):
# x=1
# for a in range(n-k+1, n+1):
# x = x * a % MOD
# return x
return kaijo[n] * inv(kaijo[k-1]) % MOD
def nCk(n,k):
return nPk(n,k) * inv(kaijo[k])
MOD = 10**9+7
kaijo = [0] * 200005
kaijo[0] = 1
for i in range(1, len(kaijo)):
kaijo[i] = kaijo[i-1] * i % MOD
n,k = get_nums_l()
if k >= n-1:
print(nCk(n+n-1, n) % MOD)
exit()
# 0人の部屋=zがk以下であるような人数の並べ方の個数
# z=0 1
# z=1 nC1 * (n-1)**1
# z=2 nC2 * (n-2)**2
# z=3 nC3 * (n-3)**3
ans = 1
for z in range(1,k+1):
ans += nCk(n,z) * nCk(n-1, z) % MOD
print(ans%MOD)
|
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
def inv(x):
return pow(x, MOD-2, MOD)
def nPk(n,k):
return kaijo[n] * inv(kaijo[n-k]) % MOD
def nCk(n,k):
return nPk(n,k) * inv(kaijo[k])
MOD = 10**9+7
kaijo = [0] * 400020
kaijo[0] = 1
for i in range(1, len(kaijo)):
kaijo[i] = kaijo[i-1] * i % MOD
n,k = get_nums_l()
if k >= n-1:
print(nCk(n+n-1, n) % MOD)
exit()
# 0人の部屋=zがk以下であるような人数の並べ方の個数
# z=0 1
# z=1 nC1 * (n-1)H1
# z=2 nC2 * (n-2)H2
# z=3 nC3 * (n-3)H3
# z nCz * (n-z)Hz
ans = 1
for z in range(1,k+1):
ans += nCk(n,z) * nCk(n-1, z)
print(ans%MOD)
|
[
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"identifier.replace.add",
"literal.replace.remove",
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.remove"
] | 565,262
| 565,263
|
u407160848
|
python
|
p02769
|
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
def inv(x):
return pow(x, MOD-2, MOD)
def nPk(n,k):
# x=1
# for a in range(n-k+1, n+1):
# x = x * a % MOD
# return x
return kaijo[n] * inv(kaijo[k-1]) % MOD
def nCk(n,k):
return nPk(n,k) * inv(kaijo[k])
MOD = 10**9+7
kaijo = [0] * 200005
kaijo[0] = 1
for i in range(1, len(kaijo)):
kaijo[i] = kaijo[i-1] * i % MOD
n,k = get_nums_l()
if k >= n-1:
print(nCk(n+n-1, n) % MOD)
exit()
# 0人の部屋=zがk以下であるような人数の並べ方の個数
# z=0 1
# z=1 nC1 * (n-1)**1
# z=2 nC2 * (n-2)**2
# z=3 nC3 * (n-3)**3
ans = 1
for z in range(1,k+1):
ans += nCk(n,z) * nCk(n-1, z) % MOD
print(ans%MOD)
|
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
def inv(x):
return pow(x, MOD-2, MOD)
def nPk(n,k):
# x=1
# for a in range(n-k+1, n+1):
# x = x * a % MOD
# return x
return kaijo[n] * inv(kaijo[n-k]) % MOD
def nCk(n,k):
return nPk(n,k) * inv(kaijo[k])
MOD = 10**9+7
kaijo = [0] * 400020
kaijo[0] = 1
for i in range(1, len(kaijo)):
kaijo[i] = kaijo[i-1] * i % MOD
n,k = get_nums_l()
if k >= n-1:
print(nCk(n+n-1, n) % MOD)
exit()
# 0人の部屋=zがk以下であるような人数の並べ方の個数
# z=0 1
# z=1 nC1 * (n-1)**1
# z=2 nC2 * (n-2)**2
# z=3 nC3 * (n-3)**3
ans = 1
for z in range(1,k+1):
ans += nCk(n,z) * nCk(n-1, z)
print(ans%MOD)
|
[
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"identifier.replace.add",
"literal.replace.remove",
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.remove"
] | 565,262
| 565,264
|
u407160848
|
python
|
p02769
|
mod=10**9+7
n,k=map(int,input().split())
ans=1-k%2
coef1=n
coef2=n-1
for i in range(1,min(k+1,n)):
tmp=1
tmp*=coef1
tmp%=mod
tmp*=coef2
tmp%=mod
ans+=tmp
ans%=mod
coef1*=n-i
coef1%=mod
coef1*=pow(i+1,mod-2,mod)
coef1%=mod
coef2*=n-1-i
coef2%=mod
coef2*=pow(i+1,mod-2,mod)
coef2%=mod
print(ans)
|
mod=10**9+7
n,k=map(int,input().split())
ans=1
coef1=n
coef2=n-1
for i in range(1,min(k+1,n)):
tmp=1
tmp*=coef1
tmp%=mod
tmp*=coef2
tmp%=mod
ans+=tmp
ans%=mod
coef1*=n-i
coef1%=mod
coef1*=pow(i+1,mod-2,mod)
coef1%=mod
coef2*=n-1-i
coef2%=mod
coef2*=pow(i+1,mod-2,mod)
coef2%=mod
print(ans)
|
[
"expression.operation.binary.remove"
] | 565,267
| 565,268
|
u163320134
|
python
|
p02769
|
def factorial(n, mod=10**9+7):
a = 1
for i in range(1,n+1):
a = a * i % mod
return a
def power(n, r, mod=10**9+7):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
def comb(n, k, mod=10**9+7):
if n < k or k < 0:
result = 0
else:
a = factorial(n, mod=mod)
b = factorial(k, mod=mod)
c = factorial(n-k, mod=mod)
result = (a * power(b, mod-2, mod=mod) * power(c, mod-2, mod=mod)) % mod
return result
n, k = map(int, input().split())
MOD = 10**9 + 7
if k >= n:
print(comb(2*n-1, n))
quit()
def power(n, r, mod=10**9+7):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
fl = [-1]*(k+1)
fl[0] = 1
def f(i):
global fl
if fl[i] > 0: return fl[i]
else:
if i <= n//2:
res = f(i-1)*(n-i+1)*(n-i)
t = power(i, MOD-2)
res *= t
res %= MOD
res *= t
res %= MOD
fl[i] = res
return res
else:
res = f(n-i) * (n-i)
res *= power(i, MOD-2)
res %= MOD
fl[i] = res
return res
if k <= n//2:
fl = [-1]*(k+1)
fl[0] = 1
def f(i):
global fl
if fl[i] > 0: return fl[i]
else:
res = f(i-1)*(n-i+1)*(n-i)
t = power(i, MOD-2)
res *= t
res %= MOD
res *= t
res %= MOD
fl[i] = res
return res
ans = 0
for i in range(k+1):
ans += f(i)
ans %= MOD
else:
fl = [-1]*(n+1)
fl[0] = comb(n, k) * comb(n-1, k) % MOD
def f(i):
global fl
if fl[i-k] > 0: return fl[i-k]
else:
res = f(i-1)*(n-i+1)*(n-i)
t = power(i, MOD-2)
res *= t
res %= MOD
res *= t
res %= MOD
fl[i-k] = res
return res
ans = 0
for i in range(k+1, n+1):
ans += f(i)
ans %= MOD
ans = comb(2*n-1, n) - ans
ans %= M0D
print(ans % MOD)
|
def factorial(n, mod=10**9+7):
a = 1
for i in range(1,n+1):
a = a * i % mod
return a
def power(n, r, mod=10**9+7):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
def comb(n, k, mod=10**9+7):
if n < k or k < 0:
result = 0
else:
a = factorial(n, mod=mod)
b = factorial(k, mod=mod)
c = factorial(n-k, mod=mod)
result = (a * power(b, mod-2, mod=mod) * power(c, mod-2, mod=mod)) % mod
return result
n, k = map(int, input().split())
MOD = 10**9 + 7
if k >= n:
print(comb(2*n-1, n))
quit()
def power(n, r, mod=10**9+7):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
fl = [-1]*(k+1)
fl[0] = 1
def f(i):
global fl
if fl[i] > 0: return fl[i]
else:
if i <= n//2:
res = f(i-1)*(n-i+1)*(n-i)
t = power(i, MOD-2)
res *= t
res %= MOD
res *= t
res %= MOD
fl[i] = res
return res
else:
res = f(n-i) * (n-i)
res *= power(i, MOD-2)
res %= MOD
fl[i] = res
return res
if k <= n//2:
fl = [-1]*(k+1)
fl[0] = 1
def f(i):
global fl
if fl[i] > 0: return fl[i]
else:
res = f(i-1)*(n-i+1)*(n-i)
t = power(i, MOD-2)
res *= t
res %= MOD
res *= t
res %= MOD
fl[i] = res
return res
ans = 0
for i in range(k+1):
ans += f(i)
ans %= MOD
else:
fl = [-1]*(n+1)
fl[0] = comb(n, k) * comb(n-1, k) % MOD
def f(i):
global fl
if fl[i-k] > 0: return fl[i-k]
else:
res = f(i-1)*(n-i+1)*(n-i)
t = power(i, MOD-2)
res *= t
res %= MOD
res *= t
res %= MOD
fl[i-k] = res
return res
ans = 0
for i in range(k+1, n+1):
ans += f(i)
ans %= MOD
ans = comb(2*n-1, n) - ans
ans %= MOD
print(ans % MOD)
|
[
"identifier.change"
] | 565,275
| 565,276
|
u922449550
|
python
|
p02769
|
import sys
n, k = map(int, input().split())
mod = 10 ** 9 + 7
f = [1]
for i in range(1,2*n+1):
f.append((f[-1] * i) % mod)
def comb(n,r):
return f[n] * (pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod) % mod
ans = comb(2*n-1, n)
if n-1 <= k:
print(ans)
sys.exit()
j = 0
for i in range(k+1,n)[::-1]:
ans -= (comb(n,n-i) * comb(i+j,j)) % mod
ans % mod
j += 1
print(ans)
|
import sys
n, k = map(int, input().split())
mod = 10 ** 9 + 7
f = [1]
for i in range(1,2*n+1):
f.append((f[-1] * i) % mod)
def comb(n,r):
return f[n] * (pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod) % mod
ans = comb(2*n-1, n)
if n-1 <= k:
print(ans)
sys.exit()
j = 0
for i in range(k+1,n)[::-1]:
ans -= (comb(n,n-i) * comb(n-1,j)) % mod
ans %= mod
j += 1
print(ans)
|
[
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 565,286
| 565,287
|
u513434790
|
python
|
p02769
|
import sys
n, k = map(int, input().split())
mod = 10 ** 9 + 7
f = [1]
for i in range(1,2*n+1):
f.append((f[-1] * i) % mod)
def comb(n,r):
return f[n] * (pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod) % mod
ans = comb(2*n-1, n)
if n-1 <= k:
print(ans)
sys.exit()
j = 0
for i in range(k+1,n)[::-1]:
ans -= (comb(n,n-i) * comb(i+j,j)) % mod
ans % mod
j += 1
print(ans)
|
import sys
n, k = map(int, input().split())
mod = 10 ** 9 + 7
f = [1]
for i in range(1,2*n+1):
f.append((f[-1] * i) % mod)
def comb(n,r):
return f[n] * (pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod) % mod
ans = comb(2*n-1, n)
if n-1 <= k:
print(ans)
sys.exit()
j = 0
for i in range(k+1,n)[::-1]:
ans -= (comb(n,n-i) * comb(i+j,j)) % mod
ans %= mod
j += 1
print(ans)
|
[
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 565,286
| 565,288
|
u513434790
|
python
|
p02769
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def C(n,r):
return fact[n]*pow(fact[n-r],mod-2,mod)*pow(fact[r],mod-2,mod)%mod
n,k = LI()
fact = [1]*(n+1)
for i in range(1,n+1):
fact[i] = i*fact[i-1]
fact[i] %= mod
ans = 0
for i in range(min(n+1,k+1)):
ans += C(n,i)*C(n-1,n-i-1) % mod
ans %= mod
print(ans)
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def C(n,r):
return fact[n] * pow(fact[n-r],mod-2,mod) * pow(fact[r],mod-2,mod) % mod
n,k = LI()
fact = [1]*(n+1)
for i in range(1,n+1):
fact[i] = i*fact[i-1]
fact[i] %= mod
ans = 0
for i in range(min(n,k+1)):
ans += C(n,i) * C(n-1,n-i-1)
ans %= mod
print(ans)
|
[
"expression.operation.binary.remove"
] | 565,289
| 565,290
|
u191874006
|
python
|
p02769
|
n,k = map(int, input().split())
mod = 10**9 + 7
ans = 0
lim = 2*(10**5) + 5
mothers = [1] * lim
mothers_inv = [1] * lim
for i in range(1, lim):
mothers[i] = mothers[i-1] * i % mod
mothers_inv[i] = pow(mothers[i], mod-2, mod)
def calc(n,k):
child = mothers[n] * mothers_inv[n-k] % mod
mother_inv = mothers_inv[k]
return((child * mother_inv)%mod)
def calc2(n,k):
child = 1
for i in range(n, n-k, -1):
child = child * i % mod
mother_inv = mothers_inv[k]
return((child * mother_inv)%mod)
if( n <= k+1):
ans = calc2(2*n-1, n-1)
print(ans)
exit()
ans = calc(2*n-1, n-1)
tmp = 0
for i in range(1,n-k):
if(i ==1):
c1 = 1
else:
c1 = calc(n-1, i-1)
c2 = calc(n, i)
ans = (ans - c1 * c2)%mod
print(ans)
|
n,k = map(int, input().split())
mod = 10**9 + 7
ans = 0
lim = 2*(10**5) + 5
mothers = [1] * lim
mothers_inv = [1] * lim
for i in range(1, lim):
mothers[i] = mothers[i-1] * i % mod
mothers_inv[i] = pow(mothers[i], mod-2, mod)
def calc(n,k):
child = mothers[n] * mothers_inv[n-k] % mod
mother_inv = mothers_inv[k]
return((child * mother_inv)%mod)
def calc2(n,k):
child = 1
for i in range(n, n-k, -1):
child = child * i % mod
mother_inv = mothers_inv[k]
return((child * mother_inv)%mod)
if( n <= k+1):
ans = calc2(2*n-1, n-1)
print(ans)
exit()
ans = calc2(2*n-1, n-1)
for i in range(1,n-k):
if(i ==1):
c1 = 1
else:
c1 = calc(n-1, i-1)
c2 = calc(n, i)
ans = (ans - c1 * c2)%mod
print(ans)
|
[
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 565,291
| 565,292
|
u490642448
|
python
|
p02771
|
a,b,c = map(int,input().split())
if a==b and b!=c:
print('Yes')
elif a==c and a!=b:
print('Yes')
elif b==c and b!=c:print('Yes')
else:print('No')
|
a,b,c = map(int,input().split())
if a==b and b!=c:
print('Yes')
elif a==c and a!=b:
print('Yes')
elif b==c and b!=a:print('Yes')
else:print('No')
|
[
"identifier.change",
"control_flow.branch.if.condition.change"
] | 565,297
| 565,298
|
u773440446
|
python
|
p02771
|
a, b, c = input().split()
ans = "No"
if (a == b and a != c) or (a == c and a != b) or (b == c and b != c):
ans = "Yes"
print(ans)
|
a, b, c = input().split()
ans = "No"
if (a == b and a != c) or (a == c and a != b) or (b == c and a != b):
ans = "Yes"
print(ans)
|
[
"identifier.change",
"control_flow.branch.if.condition.change"
] | 565,299
| 565,300
|
u544272759
|
python
|
p02771
|
a,b,c=input().split()
if a==b==c:
print('No')
elif a!=b!=c:
print('No')
else:
print('Yes')
|
a,b,c=input().split()
if a==b==c:
print('No')
elif a!=b!=c!=a:
print('No')
else:
print('Yes')
|
[
"control_flow.branch.if.condition.change"
] | 565,309
| 565,310
|
u539367121
|
python
|
p02771
|
A = input().split()
a = A.count(A[0])
b = A.count(A[1])
c = A.count(A[2])
if a == 1 or b == 1 or c == 1:
print("Yes")
else:
print("No")
|
A = input().split()
a = A.count(A[0])
b = A.count(A[1])
c = A.count(A[2])
if a == 2 or b == 2 or c == 2:
print("Yes")
else:
print("No")
|
[
"literal.number.integer.change",
"control_flow.branch.if.condition.change"
] | 565,313
| 565,314
|
u344888046
|
python
|
p02771
|
i = map(int,input().split())
if (i[0] == i[1] and i[0] != i[2]) or (i[0] == i[2] and i[0] != i[1]) or (i[1] == i[2] and i[1] != i[0]):
print("Yes")
else:
print("No")
|
i = list(map(int,input().split()))
if (i[0] == i[1] and i[0] != i[2]) or (i[0] == i[2] and i[0] != i[1]) or (i[1] == i[2] and i[1] != i[0]):
print("Yes")
else:
print("No")
|
[
"call.add",
"call.arguments.change"
] | 565,315
| 565,316
|
u763628696
|
python
|
p02771
|
i = map(int,input(),split())
if (i[0] == i[1] and i[0] != i[2]) or (i[0] == i[2] and i[0] != i[1]) or (i[1] == i[2] and i[1] != i[0]):
print("Yes")
else:
print("No")
|
i = list(map(int,input().split()))
if (i[0] == i[1] and i[0] != i[2]) or (i[0] == i[2] and i[0] != i[1]) or (i[1] == i[2] and i[1] != i[0]):
print("Yes")
else:
print("No")
|
[
"call.add",
"assignment.value.change",
"call.arguments.change"
] | 565,317
| 565,316
|
u763628696
|
python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.