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

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

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

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):
def solve(string):
    *pqr, = map(int, string.split())
    return str(sum(sorted((pqr))[:2]))


if __name__ == '__main__':
    print(solve(input()))

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

Solution (Python):
aps = list(map(int, input().split()))
print(min(sum(aps[:i]+aps[i+1:]) for i in range(len(aps))))

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

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

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

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

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

def io_generator():
	return input()
	
def ioByFile(fn='inputFile.txt'):
	with open(fn) as f:
		for line in f:
			yield line[:-1]


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


if __name__ == "__main__":
	io= lambda : io_generator()
	if sys.platform =='ios':
		testInput=ioByFile()
		io=lambda : next(testInput)
	main(io)

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

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

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

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

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

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

ans = min(x, y, z)
print(ans)

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

Solution (Python):
x = input().split()
sum1 = int(x[0]) + int(x[1])
sum2 = int(x[1]) + int(x[2])
sum3 = int(x[0]) + int(x[2])
print(min(sum1, sum2, sum3))

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

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

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

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

Solution (Python):
route_time = [int(i) for i in input().split()]
max_route_time = 0
sum_route_time = 0

for i in route_time:
    if max_route_time < i:
        max_route_time = i
    sum_route_time += i

sum_route_time -= max_route_time

print(sum_route_time)

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

Solution (Python):
a,b,c= (int(i) for i in input().split())

def function(a,b,c):
    sum = a+b+c
    ans = sum - max(a,b,c)
    return ans
  
print(function(a,b,c))

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

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

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

if b > a and c > a:
  print(a)
elif b > c:
  print(c)
else:
  print(b)

Solution (Python):
input_data=input()

X=input_data.split()

P=int(X[0])

Q=int(X[1])

R=int(X[2])

S=max([P,Q,R])

print(P+Q+R-S)

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

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

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

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

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

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

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

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

print(sum)

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

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

Solution (Python):


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

l=[p,q,r]
l.sort()
print l[0]+l[1]

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

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

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

Solution (Python):
import itertools

def main():
    inputs = list(map(int, input().split()))
    print(sum(min(list(itertools.permutations(inputs, 2)))))

if __name__ == '__main__':
    main()

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):
x,y,z = map(int, input().split())
a = [(x+y),(y+z),(x+z)]
min = x+y
for i in range(3):
    if(a[i]<min):
        min = a[i]
        
print(min)

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

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

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

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

print(sum(nums) - max(nums))

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

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

Solution (Python):

import itertools


h = map(int, input().split())

hlist = list(itertools.combinations(h, 2))

tempHour=0
ans=0

for i in range(len(hlist)):
    tempHour=hlist[i][0]+hlist[i][1]
    if tempHour < ans or ans == 0:
        ans = tempHour

print(ans)

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

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

Solution (Python):

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

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

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())))[0:2]))

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

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

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

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

A = a + b
B = b + c
C = c + a

if A < B:
  if C < A:
    print(C)
  else:
    print(A)
elif C < B:
	print(C)    
else:
    print(B)

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

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

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

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

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


if __name__ == '__main__':
	main()

Solution (Python):

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

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

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

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

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

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

Solution (Python):

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

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

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

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

Solution (Python):
s = input().split()
ld = sorted(s, reverse=False)[:2]
s = sum(int(i) for i in ld)
print(s)

Solution (Python):
def toInt(x):
    return int(x)

line = input()
kyori = line.split(" ")
result = sorted(kyori, key = toInt)[:2]

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

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

Solution (Python):
input_first = input()
for k in range(2):
    a = input_first.rstrip().split(' ')
p = int(a[0])
q = int(a[1])
r = int(a[2])
b=sorted(a)
print(int(b[0])+int(b[1]))

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

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20

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

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

ABC = sorted(ABC)

print(sum(ABC[:2]))

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

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

c.remove(max(c))

print(sum(c))

Solution (Python):
s = list(map(int, input().split()))
max = -1

for i in range(0, 3):
    if(max < s[i]):
        max = s[i]
        
ans = s[0] + s [1] + s[2] - max
print(ans)

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

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

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

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

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

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

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

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

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

