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())
li = []
for i in range(n):
    p = int(input())
    li.append(p)
m = max(li)
li.remove(m)
print(int(sum(li) + m/2))

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

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

price_list = []
for i in range(item_num):
    price_list.append(int(input()))

highest_price = max(price_list)

for i in range(item_num - 1):
    if price_list[i] == highest_price:
        price_list[i] = int(highest_price / 2)
        break

print(sum(price_list))

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

Solution (Python):

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

Solution (Python):
def calc_payment(p):
        max_p = 0
        sum_p = 0
        for p_v in p:
                max_p = max(max_p, p_v)
                sum_p += p_v
        return sum_p - (max_p // 2)


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

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

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

Solution (Python):
n, = map(int,input().split())
maxp = 0
total = 0
for i in range(n):
  p, = map(int,input().split())
  if(p>maxp):
    maxp = p
  total += p
print(total - maxp//2)

Solution (Python):
N = int(input())
kaimono_list = []
for i in range(N):
    kaimono_list.append(int(input()))
for i in range(N-1):
    for j in range(N):
        if i < j:
            if kaimono_list[i] > kaimono_list[j]:
                a = kaimono_list[i]
                kaimono_list[i] = kaimono_list[j]
                kaimono_list[j] = a
kaimono_sum = 0
for i in kaimono_list:
    kaimono_sum += i
print(kaimono_sum - kaimono_list[N-1]//2)

Solution (Python):


N = int(input())

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

p.sort()

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

print(sum(p))

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

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

Solution (Python):
N = int(input())
data_list = []
for i in range(N):
    data = int(input())
    data_list.append(data)
data_list.sort()
data_list[-1] = int(data_list[-1]/2)

print(sum(data_list))

Solution (Python):
from sys import stdin

N, *p = map(int, stdin.read().split())

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

Solution (Python):
N = int(input())
p = [0]*N
index = -1
max_value = 0
for i in range(N):
    p[i] = int(input())
    if(p[i]>max_value):
        max_value = p[i]
        index = i
p[index] = int(p[index]/2)
print(sum(p))

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

for i in range(n):
    costs.append(int(input()))
    
costs[costs.index(max(costs))] = int(costs[costs.index(max(costs))]/2)

print(sum(costs))

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

Solution (Python):
def main():
    present_count = int(input())
    present = []
    total_count = 0
    for n in range(present_count):
        p_price = int(input())
        present.append(p_price)

    max_price_index = present.index(max(present))
    present[max_price_index] = present[max_price_index] / 2

    for price in present:
        total_count += price

    print(int(total_count))


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    n = int(input())
    p = [int(input()) for _ in range(n)]
    p.sort(reverse=True)

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

main()

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

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

p.sort()

ans = 0
for i in range(N - 1):
    ans += p[i]

ans += p[N - 1] // 2
print(ans)

Solution (Python):
import math, string, itertools, fractions, heapq, collections, re,  array, bisect, sys, random, time, copy, functools


sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]


def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 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 I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    N = I()
    p = []
    for i in range(N):
        p.append(I())

    highest = max(p)
    del p[p.index(highest)]
    result = highest / 2 + sum(p)
    print(int(result))

main()

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 = [0]*(n+1)

for i in range(1,n+1) :
    p[i] = int(input())

p.sort()

p[n] = p[n]//2

print(sum(p))

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

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

Solution (Python):
N = int(input())
P = []
for n in range(N):
    P.append(int(input()))
total = 0
for p in P:
    total +=p
total -= max(P)/2
print(int(total))

Solution (Python):
n = int(input())
x = []
sum = 0

for i in range(n):
    x.append(int(input()))
    
for i in range(len(x)):
    sum += x[i]
    
print(round(sum - (max(x)/2)))

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

max_num = max(line)
sum_num = sum(line) - max_num / 2
print(int(sum_num))

Solution (Python):
N = int(input())
Price = []
maxPrice = 0
sumTotal = 0
for i in range(N):
    priceCurrent = int(input())
    Price.append(priceCurrent)
    if priceCurrent > maxPrice:
        maxPrice = priceCurrent
    sumTotal += priceCurrent
sumTotal -= int(maxPrice/2)
print(sumTotal)

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(n):
    p.append(int(input()))
p = sorted(p)
p[-1] = p[-1]/2
print(int(sum(p)))

Solution (Python):
from heapq import heappush, heappop

class Solver(object):
    def __init__(self):
        self.n = int(input())
        self.items = list()
        for _ in range(self.n):
            heappush(self.items, int(input()))

    def solve(self):
        total = 0
        for _ in range(self.n - 1):
            total += heappop(self.items)
        total += heappop(self.items) / 2
        print (int(total))


if __name__ == "__main__":
    s = Solver()
    s.solve()

Solution (Python):


from sys import stdin

input = stdin.readline

N = int(input())

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

pmax = max(p)

total = sum(p) - int(pmax / 2)

print(total)

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

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

Solution (Python):
import math
num = int(input())
list = sorted([int(input()) for _ in range(num)])

list[-1] = math.floor(list[-1]/2)

print(sum(list))

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

print(int(sum(pp)-max(pp)/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())
list_p=[]
for i in range(N):
    list_p.append(int(input()))

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

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

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())
Pn = [int(input()) for i in range(N)]
Pn.sort(reverse=True)
ans = sum(Pn) - Pn[0]//2
print(ans)

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

Solution (Python):
import sys;t = [int(l) for l in sys.stdin];t=t[1:t[0]+1];print(int(sum([i for c,i in enumerate(t) if c != t.index(max(t))]) + max(t) /2))

Solution (Python):
LINE=input()
n=LINE
ans=0
b=1
for i in range(0,int(n)):
  a=input()
  ans=int(a)+ans
  if int(a)>b:
    b=int(a)
print(int(ans-int(b)/2))

Solution (Python):


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

ans = sum(P)
ans -= int(max(P)/2)

print(ans)

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

Solution (Python):


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

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

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

price = sorted(price, reverse = True)

sum = int(price[0] / 2)

for i in range(1, n_item):
  sum += price[i]
  
print(sum)

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

p = np.array(p)

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

Solution (Python):
line = int(input())
list =[]
for i in range(line):
    list.append(int(input()))
max = max(list)
list.remove(max)
S = max // 2 + sum(list)
print(S)

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

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

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

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

p.sort(reverse=True)

max_val = p.pop(0) / 2
print(int(sum(p) + max_val))

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

Solution (Python):
import math
import sys
from operator import itemgetter







def solve(a):
	a = sorted(a, reverse = True)
	ans = a[0] // 2
	for i in range(1, len(a)):
		ans += a[i]
	print(ans)

if __name__ == '__main__':
	
	n = int(input())
	arr = []
	for i in range(n):
		arr.append(int(input()))
	
	solve(arr)

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

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)



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


def main():
    N = int(input())
    P = list(sorted([int(input()) for _ in range(N)], reverse=True))
    print(sum(P) - P[0] + P[0] // 2)


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

def main():
  input = sys.stdin.readline
  N = int(input())
  P = [int(input()) for _ in range(N)]
  Ph = max(P)
  ans = Ph // 2 + sum(P) - Ph
  print(ans)


if __name__ == '__main__':
  main()

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

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

Solution (Python):



def main():
  n = int(input())
  li = [int(input()) for _ in range(n)]
  li.sort()
  print(int(sum(li) - li[-1]/2))
  pass

if __name__=='__main__':
  main()

Solution (Python):


import copy
import numpy as np
import random

n = int(input())

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

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

print(answer)

Solution (Python):















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

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

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

Solution (Python):
from sys import stdin

N = int(stdin.readline().rstrip())
p = [int(stdin.readline().rstrip()) for _ in range(N)]

m = max(p)

print(sum(p) - m // 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 = []
for i in range(n):
    p.append(int(input()))
price_max = max(p)//2
print(sum(p) - price_max)

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

l = []
for _ in range(n):
  l.append(int(input()))
  
 
l[l.index(max(l))] *= 0.5

print(int(sum(l)))

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

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

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

for i in range(n):
    p_arr.append(int(input()))

p_max = max(p_arr)

p_sum = sum(p_arr)

print(int(p_sum - p_max/2))

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

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

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())
I = [int(input()) for i in range(N)]

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

print(sum(I))

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

P = []

for n in range(N):
	P.append(int(input()))

M = max(P)
P.remove(M)

Tot = M//2

for j in range(N-1):
	Tot += P[j]

print(Tot)

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

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

Solution (Python):




n = int(input())
p = list()
max = 0
sum = 0


for i in range(n):
    p.append(int(input()))
    if max < p[i]:
        max = p[i]
    sum += p[i]

sum -= int(max / 2)


print(sum)

Solution (Python):
import numpy as np
import math

N = int(input())

A = np.zeros(N, dtype=int)
for i in range(N):
    A[i] = int(input())




sumA = sum(A)

maxA = max(A)

print(sumA - int(maxA/2))

Solution (Python):
n = int(input())
p_list = [int(input()) for i in range(n)]
max_p = max(p_list)
max_p_index = p_list.index(max_p)
ans = 0

for i in range(n):
    if i == max_p_index:
        ans += p_list[i] // 2
    else:
        ans += p_list[i]

print(ans)

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

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

P.sort()
maxP = P.pop(-1)
ans = sum(P) + maxP//2
print(ans)

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

Solution (Python):
import numpy as np
import gc

if __name__ == '__main__':
    n=int(input())
    l = list(map(int, [input() for i in range(n)]))
    m = max(l)
    j = l.index(m)
    l[j] = m/2
    print(int(sum(l)))

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 i in range(n)]
p = sorted(p)

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

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

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


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

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

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

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

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

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

price[-1] = price[-1] / 2

print sum(price)

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

Solution (Python):


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

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


if __name__ == '__main__':
    main()

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

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

m = 0
for i in range(N):
    if p[i] > m:
        m = p[i]

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

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

m=max(p)
for i in range(n):
    if p[i]==m:
        p[i]=int(m)/2
        break

print(int(sum(p)))

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

Solution (Python):
n=int(input())
p=[]
[p.append(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())
pl = list()
for _ in range(n):
    pl.append(int(input()))

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

Solution (Python):
def run(N, p):
    return int(sum(p) - max(p) / 2)


def main():
    N = int(input())
    p = []
    for _ in range(N):
        p.append(int(input()))
    print(run(N, p))


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
total=0
max=0
i=int(input())
for j in range(i):
  p=int(input())
  total=total+p
  max=max+(p-max)*(max<p)
  
print(int(total-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 = []
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())
p = list(int(input()) for _ in range(n))
print(int(sum(p)-max(p)/2))

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

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

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

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 i in range(n)]
print(sum(p)-max(p)//2)

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

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

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

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

max_p = max(p_list)

cost = sum(p_list) - max_p /2

print(int(cost))

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

for n in range(N):
    P.append(int(input()))

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

print(int(sum(P)))

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

for i in range(N):
    if p[i] > max:
        max = p[i]
        m = i

p[m] = p[m]/2


for i in range(N):
    A += p[i]

print(int(A))

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

Solution (Python):
n = int(input())
maxv = 0
elem = 0
A = []
res = 0
for i in range(n):
    A.append(int(input()))
    maxv = max(maxv,A[i])
    if maxv==A[i]:
        elem = i

for j in range(n):
    if j == elem:
        res += int(A[j]/2)
    else:
        res += A[j]

print(res)

Solution (Python):
N = int(input())
p = []
for i in range(N):
        p.append(int(input()))
sum  = 0
max_value = max(p)
p.remove(max_value)

sum += max_value/2

for i in p:
        sum += i

print(int(sum))

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 [0]*N]
p.sort(reverse=True)
print(p[0]//2 + sum(p[1:]))

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

sum = 0
max = 0
for p in ps:
  sum += p
  if p > max:
    max = p

sum -= max // 2

print(sum)

Solution (Python):
N =int(input())
l =[int(input())for _ in range(N)]
A =max(l)
s = sum(l) -A*0.5
print(int(s))

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

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

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

prices.sort(reverse=True)

prices[0] = prices[0] / 2

print(int(sum(prices)))

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

answer = 0
M = 0
for i in range(n):
  a = int(input())
  answer += a
  M = max(a, M)
 
answer -= M/2
print(int(answer))

Solution (Python):

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

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

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

if __name__ == '__main__':
  main()

Solution (Python):


def main():
    n = int(input())
    price_list = [int(input()) for i in range(n)]
    price_list.sort()
    price_list[-1] //=  2

    print(sum(price_list))

if __name__ == '__main__':
    main()

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

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
data = [int(stdin.readline().rstrip()) for _ in range(n)]
data = sorted(data, reverse=True)
data[0] *= 0.5
data[0] = int(data[0])

print(sum(data))

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

max_price = 0
sum_price = 0
for price in prices:
    sum_price += price
    if price > max_price:
        max_price = price

sum_price -= max_price/2

print(int(sum_price))

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

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

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

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

ans = 0
for i in range(N):
    ans += a[i]

print(int(ans))

Solution (Python):
import sys
input()
prices = [int(line.strip()) for line in sys.stdin]
prices = sorted(prices, reverse=True)
prices[0] = prices[0]/2
print(int(sum(prices)))

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 i in range(N)]
print(sum(P)-max(P)//2)

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

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

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

Solution (Python):
def fastio():
    import sys
    from io import StringIO 
    from atexit import register
    global input
    sys.stdin = StringIO(sys.stdin.read())
    input = lambda : sys.stdin.readline().rstrip('\r\n')
    sys.stdout = StringIO()
    register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))

n, = I()
l = []
for i in range(n):
    l.append(I()[0])
l.sort()
print(sum(l) - l[-1]//2)

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

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

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

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

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

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

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

price[-1]=price[-1]/2

print(int(sum(price)))

Solution (Python):
from sys import stdin


def main():
    _, *pps = get_params()
    p, *ps = sorted(pps, reverse=True)
    print(solve(p, ps))


def get_params():
    return map(int, read_stdin().split('\n'))


def read_stdin():
    return stdin.read().strip()


def solve(p, ps):
    return p // 2 + sum(ps)


main()

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

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

p.sort()
p.reverse()

p[0] /= 2

print(int(sum(p)))

Solution (Python):

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

Solution (Python):
回数 = int(input())
最大値 = 0
i = 0
合計 = 0
while( i < 回数 ):
    価格 = int(input())
    合計 += 価格
    if ( 価格 > 最大値 ):
        最大値 = 価格
    i = i + 1
合計 = 合計 - 最大値/2
print(int(合計))

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

max_value = 0
values = []

while n > 0:
  value = int(input())
  if value > max_value:
    max_value = value
  values.append(value)
  n -= 1
  
price = sum(values) - max_value // 2
print(price)

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

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

Solution (Python):






def main():
    N = int(raw_input().strip())
    P = []
    for _ in range(N):
        p = int(raw_input().strip())
        P.append(p)

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


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
p = []
sum = 0
for i in range(N):
    p.append(int(input()))
M = max(p)
p = sorted(p, reverse=True)
for i in range(N):
    sum += p[i]

print(int(sum - (M/2)))

Solution (Python):
pr = int(input())
li =[]

for i in range(pr):
    li.append(int(input()))

disc = max(li) // 2

print(sum(li) - disc)

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


if __name__ == '__main__':
    main()

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

for i in range(N):
    p[i] = int(input())
    max_value = max(max_value, p[i])

price = sum(p) - max_value / 2
print(int(price))

Solution (Python):
n = int(input())
p = []
max = 0

for i in range(n):
  a = int(input())
  p.append(a)
  if max < a:
    max = a

ans = max/2

for i in range(n):
    if p[i] == max:
        p[i] = 0
        break

for i in range(n):
  ans += p[i]

print(int(ans))

Solution (Python):

n=int(input())
list=[]

for i in range(n):
	list.append(int(input()))

waribiki=int(max(list)/2)
list.remove(max(list))
list.append(waribiki)

print(sum(list))

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

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

Solution (Python):


import numpy as np

def main():
    n = int(input())
    pn = [int(input()) for i in range(n)]
    res = int(np.sum(pn)) - int(np.max(pn)) // 2
    print(res)

main()

Solution (Python):


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

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

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

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

Solution (Python):

n = int(input())
a = list(map(int, [input() for x in range(n)]))
sum = 0
a[a.index(max(a))] = max(a) / 2
for x in a:
    sum += x
print(int(sum))

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

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

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

answer = sum(prices[0:-1]) + (prices[-1] // 2)
print(answer)

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

ps = []
for n in range(N):
        ps.append( (n, int(input())) )

maxed = max(ps, key=lambda x:x[1])
maxed_index = maxed[0]
ps.pop(maxed_index)

b = maxed[1]/2
for p in ps:
        b += p[1]
print(int(b))

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

p.sort()
kota = 0
for i in range(N-1):
	kota += p[i]
kota += p[N-1]/2
print(int(kota))

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

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

max_i = prices.index(max(prices))
max_half = prices[max_i] // 2

print(sum(prices) - max_half)

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

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

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

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

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

Ans = max(p)//2
p.remove(max(p))

Ans += sum(p)
print(Ans)

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

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

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

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

a = []

for i in range(N):
    tmp=int(input())
    a.append(tmp)
    
print(sum(a)-max(a)//2)

Solution (Python):
""" Atcoder """

import sys
input = sys.stdin.readline

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

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

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