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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(5 * 10**5)
input = sys.stdin.readline

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X, Y, Z = sorted(map(int,input().split()))
print(X+Y+10*Z)

Submission status: Accepted

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

print(10*C+B+A)

Submission status: Accepted

Solution code:
ni = lambda: int(input())
nl = lambda: list(map(int, input().split()))
nm = lambda: map(int, input().split())

l = nl()

sl = sorted(l)[::-1]

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

Submission status: Accepted

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

Submission status: Accepted

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

l = [A,B,C]

for i in range(3):
  if ans < (10*l[i%3] + l[(i+1)%3] + l[(i+2)%3]):
    ans = 10*l[i%3] + l[(i+1)%3] + l[(i+2)%3]

print(ans)

Submission status: Accepted

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

l = [A,B,C]
sort_l = sorted(l)

sort_l_str = str(sort_l[2])+str(sort_l[1])

sort_l_int = int(sort_l_str)

print(sort_l[0]+sort_l_int)

Submission status: Accepted

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

M=[A,B,C]
U=max(M)
M.remove(max(M))
P=U*10+sum(M)

print(P)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = [int(x) for x in input().split()]
max_int = s.pop(s.index(max(s)))
print(max_int * 10 + sum(s))

Submission status: Accepted

Solution code:
num = sorted(map(int,input().split()))[::-1]

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from itertools import permutations
from copy import copy

choices = list(map(int, input().split()))
combs = permutations(choices, 2)

res = 0

for comb in combs:
    left = copy(choices)
    for num in comb:
        left.remove(num)
    right = int(str(comb[0]) + str(comb[1]))
    total = left[0] + right
    if total > res:
        res = total

print(res)

Submission status: Accepted

Solution code:
number = list(map(str, input().split()))

number.sort()

print(int(number[-1] + number[-2]) + int(number[0]))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    ABC = list( map(int, input().split()))
    ABC.sort()
    num = ABC.pop()*10 + ABC.pop() + ABC.pop()
    print(num)

Submission status: Accepted

Solution code:
listabc = sorted(list(map(int,input().split())))
print(9*listabc[2]+sum(listabc))

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=map(str,input().split())
ans = max(int(a+b)+int(c),int(a)+int(b+c))
hoge = max(int(b+a)+int(c),int(a)+int(c+b))
fuga = max(int(b)+int(a+c),int(b)+int(c+a))

print(max(max(ans,hoge),fuga))

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = list(input().split())
S.sort(reverse=True)
a = int("".join(S[:2]))
b = int(S[2])
print(a+b)

Submission status: Accepted

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

s = a + int(str(b)+str(c))
t = c + int(str(b)+str(a))
u = b + int(str(c)+str(a))
v = a + int(str(c)+str(b))
w = c + int(str(a)+str(b))
x = b + int(str(a)+str(c))

print(max(s,t,u,v,w,x))

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = list(map(int, input().split()))
A = max(S)
S.remove(A)
B = max(S)
S.remove(B)
C = S.pop()
print(int(str(A) + str(B)) + C)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A - Maximize the Formula
A = list(map(int,input().split()))
A_new=sorted(A,reverse=True)
A2=str(A_new[0])+str(A_new[1])
ans = int(A2)+ A_new[2]
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = sorted(map(int,input().split()),reverse=True)
print(eval(''.join(map(str,l[:2]))+'+'+str(l[2])))

Submission status: Accepted

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

def main():
    # A,B,C  = map(int, input().split())
    V = sorted(map(int, input().split()),reverse=True)
    print(10*V[0]+V[1]+V[2])
        
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b,c = sorted([int(i) for i in input().split()],reverse = True)

