Problem:
 Score : 300 points    Problem Statement Fennec is fighting with N monsters.  The health of the i -th monster is H_i .  Fennec can do the following two actions:   Attack: Fennec chooses one monster. That monster's health will decrease by 1 .  Special Move: Fennec chooses one monster. That monster's health will become 0 .   There is no way other than Attack and Special Move to decrease the monsters' health.  Fennec wins when all the monsters' healths become 0 or below.  Find the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning when she can use Special Move at most K times.      Constraints  1 \leq N \leq 2 \times 10^5  0 \leq K \leq 2 \times 10^5  1 \leq H_i \leq 10^9  All values in input are integers.         Input Input is given from Standard Input in the following format:  N  K  H_1  ...  H_N       Output Print the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning.        Sample Input 1 3 1
4 1 5      Sample Output 1 5  By using Special Move on the third monster, and doing Attack four times on the first monster and once on the second monster, Fennec can win with five Attacks.       Sample Input 2 8 9
7 9 3 2 3 8 4 6      Sample Output 2 0  She can use Special Move on all the monsters.       Sample Input 3 3 0
1000000000 1000000000 1000000000      Sample Output 3 3000000000  Watch out for overflow.

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort(reverse=True)

ans = sum(H[K:])
print(ans)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

if N <= K:
    ans = 0
else:
    H.sort()
    ans = sum(H[:N - K])
print(ans)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

if N <= K:
    print(0)
else:
    H = sorted(H)[::-1]
    print(sum(H[K:]))

Solution (Python):
N,K = map(int,input().split())
H = list(map(int,input().split()))

if N <= K:
    print(0)
else:
    H.sort()
    if K == 0:
        print(sum(H))
    else:
        print(sum(H[:-K]))

Solution (Python):
N,K=map(int,input().split())
H=sorted(list(map(int,input().split())))[::-1]
print(sum(H[K:]))

Solution (Python):
N, K, *H = map(int, open(0).read().split())

H.sort(reverse=True)
print(sum(H[K:]))

Solution (Python):
N, K = map(int, input().split())
H = sorted(list(map(int, input().split())), reverse=True)
if N <= K:
  print(0)
else:
	print(sum(H[K:]))

Solution (Python):
N, K = map(int, input().split())
*H, = map(int, input().split())
H.sort(key=lambda x: -x)
H = H[K:]
print(sum(H))

Solution (Python):
from sys import stdin

N, K = [int(x) for x in stdin.readline().rstrip().split()]
H = [int(x) for x in stdin.readline().rstrip().split()]

H.sort()

if N <= K:
    print(0)
else:
    print(sum(H[:N - K]))

Solution (Python):
N,K = list(map(int, input().split()))
Hs = list(map(int, input().split()))

if N < K:
    print(0)
    exit()

Hs.sort(reverse=True)
ans = sum(Hs[K:])

print(ans)

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N, K = MAP()
A = sorted(LIST(), reverse=1)

if K >= N:
    print(0)
    exit()

A = A[K:]
print(sum(A))

Solution (Python):
n, k = map(int, input().split())
H = list(map(int, input().split()))
H.sort(reverse=True)
print(sum(H[k:]))

Solution (Python):
import sys
input = sys.stdin.readline
from collections import deque

N,K = map(int,input().split())
H = deque(sorted([int(i) for i in input().split()]))

ans = 0
while K > 0 and H:
    H.pop()
    ans += 1
    K -= 1

print(sum(H))

Solution (Python):
n, k = map(int, input().split())
H = list(map(int, input().split()))
H.sort()

if k >= n:
    print(0)
    exit()

for _ in range(k):
    H.pop()
ans = sum(H)
print(ans)

Solution (Python):
N, K = [int(i) for i in input().split()]
H = [int(i) for i in input().split()]
H.sort()
ans = 0
if K > 0:
    ans += sum(H[:-K])
else:
    ans += sum(H)
print(ans)

Solution (Python):
import math
N,K = map(int, input().split())
H = list(map(int, input().split()))
H.sort(reverse=True)
ans = 0

if K>=N:
  print(0)
  exit()

ans = sum(H[K:])
print(ans)

Solution (Python):
N,K = map(int,input().split())
H = list( map(int,input().split()))

H.sort()

if N < K:
    K = N

