Problem:


Score : 100 points

Problem Statement

You have decided to give an allowance to your child depending on the outcome of the game that he will play now.

The game is played as follows:

There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a + printed on it.

The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)

Then, the amount of the allowance will be equal to the resulting value of the formula.

Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Constraints

All values in input are integers.

1 \leq A, B, C \leq 9

Input

Input is given from Standard Input in the following format:

A B C

Output

Print the maximum possible amount of the allowance.

Sample Input 1

1 5 2

Sample Output 1

53

The amount of the allowance will be 53 when the panels are arranged as 52+1, and this is the maximum possible amount.

Sample Input 2

9 9 9

Sample Output 2

108

Sample Input 3

6 6 7

Sample Output 3

82



Sample input:
1 5 2


Sample output:
53

Submission status: Accepted

Solution code:
import math

# inputList=[]
# for i in range(6):
#     inputNum = input()
#     inputList.append(inputNum)
inputa = input().split()
# inputb = input().split()

inputa = [int(n) for n in inputa]
inputa.sort()

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

# x = int(inputb[0])
# y = int(inputb[1])

print(c * 10 + a + b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())

if max(A,B,C)==A:
    print(A*10+B+C)
elif max(A,B,C)==B:
    print(B*10+A+C)
elif max(A,B,C)==C:
    print(C*10+B+A)

Submission status: Accepted

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

x.sort(reverse=True)
print(x[0]*10+x[1]+x[2])

Submission status: Accepted

Solution code:
a, b, c = sorted(map(int, input().split()), reverse=True)
print(10*a+b+c)

Submission status: Accepted

Solution code:
ABC = list(map(int, input().split()))
ABC.sort(reverse=True)

print( ABC[0] * 10 + ABC[1] + ABC[2] )

Submission status: Accepted

Solution code:
a,b,c = map(int,input().split())
print(max((10*a+b)+c,a+(10*b+c),10*c+a+b))

Submission status: Accepted

Solution code:
A,B,C=sorted([int(s) for s in input().split()])

print(10*C+B+A)

Submission status: Accepted

Solution code:
abc = list(map(int, input().split()))
abc.sort(reverse=True)
print(abc[0] * 10 + abc[1] + abc[2])

Submission status: Accepted

Solution code:
s = list(map(int, input().split()))
print(max(s)*10+sum(s)-max(s))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
money = list(map(int, input().split()))
money.sort(reverse=True)
print(int(str(money[0]) + str(money[1])) + money[2])

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
print(int(max(max(10*A+B+C, 10*B+A+C), A+B+10*C)))

Submission status: Accepted

Solution code:
arr=sorted(list(input().split()))
print(int(arr[2]+arr[1])+int(arr[0]))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = list(map(int,input().split()))
n.sort(reverse=True)
print(n[0]*10+n[1]+n[2])

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
a = sorted(a)
b = [str(a[2]), str(a[1])]
c = ''.join(b)
print(int(c) + a[0])

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
item_list = sorted([A, B, C], reverse=True)