Solution (Python):
arr = map(int, raw_input().split())
arr.sort()
ans = arr[0] + arr[1]
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()))
print(P+Q+R-max(P,Q,R))

Solution (Python):

import numpy as np

def main(p):
    all = np.sum(p);
    app = list(map(lambda x: -1*(x - all), p));
    print(np.min(app));

if __name__ == '__main__':
    times = list(map(int,input().split()));
    main(times);

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

Solution (Python):
import math
def get_integers(n):
    '''
    Reads in one line of input that contains n integers.
    Returns a list of n integers
    '''
    s = input()
    numbers = s.split(' ')
    r = []
    for x in numbers:
        r.append(int(x))
    return  r

a, b, c = get_integers(3)
 
ab = a+b
bc = b+c
ac = a+c
 
minimum = min(ab,bc,ac)
 
print(minimum)

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

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


 
ab = a+b
bc = b+c
ac = a+c
 
minimum = min(ab,bc,ac)
 
print(minimum)

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

ab = a+b
bc = b+c
ac = a+c

ret = min(ab,bc,ac)

print(ret)

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

Solution (Python):
a,b,c=map(int,raw_input().split())
arr=[]
arr.append(a)
arr.append(b)
arr.append(c)
arr.sort()
print(arr[0]+arr[1])

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

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

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

Solution (Python):
aaa = list(map(int,input().split()))
d = min(aaa)
aaa.remove(d)
e = min(aaa)
print(d + e)

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

Solution (Python):
from itertools import combinations

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

RR = min([a + b for a, b in combinations([P, Q, R], 2)])

print(RR)

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

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

Solution (Python):
a2b , b2c, c2a = map(int,input().split())
if b2c <= a2b and c2a <= a2b:
    print(b2c + c2a)
if a2b < b2c and  c2a <= b2c:
    print(a2b + c2a)
if b2c < c2a and a2b < c2a:
    print(b2c + a2b)

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

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

Solution (Python):

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






timelist = [0 for i in range(3)]

timelist[0],timelist[1],timelist[2] = map(int,input().split())
time = 200
for i in range(3):
    for j in range(i+1,3):
        if( time > (timelist[i]+timelist[j]) ):
            time = (timelist[i]+timelist[j])
print(time)

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

print("{}".format(PQR[0] + PQR[1]))

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

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

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

output = []
output.append(i[0]+i[1])
output.append(i[1]+i[2])
output.append(i[2]+i[0])

print(min(output))

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

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

P=int(P)
Q=int(Q)
R=int(R)

abc=P+Q
bca=Q+R
cab=R+P

print(min(abc,bca,cab))

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

print(sum(times)-max(times))

Solution (Python):
list = [int(i) for i in input().split()] 
s = min(list)
list.remove(s)
t = min(list)
Time = s+t
print(Time)

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

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

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

durations = sorted(durations)

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

Solution (Python):

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

air_list.sort()

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

Solution (Python):
def solve(p, q, r):
    return min([p+q, q+r, r+p])

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

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

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

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

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

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

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

print(sum(ls[:-1]))

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

Solution (Python):
P,Q,R = input().split(' ')
p, q, r = int(P), int(Q), int(R)
a = p + q
a = p + r if a > p + r else a
a = q + r if a > q + r else a
print(a)

Solution (Python):
import collections, heapq, math, sys

p, q, r = map(int, sys.stdin.readline().rstrip().split(' '))

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

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

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

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

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

max_time = max(P, Q, R)
if max_time == P:
    print(Q + R)
elif max_time == Q:
    print(P + R)
else:
    print(P + Q)

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

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

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

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

Solution (Python):
durations = [int(x) for x in input().rstrip(" ").split(" ")]

print( sum(durations) - max(durations))

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

Solution (Python):
p, q, r = map(int, input().split())
lst = [p,q,r]
ans = sum(lst)
for i in range(3):
    for j in range(i+1, 3):
        if lst[i] + lst[j] < ans:
            ans = lst[i] + lst[j]
print(ans)

Solution (Python):

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

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

M = l.index(max(l))

print(l[0]+l[1]+l[2]-l[M])

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

Solution (Python):
s = input().split()
p = int(s[0])
q = int(s[1])
r = int(s[2])

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

mini = 0

if a < b:
    mini = a
