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):
A=tuple(map(int,input().split()))
print(sum(A)-max(A))

Solution (Python):
import numpy as np

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

times = []

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

print(min(times))

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

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

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

min1=P
min2=Q

min1=101
min2=101





Z1=P+Q
Z2=Q+R
Z3=P+R
Z4=Q+R
Z5=R+P
Z6=Q+R

min1=Z1
if(min1>Z2):
    min1=Z2
if(min1>Z3):
    min1=Z3
print(min1)

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

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

main()

Solution (Python):
x,y,z = (int(x) for x in input().split())

a = x + y
b = y + z
c = z + x

print(min([a, b, c]))

Solution (Python):
a_i = list(map(int, input().split()))
count = 0
total = 0
for i in sorted(a_i):
    total = total + i
    count = count + 1
    if count == 2:
        break
print(total)

Solution (Python):
A, B, C = list(map(int,input().split()))
res = []
res.append(A+B)
res.append(B+C)
res.append(A+C)
print (min(res))

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

Solution (Python):

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

Solution (Python):
import itertools

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

routes = list(itertools.combinations(l, 2))

print(min([route[0]+route[1] for route in routes]))

Solution (Python):



import numpy as np
import scipy as sp

def main():
    try:
        li = list(map(int, input().split()))
        min_time = 1e100
        if li[0] + li[1] < min_time:
            min_time = li[0] + li[1]
        if li[1] + li[2] < min_time:
            min_time = li[1] + li[2]
        if li[2] + li[0] < min_time:
            min_time = li[2] + li[0]
        print(min_time)
    except:
        pass

if __name__ == '__main__':
    main()

Solution (Python):

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

Solution (Python):
lst = input().split()
p = int(lst[0])
q = int(lst[1])
r = int(lst[2])
lista = []
lista.append(p + q)
lista.append(r + q)
lista.append(p + r)
print(min(lista))

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


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

minlist = [abc, acb, bac]
print(min(minlist))

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

min = p + q

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

print (int(min))

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

Solution (Python):
l = sorted([int(i) for i in input().split()],reverse=True)

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

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

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


result = sum(list_ABC) - max(list_ABC)
print(str(result))

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

t1 = a[0] + a[1]
t2 = a[0] + a[2]
t3 = a[1] + a[2]

if t1 <= t2 and t1 <= t3:
    print(t1)
elif t2 <= t1 and t2 <= t3:
    print(t2)
else:
    print(t3)

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

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

print(min(ans))

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

P=int(input_data[0])
Q=int(input_data[1])
R=int(input_data[2])

abc = P+Q
acb = R+Q
bac = P+R
bca = Q+R
cab = R+P
cba = Q+P

answer=min(abc,acb,bac,bca,cab,cba)
print(answer)

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

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

Solution (Python):
import itertools
pqr = list(map(int,input().split(" ")))
print(sum(min(list(itertools.combinations(pqr, 2)), key=lambda x:sum(x))))

Solution (Python):
import sys
input = sys.stdin.readline

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

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

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

Solution (Python):
import sys

a = []


P, Q, R=map(int, input().split())
a.append(P)
a.append(Q)
a.append(R)
max = 0
for i in a:
    if max < i:
        max = i

print(sum(a)-max)

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

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

print(transitmin)

Solution (Python):



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

if a <= b and c <= b:
  sum = a + c
if b <= a and c <= a:
  sum = b + c
if a <= c and b <= c:
  sum = a + b







print(str(sum))

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

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

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

if a == max([a,b,c]):
  out=b+c
elif b== max([a,b,c]):
  out=a+c
elif c == max([a,b,c]):
  out=a+b
  
print(out)

Solution (Python):
P, Q, R = (int(i) for i in 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):
P, Q, R = map(int, input().split())
print(min(P+Q, Q+R, P+R))

Solution (Python):
import itertools
a= list(map(int, input().split()))
result = []
test = list(itertools.permutations(a, 2))
for i in range(len(test)):
    result.append(test[i][0] + test[i][1])
