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):
import sys
INPUT = sys.stdin.readline

def SINGLE_INT(): return int(INPUT())
def MULTIPLE_INT_LIST(): return list(map(int, INPUT().split()))
def MULTIPLE_INT_MAP(): return map(int, INPUT().split())
def SINGLE_STRING(): return INPUT()
def MULTIPLE_STRING(): return INPUT().split()

arr = MULTIPLE_INT_LIST()
arr.sort()

print(sum(arr[:2]))

Solution (Python):
import itertools
P, Q, R = (int(i) for i in input().split())

d = {"AB": P, "BC": Q, "AC":R, "BA": P, "CB":Q, "CA":R}
min = P+Q+R
roots = itertools.permutations("ABC", 3)

for r in roots:
    sumtime = 0
    sumtime+= d[r[0]+r[1]]
    sumtime += d[r[1]+r[2]]
    if sumtime < min:
        min = sumtime

print(min)

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

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

min_val = P + Q
if min_val > Q + R:
    min_val = Q + R
if min_val > P + R:
    min_val = P + R
print(min_val)

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

abc = p + q
acb = r + q
bac = p + r

ans = [abc, acb, bac]

print(min(ans))

Solution (Python):


import sys
import math
import collections

P,Q,R = map(int, sys.stdin.readline().rstrip().split(" "))
print(min([P+Q, Q+R, R+P]))
exit(0)

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(P+Q+R-max(P,Q,R))

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

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

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

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

Solution (Python):



if __name__ == '__main__':
    time = list(map(int, input().split()))
    time.sort()

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

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

m1=p;
m1=min(m1,q)
m1=min(m1,r)
if(m1==p):
        m2=min(q,r)
elif(m1==q):
        m2=min(p,r)
else:
        m2=min(p,q)

print(m1+m2)

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):
inputs = [int(s) for s in input().split()]
p = inputs[0]
q = inputs[1]
r = inputs[2]

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

print(result)

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

Solution (Python):
def main():
  p, q, r = map(int, input().split())
  print(min(p+q, p+r, q+r))
 
if __name__=='__main__':
  main()

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

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

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):
a = sorted([ int(x) for x in input().split() ])
print(a[0]+a[1])

Solution (Python):
x,y,z = sorted(map(int, input().split()))
print(x + y)

Solution (Python):
l =list(map(int,input().split()))
ans = []

for i in range(3):
    for j in range(3):
        if i != j:
            ans.append(l[i] + l[j])
        
print(min(ans))

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

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

Solution (Python):
print(sum(sorted([int(s) for s in input().split()])[:2]))

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

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

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

time.sort()

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

Solution (Python):
aa =  [int(i) for i in input().split()]

bb = sorted(aa)

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

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

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

if __name__ == "__main__":
    main()

Solution (Python):
import sys

def solve(a, b, c):
    return min(a+b, b+c, c+a)

if __name__ == '__main__':

    a, b, c = map(int, sys.stdin.readline().strip().split(" "))
    print solve(a, b, c)

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

Solution (Python):
P, Q, R = list(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):



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())
j = 0

for i in P,Q,R:
    if(i > j):
        j = i
    

print(P+Q+R-j)

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

PQR.sort()

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

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

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

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

List.sort()

result = List[0] + List[1]
print(result)

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

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

Solution (Python):
p,q,r = map(int,input().split())
ansum = sum([p,q,r])
answer = ansum - max([p,q,r])
print(answer)

Solution (Python):
A,B,C = [int(i) for i in input().split()]

r1 = A+B
r2 = B+C
r3 = C+A

s = [r1,r2,r3]
print(min(s))