else:
    mini = b

if c < mini:
    mini = c

print(mini)

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

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

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

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

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

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

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

Solution (Python):

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

a.sort()

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

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

max_time = max(X)
sum_time = sum(X)
MinSumTime = sum_time-max_time
print(MinSumTime)

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_dis = 0

min_dis = P + Q

tmp = R + Q
if min_dis > tmp:
    min_dis = tmp

tmp1 = P + R
if min_dis > tmp1:
    min_dis = tmp1

print(min_dis)

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

Solution (Python):
ls = [ x for x in map(int, input().split(' ')) ]
ls = sorted(ls)
print(ls[0] + ls[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):
A=[int(i) for i in input().split()]
print(sum(A)-max(A))

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

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

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

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

print(m)

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

PQR.sort()

print(sum(PQR[:2]))

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

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

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

print(min)

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

Solution (Python):
a, b, c = [int(i) for i in input().split()]
d = []

d.append(a + b)
d.append(b + c)
d.append(c + a)

print(min(d))

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

a = P + Q
b = P + R
c = Q + R
d = [a,b,c]

print(min(d))

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

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

Solution (Python):
l=list(input().split())
l_=[int(i) for i in l]

m=max(l_)
l_.remove(m)
print(sum(l_))

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

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())
 
m = 10e9
 
m = min(m, p + q)
m = min(m, r + q)
m = min(m, p + r)
 
print(m)

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

m = 10e9

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

print(m)

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

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

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

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

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

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

ans = min (abs(A+B), abs(B+C), abs(C+A))
print(ans)

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

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


B =[A[0]+A[1],A[0]+A[2],A[1]+A[2]]
tmp = B[0]
for i in range(len(B)):
    if tmp>=B[i]:
        tmp = B[i]


print(tmp)

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

pq = p + q
pr = p + r
qr = q + r

answer = min(pq, pr, qr)

print(answer)

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

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

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

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

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

print(mintime)

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

mintime = p + q + r - max(p,q,r)

print(mintime)

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

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

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

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

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

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

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

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

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

Solution (Python):
input_time = list(map(int, input().split()))
sum_time_l = 200
for i in range(3):

    if i + 1 == 3:
        sum_time = input_time[i] + input_time[0]
    else:
        sum_time = input_time[i] + input_time[i + 1]
    if sum_time_l > sum_time:
        sum_time_l = sum_time

print(sum_time_l)

Solution (Python):

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import exit

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

M = max(P, Q, R)

print(P + Q + R - M)

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

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


print(mind)

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

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


abc()

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

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

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

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

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

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

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

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

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

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

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

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

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())
a,b,c = p+q,q+r,r+p
ho = [a,b,c]
ho.sort()
print(ho[0])

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

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

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

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

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

resolve()

Solution (Python):
ab, bc, ca = [int(x) for x in input().split()]
print( (ab + bc + ca) - max(ab, bc, ca) )

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

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

Solution (Python):
P, Q, R = map(int, input().split())
print(min(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):
l = list(map(int,input().split()))
a = l.pop(l.index(min(l)))
b = l.pop(l.index(min(l)))
print(a+b)

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 = map(int,input().split())
print(min(p+q, p+p+r, q+r, q+q+p, r+p, r+r+q))

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

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

Solution (Python):


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

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

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

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

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

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

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

print(min(times))

Solution (Python):


p = [int(x) for x in input().split()]

p = sorted(p)

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

Solution (Python):
P,Q,R = map(int,input().split())
a1 = P + Q
a2 = P + R
a3 = Q + R
value = 300
if a1 < value:
    value = a1
if value > a2:
    value = a2
if value > a3:
    value = a3
print(value)

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

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

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

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

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

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

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

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

print(result)

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

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

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

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

Solution (Python):
a = [int(i) for i in input().split()]
list=[]
S1 = a[0]+a[1]
S2 = a[1]+a[2]
S3 = a[2]+a[0]
list.append(S1)
list.append(S2)
list.append(S3)

print(min(list))

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

Solution (Python):


P,Q,R = map(int,raw_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):
dist = [int(inp) for inp in input().rstrip().split()]

print(sum(dist) - max(dist))

Solution (Python):

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