Problem:
 Score : 200 points    Problem Statement In some other world, today is the day before Christmas Eve.  Mr. Takaha is buying N items at a department store. The regular price of the i -th item (1 \leq i \leq N) is p_i yen (the currency of Japan).  He has a discount coupon, and can buy one item with the highest price for half the regular price. The remaining N-1 items cost their regular prices. What is the total amount he will pay?      Constraints  2 \leq N \leq 10  100 \leq p_i \leq 10000  p_i is an even number.         Input Input is given from Standard Input in the following format:  N  p_1  p_2  :  p_N       Output Print the total amount Mr. Takaha will pay.        Sample Input 1 3
4980
7980
6980      Sample Output 1 15950  The 7980 -yen item gets the discount and the total is 4980 + 7980 / 2 + 6980 = 15950 yen.  Note that outputs such as 15950.0 will be judged as Wrong Answer.       Sample Input 2 4
4320
4320
4320
4320      Sample Output 2 15120  Only one of the four items gets the discount and the total is 4320 / 2 + 4320 + 4320 + 4320 = 15120 yen.

Solution (Python):
n =int(input())
p = [int(input()) for _ in range(n)]

p = sorted(p)
print(p[-1]//2 + sum(p[:-1]))

Solution (Python):

n = int(input())
P = [int(input()) for i in range(n)]

print(int(sum(P) - max(P)/2))

Solution (Python):
n = int(input())
p = sorted([int(input()) for _ in range(n)])
sum = 0
for i in range(n-1):
  sum += p[i]
sum += p[-1]//2
print(sum)

Solution (Python):
N = int(input())
List = []
for i in range(N):
    List.append(int(input()))

List.sort()
num = 0
for j in range(N):
    if j == N-1:
        num += List[j]*0.5
    else:
        num += List[j]

print(int(num))

Solution (Python):
n = int(input())
p = [int(input()) for _ in range(n)]
p.sort()
p[-1] //= 2
print(sum(p))

Solution (Python):
n = int(input())
retail = []
for i in range(n):
    retail.append(int(input()))
retail_max = max(retail)
print(int(sum(retail)-retail_max/2))

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]

p.sort()

p[n-1] /= 2

print(int(sum(p)))

Solution (Python):