Solution (Python):
l = sorted([int(x) for x in input().split()],reverse=True)
print(sum(l[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):
pqr = sorted([int(s) for s in input().split()])
print(pqr[0]+pqr[1])

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

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

Solution (Python):

ls = list(map(int, input().split()))
a = min(ls)
del ls[ls.index(min(ls))]
b = min(ls)
print(a + b)

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

a = []

a.append(n[0] + n[1])
a.append(n[1]+n[2])
a.append(n[0]+n[2])
print(min(a))

Solution (Python):


a = list(map(int, input().split()))
a.sort(reverse=True)
print(sum(a[1:]))

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

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

li = []

li.append(P)
li.append(Q)
li.append(R)

li.remove(max(li))

print(sum(li))

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())

result = min([ P + Q, Q + R, P + R, Q + R, R + P, R + P])

print("{}".format(result))

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


def solve(p, q, r ):
    duration_list = [p, q, r]
    duration_list.sort()
    return sum(duration_list[:-1])


def main():
    p, q, r  = input_from_console()
    print(solve(p, q, r ))


if __name__ == "__main__":
    import sys

    if sys.gettrace():  
        check_cases()
    else:
        main()

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

min = p+q

if min > q + r:
    min = q+r
if min > p+ r:
    min = p+r
print(min)

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

Solution (Python):
def li():
    return list(map(int, input().split()))


if __name__ == "__main__":
    pqr = li()
    pqr.sort()
    print(pqr[0] + pqr[1])

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

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

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

Solution (Python):
ab, bc, ca = map(int, input().split())

abc = ab + bc
acb = ca + bc
bac = ab + ca
bca = bc + ca
cab = ca + ab
cba = bc + ab

m = min([abc, acb, bac, bca, cab, cba])

print(m)

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(P + Q + R - max(P, Q, R))

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

route = sorted([P,Q,R])

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

Solution (Python):


p, q, r = map(int, input().split())
a = [p, q, r];

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

Solution (Python):
A = list(map(int, input().split()))
A.sort()
ans = 0
for i in range(2):
  ans += A[i]
print(ans)

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())
print(P + Q + R - max(P, Q, R))

Solution (Python):

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

hoge = S.pop(S.index(min(S)))
fuga = S.pop(S.index(min(S)))

print(hoge + fuga)

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

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

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

print(P+Q+R - max(P,Q,R))

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

m = max([P,Q,R])
print(P+Q+R-m)

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

I.sort()
print(sum(I[:2]))

Solution (Python):

import itertools

a = list(map(int,input().split())) 
ans = []
for i in itertools.permutations(a, r=2):
    ans.append(sum(list(i)))

print(min(ans))

Solution (Python):


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

Solution (Python):










import numpy as np
import math
import copy

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

m = 1000

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

print(m)

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

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

Solution (Python):
import numpy as np
P, Q, R = [int(j) for j in input().split()]

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

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

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

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

list.sort()

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

Solution (Python):
P, Q, R = map(int, input().split())
list = []
list.append(P)
list.append(Q)
list.append(R)
newlist = sorted(list)
ans = newlist[0]+newlist[1]
print("{}".format(ans))

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

xs = sorted([p,q,r])
print(sum(xs[0:2]))

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

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

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

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

one = P + Q
two = Q + R
three = R + P

min = one
if two < one:
    min = two
if three < min:
    min = three

print(min)

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

Solution (Python):
import itertools
x,y,z = map(int,input().split())
seq = (x, y,z)


a = list(itertools.combinations(seq,2))
c = [sum(b) for b in a]

print(min(c))

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

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

print(ans)

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()))
X = [P + Q, P + R, Q + R]
print(min(X))

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())

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

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

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

Solution (Python):
import sys

p, q, r = map(int, input().split())
if p <= q <= r:
    print(p + q)
elif p <= r <= q:
    print(p + r)
elif q <= p <= r:
    print(p + q)
elif q <= r <= p:
    print(r + q)
elif r <= p <= q:
    print(p + r)
elif r <= q <= p:
    print(r + q)

Solution (Python):
F, S, T = map(int, input().split())
FS = F + S
ST = S + T
TF = T + F
L = [FS, ST, TF]
print(min(L))

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

print(P + Q + R - max_distance)

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

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

p.sort()

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

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())

list = [P+Q,Q+R,R+P]
list.sort()

print(list[0])

Solution (Python):
p,q,r = (int(i) for i in input().split())
min = 1000
x = [p+q,q+r,r+p]
for i in x:
    if(i<min):
        min=i
print(min)

Solution (Python):
inputs = list(map(int, input().split()))
P,Q,R = inputs
li = [0 for i in range(3)]
li[0]=P+Q
li[1]=P+R
li[2]=Q+R
li = sorted(li)
print(li[0])

Solution (Python):


''' 
------------------------
author : iiou16
------------------------
'''

def main():
    P, Q, R, = list(map(int, input().split()))

    aa = []
    aa.append(P + Q)
    aa.append(P + R)
    aa.append(Q + R)
    
    print(min(aa))


if __name__ == '__main__':
    main()

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

Solution (Python):

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

A = PQR[0] + PQR[1]
B = PQR[1] + PQR[2]
C = PQR[2] + PQR[0]

