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, b, c = map(int, input().split())

l = list()
cost = list()

l.append(a)
l.append(b)
l.append(c)

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

print( min(cost) )

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

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

Solution (Python):


p, q ,r = [int(x) for x in input().split()]
max_length = max(p,q,r)
if max_length == p:
    print(q+r)
elif max_length == q:
    print(p+r)
else:
    print(p+q)

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

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

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

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(sum([P,Q,R]) - max(P,Q,R))

Solution (Python):
s = list(map(int,input().split()))
lst = []
for i in s:
  a = sum(s) - i
  lst.append(a)
print(min(lst))

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

kotae=sum(x)-max(x)
print(kotae)

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

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

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

Solution (Python):
data = list(map(int, input().split()))
n = len(data)
res = 300
for i in range(n-1):
  for j in range(i+1, n):
    if data[i] + data[j] < res:
      res = data[i] + data[j]
print(res)

Solution (Python):
p,q,r = map(str,input().split())
x =int(p)+int(q)
y = int(p)+int(r)
z = int(r)+int(q)
l = []
l.append(x)
l.append(y)
l.append(z)

print(min(l))

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

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

print(min([A,B,C]))

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

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

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

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

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

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

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

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

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

Solution (Python):
import itertools
a = list(map(int, input().split()))
b = list(itertools.permutations(a, 2))
ans = 201
for i in b:
    ans = min(ans, (i[0]+i[1]))
print(ans)

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

Solution (Python):
a = [ int(i) for i in input().split()]
b = []
for i in range(3):
    b.append(a[i-1]+a[i])
print(min(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(p+q+r-max(p,q,r))

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

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):
A = list(map(int, input().split()))
A.sort()
print(A[0]+A[1])

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

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

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

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

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

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

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

Solution (Python):
N=list(map(int,input().split()))
ans=[]
for i in range(len(N)-1):
  for j in range(i+1, len(N)):
    A=N[i]+N[j]
    ans.append(A)
    
print(min(ans))

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

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

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

Solution (Python):
def main17():
    data = input().split()
    num = []
    for i in range(3):
        num.append(int(data[i]))
    num2 = []
    num2.append((num[0]+num[1]))
    num2.append((num[0]+num[2]))
    num2.append((num[2]+num[1]))
    print((min(num2)))

if __name__ == "__main__":
    main17()

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

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

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

Solution (Python):
import math



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



s = p + q + r
print(s - max([p, 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())
print(P+Q+R - max(P,Q,R))

Solution (Python):
def A_Airplane():
    time_list = list(map(int, input().split()))
    time_max = max(time_list)
    time_list.remove(time_max)
    print(sum(time_list))

if __name__ == "__main__":
    A_Airplane()

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

print(sum(seq) - seq[0])

Solution (Python):

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


print(sum(flight[0: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())

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

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

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

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

print(min(sum))

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

Solution (Python):

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

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())
ab = a + b
bc = b + c
ca = c + a
print(min(ab, bc, ca))

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

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

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

print(sum1-max1)

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

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

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

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):
P, Q, R = map(int, input().split())
calc = [P+Q, Q+R, R+P]
print(min(calc))

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

print(sum(d)-max(d))

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,R]
Y=[]
for i in range(0,2):
    for j in range(i+1,3):
       
        Y.append(X[i]+X[j])

 
 

print(min(Y))

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

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

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

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

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):
P, Q, R = map(int, input().split())

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

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

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

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

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

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

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

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

Solution (Python):


A_B, B_C, C_A = (int(a) for a in input().split())

ans = (A_B + B_C + C_A) - max(A_B, B_C, C_A)
print(ans)

Solution (Python):
get = input().split()
P = int(get[0])
Q = int(get[1])
R = int(get[2])

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

print(min(A, B, C))

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

num = [int(i) for i in num]
num_fix = sorted(num)
print(num_fix[0]+num_fix[1])

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

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

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

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    a,b,c = LI()
    ans = 10 ** 5
    ans = min(ans, a + b)
    ans = min(ans, a + c)
    ans = min(ans, c + b)
    print(ans)
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

Solution (Python):
x =  [int(s) for s in input().split()]
min = x[0] + x[1]
for s in range(len(x)):
    if(s != len(x)-1):
        if(x[s] + x[s+1] < min):
            min = x[s] + x[s+1]
    elif(s == len(x)-1):
        if(x[s] + x[0] < min):
            min = x[s] + x[0]
    
print(min)

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

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

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

Solution (Python):
import logging

logging.basicConfig(level=logging.INFO, format="%(message)s")
logging.disable(logging.CRITICAL)

P, Q, R = (int(x) for x in input().split())
l_time =[P + Q, P + R, Q + R]

print(min(l_time))

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

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

P=ini[0]
Q=ini[1]
R=ini[2]

ans=P+Q+R-max(ini)

print(ans)

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

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

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

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

def main():
	v = list(map(int, input().strip().split()))
	v.sort()
	print(v[0]+v[1])

if __name__ == '__main__':
	main()

Solution (Python):
p, q, r =(int(i) for i in input().split())
ans1=p+q
ans2=q+r
ans3=p+r

if ans1<=ans2 and ans1<=ans3:
    print(ans1)
elif ans2<= ans1 and ans2 <= ans3:
    print(ans2)
else:
    print(ans3)

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

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())
l=[p+q,q+r,r+p]
print(min(l))

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