for i in range(K):
    H[-i-1] = 0

print(sum(H))

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort()
ans = 0
for i in range(N - K):
    ans += H[i]
print(ans)

Solution (Python):
import queue
import copy
import math
from collections import deque

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

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

sorted_hn = sorted(hn, reverse=True)

rest = sorted_hn[k:]

print(sum(rest))

Solution (Python):
from collections import deque

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

Hs.sort(reverse=True)
Hs = deque(Hs)

for i in range(k):
    if len(Hs) == 0:
        print(0)
        exit()
    Hs.popleft()


print(sum(Hs))

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

sortedH = sorted(H, reverse = True)

attackNum = 0
for i in range(K, N):
    attackNum += sortedH[i]

print(attackNum)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

monsters = sorted(H)

if N <= K:
    ans = 0
else:
    ans = sum(monsters[:N - K])

print(ans)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort(reverse=True)

H = H[K:]
print(sum(H))

Solution (Python):
N,K = map(int,input().split(" "))
H = list(map(int,input().split(" ")))
H.sort()
H.reverse()
tmp = H[K::]
print(sum(tmp))

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))
h = sorted(h)

if len(h) <= k:
    print(0)
else:
    if k == 0:
        print(sum(h))
    else:
        print(sum(h[:-k]))

Solution (Python):
n, k = map(int, input().split())
a_ls = list(map(int, input().split()))
a_ls.sort(reverse =True)
sum_at = 0
for i in range(k, n):
    sum_at+=a_ls[i]
print(sum_at)

Solution (Python):
n,k=map(int,input().split())

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

h.sort()

print(sum(h[:len(h)-k])) if n>k else print(0)

Solution (Python):
n, k = map(int, input().split())
h = sorted(list(map(int, input().split())), reverse = True)
count = 0

if k >= n:
    print(0)
    exit()

for i in range(k, n):
    count += h[i]

print(count)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

H = sorted(H, reverse=True)

if K >= N:
    print(0)
else:
    print(sum(H[K:]))

Solution (Python):
n,k=map(int,input().split())
H=[int(i) for i in input().split()]
k=min(n,k)
H.sort()
print(sum(H[:n-k]))

Solution (Python):
N, K = map(int, input().split())
H = [int(x) for x in input().split()]
H = sorted(H)
ans = 0
for i in range(N - K):
    ans += H[i]
print(ans)

Solution (Python):
N, K = map(int,input().split())
H = list(map(int,input().split()))
H = sorted(H)[::-1]
ans = 0
for k in range(K,N):
    ans += H[k]
print(ans)

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))
if k >= n:
    print(0)
else:
    h.sort()
    count = 0
    for i in range(n - k):
        count += h[i]
    print(count)

Solution (Python):
n, k = map(int,input().split())
alist=list(map(int, input().split()))

alist=sorted(alist)
atk=0

atk+=sum(alist[:max(n-k, 0)])
print(atk)

Solution (Python):

N,K=map(int,input().split())
H=list(map(int,input().split()))
H.sort(reverse=True)

L=sum(H[K:])
print(L)

Solution (Python):

N,K= map(int,input().split())
H =list(map(int,input().split()))


H = sorted(H)

ans = 0
for i in range(N-K):
    ans += H[i]
print(ans)

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))

h.sort(reverse=True)

hissatsu = h[:k]
normal = h[k:]

print(sum(normal))

Solution (Python):
def solve():
    N, K, *H = map(int, open(0).read().split())
    H.sort(reverse=True)
    ans = sum(H[K:])
    print(ans)


if __name__ == '__main__':
    solve()

Solution (Python):
n,k=map(int,input().split())
H=(list(sorted(map(int,input().split()))))
if k==0:
    print(sum(H))
else:
    print(sum(H[:-k]))

Solution (Python):
N, K = map(int,input().split())
H = list(map(int,input().split()))
ans = 0
H.sort()
for i in range(N-K):
    ans += H[i]
print(ans)

Solution (Python):
N, K = map(int, input().split())
H = [int(i) for i in input().split()]
H = sorted(H, reverse=True)
h = H[K:]
print(sum(h))

Solution (Python):
def main():
    N, K = map(int, input().split())
    H = list(map(int, input().split()))
    H.sort(reverse=True)
    cnt = 0
    ans = 0
    for h in H:
        if cnt < K:
            cnt += 1
        else:
            ans += h
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
n,k = map(int,input().split())
lst = list(map(int,input().split()))

