TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: 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?

Submission attempts (in order):
N=input()
if N%2==0:
  print("N/2")
else:
  print("N/2+1")

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

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

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
print(int((int(input()+1))/2))

import itertools as it
dic={}
bing=[[1 for i in range(3)] for j in range(3)]
for i in range(3):
    f=list(map(int,input().split()))
    for each in f:
        dic.update({each:(i,f.index(each))})
n=int(input())
for i in range(n):
    m=int(input())
    if m in dic.keys():
      place=dic[m]
      bing[place[0]][place[1]]=0
flag=False
code="000102101112202122"
code=code+code[::-1]
code=code+"001122021120"

for i in range(8):
    code_sep=code[6*i:6*i+6]
    p=0
    for j in range(3):
        cords=code_sep[2*j:2*j+2]
        p+=bing[int(cords[0])][int(cords[1])]
    if p==0:
        flag=True
        break
    
print("yes")if flag else print("No")

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
print(N//2)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
print(int(round(int(input())/2,0)))


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


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import sys
import numpy as np

# input = sys.stdin.readline

n = int(input())

print(round(n))

import sys
import numpy as np

# input = sys.stdin.readline

n = int(input())

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
print(round(N / 2))

N , R = tuple(list(map(int, input().split(' '))))
if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))


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

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n=int(input())
if n%2==1:
  print(n/2+1)
else:
  print(n/2)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
if N%2 == 0:
    print(N/2)
else:
    print(N/2+1)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = input()

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

mod = N % 2
if mod == 0:
    x = N // 2
else:
    x = N // 2 + 1

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

N = input()
N = int(N)

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
a = n // 2
print(a)

n = int(input())
a = n//2 + n%2
print(a)

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
if n%2==0:
    ans=n/2
else:
    ans=n//2+1
print(ans)

#A
n=int(input())

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())

print(n + 1 // 2)

n = int(input())

print((n + 1) // 2)

Verdicts: Wrong Answer

Accepted
Problem: 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?

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
def solve(lines):
    N = int(lines.pop(0))
    print(math.ceil(N/2))
solve(lines)

lines = [x.strip() for x in sys.stdin.readlines()]
def solve(lines):
    N = int(lines.pop(0))
    print(math.ceil(N/2))
solve(lines)

import sys,math
N = int(input())
print(math.ceil(N/2))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())

print(n % 2)


n = int(input())
answer = n//2
answer += n % 2
print(answer)


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
ans = 0
if n % 2 == 0:
  ans = n / 2
else:
  ans = n / 2 + 1
print(ans)

def main():
  a = []
  ans = "No"
  hit_examples = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]]
  for i in range(3):
    a.extend(list(map(int, input().split())))
  n = int(input())
  b = []
  for i in range(n):
    b.append(int(input()))
  for b_value in b:
    for i in range(len(a)):
      if b_value == a[i]:
        a[i] = -1

  for hit_example in hit_examples:
    cnt = 0
    for i in range(len(a)):
      if a[i] == -1 and i in hit_example:
        cnt += 1
      if cnt == 3:
        ans = "Yes"
        print(ans)
        return
  print(ans)

if __name__ == '__main__':
  main()

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

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
A = []
for _ in range(3):
    A += list(map(int, input().split()))
N = int(input())
B = [int(input()) for i in range(N)]

for i in range(0,N):
    for j in range(9):
        if B[i] ==  A[j]:
            A[j] = 0

if A[0]==A[1]==A[2]==0 or A[3]==A[4]==A[5]==0 or A[6]==A[7]==A[8]==0 or A[0]==A[3]==A[6]==0 or A[1]==A[4]==A[7]==0 or A[2]==A[5]==A[8]==0 or  A[0]==A[4]==A[8]==0 or A[2]==A[4]==A[6]==0 :
    print('Yes')
else:
    print('No')

import math
N = int(input())
print(math.ceil(N/2))

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N=11
k=N%2
if k==0:
    print(N/2)
else:
    print(N/2+0.5)

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

N=10
k=N%2
if k==0:
    print(round(N/2.0))
else:
    print(round(N/2+1/2.0))

n=input()
N=float(n)
k=N%2
if k==0:
    print(round(N/2.0))