print(10*a + b + c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=input().split()
a.sort()
print(int(a[-1]+a[-2])+int(a[-3]))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(max(a, b, c) * 10 + a + b + c - max(a, b, c))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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


def solve(A: int, B: int, C: int):
    l = [A, B, C]
    if max(l) == A:
        print(A * 10 + B + C)
    elif max(l) == B:
        print(A + B * 10 + C)
    else:
        print(A + B + C * 10)
    return


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

S = list(map(str, input().split()))

ans = 0
for i in range(3):
    for j in range(3):
        for k in range(3):
            if i==j or j==k or k==i: continue
            a=S[i]
            b=S[j]+S[k]
            ans=max(ans,int(a)+int(b))
print(ans)

Submission status: Accepted

Solution code:
s=list(input().split())
s.sort()
min=int(s[0])
max=int(s[2]+s[1])
total=max+min
print(total)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
l=list(map(int,input().split()))

ls=sorted(l)

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

d = max(int(a+b)+int(c),int(a+c)+int(b),
int(b+a)+int(c),int(b+c)+int(a),
int(c+a)+int(b),int(c+b)+int(a))

print(d)

Submission status: Accepted

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

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

Submission status: Accepted

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

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

buf.sort()

print(max(buf)*10+buf[1]+buf[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=sorted(input().split())
print(int(A[2]+A[1])+int(A[0]))

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)
A = A[::-1]

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = list(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())
list = [a,b,c]
list.sort(reverse=True)
print(list[0]*10 + list[1] + list[2])

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:
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())
l=sorted([a,b,c])
print(l[2]*10 + l[1] + l[0])

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
abc = list(sorted(map(str, input().split())))

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
n = input().split()
n = [int(n[i]) for i in range(len(n))]
n.sort()
n = n[::-1]

total = ''
for i in range(len(n)):
    if i == 0 or i == 1:
        total += str(n[i])
    else:
        total += '+'
        total += str(n[i])
print(eval(total))

Submission status: Accepted

Solution code:
l=[int(x) for x in input().split()]
l.sort()
print(l[0]+l[1]+10*l[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:
a, b, c = sorted(input().split())
print(int(c+b)+int(a))

Submission status: Accepted

Solution code:
def main():
    a, b, c = input().split()
    ans = 0
    ans = max(ans, int(a)+int(b+c))
    ans = max(ans, int(a)+int(c+b))
    ans = max(ans, int(b)+int(a+c))
    ans = max(ans, int(b)+int(c+a))
    ans = max(ans, int(c)+int(a+b))
    ans = max(ans, int(c)+int(b+a))
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

print(l[2] * 10 + sum(l[:2]))

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:
# -*- coding: utf-8 -*-

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

abc.sort(reverse = True)

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

Submission status: Accepted

Solution code:
print(eval('{}{}+{}'.format(*sorted(list(map(int, input().split())))[::-1])))

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

Submission status: Accepted

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

Submission status: Accepted

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

card = [a, b, c]
card.sort()
print(10*card[-1] + card[0] + card[1])

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    func()

Submission status: Accepted

Solution code:
def func():
    A, B, C = map(str, input().split())
    cand1 = int(A + B) + int(C)
    cand2 = int(B + C) + int(A)
    cand3 = int(A + C) + int(B)
    cand4 = int(B + A) + int(C)
    cand5 = int(C + B) + int(A)
    cand6 = int(C + A) + int(B)
    print(max(cand1, cand2, cand3, cand4, cand5, cand6))


if __name__ == '__main__':
    func()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

ans = 10*A[2] + A[1] + A[0]

print(ans)

Submission status: Accepted

Solution code:
#coding:utf-8
a, b, c = map(int, input().split())

#パターンを列挙 10の桁をどこにするかで3通り
x = a * 10 + b + c
y = a + b * 10 + c
z = a + b + c * 10

print(max(x, y, z))

Submission status: Accepted

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

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, 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:
a, b, c = map(int, input().split())
if 1 <= a or b or c <= 9:
    print(max(10 * a + b + c, 10 * b + a + c, 10 * c + a + b))
else:
    print('hoge!')

Submission status: Accepted

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

Submission status: Accepted

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

x = str(a[-1]) + str(a[-2])

print(a[0] + int(x))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = list(input().split())

N_sort = sorted(N)

print(int(N_sort[2]) * 10 + int(N_sort[1]) + int(N_sort[0]))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    A = list(map(int, input().split()))

    sort_A = sorted(A, reverse=True)
    ans = int(str(sort_A[0]) + str(sort_A[1])) + sort_A[2]
    print(ans)

main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    A, B, C = map(int, input().split())
    v = max([A, B, C])
    if v == A:
        return 10*A+B+C
    elif v == B:
        return 10*B+A+C
    else:
        return 10*C+A+B

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

Submission status: Accepted

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

Submission status: Accepted

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

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=map(int, input().split())
ans=9*max(a,b,c)+a+b+c
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 = map(int, input().split())

max_num = max([a, b, c])
if a == max_num:
    print(a * 10 + b + c)
elif b == max_num:
    print(b * 10 + c + a)
else:
    print(c * 10 + a + b)

Submission status: Accepted

Solution code:
a,b,c=map(int,input().split())
if(a>=b):
    if(a>=c):
        print((a*10)+b+c)
    else:
        print((c*10)+a+b)
elif (b>=c):
    print(b * 10 + a + c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

print(c * 10 + b + a)

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:
abc = [int(i) for i in input().split()]
abc.sort(reverse=True)
print(int(str(abc[0])+str(abc[1])) + abc[2])

Submission status: Accepted

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

Submission status: Accepted

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

print(List[-1]*10+List[-2]+List[0])

Submission status: Accepted

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

A.sort(reverse=True)

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

Submission status: Accepted

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

Submission status: Accepted

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

print(a*10+b+c)

Submission status: Accepted

Solution code:
import math
import sys
import queue
from collections import Counter
from itertools import accumulate
from fractions import gcd
from functools import reduce


def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

sys.setrecursionlimit(10000)

mod = 1000000007

"""
# 0埋め, 小数点出力桁指定時のときの出力
a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654

# 文字列をリストに格納
char_list = list("abcd") # ["a","b","c","d"]

# 標準入力取得
## 文字列
    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())

## 数値
    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""

if __name__ == "__main__":
    L = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
    print(10 * L[0] + L[1] + L[2])

Submission status: Accepted

Solution code:
# -*-coding: utf-8 -*-
A = map(int, input().split())
A = sorted(A, reverse=True)

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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:
import itertools


def solve():
    a, b, c = input().split()
    v = itertools.permutations([a, b, c], 3)
    max_a = 0
    for e1, e2, e3 in v:
        a = max(eval(e1 + "+" + e2 + e3), eval(e1 + e2 + "+" + e3))
        if a > max_a:
            max_a = a
    return max_a


if __name__ == "__main__":
    print(solve())

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

Submission status: Accepted

Solution code:
import sys
from fractions import gcd
import bisect
 
stdin = sys.stdin
 
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
s = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

num = na()
num.sort(reverse=True)
print(int(str(num[0])+str(num[1])) + num[2])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

print(a + b + 10*c)

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())
print(max(10*A+B+C, A+10*B+C, A+B+10*C))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(a+b+c-max(a,b,c)+max(a,b,c)*10)

Submission status: Accepted

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

R = C*10
result = (R+B)+A

print(result)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(10*a+b+c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#mapはmapオブジェクトを返すのでリストに変換
a = list(map(int, input().split(" ")))
print(sum(a) + 9 * max(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:
a, b, c = sorted(map(int, input().split()))
print(10*c + b + a)

Submission status: Accepted

Solution code:
def test():
    a = list(map(int,input().split()))
    b = str(max(a))
    a.remove(max(a))
    c = str(max(a))
    d = int(b+c)
    print(d+int(min(a)))


if __name__ == "__main__":
    test()

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

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(10*B + A + C)
else:
    print(10*C + B + A)