Problem:


Score : 100 points

Problem Statement

Takahashi wants to print a document with N pages double-sided, where two pages of data can be printed on one sheet of paper.

At least how many sheets of paper does he need?

Constraints

N is an integer.

1 \leq N \leq 100

Input

Input is given from Standard Input in the following format:

N

Output

Print the answer.

Sample Input 1

5

Sample Output 1

3

By printing the 1-st, 2-nd pages on the 1-st sheet, 3-rd and 4-th pages on the 2-nd sheet, and 5-th page on the 3-rd sheet, we can print all the data on 3 sheets of paper.

Sample Input 2

2

Sample Output 2

1

Sample Input 3

100

Sample Output 3

50



Sample input:
5


Sample output:
3

Submission status: Accepted

Solution code:
import sys, math
a = int(input())
print(math.ceil(a/2))

Submission status: Accepted

Solution code:
import sys
import math
import bisect

def main():
    n = int(input())
    ans = n // 2 + n % 2
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
n=int(input())
print(n//2+(n%2))

Submission status: Accepted

Solution code:
N = int(input())

import math

print(math.ceil(N/2))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
# input = sys.stdin.readline
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

def main():
    N=ii()
    print(-(-N//2))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:

n=int(input())
if n%2==0:
    print(n//2)
else:
    print(n//2+1)

Submission status: Accepted

Solution code:
#coding:utf-8
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    XLMIIS = lambda x: [LMIIS() for _ in range(x)]
    YN = lambda c : print('Yes') if c else print('No')
    MOD = 10**9+7

    N = II()
    from math import ceil
    print(ceil(N/2))
    

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import math
import copy
import queue
input = sys.stdin.readline
input = sys.stdin.readline
a = int(input())
print (math.ceil(a / 2))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
INF = float("inf")


def solve(N: int):
    print((N+1)//2)
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def ncr(n, r, mod=DIV):
	r = min(r, n-r)
	ret = 1
	for i in range(1, r+1):
		ret = ret * (n-i+1) % mod
		ret = ret * mod_inv(i, mod) % mod
	return ret

def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max,mod=DIV):
    fac,finv,inv = [0]*max, [0]*max, [0]*max
    fac[0]=fac[1]=1
    finv[0]=finv[1]=1
    inv[1]=1
    for i in range(2,max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod -inv[mod%i] * (mod//i)%mod
        finv[i] = finv[i-1]*inv[i]%mod
    class CONV:
        def __init__(self):
            pass
        def ncr(self,n,k):
            if(n<k):
                return 0
            if(n<0 or k<0 ):
                return 0
            return fac[n]*(finv[k]*finv[n-k]%mod)%mod
    return CONV()


def main():
    N= iRaw()
    ans = (N+1)//2
    return ans



if __name__ == "__main__":
    print(main())

Submission status: Accepted

Solution code:
import numpy as np
import math

if __name__ == "__main__":
  _n = int(input())
  ans = math.ceil(_n / 2)
  print(ans)

Submission status: Accepted

Solution code:

N = int(input())
# a,b,c = list(map(int, input().split()))
ans = N//2 if N%2==0 else N//2+1
print(ans)

Submission status: Accepted

Solution code:
N = input()

if int(N) % 2 == 1:
    print(int(N) // 2 + 1)
else:
    print(int(N) // 2)

Submission status: Accepted

Solution code:
N = int(input())

if N % 2 == 1:
    print(N//2+1)
else:
    print(N//2)

Submission status: Accepted

Solution code:
n=int(input())
print(int((n+1)/2))

Submission status: Accepted

Solution code:
N=int(input())
s=N//2
if N%2!=0:
  s+=1
print(s)

Submission status: Accepted

Solution code:
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Submission status: Accepted

Solution code:
n=int(input())
x=int((n+1)/2)
print(x)

Submission status: Accepted

Solution code:
n = int(input())
print((n + 1) // 2)

Submission status: Accepted

Solution code:
i = int(input())
print(-(-i//2))

Submission status: Accepted

Solution code:
import math
n = float(input())
print(math.ceil(n/2))

Submission status: Accepted

Solution code:
N = int(input())

answer = int(N / 2)
answer = answer + N % 2

print(answer)

Submission status: Accepted

Solution code:
N =int(input())

print(int((N+2-1)/2))

Submission status: Accepted

Solution code:
n = int(input())

if n % 2 != 0:
    print(n//2 + 1)
else:
    print(n//2)

Submission status: Accepted

Solution code:
N = int(input())

if N%2==0:
    print(N//2)
else:
    print((N+1)//2)

Submission status: Accepted

Solution code:
N = int(input())
if N % 2 == 1:
    N += 1
print(N // 2)

Submission status: Accepted

Solution code:
a=int(input())
if a%2==0:
    ans=a/2
else:
    ans=a//2+1
print(int(ans))

Submission status: Accepted

Solution code:
N = int(input())
print(int(N / 2 + 0.5))

Submission status: Accepted

Solution code:
N = int(input())
print(N//2 if N % 2 == 0 else N // 2 + 1)

Submission status: Accepted

Solution code:
n = int(input())
if n % 2 == 0:print(n//2)
else: print(n//2 + 1)

Submission status: Accepted

Solution code:
N = int(input())

print((N+2-1)//2)

Submission status: Accepted

Solution code:
import math


n = int(input())
print(math.ceil(n/2))

Submission status: Accepted

Solution code:
N=int(input())
print(int(N//2)+N%2)

Submission status: Accepted

Solution code:
N = int(input())
# X = list(map(int, input().split()))

if N%2 == 0:
  ans = N / 2
else:
  ans = N // 2 + 1
  

print(int(ans))

Submission status: Accepted

Solution code:
N = int(input())
if N%2==0:
  print(N//2)
else:
  print(N//2+1)

Submission status: Accepted

Solution code:
n = int(input())
#n,k = map(int,input().split())
#L= list(map(int, input().split()))
if n%2 == 0:
    print(n//2)
else:
    print(n//2+1)

Submission status: Accepted

Solution code:
N = int(input())

if N%2==0:
    print(N//2)
if N%2==1:
    print(N//2+1)

Submission status: Accepted

Solution code:
n = int(input())
if n % 2 == 0:
    ans = n // 2
else:
    ans= n//2+1

print(ans)

Submission status: Accepted

Solution code:
n = int(input())

import math
 
float_var = n/2
print(math.ceil(float_var))

Submission status: Accepted

Solution code:
N = int(input())
#A = list(map(int,input().split(' ')))

print((N+1)//2)

Submission status: Accepted

Solution code:
import numpy as np
N = int(input())
print(int(np.ceil(N / 2)))

Submission status: Accepted

Solution code:

n = int(input())
print((n+1)//2)

Submission status: Accepted

Solution code:
N = int(input())
if N%2 == 0:
    print(N//2)
else:
    print(N//2+1)

Submission status: Accepted

Solution code:
N = int(input())
print(N//2 if N % 2 == 0 else N // 2 + N % 2)

Submission status: Accepted

Solution code:
N=int(input())
print(int(N//2) if N%2==0 else int(N//2)+1)

Submission status: Accepted

Solution code:
def main():
    n=int(input())
    if n%2:
        print(n//2 + 1)
    else:
        print(n//2)

main()

Submission status: Accepted

Solution code:
N = int(input())
ans = (N+1) // 2
print(ans)

Submission status: Accepted

Solution code:

a = int(input())
print(a//2+(a%2!=0))

Submission status: Accepted

Solution code:
import sys

n = int(sys.stdin.readline().rstrip())

def main():
    return (n + 2 - 1) // 2

if __name__ == '__main__':
    ans = main()
    print(ans)

Submission status: Accepted

Solution code:
from math import ceil
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

def main():
    N = int(readline())

    print(ceil(N / 2))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
n = int(input())

print((n+1) // 2)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

def main():
    print((ii()+1)//2)


main()

Submission status: Accepted

Solution code:
N = int(input())

print(N//2 + 1) if N%2 == 1 else print(N//2)

Submission status: Accepted

Solution code:
n = int(input())
  
if n % 2 == 1:
  print(n//2+1)
  
else:
  print(n//2)

Submission status: Accepted

Solution code:
import math

n = int(input())
ans = math.ceil(n/2)
print(ans)

Submission status: Accepted

Solution code:
import math
def main():
    N = int(input())
    print(math.ceil(N/2))
    

main()

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    if n % 2 == 1:
        print(n // 2 + 1)
    else:
        print(n // 2)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    n = int(input())

    print(str(n//2 + n % 2))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
N = int(input())
print(N//2 + N%2)

Submission status: Accepted

Solution code:
import sys
import math
input = sys.stdin.readline

# int = int(input())
# s = input().split()
# i = list(map(int, input().split()))
# s = [input() for i in range(3)]

n = int(input())
print(math.ceil(n/2))

Submission status: Accepted

Solution code:
N = int(input())

q = N //2
r = N % 2
print(q + r)

Submission status: Accepted

Solution code:
usrInput = int(input())

if usrInput % 2 == 0:
    print(usrInput // 2)
else:
    print(usrInput // 2 + 1)

Submission status: Accepted

Solution code:
n=int(input())
if n%2==0:
  ans=n//2
else:
  ans=n//2+1
print(ans)

Submission status: Accepted

Solution code:
n=int(input())
ans=n//2
if n%2!=0:
    ans+=1
    
print(ans)

Submission status: Accepted

Solution code:
N = int(input())
print(-(-N//2))

Submission status: Accepted

Solution code:
n = int(input())
print(-(int(-n//2)))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
n = int(input())

if n % 2 == 0:
    print(n // 2)
else:
    print(n // 2 + 1)

Submission status: Accepted

Solution code:
#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math

import itertools

#import bisect

import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

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

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]



def main():
    n=int(input())
    if n%2==0:
        print(n//2)
    else:
        print(n//2+1)






if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# A
N = int(input())
if (N % 2 == 0):
    print(N//2)
else:
    print(N//2+1)

Submission status: Accepted

Solution code:
n = int(input())

if n % 2 == 0:
    print(int(n/2))
else:
    print(int(n/2) + 1)

Submission status: Accepted

Solution code:
num = int(input())

print(int(num/2) + num%2)

Submission status: Accepted

Solution code:
N = int(input())

print(N//2 if N % 2 == 0 else N//2+1)

Submission status: Accepted

Solution code:
N = int(input())

if(N%2==0):
  print(N//2)
else:
  print(N//2 + 1)

Submission status: Accepted

Solution code:
n=int(input())

print(int(((n+1)/2)))

Submission status: Accepted

Solution code:

#gcdは3.4.3だとfractionsにある
from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    n = ii()
    print(ceil(n/2))


main()

Submission status: Accepted

Solution code:
n = int(input())
print(n//2+(n%2))

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# coding: utf-8

def ri():
    return int(input())

def rl():
    return list(input().split())

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

def main():
    n = ri()
    print((n+1)//2)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# coding: utf-8


def solve(*args: str) -> str:
    n = int(args[0])
    return str(-(-n//2))


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

Submission status: Accepted

Solution code:
N = int(input())


syou = N//2
amari = N%2


print(syou+amari)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
import  math

def solve(N: int):
    print(math.ceil(N / 2))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())
if N%2 == 0:
  print(N//2)
else:
  print((N+1)//2)

Submission status: Accepted

Solution code:
def solve():
    N = int(input())
    if N % 2 == 0:
        print(N//2)
    else:
        print(N//2+1)
if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
n = int(input())
if(n%2 == 0):print(int(n/2))
else:print(int(n/2)+1)

Submission status: Accepted

Solution code:
n = int(input())
print(-(-n // 2))

Submission status: Accepted

Solution code:
n=int(input())
ans=n//2
if n%2==1:
    ans+=1
print(ans)

Submission status: Accepted

Solution code:
N = int(input())

q, r = divmod(N, 2)
if r == 0:
    print(q)
else:
    print(q + 1)

Submission status: Accepted

Solution code:
import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
from functools import lru_cache
INF = 1 << 60

#ここから書き始める
n = int(input())
if n % 2 == 0:
    print(n // 2)
else:
    print(n // 2 + 1)

Submission status: Accepted

Solution code:
n = int(input())

if n % 2 == 0:
  print(int(n//2))
else:
  print(int(n//2 + 1))

Submission status: Accepted

Solution code:
N = int(input())
if N % 2 ==0:
    print(N//2)
else:
    print(N//2 + 1)

Submission status: Accepted

Solution code:
N = int(input())
print(-(-N // 2))

Submission status: Accepted

Solution code:
N = int(input())


if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Submission status: Accepted

Solution code:
import sys
import math
sys.setrecursionlimit(int(1e6))

N = int(input())
ans = math.ceil(N / 2)

print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
import math
import itertools

def main():
    n = int(sys.stdin.readline().strip())
    print(int(math.ceil(n / 2)))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())
print(n//2 if n % 2 == 0 else n//2+1)

Submission status: Accepted

Solution code:
N=int(input())
print( (N+1)//2 )

Submission status: Accepted

Solution code:
print((int(input()) - 1) // 2 + 1)

Submission status: Accepted

Solution code:
a = int(input())


print(-(-a//2))

Submission status: Accepted

Solution code:
s=int(input())
if s%2==1:
  print(int(s//2)+1)
else:
  print(int(s//2))

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

N = I()

print(math.ceil(N / 2))

Submission status: Accepted

Solution code:
n=int(input())
d,m=divmod(n,2)
print(d+m)

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
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 LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	N = II()
	if(N%2!=0):
		print(N//2+1)
	else:
		print(N//2)

if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    N = INT()

    print(ceil(N/2))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

print(int((n+1)/2))

Submission status: Accepted

Solution code:
from math import ceil

n = int(input())
print(ceil(n/2))

Submission status: Accepted

Solution code:
def main():
	k = int(input())

	if k % 2 == 0:
		print(k//2)
	else:
		print(k//2 + 1)

if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
#A

n = int(input())

print((n+1) // 2)

Submission status: Accepted

Solution code:
import math
import sys
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N = I()
print(math.ceil(N/2))

Submission status: Accepted

Solution code:
n = int(input())

print(-(-n//2))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
#sys.setrecursionlimit(150000)


def solve(N: int):
    print(-(-N//2))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = int(input())

print(N // 2 if N % 2 == 0 else N // 2 + 1)

Submission status: Accepted

Solution code:

N=int(input())

print((N+1)//2)

Submission status: Accepted

Solution code:
N = int(input())
x, y = divmod(N, 2)
print(x + y)

Submission status: Accepted

Solution code:
N = int(input())
if N%2 ==0:
    print(N//2)
elif N%2 ==1:
    print(N//2+1)

Submission status: Accepted

Solution code:
n = int(input())
if n%2 == 1:
    print((n+1)//2)
else:
    print(n//2)

Submission status: Accepted

Solution code:
N = int(input())

a, b = divmod(N, 2)

print(a + b)

Submission status: Accepted

Solution code:
def read():
    N = int(input().strip())
    return N,

def solve(N):
    return N // 2 + N % 2

if __name__ == '__main__':
    inputs = read()
    print("{}".format(solve(*inputs)))

Submission status: Accepted

Solution code:
# list(map(int,input().split()))

n = int(input())

print((n+1)//2)

Submission status: Accepted

Solution code:
N = int(raw_input())

print (N+1)//2

Submission status: Accepted

Solution code:
print((int(input()) + 2 - 1) // 2)

Submission status: Accepted

Solution code:
#  --*-coding:utf-8-*--

N = int(input())
print((N+1)//2)

Submission status: Accepted

Solution code:
N = int(input())
answer = (N // 2) + (N % 2)
print(answer)

Submission status: Accepted

Solution code:
from math import *
N = int(input())

print(ceil(N/2))

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
N=int(input())

ans=-(-N//2)
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
if n % 2 == 1:
    print((n+1) // 2)
else:
    print(n//2)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
import math
N = int(input())

print(math.ceil(N / 2))

Submission status: Accepted

Solution code:
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial
from bisect import bisect_left # bisect_left(list, value)
#from fractions import gcd

sys.setrecursionlimit(10**7)
N = int(input())

if N%2==0:
    print(N//2)
else:
    print(N//2+1)

Submission status: Accepted

Solution code:
n=int(input())
print(n//2 + int((n%2)))

Submission status: Accepted

Solution code:
import math
n = int(input())
if n % 2 == 0:
  print(n//2)
else:
  print(n//2+1)

Submission status: Accepted

Solution code:
N= [int(i) for i in input().split()][0]
print((N+1)//2)

Submission status: Accepted

Solution code:
def main():
    n=int(input())
    print((n+1)//2)       

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    N = int(input())
    ans = -(-N//2)
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

N = int(input())
print((N + 1) // 2)

Submission status: Accepted

Solution code:
N = int(input())

ans = N // 2 + N % 2

print(ans)

Submission status: Accepted

Solution code:
N = int(input())
if N%2==0:
    N = N//2
else:
    N = N//2+1
print(N)

Submission status: Accepted

Solution code:
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    N = ir()
    print(N//2+N%2)
resolve()

Submission status: Accepted

Solution code:
n = int(input())
print((n + 2 - 1) // 2)

Submission status: Accepted

Solution code:
N = int(input())
ans = N//2
if N%2 == 1:
    ans += 1
print(ans)

Submission status: Accepted

Solution code:
n = int(input())

print(-(-n//2))

Submission status: Accepted

Solution code:
n = int(input())
if n % 2 == 1:
    print(n//2+1)
else:
    print(n//2)

Submission status: Accepted

Solution code:
N=int(input())
print(N//2+(N%2))

Submission status: Accepted

Solution code:
a = int(input())
print((a + 1) // 2)

Submission status: Accepted

Solution code:
n= int(input())

print((n+1)//2)

Submission status: Accepted

Solution code:
N = int(input())
if N % 2 == 1:
    print(N//2 + 1)
else:
    print(N//2)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
 
n = int(input())

if n%2 == 0:
    print(n//2)
else:
    print(n//2+1)

Submission status: Accepted

Solution code:
n=int(input())
#x,s = map(int,input().split())
#l = list(map(int,input().split()))
print(int(n/2) if n%2 == 0 else n//2 + 1)

Submission status: Accepted

Solution code:
n=int(input())

if n%2==0:
    print(n//2)
else:
    print(1+n//2)

Submission status: Accepted

Solution code:
n=int(input())
# n,m=map(int,input().split())
# a,b,c=map(int,input().split())
# s=input()
# s,t=map(str,input().split())
# A=list(map(int,input().split()))

if n%2==0:
  print(n//2)
else:
  print(n//2+1)

Submission status: Accepted

Solution code:
def main():
    n = int(input())
    print((n-1)//2+1)


main()

Submission status: Accepted

Solution code:
n = int(input())

if n % 2 == 0:
    print(n//2)
else:
    print((n//2) + 1)

Submission status: Accepted

Solution code:
def main():
    N = int(input())
    ans = N // 2 if N % 2 == 0 else (N // 2) + 1
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
n=int(input())
print(n//2 +int(n%2!=0))

Submission status: Accepted

Solution code:
N = int(input())
ans = N//2+N%2
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
ans = (n//2)
if n%2==0:
  print(ans)
else:
  print(ans+1)

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline

n = int(readline())

if n%2 == 0:
    print(n//2)
else:
    print(n//2+1)

Submission status: Accepted

Solution code:
# N = int(input())
# N = map(int,input().split())
# N = list(map(int,input().split()))

N = int(input())
print(((N-1)//2)+1)

Submission status: Accepted

Solution code:
a= int(input())

print((a + 1)//2)

Submission status: Accepted

Solution code:
import itertools
import sys
import math
import numpy as np
from collections import deque
from itertools import combinations
from functools import reduce
from functools import lru_cache
sys.setrecursionlimit(10**9)

def main():
    N = int(input())
    print(math.ceil(N/2))

if __name__ == "__main__":
  main()

Submission status: Accepted

Solution code:
n = int(input())

if n%2 == 1:
    print(n//2+1)
else:
    print(n//2)

Submission status: Accepted

Solution code:
n = int(input())
import math
ans = math.ceil(n / 2)
print(ans)

Submission status: Accepted

Solution code:
#A
#入力
N=int(input())
#処理
print((N+1)//2)

Submission status: Accepted

Solution code:
n = int(input())
ans = (n- 1) // 2 + 1
print(ans)

Submission status: Accepted

Solution code:
print (input()+1)/2

Submission status: Accepted

Solution code:
N = int(input())
if N % 2 == 1: print(N//2 + 1)
else: print(N//2)

Submission status: Accepted

Solution code:
N = int(input())

print((N-1)//2+1)

Submission status: Accepted

Solution code:
N = int(input())

ans = N // 2 + N%2

print(ans)

Submission status: Accepted

Solution code:
N=int(input())
print(int(N/2)+1 if N%2==1 else int(N/2))

Submission status: Accepted

Solution code:
n = int(input())
print((n-1) // 2 + 1)

Submission status: Accepted

Solution code:
#!python3

iim = lambda: map(int, input().rstrip().split())

def resolve():
    N = int(input())
    n = N // 2
    if N&1:
        n += 1
    print(n)

if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
N = int(input())
if N & 1:print(N//2 + 1)
else: print(N//2)

Submission status: Accepted

Solution code:
from math import ceil

n = int(input())
ans = ceil(n / 2)
print(int(ans))

Submission status: Accepted

Solution code:
N = int(input())

print((N + 1) // 2)

Submission status: Accepted

Solution code:
import collections
import math
N = int(input())
print(int(math.ceil(N/2)))

Submission status: Accepted

Solution code:
from math import ceil


def main():
    print(ceil(int(input()) / 2))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())
if n % 2 == 0:
    ans = n//2
else:
    ans = n//2 + 1
print(
    ans
)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

import sys
readline = sys.stdin.readline
read = sys.stdin.read

#n,*a = [int(i) for i in read().split()]
#a = [int(i) for i in readline().split()]
#n = int(input())


#n,*a = [int(i) for i in read().split()]

    
n = int(input())
    
print((n+1)//2)

Submission status: Accepted

Solution code:
n = int(input())
print(- (- n // 2))

Submission status: Accepted

Solution code:
N, = list(map(int, input().split()))

print((N + 1) // 2)

Submission status: Accepted

Solution code:
N=int(input())
print(int(N//2+(N%2==1)))

Submission status: Accepted

Solution code:
from math import ceil
N = int(input())
print(ceil(N / 2))

Submission status: Accepted

Solution code:
a=int(input())
if a%2==0:
    print(a//2)
else:
    print((a//2)+1)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 7)

N = int(input())

if N % 2 == 0:
    ans = N // 2
else:
    ans = (N + 1) // 2

print(ans)

Submission status: Accepted

Solution code:
import math

def main():
    n = int(input())
    print(int(math.ceil(n/2)))

    
main()

Submission status: Accepted

Solution code:
from sys import stdin
N = int(stdin.readline().rstrip())
print((N+1)//2)