min_dist = 999
for i in range(len(l) - 1):
    for j in range(i + 1, len(l)):
        if l[i] + l[j] < min_dist:
            min_dist = l[i] + l[j]
print(min_dist)

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

Solution (Python):
s=input().split()
p=int(s[0])
q=int(s[1])
r=int(s[2])
air=[p,q,r]
mn1=min(air)
air.remove(mn1)
mn2=min(air)
print(mn1+mn2)

Solution (Python):
import itertools

a = list(map(int, input().split()))
b = sum(a)
for i in itertools.permutations(a, 2):
    b = min(b, i[0] + i[1])
print(b)

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

i.sort();

print(i[0]+i[1]);

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

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

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

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

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

print(min(ans))

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

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

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

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())
dis = [P,Q,R]
dis.sort()
print(dis[0]+dis[1])

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

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





t = [P, Q, R]
print(sum(t)-max(t))

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

print(sum([a,b,c])-max(a,b,c))

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

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

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(L[0]+L[1])

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

print(sum(l) - max(l))

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

print(ans)

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

print(sum(l) - max(l))

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

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

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

if min > p + r:
    min = p + r

print(min)

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().split())))
pq=p+q
qr=q+r
rp=r+p
print(min([pq,qr,rp]))

Solution (Python):
n=input().split()
if int(n[0])+int(n[1]) <= int(n[1])+int(n[2]):
  if int(n[0])+int(n[1]) <= int(n[2])+int(n[0]):
    print(int(n[0])+int(n[1]))
  else:
    print(int(n[2])+int(n[0]))
else:
  if int(n[1])+int(n[2]) <= int(n[2])+int(n[0]):
    print(int(n[1])+int(n[2]))
  else:
    print(int(n[2])+int(n[0]))

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

time.remove(max(time))

print(sum(time))

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

line = [p + q, p + r, q + r]

line = sorted(line)

print(line[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())
a = p+q
b = q+r
c = p+r
print(min(a,b,c))

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

print(ans)

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

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

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

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

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

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

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

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

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()]
if P+Q <= Q+R and P+Q <= P+R:
    print(P+Q)
elif Q+R <= P+Q and Q+R <= P+R:
    print(Q+R)
elif P+R <= Q+R and P+R <= P+Q:
    print(P+R)

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

Solution (Python):
p,q,r = map(int,input().split())
print(q+p+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()))
b = 0
for i in range(len(a)):
    for j in range(len(a)):
        if i != j:
            if b == 0:
                b = a[i] + a[j]
            else:
                b = min(b, a[i] + a[j])
print(b)

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,P + R]))

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

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

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

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

Solution (Python):
P,Q,R = list(map(int,input().split()))
ABC=P+Q
ACB=R+Q
BAC=P+R
BCA=Q+R
CAB=R+P
CBA=Q+P
print(min([ABC,ACB,BAC,BCA,CAB,CBA]))

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

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

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

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

def Seekmin(x,y,z):
  min = x + y
  if x+y <= y+z and x+y <= x+z:
    return x+y
  elif x+y >= y+z and z+y <= x+z:
    return y+z
  else:
    return x+z
  
print(Seekmin(x,y,z))

Solution (Python):
AB, BC, AC = [int(_) for _ in input().split(" ")]

M = [[0, AB, AC],
     [AB, 0, BC],
     [AC, BC, 0]]

def A(l):
    t = [0] * l
    def Sub(targetList, n):
        if 1:
            if len(targetList) == 1:
                t[n] = targetList[0]
                yield t
                t[n] = 0
            for i in range(len(targetList)):
                p = targetList[:i] + targetList[i+1:]
                t[n] = targetList[i]
                for j in Sub(p, n+1):
                    yield j
        else:
            pass
    
    for i in (Sub(tuple(range(l)), 0)):
        yield i

