jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;

public class Main {
	String O,E;
	public void solve() {
		O = next();
		E = next();

		for(int i = 0;i < Math.max(O.length(), E.length());i++){
			if(i < O.length()){
				out.print(O.charAt(i));
			}

			if(i < E.length()){
				out.print(E.charAt(i));
			}
		}
		out.println();
	}
	public static void main(String[] args) {
		out.flush();
		new Main().solve();
		out.close();
	}

	/* Input */
	private static final InputStream in = System.in;
	private static final PrintWriter out = new PrintWriter(System.out);
	private final byte[] buffer = new byte[2048];
	private int p = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (p < buflen)
			return true;
		p = 0;
		try {
			buflen = in.read(buffer);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (buflen <= 0)
			return false;
		return true;
	}

	public boolean hasNext() {
		while (hasNextByte() && !isPrint(buffer[p])) {
			p++;
		}
		return hasNextByte();
	}

	private boolean isPrint(int ch) {
		if (ch >= '!' && ch <= '~')
			return true;
		return false;
	}

	private int nextByte() {
		if (!hasNextByte())
			return -1;
		return buffer[p++];
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = -1;
		while (isPrint((b = nextByte()))) {
			sb.appendCodePoint(b);
		}
		return sb.toString();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		Main mainObj = new Main();
		mainObj.solve();
	}

	public void solve() throws IOException {
		FastScanner fs = new FastScanner();
		String o = fs.next();
		String e = fs.next();
		
		StringBuffer sb = new StringBuffer();
		for(int i = 0; i < o.length() + e.length(); i++) {
			if(i % 2 == 0) {
				int index = i/2;
				sb.append(o.charAt(index));
			}else {
				int index = i/2;
				sb.append(e.charAt(index));
			}
		}
		
		System.out.println(sb.toString());
	}

	

	public class FastScanner {

		BufferedReader reader;
		private StringTokenizer st;

		public FastScanner() {
			st = null;
			reader = new BufferedReader(new InputStreamReader(System.in));
		}

		public String next() throws IOException {
			if (st == null || !st.hasMoreElements()) {
				st = new StringTokenizer(reader.readLine());
			}
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			st = null;
			String readLine = null;
			readLine = reader.readLine();
			return readLine;
		}

		public int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws NumberFormatException, IOException {
			return Long.parseLong(next());
		}

		public int[] nextIntArr(int n) throws NumberFormatException, IOException {
			int[] retArr = new int[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextInt();
			}
			return retArr;
		}

		public long[] nextLongArr(int n) throws NumberFormatException, IOException {
			long[] retArr = new long[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextLong();
			}
			return retArr;
		}

		public void close() throws IOException {
			reader.close();
		}
	}

}
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {

	public static void main(String[] args) {
		try (Scanner scanner = new Scanner(System.in)) {
			char[] o = scanner.nextLine().toCharArray();
			char[] e = scanner.nextLine().toCharArray();
			StringBuilder sb = new StringBuilder();
			IntStream.range(0, e.length).forEach(i -> sb.append(o[i]).append(e[i]));
			IntStream.range(0, o.length - e.length).forEach(i -> sb.append(o[o.length - 1 - i]));
			System.out.println(sb.toString());
		}
	}
}
//  [java]
import java.util.Scanner;

class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		 String O = sc.next();

		 String B = sc.next();
		 
		 String[] strO = O.split("");
		 String[] strB = B.split("");
		 
		 String ans[] = new String[strO.length+strB.length];
		 
		 for(int i=0; i<strB.length; i++){
			ans[2*i] = strO[i];
			ans[2*i+1] = strB[i];
		 }
		 if(strO.length>strB.length){
			 ans[2*strB.length] = strO[strO.length-1];
		 }
	
		 for(int i=0; i<ans.length; i++){
			 System.out.print(ans[i]);
		 }
		 
	}

}
//  [java]
import java.util.*;
public class Main{
	public static void main(String[] args){
    	Scanner sc = new Scanner(System.in);
      	char[] o = sc.next().toCharArray();
      	char[] e = sc.next().toCharArray();
      	String s = "";	
      
      	for(int i = 0; i < e.length; i++){
        	s += String.valueOf(o[i]);
          	s += String.valueOf(e[i]);
        }
      	if(o.length!=e.length) s += String.valueOf(o[o.length-1]);
      	System.out.println(s);
    }
}
//  [cpp]
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
int main(){
    char an[100];
    char bn[100];
    while(~scanf("%s%s",an,bn)){
        for(int i=0;i<strlen(an);i++){
            printf("%c",an[i]);
            if(i<strlen(bn)) printf("%c",bn[i]);
        }
        if(strlen(bn)>strlen(an)) printf("%c",bn[strlen(bn)-1]);
        printf("\n");
    }
    return 0;
}
//  [cpp]
#include<stdio.h>
#include<string.h>
char a[60];
char b[60];
int main(){
	scanf("%s",a);
	getchar();
	scanf("%s",b);
	int t = strlen(a) + strlen(b);
	//printf("%d\n",t);
	int n = 0,m = 0;
	for(int i = 1;i <= t;i++){
		if(i%2==0){
			printf("%c",b[n]);
			n++;
		}
		if(i%2!=0){
			printf("%c",a[m]);
			m++;
		}
	}
}
//  [cpp]
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
char a[100],b[100];
int main(){
    while(~scanf("%s%s",a,b)){
        int alen=strlen(a);
        int blen=strlen(b);
        if(alen==blen){
            for(int i=0;i<alen;i++){
                printf("%c%c",a[i],b[i]);
            }
            printf("\n");
        }
        if(alen>blen){
            for(int i=0;i<blen;i++){
                printf("%c%c",a[i],b[i]);
            }
            printf("%c\n",a[alen-1]);
        }
        if(alen<blen){
            for(int i=0;i<alen;i++){
                printf("%c%c",a[i],b[i]);
            }
            printf("%c\n",b[blen-1]);
        }
    }
    return 0;
}
//  [cpp]
#include "bits/stdc++.h"

