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

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

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

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

else:
	print(R+Q)

Solution (Python):
numerosSTR = input().split(" ")
for i in numerosSTR:
    a = int(numerosSTR[0])
    b = int(numerosSTR[1])
    c = int(numerosSTR[2])
minimos=[a,b,c]
k = min(minimos)
minimos.pop(minimos.index(k))
print(k+min(minimos))

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

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

Solution (Python):
line = input()

costs = []
for n in line.split():
    costs.append(int(n))

costs.sort()

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

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

xs = sorted(xs)


flights = xs[0] + xs[1]
print(flights)

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

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

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

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

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

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

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

Solution (Python):


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

l = [p, q, r]
l = sorted(l)

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

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):
T = sorted([int(n) for n in input().split()])
print(sum(T[:2]))

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

Solution (Python):
import sys


def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]

p2D = lambda x: print(*x, sep="\n")


p,q,r = MI()

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

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

print(sum(distance) - max(distance))

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

Solution (Python):
p,q,r=map(int,input().split())
print(min(r+q,p+q,p+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):
def q1():
    from itertools import combinations
    distance = [int(i) for i in input().split()]
    Perm = combinations(distance, 2)
    ans = 10000
    for p in Perm:
        ans = min(ans, sum(p))
    print(ans)


if __name__ == '__main__':
    q1()

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

ans = 10**1000
tmp = 0

for i in range(2):
    for j in range(i+1, 3):
        tmp = A[i] + A[j]
        ans = min(ans, tmp)

print(ans)

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

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

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

print(min(x))

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

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

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

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

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

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

Solution (Python):
import sys
IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))

def main():
    p, q, r = MII()
    print(min(min(p+q, p+r), q+r))

if __name__ == '__main__':
    main()

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

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

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())
if p >= q and p >= r:
    print(q + r)
elif q >= p and q >= r:
    print(p + r)
else:
    print(p + q)

Solution (Python):
inputted = list(map(int, input().split()))
AB = BA = inputted[0]
BC = CB = inputted[1]
AC = CA = inputted[2]

answer = min([
    AB + BC,
    AC + CB,
    BA + AC,
    BC + CA,
    CA + AB,
    CB + BA,
])

print(answer)

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

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

Solution (Python):


import sys
import math
import collections
import itertools
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")

PQR = LI()
PQR.sort(reverse=True)
print(sum(PQR[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()))
l = []
l+=[p,q,r]

l.sort()

l.pop()

print(sum(l))

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

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

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

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

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

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

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

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

l = sorted(l)

d = l[0] + l[1]

print(d)

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

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

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

Solution (Python):

import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A = lr()
answer = sum(A) - max(A)
print(answer)

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

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

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

Solution (Python):

import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)

p, q, r = map(int, readline().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):
n=input().rstrip().split()
n=[int(x) for x in n]
nn=[]
for i in range(len(n)):
  for j in range(len(n)):
    if i!=j:
      nn.append(n[i]+n[j])
print(min(nn))

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

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

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

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

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

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

print(min(li))

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

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

print(sum)

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

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

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

ans.sort()

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

Solution (Python):
from collections import deque
from collections import Counter
from itertools import product, permutations,combinations
from operator import itemgetter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right, bisect




from fractions import gcd
from math import ceil,floor, sqrt, cos, sin, pi, factorial
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')

def main():
  p, q, r = map(int, readline().split())
  print(p+q+r-max(p,q,r))
  
  
  
  
if __name__ == '__main__':
  main()

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

Solution (Python):

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

Solution (Python):
n = input().split()
total_list =[]
a = 0
for i in range(3):
    a = int(n[i-1]) + int(n[i])
    total_list.append(a)
    
print(min(total_list))

Solution (Python):
n = input().split()
total_list =[]
a = 0
for i in range(3):
    a = int(n[i-1]) + int(n[i])
    total_list.append(a)
    
print(min(total_list))

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

Solution (Python):
import itertools
import fractions
def main():
  L = list(map(int,input().split()))
  L = sorted(L)
  print(L[0]+L[1])
  
if __name__ == '__main__':
  main()

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

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

mini = min(a, b)
mini = min(mini, c)

print(mini)

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

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

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

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

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

Solution (Python):
num = list(map(int, input().split()))
ans = 1000
for i in range(3):
  t = num[i-1] + num[i]
  ans = min(t, ans)
print(ans)

Solution (Python):
import sys

*t, = map(int, sys.stdin.readline().split())

def main():
    ans = sum(t) - max(t)
    print(ans)

if __name__ ==  '__main__':
    main()

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

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

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

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

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

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

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

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

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

