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=list(map(int,input().split()));print(sum(a)-max(a))

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

L = sorted(L)
ans = sum(L[:2])
print(ans)

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def main():
    bell=LI()
    print(sum(bell)-max(bell))
main()

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
sortedPrice = sorted([a, b, c])

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

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

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

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

if a == b and b == c:
    print(a + b)
else:
    list_price = [a, b, c]
    print(sorted(list_price)[0] + sorted(list_price)[1])

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

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

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

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

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

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

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

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

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

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

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

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

print(total)

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

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

bell = tuple(map(int, input().split()))
print(sum(bell)-max(bell))

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

Solution (Python):


a,b,c=list(map(int,input().split(" ")))
sumabc=(a+b+c)

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

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

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

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

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

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

Solution (Python):
from sys import stdin
from itertools import accumulate

li = list(map(int,stdin.readline().rstrip().split()))

li.sort()

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

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

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

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

sum1 = a + b
sum2 = a + c
sum3 = b + c

print(min(sum1, sum2, sum3))

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

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

a_b = a+b
a_c = a+c
b_c = b+c

print(min(a_b,a_c,b_c))

Solution (Python):

import math


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):
a,b,_=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= list(map(int,input().split()))
print(sum(a)-max(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())
x = a+b
y = b+c
z = c+a
if x < y and x < z:
    print(x)
elif y < z and y < x:
    print(y)
else:
    print(z)

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

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

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

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

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

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

Solution (Python):
def examA():
    abc = LI()
    ans = sum(abc) - max(abc)
    print(ans)


import sys
import copy
import bisect
import heapq
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

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

l.sort()

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

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

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

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):
A = [int(a) for a in 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(a+b+c-max(a,b,c))

Solution (Python):

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

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

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

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

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

max_n = max(a,b,c)

print(a+b+c-max_n)

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

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

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

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

price = [int(p) for p in input().split()]
price.sort()
print(price[0] + price[1])

Solution (Python):

a, b, c = [int(s) for s in input().split()]
total_prices = [a + b, b + c, c + a]
print(min(total_prices))

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

Solution (Python):

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

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

Solution (Python):

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

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

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

Solution (Python):
data = input().split(" ")
m = 0
s = 0
for i in range(3):
	a = int(data[i])
	s += a
	if a >= m:
		m = a
print(s-m)

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

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

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

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

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

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

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

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

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

Solution (Python):




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

a.sort()

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

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

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

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

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

Solution (Python):
a = map(int, input().split())
l = sorted(a)
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 = sorted(map(int,input().split()))
print(a + b)

Solution (Python):

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

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

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

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

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

print(sum(a) - max(a))

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

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

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):
import sys
sys.setrecursionlimit(int(1e6))

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

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

print(ans)

Solution (Python):

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

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(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):
bells = sorted(list(map(int, input().split())))
print(bells[0]+bells[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):
INPUT = list(map(int,input().split()))
a=INPUT[0]
b=INPUT[1]
c=INPUT[2]
print(min(a+b,b+c,c+a))

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

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

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

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

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

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

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

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

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(sum(a[:2]))

Solution (Python):

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

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

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    a = list(map(int, input().rstrip('\n').split()))
    a.sort()
    print(sum(a[:2]))


if __name__ == '__main__':
    slove()

Solution (Python):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
a,b,c=map(int,input().split())
ans=min(a+b,b+c,c+a)
print(ans)

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

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    print(sum(sorted(map(int, input().split()))[:-1]))


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

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

ans=sorted(li)

print(ans[0])

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

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

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

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()))
print(sum(l)-max(l))

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

print(sum(bell) - max(bell))

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

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

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

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

Solution (Python):

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

Solution (Python):

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