def resolve():
    N = int(input())
    arr = [int(input()) for i in range(N)]
    ans = sum(arr) - int(max(arr)//2)
    print(ans)


if __name__ == "__main__":
    resolve()

Solution (Python):
s = int(input())
p = [int(input()) for i in range(s)]
print(sum(p) - max(p) // 2)

Solution (Python):
N = int(input())
p = [0]*N
s = 0

for i in range(N):
   p[i] = int(input())
   s = s + p[i]
   
print(s-max(p)//2)

Solution (Python):
N = int(input())
p = []

for i in range(N):
    p.append(int(input()))
    
mxi = p.index(max(p))
p[mxi] = p[mxi]//2
s = 0
for i in range(N):
    s = s+p[i]

print(s)

Solution (Python):
N = int(input())

pMax = 0
sumP = 0
for _ in range(N) :
    p = int(input())
    pMax = max(pMax, p)
    sumP += p

print(sumP - pMax // 2)

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]

print(sum(p)-max(p)//2)

Solution (Python):
N = int(input())
p = [int(input()) for i in range(N)]

print(int(sum(p)-max(p)//2))

Solution (Python):
n = int(input())
p = sorted([int(input()) for _ in range(n)])
res = sum(p[0:-1]) + p[-1]//2
print(res)

Solution (Python):
n = int(input())
lst = []

for i in range(n):
  item = int(input())
  lst.append(item)

goods = sorted(lst, reverse=True)
goods[0] = goods[0] // 2

print(sum(goods))

Solution (Python):
import sys

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    items = list(map(lambda x: int(x), inputs))
    items.sort()
    price = items.pop() // 2
    for i in items:
        price += i
    return price


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    N = int(input())
    ret = solve(inputs(N))
    print(ret)

Solution (Python):
N = int(input())
P = [0] * N
for i in range(N):
    P[i] = int(input())
ans = sum(P) - max(P)//2
ans = round(ans)

print(ans)

Solution (Python):
def main():
    N = int(input())
    P = [int(input()) for _ in range(N)]
    print(sum(P) - max(P)//2)


if __name__ == "__main__":
    main()

Solution (Python):
N=int(input())
p=[int(input()) for _ in range(N)]
p.sort()
p[-1]=p[-1]//2
print(sum(p))

Solution (Python):
N = int(input())
P = []
for i in range(N):
  P.append(int(input()))
print(sum(P) - max(P) // 2)

Solution (Python):
a = int(input())
b = []
for i in range(a):
    b.append(int(input()))
b = sorted(b, reverse=True)
print(sum(b) + b[0] // 2 - b[0])

Solution (Python):
N = int(input())
items = []
for _ in range(N):
    item = int(input())
    items.append(item)

items.sort()

print(int(sum(items[0:N-1]) + items[-1]/2))

Solution (Python):
N = int(input())
P = [int(input()) for _ in range(N)]
print(sum(P)-max(P)//2)

Solution (Python):
n = int(input())
p = [int(input()) for _ in range(n)]
print(sum(p) - max(p)//2)

Solution (Python):

def main():

    N = int(input())
    ans = 0
    prices =[]
    for i in range(N):
        prices.append(int(input()))
    print(int(sum(prices)-max(prices)/2))
    


if __name__== "__main__":
    main()

Solution (Python):
N=int(input()) 
a=[int(input()) for i in range(N)]
b=0

for n in range(N):
    if n==a.index(max(a)):
        b+=a[n]/2
    else:
        b+=a[n]
print(int(b))

Solution (Python):
N = int(input())
P = [int(input()) for _ in range(N)]
P.sort()
ans = P[-1] // 2 + sum(P[:-1])
print(ans)

Solution (Python):
N = int(input())
ans = 0
tmp = 0
for _ in range(N):
    p = int(input())
    ans += p
    tmp = max(tmp, p)

print (ans - tmp//2)

Solution (Python):
n=int(input())
x=list(int(input()) for _ in range(n))
res=int(sum(x)-max(x)/2)

print(res)

Solution (Python):
N = int(input())
P = []
for i in range(0, N):
    P.insert(i, int(input()))
P = sorted(P)
print(sum(P) - int(P[len(P) - 1] / 2))

Solution (Python):
n = int(input())
p = [int(input()) for _ in range(n)]
pmx = max(p)
p[p.index(pmx)] = pmx // 2
print(sum(p))

Solution (Python):


N=int(input())
a=[]
total=0
for i in range(N):
    a.append(int(input()))

a.sort(reverse=True)
for l in range(N):
    if l==0:
        a[l]=a[l]/2
    total=total+a[l]

print(int(total))

Solution (Python):
N=int(input())
P=[int(input()) for i in range(N)]

print(sum(P)-max(P)//2)

Solution (Python):
n = int(input())
a = [int(input()) for i in range(n)]

a.sort()
print(sum(a) - int(a[-1]/2))

Solution (Python):
n = int(input())
a = [int(input()) for i in range(n)]
print(int(max(a)*0.5+sum(a)-max(a)))

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    d = II()
    print("Christmas",end="")
    for _ in range(25 - d):
        print(" Eve", end="")
    print()
    return


def B():
    n = II()
    p = IR(n)
    p.sort()
    print(sum(p) - p[-1] // 2)
    return


def C():
    return


def D():
    return


if __name__ == '__main__':
    B()

Solution (Python):
n = int(input())
a = [int(input()) for i in range(n)]

a.sort()
print(sum(a)-int(a[-1]/2))

Solution (Python):
n=int(input())
info=[]
max=0
for i in range(n):
    num=int(input())
    info.append(num)
    if max<=num:
        max=num

print(sum(info)-int(0.5*max))

Solution (Python):
N = int(input())
p = [int(input()) for i in range(N)]

print(sum(p) - max(p)//2)

Solution (Python):
n = int(input())
ps = [int(input()) for i in range(n)]
print(int(max(ps)*0.5+sum(ps)-max(ps)))

Solution (Python):
n = int(input())
li = [int(input()) for _ in range(n)]
print(sum(li) - max(li) // 2)

Solution (Python):
N = int(input())
P = []
for i in range(N):
    P.append(int(input()))

max_price = max(P)
max_index = P.index(max_price)
del P[max_index]
print(sum(P) + int(max_price / 2))

Solution (Python):
N = int(input())
P = [int(input()) for i in range(N)]
print(sum(P) - max(P) // 2)

Solution (Python):
N = int(input())
p = [int(input()) for _ in range(N)]

print(sum(p) - int(max(p) / 2))

Solution (Python):
N = int(input())
P = []
for i in range(0, N):
	P.append(int(input()))
P.sort()
sum = 0
for i in range(0, N-1):
	sum += P[i]
sum += P[-1] // 2
print(sum)

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]
print(sum(p)-(max(p)//2))

Solution (Python):



N = int(input())
p = list()
for _ in range(N):
    p.append(int(input()))


p.sort()
ans = int(p[-1] / 2 + sum(p[:-1]))


print(ans)

Solution (Python):
N = int(input())
ans = 0
max_price = 0
for i in range(N):
  price = int(input())
  ans += price
  max_price = max(max_price, price)
ans -= max_price//2
print(ans)

Solution (Python):
def main():
    n = int(input())
    p = [int(input()) for _ in range(n)]
    print(sum(p) - max(p) // 2)


main()

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]
ans = sum(p) - max(p) // 2
print(ans)

Solution (Python):
N=int(input())
L=[]
for i in range(N):
  L.append(int(input()))

L.sort()
L[len(L)-1]=L[len(L)-1]//2
print(sum(L))

Solution (Python):
a = int(input())
b = [int(input()) for _ in range(a)]
b = sorted(b, reverse=True)
c = 0
for i in range(a):
    if i == 0:
        c += b[i] // 2
    else:
        c += b[i]
print(c)

Solution (Python):
import math

n = int(input())
ans = 0
dmax = -1000
for i in range(0,n):
    a = int(input())
    ans+=a
    dmax = max(dmax,a)

print (ans - dmax + int(dmax/2))

Solution (Python):
if __name__ == '__main__':
    N = int(input())
    p_list = [int(input()) for _ in range(N)]

    p_list = sorted(p_list, reverse=True)

    answer = p_list[0]//2
    for i in range(1, N):
        answer += p_list[i]
    print(answer)

Solution (Python):
N = int(input())
Ps = [list(map(int, input().split())) for _ in range(N)]
max_p = max(Ps)
Ps.remove(max_p)
Ps.append([max_p[0]//2])
r = 0
for p in Ps:
  r += p[0]
print(r)

Solution (Python):
n=int(input())
p=[]
for i in range(n):
    p.append(int(input()))

print(sum(p)-max(p)//2)

Solution (Python):
n = int(input())
l = [int(input()) for _ in range(n)]
print(sum(l)-max(l)//2)

Solution (Python):
import sys
import numpy as np

N = int(input())

p = np.zeros(N)
for n in range(N):
    p[n] = int(input())

print(int(np.sum(p)-np.max(p)/2))

Solution (Python):
n = int(input())
p_list = []
for i in range(n):
    p = int(input())
    p_list.append(p)

p_list.sort()
max = p_list.pop()
p_list.append(max/2)
print(int(sum(p_list)))

Solution (Python):
N = int(input())
p = [int(input()) for _ in range(N)]

p = sorted(p)
ans = sum(p[:-1]) + p[-1]//2
print(ans)

Solution (Python):
a = int(input())
b = list(int(input()) for i in range(a))
c = sorted(b,reverse=True)
c[0] = int(c[0]/2)
print(sum(c))

Solution (Python):
N = int(input())
P = []
for _ in range(N):
    P.append(int(input()))
print(sum(P)-max(P)//2)

Solution (Python):
N = int(input())

price_list = [int(input()) for i in range(N)]

print(int(sum(price_list) - 0.5 * max(price_list)))

Solution (Python):
n = int(input())
p = sorted([int(input()) for i in range(n)], reverse=True)
p[0] //= 2

print(sum(p))

Solution (Python):



n = int(input())
p = [int(input()) for _ in range(n)]

i = p.index(max(p))
p[i] = p[i]//2
print(sum(p))

Solution (Python):
N = int(input())
p = [int(input()) for _ in range(N)]
print(sum(p)-max(p)//2)

Solution (Python):
n = int(input())
l = [int(input()) for i in range(n)]

l.sort()
ans = sum(l) - (l[-1] // 2)
print(ans)

Solution (Python):
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)

N = int(input())
p = [int(input()) for _ in range(N)]
p.sort()
p[-1] //= 2
print(sum(p))

Solution (Python):
n = int(input())
l = [int(input()) for i in range(n)]
print(max(l)//2+sum(l)-max(l))

Solution (Python):
n = int(input())
p = sorted([int(input()) for i in range(n)])
print(sum(p)-p[n-1]//2)

Solution (Python):
n = int(input())
p = []
m = 0
for i in range(n):
    price = int(input())
    p.append(price)
    m = max(m, price)
print(sum(p) - int(m / 2))

Solution (Python):
N=int(input())
plist=[]
for i in range(N):
  p=int(input())
  plist.append(p)
  
plist.sort()
print(plist.pop()//2+sum(plist))

Solution (Python):
a = int(input())
b = [int(input()) for _ in range(a)]
b = sorted(b, reverse=True)
c  = 0
for i in range(a):
    if i == 0:
        c += b[i] // 2
    else:
        c += b[i]
print(c)

Solution (Python):
N = input()
N = int(N)
list = []
ans = 0
for i in range(N):
    token = input()
    list.append(int(token))
maxvalue_index = list.index(max(list))
for i in range(N):
    ans += list[i]
ans -= list[maxvalue_index] / 2
print(int(ans))

Solution (Python):

n = int(input())


ls = [int(input()) for i in range(n)]

maxi = max(ls)
ls.remove(maxi)
print(sum(ls) + int(maxi/2))

Solution (Python):
n = int(input())
pl = [int(input()) for _ in range(n)]
pl.sort()
print(sum(pl)-pl[-1]//2)

Solution (Python):
n = int(input())
ps = [int(input()) for _ in range(n)]
print(sum(ps) - max(ps) // 2)

Solution (Python):
S=int(input())

p=[int(input()) for i in  range(S)]

p.sort(reverse=True)

money=0

for i in range(S):
    money+=p[i]

print(int(money-p[0]/2))

Solution (Python):
n = int(input())
l = [int(input()) for i in range(n)]
m = max(l)
l.remove(m)

print(m // 2 + sum(l))

Solution (Python):
from sys import stdin
N = int(input())
P = sorted([int(p) for p in stdin.read().splitlines()])
 
print(int(P[-1]/2)+sum(P[:-1]))

Solution (Python):
N = int(input())
price = []
p = 0
for i in range(N):
  price.append(int(input()))
m = price.index(max(price))
for j in range(len(price)):
  if j != m:
     p += price[j]
  else:
     p += price[j]//2
print(p)

Solution (Python):






N = int(input())
p = []
for i in range(N):
    P = int(input())
    p.append(P)
    q = sorted(p, reverse=True)

    sum = 0
for i in range(1, N):
    sum+=q[i]


print(int(q[0]/2+sum))

Solution (Python):
n=int(input())
p=[int(input()) for i in range(n)]
print(sum(p)-max(p)//2)

Solution (Python):
n = int(input())
p = [int(input()) for _ in range(n)]
p.sort()
print(int(sum(p) - p[n-1]/2))

Solution (Python):
n = int(input())
p = list(int(input()) for i in range(n))
p.sort()
max = p.pop(-1)
p.append(max / 2)
print(round(sum(p)))

Solution (Python):
N=int(input())
P=[int(input()) for i in range (N)]
print(sum(P) - max(P)//2)

Solution (Python):
n = int(input()); l=sorted([int(input()) for _ in range(n)])
print(int(sum(l)-l[-1]/2))

Solution (Python):
n = int(input())
lst = [int(input()) for i in range(n)]
lst.sort()
print(int(sum(lst[:-1])+lst[-1]/2))

Solution (Python):
N = int(input())
k = [int(input()) for _ in range(N)]
p = int(sum(k) - max(k)/2)
print(p)

Solution (Python):
n=int(input())
p=[int(input()) for _ in range(n)]
maxp=max(p)
print(sum(p)-maxp+maxp//2)

Solution (Python):
n = int(input())
p =[]
for _ in range(n):
    p.append(int(input()))
print(int(sum(p)-max(p)/2))

Solution (Python):
n = int(input())
p = list(int(input()) for i in range(n))
a = p.pop(p.index(max(p))) / 2
print(int(sum(p) + a))

Solution (Python):
n=int(input())
p=[int(input()) for i in range(n)]

print(sum(p)-(max(p)//2))

Solution (Python):
N = int(input())
p = [int(input()) for _ in range(N)]
ans = sum(p) - max(p) // 2
print(ans)

Solution (Python):
N=int(input())
p=[int(input()) for _ in range(N)]

print(int(sum(p)-max(p)/2))

Solution (Python):
n = int(input())
l = [int(input()) for i in range(n)]
print(int(sum(l)-max(l)/2))

Solution (Python):
n=int(input())
p=[int(input()) for _ in range(n)]
print(sum(p)-max(p)//2)

Solution (Python):
N = int(input())
p = [int(input()) for i in range(N)]
print(sum(p) - (max(p) // 2))

Solution (Python):
N = int(input())
PP = [int(input()) for _ in range(N)]
print(sum(PP)-max(PP)//2)

Solution (Python):
n = int(input())
lists =[int(input()) for i in range(n)]
sums = sum(lists)
maxs = max(lists)
print(sums-maxs//2)

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]
p.sort()
print(sum(p[:-1])+p[-1]//2)

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

N = n()
P = []
for i in range(N):
    P.append(n())
P = sorted(P, reverse=True)

print(P[0] // 2 + sum(P[1:]))

Solution (Python):
N = int(input())
List = [int(input()) for _ in range(N)]

M = max(List)
List.remove(M)
print(sum(List)+M//2)

Solution (Python):

def main():
    n = int(input())
    lst = sorted(list(map(int, [input().rstrip() for _ in range(n)])))
    print(sum(lst) - lst[-1] // 2)


if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
p_List = list(int(input()) for i in range(N))
Max = max(p_List)

Sum = sum(p_List) - Max / 2

print(int(Sum))

Solution (Python):
N = int(input())
p = [int(input()) for _ in range(N)]

print(int(sum(p) - 0.5 * max(p)))

Solution (Python):
N = int(input())
p = []
for i in range(N):
    p.append(int(input()))
print(int(sum(p)-max(p)/2))

Solution (Python):
n = int(input())
c = []
for i in range(n):
    p = int(input())
    c.append(p)
c = sorted(c)
print(sum(c[:len(c)-1])+c[-1]//2)

Solution (Python):
n = int(input())
p_list=[]
for i in range(n):
    p_list.append(int(input()))
print(sum(p_list) - max(p_list)//2)

Solution (Python):
N = int(input())
 
sum = 0
max = 0
for _ in range(N):
  p = int(input())
  if(p > max):
    max = p
  sum += p
val = sum - max/2
print(int(val))

Solution (Python):
N = int(input())
p = []
for i in range(N):
    p.append(int(input()))
s = sum(p)
m = max(p) // 2
print(s - m)

Solution (Python):
n = int(input())
p = []
for i in range(n):
    p.append(int(input()))
maxval = max(p) // 2
print(sum(p) - maxval)

Solution (Python):
N = int(input())

lst = [int(input()) for i in range(N)]
lst.sort(reverse = True)
ans = int(lst[0] / 2) + sum(lst[1:])
print(ans)

Solution (Python):
n = int(input())
p = [int(input()) for _ in range(n)]
print(sum(p) - max(p) + max(p)//2)

Solution (Python):
n=int(input())
p = []
for _ in range(n):
    p.append(int(input()))
p.sort()
sum=0
for i in range(n):
  if i==n-1:
    sum=p[i]//2+sum
  else:
    sum=p[i]+sum
print(sum)

Solution (Python):
N = int(input())
kaimono = []
for i in range(N):
  kaimono.append(int(input()))

highest =kaimono.index(max(kaimono))  
kaimono[highest] = max(kaimono)//2

print(sum(kaimono))

Solution (Python):
def abc():
    n = int(input().rstrip())
    l = []
    for i in range(n):
        l.append(int(input().rstrip()))
    l.sort(reverse=True)
    print(l[0] // 2 + sum(x for x in l[1:]))


abc()

Solution (Python):
n = int(input())
lst = [int(input()) for i in range(n)]
lstmx = int(max(lst) / 2)
print(sum(lst) - lstmx)

Solution (Python):
n = int(input())
pn = []
for _ in range(n):
  pn.append(int(input()))
pmax = max(pn)
psum = sum(pn)
print(psum - pmax//2)

Solution (Python):
N=int(input())
p=[]
for _ in range(N):
    p.append(int(input()))

p.sort(reverse=True)
print(int(p[0]/2+sum(p[1:])))

Solution (Python):
n = int(input())
sum = 0
high = 0
for i in range(n):
	x = int(input())
	sum += x
	if high<x:
		high = x
sum -= high//2
print(sum)

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

N = int(input())

p = [int(input()) for _ in range(N)]

p.sort()
last = p.pop() / 2
print(int(sum(p) + last))

Solution (Python):
n = int(input())
items = []

for _ in range(n):
  items.append(int(input()))
  
print(sum(items) - max(items) + max(items) // 2)

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]
p.sort(reverse=True)
ans = sum(p[1:]) + p[0] // 2
print(ans)

Solution (Python):
n = int(input())
p = []
for i in range(n):
    p.append(int(input()))

p_max = max(p)

print(int(sum(p) - p_max / 2))

Solution (Python):
n = int(input())
p = []
for i in range(n):
    p.append(int(input()))
print(sum(p)-max(p)//2)

Solution (Python):
N = int(input())
P = [int(input()) for _ in range(N)]
answer = sum(P) - max(P)//2
print(answer)

Solution (Python):
n=int(input())
p=[int(input()) for i in range(n)]
print(sum(p)-max(p)//2)

Solution (Python):


N = int(input())
p = [int(input()) for i in range(N)]
print(sum(p)-max(p)//2)

Solution (Python):


N = int(input())
p = [int(input()) for i in range(N)]
maxim = max(p)
p.remove(max(p))
print(sum(p)+maxim//2)

Solution (Python):
N = int(input())

ans = 0
m = 0

for _ in range(N):
    p = int(input())
    ans += p
    m = max(m, p)

print(ans-(m//2))

Solution (Python):
N = int(input())
p = [int(input()) for i in range(N)]
print(sum(p) - max(p) // 2)

Solution (Python):
N = int(input())

p = []
for i in range(N):
    p.append(int(input()))

maxp = max(p)
total = sum(p)

price = total - maxp + maxp//2
print(price)

Solution (Python):
N = int(input())

p = []
for i in range(N):
    p.append(int(input()))

maxp = max(p)
total = sum(p)

price = total - maxp + maxp//2
print(price)

Solution (Python):
N = int(input())

P = sorted([int(input()) for i in range(N)], reverse=True)

pay = P.pop(0)//2+sum(P)


print(pay)

Solution (Python):
import sys
n=int(input())
a=list(map(int,sys.stdin))
a.sort()
print(sum(a[:n-1])+a[n-1]//2)

Solution (Python):
N = int(input())
p = [0]*N
for i in range(N):
    p[i] = int(input())
p.sort()
ans = p[-1] // 2 + sum(p[:-1])
print(ans)

Solution (Python):
def main():
    N = int(input())
    prices = []
    ans = 0
    for i in range(N):
        prices.append(int(input()))
    prices = sorted(prices)
    for j in range(N):
        if j == N-1:
            ans += prices[j]//2
        else:
            ans += prices[j]
    print(ans)
main()

Solution (Python):


N = int(input())

P = []
max = 0
number = 0

for i in range(N):
    p = int(input())

    if max < p:
        max = p
        number = i

    P.append(p)

P[number] = max/2

print(int(sum(P)))

Solution (Python):
import numpy as np



N = int(input())

P = []
max = 0
number = 0

for i in range(N):
    p = int(input())

    if max < p:
        max = p
        number = i

    P.append(p)



P[number] = max/2

print(int(sum(P)))

Solution (Python):
N = int(input())
p = []
for i in range(N):
    p.append(int(input()))

p.sort()
p[N-1] //= 2
print(sum(p))

Solution (Python):
n=int(input())
p=[0]*n
for _ in range(n):
  p[_]=int(input())
p.sort()
p[n-1]=int(p[n-1]/2)
s=0
for _ in range(n):
  s=s+p[_]
print(s)

Solution (Python):
N = int(input())
P = sorted([int(input()) for _ in range(N)])

ans = 0
for i in range(N):
    if i == N-1:
        ans += P[i] // 2
    else:
        ans += P[i]
        
print(ans)

Solution (Python):
n = int(input())
p =[]
for i in range(n):
    a = int(input())
    p.append(a)

p_sum = sum(p)
p_max = max(p)
print(int(p_sum - (p_max / 2)))

Solution (Python):
import numpy as np



N = int(input())

P = []
max = 0
number = 0

for i in range(N):
    p = int(input())

    if max < p:
        max = p
        number = i

    P.append(p)



P[number] = max/2

print(int(sum(P)))

Solution (Python):
N = int(input())
p_list = []
for _ in range(N):
    p_list.append(int(input()))
    
max_p = max(p_list)
print(sum(p_list)-max_p + max_p//2)

Solution (Python):
n=int(input())
a=[int(input()) for _ in range(n)]
print(int(max(a)/2+sum(a)-max(a)))

Solution (Python):
def resolve():
    N=int(input())
    l=[]
    for i in range(N):
        l.append(int(input()))
    print(sum(l)-max(l)//2)

resolve()

Solution (Python):

"""
B - Christmas Eve Eve
https://atcoder.jp/contests/abc115/tasks/abc115_b

"""
import sys


def solve(prices):
    return sum(prices[:-1]) + prices[-1]//2


def main(args):
    N = int(input())
    prices = sorted([int(input()) for _ in range(N)])
    ans = solve(prices)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):
print(eval("sum({0})-max({0})//2".format([int(input()) for i in range(int(input()))])))

Solution (Python):
N = int(input())
pi = [int(input()) for _ in range(N)]
print(sum(pi) - max(pi)//2)

Solution (Python):
N = int(input())
max_item = 0
sum_item = 0
i = 0

while N > i:                  
    c = int(input())                
    sum_item += c                   
    max_item = max(c, max_item)     
    i += 1

sum_item -= max_item // 2           
print(sum_item)

Solution (Python):
n = int(input())
p = []
 
for i in range(n):
    data = int(input())
    p.append(data)
p[p.index(max(p))] //= 2
ans = sum(p)
print(ans)

Solution (Python):
N = int(input())
pi = sorted([int(input()) for _ in range(N)])
pi[-1] //= 2
print(sum(pi))

Solution (Python):
n = int(input())
p=[]
for _ in range(n):
    p.append(int(input()))
print(int(max(p)/2)+sum(p)-max(p))

Solution (Python):
N = int(input())

ans = []

for i in range(N):
    ans.append(int(input()))

print(sum(ans)-max(ans)//2)

Solution (Python):
N = int(input())
p = [0]*N

for n in range(N):
    p[n] = int(input())
    
p.sort()

print(int(sum(p) - p[-1]/2))

Solution (Python):
n=int(input())
l=[int(input()) for i in range(n)]
m=max(l)
print(sum(l)-int(m/2))

Solution (Python):
N = int(input())
p_list=[]
for i in range(N):
  p_list.append(int(input()))
  
p_list.sort(reverse=True)
ans=0
for i in range(N):
  if i==0:
    ans+=p_list[i]/2
  else:
    ans+=p_list[i]
    
print(int(ans))

Solution (Python):
num = int(input())
x = [int(input()) for n in range(num)]
x = sorted(x)
answer = 0
for n in x:
    answer += n
print(int(answer - x[-1]/2))

Solution (Python):
import math
n = int(input())
prices = []
for i in range(n):
    prices.append(int(input()))

i = prices.index(max(prices))
prices[i] = math.ceil(prices[i]/2)

def wa(list):
    a = 0
    for i in range(len(list)):
        a = a+list[i]
    return a

print(wa(prices))

Solution (Python):
n = int(input())
p = [int(input()) for _ in range(n)]

m = max(p)/2

c = sum(p) - m

print(int(c))

Solution (Python):
N = int(input())
pi = [0]*N
sum = 0
for i in range(N):
    pi[i] = int(input())
maxprice = max(pi)
for i in range(N):
    if pi[i] == maxprice:
        pi[i] /= 2
        break
for i in range(N):
    sum += pi[i]
print(int(sum))

Solution (Python):
n=int(input())

pr=[]
for i in range(n):
    pr.append(int(input()))
    


price=sum(pr)-max(pr)*0.5

print(int(price))

Solution (Python):
n=int(input())

pr=[]
for i in range(n):
    pr.append(int(input()))

price=0
for i in range(n-1):
    price+=sorted(pr)[i]
price+=sorted(pr)[-1]*0.5
    
print(int(price))

Solution (Python):
price=[]
for i in range(int(input())):
    price.append(int(input()))
else:
    print(int(sum(price)-max(price)/2))

Solution (Python):
n = int(input())
lip = [int(input()) for i in range(n)]
print(int(sum(lip)-(max(lip)/2)))

Solution (Python):
n = int(input())
item = [int(input()) for i in range(n)]

item.sort(reverse=True)
ans = (item[0]/2) + sum(item[1:])

print(int(ans))

Solution (Python):
N = int(input())
p = [0 for i in range(N)]
for i in range(N):
    p[i] = int(input())
p.sort()
print(sum(p)-(p[-1]//2))

Solution (Python):
n = int(input())
maxi = 0
res = 0
for i in range(n):
    a = int(input())
    res += a
    if a > maxi:
        maxi = a

print(res - maxi // 2)

Solution (Python):
a = int(input())
b = []
for i in range(a):
  b.append(int(input()))
print(int(sum(b)-max(b)/2))

Solution (Python):
N = int(input())
L = [int(input()) for i in range(N)]
print(sum(L)-max(L)//2)

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]
p_max = p[0]
for j in range(1, n):
    if p[j] >= p_max:
        p_max = p[j]
for k in range(n):
    if p[k] == p_max:
        p[k] = int(p[k] / 2)
        break
print(sum(p))

Solution (Python):
number = int(input())
price = [int(input()) for i in range(number)]

print(int(sum(price)-max(price)/2))

Solution (Python):
n=int(input())
p=[int(input()) for i in range(n)]
print(sum(p)-max(p)//2)

Solution (Python):
N=int(input())

inl = [int(input()) for i in range(N)]
inl.sort()

print(sum(inl[:N-1])+inl[N-1]//2)

Solution (Python):
n=int(input())
l=[]
for i in range(n):
    l.append(int(input()))
print(sum(l)-(max(l)//2))

Solution (Python):
N = int(input())
P = []
ma = 0
for i in range(N):
    p = int(input())
    P.append(p)
    ma = max(ma, p)

print(sum(P) - ma // 2)

Solution (Python):
n = int(input())
present_list = [0]*n
for i in range(n):
	present_list[i] = int(input())
present_list = sorted(present_list)
print(sum(present_list)-present_list[-1]//2)

Solution (Python):
n=int(input())
s=[int(input()) for i in range(n)]
 
print(sum(s)-max(s)//2)

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]
s = 0

for i in range(n):
  s += p[i]
  
print(int(s - (max(p)/2)))

Solution (Python):
N = int(input())
price = []
for i in range(N): price.append(int(input()))
price.sort()

print(sum(price) - int(price[-1]/2))

Solution (Python):
N=int(input())
l=[]
for i in range(N):
  l.append(int(input()))
print(sum(l)-max(l)//2)

Solution (Python):
N=int(input())
p=[int(input()) for i in range(N)]
p.sort()
p.reverse()
S=p[0]/2
for j in range(1,N):
    S=S+p[j]
S=int(S)
print(S)

Solution (Python):
n = int(input())
pList = []
ans = 0
for _ in range(n):
        p = int(input())
        pList.append(p)
pList.sort()
for i in pList[:n-1]:
        ans += i
ans += pList[n-1]/2
print(int(ans))

Solution (Python):
print(int(eval("sum({0})-{0}[-1]/2".format(sorted([int(input()) for i in range(int(input()))])))))

Solution (Python):
n = int(input())
p = list(range(n))

for i in range(n):
	p[i] = int(input())
p[p.index(max(p))] //= 2
ans = sum(p)
print(ans)

Solution (Python):
N = int(input())
ans = 0
ma = 0

for _ in range(N):
	p = int(input())
	ans += p
	ma = max(ma, p)

ans -= ma // 2

print(ans)

Solution (Python):
N = int(input())
max_item = 0
sum_item = 0
for _ in range(N):
  c = int(input())
  sum_item += c
  max_item = max(c, max_item)

sum_item -= max_item // 2 
print(sum_item)

Solution (Python):
N = int(input())
p = list(int(input()) for i in range(N))
p.sort()
ans = sum(p[:-1])+p[-1]//2
print(ans)

Solution (Python):
N = int(input())
p = [[] for _ in range(N)]
for i in range(N):
    p[i] = list(map(int, input().split()))
All = []
for v in p:
    for _v in v:
        All.append(_v)
All.sort(reverse=True)
highest = All.pop(0)
total = highest/2
for value in All:
    total += value
print(int(total))

Solution (Python):
N = int(input())
P = [int(input()) for _ in range(N)]

P.sort()

ans = sum(P) - P[-1]
ans += P[-1]//2
print(ans)

Solution (Python):
num = []
n = int(input())
for i in range(n):
  num.append(int(input()))
ans = sum(num) - (max(num) // 2)
print(ans)

Solution (Python):
from sys import stdin
import numpy as np
N = int(stdin.readline().rstrip())
P = np.array([int(stdin.readline().rstrip()) for _ in range(N)])
P = np.sort(P)
P = P[::-1]
P[0] = int(P[0] / 2)
print(np.sum(P))

Solution (Python):
n=int(input())
a=[]
for i in range(n):
  a.append(int(input()))
print(int(sum(a)-max(a)/2))

Solution (Python):
n,*p=map(int,open(0).read().split())
print(int(sum(p)-max(p)/2))

Solution (Python):
a = int(input())
list_  = []
for i in range(a):
    b = int(input())
    list_.append(b)
s = max(list_)
list_.remove(s)
list_.append(s // 2)

print(sum(list_))

Solution (Python):

N = int(input())

p_max = 0
p_sum = 0

for i in range(N):

    p = int(input())
    p_sum += p

    if p > p_max:
        p_max = p

p_sum -= int(p_max / 2)

print(p_sum)

Solution (Python):
N = int(input())
p = [int(input()) for _ in range(N)]
print(sum(p)-max(p)//2)