lst.sort()
if k>=n:
    print(0)
else:
    lst.sort()
    cnt = 0
    for i in range(n-k):
        cnt += lst[i]
    print(cnt)

Solution (Python):
import sys
import math
import functools
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

n, k = na()
h = na()
h.sort(reverse=True)
h[:k] = [0]*k
print(sum(h))

Solution (Python):
n,k=map(int,input().split())
l=list(map(int,input().split()))

l.sort()
s=0
for i in range(len(l)-k):
    s+=l[i]
print(s)

Solution (Python):
def main():
    N, K = map(int, input().split())
    H = list(map(int, input().split()))
    H.sort(reverse=True)
    if N <= K:
        print(0)
    else:
        print(sum(H[K:]))
main()

Solution (Python):
n, k = map(int, input().split())

h = list(map(int, input().split()))
h = sorted(h)

for i in range(k):
    if len(h) == 0:
        h.append(0)
        break
    h.pop()

print(sum(h))

Solution (Python):
import math
N,K = list(map(int,input().split()))
H = list(map(int,input().split()))
H = sorted(H,reverse=True)
print(sum(H[K:]))

Solution (Python):
n,k=map(int,input().split())
ls=list(map(int,input().split()))
ls.sort()
ls.reverse()
print(sum(ls[k:]))

Solution (Python):
n,k=[int(x) for x in input().split()]
h=[int(x) for x in input().split()]
if n<=k:
    print(0)
else:
    print(sum(sorted(h)[:n-k]))

Solution (Python):
n,k = map(int, input().split())
h = list(map(int, input().split()))

h.sort(reverse = True)

ans = 0
for i in range(k,n):
    ans += h[i]

print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

N, K = map(int, input().split())
H = list(map(int, input().split()))

H = sorted(H, reverse=True)
for i in range(min(K, N)):
    H[i] = 0

print(sum(H))

Solution (Python):
n, k = map(int, input().split())
H = list(map(int, input().split()))
H = sorted(H)[::-1]

cnt = 0
for i in range(n):
    if i < k:
        pass
    else:
        cnt += H[i]

print(cnt)

Solution (Python):
import os,sys
from io import BytesIO, IOBase

def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())

mod=1000000007

import math  

for i in range(1):
    n,k=mi()
    h=li()
    h.sort(reverse=True)
    ans=sum(h[k:n])
    print(ans)

Solution (Python):


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

if k >= n:
    print(0)
else:
    arr = arr[k:]
    print(sum(arr))

Solution (Python):
N,K = map(int,input().split())
*H, = map(int,input().split())

H.sort()

for _ in [0]*min(K,N):
    H.pop()

ans = sum(H)
print(ans)

Solution (Python):
n,k = map(int, input().split())
h = list(map(int, input().split()))

h.sort()

if k>=n:
    print(0)
else:
    ans=0
    for i in range(n-k):
        ans+=h[i]
    print(ans)

Solution (Python):
N, K = map(int, input().split())
H = sorted(map(int, input().split()))
if K >= N:
    print(0)
else:
    print(sum(H[:(N - K)]))

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))
h = sorted(h, reverse=True)
if n <= k:
    print(0)
else:
    print(sum(h[k:]))

Solution (Python):

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

if n<=k:
    print(0)
else:
    h.sort()
    print(sum(h[:n-k]))

Solution (Python):
N, K = map(int, input().split())
* H, = map(int, input().split())
H.sort()
H.reverse()
for k in range(min(K, N)):
    H[k] = 0
print(sum(H))

Solution (Python):
n,k=map(int,input().split())
h=list(map(int,input().split()))
h.sort(reverse=True)
print(sum(h[k:]))

Solution (Python):
import sys
input = sys.stdin.readline

n, k = map(int, input().split())
*h, = map(int, input().split())

h = sorted(h, reverse=True)
if k >= len(h):
    print(0)
