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