def Calc(list):
    _sum = 0
    for index in range(1, len(list)):
        _from = list[index-1]
        _to = list[index]
        _sum += M[_from][_to]
    return _sum

_min = Calc([0,1,2])
for i in A(3):
    _sum = Calc(i)
    if _min > _sum:
        _min = _sum
print (_min)

Solution (Python):
l = [int(_) for _ in raw_input().split(" ")]
l.sort()
print l[0] + l[1]

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

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

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()))
a.sort()
print(sum(a[0:2]))

Solution (Python):
import sys

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

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

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

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

Solution (Python):
import itertools
PQR=list(map(int,input().split()))
kyori = list(itertools.permutations(PQR,2))
kyori_minimum = min([sum(k) for k in kyori])
print(kyori_minimum)

Solution (Python):
A,B,C=map(int,input().split())
M=max(A,B,C)
ans=A+B+C-M
print(ans)

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

Solution (Python):
a, b, c = map(int, raw_input().split())
x = a
if x < b:
    x = b
if x < c:
    x = c
y = a + b + c
print y - x

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

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

Solution (Python):





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

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

Solution (Python):



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


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

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

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

    p.sort()

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

if __name__ == '__main__':
    main()

Solution (Python):
def main():
  m = 10000000
  times = list(map(int, input().split()))
  for i in range(len(times)):
    for j in range(i + 1, len(times)):
      m = min(m, times[i] + times[j])
  print(m)


main()

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

Solution (Python):
li = list(map(int, input().split()))
li = sorted(li)
s = 0
for i in range(2):
    s += li[i]
print(s)

Solution (Python):
p,q,r=map(int,input().split())
print("{}".format(p+q+r-max([p,q,r])))

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

if minimum_time > Q + R:
  minimum_time = Q + R
if minimum_time > R + P:
  minimum_time = R + P

print(minimum_time)

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

distances.sort()

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

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

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

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

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2



def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)



def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


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


if __name__ == '__main__':
    main()

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

Solution (Python):



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

Solution (Python):
from sys import stdin

arr = [int(x) for x in stdin.readline().rstrip().split()]

arr.sort()

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

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

s=a+b+c
s-=max(a,b,c)

print(s)

Solution (Python):
A, B, C = map(int,input().split())
print(sum([A,B,C])-max(A,B,C))

Solution (Python):
ls = sorted([x for x in map(int, input().split(' '))])
print(ls[0] + ls[1])

Solution (Python):
A, B, C = map(int,input().split())
print(sum([A,B,C])-max(A,B,C))

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

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

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

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

p1 = p + q
p2 = p + r
p3 = q + r


P = [p1,p2,p3]
print(min(P))

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

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

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

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

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

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

Solution (Python):
S = list(map(int, input().split()))
S.sort()
S.pop()
print(sum(S))

Solution (Python):







line = input().split()
ab = int(line[0])
bc = int(line[1])
ca = int(line[2])


time = [ab, bc, ca]
min_time = sum(time) - max(time)

print(min_time)

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

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

ans = sum([p, q, r]) - max(p, q, r)
print(ans)

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

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

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

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

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(a+b+c-max(a,b,c))

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

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

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

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

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

print(min_time)

Solution (Python):
from sys import stdin
from collections import defaultdict

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

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

Solution (Python):
import itertools

arr = [int(i) for i in input().split()]
arrs = list(itertools.combinations(arr,2))
sum_arr = [sum(com) for com in arrs]

print(min(sum_arr))

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

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()]
pqr.sort()
print(pqr[0]+pqr[1])

Solution (Python):
a,b,c = map(int, input().split())
x = a+b
y = b+c
z = c+a
if x <= y and x <= z:
  print(x)
elif y <= x and y <= z:
  print(y)
elif z <= x and z <= y:
  print(z)

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

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

Solution (Python):


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

li = [p,q,r]
li_new = sorted(li)
total = li_new[0] + li_new[1]

print(total)

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

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

Solution (Python):

min = 0
L = list(map(int,input().split()))
for i in range(len(L)):
    min += L[i]
for i in range(3):
    for j in range(3):
        if i != j:
            if L[i]+L[j] < min :
                min = L[i]+L[j]
print(min)

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

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

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

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

Solution (Python):

import bisect
from collections import defaultdict

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

if __name__ == '__main__':
    main()

Solution (Python):
from itertools import combinations
p = [int(x) for x in input().split()]
print(min(sum(x) for x in combinations(p, 2)))

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

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

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

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

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

s=[]

s.append(p+q)
s.append(r+q)
s.append(p+r)


ans=min(s)
print(ans)