else:
    print(round(N/2+1/2.0))

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
print(n // 2 + 2 % 2)

n = int(input())
a = n //2 
b = n % 2
print(a + b)

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
a = int(input())

if a % 2 == 0:
  num = a / 2
else:
  num = (a + 1) / 2

print(num)

a = int(input())

num = - (-a//2)

print(num)

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
int ans = (n + 1) // 2;
print(ans)
  

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n=int(input())
if n%2 == 0:
  print(n/2)
else:
  print(int(n/2))

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


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
A=list(map(int,input().split()))
B=list(map(int,input().split()))
C=list(map(int,input().split()))
x=[[0 for i in range(3)] for j in range(3)]
N=int(input())
if N>=3:
  for i in range(N):
    b=int(input())
    for j in range(3):
      if A[j]==b:
        x[0][j]=1
      elif B[j]==b:
        x[1][j]=1
      elif C[j]==b:
        x[2][j]=1
  flag=0
  if x[0][0]==1:
    if x[0][1]==1 and x[0][2]==1:
      flag=1
    elif x[1][0]==1 and x[2][0]==1:
      flag=1
    elif x[1][1]==1 and x[2][2]==1:
      flag=1
  if x[1][1]==1:
    if x[0][1]==1 and x[2][1]==1:
      flag=1
    elif x[1][0]==1 and x[2][0]==1:
      flag=1
    elif x[0][2]==1 and x[2][0]==1:
      flag=1
  if x[2][2]==1:
    if x[2][0]==1 and x[2][1]==1:
      flag=1
    elif x[0][2]==1 and x[1][2]==1:
      flag=1
  if flag==1:
    print("Yes")
  else:
    print("No")
  #print(x)
else:
  print("No")

N=int(input())

print(N//2+N%2)

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())

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

N = int(input())

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
A = [list(map(int, input().split())) for _ in range(3)]
N = int(input())
B = [int(input()) for _ in range(N)]

l = [[(a_i in B) for a_i in a] for a in A]

# print(l)

flag = 0
for y in range(3):
    flag |= all(l[y])

for x in range(3):
    flag |= all([l[x][y] for y in range(3)])

flag |= all([l[y][x] for x, y in [(0, 0), (1, 1), (2, 2)]])

flag |= all([l[y][x] for x, y in [(0, 2), (1, 1), (2, 0)]])

print("Yes" if flag else "No")

N = int(input())

print(-(-N//2))

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
A=[list(map(int,input().split())) for i in range(3)]
n=int(input())
for i in range(n):
    b=int(input())
    for Row in range(3):
        for Col in range(3):
            if b==A[Row][Col]:
                A[Row][Col]=0  

print(A)

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N, M = map(int, readline().split())
if M == 0:
    print([0, 10, 100][N - 1])
    exit()
m = map(int, read().split())
S, C = zip(*zip(m, m))

def test(n):
    st = str(n)
    if len(st) != N:
        return False
    for i, c in zip(S, C):
        i -= 1
        if st[i] != str(c):
            return False
    return True

def main():
    for n in range(1000):
        if test(n):
            return n
    return -1

print(main())


n = int(input())

p = n % 2 + n // 2

print(p)

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n, m = map(int, input().split())
lst = [[] for _ in range(n)]
for _ in range(m):
    s, c = map(int, input().split())
    nums = append([s-1,c])

print(nums)

n = int(input())

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())

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



n = int(input())

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


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n, m = map(int, input().split())

a = [input().split() for i in range(m)]

s = []
c = []

for i in range(m):
    s.append(a[i][0])
    c.append(a[i][1])

S = [int(i) for i in s]
C = [int(i) for i in c]

x = 0
z = 0

for i in range(m):
    x += C[i] * (10 ** (n-S[i]))
    for k in range(m):
        if n >= 2 and S[i] == 1 and C[i] == 0:
            z += 1
            break
        if S[i] == S[k] and C[i] != C[k]:
            z += 1
            break
        if S[i] == S[k] and C[i] == C[k] and i > k:
            x -= C[i] * (10 ** (n-S[i]))
            break

if z == 0:
    if '1' in S or m == 0:
        print(x)
    else:
        print(x+10**(n-1))

else:
    print('-1')

n = int(input())

print((n + 1) // 2)


Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n =int(input())
if n%2=0:
  answer = n//2
  print(answer)
else:
  answer = n//2+1
  print(answer)


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


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

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


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
import sys
N, M = map(int, input().split())


SClis = [] 
for _ in range(M):
    a, b = map(int, input().split())
    SClis.append([a,b])

ans = [-1]*N

for i in range(M):
    singlelis = SClis[i]
    S =  (singlelis[0] - 1)
    C =  (singlelis[1])
    
    if ans[S] != -1 and ans[S] != C:
        print(-1)
        sys.exit()
    else:
        ans[S] = C


    
if N == 1:
    if ans[0] == -1:
        ans[0] = 0
        print(''.join(map(str, ans)))
        sys.exit()

if N != 1:
    if ans[0] == 0:
        print(-1)
        sys.exit()
    
    if ans[0] == -1:
        ans[0] = 1
    
    for i in range(1,N):
        if ans[i] == -1:
            ans[i] = 0

print(''.join(map(str, ans)))


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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
import math
print(math.ceil(int(input())))

import math
print(math.ceil(int(input()) / 2))


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
if N % 2 == 0:
  print(N/2)
else:
  print(N/2+1)

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


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


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
A=[list(map(int,input().strip().split())) for n in range(3)]
A_input=[]
for n in range(3):
    for m in range(3):
        A_input.append(A[n][m])
N=int(input())
b=[int(input()) for n in range(N)]

def bingo_judge(A_input,b):
    bingo=0
    judge_list=[0,0,0,0,0,0,0,0,0]
    for number in b:
        for i in range(9):
            if number==A_input[i]:
                judge_list[i]=1
            else:
                pass
    #horizonal
    for i in range(3):
        if judge_list[3*i]*judge_list[3*i+1]*judge_list[3*i+2]==1:
            bingo=1
        else:
            pass
    #vertical
    for i in range(3):
        if judge_list[i]*judge_list[i+3]*judge_list[i+6]==1:
            bingo=1
        else:
            pass
    #diagonal
    if judge_list[0]*judge_list[4]*judge_list[8]==1:
        bingo=1
    if judge_list[2]*judge_list[4]*judge_list[6]==1:
        bingo=1
    
    
    # print(*judge_disp,sep="\n")
    
    return bingo

def main():
    ans=bingo_judge(A_input,b)
    if ans==1:
        print("yes")
    elif ans==0:
        print("No")
main()

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
print(int(input())//2)

from math import ceil
n=int(input())
print(ceil(n/2))

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = input()

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

N = int(input())

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


Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
num = int(input())
print(num/2 + num%2)

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

num = int(input())
a = num/2 + num % 2
print(a)

num = int(input())
a = num//2 + num % 2
print(a)

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
print((n+1)//n)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
num = N/2
nume = N/4
if N%2==0:
    print(num)
else:
    print(nume)



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



Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import math
n = int(input())
print(math.ceil(n))

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import sys
sys.setrecursionlimit(1000000)
n,m,k=map(int,input().split())
class UnionFind(object):
    def __init__(self, N):
        self.parent = [i for i in range(N)]
        self.size = [1 for i in range(N)]
 
    def merge(self, a, b):
        if self.issame(a,b):
            return
        pa = self.root(a)
        pb = self.root(b)
        self.parent[pa] = pb
        self.size[pb] += self.size[pa]
    
    def root(self, x):
        p = self.parent[x]
        if p == x:
            return x
        else:
            r = self.root(p)
            self.parent[x] = r
            return r
    def issame(self, x, y):
        return self.root(x) == self.root(y)
    def getsize(self, x):
        return self.size[self.root(x)]
uf=UnionFind(n)
ans=[0]*n
for i in range(m):
    a,b=map(int,input().split())
    uf.merge(a-1,b-1)
    ans[a-1]-=1;ans[b-1]-=1
for i in range(k):
    c,d=map(int,input().split())
    if uf.issame(c-1,d-1):
        ans[c-1]-=1;ans[d-1]-=1
for i in range(n):
    ans[i]=uf.getsize(i)+ans[i]-1
print(*ans)


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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
from math import ceil
n = int(input())
print(round(n/2))

from math import ceil
n = int(input())
print(ceil(n/2))

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
print(N/2 if N%2==0 else (N+1)/2)


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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
a = input()
b = 0
while a >= 0:
	a -= 2
    b += 1
    if a == 1:
      break
else:
	print(b)
print(b + 1)


a = int(input())
b = 0
while a > 0:
  a -= 2
  b += 1
  if a == 1:
    print(b + 1)
    break
else:
  print(b)

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())

print(round(N / 2))

import math

N = int(input())

print(math.ceil(N / 2))

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
page = input()
if page%2 = 0 :
  print(page/2)
elif page%2 = 1 :
  print(page/2 + 1)

page = int(input())

if page%2 == 0 :
  print(int(page/2))
elif page%2 == 1 :
  print(page//2 + 1)

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
a=int(input())
b=a//2
if b==1:
  b=b+1
print(b)

a=int(input())
b=a//2
if a%2==1:
  b=b+1
print(b)

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
print(N // 2)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import sys
import os
import math
import string
import collections

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: x * y / math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def f(N):
    return sum(map(int, str(N)))


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N, M = il()
    SC = [il() for _ in range(M)]
    ret = [0] * N
    for s, c in SC:
        if ret[s - 1] == 0 or ret[s - 1] == c:
            ret[s - 1] = c
        else:
            print(-1)
            exit()
    else:
        q = ''.join(map(str, ret))
        print(q if q[0] != str(0) and len(q) == N else -1)


if __name__ == '__main__':
    main()


import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

        a = int(sys.stdin.readline().strip())
        n, mod = divmod(a, 2)
    print(n if mod == 0 else n + 1)


if __name__ == '__main__':
    main()


import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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

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


if __name__ == '__main__':
    main()


import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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

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


if __name__ == '__main__':
    main()


import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

        a = int(sys.stdin.readline().rstrip())
        n, mod = divmod(a, 2)
    print(n if mod == 0 else n + 1)


if __name__ == '__main__':
    main()


a = input()
n, mod = divmod(a, 2)
print(n if mod == 0 else n + 1)

import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A = int(sys.stdin.buffer.readline().rstrip())
    print(A//2 if A%2 == 0 else A//2 + 1)


if __name__ == '__main__':
    main()


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n=int(input())
if n%2==0:
  ans=n/2
else:
  ans=(n+1)/2

print(ans)

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

print(int(ans))


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
if N%2 == 0:
  print(N/2)
else:
  print((N+1)/2)

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


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N, M = map(int, input().split())

num = [0] * N

P = [list(map(int,input().split())) for i in range(M)]

for i in range(M + 1):
    if i == M:
        if N == 1:
            print("".join([str(n) for n in num]))
            break
        elif num[0] == 0:
            num[0] = 1
            print("".join([str(n) for n in num]))
            break
        else:
            print("".join([str(n) for n in num]))
            break
    elif P[i][0] == 1 and P[i][1] == 0:
        if N == 1:
            continue
        else:
            print(-1)
            break
    elif num[P[i][0] - 1] == 0 or num[P[i][0] - 1] == P[i][1]:
        num[P[i][0] - 1] = P[i][1]
    else:
        print(-1)
        break



import math

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


Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N, M = map(int, input().split())
sc = [tuple(map(int, input().split())) for _ in range(M)]

matches = []
for i in range(0, 1000):
    if len(str(i)) == N:
        temp = True
        for s, c in sc:
            if str(i)[s - 1] != str(c):
                temp = False
        if temp: matches.append(i)
print(-1) if len(matches) == 0 else print(min(matches))

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
x = input()
page = int(x) / 2
print(page)

import math
x = input()
page = (int(x)+1) // 2
print(page)


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N=input()
1<=N<=100
ans=(N+1)//2
print(ans)


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

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


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n, m = map(int, input().split())
num_list = ['X'] * n

def ans():
    if n == 1 and m == 0:
        return 0
    for i in range(m):
        set = list(map(str, input().split()))
        if set[0] == '1' and set[1] == '0' and n != 1:
            return -1
        else:
            if num_list[int(set[0]) - 1] == 'X':
                num_list[int(set[0]) - 1] = set[1]
            elif num_list[int(set[0]) - 1] == set[1]:
                continue
            else:
                return -1

    for i in range(n):
        if num_list[i] == 'X':
            num_list[i] = '1' if i == 0 else '0'

    return ''.join(num_list)

print(ans())


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


Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
print(N/2+1)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import math
N = int(input())
print(math.ceil(N//2))

import math
N = int(input())
print(math.ceil(N/2))

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
N=N/2
print(round(N))

import math
N = int(input())
N=N/2
print(math.ceil(N))

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
print((n+1)/2)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

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

n = input()

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


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

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
num=int(input())
if num%2==0:
  print(num/2)
else:
  print((num+1)/2)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
x = int(input()) 
print(x / 2 + 1 if x % 2 != 0 else x / 2)

x = int(input()) 
print(int(x/2)+ 1 if x % 2 != 0 else int(x/2))

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import sys
input = sys.stdin.readline

N = int(input())

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

import sys
input = sys.stdin.readline

N = int(input())

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())

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


n = int(input())

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


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
print(int(n/2))


from math import ceil
n = int(input())
print(ceil(n/2))


Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
#!/usr/bin/env python3
def func(a, i):
    return {a[0]:i, a[1]:i+1, a[2]:i+2}
A = {}
for i in range(3):
    A.update(func(input().split(), 3*i))
N = int(input())
b = [A.get(input(), -1) for _ in range(N)]
bingo = [[0, 1, 2], [3, 4, 5], [6, 7, 8],
         [0, 3, 6], [1, 4, 7], [2, 5, 8],
         [0, 4, 8], [2, 4, 6]]
for i in bingo:
    if set(i) <= set(b):
        print("Yes")
        break
else:
    print("No")

#!/usr/bin/env python3
N = int(input())
print((N + 1) // 2)

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
print(round(N/2+N%2))

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
if(n%2 ==0):
  print(n/2)
else:
  print((n/2)+1)

import math
N = int(input())
if( N%2 == 0 ):
  print(int(N/2))
else:
  print(math.ceil((N/2)))

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N, M = map(int, input().split())

S, C = [], []
for i in range(M):
  s, c = map(int, input().split())
  S += [s-1]
  C += [str(c)]
  
if N == 1:
  for i in range(10):
    flag = 1
  for m in range(M):
      if i_str[S[m]] != C[m]:
        flag = 0
        break
    if flag:
      print(i)
      break
  else:
    print(-1) 
else:
  for i in range(10**(N-1), 10**N):
    flag = 1
    i_str = str(i)
    for m in range(M):
      if i_str[S[m]] != C[m]:
        flag = 0
        break
    if flag:
      print(i)
      break
  else:
    print(-1)

N, M = map(int, input().split())

S, C = [], []
for i in range(M):
  s, c = map(int, input().split())
  S += [s-1]
  C += [str(c)]
  
for i in range(10**(N-1), 10**N):
  flag = 1
  i_str = str(i)
  for m in range(M):
    if i_str[S[m]] != C[m]:
      flag = 0
      break
  if flag:
    print(i)
    break
else:
  print(-1)

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N=int(input())

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

N=int(input())

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N = input()

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

return(ans)

# -*- coding: utf-8 -*-
"""
Created on Tue Mar  3 19:08:31 2020

@author: Kanaru Sato
"""

N = int(input())

ans = N//2 + N%2

print(ans)

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
s=int(input())
print(s/2)





import math
s = int(input())
print(math.ceil(s/2))

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import numpy as np

N = input()

num_paper = N / 2
if (N % 2) > 0:
  num_paper += 1
else:
  pass

print(num_paper)

N = input()
N = int(N)
num_paper = N / 2
if (N % 2) > 0:
  num_paper += 1
else:
  pass

print(num_paper)


import numpy as np

N = input()

num_paper = int(N) / 2
if (N % 2) > 0:
  num_paper += 1
else:
  pass

print(num_paper)


N = input()
N = int(N)
num_paper = int(N / 2)
if (N % 2) > 0:
  num_paper += 1
else:
  pass

print(num_paper)


Verdicts: Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
a = input()
if 'A' in a and 'B' in a:
    print("Yes")
else:
    print("No")

N = int(input())

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
N, M, K = map(int, input().split())
friend = [[] for _ in range(N+1)]
block = [[] for _ in range(N+1)]

for i in range(M):
  A,B = map(int, input().split())
  friend[A].append(B)
  friend[B].append(A)

for i in range(K):
  C,D = map(int, input().split())
  block[C].append(D)
  block[D].append(C)
#print(friend)
#print(block)


grouping = [False]*(N+1)
#print(grouping)
grouping[0] = True
group = [0]*(N+1)
g_num = 0
g_cnt = []
for i in range(1,N+1):
  cnt = 0
  if grouping[i] == True:
    continue 
  group[i] = g_num
  grouping[i] = True
  
  #q.put(i)
  stack = [i]
  #while not q.empty():
  while len(stack)>0:
    #print('v:',visited)
    
    p = stack.pop()
    for f in friend[p]:
      #print(p,f)
      if grouping[f]==False:
        #q.put(f)
        stack.append(f)
        group[f]=g_num
        grouping[f] =True
        cnt += 1
  g_num += 1
  g_cnt.append(cnt)
  #print('g:',grouping)
ans = []
for i in range(1,N+1):
  c = g_cnt[group[i]]-len(friend[i])
  for b in block[i]:
    if group[b]==group[i]:
      c -= 1
  ans.append(c)
print(*ans)

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N = int(input())
if N%2==0:
    print(N/2)
else:
    print(N/2 + 1)

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
import sys
sys.setrecursionlimit(5000)

N,M,K = list(map(int,input().split(' ')))

friend_list = [0]*(N+1)
bad_list = [0]*(N+1)
group = {}

parent = [i for i in range(N+1)]

def union(x,y):
    x = find(x)
    y = find(y)
    parent[x] = y

def find(x):
    if parent[x] == x:
        return x
    else:
        parent[x]= find(parent[x])
        return parent[x]



for i in range(M):
    A,B = list(map(int,input().split(' ')))
    friend_list[A]+=1
    friend_list[B]+=1
    
    union(A,B)

for i in range(1,N+1):
    oya = find(i)
    parent[i] = oya
    #print(oya)
    if oya in group:
        group[oya] = group[oya]+1
    else:
        group[oya]=1

for i in range(K):
    A,B = list(map(int,input().split(' ')))
    if find(A)==find(B):
        bad_list[A]+=1
        bad_list[B]+=1
    
    



#print(parent)
#print('parent')

#print('friend')
#print(friend_list)
#print('bad')
#print(bad_list) 
#print(group)

kouho = [0]*N

for i in range(1,N+1):
    oya = find(i)
    abc = group[oya]-friend_list[i]-bad_list[i]-1
    kouho[i-1] = abc

for k in kouho:
    print(k,end=" ")
print()

#print(parent)

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

print((N+1)//2)

Verdicts: Runtime Error

Accepted
Problem: 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?

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
#!/usr/bin/env python3
from itertools import product, permutations, combinations
from bisect import bisect_right,bisect_left
INF = float('inf')

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

#!/usr/bin/env python3
from itertools import product, permutations, combinations
from bisect import bisect_right,bisect_left
INF = float('inf')

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
N,M=map(int,input().split())
b=[list(map(int,input().split())) for i in range(M)]
lists=[0,0,0]
import sys
for i1 in range(0,M):
  for i2 in range(i1,M):
    if b[i1][0]==b[i2][0] and b[i1][1]!=b[i2][1]:
      print (-1)
      sys.exit()
    else:
      lists[b[i1][0]-1]=b[i1][1]
for i3 in range(M):
  if b[i3][0]==4-N and b[i3][1]==0:
    print (-1)
    sys.exit()
s=0
for i in range(3):
  s=s+lists[i]*10**(2-i)
if s>=10**N:
  print (-1)
elif s<10**(N-1):
  s=s+10**(N-1)
  print (s)
else:
  print (s)

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

Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
n = int(input())
if(n % 2 == 0 ):
  a = n / 2
else:
  a = n / 2 + 1
print(a)

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



Verdicts: Wrong Answer

Accepted
Problem: 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?

Submission attempts (in order):
if int(input()) % 2 == 0:
    print(int(input()) // 2)
else:
    print(int(input()) // 2 + 1)


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


Verdicts: Runtime Error

Accepted
Problem: 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?

Submission attempts (in order):
import math

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

import math

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

Verdicts: Wrong Answer

Accepted