Solution (Python):
k=list(map(int,input().split()))
k.sort()
print(int(k[0])+int(k[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())
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):
a=tuple(map(int,input().split()))
print(sum(a)-max(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,Q+R,P+R))

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

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

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

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

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

sorted(ans)
print(P+Q+R-max(ans))

Solution (Python):
from itertools import combinations

l = list(map(int,input().split()))
tmp = list(combinations(l,2))

res = 10**10
for i in tmp:
    m = sum(i)
    if res > m:
        res = m

print(res)

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

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

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

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

Solution (Python):

import sys


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



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

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

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

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

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

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

Solution (Python):

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





lst2 = sorted(lst)


D = lst2[0] + lst2[1]
print(D)

Solution (Python):












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

ans = 11000
for i in range(len(arr)):
    for j in range(i+1,len(arr)):
        num = arr[i]+arr[j]
        ans = min(ans,num)

print(ans)

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

print(min(time)+sorted(time)[-2])

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

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

Solution (Python):
s,t,u=sorted(map(int,input().split()));print(s+t)

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

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

Solution (Python):
def solve():
    N, M, L = map(int, input().split())
    return min(N+M, M+L, L+N)

print(solve())

Solution (Python):
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *
from math import *

sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()

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

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

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

Solution (Python):
a = [int(i) for i in input().split()]
print(min(a) + min([a[i] for i in range(len(a)) if i != a.index(min(a))]))

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

Solution (Python):
p,q,r = map(int, input().split())
abc = p + q
acb = r + q
bac = p + r

shortest = min(abc,acb,bac)
print(shortest)

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

lis = sorted(lis)

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

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

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

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

a_n = sorted(a_n)

print(a_n[0] + a_n[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):


def main():
    p, q, r = map(int, input().split())
    
    resList = [p+q, p+r, q+r]

    print(min(resList))

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
l=[int(x) for x in input().rstrip().split()]
ans=100000000
for i in range(3):
    for j in range(3):
        if i!=j:
            ans=min(ans,l[i]+l[j])
print(ans)

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

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

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

Solution (Python):
ab , bc , ca = map(int , input(). split())
print(ab + bc + ca - max(ab , bc , ca))

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

A.sort()

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

Solution (Python):
l = list(map(int, input().split()))
total = 0
for _ in range(2):
    total += min(l)
    l.remove(min(l))
print (total)

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

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

print(ans)

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

print(sum(pqr[:2]))

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

Solution (Python):
from itertools import combinations as comb
import numpy as np


def main():
    p, q, r = map(int, input().split())
    abc_comb = np.array(list(comb([p, q, r], 2)))
    print(np.min(np.sum(abc_comb, axis=1)))


if __name__ == "__main__":
    main()

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

Solution (Python):
P = list(map(int,input().split()))
ans = []
for i in range(3):
    for j in range(3):
        if i == j:
            continue
        ans.append(P[i]+P[j])
ans.sort()
print(ans[0])

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

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

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

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):
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(lst) - max(lst))

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

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

Solution (Python):

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

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

Solution (Python):
from sys import stdin

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

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

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

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

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

print(min(li))

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

Solution (Python):

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

m=99999

for v in itertools.combinations([P,Q,R],2):
    m=min(m,v[0]+v[1])
    

print(m)

Solution (Python):

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

m=99999
for v in itertools.permutations([P,Q,R],2):
    m=min(m,v[0]+v[1])

print(m)

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

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

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

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

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

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())
pql = [P,Q,R]
mpath = 400

for i in range(3):
    for j in range(3):
        if i == j:
            pass
        else:
            path_len = pql[i]*2 + pql[j]
            if path_len < mpath:
                mpath = path_len
            path_len = pql[i] + pql[j]
            if path_len < mpath:
                mpath = path_len
                
print(mpath)

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

Solution (Python):

from collections import Counter, deque







import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    p, q, r = list(map(int,ipti().split()))

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


if __name__ == '__main__':
    main()

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

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

ans = 100100100
for x, y in itertools.combinations([p, q, r], 2):
    ans = min(ans, x+y)
print(ans)

Solution (Python):
P, Q, R = [int(i) for i in input().strip().split()]
res = P + Q
res = min(res, Q + R)
res = min(res, R + P)
print(res)

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

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

Solution (Python):
from sys import stdin

t = [int(x) for x in stdin.readline().rstrip().split()]
t.remove(max(t))
print(sum(t))

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

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

sums = [P,Q,R]
sums.sort()
print(sums[0] + sums[1])

Solution (Python):


P,Q,R = list(map(int, input().rstrip().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(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):
a,b,c=map(int,input().split())
d=int(a+b)
e=int(a+c)
f=int(b+c)

print(min(d,e,f))

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

lis.sort()

print(lis[0]+lis[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):
print(sum(sorted(map(int,input().split()))[:2]))

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

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

Solution (Python):

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

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

Q=sorted(P)

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

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

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

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

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

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

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

print(sum(pqr) - max(pqr))

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

Solution (Python):



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

if __name__=='__main__':
  main()

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

Solution (Python):
p, q, r = map(int, input().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())

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

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

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

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

mn = 200
for i in range(2):
    for j in range(i+1,3):
        if (p[i]+p[j] < mn):
            mn = p[i]+p[j]

print(mn)

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

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

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

print(min(x))

Solution (Python):
number = input().split(" ")
P = int(number[0])
Q = int(number[1])
R = int(number[2])
ans = []
ans.append(int(P+Q))
ans.append(int(P+R))
ans.append(int(Q+R))
ans.sort()
print(ans[0])

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

temp1 = min(PQ, QR)
temp2 = min(temp1, RP)

print(temp2)

Solution (Python):


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

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

Solution (Python):
import itertools
lst = list(map(int, input().split()))
ans = float("INF")

for i in itertools.combinations(lst, 2):
    ans = min(ans, sum(i))

print(ans)

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

s = sorted(LIST())
print(s[0]+s[1])

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

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

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

print(min(a, b, c))

Solution (Python):
S=list(map(int,input().split()))
min=10**4
for i in range(3):
    time=sum(S)-S[i]
    if time<min:
        min=time
print(min)

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

Solution (Python):
import itertools
a=list(map(int,input().split()))
k=[]
for v in itertools.combinations(a,2):
    k.append(v[0]+v[1])
print(min(k))

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):
p, q, r = map(int, input().split())
s = sorted([p, q, r])
print(s[0] + s[1])

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