using namespace std;

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	string o, e;

	cin >> o >> e;

	for (int i = 0; i < o.size(); i++) {
		cout << o[i];
		if (i < e.size()) {
			cout << e[i];
		}
	}

	cout << endl;

	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
const int INF = 1000000007;

 
int main(){
  cin.tie(nullptr);
  ios::sync_with_stdio(false);

  string S, T;
  cin >> S >> T;
  for(int i=0;i<S.size();i++){
    cout << S[i];
    if(i != T.size()) cout << T[i];
  }
  cout << endl;
}
//  [c]
#include <stdio.h>
#include<string.h>
int main()
{
int flag=0,i,str1=0,str2=0;
char a[1000],b[1000],c;
gets(a);
gets(b);
flag=0;
for(i=0;i<strlen(a)+strlen(b);i++)
{
    if(flag==0)
    {
          printf("%c",a[str1++]);
          flag=1;
    }else{
        printf("%c",b[str2++]);
        flag=0;
    }
}


    return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>

int main(void)
{
	char o[50] ,e[50];
	int i, length, counti = 0, countj = 0;
	gets(o);
	gets(e);
	length = strlen(o) + strlen(e);
	for(i = 1; i <= length; i++){
		if(i % 2 == 1){
			counti++;
			printf("%c", o[counti - 1]);
		}
		else {
			countj++;
			printf("%c", e[countj - 1]);
		}
	}
	return 0;	
}
//  [c]
#include <stdio.h>
#include <string.h>

int main(int argc, char const *argv[]) {
  char o[51];
  char e[51];
  int i = 0;

  scanf("%s", o);
  scanf("%s", e);

  //while (strncmp(&o[i], "\0", 1) != 0 || strncmp(&e[i], "\0", 1) != 0) {
  while (strncmp(&o[i], "\0", 1) != 0) {
    printf("%c", o[i]);
    if (strncmp(&e[i], "\0", 1) == 0) {
      break;
    }
    else {
      printf("%c", e[i]);
    }
    i++;
  }
  printf("\n");
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define ll long long

void swap (int *x, int *y) {
  int temp;

  temp = *x;
  *x = *y;
  *y = temp;

  return;
}


long int gcd(long int a, long int b){
  long int c;

  while (b > 0){
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

int upll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?-1:*(ll*)a>*(ll*)b?1:0;
}

int downll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?1:*(ll*)a>*(ll*)b?-1:0;
}

void sortup(ll*a,int n){
  qsort(a,n,sizeof(ll),upll);
}

void sortdown(ll*a,int n){
  qsort(a,n,sizeof(ll),downll);
}

long int modpow(long int a,long int n,long int mod){
  long int ans=1;
  while(n>0){
    if(n & 1){
      ans=ans*a%mod;
    }
    a=a*a%mod;
    n/=2;
  }
  return ans;
}

long int modinv(long int a,long int mod){
  return modpow(a,mod-2,mod);
}

int max(int a,int b){
  if(a<b){
    return b;
  }
  else{
    return a;
  }
}

int min(int a,int b){
  if(a<b){
    return a;
  }
  else{
    return b;
  }
}

void chmax(int *a,int b){
  if(*a < b){
    *a = b;
  }

  return;
}

void chmin(int *a,int b){
  if(*a > b){
    *a =b;
  }

  return;
}


int main(void){
  char o[60],e[60],s[110];
  scanf("%s%s",o,e);
  int l=strlen(o),k=strlen(e),n=l+k;
  for(int i=0;i<l;i++){
    s[2*i]=o[i];
  }
  for(int i=0;i<k;i++){
    s[2*i+1]=e[i];
  }
  for(int i=0;i<n;i++){
    printf("%c",s[i]);
  }
  printf("\n");
  return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define rep(i,n) for(int i=0;i<n;i++)
int gcd(int a, int b){
    int r=1;
    while(r!=0){
        r=a%b;
        a=b;
        b=r;
    }
    return a;
}
typedef long long ll;
void revStr(char* str){
    int size = strlen(str);
    int i,j;
    char tmp = {0};
    for(i = 0, j = size - 1; i < size / 2; i++, j--){
        tmp = str[i];
        str[i] = str[j];
        str[j] = tmp;
    }return;
}
typedef struct{
    int a,b;
}data;

//昇順
int compare_int(const void *a, const void *b)
{
    return *(int*)a - *(int*)b;
}
//構造体降順
int comp( const void *c1, const void *c2 )
{
  data test1 = *(data *)c1;
  data test2 = *(data *)c2;
  int tmp1 = test1.b;   /* b を基準とする */
  int tmp2 = test2.b;
  return tmp2 - tmp1;
}


int kai(int n){
    if(n==0){
        return 1;
    }
    int sum=1;
    for(int i=1;i<=n;i++){
        sum*=i;
    }
    return sum;
}

int main(){
    char o[100],e[100];
    scanf("%s",o);
    scanf("%s",e);
    for(int i=0;i<strlen(o);i++){
        if(o[i]==0){
            ;
        }else{
            printf("%c",o[i]);
        }
        if(e[i]==0){
            ;
        }else{
            printf("%c",e[i]);
        }
    }
}
//  [c]
#include <stdio.h>
#include <math.h>
int main(void){
    
    char a[52],b[51],c[102];
    int i,j=0;
    
    scanf("%s%s",a,b);
    
    for(i=0;i<strlen(a);i++){
        c[j]=a[i];
        j++;
        c[j]=b[i];
        j++;
    }
    c[j]='\0';
    
    printf("%s",c);
    
}
//  [javascript]
"use strict";

const fs = require("fs");

const input = fs.readFileSync(0).toString().trim().split("\n");
const a = input[0];
const b = input[1];
const result = [];
for (let i = 0, len = a.length; i < len; i++)
  result[i * 2] = a[i];
for (let i = 0, len = b.length; i < len; i++)
  result[i * 2 + 1] = b[i];
process.stdout.write(result.join("") + "\n");
//  [javascript]
function Main( input ){

    input = input.split( '\n' )
    
    var o = [].slice.call( input[0] )
    var e = [].slice.call( input[1] )
    
    var pass = ''
    
    for( ;; ){
        if( o.length ) pass += o.shift()
        if( e.length ) pass += e.shift()
        if( o.length === 0 && e.length === 0 ) break
    }
    
    console.log( pass )

}

Main( require( 'fs' ).readFileSync( '/dev/stdin', 'utf8' ) )
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = [];
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on('line', (line) => {
  lines.push(line);
});
reader.on('close', () => {
    const a = lines[0].split("");
    const b = lines[1].split("");
    const ans = a.map((v, i)=>v+(b[i]||"")).join("");
    console.log(ans);
});
//  [javascript]
a=(""+require("fs").readFileSync(0)).split`\n`;console.log(a[0].split``.map((c,i)=>c+(a[1][i]||"")).join``)
//  [go]
package main

import "fmt"

func main() {
	var o, e string
	fmt.Scan(&o, &e)

	var ans string
	for i := 0; i < len(o); i++ {
		if i == len(o)-1 && len(e)-1 < i {
			ans += string(o[i])
		} else {
			ans += string(o[i]) + string(e[i])
		}
	}
	fmt.Println(ans)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var o, e string
	fmt.Scan(&o, &e)
	
	ocnt,ecnt := 0, 0
	for i := 0; i < len(o)+len(e); i++ {
		if i % 2 == 0 {
        	fmt.Printf("%v",string(o[ocnt]))
			ocnt++
		} else {
        	fmt.Printf("%v",string(e[ecnt]))
			ecnt++
		}
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var o, e string
	fmt.Scan(&o, &e)

	var ans string
	for i := 0; i < len(e); i++ {
		ans += string(o[i])
		ans += string(e[i])
	}
	if len(o)-len(e) == 1 {
		ans += string(o[len(o)-1])
	}

	fmt.Println(ans)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
)

const (
	initialBufSize = 10000
	maxBufSize     = 1000000009
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	O := nextLine()
	E := nextLine()
	ans := make([]rune, len(O)+len(E))
	for i := 0; i < len(O)+len(E); i++ {
		switch i % 2 {
		case 0:
			ans[i] = rune(O[i/2])
		case 1:
			ans[i] = rune(E[i/2])
		}
	}
	fmt.Println(string(ans))
}

func nextLine() string {
	sc.Scan()
	return sc.Text()
}
//  [go]
package main

import "fmt"

func main() {
	// Code for B - ∵∴∵
	var O, E string
	fmt.Scanf("%s\n%s", &O, &E)

	for i := 0; i < len(E); i++ {
		fmt.Printf("%c%c", O[i], E[i])
	}

	if len(O) != len(E) {
		fmt.Printf("%c", O[len(O)-1])
	}
	fmt.Printf("\n")
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"reflect"
	"strconv"
)

const (
	maxBufSize = 1024 * 1024
)

var (
	sc = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, 1)
		sc.Buffer(buf, maxBufSize)
		sc.Split(bufio.ScanWords)
		return sc
	}()
	out = bufio.NewWriter(os.Stdout)
)

func solve(o string, e string) string {
	ret := []byte(o + e)
	for i, c := range(o) {
		ret[i * 2] = byte(c)
	}
	for i, c := range(e) {
		ret[i * 2 + 1] = byte(c)
	}
	return string(ret)
}

func main() {
	defer out.Flush()

	o := next()
	e := next()
	res := solve(o, e)
	fmt.Fprintln(out, res)
}

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextStringAsBytes() []byte {
	sc.Scan()
	return []byte(sc.Text())
}

func nextInt() int64 {
	a, _ := strconv.ParseInt(next(), 10, 64)
	return a
}

func nextFloat() float64 {
	a, _ := strconv.ParseFloat(next(), 64)
	return a
}

func nextInts(n int64) []int64 {
	ret := make([]int64, n)
	for i := int64(0); i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}

func nextFloats(n int64) []float64 {
	ret := make([]float64, n)
	for i := int64(0); i < n; i++ {
		ret[i] = nextFloat()
	}
	return ret
}
func nextStrings(n int64) []string {
	ret := make([]string, n)
	for i := int64(0); i < n; i++ {
		ret[i] = next()
	}
	return ret
}

func containStr(arr []string, target string) bool {
	for _, v := range arr {
		if v == target {
			return true
		}
	}
	return false
}

func PrintOut(src interface{}, joinner string) {
	switch reflect.TypeOf(src).Kind() {
	case reflect.Slice:
		s := reflect.ValueOf(src)
		for idx := 0; idx < s.Len(); idx++ {
			fmt.Fprintf(out, "%v", s.Index(idx))
			if idx < s.Len()-1 {
				fmt.Fprintf(out, "%s", joinner)
			} else {
				fmt.Fprintln(out)
			}
		}
	default:
		fmt.Fprintln(out, "orz")
	}
}

// mapからkeysとvaluesを返す
func splitKeyValue(m map[interface{}]interface{}) (keys, values []interface{}) {
	switch reflect.TypeOf(m).Kind() {
	case reflect.Map:
		s := reflect.ValueOf(m)
		for _, v := range s.MapKeys() {
			keys = append(keys, v)
			values = append(values, s.MapIndex(v))
		}
	default:
		fmt.Fprintln(out, "orz")
	}
	return
}
//  [ruby]
o = gets.chomp.split('')
e = gets.chomp.split('')
ans = ''
o.each_with_index do |a,i|
    ans+=a
    ans+=e[i] if i<e.length
end
puts ans
//  [ruby]
o = gets.chomp.chars
e = gets.chomp.chars

l = [o.size, e.size].max

ans = l.times.with_object([]) { |i, arr| arr << o[i] << e[i] }.compact.join

puts ans
//  [ruby]
o = gets.chomp.chars
e = gets.chomp.chars

l = [o.length, e.length].max

ans = l.times.with_object([]) do |i, str|
  str << o[i] << e[i]
end

puts ans.join
//  [ruby]
require 'prime'
include Math
def max(a,b);                    a > b ? a : b                            end
def min(a,b);                    a < b ?  a : b                           end
def swap(a,b);                   a, b = b, a                              end
def gif;                         gets.to_i                                end
def gsf;                         gets.chomp                               end
def gi;                          gets.split.map(&:to_i)                   end
def gs;                          gets.chomp.split.map(&:to_s)             end
def gc;                          gets.chomp.split('')                     end
def pr(num);                     num.prime_division                       end
def putall(obj);                 obj.each{|o| puts(o)}                    end
def array(size,init=nil);        Array.new(size){init}                    end
def darray(size1,size2,init=nil);Array.new(size1){Array.new(size2){init}} end
def rep(num);                    num.times {|i|yield(i)}                  end
def repl(st,en);                 st.upto(en) {|i|yield(i)}                end


o = gc
e = gc
str = []
loop{
	str << o.shift unless o.empty?
	str << e.shift unless e.empty?
	break if o.empty? && e.empty?
}

puts str.join
//  [ruby]
require 'pp'
$DEBUG ? define_method(:dpp){|e|pp e} : define_method(:dpp){|e|}

# 入力値を文字の配列で返却する
def gets_nsp_list()
  gets.chomp.split("")
end

os = gets_nsp_list
es = gets_nsp_list

ans = []

while !os.empty? || !es.empty?
  ans.push os.shift
  ans.push es.shift
end

puts ans.join
//  [ruby]
o=gets.chomp
e=gets.chomp

ans=""
(o.length+e.length).times do |i|
    if i%2==0
        ans+=o[i/2]
    else
        ans+=e[i/2]
    end
end
puts ans
//  [rust]
use std::io;

fn main(){
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let o = buf.trim().chars().collect::<Vec<char>>();
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let e = buf.trim().chars().collect::<Vec<char>>();
	let mut ret:Vec<char> = Vec::new();
	for i in 0..(o.len()+e.len()) {
		if i%2 == 0 {
			ret.push(o[i/2]);
		}else{
			ret.push(e[i/2]);
		}
	}
	for i in ret {
		print!("{}", i);
	}
	println!("");
}
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

use std::cmp::max;
use std::cmp::min;

fn main() {
    let o: String = read();
    let e: String = read();
    let ov: Vec<char> = o.chars().collect();
    let ev: Vec<char> = e.chars().collect();
    let mut ans: String = "".to_string();

    for i in 0..o.len() {
        ans += &ov[i].to_string();
        if i < e.len() {
            ans += &ev[i].to_string();
        }
    }
    println!("{}", ans);
}
//  [rust]
use proconio::input;

fn main() {
	input!(o: String);
	input!(e: String);

	let vo: Vec<char> = o.chars().collect();
	let ve: Vec<char> = e.chars().collect();

	for i in 0..ve.len() {
		print!("{}{}", vo[i], ve[i]);
	}
	if vo.len() > ve.len() {
		print!("{}", vo[vo.len()-1]);
	}
	println!("");
}
//  [rust]
use proconio::input;
use proconio::marker::Chars;

fn main() {
    input! {
        o: Chars, e: Chars
    }

    solve(&o, &e);
}

fn solve(o: &Vec<char>, e: &Vec<char>) {
    for i in 0..(o.len() - 1) {
        print!("{}{}", o[i], e[i]);
    }
    if o.len() == e.len() {
        print!("{}{}", o[o.len() - 1], e[e.len() - 1]);
    } else {
        println!("{}", o[o.len() - 1]);
    }
    println!("");
}
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

let O = readLine()!.toArray()
let E = readLine()!.toArray() + [""]
for i in 0..<O.count {
    print(O[i]+E[i], terminator: "")
}
//  [swift]
import Foundation

var O = readLine()!.characters
var E = readLine()!.characters

var r: String = ""

while true {
    guard let o = O.popFirst() else {
        break
    }
    r.append(o)
    guard let e = E.popFirst() else {
        break
    }
    r.append(e)
}

print(r)
//  [swift]
import Foundation

let o = readLine()!.map { String($0) }
let e = readLine()!.map { String($0) }
var ans = ""
let n = e.count
for i in 0..<n {
  ans += o[i] + e[i]
}
if o.count != n {
  ans += o.last!
}
print(ans)
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);const tn=():number=>{const a=input[0];input.shift();return Number(a)};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{const a=input[0];input.shift();return String(a)};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const tc=():string=>{let a=input[0].split('');const b=a[0];a.shift();if(a.length>0){input[0]=a.join('')}else{input.shift()}return String(b)};const tcc=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(tc())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1];}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const objvs =(a)=>{const b=[];for(const v in a){b.push(a[v])}return b};const deduplicate=(a):any[]=>{return Array.from(new Set(a))};
const main=()=>{
  let [a,b]=tss(2),s='';
  for(let i=0;i<a.length;i++){
    s+=b[i]?a[i]+b[i]:a[i]
  }
  to(s)
}
main()
//  [typescript]
"use strict";
const Main = (input) =>{
   let xs = input.trim().split('\n');
   let O = xs[0].trim().split('');
   let E = xs[1].trim().split('');
   
   let ans = '';
   for(let i=0; i<E.length; i++){
     ans +=(O[i]+E[i]);
   }
   
   if(O.length==E.length){
     console.log(ans);
     }else if(O.length>E.length){
     console.log(ans+O[O.length-1]);
     }else{
     console.log(ans+E[E.length-1]);
     }
       




}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [typescript]
function main(input) {
	const [o, d] = input.trim().split("\n");
  	let result = "";
  	for (let i = 0; i < o.length; i++) {
      	if (!d[i]) {
        	result = result + o[i];
          	continue;
        }
      	result = result + o[i] + d[i];
    }
  	console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import * as fs from "fs";
const input = fs.readFileSync("/dev/stdin", "utf-8");

function Main(input: string) {
  const [O, E] = input.split("\n").map((str) => str.split(""));
  let ans: string = "";
  O.forEach((o, i) => {
    ans += o;
    if (E[i]) ans += E[i];
  });
  console.log(ans);
}

Main(input);
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const O = input[0][0];
  const E = input[1][0];

  const password: string[] = [];

  for (let i = 0; i < E.length; i++) {
    password.push(O[i]);
    password.push(E[i]);
  }

  if (O.length !== E.length) {
    password.push(O[O.length - 1]);
  }

  return password.join("");
};