print(item_list[0] * 10 + item_list[1] + item_list[2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
num = list(map(int,input().split()))
ans = sorted(num)[::-1]
print(ans[0]*10 + ans[1] + ans[2])

Submission status: Accepted

Solution code:
li = list(map(int,input().split()))

print (sum(li) + 9 * max(li))

Submission status: Accepted

Solution code:
A = sorted(map(int,input().split()))
print(A[0]+A[1]+A[2]*10)

Submission status: Accepted

Solution code:
l = sorted(list(map(int, input().split())), reverse=True)
print(l[0]*10+l[1]+l[2])

Submission status: Accepted

Solution code:

Ns = list(map(int, input().split()))
Ns.sort(reverse=True)

print (Ns[0]*10 + Ns[1] + Ns[2])

Submission status: Accepted

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

sum = a + b + c
v1 = sum + 9*a
v2 = sum + 9*b
v3 = sum + 9*c
print(max([v1,v2,v3]))

Submission status: Accepted

Solution code:
s = sorted(input().split(), reverse=1)
print(int(s[0] + s[1]) + int(s[2]))

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
a1 = a* 10 + b + c
b1 = b*10 + a + c
c1 = c*10 + a + b
print(max(a1, b1, c1))

Submission status: Accepted

Solution code:
given_list = list(map(int, input().split()))

given_list.sort()
given_list[-1] = given_list[-1] * 10
print(sum(given_list))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a = list(map(int,sorted(input().split(),reverse = True)))
print(a[0]*10+a[1]+a[2])

Submission status: Accepted

Solution code:
s=''.join(input().split())
ss = sorted(s,reverse=True)
ret = "{}*10+{}+{}".format(ss[0],ss[1],ss[2])
print(eval(ret))

Submission status: Accepted

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

Submission status: Accepted

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

x = 10*a+b+c
y = 10*b+a+c
z = 10*c+a+b
print(max(x,y,z))

Submission status: Accepted

Solution code:
a,b,c = list(map(int,input().split()))
m = max([a,b,c])
print(m*10+a+b+c-m)

Submission status: Accepted

Solution code:
a,b,c = map(int,input().split())
print(max(10*a+b+c, 10*b+a+c, 10*c+a+b))

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())
if max(A,B,C)==A:
	print(10*A+B+C)
elif max(A,B,C)==B:
	print(A+10*B+C)
else:
	print(A+B+10*C)

Submission status: Accepted

Solution code:
#https://atcoder.jp/contests/abc110/tasks/

abc = [int(i) for i in input().split()]

abc.sort()

print(abc[2] * 10 + abc[1] + abc[0])

Submission status: Accepted

Solution code:
a,b,c=(input().split())
l=[a,b,c]
L=sorted(l)
print(int(L[2]+L[1])+int(L[0]))

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
ans = max(10*A + B + C, A+ 10*B + C, A + B + 10*C)
print(ans)

Submission status: Accepted

Solution code:
i = sorted(input().rstrip().split(" "), reverse=True)
print(int(i[0]+i[1]) + int(i[2]))

Submission status: Accepted

Solution code:
i = sorted(list(input().rstrip().split(" ")), reverse=True)
print(int(i[0]+i[1]) + int(i[2]))

Submission status: Accepted

Solution code:
i = list(input().rstrip().split(" "))
i = sorted(i, reverse=True)
print(int(i[0]+i[1]) + int(i[2]))

Submission status: Accepted

Solution code:
i = list(map(int, input().rstrip().split(" ")))
i = sorted(i, reverse=True)
print(i[0]*10+i[1]+i[2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
a = sorted(a, reverse=True)
print(a[0] * 10 + a[1] + a[2])

Submission status: Accepted

Solution code:
#list = []
list = list( map(int, input().split() ) )

list.sort(reverse=True)

print( list[0]*10 + list[1] + list[2] )

Submission status: Accepted

Solution code:
S = "".join(sorted(input().split(), reverse=True))
print(int(S[0:2])+int(S[2]))

Submission status: Accepted

Solution code:
def main():
    l = list(map(int,input().split()))
    l = sorted(l,reverse=True)
    ans = ''

    ans = 10* l[0] + l[1] + l[2]
    print(ans)


    '''
    for i in range(0,len(l)-1):
        ans = ans + str(l[i])
    ans_int = int(ans) + int(l[-1])

    print(ans_int)
    '''




if __name__ == '__main__' :
    main()

Submission status: Accepted

Solution code:
def main():
    l = list(map(int,input().split()))
    l = sorted(l,reverse=True)
    ans = ''

    for i in range(0,len(l)-1):
        ans = ans + str(l[i])
    ans_int = int(ans) + int(l[-1])

    print(ans_int)




if __name__ == '__main__' :
    main()

Submission status: Accepted

Solution code:
a, b, c = list(map(int, input().split()))
print(max(a, b, c) * 9 + a + b + c)

Submission status: Accepted

Solution code:
#13:18
a = list(map(int,input().split()))
print( sum(a) + 9 * max(a) )

Submission status: Accepted

Solution code:
N = input().split()
K = []
for i in range(len(N)):
  K.append(int(N[i]))
K.sort(reverse = True)
print(K[0] * 10 + K[1] + K[2])

Submission status: Accepted

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

# 最大の数を十の位として使う
print((max(a,b,c)*10)+a+b+c-max(a,b,c))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#110 Maximize the Formula

li = list(map(int, input().rstrip().split()))
li.sort()

print(li[2]*10 + li[1] + li[0])

Submission status: Accepted

Solution code:
num = sorted(map(int, input().split()))

a = num[2]*10+num[1]
print(a + num[0])

Submission status: Accepted

Solution code:
A= list(map(int, input().split()))
B= sorted(A,reverse=True)
print(B[0]*10+B[1]+B[2])

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())

p=max(A,B,C)

print(p*9+A+B+C)

Submission status: Accepted

Solution code:
a,b,c = map(int, input().split())
list = []
list.append(a)
list.append(b)
list.append(c)
list.sort()
max = list[2]*10+list[1]+list[0]
print(max)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-


if __name__ == '__main__':
    a, b, c = sorted(map(int, input().split(' ')))
    print(10 * c + b + a)

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
s = [a, b, c]
s.sort(reverse=True)
s1 = str(s[0])+str(s[1])
print(int(s1) + int(s[-1]))

Submission status: Accepted

Solution code:
l = list(map(int, input().split()))
m = max(l)
print(sum(l) - m + m * 10)

Submission status: Accepted

Solution code:
import itertools

a,b,c = map(int,input().split())
abc = list(itertools.permutations([a,b,c]))

#print(abc)

max_sum = 0

for i in range(len(abc)):
    max_tmp = abc[i][0]*10+abc[i][1]+abc[i][2]
    if max_tmp > max_sum:
        max_sum = max_tmp

print(max_sum)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
Tmp = []
Tmp = input().rstrip().split(' ')
 
Ans = []
 
nA = int(Tmp[0])
Ans.append(nA)
 
nB = int(Tmp[1])
Ans.append(nB)
  
nC = int(Tmp[2])
Ans.append(nC)
 
Ans.sort(reverse=True)
 
nAns = Ans[0]*10+Ans[1]+Ans[2]
print(nAns)

Submission status: Accepted

Solution code:
num=list(map(int,input().split()))
num.sort(reverse=True)
print(int(str(num[0])+str(num[1]))+num[2])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X = list(map(int, input().split()))
print(max(X)*9+sum(X))

Submission status: Accepted

Solution code:
nums = [int(i) for i in input().split()]
nums.sort()
print(nums[2]*10+nums[0]+nums[1])

Submission status: Accepted

Solution code:
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac

setrecursionlimit(1000000)


def main():
	a = list(map(int,input().split()))
	a.sort()
	print(a[2]*10+sum(a[:2]))
	

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(l):
	x = l.pop()
	y = l.pop()
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	l.append(min(x,y))
	return gcd(l) if len(l) > 1 else l[0]

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

main()

Submission status: Accepted

Solution code:
*l,=map(int,input().split());print(max(l)*9+sum(l))

Submission status: Accepted

Solution code:


def main():
    target = input().split()
    target.sort(reverse=True)
    left = target[:2]
    right = target[-1]
    print(int(''.join(left))+int(right[0]))




     


        
    
if __name__== "__main__":
    main()

Submission status: Accepted

Solution code:
abc = input().split(' ')
nums = []
nums.append(int(abc[0] + abc[1]) + int(abc[2]))
nums.append(int(abc[1] + abc[0]) + int(abc[2]))
nums.append(int(abc[0]) + int(abc[1] + abc[2]))
nums.append(int(abc[0]) + int(abc[2] + abc[1]))
nums.append(int(abc[0] + abc[2]) + int(abc[1]))
nums.append(int(abc[2] + abc[0]) + int(abc[1]))
print(max(nums))

Submission status: Accepted

Solution code:
l = [int(i) for i in input().split()]
m = []
for i in range(3):
    m.append(10*l[i]+l[i-1]+l[i-2])
print(max(m))

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
X = 10*A + B + C
Y = 10*B + A + C
Z = 10*C + A + B
print(max(X, Y, Z))

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
print(max(a, b, c) * 9 + (a + b + c))

Submission status: Accepted

Solution code:
x = list(map(int,input().split()))
a = str(max(x))+str(sorted(x)[1])
print(int(a)+min(x))

Submission status: Accepted

Solution code:
A = [int(i) for i in input().split()]
print(max(A)*9+sum(A))

Submission status: Accepted

Solution code:
str = input().split()
slist = []
for i in str:
  slist.append(int(i))
slist.sort(reverse=True)
sum = slist[0]*10+slist[1]+slist[2]
print(sum)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A
lst = list(map(str, input().split()))
sorted_lst = sorted(lst, reverse=True)
print(int("".join(sorted_lst[0:2])) + int(sorted_lst[2]))

Submission status: Accepted

Solution code:
l = [int(i) for i in input().split(" ")]
total = max(l)*9 + sum(l)
print(total)

Submission status: Accepted

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

l.sort(reverse=True)
print(l[0]*10 + l[1] + l[2])

Submission status: Accepted

Solution code:
s = list(map(int,input().split()))
print(max(s)*9+sum(s))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = list(map(int,input().split()))
print (sum(l)+9*max(l))

Submission status: Accepted

Solution code:
n=sorted(input())[::-1];print(eval(n[0]+n[1])+int(n[2]))

Submission status: Accepted

Solution code:

x =map(int,input().split())
x = sorted(x, reverse=True)

print(x[0] * 10 + x[1] + x[2])

Submission status: Accepted

Solution code:
A=list(map(int,input().split()))
A.sort(reverse=True)
print((A[0]*10+A[1])+A[2])

Submission status: Accepted

Solution code:
n=list(map(int,input().split()))
n.sort(reverse=True)
print(n[0]*10+n[1]+n[2])

Submission status: Accepted

Solution code:
N = list(map(int, input().split()))
N.sort(reverse=True)
print(N[0]*10 + N[1] + N[2])

Submission status: Accepted

Solution code:
A_arr = sorted([int(x) for x in input().split()])
print(A_arr[2]*10+A_arr[1]+A_arr[0])

Submission status: Accepted

Solution code:
num = list(map(int, input().split()))
num.sort(reverse = True)
print(num[0]*10+num[1]+num[2])

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

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

abc.sort(reverse=True)

# print(abc)

# print(abc[0])
# print(abc[1])
# print(abc[2])

print(((abc[0] * 10) + (abc[1])) + abc[2])

Submission status: Accepted

Solution code:
panel = input().split()
panel.sort(reverse=True)
one = int(panel[0] + panel[1])
two = int(panel[2])
print(one + two)

Submission status: Accepted

Solution code:
a,b,c = map(int,input().split())
print(max(10*a+b+c,10*b+c+a,10*c+a+b))

Submission status: Accepted

Solution code:
ABC = list(map(int, input().split()))
mi = ABC.pop(ABC.index(min(ABC)))
ma = ABC.pop(ABC.index(max(ABC)))
print((ma * 10) + ABC[0] + mi)

Submission status: Accepted

Solution code:
words = lambda t : list(map(t, input().split()))
xs = words(int)
xs = list(reversed(sorted(xs)))
print(xs[0]*10 + xs[1] + xs[2])

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
print(max(a)*10+sum(a)-max(a))

Submission status: Accepted

Solution code:
a=list(map(int,input().split()))
b=sorted(a,reverse=True)
print(b[0]*10+b[1]+b[2])

Submission status: Accepted

Solution code:
li = list(map(int, input().split()))

li.sort()
print(li[0] + li[1] + 10 * li[2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C = map(int, input().split())
List = [A,B,C]
List.sort()
ans = List[2]*10 + List[0] + List[1]
print(ans)

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
print(A+B+C+9*max(A,B,C))

Submission status: Accepted

Solution code:
import statistics
N = list(map(int,input().split()))
A = max(N)
B = min(N)
C = sum(N)-A-B
print(A*10+B+C)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

# solve
l.sort()

# output
print(l[-1] * 10 + l[1] + l[0])

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

a.sort()

out = a[-1] * 10 + a[0] + a[1]

print(out)

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
a = sorted(a)
ans = str(a[-1]) + str(a[-2])
print(int(ans)+ a[0])

Submission status: Accepted

Solution code:
li = sorted(list(map(int, input().split())),reverse = True)
print(int(str(li[0])+str(li[1]))+li[2])

Submission status: Accepted

Solution code:
nums = list(map(int, input().split()))
nums.sort(key=lambda x: -x)
print(int(str(nums[0]) + str(nums[1])) + nums[2])

Submission status: Accepted

Solution code:
l=list(map(int,input().split()))
print(sum(l)+max(l)*9)

Submission status: Accepted

Solution code:
a=list(map(int,input().split()))
print(sum(a)+max(a)*9)

Submission status: Accepted

Solution code:
A,B,C =map(int,input().split())
print(max(A,B,C)*9+A+B+C)

Submission status: Accepted

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

y=sorted(x)

res=y[2]*10+y[0]+y[1]

print(res)

Submission status: Accepted

Solution code:
a,b,c =map(int,input().split())
l = [a,b,c]
l.sort()

res = 10*l[2]+l[0]+l[1]
print(res)

Submission status: Accepted

Solution code:
cards = input().split()
cards.sort(reverse = True)
print(int(cards[0]+cards[1])+int(cards[2]))

Submission status: Accepted

Solution code:
nums = list(map(int, input().split(' ')))

nums.sort()
nums.reverse()

print(nums[0] * 10 + nums[1] + nums[2])

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())

l = sorted([x,y,z], reverse=True)
print( l[0] * 10 + l[1] + l[2] )

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())

max = max([A,B,C])
print(sum([A,B,C])-max+max*10)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#A
def A():
    a = LI()
    a.sort()
    a, b, c = a
    print(int(str(c)+str(b))+a)
    return

#B
def B():
    return

#C
def C():
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    A()

Submission status: Accepted

Solution code:
a = map(int, input().split())
a = sorted(a, reverse=True)
print(a[0] * 10 + a[1] + a[2])

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
ABC = [int(i) for i in input().split()]
ABC.sort(reverse = True)
print(ABC[0]*10 + ABC[1] + ABC[2])

Submission status: Accepted

Solution code:
l = list(map(int, input().split()))
l.sort(reverse=True)
print(int(str(l[0]) + str(l[1])) + l[2])

Submission status: Accepted

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

print(a[2]*10+a[1]+a[0])

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
maxi = max(a, b, c)
print(str(a + b + c + maxi*9))

Submission status: Accepted

Solution code:
l = list(input().split())
l.sort()

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

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
print(max([10*A+B+C, 10*B+A+C, 10*C+A+B]))

Submission status: Accepted

Solution code:
abc = map(int, input().split())
ab = sorted(abc, reverse=True)[:3]
hoge = str(ab[0]) + str(ab[1])
print(int(hoge) + ab[2])

Submission status: Accepted

Solution code:
l = list(map(int,input().split()))
l.sort()
print(sum(l[:2])+l[2]*10)

Submission status: Accepted

Solution code:
i = input().split(' ')
a = sorted(i)[-1] + sorted(i)[-2]
b = sorted(i)[0]
print(int(a) + int(b))

Submission status: Accepted

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

b = sorted(a)

print(10 * b[2] + b[1] + b[0])

Submission status: Accepted

Solution code:
a = sorted(list(map(int, input().split())), reverse=True)
print(a[0] * 10 + a[1] + a[2])

Submission status: Accepted

Solution code:
l=sorted(list(input().split()),reverse=True)
l.insert(2,"+")
print(eval("".join(l)))

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
a = sorted(a, reverse=True)
b = 10 * a[0] + a[1] + a[2]
print(b)

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
print(max((10 * a + b + c), (a + 10 * b + c), (a + b + 10 * c)))

Submission status: Accepted

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

print(int(str(list[2])+str(list[1])) + list[0])

Submission status: Accepted

Solution code:
n = sorted([int(num) for num in input().split()])
print(n[2]*10+n[1]+n[0])

Submission status: Accepted

Solution code:
abc=list(map(int,input().split()))
print(max(abc)*9+sum(abc))

Submission status: Accepted

Solution code:
l = list(map(int, input().split()))
l.sort()
a = l.pop(-1)*10
print(a + sum(l))

Submission status: Accepted

Solution code:
#a, b, c = map(int,input().split())
ls = list(map(int,input().split()))
ls.sort(reverse=True)
print(ls[0] * 10 + ls[1] + ls[2])

Submission status: Accepted

Solution code:
def resolve():
	l=list(map(int,input().split()))
	ls=sorted(l)
	
	
	
	print(ls[2]*10+ls[1]+ls[0])

resolve()

Submission status: Accepted

Solution code:
ABC = [int(x) for x in input().split()]
#複数の整数を入力する場合はこうでABCという名のリストにしてる
ABC.sort()
#ABCリストを昇順で書き換える
answer = ABC[-1]*10 + sum(ABC[:2])
#昇順の時、一番後ろに来るのが最大値なのでそれを10倍。残り二つ(前二つ)を足す。
print(answer)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a =  list(map(int,(input().split())))
a.sort(reverse=True)
#print(a)
x = str(a[0])+str(a[1])
print(int(x)+a[2])

Submission status: Accepted

Solution code:
S = list(input().split())
S.sort()

s = S[2] + S[1]
print(int(s) + int(S[0]))

Submission status: Accepted

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

Submission status: Accepted

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

a.sort(reverse=True)

print(a[0] * 10 + a[1] + a[2])

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())

from functools import reduce

lst = [10*A+B+C, 10*A+C+B, 10*B+A+C, 10*B+C+A, 10*C+A+B, 10*C+B+A]

print(reduce(max, lst))

Submission status: Accepted

Solution code:
lst = [int(i) for i in input().split()]
lst_sort=sorted(lst,reverse=True)
print(lst_sort[0]*10+lst_sort[1]+lst_sort[2])

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())