print(min(result))

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

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

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

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

Solution (Python):
s = list(map(int, input().split()))
ans = s[0] + s[1] + s[2] - max(s)
print(ans)

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

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

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

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

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

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

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

Solution (Python):
a,b,c=map(int,input().split())
d=a+b+c-max([a,b,c])
print('{0}'.format(d))

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

l = [p, q, r]

l.sort()

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

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

Solution (Python):
a,b,c=map(int,input().split())
arr = [a, b, c]
arr.sort()
print(arr[0] + arr[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):
pqr=sorted(list(map(int,input().split())))
print(pqr[0]+pqr[1])

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

Solution (Python):
a=[int(x) for x in input().split()]
min_h = min([a[0]+a[1],a[1]+a[2],a[2]+a[0]])

print(min_h)

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

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

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

P.sort()

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

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

min_t = 1000

for i in range(3):
    if i == 2:
        min_t = min(min_t, t[i] + t[0])
    else:
        min_t = min(min_t, t[i] + t[i+1])

print(min_t)

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

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

b = 0
for x in a:
    if b<x:
        b=x
print(a[0]+a[1]+a[2]-b)

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

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

P = int(STR[0])
Q = int(STR[1])
R = int(STR[2])


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

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

p, q, r = inpl()

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

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

Solution (Python):
t1, t2, t3 = sorted(map(int, input().split()))

print(t1 + t2)

Solution (Python):
from itertools import permutations

time = list(map(int,input().split(' ')))
min = sum(time)
perm = permutations(time,2)
for p in perm:
    s = sum(p)
    if s < min:
        min = s
print(min)

Solution (Python):


line = input()
arr = []
for i in range(3):
	arr.append(int(line.split()[i]))
ans = sum(arr) - max(arr)
print(ans)

Solution (Python):
far=[]
min=0
pqr =list(map(int, input().split(" ")))

far=sorted(pqr)

for i in range(2):
    min+= far[i]
print(min)

Solution (Python):
int_list = []

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

a0 = P + Q
int_list.append(a0)
a1 = Q + R
int_list.append(a1)
a2 = P + R
int_list.append(a2)
a3 = Q + R
int_list.append(a3)
a4 = R + P
int_list.append(a4)
a5 = P + Q
int_list.append(a4)

print(min(int_list))

Solution (Python):


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

lst.sort()

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

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

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

Solution (Python):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split()
    a = int(token[0])
    b = int(token[1])
    c = int(token[2])

    return (a, b, c)


def solve(a, b, c):

        

    

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




def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

Solution (Python):

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

Solution (Python):


a = input().split()
p = int(a[0])
q = int(a[1])
r = int(a[2])
m = max(p,q,r)

print(p+q+r-m)

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

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

arr = [a, b, c]
print(min(arr))

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

Solution (Python):
num1, num2, num3 = [int(i) for i in input().split()]
a=[num1+num2,num2+num3,num1+num3]
print(min(a))

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

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

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

times.sort()

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

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

Solution (Python):


def solve():
    P, Q, R = list(map(int, input().split()))
    ans = min(P+Q, Q+R, R+P)

    print(ans)

if __name__ == "__main__":
    solve()

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

print(sum(sorted(A)[:-1]))

Solution (Python):


import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    P, Q, R = i2nn()
    print(P + Q + R - max(P, Q, R))
    return

main()

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

Solution (Python):
a,b,c=input().split()
d=[a,b,c]
p = sorted(d)

k=int(p[0])+int(p[1])
print(k)

Solution (Python):

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

a = n[0] + n[1]
b = n[0] + n[2]
c = n[1] + n[2]

print(min(a,b,c))

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

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

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

import itertools

print(min(list(map(sum, list(itertools.permutations(L, 2))))))

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

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

Solution (Python):


t = sorted(list(map(int, input().split())))

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

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

min_root = []
for i in L:
    for j in L:
        if i != j:
            min_root.append(i+j)
        else:
            continue
            
if len(min_root) > 0:
    print(min(min_root))
else:
    print(L[0]+L[1])

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

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

Solution (Python):
A = [int(i) for i in 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())

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

print(min(calc_list))

Solution (Python):

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

Solution (Python):
def solve():
    hours = [int(x) for x in input().split()]
    longestIdx = hours.index(max(hours))
    hours[longestIdx] = 0
    print(sum(hours))
solve()

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

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

P = int(IN[0])
Q = int(IN[1])
R = int(IN[2])

X = P + Q
Y = R + Q
Z = P + R

arr = [X,Y,Z]

print(min(arr))

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

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

x = max(a,b,c)

print(a+b+c-x)

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

A = int(S[0])
B = int(S[1])
C = int(S[2])
answer_1 = A + B
answer_2 = A + C
answer_3 = B + C

print(min(answer_1,answer_2,answer_3))

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

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

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

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

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



 
 
print("{}".format(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):

import sys
import itertools

input = sys.stdin.readline 

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

combi = list(itertools.combinations(a_list, 2))
sum_list = [sum(i) for i in combi]
print(min(sum_list))

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

Solution (Python):
P , Q , R = (int(i) for i in input().split())  
a = 0
b = 0
c = 0
a = P + Q
b = Q + R
c = P + R
print(min(a,b,c))

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

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

Solution (Python):


p, q, r = [int(x) for x in input().rstrip().split(" ")]

s = [0, 0, 0]
s[0] = p + q
s[1] = q + r
s[2] = r + p

print(min(s))

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

for i in range(3):
  min = p+q
  
  tugi = r+q
  if tugi < min:
    min = tugi
    
  tugi = p+r
  if tugi < min:
    min = tugi

print(min)

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

Answer = 0
standard = 0

if P >= Q:
  Answer = Q
  standard = P
else:
  Answer = P
  standard = Q

if R >= standard:
  Answer += standard
else:
  Answer += R
  
print(Answer)

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

ans_list = [list_pqr[0] + list_pqr[1],list_pqr[0] + list_pqr[2],list_pqr[1] + list_pqr[2]]

print(min(ans_list))

Solution (Python):
import fractions as fr
import itertools as it
import collections as col
import heapq as hq
import sys
sys.setrecursionlimit(10**9)

"""
N=int(input())
W=list(map(int, input().split()))
ans=10**100
for T in range(1,N):
        S1=sum(W[:T])
        S2=sum(W[T:])
        ans = min(ans, abs(S1-S2))
print(ans)
"""
P,Q,R=map(int, input().split())
print(min([P+Q, P+R, Q+R]))

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

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

Solution (Python):
n = raw_input().split(' ')

n1 = int(n[0]) + int(n[1])
n2 = int(n[1]) + int(n[2])
n3 = int(n[2]) + int(n[0])

if n1 <= n2:
  if n1 < n3:
    print(n1)
  else :
    print(n3)
elif n2 <= n3:
  print(n2)
else:
  print(n3)

Solution (Python):
string = input()
numbers = string.split(" ")
sums = []
sums.append( int(numbers[0]) +int(numbers[1]))
sums.append( int(numbers[0]) +int(numbers[2]))
sums.append( int(numbers[2]) +int(numbers[1]))
print(min(sums))

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

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):
a,b, c = map(int, input().split())
 
min = 10000
 
list = []
 
list.append(a+b)
list.append(a+c)
list.append(c+b)

for i in list:
  if min > i:
    min = i
print(min)

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

mylist.sort()

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

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

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

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


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().strip().split())
s = [p,q,r]
res = min(s)
s.remove(res)
res1 = min(s)
print(res+res1)

