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

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

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

print(min(y))

Solution (Python):
str=input()
nedan=str.split()
min=min(int(nedan[0])+int(nedan[1]),int(nedan[0])+int(nedan[2]),int(nedan[1])+int(nedan[2]))

print(min)

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

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

ab = a+b
bc = b+c
ca = c+a

if ab > bc:
    min = bc
else:
    min = ab

if min > ca:
    result = ca
else:
    result = min

print(result)

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

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(' '))
pattern = [[a,b],[b,c],[a,c]]
price = sum([a,b,c])
for p in pattern:
    price = min(price, p[0] + p[1])
print(price)

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

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

Solution (Python):
a,b,c=map(int,input().split())
import numpy as np
bagle_list=[a,b,c]
print(int(min(bagle_list)+np.median(bagle_list)))

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

print(sum(sorted(N)[:2]))

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

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

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

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

s = a + b
t = a + c
u = b + c

if s <= t and s <= u:
    print(s)
elif t <= s and t <= u:
    print(t)
else:
    print(u)

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

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

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

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

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

print(sum(sorted(money)[0:2]))

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

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

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

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

Solution (Python):
import math
import sys

def getinputdata():

    
    array_result = []
    
    data = input()

    
    array_result.append(data.split(" "))

    flg = 1

    try:


        while flg:

            data = input()

            array_temp = []

            if(data != ""):
                
                array_result.append(data.split(" "))

                flg = 1

            else:

                flg = 0
    finally:


        return array_result





arr_data = getinputdata()

arr = arr_data[0]


arr2=list(map(int, arr))

arr2.sort()

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

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

total = a + b + c

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

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

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

Solution (Python):





if __name__ == '__main__':
    bells = list(map(int, input().split()))
    bells.sort()

    print(sum(bells[:2]))

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

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

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

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

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

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

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

if a == max(a, b, c):
  print(b + c)
elif b == max(a, b, c):
  print(c + a)
elif c == max(a, b, c):
  print(a + b)

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

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

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

Solution (Python):


from itertools import combinations
print(min(map(lambda x: x[0]+x[1], combinations(map(int, input().split()), 2))))

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

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

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

    tmp1 = a + b
    tmp2 = a + c
    tmp3 = b + c
    num = [tmp1,tmp2,tmp3]
    print(min(num))

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
a, b, c = [int(x) for x in input().split()]
print(sum(sorted([a,b,c])[0:2]))

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

Solution (Python):
cos = list(map(int, input().split()))
res = min(cos)
cos.remove(min(cos))
res += min(cos)
print(res)

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

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

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

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

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

Solution (Python):


