Problem:
 Score : 100 points    Problem Statement Snuke is buying a bicycle.
The bicycle of his choice does not come with a bell, so he has to buy one separately.  He has very high awareness of safety, and decides to buy two bells, one for each hand.  The store sells three kinds of bells for the price of a , b and c yen (the currency of Japan), respectively.
Find the minimum total price of two different bells.      Constraints  1 \leq a,b,c \leq 10000  a , b and c are integers.         Input Input is given from Standard Input in the following format:  a  b  c       Output Print the minimum total price of two different bells.        Sample Input 1 700 600 780      Sample Output 1 1300   Buying a 700 -yen bell and a 600 -yen bell costs 1300 yen.  Buying a 700 -yen bell and a 780 -yen bell costs 1480 yen.  Buying a 600 -yen bell and a 780 -yen bell costs 1380 yen.   The minimum among these is 1300 yen.       Sample Input 2 10000 10000 10000      Sample Output 2 20000  Buying any two bells costs 20000 yen.

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

sum = a + b + c
max = max([a, b ,c])

answer = sum - max
print(answer)

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

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

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

Solution (Python):
bell=[a, b, c]=list(map(int, input().split(" ")))

print(sorted(bell).pop(0)\
      +sorted(bell).pop(1))

Solution (Python):




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

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

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

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

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

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

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

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

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

print(min(prices))

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

bell_price = [a, b, c]

print(sum(bell_price) - max(bell_price))

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

Solution (Python):

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

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

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

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

Solution (Python):


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



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

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

print(sum([a, b, c]) - max(a, b, c))

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

for i in range(3):
   lst[i] = int(lst[i])

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

Solution (Python):

def main():
    abc = list(map(int, input().split()))
    abc.sort()
    cnt = 0

    for _ in range(2):
        cnt += abc.pop(0)
    else:
        print(cnt)


if __name__ ==  "__main__":
    main()

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

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

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

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

ring=[]
ring.append(a)
ring.append(b)
ring.append(c)

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

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

def answer(a: int, b: int, c: int) -> int:
    return min(a + b, a + c, b + c)

print(answer(a, b, c))

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

plan1 = a + b
plan2 = b + c
plan3 = c + a

print(min(plan1, plan2, plan3))

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

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

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

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

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

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

kei = a + b + c

if a >= b and a >= c:
    kei -= a
    print(kei)

elif b >= a and b >= c:
    kei -= b
    print(kei)
else:
    kei -= c
    print(kei)

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
x = a + b
y = b + c
z = c + a
if x <= y and x <= z:
  print(x)
elif y <= x and y <= z:
  print(y)
else:
  print(z)

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

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

bell_list = []
bell_list.append(a + b)
bell_list.append(b + c)
bell_list.append(a + c)

print(min(bell_list))

Solution (Python):
S_list = list(map(int,input().split()))
sum_bell=sum(S_list)
hantei = list()
for i in S_list:
    hantei.append(sum_bell - i)
print(min(hantei))

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

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

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

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

Solution (Python):



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

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

Solution (Python):
with open(0) as f:
    a, b, c = map(int, f.read().split())
print(a+b+c-max(a,b,c))

Solution (Python):
with open(0) as f:
    a, b, c = map(int, f.read().split())
print(a+b+c-max(a,b,c))

Solution (Python):
with open(0) as f:
    a, b, c = map(int, f.read().split())
print(a+b+c-max(a,b,c))

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

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

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

print(min(sums))

Solution (Python):
'''
問題：
    snuke 君は自転車を買いに来ました。
    snuke 君はすでに買う自転車を決めたのですが、その自転車にはベルが付いていないため、 自転車とは別にベルも買う必要があります。
    snuke 君は安全意識が高いので、ベルをどちらの手でも鳴らせるよう、
    両方のハンドルに 1 つずつ 付けることにしました。

    お店にあるベルは 3 種類で、それぞれ a円、b円、c円です。
    この 3つのうち、異なる 2つのベルを選んで買うときの、値段の合計の最小値を求めて下さい。
'''

'''
制約：
    1 ≤ a,b,c ≤ 10000
    a,b,cは整数
'''


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

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

print(min(result))

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

X=[a,b,c]
X.sort()

Y=X[0]+X[1]

print(Y)

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

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


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):


def atc_066a(abc: str) -> int:
    abc_int = [int(ai) for ai in abc.split(" ")]
    abc_int.sort()
    return abc_int[0] + abc_int[1]

abc = input()
print(atc_066a(abc))

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

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

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

Solution (Python):

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


p_list = sorted(p_list)
pare = p_list[0] + p_list[1]
print(pare)

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

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

Solution (Python):



a, b, c = map(int, input().split())
my_list = [a, b, c]
my_list.sort()
print(my_list[0] + my_list[1])

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

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

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

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

Solution (Python):


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

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

print(min(vales))

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

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

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

bell_price = (a,b,c)

print(sum(bell_price)-max(bell_price))

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


print(min(s))

Solution (Python):
a,b,c=map(int,input().split())
x=[a,b,c]
print(sum(x)-max(x))

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

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

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

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

Solution (Python):


a, b, c = (int(x) for x in input().split())


gokei1 = a + b
gokei2 = a + c
gokei3 = b + c

resalt=[gokei1,gokei2,gokei3]

print(min(resalt))

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

Solution (Python):

