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

    n = sorted([A, B, C])
    ans = n[0] + n[1] + n[2] * 10
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import numpy as np

num = np.array(list(map(int, input().split())))

num[np.argmax(num)] *= 10

print(np.sum(num))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

num.sort()
num.reverse()

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

print(kozukai)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c=map(int,raw_input().split(' '))
arr = [a+int(str(b)+str(c)),a+int(str(c)+str(b)),b+int(str(c)+str(a)),b+int(str(a)+str(c)),c+int(str(a)+str(b)),c+int(str(b)+str(a))]
print max(arr)

Submission status: Accepted

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

ans1 = a * 10 + b + c
ans2 = b * 10 + c + a
ans3 = c * 10 + a + b

print(max([ans1,ans2,ans3]))

Submission status: Accepted

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

ans = 10 * max(ABC) + sum(ABC) - max(ABC)

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
abc =[A,B,C]
res = str(max(abc))
abc.remove(max(abc))
res = res + str(max(abc))
res = int(res) + min(abc)
print(res)

Submission status: Accepted

Solution code:
def main():
    data = list(map(int, input().split()))
    max_num = max(data)
    data.remove(max_num)
    print(max_num * 10 + sum(data))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from sys import stdin

input = lambda: stdin.readline()

def main():
    ABC = list(input().split())

    ABC.sort(reverse=1)
    ans = int(ABC[0] + ABC[1]) + int(ABC[2])
    print(ans)

main()

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

a.remove(d)
d = str(d)
a = list(map(str, a))
print(eval(d + a[0] + "+" + a[1]))

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

nums.sort()

a = nums[2] * 10 + nums[1]
b = nums[0]

print(a + b)

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
A=map(int,raw_input().split())
A.sort(reverse=True)

ans=0
for i in range(3):
	if i==0: ans+=A[i]*10
	else:    ans+=A[i]

print ans

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import math,string,itertools,fractions,heapq,collections,re,array,bisect

def s():
    return input()
def n():
    return int(input())
def d():
    return float(input())

def ls():
    return input().split()
def ln():
    return map(int, input().split())
def ld():
    return map(float, input().split())

def fs():
    return [input() for i in range(input())]
def fn():
    return [int(input()) for i in range(input())]
def fd():
    return [float(input()) for i in range(input())]

ABC = list(ln())
ABC = sorted(ABC)
ans1 = ABC[2]*10 + ABC[1] + ABC[0]
ans2 = ABC[2]*10 + ABC[0] + ABC[1]
print(max(ans1,ans2))

Submission status: Accepted

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

print(int("{}{}".format(str(i[0]), str(i[1]))) + i[2])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
li=[int(i) for i in input().split()]

ma=max(li)
li.remove(ma)

ans=ma*10

for i in li:
    ans+=i

print(ans)

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from sys import stdin