else:
    print(sum(h[k:]))

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(input()) 
def ifn(): return float(input()) 
def isn(): return input().split() 
def imn(): return map(int, input().split()) 
def fmn(): return map(float, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, input().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD

N,K = imn()
H = iln_r()

ans = 0
for i in range(N):

    if K > 0:
        K -= 1
    else:
        ans += H[i]
print(ans)

Solution (Python):
n,k = map(int,input().split())
h = sorted(list(map(int,input().split())), reverse=True)

for i in range(min(n,k)):
  h[i] = 0
  
print(sum(h))

Solution (Python):
b, c = map(int, input().split())

h_list = sorted(list(map(int, input().split())), reverse=True)
counter = 0
for i in range(1, b+1):
    if i > c:
        counter += h_list[i-1]
print(counter)

Solution (Python):
N, K = map(int, input().split())
Hs = list(map(int, input().split()))

Hs.sort(reverse=True)

ans = sum(Hs) - sum(Hs[:K])

print(ans)

Solution (Python):
n, k = map(int, input().split())

h = sorted(list(map(int, input().split())),reverse = True)

print(sum(h[k:]))

Solution (Python):
N, K = [int(i) for i in input().split()]
H = [int(i) for i in input().split()]
H.sort()
index = max(N-K, 0)
H_K = H[:index]
if not H_K:
    ans = 0
else:
    ans = sum(H_K)
print(ans)

Solution (Python):
N,K = map(int,input().split())
H = list(map(int,input().split()))
H = sorted(H,reverse=True)
if K >= N:
    print(0)
else:
    ans = 0
    for i in range(K,N):
        ans += H[i]

    print(ans)

Solution (Python):
x, y = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
while y > 0 and len(a) > 0:
  y -= 1
  a.pop()
  
print(sum(a))

Solution (Python):

MOD = 10 ** 9 + 7

import math

import itertools



import copy


def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(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 kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default



def main():
    n,k=map(int,input().split())
    h = list(map(int,input().split()))
    h=sorted(h,reverse=True)
    if k > n:
        k=n
    for i in range(k):
        h[i]=0
    print(sum(h))

if __name__ == "__main__":
    main()

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

if N <= K:
    print(0)
else:
    H_sort = sorted(H, reverse=True)
    print(sum(H_sort[K:]))

Solution (Python):
n,k = map(int,input().split())
h = [int(i) for i in input().split()]
h.sort(reverse=True)
a = sum(h[min(k, n):])
print(a)

Solution (Python):
N, K = map(int, input().split())
H = [int(h) for h in input().split()]
H.sort(reverse=True)
print(sum(H[K:]))

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort()
print(sum(H[:max(N-K,0)]))

Solution (Python):
N,K=map(int,input().split())
H=list(map(int,input().split()))


H.sort(reverse=True)
for i in range(min(K,N)):
    H[i]=0
print(sum(H))

Solution (Python):
N, K = map(int, input().split())
H = [int(i) for i in input().split()]
H.sort(reverse=True)

if K >= N:
    print(0)
else:
    print(sum(H[K:]))

Solution (Python):
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

H.sort(reverse = True)

print(sum(H[K:]))

Solution (Python):
N, K = map(int, input().split())
A = list(map(int, input().split()))

A.sort(reverse=True)
print(sum(A[K:]))

Solution (Python):
N, K = (int(x) for x in input().split())

H = [int(x) for x in input().split()]

H_sorted = sorted(H, reverse=True)

res = sum(H_sorted[K:])

print(res)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

H = sorted(H, key = lambda x: -x)

count = K
ans = 0
for i in H:
    if count > 0:
        count -= 1
        continue
    else:
        ans += i
print(ans)

Solution (Python):
N,K = map(int, input().split())
H = [int(a) for a in input().split()]

ans = 0
H.sort(reverse=True)
for i in range(N):
    if i < K:
        continue
    else:
        ans += H[i]

print(ans)

Solution (Python):
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort(reverse=True)
ans=0
for i in range(n):
  if i<k:
    continue
  ans+=a[i]
print(ans)

Solution (Python):
n,k=map(int,input().split())
h=sorted(list(map(int,input().split())),reverse=True)
ans=sum(h[k:])
print(ans)

Solution (Python):
n, k = map(int, input().split())
H = sorted(list(map(int, input().split())), reverse=True)

print(sum(H[k:]))

Solution (Python):
N,K=[int(i) for i in input().split(" ")]
H=[int(i) for i in input().split(" ")]

H=sorted(H,reverse=True)
print(sum(H[K:]))

Solution (Python):



def solve(*args: str) -> str:
    n, k = map(int, args[0].split())
    H = list(map(int, args[1].split()))
    H.sort(reverse=True)

    return str(sum(H[k:]))


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Solution (Python):
n, k = [int(v) for v in input().split()]
hps = sorted([int(v) for v in input().split()], reverse=True)

print(sum(hps[k:]))

Solution (Python):
n,k=map(int,input().split())
h=list(map(int,input().split()))
h.sort()
h.reverse()
ct=0
for i in range(n):
  if i>=k:
    ct+=h[i]
print(ct)

Solution (Python):
n,k=map(int,input().split())
a=list(map(int,input().split()))
if k>=n:
    print(0)
    exit()
a=sorted(a,reverse=True)
a=a[k:]

print(sum(a))

Solution (Python):
n, k = map(int, input().split())
h = sorted(list(map(int, input().split())) ,reverse=True)
h = h[k:n]
print(sum(h))

Solution (Python):
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]

n, k = ril()
ls = ril()
if n <= k:
    print(0)
    exit()
ls.sort()
if k > 0:
    ls = ls[:-k]
print(sum(ls))

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

n,k = get_nums_l()
hhh = sorted(get_nums_l(), reverse=True)

print(sum(hhh[k:]))

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort()

if K != 0:
    H = H[:-K]
ans = sum([x for x in H])
print(ans)

Solution (Python):
from math import ceil
n, k = map(int, input().split())
h_array = sorted([int(x) for x in input().split()])
if k >= n:
    print(0)
    exit()
print(sum(h_array[:n-k]))

Solution (Python):
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res

N,K=LI()
HS=LI()
HS.sort(reverse=True)
hcnt = 0
normal = 0
for i in range(N):
    if hcnt < K:
        hcnt += 1
    else:
        normal += HS[i]

print(normal)

Solution (Python):
H, K = map(int, input().split())
H = list(map(int, input().split()))

H.sort()

for i in range(K):
    if H:
        H.pop()

if len(H) == 0:
    print(0)
else:
    print(sum(H))

Solution (Python):
N, K = map(int, input().split())
H = [int(i) for i in input().split()]

H.sort(reverse=True)

Attack = H[K:]
print(sum(Attack))

Solution (Python):
n,k=map(int,input().split())
k=min(k,n)
h=[int(i) for i in input().split()]
h.sort()
if k==0:
    print(sum(h))
else:
    print(sum(h[:-k]))

Solution (Python):
n, k = map(int, (input().split()))
h = sorted([int(i) for i in input().split()], reverse=True)

print(sum(h[k:]))

Solution (Python):
n,k=map(int,input().split())
arr=sorted([int(x) for x in input().split()],reverse=True)
print(sum(arr[k:]))

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, K, H):
    H.sort()
    for _ in range(K):
        if H:
            H.pop()
    return sum(H)


