ZhenlongDai/ACPR huggingface dataset:
Problem: p03994
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
K = int(input())

ans = ''
for i, c in enumerate(s):
    dif = ord('z') - ord(c) + 1
    if i == len(s) - 1:
        K %= 26
        ans += chr(((ord(c) + K - ord('a')) % 26) + ord('a'))
    elif dif <= K:
        ans += 'a'
        K -= dif
    else:
        ans += c
print(ans)


Failing test case input:
lawitsffeodc
100

Expected output:
aaaaaaaaeodi


Actual output:
aaaaaaafeodd


Fixed submission (verdict: Accepted):
s = input()
K = int(input())

ans = ''
for i, c in enumerate(s):
    dif = ord('z') - ord(c) + 1
    dif %= 26
    if i == len(s) - 1:
        K %= 26
        if ord(c) + K > ord('z'):
            K -= 26
        ans += chr(ord(c) + K)
    elif dif <= K:
        ans += 'a'
        K -= dif
    else:
        ans += c
print(ans)

Problem: p03994
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
s=list(str(input()))
k=int(input())
n=len(s)
alpha2num=lambda c: ord(c)-ord('a')+1
for i in range(n):
    s[i]=alpha2num(s[i])

c=k
for i in range(n):
    if c-(27-s[i])>=0:
        if s[i]+c>26:
            c=c-(27-s[i])
            s[i]=1

s[-1]+=c%26
num2alpha=lambda c: chr(c+96)
for i in range(n):
    s[i]=num2alpha(s[i])

print("".join(map(str,s)))

Failing test case input:
lavitsgfeodc
111

Expected output:
aaaaaaaaeadh


Actual output:
aaaaaaafeadc


Fixed submission (verdict: Accepted):
s=list(str(input()))
k=int(input())
n=len(s)
alpha2num=lambda c: ord(c)-ord('a')+1
for i in range(n):
    s[i]=alpha2num(s[i])

c=k
for i in range(n):
    if c-(27-s[i])>=0:
        if s[i]+c>26 and s[i]!=1:
            c=c-(27-s[i])
            s[i]=1

s[-1]+=c%26
num2alpha=lambda c: chr(c+96)
for i in range(n):
    s[i]=num2alpha(s[i])

print("".join(map(str,s)))

Problem: p03994
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

def resolve():
    S = input()
    K = int(input())

    ans = []
    for s in S:
        if K > 0:
            diff = ord(s) - ord("a")
            shift = (26 - diff) % 26
            if K - shift >= 0:
                ans.append("a")
                K -= shift
            else:
                ans.append(s)

    if K > 0:
        K %= 26
        d = (K + ord(ans[-1]) - ord('a')) % 26
        ans[-1] = chr(d + ord('a'))

    print("".join(ans))


if __name__ == "__main__":
    resolve()

Failing test case input:
zyx
3

Expected output:
aax


Actual output:
aa


Fixed submission (verdict: Accepted):

def resolve():
    S = input()
    K = int(input())

    ans = []
    for s in S:
        diff = ord(s) - ord("a")
        if diff == 0:
            ans.append("a")
            continue
        elif 26 - diff <= K:
            ans.append("a")
            K -= 26 - diff
        else:
            ans.append(s)

    K %= 26
    d = (K + ord(ans[-1]) - ord('a')) % 26
    ans[-1] = chr(d + ord('a'))

    print("".join(ans))


if __name__ == "__main__":
    resolve()
Problem: p03994
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
S = str(input())
K = int(input())

K %= (len(S) * 26)

arr = [ord(S[i]) for i in range(len(S))]
count = K
for i in range(len(S)):
    if i == len(S) - 1:
        count %= 26
        if ord('z') - arr[i] + 1 <= count:
            arr[i] = ord('a')
            count -= ord('z') - ord(S[i]) + 1
        arr[i] += count
        break

    if ord('z') - arr[i] + 1 <= count:
        arr[i] = ord('a')
        count -= (ord('z') - ord(S[i]) + 1)

    if count == 0:
        break

for c in arr:
    sys.stdout.write(chr(c))

print('')


Failing test case input:
lavitsgfeodc
101

Expected output:
aaaaaaaaeodj


Actual output:
aaaaaaafeode


Fixed submission (verdict: Accepted):
import sys
S = str(input())
K = int(input())

arr = [ord(S[i]) for i in range(len(S))]
count = K
for i in range(len(S)):
    if i == len(S) - 1:
        count %= 26
        if ord('z') - arr[i] + 1 <= count:
            arr[i] = ord('a')
            count -= ord('z') - ord(S[i]) + 1
        arr[i] += count
        break

    if ord('z') - arr[i] + 1 <= count and arr[i] != ord('a'):
        arr[i] = ord('a')
        count -= ord('z') - ord(S[i]) + 1

    if count == 0:
        break

for c in arr:
    sys.stdout.write(chr(c))

