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

A = a[2]
B = a[1]
C = a[0]


ans = max(A+int(str(B) + str(C)),int(str(A) + str(B))+C)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    l = [int(i) for i in input().split()]
    l.sort(reverse=True)
    print(10*l[0]+l[1]+l[2])
main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

lists = [a,b,c]

maxi = max(lists)
mini = min(lists)

print(maxi*10 + a + b + c -maxi)

Submission status: Accepted

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

Submission status: Accepted

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

arr.sort()

A = int(str(arr[2])+str(arr[1]))

B = int(arr[0])

print( A + B )

Submission status: Accepted

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

X =a*10 + b + c
Y =b*10 + a + c
Z =c*10 + a + b
ans =max(X,Y,Z)
print(ans)

Submission status: Accepted

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

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

abc.sort()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
array_no = list(map(int,input().split()))
for I in array_no:
    if not (1 <= I <= 9): sys.exit()

max_first = array_no.pop(array_no.index(max(array_no)))
max_second = array_no.pop(array_no.index(max(array_no)))
print(int(str(max_first)+str(max_second)) + array_no[0])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    a=sorted(map(int,input().split()))
    print(a[2]*10+a[0]+a[1])
    
if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

rl = lambda: list(map(int, sys.stdin.buffer.readline().split()))

a = sorted(rl(), reverse=True)
print(a[0]*10 + a[1] + a[2])

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.buffer.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a = sorted(rl(), 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 + sum(N[1:]))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

res = 0
res = max(res, a * 10 + b + c)
res = max(res, b * 10 + a + c)
res = max(res, c * 10 + b + a)

print(res)

Submission status: Accepted

