P = 10**9 + 7

N = 1000000

inv_t = [0]+[1]

for i in range(2,N):

    inv_t += [inv_t[P % i] * (P - int(P / i)) % P]







n, k = list(map(int, input().split()))

A = list(map(int, input().split()))

mod = 10 ** 9 + 7



A.sort()



mini_count = 0

maxim_count = 0

pattern = 1

for i in range(n-k, -1, -1):

    mini = A[i]

    mini_count += mini * pattern % mod

    mini_count %= mod

    pattern = pattern * (n-i) * inv_t[n-i-k+1] % mod





pattern = 1

for i in range(n-k+1, 0, -1):

    maxim = A[-i]

    maxim_count += maxim * pattern % mod

    maxim_count %= mod

    pattern = pattern * (n-i+1) * inv_t[n-i-k+2] % mod



ans = maxim_count - mini_count

ans %= mod



print(ans)
P = 10**9 + 7

N = 200000

inv_t = [0]+[1]  # 逆元

for i in range(2, N):

    inv_t += [inv_t[P % i] * (P - int(P / i)) % P]





n, k = list(map(int, input().split()))

A = list(map(int, input().split()))

mod = 10 ** 9 + 7



A.sort()

mini_count = 0

maxim_count = 0

pattern = 1

"""

minX, maxXとして選ばれるのはそれぞれ

minX:sortAの右からk番目(大きい数値からk個取った時の最小値)とそれより左の要素

maxX:sortAの左からk番目(小さい数値からk個取った時の最大値)とそれより右の要素

選ばれるパターンはminXの場合自分の要素より右にある要素からk-1個を選ぶパターン数

つまり最初は(k-1)C(k-1) = 1

選べる要素が一つ増えるごとに

tC(k-1) ⇒ (t+1)C(k-1)のように増えるので

t * t-1 * t-2 ... * t-k ⇒ t+1 * t * t-1 ... * t-k+1 であり

つまりパターン数は (t+1) / (t-k) 倍になる

"""

for idx in range(k, n + 1):

    mini = A[-idx]  #

    mini_count += mini * pattern % mod

    mini_count %= mod



    maxim = A[idx - 1]

    maxim_count += maxim * pattern % mod

    maxim_count %= mod



    pattern = pattern * (idx) * inv_t[idx + 1 - k] % mod # 割り算のmodは逆元をかける



ans = maxim_count - mini_count

ans %= mod



print(ans)
P = 10**9 + 7
N = 1000000
inv_t = [0] + [1]
for i in range(2, N):
    inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
A.sort()
mini_count = 0
maxim_count = 0
pattern = 1
for i in range(n - k, -1, -1):
    mini = A[i]
    mini_count += mini * pattern % mod
    mini_count %= mod
    pattern = pattern * (n - i) * inv_t[n - i - k + 1] % mod
pattern = 1
for i in range(n - k + 1, 0, -1):
    maxim = A[-i]
    maxim_count += maxim * pattern % mod
    maxim_count %= mod
    pattern = pattern * (n - i + 1) * inv_t[n - i - k + 2] % mod
ans = maxim_count - mini_count
ans %= mod
print(ans)

P = 10**9 + 7
N = 200000
inv_t = [0] + [1]  # 逆元
for i in range(2, N):
    inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
A.sort()
mini_count = 0
maxim_count = 0
pattern = 1
"""
minX, maxXとして選ばれるのはそれぞれ
minX:sortAの右からk番目(大きい数値からk個取った時の最小値)とそれより左の要素
maxX:sortAの左からk番目(小さい数値からk個取った時の最大値)とそれより右の要素
選ばれるパターンはminXの場合自分の要素より右にある要素からk-1個を選ぶパターン数
つまり最初は(k-1)C(k-1) = 1
選べる要素が一つ増えるごとに
tC(k-1) ⇒ (t+1)C(k-1)のように増えるので
t * t-1 * t-2 ... * t-k ⇒ t+1 * t * t-1 ... * t-k+1 であり
つまりパターン数は (t+1) / (t-k) 倍になる
"""
for idx in range(k, n + 1):
    mini = A[-idx]  #
    mini_count += mini * pattern % mod
    mini_count %= mod
    maxim = A[idx - 1]
    maxim_count += maxim * pattern % mod
    maxim_count %= mod
    pattern = pattern * (idx) * inv_t[idx + 1 - k] % mod  # 割り算のmodは逆元をかける
ans = maxim_count - mini_count
ans %= mod
print(ans)

-N = 1000000 -inv_t = [0] + [1] +N = 200000 +inv_t = [0] + [1]  # 逆元 -for i in range(n - k, -1, -1): -    mini = A[i] +""" +minX, maxXとして選ばれるのはそれぞれ +minX:sortAの右からk番目(大きい数値からk個取った時の最小値)とそれより左の要素 +maxX:sortAの左からk番目(小さい数値からk個取った時の最大値)とそれより右の要素 +選ばれるパターンはminXの場合自分の要素より右にある要素からk-1個を選ぶパターン数 +つまり最初は(k-1)C(k-1) = 1 +選べる要素が一つ増えるごとに +tC(k-1) ⇒ (t+1)C(k-1)のように増えるので +t * t-1 * t-2 ... * t-k ⇒ t+1 * t * t-1 ... * t-k+1 であり +つまりパターン数は (t+1) / (t-k) 倍になる +""" +for idx in range(k, n + 1): +    mini = A[-idx]  # -    pattern = pattern * (n - i) * inv_t[n - i - k + 1] % mod -pattern = 1 -for i in range(n - k + 1, 0, -1): -    maxim = A[-i] +    maxim = A[idx - 1] -    pattern = pattern * (n - i + 1) * inv_t[n - i - k + 2] % mod +    pattern = pattern * (idx) * inv_t[idx + 1 - k] % mod  # 割り算のmodは逆元をかける