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):
def main(): 
    
    P = sorted(map(int, input().split()))

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


if __name__ == "__main__":
    main()

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

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

Solution (Python):


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

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

for i in range(3):
  for j in range(i+1,3,1):
    min_r=min(r_l[i]+r_l[j],min_r)

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

x=sorted(x)
print(x[0]+x[1])

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

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

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

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

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

time_list = []
time_list.append(list[0] + list[1])
time_list.append(list[2] + list[1])
time_list.append(list[0] + list[2])
print(min(time_list))

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

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

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

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

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

print(min(list))

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()))
print(sorted(time)[0] + sorted(time)[1])

Solution (Python):
p,q,r=map(int,input().split())
print(min(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 = (int(x) for x in input().split(' '))

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations
import sys
import string


INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LIM(): return list(map(lambda x:int(x) - 1, sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def LIRM(n): return [LIM() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
mod = 1000000007


a, b, c = LI()
print(min([i + j for i, j in list(combinations([a, b, c], 2))]))

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

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

total=int(S[0])+int(S[1])
print(total)

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

Solution (Python):
l = list(map(int, input().split()))
w = l
res = 200
for i in range(len(l)):
    for j in range(len(l)):
        if l[i] + l[j] < res and i != j:
            res = l[i] + l[j]
print(res)

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

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

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

a,b,c=x[0],x[1],x[2]

sumaA_B = a+b
sumaA_C = a+c
sumaB_C = b+c

r1 = min(sumaA_B,sumaA_C)
rt = min(r1,sumaB_C)

print(rt)

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

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):
from sys import stdin

p, q, r = [int(x) for x in stdin.readline().rstrip().split()]
print(min(p+q, p+r, q+r))

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

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

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

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

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

Solution (Python):
import itertools

while True:
    try:
        P, Q, R = map(int, input().split())
        
        print(min([sum(c) for c in itertools.combinations([P, Q, R], 2)]))
        
    except:
        break

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,p+r))

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

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

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

if __name__ == '__main__':
    main()

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

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

print(ans)

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

Solution (Python):
PQR = list(map(int, input().split()))
PQR.sort()
print(int(sum(PQR[: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, input().split())
print(min([p+q, q+r, r+p]))

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

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

Solution (Python):
p,q,r = map(int, input().split())
print(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):
l = list(map(int,input().split()))
l.sort()
print(l[0]+l[1])

Solution (Python):


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


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


print(res)

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

Solution (Python):
d = list(map(int, input().split()))
print(sum(sorted(d)[:-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):
list_ = list(map(int, input().split(' ')))

list_.sort()

ans = sum(list_[:2])

print(ans)

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

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

print(sum(m)-max(m))

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

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

Solution (Python):
pqr = list(map(int, input().split()))
print(sum(sorted(pqr)[: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())

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

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

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

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

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

Solution (Python):

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

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

print(min(path_list))

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):
def main():
    A, B, C = list(map(int, input().split()))
    print(min(A+B, min(A+C, B+C)))

main()

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

max = p
if max < q:
    max = q
if max < r:
    max = r
print(p+q+r-max)

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

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

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

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

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

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

Solution (Python):
p,q,r = sorted(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,r+q,p+r,q+r,r+p,q+p))

Solution (Python):
res = input().split()
map(int, res)
q = res
cand = []
while len(q) > 0:
    now = q[0]
    q.pop(0)
    b = [x for i, x in enumerate(res) if i != now]
    for i in range(len(b)):
        cand.append(int(now) + int(b[i]))
print(min(cand))

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

Solution (Python):
res = input().split()
map(int, res)
q = res
cand = []
while len(q) > 0:
    now = q[0]
    q.pop(0)
    b = [x for i, x in enumerate(res) if i != now]
    for i in range(len(b)):
        cand.append(int(now) + int(b[i]))
print(min(cand))

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,p+r,q+r))

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

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

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

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

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

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

x = []
x.append(P)
x.append(Q)
x.append(R)
x.sort()
print(x[0] + x[1])

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

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

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

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

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

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()))
print(sum(a) - max(a))

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

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

Solution (Python):
P,Q,R = (int(a) for a in input().split())
if P<Q:
    if Q<R:
        print(P+Q)
    else:
        print(P+R)
else:
    if P<R:
        print(P+Q)
    else:
        print(Q+R)

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

Solution (Python):

import sys


def solve(P: int, Q: int, R: int):
    a = sorted([P, Q, R])
    print(a[0] + a[1])
    return


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

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
import numpy as np
a = input().split()
p, q, r = map(lambda x: int(x), a)
print(np.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):
import sys
input = sys.stdin.readline
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):
P,Q,R = sorted(list(map(int,input().split())))
print(P+Q)

Solution (Python):
p = sorted(map(int, input().split()))
p.pop()
print(sum(p))

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

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

Solution (Python):
P,Q,R = map(int,input().split())
print(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):
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, p+r]))

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):
p,q,r=[int(i) for i in input().split()]
print(min(p+q,q+r,p+r))

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

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

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

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

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