Solution code:
li = list(map(int,input().split()))
li.sort(reverse=True)
print((li[0]*10)+li[1]+li[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:
abc = sorted(list(map(int,input().split())))
add = str(abc[2]) + str(abc[1])
print(int(add) + abc[0])

Submission status: Accepted

Solution code:
import itertools

aa = tuple(map(int, input().split()))
ma = 0
for a in itertools.permutations(aa, 3):
    ma = max(ma, a[0] * 10 + a[1] + a[2])
print(ma)

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
li = LI()
li.sort(reverse=True)
print(int(str(li[0]) + str(li[1])) + li[2])

Submission status: Accepted

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


if '__main__' == __name__:
    resolve()

Submission status: Accepted

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

f = max(a, b, c)
if f == a:
    print(a*10 + int(str(b+c)))
elif f == b:
    print(b*10 + int(str(a+c)))
else:
    print(c*10 + int(str(b+a)))

Submission status: Accepted

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

Submission status: Accepted

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

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:
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    ABC = LI()

    ABC.sort()

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

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
L = sorted(list(map(int, input().split())))
print(10*L[2] + L[1] + L[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:
a, b, c = map(int, input().split())

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

if x>y and x>z:
  print(x)
elif y > z:
  print(y)
else:
  print(z)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

num.sort()

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

print(e)

Submission status: Accepted

Solution code:
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())
print(9*max(a,b,c)+a+b+c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

ans = []

ans.append(int(A) + int(B+C))
ans.append(int(A) + int(C+B))
ans.append(int(B) + int(A+C))
ans.append(int(B) + int(C+A))
ans.append(int(C) + int(A+B))
ans.append(int(C) + int(B+A))

print(max(ans))

Submission status: Accepted

Solution code:
print(eval('+'.join(max(a:=input())*9+a)))

Submission status: Accepted

Solution code:
a,b,c=map(int,input().split())
lst=[a,b,c]
lst=sorted(lst)
print(10*(lst[-1])+sum(lst[: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:
a=list(map(int,input().split()))
a.sort()
print(a[2]*10+a[0]+a[1])

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:
nums = sorted([int(i) for i in input().split()])

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

Submission status: Accepted

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

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

print(eval("{}{} + {}".format(s[0], s[1], s[2])))

Submission status: Accepted

Solution code:
import statistics

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

print(int(str(max(l))+str(min(l))) +statistics.median(l))

Submission status: Accepted

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


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(A+B+10*C)

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

ABC.sort(reverse=True)

print(int(''.join(map(str, ABC[:2]))) + int(ABC[-1]))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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 = sorted(map(int, input().split()), reverse=True)
print(int(str(n[0])+str(n[1])) + n[2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    from builtins import int, map, list, print, sorted
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b,c = sorted([ int(n) for n in input().split() ])
print( 10*c+b+a )

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

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

Submission status: Accepted

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

X = sorted(X, reverse=True)
print(X[0]*10 + X[1] + X[2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:

def limpstr():return list(map(str,input().split()))

l=limpstr()
l.sort(reverse=True)
print(int(l[0]+l[1])+int(l[2]))

Submission status: Accepted

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

Submission status: Accepted

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

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)
print(a[-1]*10+a[1]+a[0])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = [int(i) for i in input().split()]
a.sort()
ans = ""
ans += str(a[-1])
ans += str(a[-2])
print(a[0] + int(ans))

Submission status: Accepted

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

lis = sorted(lis)

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

Submission status: Accepted

Solution code:
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())
x = a+b+c

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a, b, c = input().split()
lst = [a, b, c]
r_lst = sorted(lst, reverse=True)
x = ''.join(n for n in r_lst[:2])
y = ''.join(i for i in r_lst[-1:])
print(int(x)+int(y))

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:
print(eval("+".join(sorted(input()))+"*10"))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

ans = max(x, y, z)

print(ans)

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:
A,B,C=sorted(map(int,input().split()))
print(C*10+A+B)

Submission status: Accepted

Solution code:
A = list(map(int,input().split()))
B = str(sorted(A)[-1])
C = str(sorted(A)[-2])
print(int(B+C)+min(A))

Submission status: Accepted

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

Submission status: Accepted

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

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

l.sort()

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

Submission status: Accepted

Solution code:
A,B,C = sorted(input().split())
a = C+B+"+"+A

print(eval(a))

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:
abc = input()
abc_lis_str = abc.split()
abc_lis_int = [int(i) for i in abc_lis_str]
abc_lis = sorted(abc_lis_int, reverse=True)
a = abc_lis[0]
b = abc_lis[1]
c = abc_lis[2]

print( a * 10 + b + c )

Submission status: Accepted

Solution code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial#, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    num_list = i_list()

    num_list.sort(reverse=True)

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b,c = map(int,input().split())
n1,n2,n3 = sorted([a,b,c],reverse= True)

print(10*n1 + n2 + n3)

Submission status: Accepted

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

max_num = str(max(lis))
lis.pop(lis.index(int(max_num)))

if lis[0] > lis[1]:
    result = int(max_num + str(lis[0])) + lis[1]
else:
    result = int(max_num + str(lis[1])) + lis[0]

print(result)

Submission status: Accepted

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

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

n1, n2, n3 = sorted([a, b, c], reverse=True)

print(10*n1 + n2 + n3)

Submission status: Accepted

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

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

X=[A,B,C]

Y=sorted(X,reverse=True)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8

# https://atcoder.jp/contests/abc110
# 14:05-


def main():
    a, b, c = map(int, input().split())
    abc = sorted([a, b, c], reverse=True)

    return abc[0] * 10 + abc[1] + abc[2]


print(main())

Submission status: Accepted

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

h = a + b + c
i = max(a,b,c)
j = i * 10
print(j + h - i)

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

sorted_ABC = sorted(ABC,reverse=True)

S = sorted_ABC[0] * 10 +  sorted_ABC[1] + sorted_ABC[2]

print(S)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

tmp = []
ans = []
tmp.append(a)
tmp.append(b)
tmp = ''.join(tmp)
ans.append(int(tmp)+int(c))

tmp = []
tmp.append(b)
tmp.append(c)
tmp = ''.join(tmp)
ans.append(int(tmp)+int(a))

tmp = []
tmp.append(a)
tmp.append(c)
tmp = ''.join(tmp)
ans.append(int(tmp)+int(b))

tmp = []
tmp.append(c)
tmp.append(a)
tmp = ''.join(tmp)
ans.append(int(tmp)+int(b))

tmp = []
tmp.append(b)
tmp.append(a)
tmp = ''.join(tmp)
ans.append(int(tmp)+int(c))


tmp = []
tmp.append(c)
tmp.append(b)
tmp = ''.join(tmp)
ans.append(int(tmp)+int(a))

print(max(ans))

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:
abc = sorted(list(map(int, input().split())), reverse=True)
print(abc[0] * 10 + abc[1] + abc[2])

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:
a, b, c = sorted(map(int, input().split()))
print(10 * c + b + a)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
A = sorted([int(s) for s in input().split()])[::-1]
print(A[0]*10 + A[1] + A[2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A - Maximize the Formula

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

ans = 0

ans = max(ans, A*10+B+C)
ans = max(ans, A+B*10+C)
ans = max(ans, A+B+C*10)

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = input().split()
num = sorted([A, B, C], reverse=True)
num1 = int(''.join(num)[:2])
num2 = int(num[2])
print(num1+num2)

Submission status: Accepted

Solution code:
li=list(map(int,input().split()))
ma=max(li)*10
li.remove(max(li))
li.append(ma)
print(sum(li))

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

Submission status: Accepted

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

Submission status: Accepted

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

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,b,c = sorted(map(int,input().split()))
print(a+b+c*10)

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:
import sys
from itertools import permutations
def input(): return sys.stdin.readline().strip()


def main():
    a, b, c = map(int, input().split())
    ans = 0
    for p, q, r in list(permutations([a, b, c])):
        ans = max(ans, 10 * p + q + r, p + 10 * q + r)
    print(ans)


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def examA():
    A = LI()
    A.sort()
    ans = A[2]*10+A[1]+A[0]
    print(ans)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examA()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

# check
ABC.sort(reverse=True)
X = 10 * ABC[0] + ABC[1]
Y = ABC[2]
print(X + Y)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

num.sort(reverse=True)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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