Solution (Python):
P,Q,R = map(int, input().split())
l = [P, Q, R]
l.remove(max(l))
result = sum(l)
print(result)

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

l = []
for fst in inp:
    inp.remove(fst)
    for sec in inp:
        l.append(fst + sec)

print(min(l))

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

Solution (Python):

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

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

Solution (Python):
import itertools

i = list(map(int,input().split(' ')))
p = list(itertools.permutations(i, 2))

a = []
for i in p:
  a.append(sum(i))
  
print(min(a))

Solution (Python):
pqr = list(map(int,input().split()))
tmp = 0
time = 1000

for i in range(3):
    for j in range(3):
        if i == j:
            continue
        else:
            tmp = pqr[i] + pqr[j]
            time = min(time,tmp)
print(time)

Solution (Python):
P, Q, R = map(int, input().split())
abc = P+Q
acb = P+R
cab = R+Q

ans = 10000
ans = min(ans, abc)
ans = min(ans, acb)
ans = min(ans, cab)
print(ans)

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

Solution (Python):
x = input()
x2 = x.split(" ")

x2.sort()

print (int(x2[0]) + int(x2[1]))

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

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

print(min(time[0]+time[1], time[1]+time[2], time[2]+time[0]))

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

a = P + Q
b = Q + R
c = P + R

