TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
n,p=map(int,input().split())
print((p//2)+((p%2)+n)//2)

n,p=map(int,input().split())
print((p//2)+((p%2)+3*n)//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p=map(int,input().split())
print(int((a*3+2)/2))


a,p=map(int,input().split())
print(int((a*3+p)/2))


Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import math

a=input()
b=input()

bb=math.floor((a*3+b)/2)

print(bb)

import math
 
a,b=map(int,input().split()) 
bb=math.floor((a*3+b)/2)
 
print(bb)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,b = map(int,input().split())
print(((a/3)+b)//2)

a,b = map(int,input().split())
print(((a*3)+b)//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,P=map(int,input().split())
print((A*3+P)/2)

A,P=map(int,input().split())
print((A*3+P)//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
M=(P+3A)/2
M

A,P=(int(i) for i in input().split())
print((P+3*A)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int,input().split())

print(((a*3)+2) // 2)

a,p = map(int,input().split())

print(((a*3)+p) // 2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int, input().split())
p+=a*3
p/=2
print(p)


a,p = map(int, input().split())
p+=a*3
p/=2
print(int(p))


Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
n=int(input())
X=[]
for i in range(n):
    s,p=input().split()
    X.append((s,100-int(p),i+1))
X=sorted(X,key=lambda x:(x[0],x[1]))
for i in range(n):
    print(X[i][2])


a,p = map(int,input().split())
print((a*3+p)//2)


Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
a,p=map(int,input().split())

print((a*3+b)//2)

import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
a,p=map(int,input().split())

print((a*3)//2)

import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
a,b=map(int,input().split())

print((a*3+b)//2)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = input.split(" ")
print( (a*3+p)//2 )

a,p = map(int, input().split(" "))
print( (a*3+p)//2 )

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
print((3 * a + 2) // 2)

#!/usr/bin/env python3

import sys
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)

# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import product                # product(iter, repeat=n)
# from itertools import accumulate             # accumulate(iter[, f])
# from functools import reduce                 # reduce(f, iter[, init])
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from fractions import gcd                    # for Python3.4.3


def main():
    mod = 10000007                  # 10^9+7
    inf = float('inf')
    input = sys.stdin.readline      
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def ii():  return int(input())
    def mi():  return map(int, input().rstrip().split())
    def lmi(): return list(map(int, input().rstrip().split()))
    def li():  return list(input().rstrip())
    
    
    a, p = mi()
    print((p + a*3) // 2)

if __name__ == "__main__":
    main()

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import math
a,p=map(int,input().split())
f=a*3
print(math.floor(f/2))

import math
a,p=map(int,input().split())
f=a*3
print(math.floor((f+p)/2))

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = [int(_) for _ in input()]
print((a*3+p)//2)

a,p = [int(_) for _ in input()]
print((a*3+p)//2)

a,p = [int(_) for _ in input().split()]
print((a*3+p)//2)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
P, Q, R = map(int, input().split())
time = [P+Q, P+R, Q+R]
print(min(time))

A, P = map(int, input().split())
print(int((A*3 + P)/2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p=map(int,input().split())

print((a*3+p)/2)

a,p=map(int,input().split())

print((a*3+p)//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int,input().split())
print(3*a+p//2)

a,p = map(int,input().split())
print((3*a+p)//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
ans = (a * 3 + p) // 3
print(ans)

a, p = map(int, input().split())
ans = (a * 3 + p) // 2
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P =map(int,input().split())

print(int((A*3+p)/2))

A, P = map(int, input().split())

print((3*A+P)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A = input()
A =int(A)
P = input()
P =int(P)
X = (A * 3 + P) // 2 
print(X)

A = input()
A =int(A)
P = input()
P =int(P)

X = (A * 3 + P) // 2 
print(X)

A,P = map(int,input().split())

a=((P + A * 3) / 2)
print(round(a,0))

A = input()
A = int(A)
P = input()
P = int(P)

X = ( A * 3 + P ) // 2 
print ( X )

A =input()
A =int( A )
P =input()
P =int( P )

X = ( A * 3 + P ) // 2 
print( X )

A = input()
A =int(A)

P = input()
P =int(P)

X = (A * 3 + P) // 2 
print(X)

A = input()
A =int(A)
P = input()
P =int(P)

print ( (A * 3 + P) // 2 )

A = input()
A =int(A)

P = input()
P =int(P)

X = (A * 3 + P) // 2 
print(X)

A,P = map(int,input().split())
print((P + A * 3) // 2)


Verdicts: Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int,input().split()))
print((a*3+p)//2)

a,p = map(int,input().split())
print((a*3+p)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,P = map(int,input().split())
ans = (3*A+P)//3
print(int(ans))

A,P = map(int,input().split())
ans = (3*A+P)//2
print(int(ans))


Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, b = map(int, input().split())

print(int((a*3)/2))

a, b = map(int, input().split())

print(int((a*3+b)/2))

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import math

A, P =map(int,input().split())
print(A , P)

x = 3*A + P

print(math.floor(x/2))

import math

A, P =map(int,input().split())
#print(A , P)

x = 3*A + P

print(math.floor(x/2))

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P = map(int,input().split())
print(round((A*3 + P)/2, 0))

A, P = map(int,input().split())
answer = (A*3 + P)//2
print(answer)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p =map(int,input().split())
b = (3*a + P) // 2
print(b)

n,m = map(int,input().split())
s = []
k = []
p = []
for i in range(m):
    q = input().split()
    k.append(int(q[0]))
    q.remove(q[0])
    s.append(q)
    #print(q)
    for j in range(k[i]):
        s[i][j] = int(q[j])
        #print(s)
    
q = input().split()
for j in range(m):
        p.append(int(q[j]))
count = 0
for i in range(pow(2,n)):
    list = []
    for o in range(n):
        list.append(i%pow(2,o+1))
        i = i // pow(2,o+1)
    #print(list)
    for j in range(m):
        wa = 0
        for l in range(k[j] ):
            wa += list[s[j][l]-1]
        if wa == p[j]*2:
            count += 1

print(count)


a,p =map(int,input().split())
b = (3*a + p) // 2
print(b)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
n = int(input())
a=[]
for i in range(n):
  x,y = input().split()
  a.append([x,-int(y),i+1])
a.sort()
for i in range(n):
  print(a[i][2])



n = int(input())
a=[]
for i in range(n):
  x,y = input().split()
  a.append([x,-int(y),i+1])
a.sort()
for i in range(n):
  print(a[i][2])

A,N = map(int,input().split())
print((3*A+N)//2)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
print(int((a*3 + p)/2)

a, p = map(int, input().split())
print(int((a*3 + p)/2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import numpy as np

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

ks_list = []
for i in range(M):
    ks = list(map(int, input().split()))
    ks_list.append(ks)
    
p = list(map(int, input().split()))
ans = 0

for x in range(2 ** N + 1):
#     print("===========", x, ans)
    for m in range(M):
        c = 0
        for k in range(1, ks_list[m][0]+1):
            ks_mk = -ks_list[m][k]
            if int(format(x,'b').zfill(10)[ks_mk]) == 1:
                c += 1
#             print(ks_list, ks_list[m][k], ks_mk, format(x,'b').zfill(10), format(x,'b').zfill(10)[ks_mk])
#         print(c, p[m])
        if c % 2 != p[m]:
#             print("break")
            break
        if m == M-1:
            ans += 1
#     print(ans, ks_list, c, p)

print(ans)

a_, p_ = input().split()
a = int(a_)
p = int(p_)

print( ((a * 3) + p) // 2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
# -*- coding: utf-8 -*-

N = int(input().strip())

sp_list=[]
for i in range(N):
    s,p = input().rstrip().split()
    sp_list.append( [i+1,s,int(p)] )
#-----

sp_list.sort( key=lambda x:(x[1],-x[2]) )

for i,s,p in sp_list:
    print(i)


# -*- coding: utf-8 -*-

A,P = list(map(int, input().rstrip().split()))
print( (A*3 + P)//2 )

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, b = map(int, input())
print(int((a * 3 + b) / 2))

a, b = map(int, input().split())
print( int( (a * 3 + b) / 2) )


Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
[N,K]=list(map(int,input().split()))
V=list(map(int,input().split()))
have=[]
for n,k in enumerate(reversed(range(0,K+1))):
  tmp=[V[:ki]+V[-(k-ki):] for ki in range(k)
      ]+[V[:k],]
  tmp=[sorted(item) for item in tmp if sum(item)>0]
  #print(n,tmp)
  if n!=0:
    for num_remove in range(n):
      tmp2=[item[n:] for item in tmp 
            if all([g<0 for g in item[:n]])
           ]
      
      tmp.extend(tmp2)
      #print("tmp",tmp)
      #print("tmp2",tmp2)
      
  have.extend(tmp)
  #print(n,have[-1])

if have==[]:
  print(0)
else:
  print(max(list(map(sum,have))))


l = list(map(int,input().split()
            )
        )
print(int((3*l[0]+l[1])/2
         )
     )

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):

apple = A
part = P
all_part = A*3 + P

pie = all_part / 2

print(pie)

a, p = map(int, input().split())
print((a*3+p) // 2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
from operator import itemgetter

if __name__ == '__main__':
    n = int(input())
    input_list = [input() for i in range(n)]
    restaurant_list = []
    for index, _input in enumerate(input_list):
        _restaurant_data = {'id': index + 1, 'region': _input.split()[0], 'point': int(_input.split()[1])}
        restaurant_list.append(_restaurant_data)

    restaurant_list.sort(key=itemgetter('point'), reverse=True)
    restaurant_list.sort(key=itemgetter('region'))
    for restaurant in restaurant_list:
        print(restaurant['id'])


if __name__ == '__main__':
    _input = input().split()

    pie = int((int(_input[0]) * 3 + int(_input[1]))/2)
    print(pie)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,b = map(int,input().split())
if a >= 13:
    print(b)
elif a >= 6:
    print(b // 2)
else:
    print (0)

i = list(map(int,input().split()))
A=i[0]
P=i[1]
S=(A/3+P)//2
print(S)

i = list(map(int,input().split()))
A = i[0]
B = i[1]
C = B/2
if A>=13:
  print(B)
elif A<=5:
    print(0)
else:
    print(C)


i = list(map(int,input().split()))
A = i[0]
B = i[1]
if A>=13:
  print(B)
elif A>=6:
    print(B/2)
else:
    print(0)

i = list(map(int,input().split()))
A=i[0]
P=i[1]
S=(A/3+P)/2
print(S)

i = list(map(int,input().split()))
A = i[0]
B = i[1]
C = B/2
if A>=13:
  print(B)
elif A>=6 and A<=12:
    print(C)
else:
    print(0)

a,b = map(int,input().split())
if a>=13:
  print(b)
elif a>=6:
    print(b//2)
else:
    print(0)

a,b = map(int,input().split())
if a>=13:
  print(b)
elif a>=6:
    print(b/2)
else:
    print(0)

i = list(map(int,input().split()))
A=i[0]
P=i[1]
S=(A*3+P)//2
print(S)

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,b=map(int,input().split())
piece = a * 3 + b
pie = piece / 2
print(pie)

a,b=map(int,input().split())
applePie = ((a*3)+b)/2
print(applePie)

a,b=map(int,input().split())
piece = a * 3 + b
pie = piece / 2
print(int(pie))

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
p += a * 3
print(int(p/3))

a, p = map(int, input().split())
p += a * 3
print(int(p/2))

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,P = map(int,input())
print(int(((3*A)+P)//2))

A,P = map(int,input().split())
print(int(((3*A)+P)//2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P = [int(_) for _ in input().split()]
print((3 * A + P)//3)

A, P = [int(_) for _ in input().split()]
print((3 * A + P)//2)


Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
def main():
    A ,P = map(int,input().split())
    print((A*3+P)//2) 

def main():
    A ,P = map(int,input().split())
    print((A*3+P)//2) 

main()

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,P = map(int,input().split())
print((A*3+B)//2)



A,P = map(int,input().split())
print((A*3+P)//2)



Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
print((a*3 + p) / 2)


a, p = map(int, input().split())
print((a*3 + p) // 2)


Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
number = input().split(" ")
A = int(number[0])
P = int(number[1])
apple = (A * 3) + P
print(math.floor(apple / 2))

import math

number = input().split(" ")
A = int(number[0])
P = int(number[1])
apple = (A * 3) + P
print(math.floor(apple / 2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,P = map(int,input().split());print(A*3//2)

A,P = map(int,input().split());print((A*3+P)//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,b=map(input().split())
print((3*a+b)/2)

a,b=map(int,input().split())
c=(3*a+b)/2
import math
math.floor(c)

a,b=map(int,input().split())
print((3*a+b)/2)

a,b=map(int,input().split())
c=(3*a+b)/2
import math
print(math.floor(c))

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int, input().split())

b = a*3 + p

ans = int(b/2)

a,p = map(int, input().split())

b = a*3 + p

ans = int(b/2)
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,N = map(int,input().split())
A_N = A*3 + N

print(A_N/2)

A,N = map(int,input().split())
A_N = A*3 + N

print(A_N//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,b=input(),input()
aa=int(a)
bb=int(b)

c=int((3*aa+bb)/2)
print(c)

import math

a,b=map(int,input().split())
aa=int(a)
bb=int(b)

c=math.floor(int((3*aa+bb)/2))
print(c)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int,input().split())
print(3*a+p//2)

a,p = map(int,input().split())
print((3*a+p)//2)


Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

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


print((A//3)+N//2)




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


print(((A//3)+N)//2)




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


print((A*3+N)//2)




Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import math

a, p = map(int, input().sprit())

apple = 3 * a + p

ans = (math.floor(apple / 2))

print(ans)

import math

a, p = map(int, input().split())

apple = 3 * a + p

ans = (math.floor(apple / 2))

print(ans)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import math
a = input.slice("")[0]
p = input.slice("")[1]

print(math.floor((3a+p)/2))

import math

a,p = (int(i) for i in input().split(" "))

print(math.floor((3*a+p)/2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = (int(v) for f in input().split(' '))
print((a*3 + p)//2)

a, p = (int(v) for v in input().split(' '))
print((a*3 + p)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, B = map(int,input())
print((A*3+B)//2)

A, B = map(int,input().split())
print((A*3+B)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P = list(map(int, input()))
print((3 * A + P) // 2)

N = int(input())
lst = []
for i in range(N):
  s, p = input().split()
  lst.append([s, p, i])
  lst_2 = sorted(lst, key = lambda x : (x[0], -1 * int(x[1])))
  
for i in lst_2:
  print(i[2] + 1)

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


# S = [[1, 2], [2]]
# p = [0, 1]
S = [list(map(int,input().split()))[1:] for i in range(M)]
p = list(map(int, input().split()))

ans = 0

for i in range(1<<N): 
    count_2 = -1
    bit = list(str(bin(i))) # 0b0, 0b1, 0b10...
    fail = 0
    
    
    ketaume = (1<<N) // 2 + 2 - len(bit) 
    if ketaume > 0:
        for i in range(ketaume):
            bit.insert(2, "0")
    # print("search target={}".format(bit))
    for s in S: 
        count_2 += 1 
        count = 0
        for t in s: 
            # print("bit = {}".format(bit[-t]))
            if int(bit[-t]) == 1:
                count += 1 
                
        # print("{}-> number of switch is {}".format(s, count))
                
        
        # print("if mod is {}, OK".format(p[count_2]))
        # print("")
        if not count % 2 == p[count_2]:
            fail = 1 
            break
    if fail == 0:
        
        ans += 1
        
print(ans)

A, P = list(map(int, input().split()))
print((3 * A + P) // 2)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import sys

a, p = map(int, sys.stdin.readlines()[0].strip)
print((p + a * 3) // 2)

import sys

a, p = map(int, sys.stdin.readlines()[0].strip().split())
print((p + a * 3) // 2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a = []
n = int(input())
for i in range(n):
    key,value = input().split()
    a.append((key,value,int(i+1)))
a.sort(key=lambda x:(x[0],reverse = not x[1]))
for i in range(n):
    print(a[i][2])

a,p = map(int,input().split())
print((3*a+p)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
l=list(map(int,input().split()))
a=l[0]
p=l[1]
print((3a+p)//2)

l=list(map(int,input().split()))
a=l[0]
p=l[1]
print((3*a+p)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, b = [int(i) for input().split()]
c = (a * 3 + b) // 2
print(c)

a, b = [int(i) for input().split()]
c = (a * 3 + b) // 2
print(c)

a, b = [int(i) for i in input().split()]
c =(a * 3 + b) // 2
print(c)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

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

list_a = []
list_b = []
list_dist = []

for i in range(N):
  list_a.append(list(map(int, input().split())))

for j in range(Q):
  list_b.append(int(input()))

list_a.sort(key=lambda x:x[2])


for b in list_b:
  dist = 0
  time = b
  stop_flag = 0
  for a in list_a:
    time = time + a[2] - dist
    dist = a[2]
    if time > a[0]-0.5 and time < a[1]-0.5:
      stop_flag = 1
      break
  if stop_flag == 0:
    list_dist.append(-1)
  else:
    list_dist.append(dist)

for dist in list_dist:
  print(dist)

A, P = map(int, input().split())

P = A * 3 + P
print(int(P / 2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import math

a, p = map(int, input().split())
p = p + math.floor(a / 3)
print(math.floor(p / 2))

import math

a, p = map(int, input().split())
p = p + math.floor(a * 3)
print(math.floor(p / 2))

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int,input().split())

print(a*3//2)

a, p = map(int,input().split())

print((a*3+p)//2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
print(int(a * 3 + p / 2))

a, p = map(int, input().split())
print(int(a * 3 + p / 2))

a, p = map(int, input().split())
print(int((a * 3 + p) // 2))

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p=map(int,input().split())
print((a*3+p)/2)

a,p=map(int,input().split())
print(int((a*3+p)/2))

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,P=map(int,input().split())
print((3A+P)//2)


A,P=map(int,input().split())
print((3*A+P)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
OK = 0
NG = 10**10

mid = (OK+NG) // 2

s = 0
for i in range(mid):
    s += i

A, P = map(int, input().split())

print((A*3+P)//2)

A, P = map(int, input().split(" "))

print((A*3+P)//2)

Verdicts: Time Limit Exceeded

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p=map(int,input().split())
m=(3*A+P)//2
print(m)

a,p=map(int,input().split())
m=(3*a+p)//2
print(m)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):

def input2():
	return map(int,input().split())
  
a,p=input2()
ans=((A*3)+p)//2
print(ans)


def input2():
	return map(int,input().split())
  
a,p=input2()
ans=((a*3)+p)//2
print(ans)


Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
def ABC_128_A():
    A,P = map(int, input().split())
    print(int(A*3/2))


if __name__ == '__main__':

    ABC_128_A()

def ABC_128_A():
    A,P = map(int, input().split())
    print(int(A*3+P/2))


if __name__ == '__main__':

    ABC_128_A()

def ABC_128_A():
    A,P = map(int, input().split())
    print(int((A*3+P)/2))


if __name__ == '__main__':

    ABC_128_A()

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
x, y = map(int, input().split())
apple_piece_num = 3*x + y
valid_pie_num = apple_piece_num / 2
print(valid_pie_num)

x, y = map(int, input().split())
apple_piece_num = 3*x + y
valid_pie_num = apple_piece_num // 2
print(valid_pie_num)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P = map(int, input().split())

Ringonokakera = (P+(A*3))

print(Ringonokakera//3)


A, P = map(int, input().split())

Ringonokakera = (P+(A*3))

print(Ringonokakera//2)


Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A = int(input())
P = int(input())
K = 3 * A + P
print(K//2)

a,b=map(int,input().split())
print((a * 3 + b)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
n,k=map(int,input().split())
a=list(map(int,input().split()))
g=0
for i in range(0,min(n,k)):
    for j in range(0,min(k-i,n-i)):
        s=sorted(a[:i]+a[n-j:])
        p=sum(s)
        t=i+j
        c=0
        while len(s)>=c+1 and t+1<=k:
            if s[c]<0:
                p-=s[c]
                c+=1
                t+=1
            else:
                break
        g=max(g,p)
print(g)

a,p=map(int,input().split());print((3*a+p)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P = map(int, input().split())
print((A // 3 + P) // 2)

A, P = map(int, input().split())
print((A * 3 + P) // 2)

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p=int(input())
print((3*a+p)//2)

a,p=map(int,input().split())
print((3*a+p)//2)


Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int,input().split())
print((a*b+p)//2)

a,p = map(int,input().split())
print((a*3+p)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
import numpy as np

N = [int(i) for i in input().split()][0]

ls = []
for i in range(N):
  a,b = [i for i in input().split()]
  tmp = [str(a),int(b)]
  ls.append(tmp)

new_ls = sorted(ls, key=lambda x:x[1], reverse=True)
new_ls = sorted(new_ls, key=lambda x:x[0])

for next,l in enumerate(new_ls):
  for i,tmp in enumerate(ls):
    if l[0]==tmp[0] and l[1]==tmp[1]:
      print(i+1)
      continue

N = [int(i) for i in input().split()][0]

ls = []
for i in range(N):
  a,b = [i for i in input().split()]
  tmp = [str(a),int(b)]
  ls.append(tmp)

new_ls = sorted(ls, key=lambda x:x[1], reverse=True)
new_ls = sorted(new_ls, key=lambda x:x[0])

for next,l in enumerate(new_ls):
  for i,tmp in enumerate(ls):
    if l[0]==tmp[0] and l[1]==tmp[1]:
      print(i+1)
      continue

A,P = [int(i) for i in input().split()]

print((A*3+P)//2)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p=map(int,input().split(' '))
print(int((3*a+p)/2)

a,p=map(int,input().split(' '))
print(int((3*a+p)/2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
print(sum(3 * a + p)//2)


a, p = map(int, input().split())
total = 3 * a + p
print(total//2)


Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
def i():
	return int(input())
def i2():
	return map(int,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

n = i()
s = {}
for i in range(n):
	S,P = map(str,input().split())
	s[i+1] = [S, -int(P)]

note = sorted(s.items(), key=lambda x: (x[1][0],x[1][1])
print(note)

a,p = map(int,input().split())
print((3*a + p)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A,P=map(int,input().split())
B=(3A+P)//2
print(B)

A,P=map(int,input().split())
B=(3*A+P)//2
print(B)


Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
x = int(input())
y = int(input())
print(int((x*3+y)/2))

x, y = [int(i) for i in input().split()]
print(int((x*3+y)/2))


Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P = map(int,input().split())
import math

print(math.floor((3A+P)/2))

A, P = map(int,input().split())
import math

print(math.floor((3*A+P)/2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,p = map(int,input().split())
z = a*3+p
if z % 2 == 0:
  print(z/2)
else:
  print((z-1)/2)


a,p = map(int,input().split())
z = a*3+p
if z % 2 = 0:
  print(z/2)
else:
  print((z-1)/2)

a,p = map(int,input().split())
z = a*3+p
if z % 2 = 0:
  print(int(z/2))
else:
  print(int((z-1)/2))


a,p = map(int,input().split())
z = a*3+p
if z % 2 == 0:
  print(int(z/2))
else:
  print(int((z-1)/2))



Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
#coding:utf-8
d=[int(i) for i in input().split()]
print(int(answer=(d[0]*3+d[1])/2))


#coding:utf-8
d=[int(i) for i in input().split()]
print(int((d[0]*3+d[1])/2))

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
A, P = map(int,input().split())
print((3A+P)//2)

A, P = map(int,input().split())
print((3*A+P)//2)

Verdicts: Runtime Error

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a, p = map(int, input().split())
print(int((3*a)/2))

a, p = map(int, input().split())
b = a * 3 + p
print(int(b/2))

Verdicts: Wrong Answer

Accepted
Problem: We have A apples and P pieces of apple.  We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.  Find the maximum number of apple pies we can make with what we have now.

Submission attempts (in order):
a,b = map(int, input().split())

sum = a*3 + b

p = sum/2

print(p)

a,b = map(int, input().split())

sum = a*3 + b

p = sum/2

print(p)

import math

a,b = map(int, input().split())
 
sum = a*3 + b
p = sum/2
print(math.floor(p))


Verdicts: Wrong Answer

Wrong Answer

Accepted