console.log(main(read()));
//  [typescript]
function main(input):void {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	const inpt: Array<string> = input.split('\n');

	const odd: Array<string> = inpt[0].split('');
	const even: Array<string> = inpt[1].split('');

	const len: number = odd.length + even.length;

	let ans: string = ''
	for (let i = 0; i < len; i++) {
		if (i % 2 === 0) {
			ans += odd.shift();
		} else {
			ans += even.shift()
		}
	}

	console.log(ans);
}

// *** debug start ***
function debug(): void{
	const input = (<HTMLInputElement>document.getElementById('input')).value;
	input && main(input);
}
// *** debug end ***

//
declare function require(x: string): any;
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
N = int(input())
P = [int(input()) for j in range(N)]
print(sum(P) - max(P) // 2)
//  [python]
N = int(input())
num_list = []
for i in range(N):
    num_list.append(int(input()))

max_num = max(num_list)
print(str(sum(num_list) - int(max_num/2 + 0.1)))
//  [python]
n = int(input())
p = [int(input()) for i in range(n)]
p.sort()
print(sum(p)-p[-1]//2)
//  [python]
# -*- coding: utf-8 -*-
"""
Created on Sat Dec  8 20:50:55 2018

@author: Owner
"""

import collections
import scipy.misc
import sys
import numpy as np
import math
from operator import itemgetter

def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []

"""
N, X = map(int, input().split())

x = [0]*N
x[:] = map(int, input().split())

P = [0]*M
Y = [0]*M
for m in range(M):
    P[m], Y[m] = map(int, input().split())
    
all(nstr.count(c) for c in '753')
"""

N = int(input())

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

p[np.argmax(p)] = p[np.argmax(p)]/2

print(int(sum(p)))
//  [python]
import numpy as np
n = int(input())
item = np.array([int(input()) for i in range(n)])

print(int(item.sum()-item.max()/2))
//  [python]
import numpy as np
def main():
	
	n = int(input())
	sum = 0
	l = np.zeros(n)
	for i in range(n):
		buf = int(input())
		l[i] = buf
		sum += buf
	
	print(int(sum-np.max(l)/2))
		
	
		
main()# your code goes here
//  [java]
import java.util.*;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.ArrayDeque;
import java.util.Deque;


public class Main {
    public static void main(String[] args) throws Exception {
        // Your code here!
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] goods = new int[n];
        int max = 0;
        int max_index = 0;
        
        for (int i = 0; i < n; i++) {
            int price = Integer.parseInt(br.readLine());
            goods[i] = price;
            if (price > max) {
                max = price;
                max_index = i;
            }
        }
        
        goods[max_index] /= 2;
        
        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans += goods[i];
        }
        System.out.println(ans);
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String args[]) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());

		int a[] = new int[n];
		int max = 0;
		int maxI = 0;

		for (int i = 0; i < n; i++) {
			a[i] = Integer.parseInt(br.readLine());
			if (max < a[i]) {
				max = a[i];
				maxI = i;
			}
		}

		int ans = 0;

		for (int i = 0; i < n; i++) {
			if (i == maxI) {
				ans += a[i] / 2;
			} else {
				ans += a[i];
			}
		}

		System.out.println(ans);
	}
}
//  [java]
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map.Entry;

