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



Sample input:
1 3 4


Sample output:
4

Submission status: Accepted

Solution code:
I = list(map(int,input().split()))

I.sort()
print(sum(I[:2]))

Submission status: Accepted

Solution code:
#input
import itertools

a = list(map(int,input().split())) #input from array of integer like "1 2 3"
ans = []
for i in itertools.permutations(a, r=2):
    ans.append(sum(list(i)))

print(min(ans))

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
l = list(map(int,input().split()))
l.sort()
print(l[0] + l[1])

Submission status: Accepted

Solution code:
# n=int(input())
# a,b=map(int, input().split())
# c=list(map(int, input().split()))
# s=[list(map(int,list(input()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき

# a=100
# b=0.987654321
# print('{0:06d}-{1:6f}'.format(a,b))  # 0埋めのときの出力
# 000100-0.987654

import numpy as np
import math
import copy

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

m = 1000

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

print(m)

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))

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

Submission status: Accepted

Solution code:
import numpy as np
P, Q, R = [int(j) for j in input().split()]

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

Submission status: Accepted

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

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

Submission status: Accepted

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

list.sort()

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

Submission status: Accepted

Solution code:
P, Q, R = map(int, input().split())
list = []
list.append(P)
list.append(Q)
list.append(R)
newlist = sorted(list)
ans = newlist[0]+newlist[1]
print("{}".format(ans))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

one = P + Q
two = Q + R
three = R + P

min = one
if two < one:
    min = two
if three < min:
    min = three

print(min)

Submission status: Accepted

Solution code:
import itertools
x,y,z = map(int,input().split())
seq = (x, y,z)


a = list(itertools.combinations(seq,2))
c = [sum(b) for b in a]

print(min(c))

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
P, Q, R = (int(i) for i in input().split())

x = P+Q
y = Q+R
z = R+P

print(min([x,y,z]))

Submission status: Accepted

Solution code:
import sys

p, q, r = map(int, input().split())
if p <= q <= r:
    print(p + q)
elif p <= r <= q:
    print(p + r)
elif q <= p <= r:
    print(p + q)
elif q <= r <= p:
    print(r + q)
elif r <= p <= q:
    print(p + r)
elif r <= q <= p:
    print(r + q)

Submission status: Accepted

Solution code:
P, Q, R = map(int, input().split())
max_distance = max(max(P, Q), R)

print(P + Q + R - max_distance)

Submission status: Accepted

Solution code:
P, Q, R = map(int, input().split())
tmp1 = P + Q
tmp2 = R + Q
tmp3 = P + R
ans = min(tmp1, tmp2, tmp3)
print(ans)

Submission status: Accepted

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

p.sort()

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

print(list[0])

Submission status: Accepted

Solution code:
p,q,r = (int(i) for i in input().split())
min = 1000
x = [p+q,q+r,r+p]
for i in x:
    if(i<min):
        min=i
print(min)

Submission status: Accepted

