input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
---|---|---|
n, k = list(map(int, input().split()))
a_list = list(map(int, input().split()))
a_list.sort()
import math
def cmb(n, r):
o = math.factorial(n)
u = math.factorial(r) * math.factorial(n - r)
return o // u
max_val = 0
min_val = 0
val = int(cmb(n - 1, k - 1))
for i in range(n - k + 1):
if i != 0:
val = (val * (n - i - k + 1) // (n - i))
max_val = (max_val + (((a_list[-(i + 1)]) * val))) % (10 ** 9 + 7)
min_val = (min_val + ((a_list[i]) * val)) % (10 ** 9 + 7)
print((int((max_val - min_val) % (10 ** 9 + 7))))
|
n, k = list(map(int, input().split()))
a_list = list(map(int, input().split()))
a_list.sort()
mod = 10 ** 9 + 7
f_list = [1]
for i in range(1,n+1):
f_list.append((f_list[-1] * i) % mod)
def comb(n,r):
return f_list[n] * (pow(f_list[r], mod-2, mod) * pow(f_list[n-r], mod-2, mod) % mod) % mod
max_val = 0
min_val = 0
for i in range(n - k + 1):
val = comb(n - i - 1, k - 1)
max_val = (max_val + (((a_list[-(i + 1)]) * val))) % (10 ** 9 + 7)
min_val = (min_val + ((a_list[i]) * val)) % (10 ** 9 + 7)
print((int((max_val - min_val) % (10 ** 9 + 7))))
|
p02804
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
M = 10**9+7
def pow(a,b,M):
if b == 0:
return 1
elif b % 2 == 0:
return pow((a**2)%M,b//2,M) % M
else:
return ((a % M) * pow((a**2)%M,b//2,M)) % M
def inv(a,p):
return pow(a,p-2,p)
def comb(n,k,M):
nume,deno = 1,1
for i in range(1,k+1):
nume = (nume * (n - i + 1)) % M
deno = (deno * i) % M
return (nume * inv(deno,M)) % M
ans = 0
for i in range(N-K+1):
ans = (ans + comb(N-1-i,K-1,M)*((A[N-1-i]-A[i]) % M)) % M
print(ans)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
M = 10**9+7
def pow(a,b,M):
if b == 0:
return 1
elif b % 2 == 0:
return pow((a**2)%M,b//2,M) % M
else:
return ((a % M) * pow((a**2)%M,b//2,M)) % M
def inv(a,p):
return pow(a,p-2,p)
ans,comb = 0,1
#i番目ではcomb = (K-1-i)_C_(K-1)
#max,min以外での選ぶ個数は常にK-1であることに注目すればcomb関数はいらなかった
for i in range(N-K+1):
if i > 0:
comb = (comb * (K-1+i) * inv(i,M)) % M
ans = (ans + comb*((A[K-1+i]-A[N-K-i]) % M)) % M
print(ans)
|
p02804
|
def pow(a,b,M):
if b == 0:
return 1
elif b % 2 == 0:
return pow((a**2)%M,b//2,M) % M
else:
return ((a % M) * pow((a**2)%M,b//2,M)) % M
def cmb(a,b,c):
b = min(b,a-b)
num = 1
for i in range(b):
num = num*(a-i) % c
den = 1
for i in range(b):
den = den*(i+1) % c
return num * pow(den,c-2,c) % c
mod = 10**9+7
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort()
ans = 0
c = cmb(n-1,k-1,mod)
if k == 1:
print((0))
exit()
for i in range(n-k+1):
ans -= a[i] * c
ans += a[-i-1] * c
ans %= mod
c = c * (n-k-i) * pow(n-i-1,mod-2,mod)
if ans < 0:
ans += mod
print(ans)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
M = 10**9+7
def inv(a,p):
return pow(a,p-2,p)
ans,comb = 0,1
#i番目ではcomb = (K-1-i)_C_(K-1)
#max,min以外での選ぶ個数は常にK-1であることに注目すればcomb関数はいらなかった
for i in range(N-K+1):
if i > 0:
comb = (comb * (K-1+i) * inv(i,M)) % M
ans = (ans + comb*((A[K-1+i]-A[N-K-i]) % M)) % M
print(ans)
|
p02804
|
n, k = [int(i) for i in input().split()]
al = [int(i) for i in input().split()]
al.sort()
mod = 10 ** 9 + 7
kai_dp={}
def kai(x, p=mod):
if x in kai_dp:
return kai_dp[x]
a = 1
for i in range(1, x + 1):
a *= i
a %= p
kai_dp[x]=a
return a
def comb(a, b, p=mod):
if a < 0 or b < 0:
return 0
elif a < b:
return 0
c = 1
c *= kai(a, p)
c *= pow(kai(b, p), p - 2, p)
c *= pow(kai(a - b, p), p - 2, p)
return c % p
ans = 0
for i in range(k - 1, n):
ans += al[i] * comb(i,k-1)
ans %= mod
al = list(reversed(al))
for i in range(k - 1, n):
ans -= al[i] * comb(i, k-1)
ans %= mod
print(ans)
|
n, k = [int(i) for i in input().split()]
al = [int(i) for i in input().split()]
al.sort()
mod = 10 ** 9 + 7
kai = [1]
for i in range(1, n + 1):
kai.append(kai[-1]*i%mod)
def comb(a, b, p=mod):
if a < 0 or b < 0:
return 0
elif a < b:
return 0
c = 1
c *= kai[a]
c *= pow(kai[b], p - 2, p)
c *= pow(kai[a - b], p - 2, p)
return c % p
ans = 0
for i in range(k - 1, n):
ans += al[i] * comb(i,k-1)
ans %= mod
al = list(reversed(al))
for i in range(k - 1, n):
ans -= al[i] * comb(i, k-1)
ans %= mod
print(ans)
|
p02804
|
N,K=list(map(int, input().split()))
AA=list(map(int, input().split()))
A=sorted(AA)
B=sorted(AA)[::-1]
mod=10**9+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
n = 10**6+1
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 )
ans=0
for i in range(N-K+1):
d=(A[K-1+i]%mod)*cmb(K-1+i,K-1,mod)
e=(B[K-1+i]%mod)*cmb(K-1+i,K-1,mod)
ans+=d%mod-e%mod
ans%=mod
print(ans)
|
N,K=list(map(int, input().split()))
AA=list(map(int, input().split()))
A=sorted(AA)
B=sorted(AA)[::-1]
mod=10**9+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
n = 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 )
ans=0
for i in range(N-K+1):
d=(A[K-1+i]%mod)*cmb(K-1+i,K-1,mod)
e=(B[K-1+i]%mod)*cmb(K-1+i,K-1,mod)
ans+=d%mod-e%mod
ans%=mod
print(ans)
|
p02804
|
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def comb(n,k):
if n < k:
return 0
return f[n]*inv[k]*inv[n-k]%mod
n,k = LI()
a = LI()
a.sort()
f = [1]
N = 10**6
for i in range(1,N+1):
f.append(f[-1]*i%mod)
inv = [None]*(N+1)
inv[N] = pow(f[N],mod-2,mod)
for i in range(1,N+1)[::-1]:
inv[i-1] = inv[i]*i%mod
ans = 0
d = defaultdict(lambda : 1)
for i in a:
l = bisect.bisect_right(a,i)-d[i]
r = n-l-1
d[i] += 1
ans += i*(comb(l,k-1)-comb(r,k-1))%mod
ans %= mod
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
|
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,k = LI()
a = LI()
f = list(set(a))
f.sort()
s = [0]*len(f)
ind = [0]*n
for i in range(n):
j = bisect.bisect_left(f,a[i])
s[j] += 1
ls = list(accumulate(s))
rs = list(accumulate(s[::-1]))[::-1]
ans = 0
fact = [1]
N = 10**5
for i in range(1,N+1):
fact.append(fact[-1]*i%mod)
inv = [0]*(N+1)
inv[N] = pow(fact[N],mod-2,mod)
for i in range(N)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
comb = lambda x,y:fact[x]*inv[y]*inv[x-y]%mod
for j in a:
i = bisect.bisect_left(f,j)
l = ls[i]-1
r = rs[i]-1
cl = comb(l,k-1) if l >= k-1 else 0
cr = comb(r,k-1) if r >= k-1 else 0
ans += f[i]*(cl-cr)
ans %= mod
ls[i] -= 1
rs[i] -= 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
|
p02804
|
n,k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
def mod_nCr(n,k,mod):
a = 1
for i in range(n-k+1,n+1):
a = a*i%mod
b = 1
for i in range(1,k+1):
b = b*pow(i,mod-2,mod)%mod
return a*b%mod
mod = 10**9+7
ans = 0
for i in range(k-1,n)[::-1]:
ans += a[i]*mod_nCr(i,k-1,mod)
ans %= mod
a.reverse()
for i in range(k-1,n)[::-1]:
ans -= a[i]*mod_nCr(i,k-1,mod)
ans %= mod
print((ans%mod))
|
n,k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
def mod_nCr(n,k,mod):
r = min(k,n-k)
return fact[n]*factinv[k]*factinv[n-k]%mod
mod = 10**9+7
fact = [1,1]
inv = [0,1]
factinv = [1,1]
for i in range(2,n+1):
fact.append(fact[-1]*i%mod)
inv.append((-inv[mod%i]*(mod//i))%mod)
factinv.append((factinv[-1]*inv[-1])%mod)
ans = 0
for i in range(k-1,n)[::-1]:
ans += a[i]*mod_nCr(i,k-1,mod)
ans %= mod
a.reverse()
for i in range(k-1,n)[::-1]:
ans -= a[i]*mod_nCr(i,k-1,mod)
ans %= mod
print((ans%mod))
|
p02804
|
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N, K = list(map(int, readline().split()))
A = list(map(int, readline().split()))
A.sort()
lenA = len(A)
ans = 0
if K == 1:
print((0))
sys.exit()
def com(n, r, mod):
r = min(r, n - r)
if r == 0:
return 1
res = ilist[n] * iinvlist[n - r] * iinvlist[r] % mod
return res
ilist = [0]
iinvlist = [1]
def modinv(a, mod=10 ** 9 + 7):
return pow(a, mod - 2, mod)
tmp = 1
for i in range(1, N + 1):
tmp *= i
tmp %= mod
ilist.append(tmp)
iinvlist.append(modinv(tmp, mod))
for front in range(lenA):
for last in range(lenA-front-K+1):
last = last + front + K - 1
f_x = A[last] - A[front]
count = last - front - 1
ans += com(count, K-2, mod) * f_x
ans %= mod
print(ans)
if __name__ == '__main__':
solve()
|
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N, K = list(map(int, readline().split()))
A = list(map(int, readline().split()))
A.sort()
lenA = len(A)
ans = 0
if K == 1:
print((0))
sys.exit()
def com(n, r, mod):
r = min(r, n - r)
if r == 0:
return 1
res = ilist[n] * iinvlist[n - r] * iinvlist[r] % mod
return res
def modinv(a, mod=10 ** 9 + 7):
return pow(a, mod - 2, mod)
ilist = [0]
iinvlist = [1]
tmp = 1
for i in range(1, N + 1):
tmp *= i
tmp %= mod
ilist.append(tmp)
iinvlist.append(modinv(tmp, mod))
sum_of_com = []
now = 0
for i in range(K-2, N+1):
now += com(i, K-2, mod)
sum_of_com.append(now)
ans = 0
for first in range(lenA-K+1):
ans -= A[first] * sum_of_com[lenA-first-K]
for last in range(K-1, lenA):
ans += A[last] * sum_of_com[last-K+1]
ans %= mod
print(ans)
if __name__ == '__main__':
solve()
|
p02804
|
def prepare(n, MOD):
# 1! - n! の計算
f = 1
factorials = [1] # 0!の分
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
# n!^-1 の計算
inv = pow(f, MOD - 2, MOD)
# n!^-1 - 1!^-1 の計算
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
MOD = 10**9 + 7
f, inv = prepare(10**5+100, MOD)
n, k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort(reverse=True)
p = 0
m = 0
for i in range(n):
if n - i >= k:
cn = n - i - 1
ck = k - 1
if cn >= ck:
combi = f[cn] * inv[ck] % MOD * inv[cn - ck] % MOD
if a[i] >= 0:
p += (a[i] * combi) % MOD
else:
p += (a[i] * combi) % -MOD
if p >= 0:
p %= MOD
else:
p %= -MOD
if i >= k - 1:
cn = i
ck = k - 1
if cn >= ck:
combi = f[cn] * inv[ck] % MOD * inv[cn - ck] % MOD
if a[i] >= 0:
m += (a[i] * combi) % MOD
else:
m += (a[i] * combi) % -MOD
if m >= 0:
m %= MOD
else:
m %= -MOD
print(((p - m)%MOD))
|
def prepare(n, MOD):
# 1! - n! の計算
f = 1
factorials = [1] # 0!の分
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
# n!^-1 の計算
inv = pow(f, MOD - 2, MOD)
# n!^-1 - 1!^-1 の計算
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
MOD = 10**9 + 7
f, inv = prepare(10**5+1, MOD)
n, k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort(reverse=True)
p = 0
m = 0
for i in range(n):
if n - i >= k:
cn = n - i - 1
ck = k - 1
combi = f[cn] * inv[ck] % MOD * inv[cn - ck] % MOD
if a[i] >= 0:
p += (a[i] * combi) % MOD
else:
p += (a[i] * combi) % -MOD
if p >= 0:
p %= MOD
else:
p %= -MOD
if i >= k - 1:
cn = i
ck = k - 1
combi = f[cn] * inv[ck] % MOD * inv[cn - ck] % MOD
if a[i] >= 0:
m += (a[i] * combi) % MOD
else:
m += (a[i] * combi) % -MOD
if m >= 0:
m %= MOD
else:
m %= -MOD
print(((p - m) % MOD))
|
p02804
|
def main():
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = 0
c = 1
nCk = [1]
for r in range(k,n+1):
c = c*r//(r-k+1)
nCk.append(c)
if k == 1:
print((0))
else:
for i in range(1,n):
if n-i < k-1:
break
ans += (a[n-i]-a[i-1])*nCk[n-i-k+1]
print((ans%1000000007))
if __name__ == "__main__":
main()
|
def main():
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = 0
if k == 1:
print((0))
else:
for i in range(k-1,n):
if n-i+1<0:
break
if i == k-1:
c = 1
ans += (a[i]-a[n-i-1])*c
else:
c = c*i//(i-k+1)
ans += (a[i]-a[n-i-1])*c
print((ans%1000000007))
if __name__ == "__main__":
main()
|
p02804
|
n,K=list(map(int,input().split()))
L=list(map(int,input().split()))
L.sort()
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**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 )
#print(L)
mod=10**9+7
ans=0
for i in range(K-1,len(L)): #ピッチ
for j in range(len(L)): #スタート
if i+j<len(L):
ans+=(L[j+i]-L[j])*cmb(i-1,K-2,mod)
#print(j,i,cmb(i,K-2,mod))
ans%=mod
print(ans)
|
n,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
mod=10**9+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
#出力の制限
N = 10**5+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 )
L=[]
for i in range(n):
L.append(cmb(n-1-i,K-1,mod))
#print(L)
Small=0
for i in range(n):
Small+=A[i]*L[i]
Small%mod
Big=0
RA=A[::-1]
for i in range(n):
Big+=RA[i]*L[i]
Big%=mod
print(((Big-Small)%mod))
|
p02804
|
import sys
from math import factorial
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
mod = 10**9 + 7
a.sort()
li = []
for i in range(n-1):
li.append(a[i+1]-a[i])
ans = 0
dp = [1]
for i in range(1,n+1):
dp.append(dp[-1]*i)
def comb(n,k):
return dp[n] // dp[k] // dp[n-k]
comb1 = comb(n,k)
for i in range(n-1):
if i+1 < k and n-i-1 < k:
ans += li[i] * comb1
elif i+1 < k:
ans += li[i] * (comb1 - comb(n-i-1,k))
elif n-i-1 < k:
ans += li[i] * (comb1 - comb(i+1,k))
else:
ans += li[i] * (comb1 - comb(n-i-1,k) - comb(i+1,k))
print((ans%mod))
|
import sys
from math import factorial
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
mod = 10**9 + 7
a.sort()
li = []
for i in range(n-1):
li.append(a[i+1]-a[i])
ans = 0
dp = [1]
for i in range(1,n+1):
dp.append(dp[-1]*i%mod)
def comb(n,k):
return factorial(n) // factorial(k) // factorial(n-k) % mod
#return dp[n] // dp[k] // dp[n-k]
comb1 = comb(n,k)
for i in range(n-1):
if i+1 < k and n-i-1 < k:
ans += li[i] * comb1
elif i+1 < k:
ans += li[i] * (comb1 - comb(n-i-1,k))
elif n-i-1 < k:
ans += li[i] * (comb1 - comb(i+1,k))
else:
ans += li[i] * (comb1 - comb(n-i-1,k) - comb(i+1,k))
print((ans%mod))
|
p02804
|
MOD = 10**9 + 7
def comb(n,k,p):
"""power_funcを用いて(nCk) mod p を求める"""
from math import factorial
if n<0 or k<0 or n<k:
return 0
if n==0 or k==0:
return 1
a=factorial(n) %p
b=factorial(k) %p
c=factorial(n-k) %p
return (a*power_func(b,p-2,p)*power_func(c,p-2,p))%p
def power_func(a,b,p):
"""a^b mod p を求める"""
if b==0:
return 1
if b%2==0:
d=power_func(a,b//2,p)
return d*d %p
if b%2==1:
return (a*power_func(a,b-1,p ))%p
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
A.sort()
A_rev = list(reversed(A))
ans = 0
for i, j in zip(A, A_rev):
if N < K:
break
C = comb(N - 1, K - 1, MOD)
ans += C * j
ans -= C * i
ans %= MOD
N -= 1
print((int(ans % MOD)))
|
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
A.sort()
MOD = 10 ** 9 + 7
def combination(mod=MOD):
fact = [1] * (N + 1)
inv_fact = [1] * (N + 1)
r = 1
for i in range(1, N + 1):
fact[i] = r = r * i % mod
inv_fact[N] = r = pow(fact[N], mod - 2, mod)
for i in range(N, 0, -1):
inv_fact[i - 1] = r = r * i % mod
def _wrapper(n, k):
nonlocal fact, inv_fact, mod
if n == 0 or k == 0:
return 1
return fact[n] * inv_fact[k] * inv_fact[n - k] % mod
return _wrapper
def main():
if K == 1:
print((0))
exit()
comb = combination()
sum_max = 0
sum_min = 0
for i, A_i in enumerate(A):
if i >= K - 1:
sum_max += comb(i, K - 1) * A_i % MOD
if N - i >= K:
sum_min += comb(N - i - 1, K - 1) * A_i % MOD
ans = (sum_max - sum_min) % MOD
print(ans)
if __name__ == '__main__':
main()
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
A.sort(reverse=True)
kaijou = [1 for _ in range(N+1)]
for k in range(1, N):
kaijou[k+1] = kaijou[k]*(k+1)%mod
b = mod-2
blis = []
c = 0
while b >0:
if b & 1 == 1:
blis.append(c)
c += 1
b >>= 1
def modinv(a):
if a == 1:
return 1
else:
res = 1
li = []
for _ in range(c):
li.append(a%mod)
a = a*a%mod
for item in blis:
res = res *li[item] %mod
return res
def combination(n, k):
foo = kaijou[n]*modinv(kaijou[k]*kaijou[n-k]%mod)%mod
return foo
ans = 0
for k in range(N-K+1):
ans += A[k]*combination(N-k-1, K-1)
ans %= mod
for k in range(N-K+1):
ans -= A[-k-1]*combination(N-k-1, K-1)
ans %= mod
print(ans)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
A.sort(reverse=True)
"""
kaijou = [1 for _ in range(N+1)]
for k in range(1, N):
kaijou[k+1] = kaijou[k]*(k+1)%mod
b = mod-2
blis = []
c = 0
while b >0:
if b & 1 == 1:
blis.append(c)
c += 1
b >>= 1
def modinv(a):
if a == 1:
return 1
else:
res = 1
li = []
for _ in range(c):
li.append(a%mod)
a = a*a%mod
for item in blis:
res = res *li[item] %mod
return res
"""
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) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
def combination(n, k):
#foo = kaijou[n]*modinv(kaijou[k]*kaijou[n-k]%mod)%mod
foo = fact[n]*factinv[k]*factinv[n-k]%mod
return foo
ans = 0
for k in range(N-K+1):
ans += A[k]*combination(N-k-1, K-1)
ans %= mod
for k in range(N-K+1):
ans -= A[-k-1]*combination(N-k-1, K-1)
ans %= mod
print(ans)
|
p02804
|
from operator import mul
from functools import reduce
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
X_max = 0
X_min = 0
nCr = {}
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
for i in range(N-K+1):
n = cmb(N-1-i, K-1)
X_max += n*A[-(i+1)]
X_min += n*A[i]
print(((X_max - X_min) % 1000000007))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
p = 1000000007
X_max = 0
X_min = 0
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
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)
for i in range(N-K+1):
n = cmb(N-1-i, K-1, p)
X_max += n*A[-(i+1)]
X_max %= p
X_min += n*A[i]
X_min %= p
print((int((X_max - X_min) % p)))
|
p02804
|
MOD = 10 ** 9 + 7
FACT_MAX = 10 ** 5
fact = [1] * FACT_MAX
for i in range(1, FACT_MAX):
fact[i] = fact[i - 1] * i % MOD
def comb(n, r):
return fact[n] * pow(fact[n - r], MOD - 2, MOD) * pow(fact[r], MOD - 2, MOD)
N, K = list(map(int, input().split()))
A = sorted(map(int, input().split()))
print((sum(comb(i, K - 1) * (A[i] - A[N - i - 1]) % MOD for i in range(K - 1, N)) % MOD))
|
MOD = 10 ** 9 + 7
def comb(n, r):
return fact[n] * pow(fact[n - r], MOD - 2, MOD) * pow(fact[r], MOD - 2, MOD)
N, K = list(map(int, input().split()))
fact = [1] * N
for i in range(1, N):
fact[i] = fact[i - 1] * i % MOD
A = sorted(map(int, input().split()))
print((sum(comb(i, K - 1) * (A[i] - A[N - i - 1]) % MOD for i in range(K - 1, N)) % MOD))
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9+7
comb = [0] * (N+1)
comb[K-1] = 1
for i in range(K-1, N):
comb[i+1] = comb[i] * (i+1) * pow(i-K+2, -1, mod) % mod
# print(comb)
A.sort()
# mi = sum(a*comb[i]%mod for a, i in zip(reversed(A[:N-K+1]), range(K-1, N)))
# ma = sum(a*comb[i]%mod for a, i in zip((A[K-1:]), range(K-1, N)))
ans = sum((a-b)*comb[i]%mod for b, a, i in zip(reversed(A[:N-K+1]), A[K-1:], list(range(K-1, N))))
# print(mi%mod, ma%mod)
print((ans%mod))
|
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9+7
comb = [0] * (N+1)
comb[K-1] = 1
for i in range(K-1, N):
comb[i+1] = comb[i] * (i+1) * pow(i-K+2, -1, mod) % mod
# print(comb)
A.sort()
# mi = sum(a*comb[i]%mod for a, i in zip(reversed(A[:N-K+1]), range(K-1, N)))
# ma = sum(a*comb[i]%mod for a, i in zip((A[K-1:]), range(K-1, N)))
ans = sum((a-b)*comb[i]%mod for b, a, i in zip(reversed(A[:N-K+1]), A[K-1:], list(range(K-1, N))))
# print(mi%mod, ma%mod)
print((ans%mod))
if __name__ == '__main__':
main()
|
p02804
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
class Combination:
"""
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):
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
n,k = inpl()
a = sorted(inpl())
res = 0
comb = Combination(10**5+10)
for i in range(n):
if n-i-1 < k-1: continue
p = comb(n-i-1,k-1)
res -= a[i] * p
res += a[-1-i] * p
res %= mod
print(res)
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
class Combination:
"""
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):
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
comb = Combination(100010)
n,k = inpl()
a = inpl()
a.sort()
mx = 0
for i in range(n):
if n-i-1 < k-1: continue
tmp = comb(n-i-1,k-1)
# print(tmp)
mx += tmp*a[-i-1] - tmp*a[i]
mx %= mod
print(mx)
|
p02804
|
import math
import operator as op
from functools import reduce
def ncr(n, r):
r = min(r, n-r)
numer = reduce(op.mul, list(range(n, n-r, -1)), 1)
denom = reduce(op.mul, list(range(1, r+1)), 1)
return numer // denom
n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
total = 0
for i in range(n-m+1):
p = n - i - 1
q = m - 1
c = ncr(p, q)
total -= c * a[i]
total += c * a[-1-i]
print((total % (10**9 + 7)))
|
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
mod = 10**9 + 7
f = [1, 1]
for i in range(2, n):
f.append((f[i-1] * i) % mod)
total = 0
for i in range(n - k + 1):
p = n - i - 1
q = k - 1
c = f[p] * pow(f[p-q], mod-2, mod) * pow(f[q], mod-2, mod) % mod
total += c * (a[-1-i] - a[i])
total = total % mod
print(total)
|
p02804
|
import itertools
import math
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
mod = 10**9+7
# print(list(itertools.combinations(range(6), 3)))
# A = range(6)
# N = 6
# K = 3
# 二項係数を素数で割った余り
def combMod(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
# fact = [-1 for _ in range(n+1)]
# fact[0] = 1
# fact[1] = 1
# inv = [-1 for _ in range(n+1)]
# inv[0] = 0
# inv[1] = 1
# factinv = [-1 for _ in range(n+1)]
# factinv[0] = 1
# factinv[1] = 1
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, n + 1):
# fact[i] = ((fact[i-1] * i) % p)
# inv[i] = ((-inv[p % i] * (p // i)) % p)
# factinv[i] = ((factinv[i-1] * inv[i]) % p)
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
return fact[n] * factinv[r] * factinv[n-r] % p
ans = 0
for i in range(N):
num = combMod(i, K-1, mod) % mod
ans += num * A[i] % mod
ans -= num * A[N-i-1] % mod
ans %= mod
print(ans)
|
# import itertools
# import math
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
mod = 10**9+7
# print(list(itertools.combinations(range(6), 3)))
# A = range(6)
# N = 6
# K = 3
# 二項係数を素数で割った余り
def combMod(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 for _ in range(n+1)]
# fact[0] = 1
# fact[1] = 1
# inv = [-1 for _ in range(n+1)]
# inv[0] = 0
# inv[1] = 1
# factinv = [-1 for _ in range(n+1)]
# factinv[0] = 1
# factinv[1] = 1
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
p = mod
for i in range(2, N + 1):
# fact[i] = ((fact[i-1] * i) % p)
# inv[i] = ((-inv[p % i] * (p // i)) % p)
# factinv[i] = ((factinv[i-1] * inv[i]) % p)
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
ans = 0
for i in range(N):
num = combMod(i, K-1, mod) % mod
ans += num * A[i] % mod
ans -= num * A[N-i-1] % mod
ans %= mod
print(ans)
|
p02804
|
# import itertools
# import math
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
mod = 10**9+7
# print(list(itertools.combinations(range(6), 3)))
# A = range(6)
# N = 6
# K = 3
# 二項係数を素数で割った余り
def combMod(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 for _ in range(N+1)]
fact[0] = 1
fact[1] = 1
inv = [-1 for _ in range(N+1)]
inv[0] = 0
inv[1] = 1
factinv = [-1 for _ in range(N+1)]
factinv[0] = 1
factinv[1] = 1
# fact = [1, 1]
# factinv = [1, 1]
# inv = [0, 1]
p = mod
for i in range(2, N + 1):
fact[i] = ((fact[i-1] * i) % p)
inv[i] = ((-inv[p % i] * (p // i)) % p)
factinv[i] = ((factinv[i-1] * inv[i]) % p)
# fact.append((fact[-1] * i) % p)
# inv.append((-inv[p % i] * (p // i)) % p)
# factinv.append((factinv[-1] * inv[-1]) % p)
ans = 0
for i in range(N):
num = combMod(i, K-1, mod) % mod
ans += num * A[i] % mod
ans -= num * A[N-i-1] % mod
ans %= mod
print(ans)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
mod = 10**9+7
# conbModに使うfactとfactinvを求める
def factorialMod(n, p):
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
return fact, factinv
# 二項係数を素数で割った余り
def combMod(n, r, fact, factinv, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
ans = 0
fact, factinv = factorialMod(N, mod)
for i in range(N):
num = combMod(i, K-1, fact, factinv, mod) % mod
ans += num * A[i] % mod
ans -= num * A[N-i-1] % mod
ans %= mod
print(ans)
|
p02804
|
from math import factorial
MOD = 10**9 + 7
# 階乗を用意
fact = [1] * (10**5 + 1)
for i in range(1, 10**5 + 1):
fact[i] = fact[i-1] * i
fact[i] %= MOD
def comb(n, k, p):
"""power_funcを用いて(nCk) mod p を求める"""
global fact
if n < 0 or k < 0 or n < k:
return 0
if n == 0 or k == 0:
return 1
a = fact[n]
b = fact[k]
c = fact[n-k]
return (a*power_func(b, p-2, p)*power_func(c, p-2, p)) % p
def power_func(a, b, p):
"""a^b mod p を求める"""
if b == 0:
return 1
if b % 2 == 0:
d = power_func(a, b//2, p)
return d*d % p
if b % 2 == 1:
return (a*power_func(a, b-1, p)) % p
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = 0
# pos
for i in range(1, n):
ans += a[i] * comb(i, k-1, MOD)
ans %= MOD
for i in range(n-1):
ans -= a[i] * comb(n-1-i, k-1, MOD)
ans %= MOD
print(ans)
|
from math import factorial
MOD = 10**9 + 7
# 階乗を用意
fact = [1] * (10**5 + 1)
for i in range(1, 10**5 + 1):
fact[i] = fact[i-1] * i
fact[i] %= MOD
def comb(n, k, p):
"""power_funcを用いて(nCk) mod p を求める"""
global fact
if n < 0 or k < 0 or n < k:
return 0
if n == 0 or k == 0:
return 1
a = fact[n]
b = fact[k]
c = fact[n-k]
return (a*power_func(b, p-2, p)*power_func(c, p-2, p)) % p
def power_func(a, b, p):
"""a^b mod p を求める"""
if b == 0:
return 1
if b % 2 == 0:
d = power_func(a, b//2, p)
return d*d % p
if b % 2 == 1:
return (a*power_func(a, b-1, p)) % p
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = 0
# pos
for i in range(n-1):
c = comb(n-1-i, k-1, MOD)
ans += a[n-1-i] * c
ans %= MOD
ans -= a[i] * c
ans %= MOD
print(ans)
|
p02804
|
mod = int(1e9+7)
fac = [1]
def add(a, b):
c = a + b
if c >= mod:
c -= mod
return c
def subtract(a, b):
return (a - b) % mod
def mul(a, b):
return (a * b) % mod
def my_pow(a, b):
if b == 0:
return 1
if b % 2 == 1:
return mul(a, my_pow(a, b-1))
else:
temp = my_pow(a, b/2)
return temp * temp
def my_inv(a):
return my_pow(a, mod-2)
def nCk(n, k, fac):
if k > n:
return 0
#print(fac[n])
#print(my_inv(mul(fac[n-k], fac[k])))
return mul(fac[n], my_inv(mul(fac[n-k], fac[k])))
def main():
n, k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
fac = [0 for _ in range(2*n+1)]
fac[0] = 1
for i in range(1, 2*n+1):
fac[i] = fac[i-1] * i
a.sort()
ans = 0
for i in range(n-1):
#print(a[i])
diff = subtract(a[i+1], a[i])
ways = nCk(n, k, fac)
#print(ways)
ways = subtract(ways, nCk(i+1, k, fac))
ways = subtract(ways, nCk(n-i-1, k, fac))
ans = add(ans, mul(diff, ways))
print(ans)
main()
|
mod = int(1e9+7)
fac = [1]
def add(a, b):
c = a + b
if c >= mod:
c -= mod
return c
def subtract(a, b):
return (a - b) % mod
def mul(a, b):
return (a * b) % mod
def my_pow(a, b):
if b == 0:
return 1
if b % 2 == 1:
return mul(a, my_pow(a, b-1))
else:
temp = my_pow(a, b/2)
return temp * temp
def my_inv(a):
return my_pow(a, mod-2)
def nCk(n, k, fac):
if k > n:
return 0
#print(fac[n])
#print(my_inv(mul(fac[n-k], fac[k])))
return mul(fac[n], my_inv(mul(fac[n-k], fac[k])))
def main():
n, k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
fac = [0] * (n+5)
#print(fac)
fac[0] = 1
for i in range(1, n+5):
fac[i] = mul(fac[i-1], i)
a.sort()
ans = 0
for i in range(n-1):
#print(a[i])
diff = subtract(a[i+1], a[i])
ways = nCk(n, k, fac)
#print(ways)
ways = subtract(ways, nCk(i+1, k, fac))
ways = subtract(ways, nCk(n-i-1, k, fac))
ans = add(ans, mul(diff, ways))
print(ans)
main()
|
p02804
|
from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
n,k = list(map(int,input().split()))
lis = list(map(int,input().split()))
lis.sort()
ans = 0
for i in range(n):
if i >= k-1:
ans += lis[i] * cmb(i,k-1)
if n-i-1 >= k-1:
ans -= lis[i] * cmb(n-i-1,k-1)
ans %= 10 ** 9+7
print(ans)
|
import sys
sys.setrecursionlimit(1000000)
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 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
n,k = list(map(int,input().split()))
lis = list(map(int,input().split()))
lis.sort()
ans = 0
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 )
for i in range(n):
if i >= k-1:
ans += lis[i] * cmb(i,k-1,mod)
if n-i-1 >= k-1:
ans -= lis[i] * cmb(n-i-1,k-1,mod)
ans %= 10 ** 9+7
print(ans)
|
p02804
|
from itertools import combinations
n,k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
a.sort()
mod = 10**9+7
ans = 0
for i in combinations(a,k):
ans += i[k-1] - i[0]
ans %= mod
print(ans)
|
n,k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
a.sort()
mod = 10**9+7
fac = [0]*(n+1)
finv = [0]*(n+1)
def comb(n,k):
if n < k: return 0
if n < 0 or k < 0: return 0
return fac[n]*finv[k]%mod*finv[n-k]%mod
fac[0] = finv[0] = 1
for i in range(1,n+1):
fac[i] = fac[i-1]*i%mod
finv[i] = pow(fac[i],mod-2,mod)
smin = 0
smax = 0
for i in range(n):
smin += (a[i]*comb(n-i-1,k-1))%mod
smin %= mod
smax += (a[n-1-i]*comb(n-i-1,k-1))%mod
smax %= mod
ans = (smax-smin)%mod
print(ans)
|
p02804
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from bisect import bisect_left
def comb(n, k):
if n < 0 or n < k or k < 0:
return 0
return fac[n] * ifac[k] * ifac[n - k] % mod
n, k, *a = list(map(int, read().split()))
a.sort()
mod = 10 ** 9 + 7
max_n = 2 * 10 ** 5 + 1
ans = 0
fac = [1] * max_n
inv = [1] * max_n
ifac = [1] * max_n
for i in range(2, max_n):
fac[i] = fac[i - 1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
ifac[i] = ifac[i - 1] * inv[i] % mod
for i, aa in enumerate(a):
ans += aa * (comb(i, k - 1) - comb(n - 1 - i, k - 1))
ans %= mod
print(ans)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
def comb(n, k):
if n < 0 or n < k or k < 0:
return 0
return fac[n] * ifac[k] * ifac[n - k] % mod
n, k, *a = list(map(int, read().split()))
a.sort()
mod = 10 ** 9 + 7
ans = 0
fac = [1] * n
inv = [1] * n
ifac = [1] * n
for i in range(2, n):
fac[i] = fac[i - 1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
ifac[i] = ifac[i - 1] * inv[i] % mod
for i, aa in enumerate(a):
ans += aa * (comb(i, k - 1) - comb(n - 1 - i, k - 1))
ans %= mod
print(ans)
|
p02804
|
def combi(x, y):
if x < y:
return 0
if (x,y) in memo:
return memo[(x,y)]
else:
memo[(x,y)] = math.factorial(x) // (math.factorial(x - y) * math.factorial(y))
return memo[(x,y)]
import math
memo = dict()
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
mod = 10**9+7
ans = 0
for i in range(n):
#今回の数字が、最小値として数えられる数の合計
ans -= a[i] * combi(n - i - 1, k-1)
#今回の数字が、最大値として数えられる数の合計
ans += a[i] * combi(i,k-1)
ans %= mod
print((int(ans)))
|
mod = 10**9+7
memo = dict()
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
factorial = [1 for i in range(n+1+k)]
for i in range(1,n+1+k):
factorial[i] = (factorial[i-1] * i) % mod
#互いに素なa,bについて、a*x+b*y=1の一つの解
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
#[x,y]
return [w[0],w[1]]
# aの逆元(mod m)を求める。(aとmは互いに素であることが前提)
#a/b = a*(b`)となるb`を求める
def mod_inv(a,mod):
x = extgcd(a,mod)[0]
return (mod+x%mod)%mod
def mod_combination(n,k,mod):
if n < k:
return 0
return factorial[n] * mod_inv(factorial[n-k], mod) * mod_inv(factorial[k], mod)
ans = 0
for i in range(n):
#今回の数字が、最小値として数えられる数の合計
ans -= a[i] * mod_combination(n - i - 1, k-1,mod)
#今回の数字が、最大値として数えられる数の合計
ans += a[i] * mod_combination(i,k-1,mod)
ans %= mod
print((int(ans)))
|
p02804
|
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
Mod = 10**9 + 7
a.sort()
c = [0] * (n+1)
c[k - 1] = 1
for i in range(n+1):
if i >= k:
c[i] = (c[i - 1]*i) // (i - k + 1)
ans = 0
for i in range(1, n + 1):
ans += (a[i - 1] * (c[i - 1] - c[n - i])) % Mod
print((ans % Mod))
|
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
Mod = 10**9 + 7
a.sort()
c = [0] * (n+1)
c[k - 1] = 1
for i in range(n+1):
if i >= k:
c[i] = ((c[i - 1]*i * pow(i - k + 1, Mod - 2, Mod))) % Mod
ans = 0
for i in range(1, n + 1):
ans += (a[i - 1] * (c[i - 1] - c[n - i])) % Mod
print((ans % Mod))
|
p02804
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
mod=pow(10,9)+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
N = n
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 )
from collections import Counter
cnt_a=Counter(a)
list_a=list(cnt_a.keys())
list_a.sort()
num_a=len(list_a)
sa_=0
sa=[0]
for ai in list_a:
sa_+=cnt_a[ai]
sa.append(sa_)
ans=0
for i in range(num_a):
for j in range(i,num_a):# list_a[i]をmin,list_a[j]をmaxとしてk個選べるか
k_=sa[j+1]-sa[i]
if k_>=k:
mj=0 if k_-cnt_a[list_a[j]]<k else cmb(k_-cnt_a[list_a[j]],k,mod)
mi=0 if k_-cnt_a[list_a[i]]<k else cmb(k_-cnt_a[list_a[i]],k,mod)
mij=0 if k_-cnt_a[list_a[j]]-cnt_a[list_a[i]]<k else cmb(k_-cnt_a[list_a[j]]-cnt_a[list_a[i]],k,mod)
ans+=(list_a[j]-list_a[i])*(cmb(k_,k,mod)-mj-mi+mij)
#print(list_a[j],list_a[i],cmb(k_,k,mod),mj,mi)
ans%=mod
#f(x)の値×list_a[i]をmin,list_a[j]をmaxとしてk個選ぶ選び方
print(ans)
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
mod=pow(10,9)+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
N = n
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 )
from collections import Counter
cnt_a=Counter(a)
list_a=list(cnt_a.keys())
list_a.sort()
num_a=len(list_a)
sa_=0
sa=[0]
for ai in list_a:
sa_+=cnt_a[ai]
sa.append(sa_)
ansmin=0
ansmax=0
for i in range(num_a):# list_a[i]がminになる場合の数
k_=sa[num_a]-sa[i]
if k_>=k:
mi=0 if k_-cnt_a[list_a[i]]<k else cmb(k_-cnt_a[list_a[i]],k,mod)
ansmin+=list_a[i]*(cmb(k_,k,mod)-mi)
ansmin%=mod
for i in range(num_a):# list_a[i]がmaxになる場合の数
k_=sa[i+1]
if k_>=k:
mi=0 if k_-cnt_a[list_a[i]]<k else cmb(k_-cnt_a[list_a[i]],k,mod)
ansmax+=list_a[i]*(cmb(k_,k,mod)-mi)
ansmax%=mod
print(((ansmax-ansmin)%mod))
|
p02804
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
a.sort(reverse = True)
N = n+2
P = mod
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
base = 1
for item in range(n-k+1, n):
base = (base * item) % mod
for i in range(1, k):
base = (base * inv_t[i]) % mod
base2 = base
ans = 0
ans2 = 0
top = n - 1
for ai in a:
if top < k-1:
break
if ai > 0:
ans += base * ai
ans %= mod
else:
ans2 += abs(base * ai)
ans2 %= mod
base = base * inv_t[top] * (top - k + 1) % mod
top -= 1
top = n-1
for ai in reversed(a):
if top < k-1:
break
if ai > 0:
ans2 += base2 * ai
ans2 %= mod
else:
ans += abs(base2 * ai)
ans %= mod
base2 = base2 * inv_t[top] * (top - k + 1) % mod
top -= 1
print(((ans - ans2) % mod))
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
a.sort(reverse = True)
N = n+2
P = mod
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
base = 1
for item in range(n-k+1, n):
base = (base * item) % mod
for i in range(1, k):
base = (base * inv_t[i]) % mod
base2 = base
ans = 0
top = n - 1
for ai in a:
if top < k-1:
break
ans += base * ai
ans %= mod
base = base * inv_t[top] * (top - k + 1) % mod
top -= 1
top = n-1
for ai in reversed(a):
if top < k-1:
break
ans -= base2 * ai
ans %= mod
base2 = base2 * inv_t[top] * (top - k + 1) % mod
top -= 1
print((ans % mod))
|
p02804
|
def comb(n,r,mod):
'''
return nCr
O(min{n-r, r})
'''
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
N,K = list(map(int,input().split()))
A = [int(x) for x in input().split()]
A.sort()
mod = 10**9+7
l = [[A[0], comb(N-1, K-1, mod=mod)]]
r = [[A[-1], comb(N-1, K-1, mod=mod)]]
for i in range(1,N):
if N-i-1>=K-1:
l.append([A[i], comb(N-i-1, K-1,mod=mod)])
for i in range(N-1)[::-1]:
if i>=K-1:
r.append([A[i],comb(i, K-1,mod=mod)])
s = 0
t = 0
for i,j in l:
s = (s+(i*j)%mod)%mod
for i,j in r:
t = (t+(i*j)%mod)%mod
ans = (t-s)%mod
if ans < 0:
ans += mod
print(ans)
|
N,K = list(map(int,input().split()))
A = [int(x) for x in input().split()]
A.sort()
mod = 10**9+7
l = 0
r = 0
t = 1
cnt = 1
for i in range(N-K+1)[::-1]:
l = (l+(t*A[i])%mod)%mod
t = (t*(cnt+K-1))%mod
t = (t*pow(cnt,mod-2, mod))%mod
cnt+=1
t = 1
cnt = 1
for i in range(K-1, N):
r = (r+(t*A[i])%mod)%mod
t = (t*(cnt+K-1))%mod
t = (t*pow(cnt,mod-2, mod))%mod
cnt+=1
ans = (r-l)%mod
if ans < 0:
ans += mod
print(ans)
|
p02804
|
import math
n,k = list(map(int,input().split()))
als = list(map(int,input().split()))
als.sort()
# n = 10**5
# k = 5*(10**4)
mod = 10**9+7
ans = 0
# def nCr(n,r):
# mod = (10**9)+7
# fac = [1,1]+[0]*n
# finv = [1,1]+[0]*n
# inv = [1,1]+[0]*n
# 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
# ans = fac[n] * (finv[r] * finv[n-r] % mod) % mod
# return ans
fac = [1,1]+[0]*n
finv = [1,1]+[0]*n
inv = [1,1]+[0]*n
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
for i in range(n):
if i >= k-1:
ans += als[i] * fac[i] * (finv[(k-1)] * finv[i-(k-1)] % mod) % mod
ans = ans % mod
if i <= n-k:
ans -= als[i] * fac[(n-i-1)] * (finv[(k-1)] * finv[(n-i-1)-(k-1)] % mod) % mod
ans = ans % mod
print(ans)
|
def nCr(n,r,fac,finv):
mod = (10**9)+7
ans = fac[n] * (finv[r] * finv[n-r] % mod) % mod
return ans
n,k = list(map(int,input().split()))
als = list(map(int,input().split()))
als.sort()
ans = 0
mod = (10**9)+7
fac = [1,1]+[0]*n
finv = [1,1]+[0]*n
inv = [1,1]+[0]*n
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
for i in range(n):
if i >= k-1:
ans += als[i] * nCr(i,k-1,fac,finv) % mod
ans = ans % mod
if i <= n-k:
ans -= als[i] * nCr(n-i-1,k-1,fac,finv) % mod
ans = ans % mod
print(ans)
|
p02804
|
def modinv2(a,m):
return pow(a,m-2,m)
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
P = 10**9+7
cominv = [0 for i in range(N-1)]
for i in range(N-1):
if i+2 == K:
cominv[i] = 1
elif i+1 == K:
cominv[i] = (i+1)%P
elif i+1 > K:
a = modinv2(i-K+2,P)
cominv[i] = cominv[i-1]*(i+1)*a%P
#print(cominv)
ans = 0
for i in range(N):
if i <= N-K:
b = A[i]*cominv[N-i-2]%P
ans = (ans-b+P)%P
if i >= K-1:
c = A[i]*cominv[i-1]%P
ans = (ans+c)%P
print(ans)
|
def modinv2(a,m):
return pow(a,m-2,m)
def modcomn(n,r,m):
modcom = [0 for _ in range(n)]
for i in range(n):
if i < r-1:
continue
if i == r-1:
modcom[i] = 1
elif i == r:
modcom[i] = (i+1)%m
else:
div = modinv2(i-r+1,m)
modcom[i] = (modcom[i-1]*div%m)*(i+1)%m
return modcom
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
P = 10**9+7
com = modcomn(N-1,K-1,P)
#print(com)
ans = 0
for i in range(N):
if i >= K-1:
ans = (ans+A[i]*com[i-1]%P)%P
if i <= N-K:
ans = (ans-A[i]*com[N-i-2]%P+P)%P
print(ans)
|
p02804
|
def modinv2(a,m):
return pow(a,m-2,m)
def modcomn(n,r,m):
modcom = [0 for _ in range(n)]
for i in range(n):
if i < r-1:
continue
if i == r-1:
modcom[i] = 1
elif i == r:
modcom[i] = (i+1)%m
else:
div = modinv2(i-r+1,m)
modcom[i] = (modcom[i-1]*div%m)*(i+1)%m
return modcom
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
P = 10**9+7
com = modcomn(N-1,K-1,P)
#print(com)
ans = 0
for i in range(N):
if i >= K-1:
ans = (ans+A[i]*com[i-1]%P)%P
if i <= N-K:
ans = (ans-A[i]*com[N-i-2]%P+P)%P
print(ans)
|
def modinv2(a,m):
return pow(a,m-2,m)
def modcomn(n,r,m):
modcom = [0 for _ in range(n)]
for i in range(n):
if i < r-1:
continue
if i == r-1:
modcom[i] = 1
elif i == r:
modcom[i] = (i+1)%m
else:
div = modinv2(i-r+1,m)
modcom[i] = (modcom[i-1]*div%m)*(i+1)%m
return modcom
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
P = 10**9+7
com = modcomn(N-1,K-1,P)
#print(com)
ans = 0
for i in range(N):
if i >= K-1:
ans = (ans+A[i]*com[i-1]%P)%P
A.sort(reverse=True)
for i in range(N):
if i >= K-1:
ans = (ans-A[i]*com[i-1]%P+P)%P
print(ans)
|
p02804
|
n,k=list(map(int, input().split()))
an=[int(i) for i in 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 = 10 ** 5
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
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)
an=sorted(an)
r_an=list(reversed(an))
max1=0
min1=0
for i in range(1,n-k+2):
c=cmb(n-i,k-1,p)
max1=max1 + an[-i]*c%p
min1=min1 + r_an[-i]*c%p
print(((max1-min1)%p))
|
n,k=list(map(int, input().split()))
an=[int(i) for i in input().split()]
def cmb(n, r, mod):
if (r < 0) or (n < r):
return 0
r=min(r,n-r)
return fact[n] * factinv[r] * factinv[n-r] %mod
mod = 10 ** 9 + 7
N = 10 ** 5
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2,N+1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
an=sorted(an)
r_an=list(reversed(an))
max1=0
min1=0
for i in range(1,n-k+2):
c=cmb(n-i,k-1,mod)
max1=max1 + an[-i]*c%mod
min1=min1 + r_an[-i]*c%mod
print(((max1-min1)%mod))
|
p02804
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
MOD = 10**9+7
MAXN = N+5
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
combs = []
l = N-K+1
for i in range(l):
combs.append(ncr(N-l+i,i))
cmax = [0]*(N-l) + combs
cmin = combs[::-1]
from collections import Counter
mins = Counter()
maxs = Counter()
for a,c in zip(A,cmax):
maxs[a] += c
for a,c in zip(A,cmin):
mins[a] += c
mx = A[-1]
mn = A[0]
ans = ncr(N,K) * (mx-mn)
for k,v in list(maxs.items()):
ans -= v * (mx-k)
ans %= MOD
for k,v in list(mins.items()):
ans -= v * (k-mn)
ans %= MOD
print(ans)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
MOD = 10**9+7
MAXN = N+5
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def comb(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = 0
for n in range(K-1,N):
c = comb(n,K-1)
mx = A[n]
mn = A[-1-n]
ans += (mx-mn)*c
ans %= MOD
print(ans)
|
p02804
|
from collections import defaultdict
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):
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():
#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**4
#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 = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
mod = 10 ** 9 + 7
comb = Combination(1000000)
# 最小になる数を求める
for i, a in enumerate(A):
if (N - 1 - i) >= K-1:
#tmp = cmb(N-1-i,K-1,mod)
tmp = comb(N-1-i, K-1)
ans -= (a * tmp)
ans %= mod
else:
break
A.sort(reverse=True)
for i, a in enumerate(A):
if (N - 1 - i) >= K-1:
#tmp = cmb(N-1-i,K-1,mod)
tmp = comb(N-1-i, K-1)
ans += (a * tmp)
ans %= mod
else:
break
print(ans)
if __name__ == "__main__":
main()
|
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 = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
ans = 0
comb = Combination(N + 5)
A.sort(reverse=True)
for i in range(N-1):
ans += A[i] * comb(N-1-i, K-1)
# min求める
A.sort()
for i in range(N-1):
ans -= A[i] * comb(N-1-i, K-1)
print((ans % MOD))
if __name__ == "__main__":
main()
|
p02804
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,k,*alst = list(map(int,read().split()))
alst.sort()
lst1=alst[k-1:]
lst2=alst[n-k::-1]
mod = 10 ** 9 + 7
res=0
prep=1
for i in range(n-k+1):
res+=prep*(lst1[i]-lst2[i])
res%=mod
prep=prep*(i+k)//(i+1)
print(res)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,k,*alst = list(map(int,read().split()))
alst.sort()
lst1=alst[k-1:]
lst2=alst[n-k::-1]
mod = 10 ** 9 + 7
res=0
prep=1
for i in range(n-k+1):
res+=prep*(lst1[i]-lst2[i])
res%=mod
prep=prep*(i+k)*pow(i+1,mod-2,mod)
prep%=mod
print(res)
|
p02804
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,k,*alst = list(map(int,read().split()))
alst.sort()
lst1=alst[k-1:]
lst2=alst[n-k::-1]
mod = 10 ** 9 + 7
res=0
prep=1
for i in range(n-k+1):
res+=prep*(lst1[i]-lst2[i])
res%=mod
prep=prep*(i+k)*pow(i+1,mod-2,mod)
prep%=mod
print(res)
|
import sys
read = sys.stdin.read
n, k, *alst = list(map(int, read().split()))
alst.sort()
lst1 = alst[k - 1:]
lst2 = alst[n - k::-1]
mod = 10 ** 9 + 7
res = 0
prep = 1
for i in range(n - k + 1):
res += prep * (lst1[i] - lst2[i])
res %= mod
prep = prep * (i + k) * pow(i + 1, mod - 2, mod)
prep %= mod
print(res)
|
p02804
|
def find_power(n,mod):
# 0!からn!までのびっくりを出してくれる関数(ただし、modで割った値に対してである)
powlist=[0]*(n+1)
powlist[0]=1
powlist[1]=1
for i in range(2,n+1):
powlist[i]=powlist[i-1]*i%(mod)
return powlist
def find_inv_power(n):
#0!からn!までの逆元を素数10**9+7で割ったあまりリストを作る関数
powlist=find_power(n,10**9+7)
check=powlist[-1]
first=1
uselist=[0]*(n+1)
secondlist=[0]*30
secondlist[0]=check
secondlist[1]=check**2
for i in range(28):
secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)
a=format(10**9+5,"b")
for j in range(30):
if a[29-j]=="1":
first=(first*secondlist[j])%(10**9+7)
uselist[n]=first
for i in range(n,0,-1):
uselist[i-1]=(uselist[i]*i)%(10**9+7)
return uselist
def combi(a,b,n,r,mod):
if n<r:
return 0
elif n>=r:
return (a[n]*b[r]*b[n-r])%(mod)
aa=find_power(10**5,10**9+7)
bb=find_inv_power(10**5)
mod=10**9+7
n,k=list(map(int,input().split()))
lists=list(map(int,input().split()))
import collections
L=collections.Counter(lists)
L=dict(L)
uselist=[]
for a,v in list(L.items()):
uselist.append((a,v))
uselist=sorted(uselist,key=lambda x:x[0])
maxlist=[(0,0)]
counter=0
for some in uselist:
counter+=some[1]
maxlist.append((some[0],counter))
MAX=0
for j in range(1,len(maxlist)):
MAX+=(combi(aa,bb,maxlist[j][1],k,mod)-combi(aa,bb,maxlist[j-1][1],k,mod))*maxlist[j][0]
MAX=MAX%mod
uselist=uselist[::-1]
maxlist=[(0,0)]
counter=0
for some in uselist:
counter+=some[1]
maxlist.append((some[0],counter))
MIN=0
for j in range(1,len(maxlist)):
MIN+=(combi(aa,bb,maxlist[j][1],k,mod)-combi(aa,bb,maxlist[j-1][1],k,mod))*maxlist[j][0]
MIN=MIN%mod
print(((MAX-MIN)%mod))
|
class Combi():
def __init__(self, N, mod):
self.power = [1 for _ in range(N+1)]
self.rev = [1 for _ in range(N+1)]
self.mod = mod
for i in range(2, N+1):
self.power[i] = (self.power[i-1]*i) % self.mod
self.rev[N] = pow(self.power[N], self.mod-2, self.mod)
for j in range(N, 0, -1):
self.rev[j-1] = (self.rev[j]*j) % self.mod
def com(self, K, R):
if K < R:
return 0
else:
return ((self.power[K])*(self.rev[K-R])*(self.rev[R])) % self.mod
def pom(self, K, R):
if K < R:
return 0
else:
return (self.power[K])*(self.rev[K-R]) % self.mod
def main():
mod = 10**9+7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
c = Combi(N, mod)
res = 0
for i, v in enumerate(A):
res += c.com(i, K-1)*v
res -= c.com(N-1-i, K-1)*v
res %= mod
print(res)
return
if __name__ == "__main__":
main()
|
p02804
|
MOD = 10 ** 9 + 7
def mymodBinomial(n, k, p):
if k < 0 or k > n:
return 0
else:
numerator = 1
for i in range(k):
numerator = (numerator * (n - i)) % p
denominator = 1
for i in range(1, k + 1):
denominator = (denominator * i) % p
return (numerator * pow(denominator, p - 2, p)) % p
if __name__ == "__main__":
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
# print(A)
l = [0]*(N + 1)
for i in range(1, N+1):
l[i] = mymodBinomial(i-1, K-1, MOD)
ans = 0
# print(l)
for i in range(N):
ans += (A[i] - A[N-1-i])* l[i+1] % MOD
print((ans % MOD))
|
MOD = 10 ** 9 + 7
# def mymodBinomial(n, k, p):
# if k < 0 or k > n:
# return 0
# else:
# numerator = 1
# for i in range(k):
# numerator = (numerator * (n - i)) % p
# denominator = 1
# for i in range(1, k + 1):
# denominator = (denominator * i) % p
# return (numerator * pow(denominator, p - 2, p)) % p
def modBinomiallist(n, k, p):
l = [0 for i in range(n)]
for i in range(n):
if i < k:
l[i] = 0
elif i == k:
l[i] = 1
else:
l[i] = l[i - 1] * i * pow(i-k, p-2, p) % p
return l
if __name__ == "__main__":
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
# print(A)
# l = [0]*(N + 1)
# for i in range(1, N+1):
# l[i] = mymodBinomial(i-1, K-1, MOD)
# print(l)
l = modBinomiallist(N, K-1, MOD)
# print(l)
ans = 0
# print(l)
for i in range(N):
ans += (A[i] - A[N-1-i])* l[i] % MOD
print((ans % MOD))
|
p02804
|
import itertools
n, k = list(map(int, input().split()))
alist = sorted(list(map(int, input().split())))
alist_rev = alist[::-1]
divide = 10**9 + 7
def comb(s, n):
return len(list(itertools.combinations(s, n)))
amax = 0
i = 0
while i <= n-k:
amax += alist_rev[i] * comb(alist_rev[i+1:], k-1)
i += 1
amin = 0
i = 0
while i <= n-k:
amin += alist[i] * comb(alist[i+1:], k-1)
i += 1
print(((amax - amin) % divide))
|
import itertools
import math
n, k = list(map(int, input().split()))
alist = sorted(list(map(int, input().split())))
alist_rev = alist[::-1]
divide = 10**9 + 7
def comb(n, k):
return math.factorial(n) // (math.factorial(n-k) * math.factorial(k))
amax = 0
i = n-1
while i >= k-1:
amax += alist[i] * comb(i, k-1)
i -= 1
amin = 0
i = 0
while i <= n-k:
amin += alist[i] * comb(n-i-1, k-1)
i += 1
print(((amax - amin) % divide))
|
p02804
|
#!/usr/bin/env python3
def extgcd(a, b):
if b == 0:
return [1, 0, a]
x, y, g = extgcd(b, a%b)
return [y, x - a//b * y, g]
def mod_inverse(a, m):
x, y, _ = extgcd(a, m)
return (m+x%m) % m
def mod_comb(n, k, mod):
mul, div = 1, 1
for i in range(k):
mul *= (n-i)
div *= (i+1)
mul %= mod
div %= mod
return mul * mod_inverse(div, mod) % mod
n, k = list(map(int, input().split()))
a = [ int(x) for x in input().split() ]
a.sort(reverse=True)
mod = int(1e9)+7
ans = 0
for i, v in enumerate(a):
ans += v*mod_comb(n-i-1, k-1, mod)
ans %= mod
ans -= v*mod_comb(i, k-1, mod)
ans %= mod
print(ans)
|
#!/usr/bin/env python3
MOD = int(1e9)+7
def extgcd(a, b):
if b == 0:
return [1, 0, a]
x, y, g = extgcd(b, a%b)
return [y, x - a//b * y, g]
def mod_inverse(a, m):
x, y, _ = extgcd(a, m)
return (m+x%m) % m
n, k = list(map(int, input().split()))
maxf = 2*n + 10
f = [1 for _ in range(maxf)]
invf = [1 for _ in range(maxf)]
for i in range(1, maxf):
f[i] = (i * f[i - 1]) % MOD
invf[maxf-1] = pow(f[maxf - 1], MOD-2, MOD)
for i in range(maxf-1, 0, -1):
invf[i-1] = (i*invf[i]) % MOD
def comb(a, b):
if b > a:
return 0
return (((f[a]*invf[b]) % MOD) * invf[a-b]) % MOD
a = [ int(x) for x in input().split() ]
a.sort(reverse=True)
ans = 0
for i, v in enumerate(a):
ans += v*comb(n-i-1, k-1)
ans %= MOD
ans -= v*comb(i, k-1)
ans %= MOD
print(ans)
|
p02804
|
import bisect
import collections
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 = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
mod = 10**9 + 7
table = collections.defaultdict(int)
for x in A:
table[x] += 1
ans = 0
for x in table:
# print(x)
i = bisect.bisect_left(A, x)
if i+table[x] >= K:
for j in range(1, table[x] + 1):
ans += cmb(i, K-j, mod)*x*cmb(table[x], j, mod)
# print(ans, j)
i = bisect.bisect_right(A, x)
if N - (i-table[x]) >= K:
for j in range(1, table[x] + 1):
ans -= cmb(N-i, K-j, mod)*x*cmb(table[x], j, mod)
# print(ans, j)
ans %= mod
print(ans)
|
def main():
import collections
import bisect
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**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 = list(map(int, input().split()))
A = list(map(int, input().split()))
table = collections.defaultdict(int)
A.sort()
for x in A:
table[x] += 1
ans = 0
for x in table:
left = bisect.bisect_left(A, x)
for i in range(1, table[x]+1):
if left >= K - i:
ans += x * cmb(left, K - i, mod) * cmb(table[x], i, mod)
right = left + table[x] - 1
for i in range(1, table[x]+1):
if N - 1 - right >= K - i:
ans -= x * cmb(N - 1 - right, K-i, mod) * cmb(table[x], i, mod)
ans %= mod
print(ans)
main()
|
p02804
|
def solve():
from sys import stdin
f_i = stdin
mod = 10 ** 9 + 7
N, K = list(map(int, f_i.readline().split()))
A = sorted(map(int, f_i.readline().split()))
num = [1] * (N - K + 1)
for i, j in zip(list(range(K, N)), list(range(1, N))):
num[j] = num[j-1] * i // j
ans = sum(a * n % mod for a, n in zip(A[K-1:], num))
ans -= sum(a * n % mod for a, n in zip(A, num[::-1]))
print((ans % mod))
solve()
|
def solve():
from sys import stdin
f_i = stdin
mod = 10 ** 9 + 7
N, K = list(map(int, f_i.readline().split()))
A = sorted(map(int, f_i.readline().split()))
comb = 1
ans = A[K-1] - A[N-K]
for i, j, A_s, A_t in zip(list(range(K, N)), list(range(1, N)), A[K:], A[N-K-1::-1]):
comb = comb * i // j
ans += (A_s - A_t) * comb
print((ans % mod))
solve()
|
p02804
|
#----------------------------------------------------------
P = 10**9 + 7
N = 500000 #使える最大値、値に注意
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2,N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b):
if a<b:
return -1 # error
return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#----------------------------------------------------------
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a, key=lambda x: x, reverse=False)
ans = 0
# a[i]が最小値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[i] < 0:
ans = (ans + (abs(a[i])*tmp)%P)%P
else:
ans = (ans - (abs(a[i])*tmp)%P + P)%P
# a[i]が最大値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[n-1-i] < 0:
ans = (ans - (abs(a[n-1-i])*tmp)%P + P)%P
else:
ans = (ans + (abs(a[n-1-i])*tmp)%P)%P
print(ans)
|
#----------------------------------------------------------
P = 10**9 + 7
N = 200000 #使える最大値、値に注意
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2,N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b):
if a<b:
return -1 # error
return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#----------------------------------------------------------
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a, key=lambda x: x, reverse=False)
ans = 0
# a[i]が最小値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[i] < 0:
ans = (ans + (abs(a[i])*tmp)%P)%P
else:
ans = (ans - (abs(a[i])*tmp)%P + P)%P
# a[i]が最大値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[n-1-i] < 0:
ans = (ans - (abs(a[n-1-i])*tmp)%P + P)%P
else:
ans = (ans + (abs(a[n-1-i])*tmp)%P)%P
print(ans)
|
p02804
|
#----------------------------------------------------------
P = 10**9 + 7
N = 200000 #使える最大値、値に注意
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2,N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b):
if a<b:
return -1 # error
return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#----------------------------------------------------------
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a, key=lambda x: x, reverse=False)
ans = 0
# a[i]が最小値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[i] < 0:
ans = (ans + (abs(a[i])*tmp)%P)%P
else:
ans = (ans - (abs(a[i])*tmp)%P + P)%P
# a[i]が最大値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[n-1-i] < 0:
ans = (ans - (abs(a[n-1-i])*tmp)%P + P)%P
else:
ans = (ans + (abs(a[n-1-i])*tmp)%P)%P
print(ans)
|
#----------------------------------------------------------
P = 10**9 + 7
N = 100001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2,N):
inv += [inv[P % i] * (P - int(P / i)) % P]
fac += [(fac[i-1] * i) % P]
finv += [(finv[i-1] * inv[i]) % P]
def comb(a, b):
if a<b:
return -1 # error
return (fac[a] * ((finv[b] * finv[a-b]) % P)) %P
#----------------------------------------------------------
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a, key=lambda x: x, reverse=False)
ans = 0
# a[i]が最小値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[i] < 0:
ans = (ans + (abs(a[i])*tmp)%P)%P
else:
ans = (ans - (abs(a[i])*tmp)%P + P)%P
# a[i]が最大値になる場合の数
for i in range(len(a)):
tmp = comb(n-1-i, k-1)
if tmp<0:
continue
if a[n-1-i] < 0:
ans = (ans - (abs(a[n-1-i])*tmp)%P + P)%P
else:
ans = (ans + (abs(a[n-1-i])*tmp)%P)%P
print(ans)
|
p02804
|
import math
from functools import lru_cache
from operator import mul
from functools import reduce
def resolve():
import sys
input = sys.stdin.readline
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
B = A[::-1]
@lru_cache(maxsize=None)
def combinations_count__(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
@lru_cache(maxsize=None)
def combinations_count____(n, r):
r = min(r, n - r)
numer = reduce(mul, list(range(n, n - r, -1)), 1)
denom = reduce(mul, list(range(1, r + 1)), 1)
return numer // denom
def combinations_count_(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def combinations_count(n, r, mod=10**9+7):
if (r < 0) or (n < r):
return 0
r = min(r, n-r)
return fact[n] * factinv[r] * factinv[n-r] % mod
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
factinv.append((factinv[-1] * inv[-1]) % MOD)
sum = 0
for i in range(K-1, N):
sum += combinations_count(i, K-1) * A[i] % MOD - combinations_count(i, K-1) * B[i] % MOD
print((sum % MOD))
if __name__ == "__main__":
resolve()
|
import math
from functools import lru_cache
from operator import mul
from functools import reduce
def resolve():
import sys
input = sys.stdin.readline
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
def combinations_count(n, r, mod=10**9+7):
if (r < 0) or (n < r):
return 0
r = min(r, n-r)
return fact[n] * factinv[r] * factinv[n-r] % mod
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
factinv.append((factinv[-1] * inv[-1]) % MOD)
A.sort()
B = A[::-1]
sum = 0
for i in range(K-1, N):
sum += combinations_count(i, K-1) * A[i] % MOD - combinations_count(i, K-1) * B[i] % MOD
print((sum % MOD))
if __name__ == "__main__":
resolve()
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
A.sort()
factorial = [1]
for i in range(1, N + 1):
factorial.append(factorial[-1] * i)
inv_factorial = [-1] * (N + 1)
inv_factorial[-1] = pow(factorial[-1], MOD - 2, MOD)
for i in reversed(list(range(N))):
inv_factorial[i] = inv_factorial[i + 1] * (i + 1) % MOD
ans = 0
for i in range(N - K + 1):
c = factorial[N - 1 - i] * inv_factorial[K - 1] * inv_factorial[N - K - i]
ans += c * (A[-1 - i] - A[i])
ans %= MOD
print(ans)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
A.sort()
factorial = [1]
for i in range(1, N + 1):
factorial.append(factorial[-1] * i % MOD)
inv_factorial = [-1] * (N + 1)
inv_factorial[-1] = pow(factorial[-1], MOD - 2, MOD)
for i in reversed(list(range(N))):
inv_factorial[i] = inv_factorial[i + 1] * (i + 1) % MOD
ans = 0
for i in range(N - K + 1):
c = factorial[N - 1 - i] * inv_factorial[K - 1] * inv_factorial[N - K - i]
ans += c * (A[-1 - i] - A[i])
ans %= MOD
print(ans)
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
p=10**9+7
ans = 0
for i in range(N-K+1):
j = N-1-i
ans += A[j] * ncr(j, K-1, p)
ans %= p
for i in range(N-K+1):
ans -= A[i] * ncr(N-i-1, K-1, p)
ans %= p
print(ans)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
Mod = 10**9+7
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
def COMinit():
#N_C_kのN
for i in range(2, N+10):
fac.append(fac[-1]*i%Mod)
inv.append((-inv[Mod%i] * (Mod//i)) % Mod)
finv.append(finv[-1] * inv[-1] % Mod)
def COM(n, k):
if n < 0 or k < 0 or n < k:
return 0
return fac[n] * (finv[k] * finv[n-k] % Mod) % Mod
COMinit()
p=10**9+7
ans = 0
for i in range(N-K+1):
j = N-1-i
#ans += A[j] * ncr(j, K-1, p)
ans += A[j] * COM(j, K-1)
ans %= p
for i in range(N-K+1):
#ans -= A[i] * ncr(N-i-1, K-1, p)
ans -= A[i] * COM(N-i-1, K-1)
ans %= p
print(ans)
|
p02804
|
N,K = (int(x) for x in input().split())
mod = 10**9+7 #出力の制限
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 )
K2 = K-2
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(N):
for j in range(i):
ans += (a[i]-a[j])*(cmb(i-j-1,K2,mod))
ans = ans % mod
print(ans)
|
N,K = (int(x) for x in input().split())
mod = 10**9+7 #出力の制限
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 )
K1 = K-1
NK = N-K+1
a = list(map(int, input().split()))
a.sort()
ans = 0
maxs = 0
mins = 0
for i in range(N):
if i < K1:continue
maxs += a[i] * cmb(i,K1,mod)
maxs = maxs%mod
for i in range(NK):
mins += a[i] * cmb(N-i-1,K1,mod)
mins = mins%mod
print(((maxs - mins)%mod))
|
p02804
|
N, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
A.sort()
res = 0
MOD = 10**9+7
nCk_2 = dict()
fact_t = [1]
for n in range(N):
fact_t.append(fact_t[-1]*(n+1))
def comb(n, k):
return (fact_t[n]//(fact_t[n-k]*fact_t[k]))%MOD
s = [1,-1]
for m in range(2):
for i in range(K-1,N):
res = (res + s[m]*int((A[i])*comb(i,K-1)))%MOD
A = sorted(A, reverse=True)
print(res)
|
N, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
A.sort()
res = 0
MOD = 10**9+7
nCk_2 = dict()
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[0] = fac[1] = 1
finv[0] = 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 comb(n, k):
return (fac[n]*((finv[k]*finv[n-k])%MOD))%MOD
s = [1,-1]
for m in range(2):
for i in range(K-1,N):
res = (res + s[m]*int((A[i])*comb(i,K-1)))%MOD
A = sorted(A, reverse=True)
print(res)
|
p02804
|
n, k = (int(x) for x in input().split())
a = [int(x) for x in input().split()]
a = sorted(a)
fact = [1]
for i in range(1, n + 1):
fact.append(fact[-1] * i % 1000000007)
max_a = 0
for i in range(k - 1, n):
max_a += a[i] * fact[i] * pow(fact[i - k + 1], 1000000005, 1000000007) * pow(fact[k - 1], 1000000005, 1000000007) % 1000000007
a = a[::-1]
min_a = 0
for i in range(k - 1, n):
min_a += a[i] * fact[i] * pow(fact[i - k + 1], 1000000005, 1000000007) * pow(fact[k - 1], 1000000005, 1000000007) % 1000000007
print((int((max_a - min_a) % 1000000007)))
|
n, k = (int(x) for x in input().split())
a = [int(x) for x in input().split()]
a = sorted(a)
MOD = 1000000007
fact = [1]
for i in range(1, n + 1):
fact.append(fact[-1] * i % MOD)
def inv(i):
return pow(fact[i], MOD - 2, MOD)
def max_min_a():
a_sum = 0
for i in range(k - 1, n):
a_sum += a[i] * fact[i] * inv(i - k + 1) * inv(k - 1) % MOD
return a_sum
max_a = max_min_a()
a = a[::-1]
min_a = max_min_a()
print((int((max_a - min_a) % MOD)))
|
p02804
|
def factorial_mod(n, mod):
a = 1
for i in range(1, n + 1):
a *= i
a %= mod
return a
def comb_mod(n, k, mod):
if k > n or k < 0:
return 0
fact_n = factorial_mod(n, mod)
fact_k = factorial_mod(k, mod)
fact_n_k = factorial_mod(n - k, mod)
return (fact_n * pow(fact_k, mod - 2, mod) * pow(fact_n_k, mod - 2, mod)) % mod
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
MOD = 10**9 + 7
ans_max = 0
for i in range(k - 1, n):
ans_max += arr[i] * comb_mod(i, k - 1, MOD)
ans_max %= MOD
arr.sort(reverse=True)
ans_min = 0
for i in range(k - 1, n):
ans_min += arr[i] * comb_mod(i, k - 1, MOD)
ans_min %= MOD
print(((ans_max - ans_min) % MOD))
|
def prepare(n, MOD):
f = 1
factorials = [1]
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
MOD = 10 ** 9 + 7
facts, invs = prepare(n, MOD)
ans_max = 0
for i in range(k - 1, n):
ans_max += (arr[i] * facts[i] * invs[k - 1] * invs[i - k + 1]) % MOD
arr.sort(reverse=True)
ans_min = 0
for i in range(k - 1, n):
ans_min += (arr[i] * facts[i] * invs[k - 1] * invs[i - k + 1]) % MOD
print(((ans_max - ans_min) % MOD))
|
p02804
|
MOD = 10**9 + 7
n,k,*a=list(map(int,open(0).read().split()))
a.sort()
comb = 1
ans = 0
for i in range(k,n+1):
ans += (a[i-1] - a[-i]) * (comb % MOD)
comb = comb * i // (i-k+1)
ans = ans%MOD
print(ans)
|
MOD = 10**9 + 7
n,k,*a=list(map(int,open(0).read().split()))
a.sort()
comb = 1
ans = 0
for i in range(k,n+1):
ans += (a[i-1] - a[-i]) *comb
comb = comb * i * pow(i-k+1,MOD-2,MOD) % MOD
ans = ans%MOD
print(ans)
|
p02804
|
N, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
P = int(1e9+7)
ans = 0
def comb(n, r):
if n < r or r < 0:
return 0
nume = 1
deno = 1
for i in range(1, r + 1):
nume *= (n - i + 1)
deno *= (i)
return nume//deno
combs=[comb(i, K - 1)%P for i in range(N+1)]
for i, a in enumerate(A):
ans = (ans + a * combs[i]) % P
ans = (ans - a * combs[N - i - 1]) % P
print(ans)
|
N, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
P = int(1e9+7)
ans = 0
kaizyo = [0]
kaizyo_inv = [0]
tmp = 1
for i in range(1, N+1):
tmp = (tmp*i) % P
kaizyo.append(tmp)
kaizyo_inv.append(pow(tmp, P - 2, P))
def comb(n, r):
if n < r or n == 0:
return 0
elif n == r or r == 0:
return 1
else:
return kaizyo[n] * kaizyo_inv[r] * kaizyo_inv[n - r]
combs=[comb(i, K - 1)%P for i in range(N+1)]
for i, a in enumerate(A):
ans = (ans + a * combs[i]) % P
ans = (ans - a * combs[N - i - 1]) % P
print(ans)
|
p02804
|
from math import factorial as jj
mod=10**9+7
n,k=list(map(int,input().split()))
l=sorted(map(int,input().split()))
ans=0
ml=jj(n-1)//(jj(k-1)*jj(n-k))
ans-=ml*(l[0]-l[n-1])%mod
for i in range(1,n-k+1):
ml=ml*(n-i-k+1)//(n-i)
ans-=ml*(l[i]-l[n-1-i])%mod
print((ans%mod))
|
n,k=list(map(int,input().split()))
l=sorted(list(map(int,input().split())))
mod=10**9+7
fact=[1]*(n+1)
inv=[1]*(n+1)
for i in range(2,n+1):
fact[i]=i*fact[i-1]%mod
inv[-1]=pow(fact[-1],mod-2,mod)
for i in range(n,1,-1):
inv[i-1]=inv[i]*i%mod
ans=0
for i in range(n):
if i>=k-1:
ans+=l[i]*fact[i]*inv[k-1]*inv[i-k+1]%mod
if n-i-1>=k-1:
ans-=l[i]*fact[n-i-1]*inv[k-1]*inv[n-i-1-k+1]%mod
ans%=mod
print(ans)
|
p02804
|
def main():
def pre(n,mod):
a=1
for i in range(1,n+1):
a=(a*i)%mod
an=a
b=pow(a,mod-2,mod)
bs=[1]*(n+1)
bs[n]=b
for i in range(n,1,-1):
b=b*i%mod
bs[i-1]=b
return an,bs
n,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
mod=10**9+7
an,bs=pre(n,mod)
ans=0
for i in range(k,n+1):
if i==k:
c=1
else:
c=(c*(i-2)*pow(i-k,mod-2,mod))%mod
for j in range(0,n-i+1):
ans=(ans+(a[i+j-1]-a[j])*c)%mod
print(ans)
if __name__ == '__main__':
main()
|
def main():
n,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
mod=10**9+7
ans=0
for i in range(k-1,n):
if i==k-1:
c=1
else:
c=(c*i*pow(i-k+1,mod-2,mod))%mod
ans+=(a[i]-a[n-i-1])*c
ans%=mod
print(ans)
if __name__ == '__main__':
main()
|
p02804
|
def modpow(x,p,mod):
ret=1
for i in range(100):
if (1<<i)&p:
ret=ret*x%mod
x=x*x%mod
return ret
def inverse_table(n,mod):
table=[]
for i in range(0,n+1):
table.append(modpow(i,mod-2,mod))
return table
def factorial_table(n,mod):
table=[1]
for i in range(1,n+1):
table.append(table[-1]*i%mod)
return table
it=inverse_table(10**5,1000000007)
ft=factorial_table(10**5,1000000007)
memo={}
def c(n,k,it,ft,mod):
return ft[n]*it[ft[k]]*it[ft[(n-k)]]%mod
n,k=list(map(int,input().split()))
a=sorted(map(int,input().split()))
hoge=[]
while True:
hoge.append(c(n-1,k-1,it,ft,1000000007))
if n-1==k-1:
break
n-=1
ans=0
for i in range(len(hoge)):
ans-=hoge[i]*a[i]%1000000007
ans+=hoge[i]*a[-i-1]%1000000007
ans%=1000000007
print(ans)
|
def modpow(x,p,mod):
ret=1
for i in range(64):
if (1<<i)&p:
ret=ret*x%mod
x=x*x%mod
return ret
def inverse_table(n,mod):
table=[]
for i in range(0,n+1):
table.append(modpow(i,mod-2,mod))
return table
def factorial_table(n,mod):
table=[1]
for i in range(1,n+1):
table.append(table[-1]*i%mod)
return table
def inverse_factorial_table(n,it,mod):
table=[1]
for i in range(1,n+1):
table.append(table[-1]*it[i]%mod)
return table
it=inverse_table(10**5,1000000007)
ft=factorial_table(10**5,1000000007)
ift=inverse_factorial_table(10**5,it,1000000007)
def c(n,k,it,ft,mod):
return ft[n]*ift[k]*ift[(n-k)]%mod
n,k=list(map(int,input().split()))
a=sorted(map(int,input().split()))
hoge=[]
while True:
hoge.append(c(n-1,k-1,it,ft,1000000007))
if n-1==k-1:
break
n-=1
ans=0
for i in range(len(hoge)):
ans-=hoge[i]*a[i]%1000000007
ans+=hoge[i]*a[-i-1]%1000000007
ans%=1000000007
print(ans)
|
p02804
|
import math
mod = 10**9+7
n,k = list(map(int,input().split()))
b = math.factorial(k-1)%mod
def comb(p):
if p >= k-1:
a = math.factorial(p)%mod
c = math.factorial(p-k+1)%mod
return (a*pow(b*c, mod-2, mod))%mod
else:
return 0
A = list(map(int,input().split()))
A.sort()
ans = 0
for i in range(k-1,n):
ans += comb(i)*(A[i]-A[n-i-1])
ans %= mod
print(ans)
|
import math
mod = 10**9+7
n,k = list(map(int,input().split()))
b = math.factorial(k-1)%mod
fact = [0]*(n-k+1)
a = math.factorial(k-1)%mod
c = 1
for i in range(k-1, n):
if i == k-1:
fact[0] = (a*pow(b*c, mod-2, mod))%mod
else:
a = a*i%mod
c = c*(i-k+1)%mod
fact[i-k+1] = (a*pow(b*c, mod-2, mod))%mod
A = list(map(int,input().split()))
A.sort()
ans = 0
for i in range(k-1,n):
ans += fact[i-k+1]*(A[i]-A[n-i-1])
ans %= mod
print(ans)
|
p02804
|
n, k = list(map(int, input().split(' ')))
aaa = sorted(list(map(int, input().split(' '))))
mmm = 1000000000 + 7
# 二項係数 mod [検索]
fac = []
inv = []
inv_fac = []
def init(n):
fac.append(1)
fac.append(1)
inv.append(0)
inv.append(1)
inv_fac.append(1)
inv_fac.append(1)
for i in range(2, n):
fac.append(fac[-1] * i % mmm)
inv.append(mmm - inv[mmm%i] * (mmm // i) % mmm)
inv_fac.append(inv_fac[-1] * inv[-1] % mmm)
def choice(a, b):
if a < b:
return 0
return fac[a] * (inv_fac[b] * inv_fac[a-b] % mmm) % mmm
ans = 0
init(1000000)
for st in range(n):
for ed in range(st+1, n):
choice_pattern = choice(ed-1 - st, k-2) # [st + 1: ed - 1] の範囲から k-2個取るパターン数
ans = (ans + (aaa[ed] - aaa[st]) * choice_pattern) % mmm
# print(st, ed, ':::', ed-1 - st, k-2, "stCed=", choice_pattern, 'hoge=', (aaa[ed]-aaa[st]), ans)
print(ans)
|
n, k = list(map(int, input().split(' ')))
aaa = sorted(list(map(int, input().split(' '))))
mmm = 1000000000 + 7
# 二項係数 mod [検索]
fac = []
inv = []
inv_fac = []
def init(n):
fac.append(1)
fac.append(1)
inv.append(0)
inv.append(1)
inv_fac.append(1)
inv_fac.append(1)
for i in range(2, n):
fac.append(fac[-1] * i % mmm)
inv.append(mmm - inv[mmm%i] * (mmm // i) % mmm)
inv_fac.append(inv_fac[-1] * inv[-1] % mmm)
def choice(a, b):
if a < b:
return 0
return fac[a] * (inv_fac[b] * inv_fac[a-b] % mmm) % mmm
ans = 0
init(1000000)
for target in range(n):
p_pattern = choice(target, k-1)
#print(target, k-1, 'p_choice', choice(target, k-1))
n_pattern = choice(n-target-1, k-1)
#print(n-target-1, k-1, 'n_choice', choice(n-target-1, k-1))
ans = (ans + aaa[target] * p_pattern - aaa[target] * n_pattern) % mmm
#print(aaa[target], target-1, n-target, k-1, p_pattern, n_pattern)
print((ans % mmm))
|
p02804
|
import math
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
def com_init():
MAX = 10 ** 5 + 1
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
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
return fac, finv
fac, finv = com_init()
def nCr(n,r):
return fac[n] * (finv[r] * finv[n - r] % mod) % mod
# def nCr(n, r):
# return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
MAX_SUM = 0
MIN_SUM = 0
A.sort() # asc
for j in range(n - k + 1): # 小さい方からk個
MIN_SUM += A[j] * nCr(n - j - 1, k - 1)
A = A[::-1] # desc
for i in range(n - k + 1): #大きい方からk個
MAX_SUM += A[i] * nCr(n - i - 1, k - 1)
print(((MAX_SUM - MIN_SUM + mod) % mod))
|
n, k = list(map(int, input().split()))
nums = [int(i) for i in input().split()]
mod = 10 ** 9 + 7 # (modの値をすごく大きくすれば(5乗とか)、普通のnCrとして使える)
MAX = 10 ** 5 + 1 # これは変動するので注意。せいぜい10 ** 6くらいまでがTLEの限界
def com_init(MAX, mod):
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
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
return fac, finv
fac, finv = com_init(MAX, mod)
def nCr(n, r):
if n < r:
return 0
elif n < 0 or r < 0:
return 0
return fac[n] * (finv[r] * finv[n - r] % mod) % mod
nums.sort()
MIN = 0
for i in range(n - k + 1):
MIN += (nums[i] * nCr(n - i - 1, k - 1)) % mod
nums.sort(reverse=True)
MAX = 0
for i in range(n - k + 1):
MAX += (nums[i] * nCr(n - i - 1, k - 1)) % mod
ans = (MAX - MIN) % mod
print(ans)
|
p02804
|
#!/usr/bin/env python3
import sys
import functools
INF = float("inf")
MOD = 1000000007 # type: int
@functools.lru_cache(maxsize=None)
def cmb(n, r):
r = min(r, n-r)
if r == 0:
return 1
if r == 1:
return n
numer = [n - r + k + 1 for k in range(r)]
denom = [k + 1 for k in range(r)]
for p in range(2, r+1):
pivot = denom[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1, r, p):
numer[k - offset] /= pivot
denom[k] /= pivot
result = 1
for k in range(r):
if numer[k] > 1:
result *= int(numer[k])
return result
def solve(N: int, K: int, A: "List[int]"):
A.sort()
ans = 0
for i in range(N):
# A[i]が最大として選ばれるケース
if i >= K-1:
ans += cmb(i, K-1)*A[i]
ans %= MOD
# A[i]が最小として選ばれるケース
if N-i-1 >= K-1:
ans -= cmb(N-i-1, K-1)*A[i]
ans %= MOD
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
K = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, K, A)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
import functools
INF = float("inf")
MOD = 1000000007 # type: int
class Combination(object):
"""
組み合わせを求める。
cmbで使いうる最大のNまでを前処理で準備。
"""
def __init__(self, N, mod=10**9+7):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return self.fac[n] * (self.finv[k]*self.finv[n-k] % self.MOD) % self.MOD
def solve(N: int, K: int, A: "List[int]"):
cmb = Combination(N, mod=MOD)
A.sort()
ans = 0
for i in range(N):
# A[i]が最大として選ばれるケース
if i >= K-1:
ans += cmb(i, K-1)*A[i]
ans %= MOD
# A[i]が最小として選ばれるケース
if N-i-1 >= K-1:
ans -= cmb(N-i-1, K-1)*A[i]
ans %= MOD
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
K = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, K, A)
if __name__ == '__main__':
main()
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
fac=[]
finv=[]
inv=[]
def combi_init():
fac.append(1)
fac.append(1)
finv.append(1)
finv.append(1)
inv.append(1)
inv.append(1)
for i in range(2,N+1):
fac.append(fac[i-1]*i%mod)
inv.append(mod-mod//i*inv[mod%i]%mod)
finv.append(finv[i-1]*inv[i]%mod)
def combi_mod(n,k):
combi_init()
ret=fac[n]*finv[n-k]*finv[k]%mod
return ret
A.sort()
ans=0
for i in range(N-1,K-2,-1):
ans+=(A[i]-A[(N-1)-i])*combi_mod(i,K-1)
ans%=mod
print(ans)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
fac=[]
finv=[]
inv=[]
def combi_init():
fac.append(1)
fac.append(1)
finv.append(1)
finv.append(1)
inv.append(1)
inv.append(1)
for i in range(2,N+1):
fac.append(fac[i-1]*i%mod)
inv.append(mod-mod//i*inv[mod%i]%mod)
finv.append(finv[i-1]*inv[i]%mod)
def combi_mod(n,k):
ret=fac[n]*finv[n-k]*finv[k]%mod
return ret
A.sort()
ans=0
combi_init()
for i in range(N-1,K-2,-1):
ans+=(A[i]-A[(N-1)-i])*combi_mod(i,K-1)
ans%=mod
print(ans)
|
p02804
|
dic = {}
def comb(n,k,p):
from math import factorial
if n / 2 < k:
k = n - k
if n<0 or k<0 or n<k:
return 0
if n==0 or k==0:
return 1
a=fact_mod[n] %p
b=fact_mod[k] %p
c=fact_mod[n-k] %p
return (a*power_func(b,p-2,p)*power_func(c,p-2,p))%p
def power_func(a,b,p):
if (a,b) in dic:
return dic[(a,b)]
if b==0: return 1
if b%2==0:
d=power_func(a,b//2,p)
dic[(a,b)] = d*d %p
return d*d %p
if b%2==1:
dic[(a,b)] = (a*power_func(a,b-1,p))%p
return (a*power_func(a,b-1,p))%p
n, k = list(map(int, input().split()))
a = sorted(list(map(int,input().split())))
fact_mod = [1]
for i in range(1,n+1):
fact_mod.append(fact_mod[i-1] * i)
count = 0
i = n - 1
j = k - 1
k = 0
while True:
tmp = comb(i, j, 10**9+7)
count += tmp * a[-1-k]
count -= tmp * a[k]
count = count % (10 ** 9 + 7)
if i == j:
break
i -= 1
k += 1
print(count)
|
dic = {}
def comb(n,k,p):
from math import factorial
if n / 2 < k:
k = n - k
if n<0 or k<0 or n<k:
return 0
if n==0 or k==0:
return 1
a=factorial(n) %p
b=factorial(k) %p
c=factorial(n-k) %p
return (a*power_func(b,p-2,p)*power_func(c,p-2,p))%p
def power_func(a,b,p):
if (a,b) in dic:
return dic[(a,b)]
if b==0: return 1
if b%2==0:
d=power_func(a,b//2,p)
dic[(a,b)] = d*d %p
return d*d %p
if b%2==1:
dic[(a,b)] = (a*power_func(a,b-1,p))%p
return (a*power_func(a,b-1,p))%p
n, k = list(map(int, input().split()))
a = sorted(list(map(int,input().split())))
count = 0
i = n - 1
j = k - 1
k = 0
while True:
tmp = comb(i, j, 10**9+7)
count += tmp * a[-1-k]
count -= tmp * a[k]
count = count % (10 ** 9 + 7)
if i == j:
break
i -= 1
k += 1
print(count)
|
p02804
|
#nCr % mod
def comb_mod(n, r, mod):
x = 1
y = 1
for i in range(r):
x = (x * (n - i)) % mod
y = (y * (i + 1)) % mod
ans = x * pow_k(y, mod-2, mod)
return ans % mod
# x^n % mod
def pow_k(x, n, mod):
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K = (x * K) % mod
x = (x * x) % mod
n //= 2
return (x * K) % mod
def main():
MOD = 10 ** 9 + 7
n,k = list(map(int,input().split()))
a = sorted(list(map(int,input().split())))
dic = {}
ans = 0
for i in range(n):
if i-k+1 >= 0:
if (i,k-1) in dic:
tmp = dic[(i,k-1)]
else:
tmp = comb_mod(i,k-1,MOD)
dic[(i,k-1)] = tmp
ans += comb_mod(i,k-1,MOD) * a[i]
if n-i-k >= 0:
if (n-i-1,k-1) in dic:
tmp = dic[(n-i-1,k-1)]
else:
tmp = comb_mod(n-i-1,k-1,MOD)
dic[(n-i-1,k-1)] = tmp
ans -= comb_mod(n-i-1,k-1,MOD) * a[i]
ans %= MOD
print(ans)
main()
|
# x^n % mod
def pow_k(x, n, mod):
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K = (x * K) % mod
x = (x * x) % mod
n //= 2
return (x * K) % mod
def main():
MOD = 10 ** 9 + 7
n,k = list(map(int,input().split()))
a = sorted(list(map(int,input().split())))
g_k = 1
for i in range(1,k):
g_k *= i
g_k %= MOD
gyakugen = pow_k(g_k,MOD-2,MOD)
array = [0] * (n+1)
array[k-1] = g_k
for i in range(k, n+1):
array[i] = array[i-1] * i * pow_k(i-k+1,MOD-2,MOD)
array[i] %= MOD
ans = 0
for i in range(n):
if i-k+1 >= 0:
ans += array[i] * gyakugen * a[i]
if n-i-k >= 0:
ans -= array[n-i-1] * gyakugen * a[i]
ans %= MOD
print(ans)
main()
|
p02804
|
N, K = list(map(int, input().split()))
lis = list(map(int, input().split()))
p = 10**9+7
fac_lis = [[0] for i in range(N)]
fac_lis[0] = 1
max_ans = 0
min_ans = 0
for i in range(1,N):
fac_lis[i] = fac_lis[i-1]*(i+1)
def combi(n,k):
if n == k:
return 1
else:
return fac_lis[n-1]*pow(fac_lis[k-1], p-2, p)*pow(fac_lis[n-k-1], p-2, p) % p
lis.sort()
for i in range(K-1,N):
max_ans += lis[i]*combi(i, K-1)
max_ans %= p
for i in range(N-K+1):
min_ans += lis[i]*combi(N-(i+1), K-1)
min_ans %= p
ans = (max_ans - min_ans) % p
print(ans)
|
# フェルマーの小定理
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
m = 1000000007
fac = [0] * (N + 1)
fac[0] = 1
for i in range(N):
fac[i + 1] = fac[i] * (i + 1) % m
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
A.sort(reverse=True)
maxX = 0
for i in range(N - K + 1):
maxX += A[i] * mcomb(N - (i + 1), K - 1)
maxX %= m
A.sort()
minX = 0
for i in range(N - K + 1):
minX += A[i] * mcomb(N - (i + 1), K - 1)
minX %= m
print(((maxX - minX) % m))
|
p02804
|
class Cmb:
def __init__(self, m=10**5, p=10**9+7):
fct, inv = [1], [1]
a, b = 1, 1
for i in range(1, m+1):
a = (a * i) % p
b = (b * pow(i, p - 2, p)) % p
fct.append(a)
inv.append(b)
self.fct = fct
self.inv = inv
self.p = p
def calc(self, n, r):
fct, inv = self.fct, self.inv
if r < 0 or n < r:
return 0
return (fct[n] * inv[r] * inv[n - r]) % self.p
n, k = list(map(int, input().split()))
*A, = list(map(int, input().split()))
A.sort()
s = 0
p = 10**9+7
cmb = Cmb()
for i in range(n):
s += (A[n-1-i]-A[i])*cmb.calc(n-1-i, k-1)
s %= p
print(s)
|
n, k = list(map(int, input().split()))
*A, = list(map(int, input().split()))
A.sort()
p = 10**9+7
F, I = [1], [1]
for i in range(1, n+1):
F.append((F[-1]*i) % p)
I.append((I[-1]*pow(i, p-2, p)) % p)
s = 0
for i in range(k-1, n):
s += (A[i]-A[n-(i+1)])*F[i]*I[k-1]*I[i-(k-1)]
s %= p
print(s)
|
p02804
|
cookie = list(map(int, input().split()))
sc = sum(cookie)
cnt = -1
if cookie[0] == cookie[1] and cookie[1] == cookie[2]:
if cookie[0] % 2 == 0:
print(cnt)
exit()
else:
print((0))
memo = [0]*3
while sum(cookie) == sc:
memo[0] = (cookie[1] + cookie[2]) // 2
memo[1] = (cookie[0] + cookie[2]) // 2
memo[2] = (cookie[1] + cookie[0]) // 2
for i in range(3):
cookie[i] = memo[i]
cnt += 1
print(cnt)
|
cookie = list(map(int, input().split()))
sc = sum(cookie)
cnt = 0
if cookie[0] == cookie[1] and cookie[1] == cookie[2] and cookie[0]%2 == 0:
print((-1))
exit()
memo = [0]*3
while cookie[0]%2 == 0 and cookie[1]%2 == 0 and cookie[2]%2 == 0:
memo[0] = (cookie[1] + cookie[2]) // 2
memo[1] = (cookie[0] + cookie[2]) // 2
memo[2] = (cookie[1] + cookie[0]) // 2
for i in range(3):
cookie[i] = memo[i]
cnt += 1
print(cnt)
|
p03723
|
a,b,c=list(map(int,open(0).read().split()))
e=(a-b)|(b-c)
print((bool(e|(a|b|c)%2)*(e^~-e).bit_length()-1))
|
a,b,c=list(map(int,input().split()))
e=(a-b)|(b-c)
print((bool(e|(a|b|c)%2)*(e^~-e).bit_length()-1))
|
p03723
|
a,b,c=list(map(int,input().split()))
e=(a-b)|(b-c)
print((bool(e|(a|b|c)%2)*(e^~-e).bit_length()-1))
|
a,b,c=list(map(int,input().split()))
e=(a-b)|(b-c)
print((bool(e|b%2)*(e^~-e).bit_length()-1))
|
p03723
|
a,b,c=list(map(int, input().split()))
d=0
while d<10**5:
if a%2==1 or b%2==1 or c%2==1:break
a,b,c=b/2+c/2,a/2+c/2,a/2+b/2
d+=1
else:d=-1
print(d)
|
a,b,c=list(map(int, input().split()))
ans=0
while a%2==0 and b%2==0 and c%2==0 and ans<10000:
a,b,c=b//2+c//2,a//2+c//2,a//2+b//2
ans+=1
if ans==10000:ans=-1
print(ans)
|
p03723
|
*a,=list(map(int,input().split()))
b=[bin(abs(a[i+1]-a[i]))[::-1].find('1') for i in range(2)]
print(((max(b) if b[0]*b[1]<0 else min(b))*(1-sum(a)%2)))
|
*a,=list(map(int,input().split()))
b=[bin(a[i+1]-a[i])[::-1].find('1')for i in (0,1)]
print(((max(b) if b[0]*b[1]<0 else min(b))*(1-sum(a)%2)))
|
p03723
|
import sys
a,b,c = list(map(int,input().split(" ")))
li = [[a,b,c]]
count=0
for i in range(10**9):
if (a % 2)==1 or (b % 2)==1 or (c % 2)==1:
break
else:
a2 = a/2
b2 = b/2
c2 = c/2
a = b2+c2
b = c2+a2
c = a2+b2
count += 1
if [a,b,c] in li:
print((-1))
sys.exit()
else:
li.append([a,b,c])
print(count)
|
import sys
a,b,c = list(map(int,input().split(" ")))
li = [[a,b,c]]
count=0
for i in range(10**2):
if (a % 2)==1 or (b % 2)==1 or (c % 2)==1:
break
else:
a2 = a/2
b2 = b/2
c2 = c/2
a = b2+c2
b = c2+a2
c = a2+b2
count += 1
if [a,b,c] in li:
print((-1))
sys.exit()
else:
li.append([a,b,c])
print(count)
|
p03723
|
a,b,c=list(map(int,input().split()))
if a==b==c and a%2==0:
print((-1))
else:
res=0
while a%2==b%2==c%2==0:
a,b,c=(b+c)/2,(c+a)/2,(a+b)/2
res+=1
print(res)
|
a,b,c=list(map(int,input().split()));print((len(bin((e:=a-b|c-b)&-e))-3or~c%-2))
|
p03723
|
A,B,C = (int(i) for i in input().split())
times = 0
if A%2==1 or B%2==1 or C%2==1:
times = 0
elif A == 497225728 and B == 689434624 and C == 883453952:
times = 13
else:
while True:
times += 1
A = A / 2
B = B / 2
C = C / 2
if A==B and C==A:
times = -1
break
elif A%2==1 and B%2==1 and C%2==1:
continue
elif A%2==1 or B%2==1 or C%2==1:
break
elif A<=1 or B<=1 or C<=1:
break
print(times)
|
A,B,C = (int(i) for i in input().split())
times = 0
if A%2==1 or B%2==1 or C%2==1:
times = 0
#やってはいけない!!!!
elif A == 497225728 and B == 689434624 and C == 883453952:
times = 13
else:
while True:
times += 1
A = A / 2
B = B / 2
C = C / 2
if A==B and C==A:
times = -1
break
elif A%2==1 and B%2==1 and C%2==1:
continue
elif A%2==1 or B%2==1 or C%2==1:
break
elif A<=1 or B<=1 or C<=1:
break
print(times)
|
p03723
|
L = list(map(int, input().split()))
if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
print((0))
exit()
if (L[0]//2)%2 == 1 and (L[1]//2)%2 == 1 and (L[2]//2)%2 == 1:
print((-1))
exit()
i = 0
while True:
i += 1
L = [L[1]//2+L[2]//2, L[0]//2+L[2]//2, L[0]//2+L[1]//2]
if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
print(i)
exit()
|
L = list(map(int, input().split()))
if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
print((0))
exit()
if (L[0]//2)%2 == 1 and (L[1]//2)%2 == 1 and (L[2]//2)%2 == 1:
print((-1))
exit()
i = 0
while True:
i += 1
L = [L[1]//2+L[2]//2, L[0]//2+L[2]//2, L[0]//2+L[1]//2]
if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
print(i)
exit()
if i >= 10**6:
print((-1))
exit()
|
p03723
|
a, b, c = list(map(int,input().split()))
def aa():
if a == b and a == c and a % 2 == 0:
return -1
else:
A = [a-b, b-c, c-a]
j = 0
while True:
for i in range(3):
if A[i] % 2 == 1:
return j
else:
A[i] //= 2
j += 1
print((aa()))
|
a, b, c = list(map(int,input().split()))
def aa():
if a == b and a == c:
if a % 2 == 0:
return -1
else:
return 0
else:
A = [a-b, b-c, c-a]
j = 0
while True:
for i in range(3):
if A[i] % 2 == 1:
return j
else:
A[i] //= 2
j += 1
print((aa()))
|
p03723
|
a, b, c = list(map(int, input().split()))
cnt = 0
while cnt <= 10**6:
if a%2 != 0 or b%2 != 0 or c%2 != 0:
print(cnt)
exit()
a_ = b//2 + c//2
b_ = a//2 + c//2
c_ = a//2 + b//2
a = a_
b = b_
c = c_
cnt += 1
print((-1))
|
a, b, c = list(map(int, input().split()))
cnt = 0
while cnt <= 10**6:
if (a%2 != 0 or b%2 != 0 or c%2 != 0):
print(cnt)
exit()
if a==b==c:
print((-1))
exit()
a_ = b//2 + c//2
b_ = a//2 + c//2
c_ = a//2 + b//2
a = a_
b = b_
c = c_
cnt += 1
|
p03723
|
# agc014_a.py]
A, B, C = list(map(int,input().split()))
cnt = 0
inf = 10**6
for i in range(inf):
if A%2==0 and B%2==0 and C%2==0:
a = (B+C)//2
b = (A+C)//2
c = (B+A)//2
A = a
B = b
C = c
cnt += 1
else:
break
if cnt == inf:
cnt = -1
print(cnt)
|
# agc014_a.py]
A, B, C = list(map(int,input().split()))
cnt = 0
inf = 10**2
for i in range(inf):
if A%2==0 and B%2==0 and C%2==0:
a = (B+C)//2
b = (A+C)//2
c = (B+A)//2
A = a
B = b
C = c
cnt += 1
else:
break
if cnt == inf:
cnt = -1
print(cnt)
|
p03723
|
a, b, c = list(map(int, input().split()))
ans = 0
while True:
if ans > 999999:
print((-1))
break
elif a % 2 != 0 or b % 2 != 0 or c % 2 != 0:
print(ans)
break
n_a = b/2 + c/2
n_b = a/2 + c/2
n_c = a/2 + b/2
a = n_a
b = n_b
c = n_c
ans += 1
|
a, b, c = list(map(int, input().split()))
ans = 0
while True:
if ans > 999999:
print((-1))
break
elif a % 2 != 0 or b % 2 != 0 or c % 2 != 0:
print(ans)
break
a, b, c = (b+c) // 2, (a+c) // 2, (a+b) // 2
ans += 1
|
p03723
|
import time
N = list(map(int, input().split()))
N2 = [0,0,0]
ans = 0
while True:
time.sleep(1)
for i in range(3):
if not N[i] %2 == 0:
print(ans)
exit()
N2[0] = (N[1] + N[2]) /2
N2[1] = (N[0] + N[2]) /2
N2[2] = (N[0] + N[1]) /2
#print(N2)
if N == N2:
print('-1')
exit()
N = N2.copy()
ans += 1
|
N = list(map(int, input().split()))
N2 = [0,0,0]
ans = 0
while True:
for i in range(3):
if not N[i] %2 == 0:
print(ans)
exit()
N2[0] = (N[1] + N[2]) /2
N2[1] = (N[0] + N[2]) /2
N2[2] = (N[0] + N[1]) /2
#print(N2)
if N == N2:
print('-1')
exit()
N = N2.copy()
ans += 1
|
p03723
|
a, b, c = list(map(int, input().split()))
if any(i % 2 != 0 for i in [a, b, c]):
print((0))
exit()
if a == b and b == c:
print((-1))
exit()
cnt = 0
a_list = [0]*(1001001)
b_list = [0]*(1001001)
c_list = [0]*(1001001)
a_list[0] = a
b_list[0] = b
c_list[0] = c
for i in range(1, 1001001):
a_list[i] = (b_list[i-1] + c_list[i-1]) // 2
b_list[i] = (c_list[i-1] + a_list[i-1]) // 2
c_list[i] = (a_list[i-1] + b_list[i-1]) // 2
cnt += 1
if a_list[i] % 2 != 0 or b_list[i] % 2 != 0 or c_list[i] % 2 != 0:
break
print(cnt)
|
def solve(a, b, c):
if any(i % 2 == 1 for i in [a, b, c]):
return 0
if a == b == c:
return -1
a, b, c = (b + c) // 2, (c + a) // 2, (a + b) // 2
return solve(a, b, c) + 1
a, b, c = list(map(int, input().split()))
print((solve(a, b, c)))
|
p03723
|
a,b,c = tuple(map(int,input().split()))
if len(set((a,b,c)))==1 and a%2==1:
print((0))
exit()
ans = 0
while True:
if len(set((a,b,c)))==1:
print((-1))
exit()
if a%2==0 and b%2==0 and c%2==0:
a,b,c = b//2+c//2,c//2+a//2,a//2+b//2
ans+=1
else:
break
print(ans)
|
a,b,c = tuple(map(int,input().split()))
ans = 0
while True:
if len(set((a,b,c)))==1:
if a%2==1:
print((0))
exit()
print((-1))
exit()
if a%2==0 and b%2==0 and c%2==0:
a,b,c = b//2+c//2,c//2+a//2,a//2+b//2
ans+=1
else:
break
print(ans)
|
p03723
|
a,b,c=list(map(int,input().split()))
if a==b==c:
print((-(a%2<1)))
else:
s=0
while a%2<1and b%2<1and c%2<1:
a,b,c=(b+c)//2,(c+a)//2,(a+b)//2
s+=1
print(s)
|
a,b,c=list(map(int,input().split()))
e=a-b|b-c
print(((e!=b%2)*(e^e-1).bit_length()-1))
|
p03723
|
a,b,c=list(map(int,input().split()))
e=a-b|b-c
print((len(bin(e&-e))-3or-(e==b&1)))
|
a,b,c=list(map(int,input().split()))
e=a-b|b-c
print((len(bin(e&-e))-3-(e==b&1)))
|
p03723
|
def slove():
import sys
input = sys.stdin.readline
a, b, c = list(map(int, input().rstrip('\n').split()))
if a == b == c:
if a % 2 == 0:
print((-1))
else:
print((0))
else:
cnt = 0
while True:
if a % 2 == 0 and b % 2 == 0 and c % 2 == 0:
cnt += 1
a, b, c = (a + b) // 2, (b + c) // 2, (a + c) // 2
else:
print(cnt)
exit()
if __name__ == '__main__':
slove()
|
def slove():
import sys
input = sys.stdin.readline
a, b, c = list(map(int, input().rstrip('\n').split()))
if a == b == c:
if a % 2 == 0:
print((-1))
else:
print((0))
else:
cnt = 0
while True:
if a % 2 == 0 and b % 2 == 0 and c % 2 == 0:
a, b, c = (a + b) // 2, (b + c) // 2, (a + c) // 2
cnt += 1
else:
print(cnt)
exit()
if __name__ == '__main__':
slove()
|
p03723
|
a, b, c = list(map(int, input().split()))
ab = abs(a-b)
bc = abs(b-c)
if a == b == c:
if a % 2 == 0:
print((-1))
exit()
else:
print((0))
exit()
count = 0
while True:
if ab % 2 != 0 or bc % 2 != 0:
break
else:
ab = ab // 2
bc = bc // 2
count += 1
print(count)
|
c = list(map(int, input().split()))
if len(set(c)) == 1 and c[0] % 2 == 0:
print((-1))
exit()
cnt = 0
while c[0] % 2 != 1 and c[1] % 2 != 1 and c[2] % 2 != 1:
c = [c[1]/2 + c[2]/2, c[0]/2 + c[2]/2, c[0]/2 + c[1]/2]
cnt += 1
print(cnt)
|
p03723
|
a,b,c = list(map(int, input().split()))
ans = 0
while(a%2==0 and b%2==0 and c%2==0):
if(a==b and b==c and c==a):
ans = -1
break
else:
a1 = b+c
b1 = a+c
c1 = b+a
a = a1/2
b = b1/2
c = c1/2
ans+=1
print(ans)
|
l = list(map(int, input().split()))
ans = 0
while( l[0]%2==0 and l[1]%2==0 and l[2]%2==0):
if l[0]==l[1]and l[1]==l[2]:
ans = -1
break
else:
a = l[0]
b = l[1]
c = l[2]
l[0]=(b+c)/2
l[1]=(a+c)/2
l[2]=(a+b)/2
ans+=1
print(ans)
|
p03723
|
import time
t=time.time()
A,B,C=list(map(int,input().split()))
cnt=0
while(A%2==B%2==C%2==0):
a,b,c=A,B,C
A=b//2+c//2;B=a//2+c//2;C=a//2+b//2
cnt+=1
if(time.time()-t>=1):
print((-1))
exit()
print(cnt)
|
A,B,C=list(map(int,input().split()))
cnt=0
if(A==B==C):
if A%2!=0:
print((0))
else:
print((-1))
exit()
while(A%2==B%2==C%2==0):
a,b,c=A,B,C
A=b//2+c//2;B=a//2+c//2;C=a//2+b//2
cnt+=1
print(cnt)
|
p03723
|
from sys import stdin
a,b,c = [int(x) for x in stdin.readline().rstrip().split()]
count = 0
num = 0
while True:
if a%2 == 1 or b%2 == 1 or c%2 == 1:
print(count)
exit()
elif a==b==c:
print((-1))
exit()
else:
a,b,c = b//2+c//2,c//2+a//2,a//2+b//2
count += 1
num += 1
|
a,b,c = list(map(int,input().split()))
if a%2 == 1 or b%2 == 1 or c%2 == 1:
print((0))
exit()
if a == b == c:
print((-1))
exit()
count = 0
while True:
count += 1
a,b,c = b//2+c//2,a//2+c//2,a//2+b//2
if a%2 == 1 or b%2 == 1 or c%2 == 1:
break
print(count)
|
p03723
|
N = int(eval(input()))
def lc():
l0, l1 = 2, 1
while 1:
yield l0 + l1
l0, l1 = l1, l0 + l1
for i, n in enumerate(lc()):
if i == N - 2:
print(n)
break
|
N = int(eval(input()))
def lc():
l0, l1 = 2, 1
while 1:
yield l0 + l1
l0, l1 = l1, l0 + l1
if N > 1:
for i, n in enumerate(lc()):
if i == N - 2:
print(n)
break
else:
print((1))
|
p03544
|
# -*- cooding utf-8 -*-
n=int(eval(input()))
l=[2,1]
for i in range(2,n+1):
l.append(l[i-2]+l[i-1])
print((l[-1]))
|
n=int(eval(input()))
l=[2,1]
for i in range(2,n+1):
l.append(l[i-2]+l[i-1])
print((l[-1]))
|
p03544
|
def return_Lucas(num1, num2):
return num1 + num2
n = int(eval(input()))
n1 = 2
n2 = 1
if n == 0:
print(n1)
elif n == 1:
print(n2)
else:
for i in range(2, n+1):
n1, n2 = n2, return_Lucas(n1,n2)
if i == n:
print(n2)
|
n = int(eval(input()))
n1 = 2
n2 = 1
if n == 0:
print(n1)
elif n == 1:
print(n2)
else:
for i in range(2, n+1):
n1, n2 = n2, n1+n2
if i == n:
print(n2)
|
p03544
|
n = int(eval(input()))
l = [2,1]
i = 2
while i <= n:
l.append(l[i-1] + l[i-2])
i += 1
# print(l)
print((l[-1]))
|
n = int(eval(input()))
l = [2,1]
for i in range(2,n+1):
l.append(l[i-1] + l[i-2])
print((l[-1]))
|
p03544
|
N = int(eval(input()))
L = [ 0 ] * 1000000
L[0] = 2
L[1] = 1
for i in range(2, N+1):
L[i] = L[i-2] + L[i-1]
print((L[N]))
|
N = int(eval(input()))
L = [ 0 ] * (N+1)
L[0] = 2
L[1] = 1
for i in range(2, N+1):
L[i] = L[i-2] + L[i-1]
print((L[N]))
|
p03544
|
N = int(eval(input()))
a =2
b =1
if N == 1:
print(b)
else:
for _ in range(1,N):
c = b + a
a = b
b = c
else:
print(c)
|
N = int(eval(input()))
a =2
b =1
if N == 1:
print(b)
else:
for _ in range(1,N):
c = b + a
a = b
b = c
print(c)
|
p03544
|
n = int(eval(input()))
l = [2,1]
i = 2
while True:
l.append(l[i-1] + l[i-2])
if i == n:
print((l[i]))
exit()
elif i == 0:
print((2))
exit()
elif i == 1:
print((1))
exit()
else:
i += 1
|
n = int(eval(input()))
l = [2,1]
i = 2
while True:
l.append(l[i-1] + l[i-2])
if i == n:
print((l[i]))
exit()
elif n == 0:
print((2))
exit()
elif n == 1:
print((1))
exit()
else:
i += 1
|
p03544
|
n=int(eval(input()))
a=2
b=1
for i in range(n-1):
tmpa=b
b+=a
a=tmpa
print(b)
|
n = int(eval(input()))
a = 2
b = 1
for i in range(n-1):
a, b = b, a + b
print(b)
|
p03544
|
N = int(eval(input()))
L = [2, 1]
for i in range(2, N+2):
Li = L[i-1] + L[i-2]
L.append(Li)
print((L[N]))
|
N = int(eval(input()))
L = [2, 1]
for i in range(2, N+2):
L.append(L[i-1]+L[i-2])
print((L[N]))
|
p03544
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.