A,B,C=LI()

print(max(10*A+B+C, 10*B+A+C, 10*C+B+A))

Submission status: Accepted

Solution code:
a,b,c=map(int,input().split())
A=max(a,b,c)
B=min(a,b,c)
C=a+b+c-A-B
print((A*10+C)+B)

Submission status: Accepted

Solution code:
S = list(map(int,input().split()))
ans=max(S)*9+sum(S)
print(ans)

Submission status: Accepted

Solution code:
a = list(input())
a.sort(reverse=True)
print(int(a[0]+a[1])+int(a[2]))

Submission status: Accepted

Solution code:
c = sorted(list(map(int, input().split())),reverse=True)

print(c[0] * 10 + c[1] + c[2])

Submission status: Accepted

Solution code:
X = input().split()
formulas = []
formulas.append(''.join(X[0]+X[1]+"+"+X[2]))
formulas.append(''.join(X[1]+X[2]+"+"+X[0]))
formulas.append(''.join(X[2]+X[0]+"+"+X[1]))
print(max([eval(x) for x in formulas]))

Submission status: Accepted

Solution code:
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

A, B, C = sorted(nl(), reverse=True)
print(int(str(A) + str(B)) + C)

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
k= max(A, B, C)
print(k*9+A+B+C)

Submission status: Accepted

