Chef goes to the supermarket to buy some items. Luckily there's a sale going on under which Chef gets the following offer: 

If Chef buys 3 items then he gets the item (out of those 3 items) having the lowest price as free. 

For e.g. if Chef bought 3 items with the cost 6, 2 and 4, then he would get the item with cost 2 as free. So he would only have to pay the cost of the other two items which will be 6 + 4 = 10.

Chef buys 3 items having prices A, B and C respectively. What is the amount of money Chef needs to pay?

------ Input Format ------ 

- The first line will contain an integer T - number of test cases. Then the test cases follow.
- The first and only line of each test case contains three integers A, B, C - the prices of the items bought by Chef.

------ Output Format ------ 

For each test case, output the price paid by Chef.

------ Constraints ------ 

$1 ≤ T ≤ 100$
$1 ≤ A, B, C ≤ 10$

----- Sample Input 1 ------ 
3
6 2 4
3 3 3
8 4 4

----- Sample Output 1 ------ 
10
6
12

----- explanation 1 ------ 
Test case-1: Explained in the problem statement.

Test case-2: Since all the three items have the same price, Chef will get one of them free and will have to pay the cost of the other two items which will be $3 + 3 = 6$. 

Test case-3: Chef will get one of the items having price $4$ as free and will have to pay the cost of the other two items which will be $8 + 4 = 12$.

Difficulty: EASY
Tags: Mathematics

Starter code:

Solutions:
for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	print(a + b + c - min(a, b, c))


for _ in range(int(input())):
	A = list(map(int, input().split()))
	A.sort()
	print(A[1] + A[2])


T = int(input())
for i in range(0, T):
	(a, b, c) = map(int, input().split())
	temp = min(a, b, c)
	print(a + b + c - temp)


t = int(input())
while t > 0:
	(a, b, c) = map(int, input().split())
	min_val = min(a, b, c)
	sum_val = a + b + c
	print(sum_val - min_val)
	t -= 1


t = int(input())
for i in range(t):
	(A, B, C) = tuple(map(int, input().split()))
	m = min(A, B, C)
	print(A + B + C - m)


t = int(input())
for _ in range(t):
	a = list(map(int, input().split()))
	a.sort()
	print(a[1] + a[2])


t = int(input())
for i in range(t):
	lst = list(map(int, input().split()))
	lst.sort()
	print(lst[1] + lst[2])


t = int(input())
for i in range(t):
	(m, n, o) = map(int, input().split())
	print(m + n + o - min(m, n, o))


t = int(input())
for _ in range(t):
	costs = list(map(int, input().split()))
	print(sum(costs) - min(costs))


t = int(input())
for i in range(t):
	a = list(map(int, input().split()))
	c = min(a)
	a.remove(c)
	sum = 0
	for i in a:
		sum = sum + i
	print(sum)


import sys
for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	y = a + b + c - min(a, b, c)
	sys.stdout.write(str(y) + '\n')


n = int(input())
for i in range(n):
	(a, b, c) = tuple(map(int, input().split()))
	l = min(a, b, c)
	print(a + b + c - l)


t = int(input())
for i in range(t):
	(x, y, z) = map(int, input().split(' '))
	a = min(x, y, z)
	if a == x:
		print(y + z)
	elif a == y:
		print(x + z)
	else:
		print(x + y)


t = int(input())
for _ in range(t):
	(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)
	else:
		print(b + c)


for i in range(int(input())):
	(x, y, z) = map(int, input().split())
	print(x + y + z - min(x, y, z))


n = int(input())
for i in range(n):
	a = list(map(int, input().split()))
	a.sort()
	p = a[1:]
	print(sum(p))


for i in range(int(input())):
	a = list(map(int, input().split()))
	least = min(a)
	print(sum(a) - least)


t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	x = min(a, b, c)
	print(a + b + c - x)


t = int(input())
import math
for i in range(t):
	(n, k, s) = map(int, input().split())
	print(n + k + s - min(n, k, s))


