AtCoder Beginner Contest 066 - ringring

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-----
700 600 780

-----Sample Output-----
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.

Source: atcoder | Difficulty: EASY


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


bell = [a, b, c] = list(map(int, input().split(' ')))
print(sorted(bell).pop(0) + sorted(bell).pop(1))


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


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


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


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


(*Y,) = map(int, input().split())
print(sum(Y) - max(Y))


(*P,) = map(int, input().split())
print(sum(P) - max(P))


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


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


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


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


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


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


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


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


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


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


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


(p, q, r) = map(int, input().split())
print(p + q + r - max([p, q, r]))


m = list(map(int, input().split()))
print(sum(m) - max(m))


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


l = list(map(int, input().split()))
print(sum(sorted(l)[:-1]))


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


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


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


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


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


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


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


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


l = sorted([int(i) for i in input().split()])
print(l[0] + l[1])


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


(a, b, c) = list(map(int, input().split()))
bell_price = [a, b, c]
print(sum(bell_price) - max(bell_price))


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


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


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


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


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


c = list(map(int, input().split()))
print(sum(c) - max(c))


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


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


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


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


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


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


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


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


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


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


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


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


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


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


(a, s, d) = map(int, input().split())
print(a + s + d - max(a, s, d))


(a, b, c) = [int(i) for i in input().split()]
print(a + b + c - max(a, b, c))


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


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


def iroha():
	lists = list(map(int, input().split()))
	lists.sort()
	print(lists[0] + lists[1])

def __starting_point():
	iroha()
__starting_point()


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


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


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


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


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


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


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


(A, B, C) = map(int, input().split())
print(A + B + C - max(A, B, C))


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


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


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


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


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


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


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


B = list(map(int, input().split()))
print(sum(B) - max(B))


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


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


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


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


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


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


N = [int(s) for s in input().split()]
print(sum(sorted(N)[:2]))


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


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


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


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


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


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


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


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


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


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


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


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


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


(*X,) = map(int, input().split())
print(sum(X) - max(X))


(x, y, z) = map(int, input().split())
print(min(x + y, y + z, z + x))


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


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


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


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


(S, M, L) = sorted(list(map(int, input().split())))
print(S + M)


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


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


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


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


l = sorted([int(i) for i in input().split()])
print(sum(l[0:2]))


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


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


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


L = list(map(int, input().split()))
print(sum(L) - max(L))


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


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


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


nums = list(map(int, input().split()))
ans = sum(nums) - max(nums)
print(ans)


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


(*a,) = map(int, input().split())
a.remove(max(a))
print(sum(a))


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


(a, b, c) = sorted([int(i) for i in input().split()])
print(a + b)


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


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


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


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


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


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


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


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


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


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


lst = input().split()
for i in range(3):
	lst[i] = int(lst[i])
lst.sort()
print(lst[0] + lst[1])


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


(a, b, c) = (int(x) for x in input().split())
X = [a, b, c]
X.sort()
Y = X[0] + X[1]
print(Y)


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


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


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


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


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


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


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


def main():
	abc = list(map(int, input().split()))
	abc.sort()
	cnt = 0
	for _ in range(2):
		cnt += abc.pop(0)
	else:
		print(cnt)
main()


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


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


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


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


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


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


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