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):






















































def calculation(lines):
    
    N = int(lines[0])
    
    values = list()
    for i in range(N):
        values.append(int(lines[i+1]))

    result = sum(values) - int(max(values)/2)

    return [result]



def get_input_lines():
    line = input()
    N = int(line)
    lines = list()
    lines.append(line)
    for _ in range(N):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['3', '4980', '7980', '6980']
        lines_export = [15950]
    if pattern == 2:
        lines_input = ['4', '4320', '4320', '4320', '4320']
        lines_export = [15120]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines()
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

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()))
ans = sum(p) - (max(p) // 2)
print(ans)

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

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

print(int(sorted(p)[-1]*0.5+sum(sorted(p)[:-1])))

Solution (Python):
Row = int(input())
List = []
res = 0
for i in range (Row):
  List.append(int(input()))
List.sort()
List[Row-1] = List[Row-1]//2
for i in range (Row):
  res += List[i]
print(res)

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

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()
ans = sum(p[:-1]) + p[-1] // 2
print(ans)

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

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

Solution (Python):
n=int(input())
m=0
s=0
for i in range(n):
  a=int(input())
  s+=a
  if a >m:
    m=a 
d=m/2
print(int(s-d))

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

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

Solution (Python):

N = int(input())
P = [int(input()) for _ in range(N)]
P = sorted(P)
P[-1] = P[-1]//2
print(sum(P))

Solution (Python):
N_1 = int(input())
A = [int(input()) for i in range(N_1)]

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

Solution (Python):
import math
n = int(input())
p = []
for i in range(n):
  p.append(int(input()))
p = sorted(p, reverse=True)
cnt = p[0] /2
for i in p[1:]:
  cnt += i
print(math.floor(cnt))

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

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

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

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

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

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

ma = max(p)
s = sum(p)

print(s - ma + ma // 2)

Solution (Python):
import math
def main():
  n = int(input())
  p = [int(input()) for i in range(n)]
  ans=p[0]
  max=p[0]
  for i in range(1,n):
    ans+=p[i]
    if max<p[i]:
      max=p[i]
  ans-=int(max/2)
  print(ans)
main()

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

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

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

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

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

P = [int(input()) for _ in range(N)]
P.sort(reverse=True)

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

Solution (Python):


import copy
import random
import bisect 
import fractions 
import math
import sys
import collections
from decimal import Decimal 

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

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

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

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())
p = [0] * n
for i in range(n):
  p[i]= int(input())
p.sort()
print(p[-1]//2 + sum(p[:-1]))

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

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

max_ = max(p)
flag = True
cnt = 0
for i in p:
    if i == max_ and flag:
        cnt += i // 2
        flag = False
    else:
        cnt += i
print(cnt)

Solution (Python):


import sys

input = iter(sys.stdin.read().splitlines()).__next__

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


P.sort()


res = sum(P[:-1]) + P[-1]//2

print(res)

Solution (Python):
def solve():
    n = int(input())
    s = []
    for i in range(n):
        s.append(int(input()))
    s.sort()
    res = 0
    for i, x in enumerate(s):
        res += x
        if i == n - 1:
            res -= x // 2
    print(res)

solve()

Solution (Python):
N = int(input())
cost = []
for i in range(N):
    cost.append(int(input()))
cost.sort(reverse=True)
sum_cost = cost[0]//2 + sum(cost[1:])
print(sum_cost)

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)]
ans = sum(p) - max(p)//2
print(ans)

Solution (Python):
n = int(input())
a = list([input() for i in range(n)])
z = 0
ax = 0
for i in range(n):
    a[i] = int(a[i])
    if a[i] > ax:
        z = i
        ax = a[i]
        
print(int(sum(a)-a[z]/2))

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