fly = []
fly.append(A)
fly.append(B)
fly.append(C)

print(min(fly))

Solution (Python):


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

PQR = [P, Q, R]
PQR_sorted = sorted(PQR)

print(sum(PQR_sorted[0:2]))

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

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

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

Solution (Python):
list_num = [int(num) for num in input().split()]
list_num.sort(reverse=False)

print(str(list_num[0]+list_num[1]))

Solution (Python):
route = input().split()
route.sort()
min = int(route[0]) + int(route[1])
print(min)

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

times = [P,Q,R]
lst = sorted(times)

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

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

list = [p,q,r]
slist = sorted(list)
print(slist[0]+slist[1])

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

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

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

print(yama[0]+yama[1]+yama[2]-max(yama))

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

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

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

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

Solution (Python):
s = [int(x) for x in input().split()]
s.sort()

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

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

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

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

time_list.sort()
print(time_list[0] + time_list[1])
exit(0)

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

Solution (Python):
times = [int(x) for x in input().split(' ')]
times.sort()
print(sum(times[:-1]))

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

d = a + b
e = b + c
f = c + a

if d <= e and d <= f:
    print(d)
    sys.exit()
if e <= d and e <= f:
    print(e)
    sys.exit()
if f <= e and f <= d:
    print(f)
    sys.exit()

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

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

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

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

tsum = min(n)
n.remove(min(n))
tsum += min(n)

print(tsum)

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):
a, b, c = map(int, input().split())
print(a+b+c-max(a,b,c))

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

pq=P+Q
pr=P+R
qr=Q+R
list=[pq,qr,pr]
print(min(list))

Solution (Python):

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

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

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

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

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

Solution (Python):


p, q, r = list(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):
import numpy as np
inp = input()
p = int(inp.split()[0])
q = int(inp.split()[1])
r = int(inp.split()[2])

pq = p + q
qr = q + r
rp = r + p

a = np.array([pq, qr, rp])

print(np.min(a))

Solution (Python):
A = [int(i) for i in input().split()]
A.sort()

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

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

Solution (Python):
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    A = InputToInt()
    A.sort()
    print(A[0]+A[1])

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

Solution (Python):
ll = lambda: list(map(int, input().split()))
testcases = 1

for testcase in range(testcases):
    [p,q,r] = ll()
    print(p+q+r-max(p,q,r))

Solution (Python):
import sys,collections,math,random;sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a = Is()
print(sum(a)-max(a))

Solution (Python):


p, q, r  = map(int, input().split())
numlist = [p, q, r]
print( p + q + r - max(numlist))

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

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

arr = [P, Q, R]

print((P + Q + R) - max(arr))

Solution (Python):
a, b, c = map(int, input().split())
max = 0
for i in [a, b, c]:
  if i > max:
    max = i
print(a+b+c-max)

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):

import sys;
import string;
sys.setrecursionlimit(20000) 

import copy
import itertools

from functools import lru_cache









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


















import re

def doit():
  pq = p + q
  qr = q + r
  rp = r + p
  return min(min(pq, qr), rp)



try:
  print(doit())
except Exception as e:
  print("e", e, file=sys.stderr)

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

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

print(P + Q + R - max(P, Q, R))

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

Solution (Python):
P, Q, R = map(int, input().split())
a1 = min(P, Q, R)
if a1 == P:
    a2 = min(Q, R)
if a1 == Q:
    a2 = min(P, R)
if a1 == R:
    a2 = min(P, Q)

print(a1 + a2)

Solution (Python):
ab, bc, ca = map(int, input().split())

min_dis = 0
abbc = ab + bc
abca = ab + ca
bcca = bc + ca

print(min(abbc, abca, bcca))

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

Solution (Python):
P,Q,R = (int(i) for i in input().split()) 
S=[]
S.append(P+Q)
S.append(R+Q)
S.append(P+R)

print(min(S))

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

Solution (Python):


a,b,c = map(int, input().split())
a1=a+b
a2=a+c
a3=b+c
if(a1<=a2 and a1<=a3):
    print(a1)
elif(a2<=a1 and a2<=a3):
    print(a2)
else:
    print(a3)

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

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

Solution (Python):
lst = input().split()

for i in range(0, len(lst)):
    lst[i] = int(lst[i])


lst = sorted(lst)

ans_sum = 0
for i in range(0, 2):
    ans_sum += lst[i]

print(ans_sum)

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

Solution (Python):



import sys