print('')

Problem: p03994
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

s= input()
K=int(input())
def can_change_to_a(st,remains):
    if remains >25:
        return True
    if ord('z')+1  - ord(st) <= remains:
        return True
    return False

s_ans = list(s)
for i,ch in enumerate(s):
    if can_change_to_a(ch,K):
        K -= ord('z')+1-ord(ch)
        s_ans[i]='a'

s_ans[-1]= chr((ord(s_ans[-1])+K -ord('a') )%27 + ord('a'))

print(''.join(s_ans))

Failing test case input:
caoffestiwdl
101

Expected output:
aaaaaastiwdm


Actual output:
aaaafeaaiwdo


Fixed submission (verdict: Accepted):

s= input()
K=int(input())
def can_change_to_a(st,remains):
    if ord('z')+1 - ord(st) <= remains:
        return True
    return False

s_ans = list(s)
for i,ch in enumerate(s):
    if ch=='a':
        continue
    if K >= ord('z')+1-ord(ch):
        K -= ord('z')+1-ord(ch)
        s_ans[i]='a'

s_ans[-1]= chr(  (ord(s_ans[-1])-ord('a')+K )%26 + ord('a'))

print(''.join(s_ans))
Problem: p03994
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def up(c, i):
    i %= 26
    b = ord('z')-ord(c)+1
    if i >= b:
        i -= b
        c = 'a'
    c = chr(ord(c)+i)
    return c



s = input()
K = int(input())

a = ord('a')
ans = ''

for i in range(len(s)):
    b = ord('z')-ord(s[i])+1
    if i == len(s)-1:
        ans += up(s[i], K)
    elif K >= b:
        K -= b
        ans += 'a'
    else:
        ans += s[i]

print(ans)

Failing test case input:
lavitsgfeodc
111

Expected output:
aaaaaaaaeadh


Actual output:
aaaaaaafeadc


Fixed submission (verdict: Accepted):
def up(c, i):
    i %= 26
    b = ord('z')-ord(c)+1
    if i >= b:
        i -= b
        c = 'a'
    c = chr(ord(c)+i)
    return c



s = input()
K = int(input())

a = ord('a')
ans = ''

for i in range(len(s)):
    b = ord('z')-ord(s[i])+1
    if i == len(s)-1:
        ans += up(s[i], K)
    elif b == 26:
        ans += 'a'
    elif K >= b:
        K -= b
        ans += 'a'
    else:
        ans += s[i]

print(ans)

Problem: p03994
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def up(c, i):
    i %= 26
    b = ord('z')-ord(c)+1
    if i >= b:
        i -= b
        c = 'a'
    c = chr(ord(c)+i)
    return c



s = input()
K = int(input())

a = ord('a')
ans = ''

for i in range(len(s)):
    b = ord('z')-ord(s[i])+1
    if i == len(s)-1:
        ans += up(s[i], K)
    elif b == 25:
        ans += 'a'
    elif K >= b:
        K -= b
        ans += 'a'
    else:
        ans += s[i]

print(ans)

Failing test case input:
cdoeffstbwil
001

Expected output:
cdoeffstbwim


Actual output:
cdoeffstawim


Fixed submission (verdict: Accepted):
def up(c, i):
    i %= 26
    b = ord('z')-ord(c)+1
    if i >= b:
        i -= b
        c = 'a'
    c = chr(ord(c)+i)
    return c



s = input()
K = int(input())

a = ord('a')
ans = ''

for i in range(len(s)):
    b = ord('z')-ord(s[i])+1
    if i == len(s)-1:
        ans += up(s[i], K)
    elif b == 26:
        ans += 'a'
    elif K >= b:
        K -= b
        ans += 'a'
    else:
        ans += s[i]

print(ans)
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c-min(a,b,c))

Failing test case input:
1 8 1

Expected output:
82


Actual output:
81


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a= list(input())
a.sort()
print(a[2] * 10 + a[1] + a[0])

Failing test case input:
-1 12 1

Expected output:
120


Actual output:
----------  


