Problem:


Score : 100 points

Problem Statement

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.

Constraints

All values in input are integers.

0 \leq A, P \leq 100

Input

Input is given from Standard Input in the following format:

A P

Output

Print the maximum number of apple pies we can make with what we have.

Sample Input 1

1 3

Sample Output 1

3

We can first make one apple pie by simmering two of the three pieces of apple. Then, we can make two more by simmering the remaining piece and three more pieces obtained by cutting the whole apple.

Sample Input 2

0 1

Sample Output 2

0

We cannot make an apple pie in this case, unfortunately.

Sample Input 3

32 21

Sample Output 3

58



Sample input:
1 3


Sample output:
3

Submission status: Accepted

Solution code:
A, P = map(int,input().split())

ringo = A*3 + P
ringo = ringo // 2
print("{:.0f}".format(ringo))

Submission status: Accepted

Solution code:
data = input().split(" ")
apple = int(data[0])
piece=int(data[1])
piece+=apple*3;
print(int(piece/2))

Submission status: Accepted

Solution code:
a, p = map(int, input().split())

def pie(a, p):
    piece = p + a * 3
    pies = piece // 2
    print(pies)

pie(a, p)

Submission status: Accepted

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

# In[7]:


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


# In[8]:


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


# In[ ]:

Submission status: Accepted

Solution code:
a,b = map(int, input().split())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
import math
a,p=map(int,input().split(" "))
print(math.floor((a*3+p)/2))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,P=input().split()
P1 = int(A)*3
ans = (P1+int(P))//2
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

A, P = input().split()

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
from collections import Counter

def main():
    A, P = LI()
    X = P + A * 3
    ans = X // 2
    return ans

print(main())

Submission status: Accepted

Solution code:
import math
A, P = map(int, input().split())
answer = int(math.floor((A * 3 + P) / 2))
print(answer)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

inputs =  list(map(int, sys.stdin.readline().split()))

sum_break_apple = inputs[0]*3 + inputs[1]

print(int(sum_break_apple/2))

Submission status: Accepted

Solution code:
###############################################################################

from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict
import math


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    ret = math.factorial(x)
    ret = ret // (math.factorial(x - y) * math.factorial(y))

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance


class UnionFind:

    def __init__(self, n):
        self.parent = [i for i in range(n)]

    def root(self, i):
        if self.parent[i] == i:
            return i
        self.parent[i] = self.root(self.parent[i])
        return self.parent[i]

    def unite(self, i, j):
        rooti = self.root(i)
        rootj = self.root(j)
        if rooti == rootj:
            return
        if rooti < rootj:
            self.parent[rootj] = rooti
        else:
            self.parent[rooti] = rootj

    def same(self, i, j):
        return self.root(i) == self.root(j)


###############################################################################


def main():
    a, p = intin()

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a, p = map(int, input().split())
ans = int((a * 3 + p) / 2)
print(ans)

Submission status: Accepted

Solution code:
input_data = [int(x) for x in input().split()]
A = input_data[0]
P = input_data[1]


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

Submission status: Accepted

Solution code:
a=[]#入力画面の二文字を別々の文字に格納
a=input().split(" ")
A=int(a[0])
P=int(a[1])
x=int((A*3+P)/2)
print(x)

Submission status: Accepted

Solution code:
apple, piece = map(int, input().split())