T = int(input())
for i in range(0, T):
	(A, B, C) = map(int, input().split())
	if A <= B:
		if A <= C:
			print(B + C)
		else:
			print(A + B)
	elif B <= C:
		print(A + C)
	else:
		print(A + B)


t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	s = a + b + c
	if a <= b and a <= c:
		s = s - a
	elif b <= a and b <= c:
		s = s - b
	elif c <= a and c <= b:
		s = s - c
	print(s)


t = int(input())
for i in range(t):
	a = list(map(int, input().split()))
	m = a.remove(min(a))
	n = 0
	for j in range(len(a)):
		n += a[j]
	print(n)


t = int(input())
for i in range(0, t):
	(a, b, c) = map(int, input().split())
	lists = [a, b, c]
	lists = sorted(lists)
	print(lists[-1] + lists[-2])


def calculate_price(a, b, c):
	prices = [a, b, c]
	prices.sort()
	return prices[2] + prices[1]
t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	price = calculate_price(a, b, c)
	print(price)


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


n = int(input())
for i in range(n):
	(a, b, c) = map(int, input().split())
	s = sorted([a, b, c], reverse=True)
	print(s[0] + s[1])


for i in range(int(input())):
	x = list(map(int, input().split()))
	print(sum(x) - min(x))


t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	prices = []
	prices.append(a)
	prices.append(b)
	prices.append(c)
	prices.remove(min(prices))
	print(sum(prices))


t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	lst = []
	lst.append(a)
	lst.append(b)
	lst.append(c)
	lst.sort(reverse=True)
	print(lst[0] + lst[1])


T = int(input())
for i in range(T):
	(a, b, c) = map(int, input().split())
	min = 999999999999999999999999999
	if a < min:
		min = a
	if b < min:
		min = b
	if c < min:
		min = c
	a = a + b + c
	a = a - min
	print(a)


T = int(input())
for i in range(T):
	(A, B, C) = map(int, input().split())
	print(A + B + C - min(A, B, C))


for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	m = min(a, b, c)
	print(a + b + c - m)


testcases = int(input())
for i in range(testcases):
	(A, B, C) = map(int, input().split())
	m = min(A, B, C)
	print(A + B + C - m)


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	print(sum(l) - min(l))


n = int(input())
for i in range(n):
	m = list(map(int, input().split()))
	m.remove(min(m))
	print(sum(m))


for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	lis = list()
	lis.append(a)
	lis.append(b)
	lis.append(c)
	lis.sort()
	print(lis[1] + lis[2])


test = int(input())
while test:
	(A, B, C) = [int(x) for x in input().split()]
	sum = A + B + C
	list = [A, B, C]
	smallest = min(list)
	sum -= smallest
	print(sum)
	test -= 1


for i in range(int(input())):
	(a, b, c) = list(map(int, input().split()))
	l = [a, b, c]
	l.remove(min(l))
	print(sum(l))


for i in range(int(input())):
	a = list(map(int, input().split()))
	a = sorted(a)
	del a[0]
	print(sum(a))


t = int(input())
for _ in range(t):
	(a, b, c) = list(map(int, input().split()))
	print(sum([a, b, c]) - min(a, b, c))


for t in range(int(input())):
	a = [int(i) for i in input().split()]
	s = sum(a)
	a.sort()
	s = s - a[0]
	print(s)


for t in range(int(input())):
	(a, b, c) = map(int, input().split())
	dis = min(a, b, c)
	print(a + b + c - dis)


T = int(input())
for _ in range(T):
	(A, B, C) = map(int, input().split())
	print(max(A + B, B + C, A + C))


t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	cost = [a, b, c]
	cost.sort()
	print(cost[1] + cost[2])


T = int(input())
for i in range(T):
	(a, b, c) = map(int, input().split())
	l = [a, b, c]
	m = min(l)
	print(sum(l) - m)


def glf(x, y, z):
	ans = x + y + z - min(x, y, z)
	print(ans)
t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	g = glf(a, b, c)


for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	print(max(a + b, b + c, a + c))


T = int(input())
for _ in range(T):
	(A, B, C) = map(int, input().split())
	lowest = min(A, B, C)
	print(A + B + C - lowest)