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())
m = max([a,b,c])
print(m*9+a+b+c)

Submission status: Accepted

Solution code:

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

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

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

Submission status: Accepted

Solution code:
ABC = [int(x) for x in input().split()]
ABC.sort()
answer = ABC[-1]*10 + sum(ABC[:2])
print(answer)

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
s = [A, B, C]
s.sort()

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

Submission status: Accepted

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

abc()

Submission status: Accepted

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

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

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 = 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(10*c+b+a)

Submission status: Accepted

Solution code:
ABC = list(map(int, input().split()))
sum = 0
sum += max(ABC)*10
index = ABC.index(max(ABC))
for i in range(3):
    if i != index:
        sum += ABC[i]
print(sum)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

li = [A, B, C]
li.sort(reverse=True)

tmp = str(li[0])+str(li[1])

print(int(tmp)+li[2])

Submission status: Accepted

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

Submission status: Accepted

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

num_list = [A,B,C]
num_list.sort(reverse=True)


left = str(num_list[0]) + str(num_list[1])

left = int(left)

print(left + num_list[2])

Submission status: Accepted

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

ls.sort()

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys

input = sys.stdin.readline

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

main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

li = []

li.append(A)
li.append(B)
li.append(C)

reli = sorted(li, reverse=True)

num = reli[0] * 10 + reli[1] + reli[2]

print(num)

Submission status: Accepted

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

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())
d=max(a,max(b,c))
print(a+b+c+9*d)

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

if A >=B and A >= C:
    print(int(A+B)+int(C))
elif B >=C and B >= A:
    print(int(B+A)+int(C))
else:
    print(int(C+A)+int(B))

Submission status: Accepted

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

Submission status: Accepted

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

li = []
li.append(a)
li.append(b)
li.append(c)

sli = sorted(li, reverse=True)
re = str(sli[0]) + str(sli[1])
re = int(re) + sli[2]
print(re)

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

ABC.sort(reverse=True)

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

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

Submission status: Accepted

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

ans = 0

ans += max(A)*10
A.remove(max(A))
ans += A[0]+A[1]
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
L=list(map(int,input().split()))
A=[]
for i in range(2):
  n=L[i]+L[i-2]*10+L[i-1]
  m=L[i]+L[i-2]+L[i-1]*10
  A.append(n)
  A.append(m)
print(max(A))

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_A = input().split()

lst_A.sort()

ans = int(lst_A[2]) * 10 + int(lst_A[0]) + int(lst_A[1])

print(ans)

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

Submission status: Accepted

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

Submission status: Accepted

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

nums=sorted(nums,reverse=True)

x=int(str(nums[0])+str(nums[1]))
y=nums[2]
print(x+y)

Submission status: Accepted

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

max_num = []

max_num.append(a*10+b+c)
max_num.append(b*10+a+c)
max_num.append(a*10+c+b)
max_num.append(c*10+a+b)
max_num.append(b*10+c+a)
max_num.append(c*10+b+a)

print(max(max_num))

Submission status: Accepted

Solution code:
a, b, c =  [ int(v) for v in 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()))
abc.sort()
print(abc[2]*10+abc[1]+abc[0])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
D = [A,B,C]
X = max(D)
Z = min(D)
Y = sum(D) - (X + Z)
E = str(X) + str(Y)
print(int(E) + int(Z))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    a = f()
    a = sorted(a, reverse = True)
    print(10*a[0] + a[1] + a[2])

solve()

Submission status: Accepted

Solution code:
c = [int(i) for i in input().split(' ')]
c.sort(reverse=True)

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

N = [int(x) for x in stdin.readline().rstrip().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())

m=max(a,b,c)