resolve()

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

print(sum(temp)-max(temp))

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

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

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

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

Solution (Python):
time = list(map(int, input().split()))
sum = sum(time)
ans = [0] * 3

for i in range(3):
    ans[i] = sum - time[i]
print(min(ans))

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

Solution (Python):
a,b,c=map(int,input().split())
d=a+b
e=b+c
f=c+a
list={d,e,f}
print(min(list))

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

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    p,q,r = map(int, input().split())
    
    answer = min(p+q,q+r,r+p)
    print(answer)
    
    
main()

Solution (Python):
p, q ,r = map(int, input().split())
if 1 <= p <= 100 and 1 <= q <= 100 and 1 <= r <= 100:
    print(min(p+q, p+r, q+r))
else:
    print('Invalid value')

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

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

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

if __name__ == '__main__':
    print(main())

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

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

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

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

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

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

res = P + Q + R - max(P, Q, R)

print(res)

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

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

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


candidacy1 = P + Q
candidacy2 = R + Q
candidacy3 = P + R

result = candidacy1
if result > candidacy2:
    result = candidacy2

if result > candidacy3:
    result = candidacy3

print(result)

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

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

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

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

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

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

ans = sum(cost_list) - max(cost_list)
print(ans)

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

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

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

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

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

r1 = p + q
r2 = q + r
r3 = p + r

print(min(r1, r2, r3))

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()))
p = l[0]
q = l[1]
r = l[2]
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):
times = list(map(int, input().split()))
print(sum(times) - max(times))

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

s = [a,b,c]

s = sorted(s)

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

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

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

Solution (Python):

import sys


def solve(P: int, Q: int, R: int):
    print(min(P + Q, Q + R, R + P))
    return



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

if __name__ == '__main__':
    main()

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

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

print (min(n1+n2,n3+n2, n1+n3))

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

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

print (min(n1+n2,n3+n2, n1+n3))

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

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

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

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

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

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, p+r, q+r))

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

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

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

Solution (Python):
num = [int(i) for i in input().split()]
print(min([num[0] + num[1], num[1] + num[2], num[2] + num[0]]))

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

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

Solution (Python):



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





pqr = sorted(pqr)



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

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

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

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

if a<=b and a<=c:
	print(a)
elif b<=a and b<=c:
	print(b)
else:
	print(c)

Solution (Python):

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

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

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

nums.sort()

res = nums[0] + nums[1]

print(res)

Solution (Python):
def test():
    p = list(map(int,input().split()))
    result = 0

    for i in range(len(p)-1):
        result += min(p)
        p.remove(min(p))

    print(result)


if __name__ == "__main__":
    test()

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

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

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

Solution (Python):
print(sum(sorted(list(map(int,input().split())))[: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,input().split())
print(min(P+Q,min(P+R,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):
p, q, r = map(int, input().split())
print(p + q + r - max(p, q, r))

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

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

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

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

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

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

Solution (Python):

input = input().split()


a = int(input[0])
b = int(input[1])
c = int(input[2])



list = [a+b, b+c ,c+a]

ans = min(list)
print(ans)

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

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

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

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

cs=sorted(c)

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

Solution (Python):

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

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

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

Solution (Python):

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

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


if __name__ == "__main__":
    print(solve())

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

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

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

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

Solution (Python):


def main(P, Q, R):
    total = P + Q + R
    ans = total - max(P, Q, R)
    return ans

if __name__ == '__main__':
    P, Q, R = list(map(int, input().split()))
    print(main(P, Q, R))

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

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

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):
lst = list(map(int, input().split()))
print(sum(sorted(lst)[:2]))

Solution (Python):
pqr=[int(x) for x in 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):
p, q, r = map(int, input().split())
sorted_list = sorted([p, q, r])
ans = sorted_list[0] + sorted_list[1]
print(ans)

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

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

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

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

print(sum(n)-max(n))

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

Solution (Python):

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

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

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

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

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

print(sum(t)-max(t))

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

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

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

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

sum1 = sum - P
sum2 = sum - Q
sum3 = sum - R

answer = min(sum1, sum2, sum3)

print(answer)

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

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

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

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

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

print(a+b)

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

PQR.remove(max(PQR))
ans = sum(PQR)
print(ans)

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

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

Solution (Python):

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

Solution (Python):


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

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

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

Solution (Python):


import os
import sys

P, Q, R = map(lambda x: int(x), input().split(" "))

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

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

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

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

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

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

Solution (Python):
S = input()

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

S.sort()

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

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

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


main()

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

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

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

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

LEN = 3
abc_sum = 0
for i in range(len(num_list) - 1):
  abc_sum += num_list[i]

bca_sum = 0
reversed_list = list(reversed(num_list))
for i, num in enumerate(reversed_list, 1):
  if i == LEN:
    break
  bca_sum += num

cab_sum = 0
cab_sum += num_list[-1]
cab_sum += num_list[0]

l = [abc_sum, bca_sum, cab_sum]

print(min(l))

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

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

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

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

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

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

time.sort()

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