Solution (Python):
N = int(input())
P = sorted([int(input()) for _ in range(N)], reverse=True)
ans = sum(P) - P[0] // 2
print(ans)

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=sorted([int(input()) for i in range(n)])
print(sum(a[:n-1])+a[-1]//2)

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

Solution (Python):
N = int(input())
P = [int(input()) for X in range(0,N)]
P[P.index(max(P))] = max(P)//2
print(sum(P))

Solution (Python):
import sys
N = int(input())
array = []
for I in range(N): array.append(int(input()))
for J in array:
    if not ( 100 <= J <= 10000 ): sys.exit()
if not ( 2 <= N <= 10 ): sys.exit()

print(max(array)//2 + sum(array) - max(array))

Solution (Python):
import sys
N = int(input())
array = []
for I in range(N): array.append(int(input()))
for J in array:
    if not ( 100 <= J <= 10000 ): sys.exit()
if not ( 2 <= N <= 10 ): sys.exit()

print(int(max(array)/2) + sum(array) - max(array))

Solution (Python):

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

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

Solution (Python):
N = int(input())
p = [int(input()) for _ in range(N)]
max_p = max(p)
max_index = p.index(max_p)

sum = 0
for i in range(N):
    if i == max_index:
        sum += int(p[i]/2)
    else:
        sum += p[i]
print(sum)

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

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

n = ri()
li = sorted([ri() for _ in range(n)])
print(sum(li[:-1]) + li[-1]//2)

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
pl = [I() for _ in range(N)]
pl.sort(reverse=True)
ans = 0
for i in range(N):
    if i == 0:
        ans += pl[i]//2
    else:
        ans += pl[i]
print(ans)

Solution (Python):
n = int(input())
p = list(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(raw_input())
prices = [ int(raw_input()) for _ in range(n)] 
prices.sort()
print sum(prices[:-1]) + prices[-1] /2

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

if __name__ == '__main__':
    main()

Solution (Python):
N,*p=map(int,open(0).read().split());print(sum(sorted(p)[:-1])+max(p)//2)

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

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=[int(input()) for _ in range(N)]
print(sum(p)-max(p)//2)

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

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

p.sort(reverse = True)  
p[0] = p[0]//2
  
print(sum(p))

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

Solution (Python):





def main():
    N = int(input())
    p = [None] * N
    for i in range(N):
        p[i] = int(input())
    
    p = sorted(p)
    return sum(p[:-1]) + p[-1]//2


print(main())

Solution (Python):
n,*l=map(int,open(0));l.sort();l[-1]=l[-1]//2;print(sum(l))

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

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())
p = [int(input()) for _ in range(n)]
mp = max(p)
print((sum(p)-mp) + (mp//2))

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

Solution (Python):
L=list()
N=int(input())
for i in range(N):
  s=int(input())
  L.append(s)
print(sum(L)-(max(L)//2))

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

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

Solution (Python):
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
INF = float('inf')


def main():
    N = int(readline())
    total = 0
    maximum = 0

    for _ in range(N):
        p = int(readline())
        total += p
        maximum = max(maximum,p)

    ans = total - maximum//2
    print(ans)
if __name__ == '__main__':
    main()

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

p=sorted(p)
print(int(sum(p[:-1])+0.5*p[-1]))

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

Solution (Python):
N = int(input())
M = 0
P = 0
for i in range(N):
    A = int(input())
    P += A
    M = max(M,A)

print(P - M//2)

Solution (Python):
def main():
    p=sorted(int(input()) for _ in range(int(input())))
    p[-1] //= 2
    print(sum(p))
    
if __name__ == "__main__":
    main()

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

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


if __name__ == '__main__':
    solve()

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

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

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

p.sort()

p[-1] = int(p[-1]/2)

print(sum(p))

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

Solution (Python):
n = int(input())
p = list(int(input()) for i in range(n))
p.sort(reverse = True)
s = p.pop(0) // 2
print(sum(p,s))

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

Solution (Python):
N = int(input())
P = sorted(map(int,(list((input() for _ in range(N))))),reverse = True)
P[0] = P[0]//2
print(sum(P))

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

n = int(input())
a = list(int(input()) for i in range(n))

ma = max(a)

ans = sum(a)-ma//2

print(ans)

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

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

Solution (Python):
n,*l=map(int,open(0))
print(sum(l)-max(l)//2)

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

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

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

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

p[n-1] = p[n-1]//2

print(sum(p))

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

for _ in range(N):
  A.append(int(input()))

A.sort()
A[-1] //= 2

print(sum(A))

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



p_l_s = sorted(p_l, reverse=True)

p_l_s[0] = int(p_l_s[0] / 2)


print(sum(p_l_s))

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

Solution (Python):
N=int(input())
ans=0
l=0
for _ in range(N):
  p=int(input())
  ans+=p
  l=max(p,l)
print(ans-l//2)

Solution (Python):
n = int(input())
p = []
for i in range(n):
    p.append(int(input()))
p = sorted(p, reverse = True)
ans = 0
for i in range(n):
    if i == 0: ans += p[i] // 2
    else: ans += p[i]
print(ans)

Solution (Python):
n = int(input())
p = [int(input()) for i in range(n)]
p1 = sorted(p)
a = p1.pop(-1)
a1 = a // 2
ans = sum(p1)
ans += a1
print(ans)

Solution (Python):
N = int(input())
arr = [int(input()) for i in range(N)]
print(sum(arr) - max(arr)//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):
l=[]
for i in range(int(input())):
    l.append(int(input()))
print(sum(l)-max(l)//2)

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

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

A.sort()
print(sum(A) - A[N-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 i in range(N)]
p.sort()
p[-1]//=2
print(sum(p))

Solution (Python):

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

Solution (Python):
mod = 1000000007
eps = 10**-9


def main():
    import sys
    input = sys.stdin.readline

    N = int(input())
    ans = 0
    M = -1
    for _ in range(N):
        p = int(input())
        ans += p
        if p > M:
            M = p
    print(ans - M // 2)


if __name__ == '__main__':
    main()

Solution (Python):
import sys
import math
import itertools
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

N = i()
p = [i() for _ in range(N)]
p.sort()
p[-1] = p[-1]//2
print(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())
p = [int(input()) for _ in range(n)]
s = sorted(p, reverse=True)
print((s[0]//2)+sum(s[1:]))

Solution (Python):
n=int(input())
l=[]
x=0
for i in range(n):
    l.append(int(input()))
y=l.index(max(l))

for i in range(n):
    if i==y:
        x+=l[i]//2
    else:
        x+=l[i]
             
print(x)

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())
pp = [0] * n
for i in range(n):
    pp[i] = int(input())

pp = sorted(pp)
pp[-1] //= 2
print(sum(pp))

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

ans = sum(p)
ans -= max(p) // 2

print(ans)

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

p.sort(reverse=True)
p[0] = p[0]//2
print(sum(p))

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

Solution (Python):
def actual(n, P):
    return int(sum(P) - (max(P) // 2))

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

print(actual(n, P))

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

p.sort(reverse = True)
ans = 0

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

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

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

Solution (Python):


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

print(sum(p)-max(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())

lis = []
for _ in range(n):
    lis.append(int(input()))
    
lis = sorted(lis)

print(int(max(lis)/2) + sum(lis[:n-1]))

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

Solution (Python):
def ip():return int(input())

ans=0
m=99
for _ in range(ip()):
    p=ip()
    ans+=p
    m=max(m,p)
print(ans-m//2)

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

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

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

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

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

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

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

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

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

saidai = max(p)
del p[p.index(saidai)]
print(sum(p)+ saidai//2)

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

Solution (Python):

if __name__ == '__main__':
    n = int (input())
    list = []
    for i in range(n):
        list.append(int(input()))
    list.sort(reverse=True)
    list[0]= list[0]//2

    print(sum(list))

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

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

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

Solution (Python):
import sys
import math
from collections import Counter
import itertools
import fractions
import datetime
from decimal import Decimal



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")



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

Solution (Python):



p_list = [int(input()) for _ in range(int(input()))]
print(sum(p_list) - (max(p_list) // 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)]
p.sort()
ans = 0
for i in range(n-1):
    ans += p[i]
print(ans + p[-1]//2)

Solution (Python):

import sys

import fractions
import copy
import bisect
import math
import numpy as np
import itertools
from itertools import combinations_with_replacement


from operator import itemgetter
from sys import stdin

from operator import mul
from functools import reduce
from collections import Counter





j=0
k=0
n=3
r=1
a=[0]






"1行1つの整数を入力を取得し、整数と取得する"




"12 21 332 とか入力する時に使う"
"1行に複数の整数の入力を取得し、整数として扱う"

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

for i in number_list:
    print(number_list[i-1])

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

'''
x=[]
y=[]
for i in range(N):
    x1, y1=[int(i) for i in input().split()]
    x.append(x1)
    y.append(y1)
print(x)
print(y)
"複数行に2数値を入力する形式 x座標とy座標を入力するイメージ"
'''

'''
mixlist=[]
for i in range(N):
    a,b=input().split()
    mixlist.append((int(a),b))
print(mixlist)
"複数行にintとstrを複合して入力するやつ，今回はリスト一つで処理している"
'''

'''



"正方行列にstr型の値を入力"
'''




'''
入力
1 2
4 5
7 8
出力結果
[[1, 2], [4, 5], [7, 8]]
'''
"列数に関して自由度の高いint型の値を入力するタイプの行列"


'''
table = [[int(i) for i in input().split()] for m in range(m)]

print(type(N))
print(N)
print(type(M))
print(M)

print(type(table))
print(table)
'''











'''
入力
1234
出力
1
[[1, 2, 3, 4]]
'''




'''
word_list= input().split(" ")
print(word_list[0])
"連続文字列の入力"
"qw er ty とかの入力に使う"
"入力すると空白で区切ったところでlistの番号が与えられる"
'''



'''
A, B, C=stdin.readline().rstrip().split()
print(A)
"リストではなく独立したstr型を入れるなら以下のやり方でOK"
'''




"aという変数に入っているものを大文字にして出力"

















'''
コンビネーションの組み合わせの中身を出力する形式
for i in itertools.combinations(brray, 2)
combinationsをpermutationsにすれば順列になる
今回なら(abc133B)
入力
1 2
5 5
-2 8
出力
[[1, 2], [5, 5], [-2, 8]]
もちろん一次元リストでも使えるし
何よりiもリストのように使えるので便利
'''


'''
def cmb(n,r):
    
    r= min(n-r,r)
    
    if r == 0: return 1
    over = reduce(mul, range(n, n-r, -1))
    
    
    

    under = reduce(mul, range(1, r+1))
    
    
    
    

    return over // under
    
    
    
    
a = cmb(n, r)

'''

'''
import itertools
from itertools import combinations_with_replacement

combinationについて
以下の違いを意識しよう
combinations() p, r 長さrのタプル列、ソートされた順で重複なし

combinations_with_replacement() p, r 長さrのタプル列、ソートされた順で重複あり


使用例 　　　　　　　　　　　                  出力　　
combinations('ABCD', 2)　　　　　　　　　　　　AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2)　　 AA AB AC AD BB BC BD CC CD DD
'''



'''




for i in a.most_common(n):print(i)





 


'''









'''
bisect.bisect_left(a, x, lo=0, h=len(a))
引数
a: ソート済みリスト
x: 挿入したい値
lo: 探索範囲の下限
hi: 探索範囲の上限
(lo, hiはスライスと同様の指定方法)
bisect_leftはソートされたリストaに対して順序を保ったままxを挿入できる箇所を探索します。leftが示す通り、aにすでにxが存在している場合は、挿入箇所は既存のxよりも左側になります。また、lo, hiを指定することで探索範囲を絞り込むことも可能です。デフォルトはaの全体が探索対象です。
'''

'''
素数の判定
'''
def is_prime(n):
    if n == 1: return False

    for k in range(2, int(np.sqrt(n)) + 1):
        
        if n % k == 0:
            return False
            
    return True


'''
npのmaxとmaximumの違い
xs = np.array([1, -2, 3])
np.max(xs, 0)
この出力は3となります．[1, -2, 3]と0の4つの数字のうち，最も大きい値を出力します．

一方で，[max(1, 0), max(-2, 0), max(3, 0)]を出力したい時があります．
その時は，numpyのmaximum関数を用います．

xs = np.array([1, -2, 3])
np.maximum(xs, 0)  

'''

def factorial(x, mod=10**9+7):
    
    
    
    tmp = 1
    for i in range(1, x+1):
        tmp = (tmp * i) % mod
    return tmp
    '''
    Basically, when you do a**d % n, you actually have to calculate a**d, which could be quite large.
    But there are ways of computing a**d % n without having to compute a**d itself, and that is what pow does.
    '''
"
def gcd(a, b):
    while b:
        
        
        a, b = b, a % b
    return a

"
def lcm(a, b):
    return a * b // gcd (a, b)

"
def divisor(n):
    i = 1
    table = []
    while i * i <= n:
        if n%i == 0:
            table.append(i)
            table.append(n//i)
        i += 1
    table = list(set(table))
    return table











'''
ascii_letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
digits = '0123456789'
hexdigits = '0123456789abcdefABCDEF'
letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv...\xaf\xb0...
lowercase = 'abcdefghijklmnopqrstuvwxyz'
octdigits = '01234567'
printable = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTU...
punctuation = '!"
uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
whitespace = '\t\n\x0b\x0c\r '
'''
'''
引数endに任意の文字列を指定すると、その文字列が改行の代わりに最後に挿入される。例えば連続するprint()の出力を改行なしで単純に連結したい場合は空文字列''を指定すればよい。

print('abc', end='---')
print('xyz')


print('abc', end='')
print('xyz')

source: print_basic.py
なお、デフォルトで改行されるのは引数endのデフォルト値が改行文字'\n'に設定されているから。
'''

def main():
    n=3
    steps=0
    state=0
    w=1
    j=0
    k=0
    
    n=int(input())
    
    
    
    
    kl=[0]*n
    for i in range(n):
        kl[i]=int(input())
    
    
    kl.sort()
    kl[-1]=kl[-1]/2
    print(int(sum(kl)))
    
    
    


    
    
     

    l = ['aaa', 'bbb', 'ccc']
    x=l.index('aaa')
    
    
    
    

    
        
    
    

    
    
    
    
    DP = np.zeros(w+1, dtype=int)
    exdp=np.zeros((3,4)) 
    
    
    
        
        
    
    
        
        
    


    
    



    '''
    入力
    1234
    出力
    [1, 2, 3, 4]
    '''
    pin_l=["x" for i in range(10)]
    

    ls = ["a", "b", "c", "d", "e"]


    
    

    
    

    
    
    
    
    
    '''
    lsというリストの場合に、1つ飛びの値を取得したい場合には
    ls[::2]
    のようにします。こうすると、
    ["a", "c", "d"]と出力される
    '''

if __name__ == "__main__":
    main()

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 _ in range(N)]

sorted_p = sorted(p)
half_price = int(sorted_p[-1] / 2 )
total_price = 0

for i in range(N-1):
    total_price += sorted_p[i]
total_price += half_price

print(total_price)

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

ans = 0
for i in range(len(p)):
    if i == len(p)-1:
        ans += p[i]//2
    else:
        ans += p[i]

print (ans)

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

a = [0]*n

for i in range(0,n):
  a[i] = int(input())
  
a.sort()
a[-1] = int(a[i]/2)
print(sum(a))

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

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

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

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

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

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

cart =[]

for _ in range(n):
    p = int(input())

    cart.append(p)

p_m = max(cart)

index = cart.index(p_m)

total =0
for i in range(n):
    if i != index:
        total +=cart[i]
    else:
        total +=cart[i]/2

print(int(total))

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

diff = max(p) // 2

print(sum(p) - diff)

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

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

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

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

Solution (Python):
n = int(input())
a = []
for i in range(n):
    a.append(int(input()))
a.sort()
b = int(a.pop() * 0.5)
print(sum(a) + b)

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

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

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

l.sort(reverse = True)
l[0] = l[0]//2

print(sum(l))

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

Solution (Python):
N = int(input())
p = list(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)-(max(p)//2))

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