Solution code:
nums = list(map(int, input().split()))

nums.sort()

#print(nums)

A = 10 * int(nums[2]) + int(nums[1])
B = int(nums[0])

print(A + B)

Submission status: Accepted

Solution code:
x = sorted([int(x) for x in input().split()])
print(x[0] + x[1] + 10 * x[2])

Submission status: Accepted

Solution code:
dig = input().split()
dig.sort()
print(eval(dig[2] + dig[1] + '+' + dig[0]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=input().split()
for i in range(3):
   a[i]=int(a[i])
s=9*max(a)+sum(a)
print(s)

Submission status: Accepted

Solution code:
a, b, c = sorted(input().split())
print(eval(c+b+'+'+a))

Submission status: Accepted

Solution code:
S = sorted(input().split(), reverse=True)
print(int(S[0]+S[1]) + int(S[2]))

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
x = max(a)
a.remove(max(a))
print(10*x + a[0] +a[1])

Submission status: Accepted

Solution code:
S = sorted(input().split(), reverse=True)
print(eval(S[0]+S[1]+ '+' + S[2]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
a.sort(reverse=True)
print(int(str(a[0])+str(a[1])) + a[2])

Submission status: Accepted

Solution code:
ABC=sorted(map(int,input().split()));print(int(str(ABC[2])+str(ABC[1]))+ABC[0])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# INPUT
num = list(map(int, input().split()))

# # PROCESS
answer = 0
first_max = max(num)
num.remove(first_max)
second_max = max(num)
num.remove(second_max)
third_max = max(num)

answer = int(str(first_max) + str(second_max)) + third_max


# OUTPUT
print(answer)

Submission status: Accepted

Solution code:
L=sorted(list(map(int, input().split())))
print(int(str(L[2])+str(L[1]))+L[0])

Submission status: Accepted

Solution code:
A = map(int, input().split())
A = sorted(A)
print(A[2] * 10 + A[1] + A[0])

Submission status: Accepted

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

print(a + b + c + max(a, b, c) * 9)

Submission status: Accepted

Solution code:
li = list(map(int,input().split()))
li.sort(reverse=True)
print(li[0]*10+sum(li[1:]))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def solve(A: int, B: int, C: int):
    a = [A, B, C]
    a = sorted(a, reverse=True)
    print(a[0]*10 + a[1] + a[2])
    return


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    solve(A, B, C)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
abc = list(map(int, input().split()))
abc.sort(reverse = True)
print(abc[0]*10+abc[1]+abc[2])