print(min(a,b,c))

Solution (Python):
lista = input().split(" ")
a, b, c = lista
a = int(a)
b = int(b)
c = int(c)
lista1 = [a, b, c]
lista1.sort()
t = lista1[0]+lista1[1]
print(t)

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

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

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

Solution (Python):
a = input().split()
p = int(a[0])
q = int(a[1])
r = int(a[2])
x = p + q
y = q + r
z = p + r
print(min([x,y,z]))

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

ans = min(sm)
print(ans)

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

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

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

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

def findmin(ab, bc, ca):
  op1 = ab + bc
  op2 = ca + bc
  op3 = ab + ca
  best = min(op1, op2, op3)
  print(best)
  
findmin(ab, bc, ca)

Solution (Python):
from sys import stdin
import numpy as np

P, Q, R = [int(x) for x in stdin.readline().rstrip().split()]

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

print(np.min(time))

Solution (Python):
P,Q,R=map(int,input().split())
a=P+Q
b=Q+R
c=R+P
if a<b:
    if a<c:
        print(a)
    elif c<a:
        print(c)
    else:
        print(c)
elif b<a:
    if b<c:
        print(b)
    elif c<b:
        print(c)
    else:
        print(c)
else:
    if a<c:
        print(a)
    elif c<a:
        print(c)
    else:
        print(c)

Solution (Python):
import numpy as np

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

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

print(min(a, b, c))

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

flightTime.sort()
answer = flightTime[0] + flightTime[1]
print(answer)

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

Solution (Python):



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

print(P+Q)

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

sum = []
for i in range(3):
    for j in range(3):
        if (i != j):
            sum.append(t[i]+t[j])

print(min(sum))

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

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

Solution (Python):



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

min_distance = 10000


distance = P + Q
if distance < min_distance:
    min_distance = distance


distance = R + Q
if distance < min_distance:
    min_distance = distance


distance = P + R
if distance < min_distance:
    min_distance = distance


distance = Q + R
if distance < min_distance:
    min_distance = distance


distance = R + P
if distance < min_distance:
    min_distance = distance


distance = Q + P
if distance < min_distance:
    min_distance = distance

print(min_distance)

Solution (Python):

def main():
    P,Q,R = map(int,input().split())
    X = list()
    XX = 9999999
    X.append(P+Q)
    X.append(P+R)
    X.append(Q+R)
    
    for i in X:
        if XX > i:
            XX = i
    print(XX)
if __name__ == '__main__':
    main()

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

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

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

Solution (Python):



PQR = input()
P = int(PQR.split(' ')[0])
Q = int(PQR.split(' ')[1])
R = int(PQR.split(' ')[2])



result = []
result.append(P+Q)
result.append(P+R)
result.append(R+Q)

print(min(result))

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

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