Solution (Python):
a=list(map(int,input().split()))
print(sum(a)-max(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):
a, b, c = map(int, input().split())
ab = a + b
bc = b + c
ac = a + c
if ab < ac and ab < bc:
  print(ab)
elif bc < ab and bc < ac:
  print(bc)
else:
  print(ac)

Solution (Python):
import numpy as np
bell_li = list(map(int, input().split()))
bell_np = np.array(bell_li)
bell_np_sorted = bell_np.argsort()
print(bell_li[bell_np_sorted[0]] + bell_li[bell_np_sorted[1]])

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a = LIST()
    a.sort()
    print(a[0]+a[1])
if __name__ == '__main__':
    do()

Solution (Python):
a=list(map(int,input().split()))
a.sort(reverse=False)
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 = 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())
print(a+b+c-max(a,b,c))

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

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

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

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

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

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

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

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

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

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

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

bell = [a,b,c]
s_bell = sorted(bell)
print(s_bell[0]+s_bell[1])

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

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

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

Solution (Python):


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

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

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


if __name__ == "__main__":
    resolve()

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

Solution (Python):

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

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

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

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

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

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

print(min(price_list))

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

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

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

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

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

Solution (Python):
a=list(map(int,input().split()))
print(sum(a)-max(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()))
print(sum(a)-max(a))

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

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

Solution (Python):
s=list(input().split())
a=int(s[0])
b=int(s[1])
c=int(s[2])
s2=[a,b,c]
s2.sort()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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()))
print(sum(A) - max(A))

Solution (Python):
s = input().split()
t = map(int, s)
f1 = min(t)
s.pop(s.index(str(f1)))
t = map(int, s)
f2 = min(t)
print(f1 + f2)

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

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

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

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

Solution (Python):
a,b,c = map(int, input().split())
ab = a + b
ac = a + c
bc = b + c
if ab > ac:
    if ac > bc:
        print(bc)
    else:
        print(ac)
else:
    if ab > bc:
        print(bc)
    else:
        print(ab)

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

Solution (Python):
import sys
import copy
import  math
import bisect
from collections import *
from operator import itemgetter
"""
from fractions import gcd
def lcm(x, y):
    return (x * y) // gcd(x, y)
"""
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

li = sorted(na())
print(li[0] + li[1])

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

A.sort()

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

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

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

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

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

print(sum(price[: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):
b = list(map(int, input().strip().split(' ')))
print(sum(b)-max(b))

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

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

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

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

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

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

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

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

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):
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):
aList = list(map(int, input().split()))
print(sum(aList) - max(aList))

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

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

if __name__ == '__main__':
    print(main())

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

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

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

x = a+b
y = b+c
z = c+a

ans = min([x,y,z])

print(ans)

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

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

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

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

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

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

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
nums = list(map(int,input().split()))
sum = 0
for num in nums:
    sum += num
print(sum - max(nums))

Solution (Python):
nums = list(map(int,input().split()))
sum = 0
for num in nums:
    sum += num
print(sum - max(nums))

Solution (Python):
num = list(map(int,input().split()))
lp = 0
while lp < len(num)-1:
    rp = len(num)-1
    while rp > lp:
        if num[rp] < num[rp-1]:
            x = num[rp]
            num[rp] = num[rp-1]
            num[rp-1] = x
        rp -= 1
    lp += 1
print(num[0]+num[1])

Solution (Python):
num = list(map(int,input().split()))
lp = 0
while lp < len(num)-1:
    rp = len(num)-1
    while rp > lp:
        if num[rp] < num[rp-1]:
            x = num[rp]
            num[rp] = num[rp-1]
            num[rp-1] = x
        rp -= 1
    lp += 1
print(num[0]+num[1])

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

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

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

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

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

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

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

Solution (Python):
L,C,R = map(int,input().split())
print(L+C+R-max(L,C,R))

Solution (Python):



import sys
input = sys.stdin.readline


def main():
    l = list(map(int, input().split()))
    l.sort()

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

Solution (Python):
def test():
    x = list(map(int,input().split()))
    result = 0
    for i in range(len(x)-1):
        result += min(x)
        x.remove(min(x))

    print(result)


if __name__ == "__main__":
    test()

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

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

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

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

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

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

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

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

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

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

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

print(sum(a)- max(a))

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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

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

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