Problem:
 Score : 100 points    Problem Statement There are three airports A, B and C, and flights between each pair of airports in both directions.  A one-way flight between airports A and B takes P hours, a one-way flight between airports B and C takes Q hours, and a one-way flight between airports C and A takes R hours.  Consider a route where we start at one of the airports, fly to another airport and then fly to the other airport.  What is the minimum possible sum of the flight times?      Constraints  1 \leq P,Q,R \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  P  Q  R       Output Print the minimum possible sum of the flight times.        Sample Input 1 1 3 4      Sample Output 1 4   The sum of the flight times in the route A \rightarrow B \rightarrow C: 1 + 3 = 4 hours  The sum of the flight times in the route A \rightarrow C \rightarrow C: 4 + 3 = 7 hours  The sum of the flight times in the route B \rightarrow A \rightarrow C: 1 + 4 = 5 hours  The sum of the flight times in the route B \rightarrow C \rightarrow A: 3 + 4 = 7 hours  The sum of the flight times in the route C \rightarrow A \rightarrow B: 4 + 1 = 5 hours  The sum of the flight times in the route C \rightarrow B \rightarrow A: 3 + 1 = 4 hours   The minimum of these is 4 hours.       Sample Input 2 3 2 3      Sample Output 2 5

Solution (Python):
p,q,r=map(int, input().split())
print(min(p+q,q+r,r+p))

Solution (Python):
p,q,r = list(map(int,input().split()))
a = p + q
b = q + r
c = p + r
print(min(a,b,c))

Solution (Python):
p, q, r = map(int, input().split())

ans = min(p + q, q + r, p + r)
print(ans)

Solution (Python):
T=list(map(int,input().split(' ')))
T.sort()
print(sum(T[:2]))

Solution (Python):
p, q, r = map(int,input().split())
print(min(p+q,p+r,q+r))

Solution (Python):
l = list(map(int, input().split()))
print(sorted(l)[0]+sorted(l)[1])

Solution (Python):
n = list((map(int,input().split())))
n.sort()
print("{}".format(n[0]+n[1]))

Solution (Python):
P,Q,R=map(int,input().split())
x=min(P+Q,R+Q,P+R,Q+R,Q+P,R+P)
print(x)

Solution (Python):
R = list(map(int,input().split(' ')))
R.sort()
print(R[0]+R[1])

Solution (Python):



P, Q, R = map(int, input().split())

x = P + Q
y = Q + R
z = R + P

if x < y:
    if x < z:
        print(x)
    else:
        print(z)
else:
    if y < z:
        print(y)
    else:
        print(z)

Solution (Python):

import sys










def main():
    times = [int(x) for x in sys.stdin.readline().split()]
    times.sort()
    ans = sum(times[:2])
    print(ans)




if __name__ == "__main__":
    main()

Solution (Python):
import unittest


class TestA(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(1, 3, 4), 4)

    def test_2(self):
        self.assertEqual(think(3, 2, 3), 5)


def solve():
    p, q, r = read()
    result = think(p, q, r)
    write(result)


def read():
    return read_int(3)


def read_int(n):
    return read_type(int, n)


def read_float(n):
    return read_type(float, n)


