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: Wrong Answer

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

if q + p < r:
    r = p+q
if q + r < p:
    p = p+r
if r + p < q:
    q = r+p
    
if q + p < m:
    m = p+q
if q + r < m:
    m = p+r
if r + p < m:
    m = r+p

print(m)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
P, Q, R = map(int, input().split())
import itertools
min_num = 101
for v in itertools.permutations([P, Q, R]):
    if v[0] + v[1] < min_num:
        min_num = v[0] + v[1]

print(min_num)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

min1=101
min2=101

if min1>P:
    min1=P
    flag="P"
if min1>Q:
    min1=Q
    flag="Q"
if min1>R:
    min1=R
    flag="R"
if(flag!="P"):
    if min2>P:
        min2=P
if(flag!="Q"):
    if min2>Q:
        min2=Q
if(flag!="R"):
    if min1>R:
        min2=R
print(min1+min2)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
# Your code here!

input_dis = input()
distance = input_dis.split(" ")
 
minum_dis = 100000000

cal_dis1 = int(distance[0]) + int(distance[1])
cal_dis2 = int(distance[2]) + int(distance[1])
cal_dis3 = int(distance[2]) + int(distance[1])

if cal_dis1 < minum_dis:
    minum_dis = cal_dis1
if cal_dis2 < minum_dis:
    minum_dis = cal_dis2
if cal_dis3 < minum_dis:
    minum_dis = cal_dis3
    
print(minum_dis)

Submission status: Wrong Answer

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

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

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

if q + p < m:
    m = p+q
if q + r < m:
    m = p+r
if r + p < m:
    m = r+q

print(m)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

t1 = a[0] + a[1]
t2 = a[0] + a[2]
t3 = a[1] + a[2]

if t1 < t2 and t1 < t3:
    print(t1)
elif t2 < t1 and t2 < t3:
    print(t2)
else:
    print(t3)

Submission status: Wrong Answer

Solution code:
P,Q,R = map(int,input().split())
if R == P + Q:
    print(R)
if R > P + Q:
    print(P + Q)
if R < P + Q and P <= Q:
    print(R + P)
if R < P + Q and Q <= P:
    print(R + Q)

Submission status: Wrong Answer

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

P.sort

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

Submission status: Wrong Answer

Solution code:
a ,b ,c =map(int,input().split())
d= 0
if a + b > b + c :
        d = b + c
else:
    d = a + b

if d > a + c:
    d = a + d
print(d)

Submission status: Wrong Answer

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

P = int(STR[0])
Q = int(STR[1])
R = int(STR[2])

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split()
    a = int(token[0])
    b = int(token[1])
    c = int(token[2])

    return (a, b, c)


def solve(a, b, c):

        

    

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




def main():
    # 出力

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

Submission status: Wrong Answer

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

min = p + q

if (min > q + r):
    min = q + r
elif (min > r + p):
    min = r + p

print (min)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-
# abc129/abc129_a
import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    P, Q, R = i2nn()
    print(R + Q + R - max(P, Q, R))
    return

main()

Submission status: Wrong Answer

Solution code:
a=[int(x) for x in input().split()]
min_h = min([a[0]+a[1],a[1]+a[2],a[2]+a[1]])

print(min_h)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

A = int(S[0])
B = int(S[1])
C = int(S[2])
answer_1 = A + B
answer_2 = A + C
answer_3 = B + C

print(max(answer_1,answer_2,answer_3))

Submission status: Wrong Answer

Solution code:
input_dis = input()
distance = input_dis.split(" ")

minum_dis = 1000

for i in range(2):
    cal_dis = int(distance[i]) + int(distance[i + 1])
    if cal_dis < minum_dis:
        minum_dis = cal_dis
        
print(minum_dis)

Submission status: Wrong Answer

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

PQ=P + Q
QR=Q + R
PR=P + R

print(min(PQ,QR,QR))

Submission status: Wrong Answer

Solution code:
#AB間は片道P時間,BC間は片道Q時間,CA間は片道R時間
#P+Qと、P+Rのどちらが小さい数になるか

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

PQ= P + Q
QR = Q + R
PR = P + R;

print(min(PQ,QR,QR))

Submission status: Wrong Answer

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


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

Submission status: Wrong Answer

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

d = max(a, b, c)
e = min(a, b, c)

print(d+e)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
P, Q, R = map(int, input().split())
abc = P+Q
acb = R+Q
dca = Q+R

ans = 10000
ans = min(ans, abc)
ans = min(ans, acb)
ans = min(ans, dca)
print(ans)

Submission status: Wrong Answer

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

min = 100

list = []

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

for i in list:
  if min > i:
    min = i
print(min)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
n = raw_input().split(' ')

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

if n1 < n2:
  print(n1)
elif n2 < n3:
  print(n2)
else:
  print(n3)

Submission status: Wrong Answer

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

ans = float('inf')