input = sys.stdin.readline

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

main()

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

a1 = a+b
a2 = a+c
a3 = b+c
x = [a1, a2, a3]
print(min(x))

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 = []
D.append(A+B)
D.append(B+C)
D.append(A+C)
print(min(D))

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

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

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

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

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

Solution (Python):
from sys import stdin
data = stdin.readline().split()
l = [None] * 3
l[0],l[1],l[2] = int(data[0]), int(data[1]), int(data[2])
l = sorted(l)
print(l[0] + l[1])

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

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

Solution (Python):
X = list(map(int,input().split()))
X.sort()
print(X[0]+X[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())
i=list()
i.append(P + Q)
i.append(Q + R)
i.append(R + P)
print(min(i))

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

Solution (Python):
from itertools import permutations
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())

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

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

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

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

Solution (Python):



from sys import stdin

input = stdin.readline



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








def main():
    print(min([P+Q,Q+R,P+R]))

if __name__ == "__main__":
    main()

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

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

print(min(l))

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

Solution (Python):
from sys import stdin

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

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

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

Solution (Python):
def main():
    a = [int(x) for x in input().split()]
    print(sum(sorted(a)[:2]))

if __name__=='__main__':
    main()

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

print(sum(A[:2]))

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

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [P, Q, R] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print min(P + Q, P + R, R + Q)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
n = input().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])
n = max(a,b,c)
print(a+b+c-n)

Solution (Python):
p = list(map(int, input().split()))
sum = 0
for i in range(3):
  sum = sum + p[i]
print(sum - max(p))

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())

o1 = a+b
o2 = a+c
o3 = b+c
print(min(o1, o2, o3))

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

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

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

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

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

sum = 0
for i in range(len(zikan)):
    sum += zikan[i]

sum = sum - max(zikan)

print(sum)

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

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

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

pq = p+q
qr = q+r
rp = r+p

print(min(pq,min(qr,rp)))

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

print(sum(X[:2]))

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

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

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

ABC = P + Q
ACB = R + Q
BCA = P + R

ans = min(ABC, ACB, BCA)

print(int(ans))

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

print(sum(array)-max)

Solution (Python):
class Airplane:
    def __init__(self):
        self.P, self.Q, self.R = map(int, input().split())

    def calMineTime(self):
        lines = [self.P, self.Q, self.R]
        lines.sort()

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


airPlane = Airplane()
airPlane.calMineTime()

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

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

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

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

A = P+Q
B = Q+R
C = R+P

print(min(A,B,C))

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

li.sort()
ans = li[0]+li[1]








print(str(ans))

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

time.sort()

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

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

a = []
a.append(p + q)
a.append(p + r)
a.append(q + r)
a.append(q + p)

print(min(a))

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

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

min = P + Q

if R + Q < min:
    min = R + Q
    
if P + R < min:
    min = P + R

if Q + R < min:
    min = Q + R

if R + P < min:
    min = R + P

if Q + P < min:
    min = Q + P
    
print(min)

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

ans = []

ans.append(P + Q)
ans.append(Q + R)
ans.append(R + P)

print(min(ans))

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

Solution (Python):


import itertools
from collections import Counter
from collections import defaultdict
import bisect
from heapq import heappush, heappop

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

if __name__ == '__main__':
    main()

Solution (Python):
hoge = input().split()
huga = []
huga.append(int(hoge[0]))
huga.append(int(hoge[1]))
huga.append(int(hoge[2]))
huga.remove(max(huga))

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

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

a = p + q
b = q + r
c = r + p

print(min(a, b, c))

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

Solution (Python):
import numpy as np
*P, = list(map(int, input().split()))
P = np.array(P)

ans = np.sum(P) - np.max(P)
print(ans)

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) 


P,Q,R = map(int,input().split())
a = [P,Q,R]
a.sort()
print(a[0]+a[1])

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

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

Solution (Python):
P, Q, R = map(int, input().split())
res = sum(sorted([P, Q, R])[:2])
print(res)

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

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

P.sort()

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

Solution (Python):
p,q,r = [int(i) for i in input().split()]
a = max(p,q,r)
print(p+q+r-a)

Solution (Python):
t = [int(x) for x in 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):
inputs = list(map(int, input().split()))

print(sum(inputs) - max(inputs))

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

print(min(a))

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

tmp = P
if tmp < Q:
    tmp =Q

if tmp < R:
    tmp = R

ans = P+Q+R-tmp

print(ans)