def main():
    N, K = read_int_n()
    H = read_int_n()
    print(slv(N, K, H))


if __name__ == '__main__':
    main()

Solution (Python):
n, k = map(int, raw_input().split())
hh = map(int, raw_input().split())
hh.sort()
print sum(hh[:-k if k else n])

Solution (Python):
n,k=map(int,input().split())
h=list(map(int,input().split()))
h.sort(reverse=True)
count=0
for i in range(k,len(h)):
    count+=h[i]
print(count)

Solution (Python):
N, K = [int(s) for s in input().split()]
H = [int(s) for s in input().split()]
H.sort(reverse=True)
s = 0
for i in range(K,N):
    s += H[i]
print(s)

Solution (Python):
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
b.sort()
summ=0
for i in range(0,a[0]-a[1]):
    summ+=b[i]
print(summ)

Solution (Python):
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))

H.sort(reverse=True)

if N <= K:
    print(0)
else:
    for i in range(K):
        H[i] = 0
    print(sum(H))

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

H.sort(reverse = True)
ans = 0 
for i in range(K, N, 1):
    ans += H[i]
print(ans)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort(reverse = True)
print(sum(H[K:]))

Solution (Python):
n,k = map(int,input().split())
h = list(map(int,input().split()))
if k >= n:
    print(0)
else:
    h.sort()
    ans = 0
    for i in range(n-k):
        ans += h[i]
    print(ans)

Solution (Python):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read