piece += apple * 3
print(piece // 2)

Submission status: Accepted

Solution code:
A,P=[int(x) for x in input().split()]
out=int((A*3+P)/2)

print(out)

Submission status: Accepted

Solution code:

lst_1 = input().split()

A = int(lst_1[0])
P = int(lst_1[1])

piece = A * 3

piece += P

pie = piece // 2

print(pie)

Submission status: Accepted

Solution code:
a, p = map(int, input().split())

kakera = 3 * a + p
pie = kakera // 2
print(pie)

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    A, P = map(int, input().split())

    P += 3 * A

    print(str(P//2))

Submission status: Accepted

Solution code:
input_AP = list(map(int, input().split()))
A = input_AP[0]
P = input_AP[1]

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

Submission status: Accepted

Solution code:
a,p = map(int, input().split())


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def input_from_console():
    a, p = map(int, input().split())
    return a, p


def solve(a, p):
    import math
    total_slice = a * 3 + p
    result = math.floor(total_slice / 2)
    return result


def main():
    a, p = input_from_console()
    print(solve(a, p))


if __name__ == "__main__":
    import sys

    if sys.gettrace():  # Check if the python interpreter is in debug mode or not.
        check_cases()
    else:
        main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin


a, p = [int(x) for x in stdin.readline().rstrip().split()]

p = p + a * 3
ans = p // 2

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import math
import collections

A,P = map(int, sys.stdin.readline().rstrip().split(" "))
P = P + A*3
print(P//2)
exit(0)

Submission status: Accepted

Solution code:
def main():
    a, p = map(int, input().split())

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#A問題
A,B=map(int, input().split())
A_piece = (A * 3) + B
ApplePie = A_piece//2
print(ApplePie)

Submission status: Accepted

Solution code:
x=input()
xx=x.split()
A=int(xx[0])
P=int(xx[1])
a=(A*3+P)/2
print(int(a))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
class ApplePie:
    def __init__(self):
        self.A, self.P = map(int, input().split())

    def makePie(self):
        piece = self.P + self.A * 3
        print(piece // 2)


applePie = ApplePie()
applePie.makePie()

Submission status: Accepted

Solution code:
A, P = [int(x) for x in input().split(' ')]
pies = (A * 3 + P) // 2
print(pies)

Submission status: Accepted

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

print(int((l[0]*3+l[1])/2))

Submission status: Accepted

Solution code:
a,p=map(int,input().split())
total=a*3+p

print(total//2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, P = input().split()

a = int(A)
p = int(P)
apple = int((a*3 + p) / 2)

print(apple)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
from math import floor
a,p=map(int,input().split())
piece=p+3*a
print(floor(piece/2))

Submission status: Accepted

Solution code:
a, p = map(int,input().split())

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

Submission status: Accepted

Solution code:
A,P=(int(x) for x in input().split())

chip = 3*A + P
import math
ans = math.floor(chip/2)
print(ans)

Submission status: Accepted

Solution code:
A, P = map(int, input().split())
sum = A * 3 + P
pie = int(sum / 2)
print(pie)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:
N, M = map(int, input().split())
print(int((N*3+M)/2))

Submission status: Accepted

Solution code:
import sys

fin = sys.stdin.readline
A, P = [int(elem) for elem in fin().split()]

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun May 26 21:02:44 2019

@author: aono
"""

s = input().split()

s = [int(v) for v in s]

apple = s[0]
apple_pieces = s[1]

apple_pieces = apple_pieces + 3*apple
apple_pies = int(apple_pieces / 2)

print(apple_pies)

Submission status: Accepted

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

Submission status: Accepted

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


def solve(A: int, P: int):
    P += A * 3
    print(int(P / 2))
    return


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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

totalpiece = A * 3 + P

#output
print(int(totalpiece / 2))

Submission status: Accepted

Solution code:
A, P = map(int,input().split())

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

Submission status: Accepted

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

Submission status: Accepted

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

from collections import deque
import itertools as ite
import sys
import math

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

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

Submission status: Accepted

Solution code:
A, P = input().split()
A = int(A)
P = int(P)

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

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

Solution code:
a, p = map(int, input().split())

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

Submission status: Accepted

Solution code:
a, p = map(int, input().split())

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

Submission status: Accepted

Solution code:
s = input().split()
A = int(s[0])
P = int(s[1])

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

Submission status: Accepted

Solution code:
AP = [int(i) for i in input().split()]
apple = AP[0] * 3 + AP[1]
answer = int(apple/2)
print(answer)

Submission status: Accepted

Solution code:
import math
a,p = map(int,input().split())
p = a*3 + p

print(math.floor(p/2))

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

S = A * 3 + P

print(S // 2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def solve():
    a, p = map(int, input().split())
    p += (a*3)
    pie = p / 2
    print(int(pie))

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
A, P = (int(x) for x in input().split())

B = int(A*3)
C = int((B+P)/2)

print(C)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
a,p = [int(i) for i in input().split()]


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

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
input = sys.stdin.readline

# N = int(input())
# L = [int(x) for x in input().split()]
A, P = map(int, input().split())
# S = input()

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

Submission status: Accepted

Solution code:
def main():
    line = input()
    a, p = line.split(" ")
    p = int(p)
    p += int(a) * 3
    pi = p // 2
    print(pi)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
(a,p) = map(int,input().split())

n = 3 * a + p

x = n // 2

print(x)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
data = list(map(int,input().split()))
print(math.floor((data[0]*3+data[1])/2))

Submission status: Accepted

Solution code:
A, P = (int(i) for i in input().split())

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

Submission status: Accepted

Solution code:
a, p = map(int, input().split())

piece = a * 3 + p
pie = piece / 2

print(int(pie))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,P=map(int,input().split())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,p = map(int,raw_input().split())
print (3*a+p)/2

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A,P=map(int,input().split())

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

print(pi)

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
from collections import deque
from heapq import heappush,heappop
import re

def int_raw():
    return int(input())
 
def ss_raw():
    return input().split()
 
def ints_raw():
    return tuple(map(int, ss_raw()))

def main():
    N,P = ints_raw()
    return (N*3+P)//2

print(main())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def solve():
    A, P = map(int, input().split())
    
    print ((A*3 + P)//2)
    
if __name__ == "__main__":  
    solve()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
a,p = map(int,input().split())
ans = (3*a + p)//2
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
a,p = map(float,input().split())
p+=a*3
print(math.floor(p/2))

Submission status: Accepted

Solution code:
A,P = map(int,input().split())

K = 3*A

total = K + P

pi = int((K + P)/2)
print(pi)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

a = A * 3 + P

print(int(a // 2))

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

P2 = A*3

print(int((P + P2)/2))

Submission status: Accepted

Solution code:
a, p = map(int, input().split())
b = a * 3
pie = int((b + p) / 2)

print(str(pie))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
def main():
    A,P = map(int,input().split())
    A = A*3
    pi = int((A+P)/2)
    print(pi)
if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
inp = input()
st = inp.split()
a = int(st[0])
p = int(st[1])
p += a*3
ans = int(p / 2)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    s = input().rstrip().split(' ')

    A = int(s[0])
    P = int(s[1])
    
    print(int((A*3+P)/2))

Submission status: Accepted

Solution code:
x,y = map(int,input().split())
n = (3*x+y)/2
print(int(n))

Submission status: Accepted

Solution code:
A,P=map(int,input().split())

num=A*3+P

num=num//2

print(num)

Submission status: Accepted

Solution code:
I=lambda:map(int,input().split())
A,P=I()
print((A*3+P)//2)

Submission status: Accepted

Solution code:
A, P = [int(ap) for ap in input().split()]
K = A * 3 + P
print(K // 2)

Submission status: Accepted

Solution code:
A,P = map(int,input().split())

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

Submission status: Accepted

Solution code:
A, P = map(int, input().split())
piece = A*3 + P

print(piece // 2)

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

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

Submission status: Accepted

Solution code:
A,P = map(int,input().split())

P += 3*A

print(P//2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = input().split()
a = [int(f) for f in a]

a1 = a[0]*3
print((a1 + a[1]) // 2)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,p = [int(x) for x in input().split()]

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


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


if __name__ == '__main__':
	import sys
	sys.exit(main())

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
A, P = map(int,input().split())
print(int((3*A + P) / 2))

Submission status: Accepted

Solution code:
def main():
    A, P = map(int, input().split())

    print("{}".format((A*3+P)//2))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a, p = (int(i) for i in input().split())

ans  = (a * 3 + p)/2
print(int(ans))

Submission status: Accepted

Solution code:
A, P = [int(_) for _ in input().split()]

P += 3 * A

print(P // 2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,p = map(int,input().split())

p = p + a * 3

print(p // 2)

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

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

Submission status: Accepted

Solution code:
N,P=[int(x) for x in input().split()]

A=N*3+P

print(int(A/2))

Submission status: Accepted

Solution code:
a,p=(int(i) for i in input().split())
v=(3*a+p)//2
print(v)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, p = (int(i) for i in input().split())

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

Submission status: Accepted

Solution code:
A,P = map(int, raw_input().split())
P = P + A*3
print(P/2)

Submission status: Accepted

Solution code:

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

p = p+a*3

print(p//2)

Submission status: Accepted

Solution code:
def solve():
  A, P = map(int, input().split())
  return (A * 3 + P) // 2

print(solve())

Submission status: Accepted

Solution code:
A,P = map(int,input().split())
P += A*3

answer = P//2
print(answer)

Submission status: Accepted

Solution code:
A,P = input().split()
A = int(A)
P = int(P)
p = A*3 + P
p_num = p //2
print(p_num)

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

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

Submission status: Accepted

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

# In[3]:


import sys
input = sys.stdin.readline
A, B = map(int, input().split())


# In[4]:


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


# In[ ]:

Submission status: Accepted

Solution code:
inp = input()
a = int(inp.split()[0])
p = int(inp.split()[1])

ans = (a * 3 + p) // 2

print(ans)

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
Max = sys.maxsize
def l():
	return list(map(int,input().split()))
def m():
	return map(int,input().split())
def s(x):
	a = []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa == x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x):
	return " ".join(map(str,x))

a,p = m()

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

Submission status: Accepted

Solution code:
# スペース区切りの整数の入力
A,P = map(int, input().split())

P=P+3*A

print(int(P/2))

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

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

Submission status: Accepted

Solution code:
a,b = map(int,input().split())
a = 3*a
c = a + b
if c > 0:
    print(int(c/2))
else:
    print(0)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
apple = input().split()
ringo = int(apple[0])
kakera = int(apple[1])

print(math.floor((ringo * 3 + kakera) / 2))

Submission status: Accepted

Solution code:
A, P = map(int, input().split())
pice = A * 3 + P
pi = pice // 2
print(pi)

Submission status: Accepted

Solution code:
a,p = map(int,input().split())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
A,P = [int(x) for x in input().split()]
print(int((3*A+P)//2))

Submission status: Accepted

Solution code:
inp = list(map(int, input().split()))
res=int((inp[0]*3+inp[1])/2)
print(res)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
a,p = (int(i) for i in input().split()) 
piece=a*3+p
pie=int(piece/2)
print(pie)

Submission status: Accepted

Solution code:
A, P = map(int,input().split())

p = A*3 + P
result = int(p / 2)
print("{}".format(result))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from __future__ import print_function
# import numpy as np
# import numpypy as np
import sys
input = sys.stdin.readline

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)

import math
import string
import fractions
import re
import array
import copy
import functools
import operator

import collections
import itertools
import bisect
import heapq


from heapq import heappush
from heapq import heappop

# from itertools import accumulate
# from collections import deque
import random


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



if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, P = map(int, input().split())
a = A * 3
b = a + P
print(int(b/2))

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

piece = A * 3 + P

print(piece // 2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

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

input = lambda: stdin.readline()
main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, p = map(int, input().split())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, P = map(int, input().split())

N = (A*3 + P)//2

print(N)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

i = list(map(int,input().split()))

kakera = (i[0] * 3) + i[1]
pie = int((kakera - kakera%2)/2)
print (pie)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=list(map(int,input().split(" ")))
print((a[0]*3+a[1])//2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

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

Submission status: Accepted

Solution code:
a,p = map(int, input().split())

ans = (a*3 + p) //2

print(ans)

Submission status: Accepted

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

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

p += 3*a

print(p//2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,P= map(int,input().split())

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

Submission status: Accepted

Solution code:
a,p = map(int, input().split())


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

Submission status: Accepted

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


def solve(A: int, P: int):
    print((3*A+P)//2)
    return


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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from sys import stdin
import math
import itertools


def makeIntMatrix(lines):
    intMatrix = []
    for a in makeStringMatrix(lines):
        intMatrix.append([int(b) for b in a])
    return intMatrix
 
 
def makeStringMatrix(lines):
    stringMatrix = [line.split() for line in lines]
    return stringMatrix
 
 
def makeInt(line):
    return int(line.rstrip())
 
 
def makeMultiInteger(line):
    return [int(x) for x in line.rstrip().split()]


def solve(input_string):
    a, p = makeMultiInteger(input_string[0])
    #print(a, p)
    p += a*3
    #print(p)
    return p//2


def main():
    input_lines = stdin.readlines()
    answer = solve(input_lines)
    print(answer)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a, b = map(int, input().split())
ans = 0
b = b + a * 3
ans = b / 2
print(int(ans))