def read_type(t, n):
    return list(map(lambda x: t(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(p, q, r):
    return min(p + q, q + r, r + p)


def write(result):
    print(result)


if __name__ == '__main__':
    
    solve()

Solution (Python):
P,Q,R = map(int,input().split())
l = sorted([P,Q,R])
print(l[0]+l[1])

Solution (Python):
data = list(map(int,input().split()))
data.sort()
print(data[0]+data[1])

Solution (Python):
l = list(map(int, input().split(" ")))
l.sort()

print(sum(l[:2]))

Solution (Python):
pqr = list(map(int, input().split()))

pqr.sort()
print(pqr[0] + pqr[1])

Solution (Python):

a,b,c=map(int, input().split())
print(min(a+b,b+c,c+a))

Solution (Python):
P , Q , R = map(int , input() . split())

print( min( P + Q , Q + R , R + P ) )

Solution (Python):
P, Q, R = map(int, input().split())
print(min(P + Q, Q + R, R + P))

Solution (Python):
P, Q, R = map(int, input().split())

print(min(P+Q,Q+R,R+P))

Solution (Python):
N = input()
numberArray = [int(x) for x in N.split()]
min1 = min(numberArray)
numberArray.remove(min(numberArray))
min2 = min(numberArray)
numberArray.remove(min(numberArray))
print(min1 + min2)

Solution (Python):
P, Q, R = map(int, input().split())

print(min([P + Q, Q + R, R + P]))

Solution (Python):
P, Q, R = map(int, input().split())
print(P + Q + R - max(P, Q, R))

Solution (Python):
P , Q , R = map( int , input().split())

distance = [P+Q , Q+R , R+P]

print(min(distance))

Solution (Python):
a,b,c=map(int,input().split(" "))
d=[]
d.append(a+b)
d.append(a+c)
d.append(c+b)
print(min(d))

Solution (Python):
d = list(map(int, input().split()))

d.sort()
wa = d[0] + d[1]

print(wa)

Solution (Python):
p,q,r=map(int,input().split())
print (min(p+q,p+r,q+r))

Solution (Python):
p,q,r=map(int,input().split())
print(min(p+q,p+r,q+r))

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
def input():
    return sys.stdin.readline().rstrip()

def main():
    a=list(map(int,input().split()))
    print(sum(a)-max(a))

if __name__ == '__main__':
    main()

Solution (Python):

p,q,r = map(int, input().split())

ret = p+q+r-max([p,q,r])
print(ret)

Solution (Python):
l=list(map(int,input().split()))
ls=sorted(l)
print(ls[0]+ls[1])

Solution (Python):
l=list(map(int,input().split()))
ls=sorted(l)
print(ls[0]+ls[1])

Solution (Python):
l = [0]*3

l[0],l[1],l[2] = map(int,input().split())

l.sort()

print(l[0]+l[1])

Solution (Python):
P, Q, R = map(int, input().split())
a = P + Q
b = Q + R
c = R + P
d = min(a, b, c)
print(d)

Solution (Python):
P,Q,R = map(int,input().split())
print(P+Q+R - max(P,Q,R));

Solution (Python):
p,q,r = map(int, input().split())
total = p + q + r - max(p,q,r)
print(total)

Solution (Python):
p,q,r = map(int,input().split())

print(min(p+q,q+r,r+p))

Solution (Python):
p,q,r=map(int, input().split()) 
box = [p,q,r]
print(min(box)+sorted(box)[1])

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

ans = min(a+b,b+c,c+a)
print(ans)

Solution (Python):

import sys
def input():
    return sys.stdin.readline().rstrip()

def main():
    P, Q, R = map(int, input().split())
    print(P+Q+R-max(P,Q,R))


if __name__ == '__main__':
    main()

Solution (Python):
p, q, r = map(int, input().split())

print(min(p + q, q + r, r + p))

Solution (Python):
P,Q,R = map( int, input().split() )
A = P + Q
B = P + R
C = Q + R

print( min(A,B,C) )

Solution (Python):
a, b, _ = sorted(list(map(int,input().split())))
print(a+b)

Solution (Python):
p,q,r=map(int,input().split())

li=[p,q,r]

li.sort()

print(sum(li)-li[2])

Solution (Python):


import sys



tmp = input().split()
p,q,r = list(map(lambda a: int(a), tmp))

sum = p+q+r-max(p,max(q,r))
print(sum)

Solution (Python):
p, q, r = list(map(int, input().split()))

x = p + q
y = q + r
z = r + p

if (x <= y) and (x <= z):
    print(x)
elif (y <= x) and (y <= z):
    print(y)
else:
    print(z)

Solution (Python):
a = [int(i) for i in input().split(" ")]
print(sum(a)-max(a))

Solution (Python):
pqr = sorted(map(int, input().split()))

print(pqr[0] + pqr[1])

Solution (Python):
p,q,r = input().split()
p,q,r = int(p),int(q),int(r)

print(min([p+q,q+r,r+p]))

Solution (Python):
P, Q, R = [int(x) for x in input().split()]

l = [P, Q, R]
res_l = []
for (i_index, i) in enumerate(l):
    for (j_index, j) in enumerate(l):
        if i_index != j_index:
            res_l.append(i+j)

print(min(res_l))

Solution (Python):
P, Q, R = [int(x) for x in input().split()]

res_l = [P+Q, R+Q, P+R, Q+R, R+P, Q+P]

print(min(res_l))

Solution (Python):



P,Q,R = map(int, open(0).read().split())

print(min(P+Q, Q+R, P+R))

Solution (Python):
tmp = list(map(int, input().split()))
p = tmp[0]
q = tmp[1]
r = tmp[2]

maxv = max(p, q, r)

print(p+q+r-maxv)

Solution (Python):
P, Q, R = map(int, input().split())
L =[]
l1 = P+Q
l2 = P+R
l3 = Q+R
l4 = Q+P
l5 = R+P
l6 = R+Q
L.extend([l1, l2, l3, l4, l5, l6])
print(min(L))

Solution (Python):

flight_times = [int(s) for s in input().split()]

min_flight_time = 999999999

for i in range(3):
    for j in range(3):
        if i != j:
            min_flight_time = min(min_flight_time, flight_times[i] + flight_times[j])

print(min_flight_time)

Solution (Python):
time = sorted(list(map(int,input().split())))
print(time[0]+time[1])

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def main():
    lst=list(sorted(map(int,input().split())))
    print(sum(lst[:2]))

main()

Solution (Python):
def p_a():
    pqr = list(map(int, input().split()))
    print(sum(pqr) - max(pqr))
    
p_a()

Solution (Python):
A = list(map(int, input().split()))
ans = sum(A) - max(A)
print(ans)

Solution (Python):
l = list(map(int, input().split()))
l.sort()
print(l[0]+l[1])

Solution (Python):
P , Q , R = map(int, input().split())

if P >= Q and P >= R:
    print(Q + R)
elif Q >= P and Q >= R:
    print(P + R)
else:
    print(P + Q)

Solution (Python):
p, q, r = map(int, input().split())
time = []
time.append(p+q)
time.append(r+q)
time.append(p+r)

print(min(time))

Solution (Python):
T = sorted(list(map(int,input().split())))
print(T[0] + T[1])

Solution (Python):
a, b, c = map(int, input().split())
print(a + b + c - max(a, b, c))

Solution (Python):
p, q, r = map(int, input().split())
ls = [p+q, q+r, r+p]
print(min(ls))

Solution (Python):
p,q,r = map(int,input().split())
print(min(p+q,q+r,r+p))

Solution (Python):
pqr = [int(i) for i in input().split()]
print(sum(sorted(pqr)[:-1]))

Solution (Python):
P, Q, R = map(int, input().split())
print(min(P+Q, Q+R, R+P))

Solution (Python):
p,q,r=map(int,input().split())
a=p+q
b=p+r
c=q+r
print(min(a,b,c))

Solution (Python):
a,b,c=map(int,input().split())
print(min(a+b,b+c,c+a))

Solution (Python):
a=list(map(int,input().split()))
a.sort()
print(a[0]+a[1])

Solution (Python):

import sys
sys.setrecursionlimit(10000)
INF = 1<<32


def solve(P: int, Q: int, R: int):
    print(sum([P,Q,R])-max([P,Q,R]))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    P = int(next(tokens))  
    Q = int(next(tokens))  
    R = int(next(tokens))  
    solve(P, Q, R)

if __name__ == '__main__':
    main()

Solution (Python):
p, q, r = map(int, input().split())

ans = p + q + r

ans = min(ans, p + q)
ans = min(ans, p + r)
ans = min(ans, q + r)

print(ans)

Solution (Python):
a, b, c = map(int, input().split());
ans = 0;

ans = a + b 
if a + c < ans: ans = a + c
if b + a < ans: ans = b + a
if b + c < ans: ans = b + c
if c + a < ans: ans = c + a
if c + b < ans: ans = c + b


print(ans)

Solution (Python):
a,b,c=map(int, input().split())
d=a+b
e=a+c
f=b+c
r=[]
r.append(d)
r.append(e)
r.append(f)
mi=r[0]
for i in r:
  if i<=mi:
    mi=i
    
print(mi)

Solution (Python):
p,q,r=map(int,input().split())
ans=p+q
if ans>q+r:
    ans=q+r
if ans>r+p:
    ans=r+p
print(ans)

Solution (Python):
p, q, r = input().split()
p = int(p)
q = int(q)
r = int(r)

routes = [p + q, q + r, r + p]
print(min(routes))

Solution (Python):
l=list(map(int,input().split()))
print(sum(l)-max(l))

Solution (Python):
P,Q,R = map(int,input().split())
pq = P+Q
qr = Q+R
rp = R+P
L = [pq,qr,rp]
print(min(L))

Solution (Python):
p, q, r = (int(_) for _ in input().split())

print(min(p+q, q+r, r+p))

Solution (Python):
import itertools

s = list(map(int, input().split()))
s = itertools.combinations(s, 2)

mins = 1000000000
for ss in s:
  mins = min(mins, sum(ss))

print(mins)

Solution (Python):
A = sorted([int(i) for i in input().split()])
print(A[0] + A[1])

Solution (Python):
p, q, r = map(int, input().split())
print(p+q+r-max(p, q, r))

Solution (Python):
p,q,r = map(int, input().split())
print(p+q+r - max(p,q,r))

Solution (Python):
a=list(map(int, input().split()))
a.sort()
print(a[0]+a[1])

Solution (Python):
p,q,r = map(int,input().split())
print(min(p+q, q+r, r+p))

Solution (Python):
from collections import Counter,defaultdict,deque
import sys,bisect,math,itertools,string,queue
from heapq import heappop, heappush
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

p = inpl()
p.sort()
print(p[0]+p[1])

Solution (Python):
p, q, r = map(int, input().split())
l = [p+q, q+r, r+p]
print(min(l))

Solution (Python):


def main():
    range_list = [int(s) for s in input().split()]
    range_list.sort()
    print(range_list[0] + range_list[1])

if __name__ == "__main__":
    main()

Solution (Python):
p,q,r=map(int,input().split())
ans=min(p+q,q+r,r+p)
print(ans)

Solution (Python):
P,Q,R=map(int,input().split())
print(min(P+Q,Q+R,R+P))

Solution (Python):
a = list(map(int, input().split()))

print(sum(a)-max(a))

Solution (Python):
P,Q,R = map(int,input().split())

answer = P+Q,P+R,Q+R
print(min(answer))

Solution (Python):
l=list(map(int,input().split()))
print(sum(l)-max(l))

Solution (Python):
PQR = list(map(int, input().split()))
print(sum(PQR) - max(PQR))

Solution (Python):

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

print(a+b+c-max(a,b,c))

Solution (Python):
a=sorted(list(map(int,input().split())));print(a[0]+a[1])

Solution (Python):
P,Q,R=map(int,input().split())
print(min(P+Q,Q+R,R+P))

Solution (Python):
P,Q,R=map(int,input().split())

pq=P+Q
qr=Q+R
rp=R+P

print(min(pq,qr,rp))

Solution (Python):
l=sorted(map(int,input().split()))
print(sum(l)-max(l))

Solution (Python):
print(sum(sorted(list(map(int, input().split())))[:2]))

Solution (Python):
def main():
    array = [int(x) for x in input().split()]

    array = sorted(array)
    ans = array[0] + array[1]
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
l = [int(x) for x in input().split()]
l.sort()
answer = l[0] + l[1]
print(answer)

Solution (Python):
PQR = [int(x) for x in input().split(' ')]
PQR.sort()
answer = PQR[0] + PQR[1]
print(answer)

Solution (Python):
PQR = [int(x) for x in input().split()]
PQR.sort()
answer = PQR[0] + PQR[1]
print(answer)

Solution (Python):
p,q,r = [int(i) for i in input().split(' ')]

x = p+q
y = q+r
z = r+p

print(min([x,y,z]))

Solution (Python):
p,q,r = [int(i) for i in input().split(' ')]

x = p+q
y = q+r
z = r+p

print(min([x,y,z]))

Solution (Python):
p,q,r  = map(int, input().split())

print(min(p+q, q+r, r+p))

Solution (Python):
P,Q,R = map(int, input().split())
print(P+Q+R-max(P,Q,R))

Solution (Python):
r,d,x = map(int,input().split())
print(r+d+x-max(r,d,x))

Solution (Python):
x = list(map(int, input().split()))
min1 = min(x)
x.remove(min1)
min2 = min(x)

print(min1 + min2)

Solution (Python):
P,Q,R=[int(x) for x in input().split()]

ans=min(P+Q,Q+R,R+P)
print(ans)

Solution (Python):
d=list(map(int,input().split()))
l=[]
for i in range(3):
  for j in range(3):
    if i!=j:
      l.append(d[i]+d[j])
print(min(l))

Solution (Python):
a = list(map(int, input().split()))
print(sum(a)-max(a))

Solution (Python):
p,q,r = map(int,input().split())
l = [p,q,r]
l.sort()
print(l[0]+l[1])

Solution (Python):
l = [int(i) for i in input().split()]
l.sort()
print(l[0] + l[1])

Solution (Python):
P, Q, R = map(int, input().split())
print(min(P + Q, Q + R, R + P))

Solution (Python):
y=input().split()
for i in range(len(y)):
    y[i]=int(y[i])
a=[]
a.append(y[0]+y[1])
a.append(y[2]+y[1])
a.append(y[0]+y[2])
a.sort()
print(a[0])

Solution (Python):
print(sum(sorted(map(int, input().split()))[:-1]))

Solution (Python):
P, Q, R = map(int, input().split())

hour = [P + Q, P + R, Q + R]
print(min(hour))

Solution (Python):
a = list(map(int, input().split()))
print(sum(a) - max(a))

Solution (Python):
a,b,c=map(int,input().split())
print(a+b+c-max(a,b,c))

Solution (Python):
X = list(map(int, input().split()))
X=sorted(X)
print(X[0]+X[1])

Solution (Python):

import sys


def solve(P: int, Q: int, R: int):
    a = P + Q
    b = Q + R
    c = R + P
    print(min([a, b, c]))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    P = int(next(tokens))  
    Q = int(next(tokens))  
    R = int(next(tokens))  
    solve(P, Q, R)

if __name__ == '__main__':
    main()

Solution (Python):

import sys
sys.setrecursionlimit(10 ** 7)


def solve(P: int, Q: int, R: int):
    lst = [P, Q, R]
    lst.sort()
    print(lst[0] + lst[1])
    return




def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    P = int(next(tokens))  
    Q = int(next(tokens))  
    R = int(next(tokens))  
    solve(P, Q, R)


if __name__ == '__main__':
    main()

Solution (Python):
A, B, C = map(int, input().split())
print(min(A+B, B+C, C+A))

Solution (Python):
p,q,r = list(map(int,input().strip().split()))
a = p + q
b = q + r
c = r + p
s = [a,b,c]
print(min(s))

Solution (Python):
P, Q, R = map(int, input().split())

print(min(P+Q, P+R, Q+R))

Solution (Python):
A,B,C=map(int, input().split())

a=A+B
b=C+B
c=A+C
print(min(a,b,c))

Solution (Python):
P,Q,R = map(int,input().split())

print(min(P+Q,P+R,Q+R))

Solution (Python):
ABC = input().split()
AtoB = int(ABC[0])
BtoC = int(ABC[1])
CtoA = int(ABC[2])
l = []
for i in range(3):
    l.append(int(ABC[i]))
l.sort()
answer = l[0] + l[1]
print(answer)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

P,Q,R = sorted(map(int,read().split()))

answer = P+Q
print(answer)

Solution (Python):
hoge = list(map(int, input().split()))

hoge.sort()

print(hoge[0]+hoge[1])

Solution (Python):
p,q,r = map(int,input().split())
a = p+q
b = q+r
c = r+p
l=[a,b,c]

print(min(l))

Solution (Python):
p,q,r=map(int,input().split())
print(min(p+q,q+r,r+p))

Solution (Python):
p=input().split()
q= [int(s) for s in p]
q.sort()
print(q[0]+q[1])

Solution (Python):

p, q, r = map(int, input().split())







print(min(p + q, q + r, r + p))

Solution (Python):
P,Q,R = map(int,input().split())
print(min(P+Q,Q+R,R+P))

Solution (Python):
p , q , r = map(int , input().split())
a , b , c = p + q , q + r , r + p
if a <= b:
    if a <= c:
        print(a)
    else:
        print(c)
else:
    if b <= c:
        print(b)
    else:
        print(c)

Solution (Python):
x = sorted(list(map(int,input().split(" "))))
print(x[0]+x[1])

Solution (Python):
P, Q, R = map(int, input().split())

print(min(P+Q, Q+R, R+P))

Solution (Python):
a=sorted(list(map(int,input().split())))
print(a[0]+a[1])

Solution (Python):
p,q,r=map(int,input().split())
ans=p+q+r-max(p,q,r)
print(ans)

Solution (Python):

P, Q, R = map(int, input().split())
ans = min(P+Q,Q+R,R+P)
print(ans)

Solution (Python):
p,q,r=map(int,input().split());print(p+q+r-max(p,q,r))

Solution (Python):
p, q, r = map(int, input().split())

print(min(p+q, q+r, r+p))

Solution (Python):
L = list(map(int, input().split()))
L.sort()
print(sum(L[:-1]))

Solution (Python):
P,Q,R = map(int,input().split())
print(P+Q+R-max(P,Q,R))

Solution (Python):
pqr = list(map(int, input().split()))
pqr.sort()
print(pqr[0]+pqr[1])

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

N.sort()
print(N[0]+N[1])

Solution (Python):
p,q,r=list(map(int,input().split()))
ans=min(p+q,q+r,r+p)
print(ans)

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

N.sort()

print(N[0] + N[1])

Solution (Python):
INPUT = list(map(int,input().split()))
P = INPUT[0]
Q = INPUT[1]
R = INPUT[2]

print(min(P+Q,Q+R,R+P))

Solution (Python):
'''A - Airplane
https://atcoder.jp/contests/abc129/tasks/abc129_a

>>> main(1, 3, 4)
4
>>> main(3, 2, 3)
5

in5.txt
>>> main(99, 62, 92)
154'''

from itertools import permutations


def main(p, q, r):
    _max = 999

    for p in permutations([p, q, r], 2):
        if _max > sum(p):
            _max = sum(p)

    print(_max)


if __name__ == '__main__':
    p, q, r = map(int, input().split(' '))
    main(p, q, r)

Solution (Python):
a,b,c=map(int,input().split())
print(a+b+c-max(a,b,c))

Solution (Python):
P,Q,R = map(int,input().split())

print(min(P+Q,Q+R,R+P))

Solution (Python):
a,b,c=map(int,input().split())
d=a+b+c
print(min(d-a,d-b,d-c))

Solution (Python):
P, Q, R = map(int, input().split())

print(min(P+Q, Q+R, P+R))

Solution (Python):
P,Q,R = map(int, input().split())
print(min(P+Q, Q+R, R+P))

Solution (Python):
P,Q,R = map(int,input().split())
print(min(P+Q,Q+R,P+R))

Solution (Python):
a = list(map(int, input().split()))
print(sum(sorted(a)[:2]))

Solution (Python):
p,q,r = map(int, input().split())
print(min(p+q,q+r,r+p))

Solution (Python):
p, q, r = map(int, input().split())
t = p + q + r - max(p, q, r)
print(t)

Solution (Python):
P , Q ,R = map(int ,input().split())
print(min(P + Q , P + R , R + Q))

Solution (Python):

A = list(map(int,input().split()))
A.sort()

print(A[0]+A[1])

Solution (Python):
P, Q, R = map(int, input().split())
print(min(P + Q, Q + R, R + P))

Solution (Python):
a=list(map(int,input().split()))
print(sum(a)-max(a))

Solution (Python):
p,q,r=map(int,input().split())

print(min(p+q,q+r,r+p))

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    p, q, r = list(map(int, input().rstrip('\n').split()))
    print(min(p + q, q + r, r + p))


if __name__ == '__main__':
    slove()

Solution (Python):

lst = [int(x) for x in input().split()]
lst.sort()
print(lst[0] + lst[1])

Solution (Python):
l = list(map(int, input().split()))
l_sorted = sorted(l)

print(l_sorted[0] + l_sorted[1])

Solution (Python):
T=list(map(int,input().split()))
print(sum(T)-max(T))

Solution (Python):
l= sorted(list(map(int, input().split())))[:2]
print(sum(l))

Solution (Python):
a_L = list(map(int,input().split()))
a_L = sorted(a_L)
print(a_L[0]+a_L[1])

Solution (Python):
l=list(map(int,input().split()))
print(sum(l)-max(l))

Solution (Python):
if __name__ == "__main__":
    A = list(map(int, input().split()))
    A.sort()
    print(A[0]+A[1])

Solution (Python):
P,Q,R=map(int,input().split())
ans=min(P+Q,P+R,Q+R)
print(ans)

Solution (Python):
p = list(map(int, input().split()))
print(sum(p) - max(p))

Solution (Python):
p,q,r=map(int,input().split())
pqr=[p,q,r]
pqr.sort()
print(pqr[0]+pqr[1])

Solution (Python):
p,q,r=map(int,input().split())
print(min([p+q,q+r,r+p]))

Solution (Python):
arr = list(map(int, input().split()))

arr.sort()

print(arr[0] + arr[1])

Solution (Python):



def main():
    p, q, r = map(int, input().split())
    print(min(min(p+q, q+r), r+p))


if __name__ == '__main__':
    main()

Solution (Python):
*a, b = sorted(map(int, input().split()))
print(sum(a))

Solution (Python):
import heapq
l = list(map(int,input().split()))

heapq.heapify(l)
print(heapq.heappop(l) + heapq.heappop(l))

Solution (Python):
P, Q, R = map(int, input().split())

min_d = P+Q
min_d = min(min_d, Q+R)
min_d = min(min_d, P+R)
print(min_d)

Solution (Python):
Airplane=list(map(int,input().split()))
Airplane.remove(max(Airplane))
print(sum(Airplane))

Solution (Python):
p, q, r = map(int, raw_input().split())
ans = min(p+q, p+r, q+r)
print (ans)

Solution (Python):
lis = list(map(int,input().split()))

lis.sort()
print(lis[0] + lis[1])

Solution (Python):
a = list(map(int, input().split()))
a.sort()
print(a[0]+a[1])

Solution (Python):
P,Q,R = map(int,input().split(" "))

print(min([P+Q,P+R,Q+R]))

Solution (Python):
P,Q,R=map(int,input().split());print(min(P+Q,Q+R,R+P))

Solution (Python):
P,Q,R=map(int,input().split())
n=(P,Q,R)
print((P+Q+R)-max(n))

Solution (Python):
P,Q,R = map(int,input().split())
A = [P,Q,R]
A.sort()
print(A[0]+A[1])

Solution (Python):
P, Q, R = map(int,input().split())
min = 1000
AC = P + Q
BA = R + P
AB = R + Q
if AC < min:
    min = AC
if BA < min:
    min = BA
if AB < min:
    min = AB
print(min)

Solution (Python):
time = list(map(int, input().split()))

print(sum(time) - max(time))

Solution (Python):
a = list(map(int, input().split()))
ans = sum(a)-max(a)
print(ans)

Solution (Python):
p,q,r = map(int,input().split())
print(p+q+r-max(p,q,r))

Solution (Python):
p,q,r = map(int, input().split())
print(min(p+q, min(q+r, r+p)))

Solution (Python):
a,b,c = map(int, input().split())
s1 = a + b
s2 = b + c
s3 = c + a

if s1 <= s2:
  if s1 <= s3:
    print(s1)
  elif s3 <= s1:
    print(s3)
elif s2 <= s1:
  if s2 <= s3:
    print(s2)
  elif s3 <= s2:
    print(s3)

Solution (Python):
p, q, r = map(int, input().split())
a, b, c = sorted([p, q, r])
print(a + b)

Solution (Python):
P,Q,R=map(int,input().split())
print(min(P+Q,Q+R,R+P))

Solution (Python):
p,q,r = map(int,input().split())
print(min(p+q,p+r,q+r))

Solution (Python):
p, q, r = map(int, input().split())

ans = p+q
ans = min(ans, p + r)
ans = min(ans, q + r)

print(ans)

Solution (Python):
P,Q,R = list(map(int,input().split()))
print(min(P+Q,Q+R,R+P))

Solution (Python):
p, q, r = map(int, input().split())
print(min(p+q, q+r, r+p))

Solution (Python):
p,q,r=map(int,input().split())
maxi=max(p,q,r)
print(p+q+r-maxi)

Solution (Python):
from sys import stdin

li = list(map(int,stdin.readline().rstrip().split()))

li.sort()

print(li[0]+li[1])

Solution (Python):
P,Q,R=map(int,input().split()) 
a=[P+Q,Q+R,R+P]

print(min(a))

Solution (Python):
A = sorted(list(map(int, input().split())))
print(sum(A[:2]))

Solution (Python):
flight_times = list(map(int, input().split(" ")))
flight_times.sort()
print(flight_times[0] + flight_times[1])

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

list = sorted(list)

print( list[0] + list[1])

Solution (Python):
p, q, r = map(int, input().split())
print(min(p+q,q+r,r+p))

Solution (Python):

a = list(map(int,input().split()))
print(sum(a) - max(a))

Solution (Python):
p, q, r = map(int, input().split())

x = p + q
y = q + r
z = r + p

print(min(x, y, z))

Solution (Python):
P,Q,R = list(map(int,input().split()))
print(min(P + Q,P + R,Q + R))

Solution (Python):
P, Q, R = map(int, input().split())

list = [P, Q, R]
min1 = min(list)
list.remove(min1)
min2 = min(list)
print(min1 + min2)

Solution (Python):
p, q, r = map(int, input().split())
print(min(p+q, q+r, r+p))

Solution (Python):
pqr=sorted(list(map(int,input().split())))
print(pqr[0]+pqr[1])

Solution (Python):
P,Q,R=[int(s) for s in input().split() ]
print(min([P+Q,Q+R,R+P]))

Solution (Python):

def main():
    *A, = map(int, open(0).read().split())
    ans = sum(A) - max(A)
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
from sys import exit, stderr, stdin
input = stdin.readline


def debug(var, name="hoge"):
    print(str(type(var)) + name +":" + " = " + repr(var), file=stderr)
    return


def main():
    A, B, C = sorted(list(map(int,input().split())))
    print(A+B)
    
    
    
    
    
    
    
    


if __name__ == "__main__":
    main()

Solution (Python):
p, q, r = map(int, input().split())
print(min(p+q, q+r, p+r))

Solution (Python):
t = list(map(int, input().split()))
t.sort()
print(t[0] + t[1])

Solution (Python):
p, q, r = map(int, input().split())
print(min(p + q, q + r, r + p))

Solution (Python):
lst = list(map(int, input().split()))
lst.sort()
print(lst[0] + lst[1])

Solution (Python):
P, Q, R = map(int, input().split())
cost = [P + Q, R + Q, R + P]
print(min(cost))

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

print(min(a + b, b + c, c + a))

Solution (Python):
P, Q, R = map(int, input().split())
print(P+Q+R-(max(P,Q,R)))

Solution (Python):
P, Q, R=map(int, input().split())
print(min(P+Q, Q+R, R+P))

Solution (Python):
p = list(map(int,input().split()))
print(sum(p)-max(p))

Solution (Python):
p, q, r = map(int, input().split())
print(min(p + q, q + r, r + p))

Solution (Python):
p, q, r = [int(i) for i in input().split()]

ans = [p+q, q+r, p+r]
print(min(ans))

Solution (Python):
l = [int(x) for x in input().split()]
l.sort()
print(int(l[0])+int(l[1]))

Solution (Python):
P,Q,R = map(int, input().split())
print(P+Q+R-max(P,Q,R))

Solution (Python):
n=[int(i) for i in input().split()]
n.sort()
print(n[0]+n[1])

Solution (Python):

s = list(map(int,input().split()))
print(sum(s)-max(s))

Solution (Python):
P,Q,R=map(int,input().split())

print(min(P+Q,Q+R,R+P))

Solution (Python):
l = list(map(int, input().split()))
print(sum(l)-max(l))

Solution (Python):
P,Q,R = map(int, input().split())
print(min(P+Q, Q+R, R+P))

Solution (Python):
import itertools

n = map(int, input().split())
ns = list(itertools.combinations(n,2))
num = list()

for i in ns:
  num.append(i[0] + i[1])
print(min(num))

Solution (Python):
p, q, r = map(int, input().split())
ans = 0
if p <= q:
    a = p
    b = q
    if b <= r:
        ans = a + b
    else:
        ans = a + r
else:
    a = q
    b = p
    if b <= r:
        ans = a + b
    else:
        ans = a + r
print(ans)

Solution (Python):
t = list(map(int, input().split()))
t.sort()
del t[-1]
print(sum(t))

Solution (Python):
P,Q,R = map(int,input().split())
print(min(P+Q,P+R,Q+R,Q+P,R+P,R+Q))

Solution (Python):
P,Q,R=[int(x) for x in input().split()]
print(min(P+Q,Q+R,R+P))

Solution (Python):
P, Q, R = map(int,input().split())
print(P+Q+R-max([P,Q,R]))

Solution (Python):
A = sorted(list(map(int, input().split())))
print(A[0]+A[1])

Solution (Python):
times = list(map(int, input().split()))

sum_times = sum(times)
max_time = 0
for i in range(len(times)):
    if max_time < times[i]:
        max_time = times[i]
print(sum_times - max_time)

Solution (Python):
p, q, r = map(int,input().split())
print(p + q + r - max(p, q, r))

Solution (Python):
print(sum(sorted(map(int,input().split()))[:2]))

Solution (Python):
t = list(map(int, input().split()))

ans = t[0] + t[1]
for i in range(3):
    for j in range(3):
        if i == j:
            continue
        ans = min(t[i] + t[j], ans)
print(ans)

Solution (Python):
p,q,r = map(int, input().split())

print(min(p+q,q+r,p+r))

Solution (Python):
P,Q,R = map(int,input().split()) 
import itertools
ans = min(map(sum,list(itertools.combinations([P,Q,R], 2))))
print(ans)

Solution (Python):
p,q,r = map(int, input().split())
print(min(p+q,q+r,r+p))

Solution (Python):
P,Q,R = map(int,input().split())
k = [P+Q,Q+R,P+R]
print(min(k))

Solution (Python):
hour = list(map(int, input().split()))

sorted_hour = sorted(hour)


print(sorted_hour[0]+sorted_hour[1])

Solution (Python):
s = sorted(map(int, input().split()))
print (s[0] + s[1])

Solution (Python):
p, q, r = map(int, input().split())
print(min(p+q, q+r, r+p))

Solution (Python):
p,q,r=map(int, input().split())
a=p+q
b=p+r
c=r+q
print(min(a,b,c))

Solution (Python):
lst = list(map(int,input().split()))
lst.sort()
print(lst[0]+lst[1])

Solution (Python):
p,q,r=map(int,input().split())
print(p+q+r-max(p,q,r))

Solution (Python):
p,q,r = map(int,input().split())

print(min(p+q,p+r,q+r))

Solution (Python):

p, q, r = map(int, input().split())
print (min(p+q, q+r, r+p))

Solution (Python):
p,q,r=map(int, input().split())
i=p+q+r
print(i-max(p,q,r))

Solution (Python):
P,Q,R = map(int,input().split())
total = P+Q+R
A = total-P
B = total-Q
C = total-R
print(min(A,B,C))

Solution (Python):
lst = list(map(int,input().split()))
lst.sort()

print ( lst[0] + lst[1] )

Solution (Python):
P,Q,R =map(int,input().split())
print(P+Q+R-max(P,Q,R))

Solution (Python):
a = list(map(int, input().split()))
print(sum(a)-max(a))

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

print(min(a+b, a+c, b+c))

Solution (Python):
a = list(map(int,input().split()))
print(min(a[0]+a[1],a[1]+a[2],a[2]+a[0]))

Solution (Python):
P, Q, R = map(int, input().split())
X = [P, Q, R]
X.sort()
X.pop()
print(sum(X))

Solution (Python):
p, q, r = map(int, input().split())
print(min(p+q, q+r, r+p))