n,k = [int(i) for i in readline().split()]
h = [int(i) for i in readline().split()]

h.sort()

if k >= n:
    print(0)
else:
    print(sum(h[:n-k]))

Solution (Python):
n,k=map(int,input().split())
H=list(map(int,input().split()))
H.sort()
cnt=0
for i in range(n-k):
    cnt +=H[i]
print(cnt)

Solution (Python):
n,k = map(int, input().split())
h = sorted(map(int, input().split()), reverse=True)

print(sum(h[k:]))

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))
h.sort(reverse=True)
print(sum(h[k:]))

Solution (Python):
N,K = map(int,input().split())
H = list(map(int,input().split()))
H.sort(reverse=True)
X = H[K:]
ans = sum(X)
print(ans)

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
mod=10**9+7

n,k=map(int,input().split())
h=list(map(int,input().split()))
h.sort(reverse=True)
if n<=k:
    print(0)
    quit()
for i in range(k):
    h[i]=0
print(sum(h))

Solution (Python):
import sys
input = sys.stdin.readline
N, K = [int(x) for x in input().split()]
H = [int(x) for x in input().split()]
H.sort()
if K >= N:
    print(0)
    sys.exit()
H = H[:N - K]
print(sum(H))

Solution (Python):
n,k=map(int,input().split())
A=list(map(int,input().split()))

if k >= n:
    print(0)
else:
    A=sorted(A,reverse=True)
    print(sum(A[k:]))

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))

if K >= N:
    print(0)
    exit()

H = sorted(H)

print(sum(H[0:len(H)-K]))

Solution (Python):
n,k = map(int,input().split())
hh = list(map(int,input().split()))

if n-k <= 0:
  print(0)
else:
  print(sum(sorted(hh)[:n-k]))

Solution (Python):
n, k = map(int, input().split())
H = list(map(int, input().split()))
H = sorted(H, reverse=True)

if n <= k:
    ans = 0
else:
    ans = sum(H[k:])

print(ans)

Solution (Python):
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort()
tmp = 0
if K <= N:
    tmp = sum(H[:N - K])

print (tmp)

Solution (Python):
n, k = map(int, input().split())
h = list( map(int, input().split()))

h.sort(reverse=True)

if k >= n:
    print(0)
else:
    ans = sum(h[k:])
    print(ans)

Solution (Python):
N, K = list(map(int, input().split()))
S = sum(sorted(list(map(int, input().split())), reverse=True)[K:])
print(S)

Solution (Python):
n, k = map(int, input().split())
nums = [int(i) for i in input().split()]
nums = sorted(nums)[::-1]
print(sum(nums[k:]))

Solution (Python):

import re
import math
import fractions
import random
from heapq import heappop,heappush
import time
import sys
readline = sys.stdin.readline

mod=int(10**9+7)
inf=int(10**20)
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
 

 

n,k=map(int,input().split())
H=list(map(int,input().split()))
H.sort()
sum_=0
for a in range(n-k):
    sum_+=H[a]
print(sum_)

Solution (Python):

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():
    n,k = LI()
    h = LI()
    if n <= k:
        print(0)
        return
    h.sort()
    ans = sum(h[:n-k])
    print(ans)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
n, k = map(int, input().split())
h = sorted(list(map(int, input().split())))[::-1]

print(sum(h[k:]))

Solution (Python):
import math
import fractions

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    
    return divisors

def ValueToBits(x,digit):
    res = [0 for i in range(digit)]
    now = x
    for i in range(digit):
        res[i]=now%2
        now = now >> 1
    return res

def BitsToValue(arr):
    n = len(arr)
    ans = 0
    for i in range(n):
        ans+= arr[i] * 2**i
    return ans




n,w = list(map(int, input().split()))
a = list(map(int, input().split()))

a.sort()

for i in range(min(w,n)):
    a[n-1-i]=0
print(sum(a))

Solution (Python):
N,K = map(int, input().split())
Hs = list(map(int, input().split()))
Hs.sort(reverse=True)
ans = sum(Hs[K:])
print(ans)

Solution (Python):
N,K=map(int,input().split())
H=sorted(list(map(int,input().split())))[::-1]
print(sum(H[K:]))

Solution (Python):
H, K = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort(reverse=True)
ans = 0
for i in range(K,len(arr)):
    ans += arr[i]
print(ans)