Fixed submission (verdict: Accepted):
a= list(map(int,input().split()))
a.sort()
print(a[2] * 10 + a[1] + a[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = list(map(int,input().split()))
l.sort
print(l[2]*10 + l[1] + l[0])

Failing test case input:
6 5 0

Expected output:
65


Actual output:
11


Fixed submission (verdict: Accepted):
l = list(map(int,input().split()))
l.sort()
print(l[2]*10 + l[1] + l[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = sorted(map(int,input().split()))
print(10*a + b+c)

Failing test case input:
1 9 8

Expected output:
99


Actual output:
27


Fixed submission (verdict: Accepted):
a,b,c = sorted(map(int,input().split()))
print(10*c+b+a)

Problem: p03250
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a = list(map(int,input().split()))
a.sort
print(10*a[2]+a[1]+a[0])

Failing test case input:
1 8 1

Expected output:
82


Actual output:
19


Fixed submission (verdict: Accepted):
a = list(map(int,input().split()))
a.sort()
print(10*a[2]+a[1]+a[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=map(int,input().split())
n=10*A+B
m=10*B+C
print(max(n+C,A+m))

Failing test case input:
2 5 8

Expected output:
87


Actual output:
60


Fixed submission (verdict: Accepted):
A,B,C=map(int,input().split())
n=max(10*A+B+C,A+10*B+C,A+B+10*C)
print(n)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
abc=list(map(int,input().split()))
abc.sort(reverse=True)
print(sum(abc[:2])+abc[2])

Failing test case input:
6 6 5

Expected output:
71


Actual output:
17


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int,input().split())
print(10*a+b+c,a+10*b+c,a+b+10*c)

Failing test case input:
1 5 2

Expected output:
53

Actual output:
17 53 26


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
print(max(10*a+b+c,a+10*b+c,a+b+10*c))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k=list(map(str,input().split()))
k.sort()
print(int(k[0]+k[1])+int(k[2]))


Failing test case input:
1 3 7

Expected output:
74


Actual output:
20


Fixed submission (verdict: Accepted):
k=list(map(str,input().split()))
k.sort()
l=str(k[2])+str(k[1])
print(int(l)+int(k[0]))
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
print(max(a+b,b+c,c+a))

Failing test case input:
0 7 0

Expected output:
70


Actual output:
7


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=sorted(map(int,input().split()))
print(10*a+b+c)

Failing test case input:
-1 0 2

Expected output:
19


Actual output:
-8


Fixed submission (verdict: Accepted):
a,b,c=sorted(map(int,input().split()))
print(10*c+b+a)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = list(input().split())
print(n)
list.sort(n, reverse=True)
print(int((n[0]+n[1])) + int(n[2]))

Failing test case input:
1 3 -4

Expected output:
27


Actual output:
['1', '3', '-4']
27


Fixed submission (verdict: Accepted):
n = list(input().split())
list.sort(n, reverse=True)
print(int((n[0]+n[1])) + int(n[2]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(max([10*a + b, 10*b + c]))

Failing test case input:
6 6 5

Expected output:
71


Actual output:
66


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(max([10*a + b + c, 10*b + c + a, 10*c + a + b]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = list(map(int, input().split()))
A.sort(reverse=True)
print(A)
print(A[0]*10+A[1]+A[2])


Failing test case input:
5 9 5

Expected output:
100


Actual output:
[9, 5, 5]
100


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=sorted(map(int,input().split()))
print(10*A+B+C)

Failing test case input:
0 0 -1

Expected output:
-1


Actual output:
-10


Fixed submission (verdict: Accepted):
A,B,C=sorted(map(int,input().split()))
print(10*C+B+A)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A =list(map(int, input().split()))
A.sort()
print(A)
print(A[2]*10+A[1]+A[0])

Failing test case input:
1 8 1

Expected output:
82


Actual output:
[1, 1, 8]
82


Fixed submission (verdict: Accepted):
A =list(map(int, input().split()))
A.sort()
print(A[2]*10+A[1]+A[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
panels = input().split()
panels = [int(panel) for panel in panels]
panels = sorted(panels,reverse=True)

print(panels)

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

Failing test case input:
2 21 2

Expected output:
214


Actual output:
[21, 2, 2]
214


Fixed submission (verdict: Accepted):
panels = input().split()
panels = [int(panel) for panel in panels]
panels = sorted(panels,reverse=True)

print(panels[0]*10+panels[1]+panels[2])
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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(a[0]))


if __name__ == "__main__":
    test()


Failing test case input:
6 5 0

Expected output:
65


Actual output:
70


Fixed submission (verdict: Accepted):
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()

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k=list(map(str,input().split()))
k.sort()
l=str(k[0]+k[1])
print(int(l)+int(k[2]))

Failing test case input:
6 7 4

Expected output:
80


Actual output:
53


Fixed submission (verdict: Accepted):
k=list(map(str,input().split()))
k.sort()
l=str(k[2])+str(k[1])
print(int(l)+int(k[0]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=sorted(map(int,input().split()))
print(c*10+b+c)

Failing test case input:
0 7 0

Expected output:
70


Actual output:
77


Fixed submission (verdict: Accepted):
a,b,c=sorted(map(int,input().split()))
print(c*10+b+a)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = [int(i) for i in input().split()]
l.sort()
print(l[0] * 10 + l[1] + l[2])

Failing test case input:
6 7 5

Expected output:
81


Actual output:
63


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C = map(int, input().split())
r = max(A,B,C)*10 + B +C
print(r)

Failing test case input:
0 2 -2

Expected output:
18


Actual output:
20


Fixed submission (verdict: Accepted):
A,B,C = map(int, input().split())
r = max(A,B,C)*9 + A+B+C
print(int(r))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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(A+10*B+C)
else:
    print(A+B+10*C)

Failing test case input:
9 9 8

Expected output:
107


Actual output:
98


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N=sorted(list(map(int,input().split())))
print(N[0]*10+N[1]+N[2])

Failing test case input:
5 4 8

Expected output:
89


Actual output:
53


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x=list(map(int, input().split()))
print(max(x[0]*10+x[1]+x[2], x[0]+x[1]*10+x[2]))

Failing test case input:
1 2 7

Expected output:
73


Actual output:
28


Fixed submission (verdict: Accepted):
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))
Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,c = map(int,input().split())
l=sorted([a,b,c])
int(str(l[2])+str(l[1]))+l[0]

Failing test case input:
3 0 0

Expected output:
30


Actual output:

Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
l=sorted([a,b,c])
print(int(str(l[2])+str(l[1]))+l[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int, input().split())

ans = []

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

print(max(ans))

Failing test case input:
1 2 3

Expected output:
33


Actual output:
35


Fixed submission (verdict: Accepted):
a,b,c = map(int, input().split())

ans = []

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

print(max(ans))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k=list(map(str,input().split()))
k.sort()
l=k[0]+k[1]
print(int(l)+int(k[2]))

Failing test case input:
5 5 8

Expected output:
90


Actual output:
63


Fixed submission (verdict: Accepted):
k=list(map(str,input().split()))
k.sort()
l=str(k[2])+str(k[1])
print(int(l)+int(k[0]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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


Failing test case input:
4 2 4

Expected output:
46


Actual output:
48


Fixed submission (verdict: Accepted):

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = sorted(map(int, input().split()))
print(10*a+b+c)

Failing test case input:
1 5 8

Expected output:
86


Actual output:
23


Fixed submission (verdict: Accepted):
a, b, c = sorted(map(int, input().split()), reverse=True)
print(10*a+b+c)

Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A, B, C = map(int, input().split())

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

Failing test case input:
1 3 7

Expected output:
74


Actual output:
20


Fixed submission (verdict: Accepted):
A, B, C = map(int, input().split())

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = sorted(list(map(int, input().split())))
print(l[0] * 10 + l[1] + l[2])

Failing test case input:
1 5 2

Expected output:
53

Actual output:
17


Fixed submission (verdict: Accepted):
l = sorted(list(map(int, input().split())))
print(l[2] * 10 + l[1] + l[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int,input().split())
print(max(a*10+b+c, a+b*10+c))

Failing test case input:
6 6 9

Expected output:
102


Actual output:
75


Fixed submission (verdict: Accepted):
a, b, c = map(int,input().split())
print(max(a*10+b+c, a+b*10+c, a+b+c*10))

Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import os
l = list(map(int,input().split()))
l.sort()
a =l[2]*10+l[1]+l[2]
print(a)


Failing test case input:
0 3 -4

Expected output:
26


Actual output:
33


Fixed submission (verdict: Accepted):
import os
l = list(map(int,input().split()))
l.sort()
a =l[2]*10+l[1]+l[0]
print(a)
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

A, B, C = (int(i) for i in input().split())

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


Failing test case input:
1 1 1

Expected output:
12


Actual output:
12
12
12


Fixed submission (verdict: Accepted):

A, B, C = (int(i) for i in input().split())

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = list(map(int,input().split()))
l.sort
print(l[2]*10+l[1]+l[0])

Failing test case input:
6 7 5

Expected output:
81


Actual output:
63


Fixed submission (verdict: Accepted):
l = list(map(int,input().split()))

l.sort()

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

lst_A = input().split()

print(lst_A)

lst_A.sort()

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

print(ans)

Failing test case input:
3 2 -1

Expected output:
31


Actual output:
['3', '2', '-1']
31


Fixed submission (verdict: Accepted):

lst_A = input().split()

lst_A.sort()

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

print(ans)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C = map(int,input().split())
L = [A, B, C]
L.sort()
print(A + B + 10 * C)

Failing test case input:
5 2 2

Expected output:
54


Actual output:
27


Fixed submission (verdict: Accepted):
A,B,C = map(int,input().split())
L = [A, B, C]
L.sort()
print(L[0] + L[1] + 10 * L[2])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = sorted(input().split())
d=b+c
print(int(a)+int(d))

Failing test case input:
1 8 1

Expected output:
82


Actual output:
19


Fixed submission (verdict: Accepted):
a,b,c = sorted(map(int,input().split()))
d=str(c)+str(b)
print(a+int(d))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = list(map(int,input().split()))
l.sort()
print(sum(l[:2])+l[2]*100)

Failing test case input:
0 4 0

Expected output:
40


Actual output:
400


Fixed submission (verdict: Accepted):
l = list(map(int,input().split()))
l.sort()
print(sum(l[:2])+l[2]*10)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
li=list(map(int,input().split()))
li.sort()
print(li[0]*10+li[1]+li[2])

Failing test case input:
1 2 3

Expected output:
33


Actual output:
15


Fixed submission (verdict: Accepted):
li=list(map(int,input().split()))
li.sort()
print(li[2]*10+li[1]+li[0])

Problem: p03250
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b,c=map(int ,input().split())
maxs=a*10+b+c
maxs=max(a+b*10+c,maxs)
print(maxs)

Failing test case input:
5 4 8

Expected output:
89


Actual output:
62


Fixed submission (verdict: Accepted):
a,b,c=map(int ,input().split())
maxs=a*10+b+c
maxs=max(a+b*10+c,maxs)
maxs=max(a+b+c*10,maxs)
print(maxs)
Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B,C=map(int,input().split())
ichi=10*A+B+C
two=A+10*B+C
three=C*10+A+B
print(max(ichi,two))


Failing test case input:
2 6 7

Expected output:
78


Actual output:
69


Fixed submission (verdict: Accepted):
A,B,C=map(int,input().split())
ichi=10*A+B+C
two=A+10*B+C
three=C*10+A+B
print(max(ichi,two,three))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(max([10*a + b + c, 10*b + c + a]))

Failing test case input:
-1 3 7

Expected output:
72


Actual output:
36


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(max([10*a + b + c, 10*b + c + a, 10*c + a + b]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = [int(i) for i in input().split()]
l.sort
print(l[0]*10 + l[1] + l[2])


Failing test case input:
4 3 5

Expected output:
57


Actual output:
48


Fixed submission (verdict: Accepted):
l = [int(i) for i in input().split()]


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

Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A = [int(i) for i in input().split()]
A.sort()
print(A[0]*10+A[1] + A[2])

Failing test case input:
1 8 2

Expected output:
83


Actual output:
20


Fixed submission (verdict: Accepted):
A = [int(i) for i in input().split()]
A.sort()
print(A[2]*10+A[1] + A[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
L=sorted(list(map(int, input().split())))
print(L[2]*L[1]+L[0])

Failing test case input:
0 1 0

Expected output:
10


Actual output:
0


Fixed submission (verdict: Accepted):
L=sorted(list(map(int, input().split())))
print(int(str(L[2])+str(L[1]))+L[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
if a == max(a, b, ):
  print(a*10+b+c)
elif b == max(a, b, c):
  print(a+b*10+c)
else:
  print(a+b+c*10)

Failing test case input:
6 6 7

Expected output:
82

Actual output:
73


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
if a == max(a, b, c):
  print(a*10+b+c)
elif b == max(a, b, c):
  print(a+b*10+c)
else:
  print(a+b+c*10)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

A, B, C = [int(i) for i in input().split(' ')]

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


Failing test case input:
-1 0 2

Expected output:
19


Actual output:
1


Fixed submission (verdict: Accepted):

A, B, C = [int(i) for i in input().split(' ')]

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

Problem: p03250
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b,c = map(int,input().split())
print(max(10*a+b+c, a+10*b+c))

Failing test case input:
-2 1 7

Expected output:
69


Actual output:
15


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
print(max(10*a+b+c, a+10*b+c, a+b+10*c))
Problem: p03250
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import math





inputa = input().split()


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

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




print(c * 10 + a + b)




Failing test case input:
2 6 5

Expected output:
67


Actual output:
58


Fixed submission (verdict: Accepted):
import math





inputa = input().split()


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

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




print(c * 10 + a + b)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int, input().split())
print(max(a*10+b+c, a+b*10+c))

Failing test case input:
1 5 8

Expected output:
86


Actual output:
59


Fixed submission (verdict: Accepted):
a,b,c = sorted(list(map(int, input().split())))
print(c*10+b+a)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    num = list(map(int, input().split()))
    num.sort()
    num.reverse()
    print(num)
    print(num[0] * 10 + num[1] + num[2])

if __name__ == '__main__':
    main()

Failing test case input:
6 6 5

Expected output:
71


Actual output:
[6, 6, 5]
71


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

if __name__ == '__main__':
    main()

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = sorted(map(int,input().split()))
print(10*c+b+c)

Failing test case input:
0 6 2

Expected output:
62


Actual output:
68


Fixed submission (verdict: Accepted):
a,b,c = sorted(map(int,input().split()))
print(10*c+b+a)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=list(map(int,input().split()))
a.sort
print(a[2]*10+a[1]+a[0])

Failing test case input:
1 9 8

Expected output:
99


Actual output:
90


Fixed submission (verdict: Accepted):
a=list(map(int,input().split()))
a.sort()
print(a[2]*10+a[1]+a[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int,input().split())
print(max(a * 10 + b + c,a + b * 10 + c))

Failing test case input:
1 2 7

Expected output:
73


Actual output:
28


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
print(max(a,b,c)*10+a + b + c -max(a,b,c))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())

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


Failing test case input:
0 9 8

Expected output:
98


Actual output:
89


Fixed submission (verdict: Accepted):
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 + a + c)
else:
    print(10 * c + a + b)
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
from sys import stdin
a, b, c = [int(i) for i in stdin.readline().rstrip().split()]
if 10 * a + b + c > a + 10 * b + c:
    print(10 * a + b + c)
else:
    print(a + 10 * b + c)

Failing test case input:
6 7 9

Expected output:
103


Actual output:
85


Fixed submission (verdict: Accepted):
from sys import stdin
a, b, c = [int(i) for i in stdin.readline().rstrip().split()]

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int, input().split()))
print(a[0] + a[1] + a[2] * 10)

Failing test case input:
6 7 5

Expected output:
81


Actual output:
63


Fixed submission (verdict: Accepted):
a = sorted(list(map(int, input().split())))
print(a[0] + a[1] + a[2] * 10)

Problem: p03250
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(10*b + c + a)

Failing test case input:
3 0 0

Expected output:
30


Actual output:
3


Fixed submission (verdict: Accepted):
a, b, c = sorted(map(int, input().split()))
print(c*10+a+b)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = [int(i) for i in input().split()]
n.sort(reverse=True)
print(n[0]*10*n[1]+n[2])

Failing test case input:
6 6 9

Expected output:
102


Actual output:
546


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, C = map(int, input().split())
result1 = A + B*10 + C
result2 = A*10 + B + C

print(max(result1, result2))

Failing test case input:
2 6 7

Expected output:
78


Actual output:
69


Fixed submission (verdict: Accepted):
A, B, C = map(int, input().split())
num1 = A*10 + B + C
num2 = A + B*10 + C
num3 = A + B + C*10
print(max(num1, num2, num3))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
ABC = [int(abc) for abc in input().split()]
ABC.sort()
print(ABC[0]*10 + ABC[1] + ABC[2])

Failing test case input:
1 16 0

Expected output:
161


Actual output:
17


Fixed submission (verdict: Accepted):
ABC = [int(abc) for abc in input().split()]
ABC.sort(reverse=True)
print(ABC[0]*10 + ABC[1] + ABC[2])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = map(int,input().split())

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

print(anli[2] * 10 + anli[1] +anli[1])

Failing test case input:
2 6 1

Expected output:
63


Actual output:
64


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())

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

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
ai = lambda: list(map(int,input().split()))
ai_ = lambda: [int(x)-1 for x in input().split()]

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


Failing test case input:
4 4 8

Expected output:
88


Actual output:
52


Fixed submission (verdict: Accepted):
ai = lambda: list(map(int,input().split()))
ai_ = lambda: [int(x)-1 for x in input().split()]

a,b,c = ai()
d = max(a,b,c)
print(10*d+a+b+c-d)
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p = sorted(list(map(int, input().split())), reverse = True)
print(p[0] * p[1] + p[2])

Failing test case input:
0 4 -4

Expected output:
36


Actual output:
-4


Fixed submission (verdict: Accepted):
p = sorted(list(map(int, input().split())), reverse = True)
print(p[0] * 10 + p[1] + p[2])

Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,c=map(int,input().split())
print(max(a,b,c)+a+b+c)

Failing test case input:
2 3 7

Expected output:
75


Actual output:
19


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x = sorted(int(a) for a in input().split(' '))
print(x[0] * 10 + x[1] + x[2])

Failing test case input:
4 3 5

Expected output:
57


Actual output:
39


Fixed submission (verdict: Accepted):
x = [int(a) for a in input().split(' ')]
x = sorted(x)
print(x[0] + x[1] + x[2] * 10)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
abc = list(map(int,input().split()))
abc.sort()
abc[2]*10+abc[1]+abc[0]


Failing test case input:
1 16 0

Expected output:
161


Actual output:

Fixed submission (verdict: Accepted):
abc = list(map(int,input().split()))
abc.sort()
print(abc[2]*10+abc[1]+abc[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x=list(map(int, input().split()))
print(max(x[0]*10+x[1], x[1]*10+x[2]))

Failing test case input:
1 2 7

Expected output:
73


Actual output:
27


Fixed submission (verdict: Accepted):
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))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
s=[]
s.append(a)
s.append(b)
s.append(c)
s.sort
print(s[2]*10+s[1]+s[0])

Failing test case input:
9 7 8

Expected output:
105


Actual output:
96


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
s=[]
s.append(a)
s.append(b)
s.append(c)
s.sort()

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x=list(map(int,input().split()))
print(x)
x.sort()
print(int(str(x[-1])+str(x[1]))+x[0])


Failing test case input:
8 7 8

Expected output:
95


Actual output:
[8, 7, 8]
95


Fixed submission (verdict: Accepted):
x=list(map(int,input().split()))

x.sort()
print(int(str(x[-1])+str(x[1]))+x[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N = list(map(int, input().split()))
N.sort(reverse=True)
print(N)
print(N[0]*10 + N[1] + N[2])


Failing test case input:
1 5 2

Expected output:
53

Actual output:
[5, 2, 1]
53


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c = sorted(map(int,input().split()))
d=str(b)+str(c)
print(a+int(d))


Failing test case input:
0 1 0

Expected output:
10


Actual output:
1


Fixed submission (verdict: Accepted):
a,b,c = sorted(map(int,input().split()))
d=str(c)+str(b)
print(a+int(d))
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = list(map(int, input().split()))
A.sort()
print(A[0]*10+A[1]+A[2])

Failing test case input:
6 6 0

Expected output:
66


Actual output:
12


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = sorted(list(map(int, input().split())))
print(l[0] + int(str(l[1]) + str(l[2])))

Failing test case input:
6 6 9

Expected output:
102


Actual output:
75


Fixed submission (verdict: Accepted):
l = sorted(list(map(int, input().split())))
print(l[0] + int(str(l[2]) + str(l[1])))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = (int(i) for i in input().split())  
integers = [a, b, c]
integers = [a, b, c]
print(integers[2]*10+integers[1]+integers[0])

Failing test case input:
6 7 5

Expected output:
81


Actual output:
63


Fixed submission (verdict: Accepted):
a, b, c = (int(i) for i in input().split())  
integers = [a, b, c]
integers.sort()
print(integers[2]*10+integers[1]+integers[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
str = input().split(" ")
str.sort()
print(int(str[0] + str[1]) + int(str[2]))

Failing test case input:
3 0 -1

Expected output:
29


Actual output:
-7


Fixed submission (verdict: Accepted):
str = input().split(" ")
str.sort(reverse=True)
print(int(str[0] + str[1]) + int(str[2]))

Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,c=input().split()
print(max(a,b,c)*9+a+b+c)

Failing test case input:
1 1 0

Expected output:
11


Actual output:
111111111110


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(max(a,b,c)*9+a+b+c)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = list(map(int, input().split()))
n.sort()
print(n[0]*10 + n[1] + n[2])

Failing test case input:
9 7 8

Expected output:
105


Actual output:
87


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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
arr = [int(i) for i in input().split()]

arr.sort()

[a, b, c] = arr
print(c * 10 + b + c)


Failing test case input:
-1 0 2

Expected output:
19


Actual output:
22


Fixed submission (verdict: Accepted):
arr = [int(i) for i in input().split()]

arr.sort()

[a, b, c] = arr
print(c * 10 + b + a)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
[a, b, c] = sorted([a, b, c])
print(10 * a + b + c)

Failing test case input:
1 -3 0

Expected output:
7


Actual output:
-29


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
[a, b, c] = sorted([a, b, c], reverse=True)
print(10 * a + b + c)
Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

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)


Failing test case input:
9 9 5

Expected output:
104


Actual output:
104
104


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

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=sorted(input().split())

print(int(A+B)+int(C))

Failing test case input:
-1 5 1

Expected output:
50


Actual output:
-6


Fixed submission (verdict: Accepted):
A,B,C=sorted(input().split())

print(int(C+B)+int(A))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())

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

Failing test case input:
6 6 0

Expected output:
66


Actual output:
12


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=list(map(int,input().split()))
print(max((s[0]+10*s[1]+s[2]), (10*s[0]+s[1]+s[2])))

Failing test case input:
1 5 8

Expected output:
86


Actual output:
59


Fixed submission (verdict: Accepted):
s=list(map(int,input().split()))
s.sort()
print(s[0]+s[1]+10*s[2])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
li = list(map(int,input().split()))
li.sort()
print(10*li[0]+li[1]+li[2])

Failing test case input:
3 0 -1

Expected output:
29


Actual output:
-7


Fixed submission (verdict: Accepted):
li = list(map(int,input().split()))
li.sort(reverse = True)
print(10*li[0]+li[1]+li[2])

Problem: p03250
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
A=list(map(int, input().split()))
A.sort()
print(sum(A)+A[0]*9)

Failing test case input:
3 2 -1

Expected output:
31


Actual output:
-5


Fixed submission (verdict: Accepted):
A=list(map(int, input().split()))
A.sort(reverse=True)
print(sum(A)+A[0]*9)
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
number=[int(i) for i in input().split()]
number.sort()
int(str(number[2])+str(number[1]))+number[0]

Failing test case input:
-1 0 2

Expected output:
19


Actual output:

Fixed submission (verdict: Accepted):
number=[int(i) for i in input().split()]
number.sort()
print(int(str(number[2])+str(number[1]))+number[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

a,b,c=map(int,input().split())
ans=(max(a,b,c)*9 + a+b+c)

Failing test case input:
9 9 8

Expected output:
107


Actual output:

Fixed submission (verdict: Accepted):

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
li = list(map(int, input().split()))
ans = 0
li.sort()
ans += li[0]+li[1]+li[2]*10

Failing test case input:
1 8 1

Expected output:
82


Actual output:

Fixed submission (verdict: Accepted):
li = list(map(int, input().split()))
ans = 0
li.sort()
ans += li[0]+li[1]+li[2]*10
print(ans)

Problem: p03250
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b,c = map(int, input().split())
print(max(max(a,b), c) * 10 + min(max(a,b), max(b,c)) + min(min(a,b), c))

Failing test case input:
-1 12 1

Expected output:
120


Actual output:
131


Fixed submission (verdict: Accepted):
a,b,c = map(int, input().split())
print(max(max(a,b), c) * 10 + min(min(max(a,b), max(b,c)), max(a,c)) + min(min(a,b), c))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = list(map(int,input().split()))
l.sort()
print(l[0]*10 +l[1]+l[2])

Failing test case input:
-1 4 2

Expected output:
41


Actual output:
-4


Fixed submission (verdict: Accepted):
l = list(map(int,input().split()))
l.sort()
print(l[2]*10 +l[1]+l[0])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
print(max([a*10+b+c,a+b*10+c]))

Failing test case input:
1 4 8

Expected output:
85


Actual output:
49


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(max([a*10+b+c,b*10+c+a,c*10+a+b]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(max((10 * a + c), (a + 10 * b + c)))

Failing test case input:
1 -3 0

Expected output:
7


Actual output:
10


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(max((10 * a + b + c), (a + 10 * b + c), (a + b + 10 * c)))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=list(map(int,input().split()))
sorted(a)
print(a[0]+a[1]*a[2])


Failing test case input:
9 9 9

Expected output:
108

Actual output:
90


Fixed submission (verdict: Accepted):
a=list(map(int,input().split()))
a=sorted(a)
print(a[-1]*10+a[1]+a[0])

Problem: p03250
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b, c = map(int, input().split())
print(max(a*10+b+c, a+b*10+c))

Failing test case input:
5 4 8

Expected output:
89


Actual output:
62


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())
print(max(a*10+b+c, a+b*10+c, a+b+c*10))
Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c = input().split()

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

Failing test case input:
-1 12 1

Expected output:
120


Actual output:
-1121212121212121212121


Fixed submission (verdict: Accepted):
a, b, c = map(int, input().split())

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

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
abc = list(map(int,input().split()))
abc.sort
print(abc[0] + (abc[2]*10 + abc[1]))


Failing test case input:
2 21 1

Expected output:
213


Actual output:
33


Fixed submission (verdict: Accepted):
abc = list(map(int,input().split()))
abc.sort()
print(abc[0] + (abc[2]*10 + abc[1]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = list(map(int, input().split()))

ss = sorted(s)
print(s[-1]*10+s[-2]+s[-3])

Failing test case input:
1 21 1

Expected output:
212


Actual output:
32


Fixed submission (verdict: Accepted):
s = list(map(int, input().split()))

ss = sorted(s)
print(ss[-1]*10+ss[-2]+ss[-3])

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=map(int,input().split())
D=A+B
print(D+C)

Failing test case input:
6 7 9

Expected output:
103


Actual output:
22


Fixed submission (verdict: Accepted):
A,B,C=sorted(map(int,input().split()))
print(A+B+C*10)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = list(map(int, input().split()))
n.sort(reverse=True)
n2 = n[1] + n[2]

print("{}{}".format(n[0],n2))

Failing test case input:
9 9 8

Expected output:
107


Actual output:
917


Fixed submission (verdict: Accepted):
n = list(map(int, input().split()))
n.sort(reverse=True)
max = str(n[0]) + str(n[1])
max = int(max) + n[2]

print("{}".format(max))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=list(input().split())
a=sorted(a)
print(int(a[2])+int(a[0]+a[1]))

Failing test case input:
1 3 -4

Expected output:
27


Actual output:
-38


Fixed submission (verdict: Accepted):
a=list(input().split())
a=sorted(a)
print(int(a[0])+int(a[2]+a[1]))

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=map(int, input().split())  
if A==max(A,B,C):
    print(A*10+B+C)
elif B==max(A,B,C):
    print(B*10+A+C)
if C==max(A,B,C):
    print(C*10+B+A)

Failing test case input:
8 7 8

Expected output:
95


Actual output:
95
95


Fixed submission (verdict: Accepted):
A,B,C=map(int, input().split())  
if A==max(A,B,C):
    print(A*10+B+C)
elif B==max(A,B,C):
    print(B*10+A+C)
elif C==max(A,B,C):
    print(C*10+B+A)

Problem: p03250
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = list(map(int, input().split()))
s.sort()
print((s[2] * 10 + s[1]) + s[1])


Failing test case input:
1 -3 0

Expected output:
7


Actual output:
10


Fixed submission (verdict: Accepted):
s = list(map(int, input().split()))
s.sort()
print((s[2] * 10 + s[1]) + s[0])