a, b, c = map(int, input().split())
if (1 <= a & a <= 10000) & (1 <= b & b <= 10000) & (1 <= c & c <= 10000):
    p_ab = a + b
    p_bc = b + c
    p_ac = a + c
    print(min(p_ab,p_bc,p_ac))

Solution (Python):
import itertools
N_List = list(map(int,input().split()))
a = sum(N_List)

for v in itertools.combinations(N_List,2):
    if a >= sum(v):
        a = sum(v)
print(a)

Solution (Python):

bell1, bell2, bell3 = map(int, input().split())

bell_list = [bell1, bell2, bell3]
min_price_bell = []

bell_list.sort()

for i in range(0, 2):
    min_price_bell.append(bell_list[i])

print(sum(min_price_bell))

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

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





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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
bell = [a, b, c]
print(sum(bell) - max(bell))

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

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

Solution (Python):
price_of_bell_a, price_of_bell_b, price_of_bell_c = map(int, input().split())

sum_a_b = price_of_bell_a + price_of_bell_b
sum_a_c = price_of_bell_a + price_of_bell_c
sum_b_c = price_of_bell_b + price_of_bell_c

print(min(sum_a_b, sum_a_c, sum_b_c))

Solution (Python):
abc = list(map(int, input().split()))
abc.remove(max(abc))

print(sum(abc))

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

print(ans)

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

d = a + b
e = b + c
f = c + a
l = [d, e, f]
print(min(l))

Solution (Python):
l = list(map(int, input().split()))
ls = sorted(l)
print(ls[0]+ls[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(sum([a,b,c])-max(a,b,c))

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

com = list(itertools.combinations(l,2))

k = []
for i in range(len(com)):
    k.append(sum(com[i]))
    
print(min(k))

Solution (Python):

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



l = [a, b, c]
l.sort()
print(l[0]+l[1])

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

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

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

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

d = [a] + [b] + [c]
d.sort()

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

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

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

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

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

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

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

Solution (Python):
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
ls=[a,b,c]
ls.sort()
print(ls[0]+ls[1])

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

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

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

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

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

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(A+B+C-max(A,B,C))

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    num_list = i_list()

    num_list.sort()

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    a, b, c = map(int, readline().split())
    print(a+b+c-max(a,b,c))


if __name__ == '__main__':
    main()

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

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

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

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

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

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

d = min(a,b,c)

ans = 0
if d == a:
    ans = d + min(b,c)
elif d == b:
    ans = d + min(a,c)
else:
    ans = d + min(a,b)
print(ans)

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate 

from collections import deque,defaultdict,Counter
import decimal
import re












import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
A = readInts()
mi = float('inf')
for a,b in combinations(A,2):
    mi = min(mi, a+b)
print(mi)

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

p=[a,b,c]
p.sort()

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

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

x.sort()

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

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

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

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

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

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

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

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

Solution (Python):


import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

def main():
    a = na()
    print(sum(a) - max(a))

if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

a, b, c = inl()


def solve():
    return min([a + b, b + c, a + c])


print(solve())

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

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

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

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



if __name__ == "__main__":
    solve()

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

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

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

print(ans)

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


def main():
    a, b, c = map(int, input().split())
    m = max(a, b, c)
    print(a + b + c - m)


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

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

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

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

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

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

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
import numpy as np
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X = MAP()
X = sorted(X)
print(X[0] + X[1])

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

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

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

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

Solution (Python):
rp=list(map(int,input().split()))
print(min([sum(rp)-x for x in rp]))

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    a, b, c = map(int, readline().split())

    ans = a + b + c - max(a, b, c)

    print(ans)

    return


if __name__ == '__main__':
    main()

Solution (Python):
rp=list(map(int,input().split()))
print(min([sum(rp)-x for x in rp]))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
print(sum(sorted([int(x) for x in input().split()])[0:2]))

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

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

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

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

Solution (Python):
a,b,c = (int(x) for x in input().split())
if a+b <= a+c <= b+c or a+b <= b+c <= a+c:
  print (a+b)
elif a+c <= a+b <= b+c or a+c <= b+c <= a+b:
  print (a+c)
else:
  print (b+c)

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

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 = [int(i) for i in input().split()]
a.sort()
print(a[0] + a[1])

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
l = LI()
l.sort()
print(sum(l[0:2]))

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

a,b,c = sorted(list(map(int,input().split())))
print(a+b)

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

arr.sort()

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
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**9)
INF = 10**9
mod = 10**9+7

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

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

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

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

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

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

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

price = a+b+c-max(a,b,c)

print(price)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
array_abc = list(map(int,input().split()))
if min(array_abc) < 0 or max(array_abc) > 10000:
    sys.exit()

min = 30000
for I in range(len(array_abc)):
    for J in range(len(array_abc)):
        if not I == J:
            if min > array_abc[I] + array_abc[J]:
                min = array_abc[I] + array_abc[J]

print(min)

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

bell_1 = a + b
bell_2 = b + c
bell_3 = c + a

if (bell_1 <= bell_2) and (bell_1 <= bell_3):
    print(bell_1)

elif (bell_2 <= bell_1) and (bell_2 <= bell_3):
    print(bell_2)

elif (bell_3 <= bell_1) and (bell_3 <= bell_2):
    print(bell_3)

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

Solution (Python):
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations

def main():
    price = sorted(list(map(int, input().split())))

    print(sum(price[:2]))

if __name__ == '__main__':
    main()

Solution (Python):


l = sorted(list(map(int, input().split())))

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

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

Solution (Python):
def actual(a, b, c):
    return min((a + b), (b + c), (c + a))

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