A = [int(i) for i in stdin.readline().rstrip().split()]
A.sort()

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

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:
abcs = list(map(int, input().split()))
max_int = max(abcs)
abcs.remove(max(abcs))
print(max_int * 10 + abcs[0] + abcs[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:
# -*- coding: utf-8 -*-
# 
import math
import sys
import itertools
import numpy as np


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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = input().split() 
a = int(x[0])
b = int(x[1])
c = int(x[2])
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())

sol = []
sol.append(a*10+b+c)
sol.append(b*10+a+c)
sol.append(c*10+a+b)

print(max(sol))

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

a,b,c = li()
abc = list([a,b,c])

abc.sort(reverse=True)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, c = [int(v) for v in input().split()]

v = sorted([a, b, c], reverse=True)
print(int(str(v[0]) + str(v[1])) + v[2])

Submission status: Accepted

Solution code:
def solve():
  a = list(map(int, input().split()))
  # print(a)
  a = sorted(a)
  A = str(a[2]) + str(a[1])
  A = int(A)
  print(A + a[0])

solve()

Submission status: Accepted

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

Submission status: Accepted

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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

a, b, c = map(int, input().split())
print(max(int(str(a)+str(b))+c, int(str(b)+str(a))+c, int(str(b)+str(c))+a, int(str(c)+str(b))+a, int(str(c)+str(a))+b, int(str(a)+str(c))+b))

Submission status: Accepted

Solution code:
def ketanowa(p):
    ans = 0
    p = str(p)
    for i in p:
        ans += int(i)
    return ans


def main():
    temp=input()
    temp=list(map(int,list(temp.split(" ")))) 
    temp = sorted(temp,key = lambda x:-x)
    print(temp[0]*10+temp[1]+temp[2])

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

print (ret)

Submission status: Accepted

Solution code:
a = input().split()
for i in range(3):
    a[i] = int(a[i])
    
a = sorted(a)

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

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


def main():
    a, b, c = map(int, input().split())
    print(run(a, b, c))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

k = max(a)

print(k*9+sum(a))

Submission status: Accepted

Solution code:

cards = sorted(map(int, raw_input().split(' ')))

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

Submission status: Accepted

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

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

Submission status: Accepted

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

a.sort()

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

a=list(map(int,input().split()))
a.sort()
[A,B,C] = a

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

Submission status: Accepted

Solution code:
nums = [int(num) for num in input().split()]
a = nums[0]
b = nums[1]
c = nums[2]
maxi = max(a,b)
maxi = max(maxi,c)
if maxi == a:
    ans = a*10 +b+c
elif maxi == b:
    ans = b*10+a+c
else:
    ans = c*10+a+b    
print(ans)

Submission status: Accepted

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

L = [A, B, C]

L.sort()

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

a = map(int,input().split(" "))

a = sorted(a)

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

Submission status: Accepted

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

A = sorted(A)

big = A[2]
mid = A[1]
sma = A[0]

print(big * 10 + mid + sma)

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:
X = sorted(list(map(int, input().split())))
A, B, C = X[0], X[1], X[2]
print(int(str(C) + str(B)) + A)

Submission status: Accepted

Solution code:
def i1():
 return int(input())
def i2():
 return [int(i) for i in input().split()]

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
from itertools import takewhile
def solve():
    a,b,c = list(map(int, input().split()))
    res = a+b+c+9*max([a,b,c])
    return str(res)

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

Submission status: Accepted

Solution code:
a = input().split()

a = [int(i) for i in a]
a = sorted(a)

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

Submission status: Accepted

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

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:
listA = list(map(int, input().split()))
listA.sort()
a = listA[2]
b = listA[1]
c = listA[0]

print(a*10+b+c)

Submission status: Accepted

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

Submission status: Accepted

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

maxNum = max(a, b, c)

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

Submission status: Accepted

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

print(10*m+l+n)

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

Submission status: Accepted

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

Submission status: Accepted

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

n = [a, b, c]
n = sorted(n)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c = [int(i) for i in 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().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.sort()

a.reverse()

b = int(a[0])*10 + int(a[1])

c = int(a[2])

print(b+c)

Submission status: Accepted

Solution code:
A = [0, 0, 0]
A[0], A[1], A[2] = map(int, input().split())
A.sort()

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# your code goes here
A = list(map(int,input().split()))

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
def getN():
    return int(input())

def getMN():
    a = input().split()
    b = [int(i) for i in a]
    return b[0],b[1]

def getlist():
    a = input().split()
    b = [int(i) for i in a]
    return b

a,b,c = getlist()
m = max([a,b,c])
print(10*m + a+ b+ c -m)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding:utf-8

INF = float('inf')


def inpl(): return list(map(int, input().split()))


X = inpl()
X.sort()
print(X[2] * 10 + X[1] + X[0])

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())
print(sum([A, B, C]) + max([A, B, C]) * 9)

Submission status: Accepted

Solution code:
def nl(): return list(map(int, input().split()))
# print('Yes' if a else 'No')

arr = nl()
print(max(arr) * 9 + sum(arr))

Submission status: Accepted

Solution code:
import numpy as np
import math

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

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

largest = max([A, B, C])
total = largest * 9 + A + B + C
print(total)

Submission status: Accepted

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

Submission status: Accepted

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

print(c * 10 + a + b)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
a = map(int,stdin.readline().split())
a.sort()
a.reverse()
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:
abc = list(map(int, input().split()))

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

Submission status: Accepted

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

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

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

A, B, C = raw_input().split()
ans = 0

for p in permutations([A, B, C, '+']):
    if p[0] == '+' or p[3] == '+':
        continue
    ans = max(ans, eval(''.join(p)))
print ans

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
I = [int(i) for i in input().split()]
I.sort(reverse=True)
a, b, c = map(str, I)
ans = int(a + b) + int(c)
print(ans)

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
xs = [int(_) for _ in input().split()]

xs.sort()

result = xs[2] * 10 + xs[1] + xs[0]

print(result)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
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:
l = list(map(int,input().split()))
l = sorted(l)
l = l[::-1]
print(l[0]*9+sum(l))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
import collections
import itertools
import array
import inspect

# Set max recursion limit
sys.setrecursionlimit(1000000)


# Debug output
def chkprint(*args):
    names = {
        id(v): k
        for k, v in inspect.currentframe().f_back.f_locals.items()
    }
    print(', '.join(
        names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))


# Binary converter
def to_bin(x):
    return bin(x)[2:]


def li_input():
    return [int(_) for _ in input().split()]


def gcd(n, m):
    if n % m == 0:
        return m
    else:
        return gcd(m, n % m)


def gcd_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = gcd(v, L[i])

    return v


def lcm(n, m):
    return (n * m) // gcd(n, m)


def lcm_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = lcm(v, L[i])

    return v


# Width First Search (+ Distance)
def wfs_d(D, N, K):
    """
    D: 隣接行列(距離付き)
    N: ノード数
    K: 始点ノード
    """

    dfk = [-1] * (N + 1)
    dfk[K] = 0

    cps = [(K, 0)]
    r = [False] * (N + 1)
    r[K] = True
    while len(cps) != 0:
        n_cps = []
        for cp, cd in cps:
            for i, dfcp in enumerate(D[cp]):
                if dfcp != -1 and not r[i]:
                    dfk[i] = cd + dfcp
                    n_cps.append((i, cd + dfcp))
                    r[i] = True

        cps = n_cps[:]

    return dfk


# Depth First Search (+Distance)
def dfs_d(v, pre, dist):
    """
    v:  現在のノード
    pre: １つ前のノード
    dist: 現在の距離

    以下は別途用意する
    D: 隣接リスト(行列ではない)
    D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
    """

    global D
    global D_dfs_d

    D_dfs_d[v] = dist

    for next_v, d in D[v]:
        if next_v != pre:
            dfs_d(next_v, v, dist + d)

    return


def sigma(N):
    ans = 0
    for i in range(1, N + 1):
        ans += i
    return ans


def comb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2, r + 1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p - 1, r, p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def bisearch(L, target):
    low = 0
    high = len(L) - 1
    
    while low <= high:
        mid = (low + high) // 2
        guess = L[mid]
        if guess == target:
            return True
        elif guess < target:
            low = mid + 1
        elif guess > target:
            high = mid - 1
    if guess != target:
        return False

# --------------------------------------------

dp = None


def main():
    a = input().split()
    a.sort(reverse=True)

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


main()

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:
il = lambda: list(map(int, input().split()))
ils = lambda n, s="int(input())": [eval(s) for _ in range(n)]

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

# A - Maximize the Formula /
# 実行時間制限: 2 sec / メモリ制限: 1024 MB
# 配点 : 100点

# 問題文
# あなたは子供にゲームをプレイさせ、その結果に応じてお小遣いをあげることにしました。
# そのゲームの内容は以下の通りです。
#     1以上 9 以下の整数 1 つが書かれた整数パネル 3 枚と + が書かれた演算子パネル 1枚がある
#     これら 4枚のパネルを横一列に並べて X+Yの形の数式を作る (すなわち、演算子パネルを端に置くことはできない)
#     数式を計算した結果と同じ値のお小遣いをあげる

# ゲームで使用する各整数パネルの値 A,B,Cが与えられるので、あげることになり得るお小遣いの最大値を求めてください。

# 制約
#     入力はすべて整数である
#     1≤A,B,C≤9

# 入力
# 入力は以下の形式で標準入力から与えられる。
# A B C

# 出力
# あげることになり得るお小遣いの最大値を出力せよ。

# 入力例 1
# 1 5 2

# 出力例 1
# 53

# 52+1 と並べたときにあげることになるお小遣いは 53となりこれが最大です。

# 入力例 2
# 9 9 9

# 出力例 2
# 108

# 入力例 3
# 6 6 7

# 出力例 3
# 82


def calculation(lines):
    # N = int(lines[0])
    a, b, c = list(map(int, lines[0].split()))
    result = max(a, b, c) * 9 + a + b + c
    return [result]


# 引数を取得
def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines


# テストデータ
def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['1 5 2']
        lines_export = [53]
    if pattern == 2:
        lines_input = ['9 9 9']
        lines_export = [108]
    if pattern == 3:
        lines_input = ['6 6 7']
        lines_export = [82]
    return lines_input, lines_export


# 動作モード判別
def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode


# 主処理
def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(2)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    # if mode > 0:
    #     print(f'lines_input=[{lines_input}]')
    #     print(f'lines_export=[{lines_export}]')
    #     print(f'lines_result=[{lines_result}]')
    #     if lines_result == lines_export:
    #         print('OK')
    #     else:
    #         print('NG')
    # finished = time.time()
    # duration = finished - started
    # print(f'duration=[{duration}]')


# 起動処理
if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
a,b,c=input()
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: Runtime Error

Solution code:
s = sum(map(int, raw_input().split(' ')))
print sum(s) + 10 *max(s)

Submission status: Runtime Error

Solution code:
n,m,X,Y=sorted(map(int,input().split()))
x=max([X],max(map(int,input().split())))
y=min([Y],min(map(int,input().split())))
print("No War" if x<y else "War")

Submission status: Runtime Error

Solution code:
n, m, x, y = map(int, input().split())
xs = input().split()
ys = input().split()

for i in range(n):
    xs[i] = int(xs[i])

for i in range(m):
    ys[i] = int(ys[i])

if max(xs) < min(ys):
    print("No War")
else:
    print("War")

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
A,B,C=input().split()
ichi=eval(AB+C)
two=eval(A+BC)
print(max(ichi,two))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
pritn(eval("+".join(sorted(input()))+"*10"))

Submission status: Runtime Error

Solution code:
import sys
import collections

s = list(map(str,input()))
t = list(map(str,input()))
cnts = collections.Counter(s)
cntt = collections.Counter(t)
cs = sorted(cnts.values())
ct = sorted(cntt.values())

if len(s) != len(t):
    print("No")
    sys.exit()

for i,j in zip(cs,ct):
    if i != j:
        print("No")
        sys.exit()

print("Yes")

Submission status: Runtime Error

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

Submission status: Runtime Error

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