print(int(9*m+a+b+c))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
ABC = list(input().split())
ABC.sort(reverse=True)
print(eval(ABC[0] + ABC[1] + "+" + ABC[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:
n = list(input().split())
n = sorted(n, reverse=True)

ans = int(''.join(n[:2])) + int(n[2])

print(ans)

Submission status: Accepted

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


def solve(A: int, B: int, C: int):

    L = [A,B,C]
    L.sort(reverse=True)
    L[0] *= 10
    print(sum(L))

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
l = [int(x) for x in sorted(stdin.readline().rstrip().split(), reverse=True)]
print(int(str(l[0]) + str(l[1])) + l[2])

Submission status: Accepted

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

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    input_list = sorted(map(int, input().split()), reverse=True)

    print(str(input_list[0]*10 + input_list[1] + input_list[2]))

Submission status: Accepted

Solution code:
a = list(input().split())
b = int(max(a))
a.remove(max(a))
result = 0
for i in range(2):
    result += int(a[i])
print(b * 10 + int(result))

Submission status: Accepted

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

L = [int(v) for v in input().split()]
L.sort(reverse = True)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
lst = input().split()
lst_s = sorted(lst)
#print(lst_s)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
l = [int(i) for i in input().split()]
ans = max(l)*10
result = l[0]+l[1]+l[2]+max(l)*9
print(result)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun May 19 14:58:31 2019

@author: Yamazaki Kenichi
"""

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

A.sort()

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

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:
def main():
    ABC = list(map(int, input().split()))
    A,B,C = ABC[0], ABC[1], ABC[2]
    arr = [A*10+B+C, A+B*10+C, A+B+C*10]
    print(max(arr))
main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
A - Maximize the Formula
https://atcoder.jp/contests/abc110/tasks/abc110_a

"""
import sys


def solve(nums):
    return nums[0]*10 + nums[1] + nums[2]


def main(args):
    nums = sorted(map(int, input().split()), reverse=True)
    ans = solve(nums)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

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:
a,b,c=sorted(input().split())
print(eval("{}{}+{}".format(c,b,a)))

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

Submission status: Accepted

Solution code:

l = input().split()
l.sort(reverse=True)
Y = int(l[-1])
l.pop()
X = int(''.join(l))
print(X + Y)

Submission status: Accepted

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

Submission status: Accepted

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

ans = sorted(s)

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

Submission status: Accepted

Solution code:
s = input().split()
s.sort(reverse=True)
print(int(''.join(s[:2]))+int(s[2]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys


def input():
    return sys.stdin.readline()[:-1]

# N = int(input())
# A = [int(x) for x in input().split()]
# a, b, c = map(int, input().split())
# name1 = str(input())
# alph = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5}


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

Submission status: Accepted

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

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

Submission status: Accepted

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

n=sorted(n, reverse=True)

max = int(n[0]+n[1]) + int(n[2])
print(max)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
lst = []
lst.append(A)
lst.append(B)
lst.append(C)

a = max(lst)
lst.remove(a)
b = max(lst)
lst.remove(b)
ans = str(a) + str(b)
ans = int(ans) + int(lst[0])
print(ans)

Submission status: Accepted

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

i = L.index(max(L))

sum = L.pop(i) * 10

for j in L : 
    sum += j
    
print(sum)

Submission status: Accepted

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

Submission status: Accepted

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

ABC.sort()
print(sum(ABC[:2]) + 10*ABC[2])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
[a,b,c] = [int(j) for j in input().split()]
[u,v,w] = [max([a,b,c]),a+b+c-max([a,b,c])-min([a,b,c]),min([a,b,c])]
print(10 * u + v + w)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# coding: utf-8
from sys import stdin

ABC = list(map(int,stdin.readline().rstrip().split()))

def main():
    print(ABC.pop(ABC.index(max(ABC))) * 10 + sum(ABC))
    
if __name__ == '__main__':
    main()

Submission status: Accepted

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

lst = [A,B,C]
lst.sort()
print(lst[2] * 10 + lst[1] + lst[0])

Submission status: Accepted

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

maxa=max(A,B,C)

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
###############################################################################

from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy

def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance


###############################################################################


def main():
    a, b, c = intin()

    abc = [a, b, c]
    abc.sort()

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


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:
abc="".join(sorted(input().split(" "))[::-1])
print(int(abc[:2])+int(abc[2]))

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

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

Submission status: Accepted

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

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

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())
list = [a,b,c]
list1 = sorted(list)
d = str(list1[-1]) + str(list1[-2])
num = int(d) + list1[0]
print(num)

Submission status: Accepted

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

Submission status: Accepted

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

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 = sorted(list(map(int,input().split())))#複数の入力をリストに入れてソートした
print(a[2]*10+a[1]+a[0])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

A = 10*a+b+c
B = 10*b+a+c
C = 10*c+a+b
print(max(A, B, 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=list(map(int,input().split()))
A.sort(reverse=True)
print(A[0]*10+A[1]+A[2])

Submission status: Accepted

Solution code:
a = list(int(i) for i in input().split())

a = sorted(a)

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

Submission status: Accepted

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

print(10 * C + B + A)

Submission status: Accepted

Solution code:
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
ls = [int(c) for c in input().split()]
ls.sort()
ans = ls[2] * 10 + ls[1] + ls[0]
print(ans)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
from math import *
from itertools import *
from collections import *
from functools import *
try:
    from math import gcd
except Exception:
    from fractions import gcd


def solve(A: int, B: int, C: int):
    a, b, c = sorted([A, B, C])
    return a + b + 10 * c


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
    result = solve(A, B, C)
    print(result)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
lists = [A,B,C]
lists.sort()
lists.reverse()
result = int(str(lists[0]) + str(lists[1])) + lists[2]
print(result)

Submission status: Accepted

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

Submission status: Accepted

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

n = input()
n = re.split(" ",n)

n.sort()
n.reverse()

A = int(n[0])
B = int(n[1])
C = int(n[2])

print(10*A + B + C)

Submission status: Accepted

Solution code:
import bisect
from collections import Counter
def MI(): return map(int, input().split())
def II(): return int(input())
def IS(): return input()
def LI(): return list(map(int, input().split()))

li = sorted(LI(), reverse=True)
print(int(str(li[0])+str(li[1])) + int(li[2]))

Submission status: Accepted

Solution code:
a=sorted(input().split())
print(eval(a[2]+a[1]+"+"+a[0]))

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

Submission status: Accepted

Solution code:
#coding:utf-8

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

result = 10 * input_data[0] + input_data[1] + input_data[2]
print(result)

Submission status: Accepted

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

Submission status: Accepted

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

N.sort(reverse=True)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
nums = list(map(int, input().split()))
nums.sort()
print(nums[2] * 10 + nums[1] + nums[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:
Ms = [int(i) for i in input().split()]
Ms = sorted(Ms)
print(Ms[-1]*10+Ms[0]+Ms[1])