Solution code:
inputs = list(map(int, input().split()))
P,Q,R = inputs
li = [0 for i in range(3)]
li[0]=P+Q
li[1]=P+R
li[2]=Q+R
li = sorted(li)
print(li[0])

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' 
------------------------
author : iiou16
------------------------
'''

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

    aa = []
    aa.append(P + Q)
    aa.append(P + R)
    aa.append(Q + R)
    # print(aa)
    print(min(aa))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

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

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

fly = []
fly.append(A)
fly.append(B)
fly.append(C)

print(min(fly))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

PQR = [P, Q, R]
PQR_sorted = sorted(PQR)

print(sum(PQR_sorted[0:2]))

Submission status: Accepted

Solution code:
p,q,r = map(int,input().split())
a1 = p + q
a2 = p + r
a3 = q + r
a = [a1, a2, a3]
print(min(a))

Submission status: Accepted

Solution code:
arr = list(map(int, input().split()))
arr.sort()
print(sum(arr[:-1]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
list_num = [int(num) for num in input().split()]
list_num.sort(reverse=False)

print(str(list_num[0]+list_num[1]))

Submission status: Accepted

Solution code:
route = input().split()
route.sort()
min = int(route[0]) + int(route[1])
print(min)

Submission status: Accepted

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

times = [P,Q,R]
lst = sorted(times)

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

Submission status: Accepted

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

list = [p,q,r]
slist = sorted(list)
print(slist[0]+slist[1])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
yama = []
yama = list(map(int, input().split()))

print(yama[0]+yama[1]+yama[2]-max(yama))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = [int(x) for x in input().split()]
s.sort()

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

Submission status: Accepted

Solution code:
X=list(map(int,input().strip().split(' ')))
X=sorted(X)
print(X[0]+X[1])

Submission status: Accepted

Solution code:
time_list = list(map(int, input().split(' ')))

time_list.sort()
print(time_list[0] + time_list[1])
exit(0)

Submission status: Accepted

Solution code:
times = [int(x) for x in input().split(' ')]
times.sort()
print(sum(times[:-1]))

Submission status: Accepted

Solution code:
import sys
a, b, c = map(int, input().split())

d = a + b
e = b + c
f = c + a

if d <= e and d <= f:
    print(d)
    sys.exit()
if e <= d and e <= f:
    print(e)
    sys.exit()
if f <= e and f <= d:
    print(f)
    sys.exit()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = list(map(int, input().split()))

tsum = min(n)
n.remove(min(n))
tsum += min(n)

print(tsum)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

pq=P+Q
pr=P+R
qr=Q+R
list=[pq,qr,pr]
print(min(list))

Submission status: Accepted

Solution code:

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/Library/Frameworks/Python.framework/Versions/3.5/bin/python3

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

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

Submission status: Accepted

Solution code:
import numpy as np
inp = input()
p = int(inp.split()[0])
q = int(inp.split()[1])
r = int(inp.split()[2])

pq = p + q
qr = q + r
rp = r + p

a = np.array([pq, qr, rp])

print(np.min(a))

Submission status: Accepted

Solution code:
A = [int(i) for i in input().split()]
A.sort()

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

Submission status: Accepted

Solution code:
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    A = InputToInt()
    A.sort()
    print(A[0]+A[1])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
ll = lambda: list(map(int, input().split()))
testcases = 1
# testcases = int(input())
for testcase in range(testcases):
    [p,q,r] = ll()
    print(p+q+r-max(p,q,r))

Submission status: Accepted

Solution code:
import sys,collections,math,random;sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a = Is()
print(sum(a)-max(a))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# 整数の入力
p, q, r  = map(int, input().split())
numlist = [p, q, r]
print( p + q + r - max(numlist))

Submission status: Accepted

Solution code:
list_x = list(map(int,input().split()))
ans = sum(list_x) - max(list_x)
print(ans)

Submission status: Accepted

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

arr = [P, Q, R]

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

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
max = 0
for i in [a, b, c]:
  if i > max:
    max = i
print(a+b+c-max)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys;
import string;
sys.setrecursionlimit(20000) # 再起呼び出しの最大数をセット

import copy
import itertools

from functools import lru_cache
#@lru_cache(maxsize = None)

# 整数の入力
#n = int(input())

# スペース区切りの整数の入力
#a = [x for x in map(int, input().split())]
#n, a, b, c, d = map(int, input().split())
#print("sp", n, q, file=sys.stderr)
p, q, r = map(int, input().split())

# 改行区切りの整数の入力
#a = []
#for x in range(m):
#  a.append([int(x) for x in input().split()])
#p = [int(x) for x in input().split()]

# 文字列の入力
#s = input()

# 出力
#print("{} {}".format(a+b+c, s))
#a.sort()
#print(set(a), file=sys.stderr)
#print(len(set(a)))

#cache = dict()

import re

def doit():
  pq = p + q
  qr = q + r
  rp = r + p
  return min(min(pq, qr), rp)

#print(doit([0] * 4))
#doit(s)
try:
  print(doit())
except Exception as e:
  print("e", e, file=sys.stderr)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
P, Q, R = map(int, input().split())
a1 = min(P, Q, R)
if a1 == P:
    a2 = min(Q, R)
if a1 == Q:
    a2 = min(P, R)
if a1 == R:
    a2 = min(P, Q)

print(a1 + a2)

Submission status: Accepted

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

min_dis = 0
abbc = ab + bc
abca = ab + ca
bcca = bc + ca

print(min(abbc, abca, bcca))

Submission status: Accepted

Solution code:
P,Q,R = (int(i) for i in input().split()) 
S=[]
S.append(P+Q)
S.append(R+Q)
S.append(P+R)

print(min(S))

Submission status: Accepted

Solution code:
P, Q, R = map(int,input().split())
datas = [P,Q,R]
datas.sort()
print(sum(datas[:2]))

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
a,b,c = map(int, input().split())
a1=a+b
a2=a+c
a3=b+c
if(a1<=a2 and a1<=a3):
    print(a1)
elif(a2<=a1 and a2<=a3):
    print(a2)
else:
    print(a3)

Submission status: Accepted

Solution code:
P, Q, R = tuple(map(int, input().split()))
A = P + Q
B = P + R
C = Q + R
print(min(A, B, C))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
lst = input().split()

for i in range(0, len(lst)):
    lst[i] = int(lst[i])

# print(lst)
lst = sorted(lst)

ans_sum = 0
for i in range(0, 2):
    ans_sum += lst[i]

print(ans_sum)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys

input = sys.stdin.readline

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

main()

Submission status: Accepted

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

a1 = a+b
a2 = a+c
a3 = b+c
x = [a1, a2, a3]
print(min(x))

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
data = stdin.readline().split()
l = [None] * 3
l[0],l[1],l[2] = int(data[0]), int(data[1]), int(data[2])
l = sorted(l)
print(l[0] + l[1])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from itertools import permutations
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#ABC129A-Airplane.py

#import list
from sys import stdin

input = stdin.readline

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

#variable

#function

#class

#main function
def main():
    print(min([P+Q,Q+R,P+R]))

if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

print(min(l))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

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

input = lambda: stdin.readline()
main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    a = [int(x) for x in input().split()]
    print(sum(sorted(a)[:2]))

if __name__=='__main__':
    main()

Submission status: Accepted

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

print(sum(A[:2]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [P, Q, R] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print min(P + Q, P + R, R + Q)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
p,q,r = map(int, input().split())
if p > q:
    if p > r:
        print(q+r)
    else:
        print(p+q)
else:
    if q > r:
        print(p+r)
    else:
        print(p+q)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = input().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])
n = max(a,b,c)
print(a+b+c-n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# input
a, b, c = map(int, input().split())
# calc
o1 = a+b
o2 = a+c
o3 = b+c
print(min(o1, o2, o3))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
zikan = list(map(int, input().split()))

sum = 0
for i in range(len(zikan)):
    sum += zikan[i]

sum = sum - max(zikan)

print(sum)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

pq = p+q
qr = q+r
rp = r+p

print(min(pq,min(qr,rp)))

Submission status: Accepted

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

print(sum(X[:2]))

Submission status: Accepted

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

Submission status: Accepted

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

ABC = P + Q
ACB = R + Q
BCA = P + R

ans = min(ABC, ACB, BCA)

print(int(ans))

Submission status: Accepted

Solution code:
array = list(map(int, input().split()))
max = max(array)

print(sum(array)-max)

Submission status: Accepted

Solution code:
class Airplane:
    def __init__(self):
        self.P, self.Q, self.R = map(int, input().split())

    def calMineTime(self):
        lines = [self.P, self.Q, self.R]
        lines.sort()

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


airPlane = Airplane()
airPlane.calMineTime()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(min(A,B,C))

Submission status: Accepted

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

li.sort()
ans = li[0]+li[1]








print(str(ans))

Submission status: Accepted

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

time.sort()

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

Submission status: Accepted

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

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

print(min(a))

Submission status: Accepted

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

Submission status: Accepted

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

min = P + Q

if R + Q < min:
    min = R + Q
    
if P + R < min:
    min = P + R

if Q + R < min:
    min = Q + R

if R + P < min:
    min = R + P

if Q + P < min:
    min = Q + P
    
print(min)

Submission status: Accepted

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

ans = []

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

print(min(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# https://atcoder.jp/contests/abc129/tasks/abc129_a

import itertools
from collections import Counter
from collections import defaultdict
import bisect
from heapq import heappush, heappop

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
hoge = input().split()
huga = []
huga.append(int(hoge[0]))
huga.append(int(hoge[1]))
huga.append(int(hoge[2]))
huga.remove(max(huga))

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

Submission status: Accepted

Solution code:
import numpy as np
*P, = list(map(int, input().split()))
P = np.array(P)

ans = np.sum(P) - np.max(P)
print(ans)

Submission status: Accepted

Solution code:
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

P.sort()

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

Submission status: Accepted

Solution code:
p,q,r = [int(i) for i in input().split()]
a = max(p,q,r)
print(p+q+r-a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
p,q,r = map(int,input().split(" "))
a = []
a.append(p+q)
a.append(q+r)
a.append(r+p)

print(min(a))

Submission status: Accepted

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

tmp = P
if tmp < Q:
    tmp =Q

if tmp < R:
    tmp = R

ans = P+Q+R-tmp

print(ans)

Submission status: Accepted

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

pa=a+b
pb=b+c
pc=a+c

min_=min(pa,min(pb,pc))
print(min_)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
num = list(map(int, input().split()))
num.sort()
num = num[0:2]
print(sum(num))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def solve():
    p, q, r = sorted([int(x) for x in input().split()])

    print(p + q)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
input = sys.stdin.readline
 
# bisect_left(lists, 3)
# bisect_right(lists, 3)

# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

def main():
	P,Q,R = map(int, input().split(" "))
	#N = int(input())
	#S = input()
	#S = list(S)

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

	ans1 = ans[0] + ans[1]

	print(ans1)


	

if __name__ == "__main__":
	main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-

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

# 最小の組み合わせを探す
min_hour = 0

h1 = P + Q
h2 = Q + R
h3 = R + P

ans = min([h1, h2, h3])
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

print(sum(N) - max(N))

Submission status: Accepted

Solution code:
p,q,r = map(int, input().split())
l = [p,q,r]
l = sorted(l, reverse=True)
print(l[1] + l[2])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

result = []
for i in range(len(p)):
    for j in range(i+1, len(p)):
        result.append(p[i] + p[j])

print(min(result))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
num_list = list(map(int,input().split()))

import itertools
result = []
for x in itertools.combinations(num_list,2):
    result.append(sum(x))
    
print(min(result))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c  = map(int, input().split())
o = a+b+c-max([a,b,c])
print(o)

Submission status: Accepted

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

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

l = []
l.append(pq)
l.append(qr)
l.append(pr)
print(min(l))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

L = [p, q, r]

ans = 100000
for i in range(3):
    for j in range(3):
        if i != j:
            check = L[i] + L[j]
            ans = min(ans, check)
print(ans)

Submission status: Accepted

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


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

pqr= [ int(x) for x in sys.stdin.readline().split() ]
print( sum(pqr) - max(pqr) )

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


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


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    P = int(next(tokens))  # type: int
    Q = int(next(tokens))  # type: int
    R = int(next(tokens))  # type: int
    solve(P, Q, R)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S =[0]*3

S[0],S[1],S[2] = map(int,input().split())
ans =int(0)

S.sort()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

print(sum(tmp) - max(tmp))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
p,q,r = map(int,input().split())
a = p + q
b = q + r
c = p + r
print("{}".format(min(a,b,c)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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