import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main {
	
	public static class Move {
		int fx, fy, gx, gy;
		
		public Move(int fx, int fy, int gx, int gy) {
			this.fx = fx;
			this.fy = fy;
			this.gx = gx;
			this.gy = gy;
		}
		
		public String toString() {
			return this.fy + " " + this.fx + " " + this.gy + " " + this.gx;
		}
	}
	
	public static int[][] move_dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
	public static boolean in_range(int x, int y, int W, int H) {
		return 0 <= x && x < W && 0 <= y && y < H;
	}
	
	public static void main(String[] args) throws IOException {
		try(final Scanner sc = new Scanner(System.in)){
			final int N = sc.nextInt();
			
			int[] array = new int[N];
			for(int i = 0; i < N; i++) { array[i] = sc.nextInt(); }
			
			System.out.println(Arrays.stream(array).sum() - Arrays.stream(array).max().getAsInt() / 2);
		}
	}

	public static class Scanner implements Closeable {
		private BufferedReader br;
		private StringTokenizer tok;

		public Scanner(InputStream is) throws IOException {
			br = new BufferedReader(new InputStreamReader(is));
		}

		private void getLine() throws IOException {
			while(!hasNext()){
				tok = new StringTokenizer(br.readLine());
			}
		}

		private boolean hasNext() {
			return tok != null && tok.hasMoreTokens();
		}

		public String next() throws IOException {
			getLine();
			return tok.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public int[] nextIntArray(int n) throws IOException {
			final int[] ret = new int[n];
			for(int i = 0; i < n; i++){
				ret[i] = this.nextInt();
			}
			return ret;
		}

		public long[] nextLongArray(int n) throws IOException {
			final long[] ret = new long[n];
			for(int i = 0; i < n; i++){
				ret[i] = this.nextLong();
			}
			return ret;
		}

		public void close() throws IOException {
			br.close();
		}
	}
}
//  [java]
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        List<Integer> p = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            p.add(sc.nextInt());
        }
        sc.close();

        Collections.sort(p);

        p.add(p.remove(n - 1) / 2);
        int ans = p.stream().mapToInt(e -> e).sum();
        System.out.println(ans);
    }

}
//  [cpp]
#include<stdio.h>