for i in range(3):
    for j in range(3):
        if i != j:
            if ans > a[i] + a[j]:
                print(a[i],a[j])
                ans = a[i] + a[j]

print(ans)

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
x, y, z = map(int, input().split())
m = x + y
if(m > x + z):
    m = x + z
if(m > y + z):
    m = y + x

print(m)

Submission status: Wrong Answer

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

min_val = P + Q
if min_val > Q + R:
    min_val = Q + R
elif min_val > P + R:
    min_val = P + R
print(min_val)

Submission status: Wrong Answer

Solution code:
from sys import stdin
import numpy as np

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

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

print(np.min(time))

Submission status: Wrong Answer

Solution code:
P, Q, R = map(int, input().split())
import itertools
min = 101
for v in itertools.permutations([P, Q, R]):
    if v[0] + v[1] < min:
        min = v[0] + v[1]

print(min)

Submission status: Wrong Answer

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

sum = []
for i in range(2):
        sum.append(t[i]+t[i+1])

print(min(sum))

Submission status: Wrong Answer

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

c = max(a, b, c)
d = min(a, b, c)

print(a+b)

Submission status: Wrong Answer

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

if __name__=='__main__':
  main()

Submission status: Wrong Answer

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

l = []
for fst in inp:
    for sec in inp:
        l.append(fst + sec)

print(min(l))

Submission status: Wrong Answer

Solution code:
#-*- coding: utf-8
#  -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(p, q, r):
    # 3 -> 3 * 60 = 180
    # 4 -> 4 * 90 = 360
    # 5 -> 5 *
    # 360 / 5 = 180 - 72 = 108 = 54 * 2 * 5
    # (180 - (360 / 5)) * 5
    #p, q, r
    e = min(p, q, r)
    if e == p: return q + r
    elif e == q: return p + r
    elif e == r: return p + q
    else:
        assert(True)



do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    # k = int(parsed_lines[0][1])
    # S = parsed_lines[1][0]
    # return n, k, S
    return n


if not do_submit:
    n = input_parse("""
    3
    """)
    print(sol(n))

    n = input_parse("""
    100
    """)
    print(sol(n))

else:
    p, q, r= list(map(int, input().split()))
    # S = input().split()
    # print(sol(n, k, S))
    #n = int(input().strip())
    # S = input().strip()
    print(sol(p, q, r))

Submission status: Wrong Answer

Solution code:
l = sorted([int(x) for x in input().split()])
print(sum(l[1:]))

Submission status: Wrong Answer

Solution code:
P, Q, R = map(int, input().split())
if P + Q < 2 * R:
    print(P + Q)
else:
    if P < Q:
        print(P + R)
    else:
        print(Q + R)

Submission status: Wrong Answer

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

ans = 100
for i in range(3):
    for j in range(i+1,3):
        tmp1 = li[i] + li[j]
        if tmp1 < ans:
            ans = tmp1
print(ans)

Submission status: Wrong Answer

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

a = []

a.append(n[0] + n[1])
a.append(n[1]+n[2])
print(min(a))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
# 6/9 ABC
a = input().split()
p = int(a[0])
q = int(a[1])
r = int(a[2])
x = p + q
y = q + r
z = p + r
if x <= y and z:
  print(x)
elif y <= x and z:
  print(y)
else:
  print(z)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

a = []

a.append(n[0] + n[1])
a.append(n[1]+n[2])
print(max(a))

Submission status: Wrong Answer

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 = 101

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

print(m)

Submission status: Wrong Answer

Solution code:
F, S, T = map(int, input().split())
FS = F + S
ST = S + T
TF = T + F
L = [FS, ST, TF]
print(max(L))

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
p,q,r=map(int,input().split())
n=[p+q,q+r,r+p]
ns=sorted(n)
print(n[0])

Submission status: Wrong Answer

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

Submission status: Wrong Answer

Solution code:
PQR = list(map(int, input().split()))
ans = 0
for x in PQR:
	if(x != max(PQR)):
		ans += x
print(ans)

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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 + P)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

a.sort

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

Submission status: Wrong Answer

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

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

Submission status: Wrong Answer

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

Submission status: Wrong Answer

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

Submission status: Time Limit Exceeded

Solution code:
#!/home/ryo/.pyenv/versions/anaconda3-2019.03/envs/hoge/bin/python
import time
time.sleep(2)
P,Q,R = map(int,input().split())
print(min(P+Q,min(Q+R,R+P)))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a,s,d=map(int, input().split())

print(min(a+s,s+d,d+a))

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3
import sys
input = lambda: sys.stdin.readline().strip()
p, q, r = [int(x) for x in input().split()]
print(min(p + q, q + r, r + p))

Submission status: Accepted

Solution code:

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

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

Submission status: Accepted

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

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

min = 200
for i in range(0,len(list_m)):
    if min > int(list_m[i]):
        min = list_m[i]

print(min)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