Solution (Python):
x, y, z = map(int, input().split())
m = x + y
if(m > x + z):
    m = x + z
if(m > y + z):
    m = y + z

print(m)

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

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

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

a.append(p)
a.append(q)
a.append(r)
a.sort()
print(a[0] + a[1])

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

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

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

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

A = p+q
B = q+r
C = p+r
mylist = [A,B,C]

print(min(mylist))

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

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

Solution (Python):
import sys
import itertools

ts = (int(d) for d in sys.stdin.readline().split())
out = [sum((x0, x1)) for (x0, x1) in itertools.permutations(ts, 2)]
print(min(out))

Solution (Python):
lista = input().split(" ")
a, b, c = lista
a = int(a)
b = int(b)
c = int(c)
lista1 = [a, b, c]
lista1.sort()
t = lista1[0]+lista1[1]
print(t)

Solution (Python):
a,b,c =input().split(" ")
mylist = [int(a),int(b),int(c)]
mylist.sort()
print(sum(mylist[0:2]))

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

Solution (Python):


"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(p, q, r):
    
    
    
    
    
    
    e = max(p, q, r)
    if e == p: return q + r
    elif e == q: return p + r
    elif e == r: return p + q
    else:
        assert(True)



do_submit = True


def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    
    
    
    return n


if not do_submit:
    n = input_parse("""
    3
    """)
    print(sol(n))

    n = input_parse("""
    100
    """)
    print(sol(n))

else:
    p, q, r= list(map(int, input().split()))
    
    
    
    
    print(sol(p, q, r))

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):
a = list(map(int, input().split()))

ans = float('inf')

for i in range(3):
    for j in range(3):
        if i != j:
            if ans > a[i] + a[j]:
                ans = a[i] + a[j]

print(ans)

Solution (Python):
old_list=list(input().split())
new_list = sorted(old_list)
res=int(new_list[0])+int(new_list[1])
print(res)

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

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

Solution (Python):

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


N = [P,Q,R]

N.sort()

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

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

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

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

ls.sort()
ls.pop()
print(sum(ls))

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

comb = list(itertools.combinations([p, q, r], 2))
ans = min([sum(i) for i in comb])
print(ans)

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

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

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

Solution (Python):


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


if __name__ == "__main__":
    main()

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())
a = P + Q
b = Q + R
c = P + R
print(min(a,b,c))

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    p, q, r = [int(i) for i in input().split()]
    times = [p, q, r]
    print(sum(times) - max(times))


if __name__ == "__main__":
    main()

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

for i in range(3):
    min_time=min(p+q,r+q,p+r)
    

print(min_time)

Solution (Python):
li = []
x,y,z = map(int,input().split())
li.append(x)
li.append(y)
li.append(z)
li2 = sorted(li)
print(li2[0]+li2[1])

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

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

Solution (Python):
def solve():
    p, q, r = map(int, input().split())
    ab = min(p, r+q)
    bc = min(q, p+r)
    ca = min(r, p+q)
    result = min(ab + bc, bc + ca, ca + ab)
    print(result)

if __name__ == "__main__":
    solve()

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())
li = [p, q, r]

ans = []
for i in range(3):
    for j in range(i+1,3):
        ans.append(li[i] + li[j])
print(min(ans))

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

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

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

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

Solution (Python):
d=input().split()
d=list(map(int,d))
a=d[0]
b=d[1]
c=d[2]
if a+b<=c+a and a+b<=b+c:
    print(a+b)
elif c+b<=c+a and c+b<=b+a:
    print(c+b)
elif a+c<=b+a and a+c<=b+c:
    print(a+c)

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

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

print(out)

Solution (Python):
a=[]
b=[]
for x in input().split():
	a.append(int(x))
    
b.append(a[0]+a[1])
b.append(a[2]+a[1])
b.append(a[0]+a[2])

b.sort()

print(b[0])

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

max_t=max(P,Q,R)

ans=P+Q+R-max_t
print(ans)