data = input()
A = data.split(" ")
A.sort(key = lambda x:int(x))
print(int(A[0])+int(A[1]))

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
print(min(a+b, min(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())
lst1 = [a,b,c]
lst2 = sorted(lst1)
print(lst2[0] + lst2[1])

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

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

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

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

Solution (Python):


nums=sorted(list( int(i) for i in input().split() ))

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

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

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

Solution (Python):
def solve():
    prices = list(map(int, input().split(" ")))
    prices.sort()
    print(sum(prices[:2]))

    
solve()

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

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

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

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

s=a+b
t=b+c
u=c+a

print(min(s,t,u))

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

Solution (Python):
l = [int(n) for n in input().split()]
print(sum(sorted(l)[:2]))

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

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

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

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

Solution (Python):
_item = [int(e) for e in input().split(' ')]
_sum = []
for i in range(3):
	for j in range(i, 3):
		if i != j:
			_sum.append(_item[i] + _item[j])
index = 0
for i in range(len(_sum)):
	if i == 0 or _sum[index] > _sum[i]:
		index = i
print(_sum[index])

Solution (Python):

xs = map(int, input().split())

xs = sorted(xs)

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

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

Solution (Python):
def read_int_list():
    return list(map(int, input().split()))

n = read_int_list()
n.sort()
print(n[0]+n[1])

Solution (Python):

"""
http://abc066.contest.atcoder.jp/tasks/abc066_a

"""
import sys
from sys import stdin
input = stdin.readline


def main(args):
    rings = [int(x) for x in input().split()]
    rings.sort()
    print(rings[0] + rings[1])


if __name__ == '__main__':
    main(sys.argv[1:])

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

Solution (Python):
a = [int(i) for i in input().split()]
ans = sum(a)
for i in range(len(a)):
    check = sum(a) - a[i]
    if check < ans:
        ans = check
print(ans)

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

print(sum(abc) - max(abc))

Solution (Python):
from collections import defaultdict
from itertools import product, groupby
from math import pi
from collections import deque
from bisect import bisect, bisect_left, bisect_right
INF = 10 ** 10


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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
def main():
    print(sum(sorted([int(i) for i in input().split()])[:2]))


if __name__ == "__main__":
    main()

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

max = max(number)

number.remove(max)

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

Solution (Python):
def ringring(x):
    x.sort()
    return x[0] + x[1]

l = [int(i) for i in input().split()]
print(ringring(l))

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

Solution (Python):
prices = []

prices = input().split()

sum1 = int(prices[0]) + int(prices[1])
sum2 = int(prices[0]) + int(prices[2])
sum3 = int(prices[1]) + int(prices[2])

if sum1 <= sum2 and sum1 <= sum3:
    print(sum1)
elif sum2 <= sum1 and sum2 <= sum3:
    print(sum2)
elif sum3 <= sum1 and sum3 <= sum2:
    print(sum3)

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

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

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

Solution (Python):


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

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

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

Solution (Python):



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

Solution (Python):
price = input().split(" ")
price.sort(key=int)
total = int(price[0])+int(price[1])
print(total)

Solution (Python):
input_line = map(int,raw_input().split(" "))
tmpMin = float("inf")
if tmpMin > input_line[0] + input_line[1]:
	tmpMin = input_line[0] + input_line[1]
if tmpMin > input_line[0] + input_line[2]:
	tmpMin = input_line[0] + input_line[2]
if tmpMin > input_line[1] + input_line[2]:
	tmpMin = input_line[1] + input_line[2]
print tmpMin

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

Solution (Python):


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

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

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

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

Solution (Python):



import sys

prices = list(map(int, sys.stdin.readline().split(' ')))

prices.sort()

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

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

Solution (Python):


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

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

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

Solution (Python):
import sys

items = [int(x) for x in sys.stdin.readline().rstrip().split()]
items.sort()
print items[0] + items[1]

Solution (Python):
numsstr = input().split()
nums = []
for n in numsstr:
    nums.append(int(n))
ans = sum(nums)-max(nums)
print(ans)

Solution (Python):
if __name__ == "__main__":
    a, b, c = list(map(int, input().split()))
    result = []
    result.append(a + b)
    result.append(a + c)
    result.append(b + c)
    
    print(min(result))

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

Solution (Python):
def ri(): return int(input())
def rli(): return list(map(int, input().split()))
def ris(): return list(input())
def pli(a): return "".join(list(map(str, a)))

a = rli()
a.remove(max(a))
print(sum(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(" "))

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

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

Solution (Python):
import numpy as np

a,b,c = map(int,input().split())
ans = np.sum(np.sort([a,b,c])[0:2])
print(ans)

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

Solution (Python):
t = map(int, raw_input().split())
t.sort()
print t[0] + t[1]

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

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

Solution (Python):


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

Solution (Python):


import re

x = raw_input()
x = map(int, re.split("\s", x))
x.sort()

print x[0] + x[1]

Solution (Python):
a = [int(x) for x in input().split()]
s = 0
if a[0] <= a[1]:
    s = a[0]
    if a[1] <= a[2]:
        s += a[1]
    else:
        s += a[2]
else:
    s = a[1]
    if a[0] <= a[2]:
        s += a[0]
    else:
        s += a[2]
print(s)

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

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

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



a.sort()

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

Solution (Python):
l = raw_input().split()
price1 = int(l[0]) + int(l[1])
price2 = int(l[0]) + int(l[2])
price3 = int(l[1]) + int(l[2])
if price1 > price2:
	price = price2
else:
	price = price1
if price > price3:
	price = price3
print price

Solution (Python):
def min(a, b, c):
    list = [a,b,c]
    list.sort()
    return list[0] + list[1]

if(__name__ == "__main__"):
    a, b, c = (int(i) for i in input().split())
    print(min(a, b, c))

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

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

print(sum(price)-max(price))

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

Solution (Python):
inpt = map(int, raw_input().split())
inpt.sort()

print inpt[0] + inpt[1]

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

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

Solution (Python):
import sys
import math

l = raw_input().split()
l[0] = int(l[0])
l[1] = int(l[1])
l[2] = int(l[2])

sum = l[0]+l[1]+l[2]
min = sum

for i in range(3):
    s = sum - l[i]
    if s < min:
        min = s

print min

Solution (Python):

a, b, c = list(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):
abc = map(int, input().split())
val1 = 10001
val2 = 10001
for i in abc:
	if i < val1 and i < val2:
		val2 = val1
		val1 = i
	elif i < val2:
		val2 = i
print(val1 + val2)

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

Solution (Python):
import sys

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

sum_1 = a + b
sum_2 = b + c
sum_3 = c + a

if sum_1 >= sum_2:
    min_1 = sum_2
else: 
    min_1 = sum_1

if min_1 >= sum_3:
    ans = sum_3
else:
    ans = min_1

print(ans)

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

Solution (Python):
a, b, c = (int(i) for i in input().split())
e=a+b+c-max(a,b,c)
print(e)

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

tmp = 0
buy_rings = []
for e in l:
    if tmp == 0:
        tmp = e
        continue
    if tmp <= e:
        buy_rings.append(tmp)
        tmp = e
    else:
        buy_rings.append(e)

print(sum(buy_rings))

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

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

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

Solution (Python):
def find_pair(nums):
    st_nums = sorted(nums)
    return st_nums[0] + st_nums[1]

if __name__ == "__main__":
    
    nums = tuple([int(text) for text in raw_input().split()])
    print(find_pair(nums))

Solution (Python):

n = input()
s = n.split(" ")
for i in range(3):
    s[i] = int(s[i])


print(sum(s)-max(s))

Solution (Python):
abc = map(int, raw_input().rstrip().split(' '))
largest = max(abc)
print sum(abc) - largest

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

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

Solution (Python):





x = input().split()


y =[int(x[0]), int(x[1]), int(x[2])]

z = sorted(y)

ans = z[0] + z[1]

print(ans)

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

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

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

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

Solution (Python):



a = [int(i) for i in input().split()]
ans = sum(a)-max(a)
print(ans)

Solution (Python):
X = map(int, raw_input().split())

print sum(X) - max(X)

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

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

Solution (Python):





x = input().split()


y =[int(x[0]), int(x[1]), int(x[2])]

z = sorted(y)

ans = z[0] + z[1]

print(ans)

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()


def main():
    a = LI()

    return sum(a) - max(a)


print(main())

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

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

if a > b:
  a, b = b, a

if b > c:
  b, c = c, b

if a > b:
  a, b = b, a

print(a+b)

Solution (Python):
a,b,c=map(int,input().split())
d=[a,b,c]
d.sort(reverse=True)
sum = 0

for i in range(2):
    sum += d.pop()
print(sum)

Solution (Python):
if(__name__=="__main__"):
    num = [int(i) for i in input().split()]
    
    
    sortnum = sorted(num)
    sortnum.pop()
    print(sum(sortnum))

Solution (Python):


l=map(int,raw_input().split())
ls=sorted(l)
print ls[0]+ls[1]

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

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

result = 0

if l[0] < l[1]:
    result += l[0]

    if l[1] < l[2]:
        result += l[1]

    else:
        result += l[2]

else:
    result += l[1]

    if l[0] < l[2]:
        result += l[0]

    else:
        result += l[2]

print(result)

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

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

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

Solution (Python):
*X,=map(int,input().split());print(sum(X)-max(X))

Solution (Python):
from sys import stdin
a = map(int,stdin.readline().split())
a.sort()
print a[0] + a[1]

Solution (Python):




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

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

a,b,c=a+b,b+c,c+a

ans=min(a,b,c)

print(ans)

Solution (Python):
A, B, C = map(int, raw_input().split())
max_num = max([A,B,C])
result = A+B+C - max_num
print result

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

Solution (Python):
abc = input().split(' ')
max_ = max(abc)
abc =[ int(x) for x in abc]
s=  0
min_ = min(abc) 
if abc[0] == abc[1] == abc[2] :
    print(abc[0] + abc[1])

elif abc.count(max(abc)) == 2:
    print(max(abc) + min(abc))

    
else:    
    for i in abc:
        if i != max(abc):
            s += i
    print(s)

Solution (Python):
abc = input().split(' ')
max_ = max(abc)
abc =[ int(x) for x in abc]
s=  0
min_ = min(abc) 
if abc[0] == abc[1] == abc[2] :
    print(abc[0] + abc[1])

elif abc.count(max(abc)) == 2:
    print(max(abc) + min(abc))

    
else:    
    for i in abc:
        if i != max(abc):
            s += i
    print(s)

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

Solution (Python):
import sys




def read_int_list():
    return list(map(int, input().split()))


def read_str_list():
    return input().split()


def read_int():
    return int(input())


def read_str():
    return input()


def main():
    a, b, c = read_int_list()
    p = sorted([a, b, c])
    res = p[0] + p[1]
    print(res)


main()

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

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

print(min(price))

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

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

Solution (Python):

a=[]
a+=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):
import sys
a=0
b=0
c=0
x=3


v,y,z =[int(x) for x in input().split(" ")]

a = v+y
b = y+z
c = z+v

if a<b and a<c:
	print (a)

if b<c and b<a:
	print (b)

if c<b and c<a:
	print (c)

if a == b and b == c:
	print (a)

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

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

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

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

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

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

minsum=a+b

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

print(minsum)

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

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

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

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

Solution (Python):

def main():
    arg = input()
    arg = arg.split()
    a = int(arg[0])
    b = int(arg[1])
    c = int(arg[2])
    bells = [a, b, c]
    bells.sort()
    print(bells[0] + bells[1])


if __name__ == '__main__':
    main()

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

v1 = int(a) + int(b)
v2 = int(a) + int(c)
v3 = int(b) + int(c)

print(min(v1, v2, v3))

Solution (Python):
a, b, c = map(int, raw_input().split())
ab = a + b
bc = b + c
ca = c + a

if ab <= bc and ab <= ca:
    print ab
elif bc <= ab and bc <= ca:
    print bc
else:
    print ca

Solution (Python):


l = map(int, raw_input().split())

a=[]
a.append(l[0])
a.append(l[1])
a.append(l[2])


a.sort()

print a[0]+a[1]

Solution (Python):
A, B, C = raw_input().split()

a = int(A)
b = int(B)
c = int(C)

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

print min(arr)

Solution (Python):
n = map(int, raw_input().split())
n.sort()
print n[0] + n[1]

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

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

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

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

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

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

if __name__ == '__main__':
    main()

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

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

bells = sorted(bells)

ans = bells[0]+bells[1]

print(ans)

Solution (Python):


def main():
    a, b, c = (int(x) for x in raw_input().split())

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


if __name__ == "__main__":
    main()

Solution (Python):
p = map(int, raw_input().split())
print sum(p)-max(p)

Solution (Python):

a = input().split()
min_data = None
for i in range(len(a)):
    for j in range(len(a)):
        if i == j:
            pass
        elif min_data is None:
            min_data = int(a[i])+int(a[j])
        else:
            min_data = min(min_data, int(a[i])+int(a[j]))
print(min_data)

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

if min(bells) == bells[0]:
    print(min(bells) + min(bells[1], bells[2]))
elif min(bells) == bells[1]:
    print(min(bells) + min(bells[0], bells[2]))
else:
    print(min(bells) + min(bells[0], bells[1]))

Solution (Python):


import numpy as np

if __name__=="__main__":
    a,b,c = map(int,input().split())
    bells = np.array([a,b,c])
    bells.sort()
    print(np.sum(bells[0:2]))

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

Solution (Python):

abc = list(int(i) for i in input().split())

abc.sort()
z = abc[0] + abc[1]
print(z)

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

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

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

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

Solution (Python):
def main():
    PRICE = tuple(map(int, input().split()))

    price = sorted(PRICE)
    ans = price[0] + price[1]
    print(ans)

main()

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

Solution (Python):

arr = input().split()
for i in range(len(arr)):
    arr[i] = int(arr[i])
arr.sort()

s = 0
for i in range(2):
    s += arr[i]

print(s)

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

a.sort()

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

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

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

print(min(values))

Solution (Python):

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

Solution (Python):
st = input().split()
a = int(st[0])
b = int(st[1])
c = int(st[2])

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

Solution (Python):
a, b, c = [int(x) for x in input().split()]
if a >= b and a >= c:
	print(b + c)
elif b >= a and b >= c:
	print(a + c)
else:
	print(a + b)