url = "https://atcoder.jp//contests/abc129/tasks/abc129_a"

def main():
    p, q, r = list(map(int, input().split()))
    print(sum([p,q,r]) - max(p,q,r))

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

ans = a + b
if a + c < ans:
  ans = a + c
if b + c < ans:
  ans = b + c

print(ans)

Submission status: Accepted

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

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

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



abc = P + Q
acb = Q + R
bca = P + R
print(min(abc, acb, bca))

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# AtCoder Beginner Contest 129
# A - Airplane

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

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

print(sum(V) - max(V))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S_list = list(map(int,input().split()))
sum_1 = sum(S_list)
S_list_1 = [sum_1 - i for i in S_list] 
print(min(S_list_1))

Submission status: Accepted

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

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

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

ans = float("inf")
for i in range(2):
  for j in range(i+1,3):
    t = pqr[i]+pqr[j]
    if t < ans: ans = t
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
lst = sorted([int(x) for x in input().split()])

print(sum(lst[:2]))

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:
# import math
# import statistics
#a=input()
#b,c=int(input()),int(input())
# c=[]
# for i in a:
#     c.append(int(i))
e1,e2,e3 = map(int,input().split())
#f = list(map(int,input().split()))
# g = [input() for _ in range(15)]
# zoro = int(a[0]*len(a))
A=e1+e2
B=e2+e3
C=e1+e3
print(min(A,B,C))

Submission status: Accepted

Solution code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

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

Submission status: Accepted

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

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

print(min(Flight_time))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
pqr = list(map(int, input().split()))
print(min([a+b for a, b in itertools.combinations(pqr, 2)]))

Submission status: Accepted

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

a_c = p + q
a_b = r + q
b_c = p + r

minimum_time=min(a_c,a_b,b_c)

print(minimum_time)

Submission status: Accepted

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

list = [p, q, r]
list.sort()

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

Submission status: Accepted

Solution code:
L=list(map(int,input().split()))
print(min(sum(L)-v for v in L))

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

print(min(sums))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(min(p_list))

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:
# 129a

def atc_129a(input_value: str) -> int:
    PQR = input_value.split(" ")
    P = int(PQR[0])
    Q = int(PQR[1])
    R = int(PQR[2])

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

input_value = input()
print(atc_129a(input_value))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# 数値を取得
time_list = list(map(int,input().split()))

# 最短時間を出力
time_list = sorted(time_list)
sumtime = time_list[0] + time_list[1]
print(sumtime)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# A - Airplane

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

Submission status: Accepted

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

D = []

D.append(P)
D.append(Q)
D.append(R)

#print(D)
D.sort()
#print(D)
aa = D[0]+D[1]
print(aa)

Submission status: Accepted

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

a1=sorted(a)


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

Submission status: Accepted

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

Submission status: Accepted

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

PR = P + R
QR = Q + R
QP = Q + P

ans = min(PR,min(QR,QP))

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
P, Q, R = map(int, input().split())
#3つの中で1,2番目に小さい数の和
flight_time = [P, Q, R]
flight_time.sort()
answer =flight_time[0] + flight_time[1]
print(answer)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# p,q,rに時間を整数で入力
p,q,r = map(int,input().split())
# それぞれ要する時間のリストを作成
time = [p,q,r]
# 各時間の合計値から、地点間の最大の時間数を引く
print(sum(time)-max(time))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
p,q,r=map(int,input().split())
dp=[0]*2
dp[0]=min(p,q)
dp[1]=min(max(q,p),r)
print(dp[1]+dp[0])

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
P,Q,R=map(int,input().split())
if (1<=P&P<=100)&(1<=Q&Q<=100)&(1<=R&R<=100):
    ABC=P+Q
    BCA=Q+R
    CAB=R+P
    answer=min(ABC,BCA,CAB)
    print(answer)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#129A
# 1.値を正しく取得
a, b, c = (int(x) for x in input().split())

# 2.正しく処理
gokei1 = a + b
gokei2 = a + c
gokei3 = b + c

resalt=[gokei1,gokei2,gokei3]

print(min(resalt))

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 = sorted([int(n) for n in input().split()])
print(p + q)

Submission status: Accepted

Solution code:
t1, t2, t3 = sorted(map(int, input().split()))
print(t1 + t2)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
ab_time, bc_time, ca_time = map(int, input().split())

time_sum_list = [ab_time, bc_time, ca_time]

max_time = max(ab_time, bc_time, ca_time)

min_time_line = sum(time_sum_list) - max_time
print(min_time_line)

Submission status: Accepted

Solution code:
ab_time, bc_time, ca_time = map(int, input().split())

time_sum_list = [ab_time, bc_time, ca_time]

max_time_line = max(ab_time, bc_time, ca_time)

print(sum(time_sum_list) - max_time_line)

Submission status: Accepted

Solution code:
# 最短の飛行時間を求める

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

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