int main(void)
{
	int N, p, i, max = 0, ans = 0;
	scanf("%d", &N);
	for (i = 0; i < N; ++i) {
		scanf("%d", &p);
		ans += p;
		if (max < p) {
			max = p;
		}
	}
	printf("%d", ans - max + max / 2);
	return 0;
}
//  [cpp]
#include <iostream>
#include <vector>

using namespace std;

int main(){
  int N; cin>>N;
  vector<int> p(N);
  int index=0;
  for(int i=0;i<N;i++){
    cin>>p[i];
    index=(p[index]>p[i]?index:i);
  }
   
  int sum=0;
  for(int i=0;i<N;i++){
    if(i==index){
      sum+=p[i]/2;
    }
    else sum+=p[i];
  }

  cout<<sum<<endl;

  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int N, sum, Max;

int main(){
    int p;
    scanf("%d", &N);
    for (int i=1; i<=N; i++){
        scanf("%d", &p);
        Max = max(Max, p);
        sum += p;
    }
    printf("%d", sum - (Max/2));
    return 0;
}
//  [cpp]
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <numeric>

using namespace std;

int main() {
  int n;
  cin >> n;
  vector<int> p;
  for (int i=0; i<n; ++i) {
    int x;
    cin >> x;
    p.push_back(x);
  }
  sort(begin(p), end(p));
  p[p.size()-1] /= 2;
  int ans = accumulate(begin(p), end(p), 0);
  cout << ans << endl;
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
 
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
 
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
 
const int mod=1e9+7;
 
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};
 
mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}
 
bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;
 
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }
 
    return true;
}
 
map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}
 
void printv(vi& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
void printv(vll& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
int vtotal(vi& v){
  int total=0;
  rep(i,v.size()) total+=v[i];
  return total;
}
 
int main()
{
  //init(); // mint初期化
  cin.tie( 0 );
  ios::sync_with_stdio( false );
 
  int n;
  cin>>n;
  vi p(n);
  rep(i,n)cin>>p[i];
  rvisort(p);
  int ans=vtotal(p)-p[0]/2;
  cout(ans);
 
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define pb push_back
#define Int long long
using namespace std;

const int MAXN=500005;
const long MOD=(long)(1e9+7);
vector<int> adj[MAXN];
vector<pair<int,int>> G[MAXN];

Int N,M,K;
Int B,C,H,W;
Int X,Y,Z;
vector<Int> A;

Int ceilS(Int x,Int y){
    return (x+y-1)/y;
}
using D=long double;

Int perform(Int x){
    return (x*(x+1))/2LL;
}

D getExpectation(D x) {
   return perform(x)/x;
}

int main()
{
    cin>>N;
    Int sum=0;Int ans=0;
    for(int i=0;i<N;++i){
        Int x;cin>>x;
        sum+=x;
        ans=max(ans,x);
    }
    Int rem=ans/2;
    sum-=ans;
    sum+=rem;
    cout<<sum<<"\n";
}
//  [c]
#include<stdio.h>
int main()
{
    int n;
    scanf("%d",&n);
    int da=0,he=0;
    int a;
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a);
        he += a;
        if(a>da)da=a;
    }
    printf("%d",he-da/2);
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    long long int i,j,n,max,s;
    double sum;
    scanf("%lld",&n);
    j=0;
    long long int a[n+10];
    for(i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    max=a[0];
    for(i=0;i<n;i++)
    {
        if(max<a[i])
        {
            max=a[i];
            j=i;
        }
    }
    a[j]=0;
    sum=max/2.0;
    for(i=0;i<n;i++)
    {
        sum=sum+a[i];
    }
   s=(long long int)sum;
   if(s==sum)
   {
       printf("%lld\n",s);
   }
   else
    printf("%.1lf\n",sum);
   return 0;

}
//  [c]
//b.c B-Christmas Eve Eve
#include<stdio.h>

int main(void){
    int n;
    scanf("%d\n",&n);
    int p[n];
    for(int i=0;i<n;++i){
        scanf("%d",&p[i]);
    }

    int max = p[0];
    int maxnum = 0;
    for(int i=0;i<n;++i){
        if(max<p[i]){
            max = p[i];
            maxnum = i;
        }
    }

    int sum = 0;
    for(int i=0;i<n;++i){
        if(i!=maxnum){
            sum += p[i];
        }else{
            sum += (p[i]/2);
        }
    }

    printf("%d\n",sum);
    return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    int n,p,ans=0,max=0;
    scanf("%d",&n);
    for (int i=0; i<n; i++){
        scanf("%d",&p);
        ans+=p;
        max=max>p?max:p;
    }
    ans=ans-max/2;
    printf("%d\n",ans);
	return 0 ;
}
//  [c]
#include<stdio.h>
int main()
{
    int n,i, s, max =-1,ttl1 =0, ttl2=0,ttl ;
    scanf("%d", &n);
    for(i=1;i<=n;i++)
    {
        scanf("%d", &s);
        if(s>max)
        {
            max = s;
            ttl1=max/2;
        }
        ttl2 += s;

    }
    ttl = ttl1 +ttl2-max;
    printf("%d", ttl);
    return 0;
}
//  [c]
#include <stdio.h>

int main()
{
	int i, N, p[11], max = 0, sum = 0;
	scanf("%d", &N);
	for (i = 1; i <= N; i++) scanf("%d", &(p[i]));
	for (i = 1; i <= N; i++) {
		if (p[i] > max) max = p[i];
		sum += p[i];
	}
	printf("%d\n", sum - max / 2);
	fflush(stdout);
	return 0;
}
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
	//文字列から10進数に変換するときはparseIntを使います
	var n = parseInt(input[0], 10);
    var ptotal=0;pbox=0;
	for(i=1;i<=n;i++){
        var p = parseInt(input[i], 10);
         ptotal+=p;
        if(pbox<=p){ pbox=p;}
   
    }
    console.log(ptotal-pbox/2);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';
const main = input => {
  const n = parseInt(input[0], 10);
  input.shift();
  const p = input.map(val => parseInt(val, 10));
  p.pop();
  // console.log(n, p);
  p[p.indexOf(Math.max.apply(null, p))] /= 2;
  console.log(p.reduce((prev, current)  => prev + current));
  
  
}
main(require("fs").readFileSync("/dev/stdin", "utf8").split('\n'));
//  [javascript]
function Main(input) {
  // 入力
	input = input.split('\n');
	
	var n = parseInt(input[0], 10);
	input.shift();
	for (var i = 0; i < n; i++) {
		input[i] = parseInt(input[i], 10);
	}

	// 計算
	var tmp = input.indexOf(Math.max.apply(null, input));
	input[tmp] /= 2; 
	function sum(a) {
		return a.reduce(function(x, y) { return x + y; });
	}

	//出力
	console.log('%d', sum(input));
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";

function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function main(input) {
  var _splitNum$filter = splitNum(input).filter(function (x) {
    return x;
  }),
      _splitNum$filter2 = _toArray(_splitNum$filter),
      N = _splitNum$filter2[0],
      ps = _splitNum$filter2.slice(1);

  ps.sort(function (a, b) {
    return b - a;
  });
  ps[0] /= 2;
  var sum = ps.reduce(function (a, b) {
    return a + b;
  }, 0);
  console.log(sum);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));

function splitNum(line) {
  return line.split(/\s+/).map(function (n) {
    return parseInt(n);
  });
}
//  [javascript]
'use strict'

const main = (INPUT) => {
  const tmp = INPUT.split('\n').map(n => Number(n))
  tmp.shift()
  let input = tmp.sort((a, b) => b - a)
  let ans = 0;
  for (let i = 0; i < input.length; i++) {
    if (i == 0) {
      ans += input[i] / 2
    } else {
      ans += input[i]
    }
  }
  console.log(ans);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input){
	input = input.split("\n").map((a)=>~~a);
  var highest = -1;
  var price = 0;
  for(var i = 1; i < input.length;i++){
  	price += input[i];
    if(highest < input[i]){
    	highest = input[i];
    }
  }
  price -= highest / 2;
  return ~~price;
}

// If you are interested in the algorithms I used, 
// there is no need to read down from this line.

((b,c,d)=>"undefined"!=typeof require?console.log(Main(require("fs").readFileSync("/dev/stdin","utf8"))):[b=b.split("\n").slice(1,-1).join("\n"),c=function(){try{return Main(b)}catch(f){return f.stack||f.message}}(),d=typeof c,"string"==d||(c=JSON.stringify(c)),$("<form>").append([[10,b],0,[1,d],0,[10,c]].map(f=>$(f?"<textarea>":"<br>",f&&{rows:f[0],cols:40,text:f[1]}))).appendTo("body")])(`
4
4320
4320
4320
4320
`);
//  [go]
package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	
	prices := make([]int, n)
	
	sum := 0;
	high := 0
	for i := 0; i < n; i++ {
		fmt.Scan(&prices[i])
		sum += prices[i]
		if prices[i] > high {
			high = prices[i]
		}
	}
	sum -= high / 2
	fmt.Println(sum)
}
//  [go]
package main

import "fmt"

func main() {
	var N, p int
	fmt.Scan(&N)

	var max, add int
	for i := 0; i < N; i++ {
		fmt.Scan(&p)
		add += p
		if max < p {
			max = p
		}
	}

	fmt.Println(add - max/2)
}
//  [ruby]
_,*p=$<.map &:to_i
p p.inject(:+)-p.max/2
//  [ruby]
n = gets.to_i
ps = n.times.map { gets.to_i }.sort!

puts ps[0..-2].inject(:+) + ps[-1] / 2
//  [ruby]
n=gets.to_i
s=0
m=0
n.times do
  a=gets.to_i
  s+=a
  if a>m 
    m=a
  end
end
s-=m/2
p s
//  [ruby]
n,*a=`dd`.split.map(&:to_i)
m=a.max
p a.sum-m+m/2
//  [ruby]
n=gets.to_i
s=[]
n.times do |i|
  s[i]=gets.to_i
end
s=s.sort.reverse
s[0]=s[0]/2
puts s.sum
//  [ruby]
n = gets.to_i
ps = n.times.map {gets.to_i}
max = ps.max
p max / 2 + (ps.sum - max)
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: usize = read();
    let mut a: Vec<i64> = vec![];
    for _ in 0..n {
        a.push(read());
    }

    let maxv: i64 = *a.iter().max().unwrap();
    let sum: i64 = a.iter().sum();
    println!("{}", sum - (maxv / 2));
}
//  [rust]
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let N: i32 = read();
    let P: Vec<i32> = (0..N).map(|_| read()).collect();
    let mut ans = 0;
    let mut ma = 0;
    for &p in &P {
        ans += p;
        ma = std::cmp::max(ma, p);
    }
    println!("{}", ans - ma/2);
}
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();
    let n: usize = iter.next().unwrap().parse().unwrap();
    let p: Vec<i32> = (0..n).map(|_|  iter.next().unwrap().parse().unwrap()).collect();
    let mut ans: i32 = p.iter().sum();
    ans -= p.iter().max().unwrap() / 2;
    println!("{}",ans);
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input!(n: usize, p: [usize; n]);

    let max: &usize = p.iter().max().unwrap();

    println!("{}", p.iter().sum::<usize>() - *max / 2);
}
//  [rust]
use proconio::{input, fastout};

macro_rules! debug {
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
      }
  }

#[fastout]
fn main() {
    input!{
        n: usize,
        mut p: [usize;n],
    }

    p.sort();
    let mut ans = 0;
    for i in 0..n {
        if i==n-1 {
            ans += p[i]/2;
        } else {
            ans += p[i];
        }
    }

    println!("{}", ans);

}
//  [rust]
#![allow(non_snake_case)]
#![allow(unused_imports)]
#![allow(dead_code)]

use proconio::{input, fastout};
use proconio::marker::*;
use whiteread::parse_line;
use std::collections::*;
use num::*;
use num_traits::*;
use superslice::*;
use std::ops::*;

use itertools::Itertools;
use itertools_num::ItertoolsNum;


#[fastout]
fn solve() {
    const MOD: usize = 1_000_000_007;
    const INF: usize = std::usize::MAX;
    
    input!{
        n: usize,
        mut p_vec: [usize; n],
    }

    p_vec.sort();

    println!("{}", p_vec[..n-1].iter().sum::<usize>() + p_vec[n-1]/2);
}

fn main() {
    solve()
}

#[cfg(test)]
mod test {
    use super::solve;
}