TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: 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.

Submission attempts (in order):
A = int(input())
B = int(input())
C = int(input())
a = 10*A + B
b = 10*B + C
print(max([a+C ,A+b]))

A = int(input())
B = int(input())
C = int(input())
a = 10*A + B
b = 10*B + C
c = 10*C + A
d = 10*A + C
e = 10*B + A
f = 10*C +B
print(max([a+C ,b+A, c+B, d+B, e+C, f+A]))


suuji = list(map(int, input().split()))
saidai = max(suuji)
suuji.remove(saidai)
print(saidai*10+suuji[0]+suuji[1])


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a,b,c = map(int,input().split())
print(max(10*a+b,10*b+c))

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
s = list(map(int, input().split()))
s.sort()
print((s[2] * 10 + s[1]) + s[1])


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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
N, M, X, Y =map( int, input()split())
x = list(map( int, input().split()))
y = list(map( int, input().split()))
 
x = sorted(x)
y = sorted(y)
 
for i in range(X + 1, Y + 1):
  if( x[N-1] < i <= y[0]):
    print('No War')
    exit()
    
  else:
    print('War')
    break

N = list(map( int, input().splot()))

N = sorted(N)

Nmax = int(N[2] * 10 + N[1] + N[0])

print(int(Nmax))

N, M, X, Y =map( int, input().split())
x = list(map( int, input().split()))
y = list(map( int, input().split()))
 
x = sorted(x)
y = sorted(y)
 
for i in range(X + 1, Y + 1):
  if( x[N-1] < i <= y[0]):
    print('No War')
    exit()
    
print('War')

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

N = sorted(N)

Nmax = int( N[2] * 10 + N[1] + N[0])

print(int(Nmax))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
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])

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
A, B, C = map(int, input().split())
print(sum([A, B, C]) - min([A, B, C]))

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

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

A, B, C = map(int, input().split())
print(sum(A, B, C) - min(A, B, C))

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

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

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a = list(map(int,input()))

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


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

Verdicts: Runtime Error

Accepted
Problem: 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.

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a = list(map(int, input().split()))
d = max(a)
a.remove(d)
ans(d*10+sum(a))

a = map(int, input().split())
d = max(a)
a.remove(d)
ans(d*10+sum(a))



s = input()
t = input()
dict_s = ["_"]*26
dict_t = ["_"]*26
alphabet = [chr(i) for i in range(97, 97 + 26)]
print(alphabet)
for i in range(len(s)):
    if dict_s[alphabet.index(s[i])] == "_":
        dict_s[alphabet.index(s[i])] = t[i]
    elif dict_s[alphabet.index(s[i])] != t[i]:
            print("No")
            exit()
    if dict_t[alphabet.index(t[i])] == "_":
        dict_t[alphabet.index(t[i])] = s[i]
    elif dict_t[alphabet.index(t[i])] != s[i]:
            print("No")
            exit()
print("Yes")


a = list(map(int, input().split()))
d = max(a)
a.remove(d)
print(d*10+sum(a))


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
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])

panels = input().split()
panels = [int(panel) for panel in panels]
panels = sorted(panels,reverse=True)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
l = list(map(int,input().split()))
l.sort
print(l[2]*10 + l[1] + l[0])

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
l = list(map(int,input().split()))
l.sort()
print(l[0]*10+l[1]+l[2])

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
a,b,c=map(int,input().split())
ans=[]
ans.append(a)
ans.append(b)
ans.append(c)
ans.sort(reverse=True)
temp=""
temp+=ans[0]
temp+=ans[1]
print(int(temp)+ans[2])


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


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a=int(input().split())
a.sort()
print(a[2]*10+a[1]+a[0])

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
abc = list(map(int,input()))
abc.sort()
abc[2] *= 10
print(sum(abc))

abc = list(map(int,input().split()))
abc.sort()
abc[2] *= 10
print(sum(abc))


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
A =list(map(int, input().split()))
A.sort()
print(A)
print(A[2]*10+A[1]+A[0])

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
a,b,c=map(int,input().split())
print(max(a,b,c)*10 + sorted(nums)[-2] + min(a,b,c))

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
lst = list(map(int, input().split()))
ans = 0

max_ = -1
argmax = None
for i in range(3):
    if lst[i] > max_:
        max_ = lst[i]
        argmax = i

lst.pop(i)
ans = int(str(max_) + '0')
for l in lst:
    ans += l
print(ans)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
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")

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a, b, c = list(map(int, input().split()))

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

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

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
li = list(map(int,input().rstrip().split()))


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

#110 Maximize the Formula

li = list(map(int, input().rstrip().split()))
li.sort()

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)

a,b,c = sorted(map(int,readline().split()))
print (10 * c  + b + a)

import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
 
a,b,c = sorted(map(int,readline().split()))
print (10 * c  + b + a)


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a,b,c=map(int,input().split())
arr=[a,b,c]
arr=sorted(a,b,c)
print(10*arr[-1]+arr[1]+arr[0])

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
n = list(map(int, input().split()))
n = n.sort()
print(n[2]* 10 + n[1] + n[0])

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
num = list(map(int, input().split()))
num.sort(reverse=True)
a = str(num[0])
b = str(num[1])
c = int(num[2])
ab = a + b
ab = int("ab")
print(ab + c)

num = list(map(int, input().split()))
num.sort(reverse=True)
a = str(num[0])
b = str(num[1])
c = int(num[2])
ab = a + b
ab = int(ab)
print(ab + c)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):

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



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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
l=list(map(int,input().split()))
l.sort(reverse=True)
ans=l[0]*9+sum(l)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
abc=list(map(int,input().split()))
print(sum(abc)-min(abc))

abc=sorted(list(map(int,input().split())))
print(int(str(abc[2])+str(abc[1]))+abc[0])


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
A = list(map(int, input().split()))
A.sort()
print(int(A[2] + A[1]) + int(A[0]))

A = input().split()
A.sort()
print(int(A[2] + A[1]) + int(A[0]))

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
l = list(map(int,input().split()))
l.sort()
print(sum(l[:2])+l[2]*100)

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
ns = input().split()

def bSort(a):
    for i in range(len(a)):
        for j in range(len(a)-1, i, -1):
            if a[j] < a[j-1]:
                a[j], a[j-1] = a[j-1], a[j]

    return a

def bSort(a):
    for i in range(len(a)):
        for j in range(len(a)-1, i, -1):
            if a[j] < a[j-1]:
                a[j], a[j-1] = a[j-1], a[j]

    return a

ns = input().split()
s = bSort(ns)
print(int(s[2]) * 10 + int(s[1]) + int(s[0]))

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
A,B,C = sorted(map(int, input().split()))
print(C*10+B+C)

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
import numpy as np,math,itertools

a=[int(i) for i in input()]
b=a[1]
c=a[2]
d=a[0]
print(max([10*d+b+c,d+10*b+c]))

import numpy as np,math,itertools

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
s=sorted(list(map(int,input().input())))[::-1]
print(s[0]*10+s[1]+s[2])


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


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a, b, c = sorted(map(int, input()))
print(a + b + c * 10)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
l = [int(i) for i in input().split()]
l.sort()
print(l[0] * 10 + l[1] + l[2])

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
abc = list(map(int,input().split(" "))
m = max(abc)
s = sum(abc)
ans = s-m+(m*10)
print(ans)

abc =list(map(int,input().split(" "))) 
m = max(abc)
s = sum(abc)
ans = s-m+(m*10)
print(ans)

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
A,B,C = map(int,input().split()
max(10*A + B + C,A+10*B+C,A+B+10*C)

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
l = [int(input()) for i in range(3)]
l.sort()
print(l[2]*10 + l[0] + l[1])

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

Verdicts: Runtime Error

Accepted
Problem: 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.

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

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

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

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

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
num = int(input()),int(input()),int(input())

num = list(num)

num.sort()
num.reverse()

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


num = list(input())

num = num.sort().reverse()

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


num = [0,0,0]
num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.sort()

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

a = int(input())
b = int(input())
c = int(input())


if a < b:
    d = b
    another = a
else:
    d = a
    another = b

if d < c:
    d2 = str(d)
    d = str(c)

f = d + d2

print(int(f)+another)

num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.sort()

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

num = [0,0,0]
num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.sort().reverse()

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

num = [0,0,0]
num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.sort()
num.reverse()

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


num = list(input())

num.sort().reverse()

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




num = [0,0,0]
num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.sort()
num.reverse()

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


num = [0,0,0]
num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.sorted()

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

num = [0,0,0]
num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.reverse()

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

num = []
num[0] = int(input())
num[1] = int(input())
num[2] = int(input())

num.sort()

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

a = int(input())
b = int(input())
c = int(input())


if a < b:
    d = b
    another = a
else:
    d = a
    another = b

if d < c:
    d[0] = str(d)
    d[1] = str(c)

f = d[1] + d[0]

print(int(f)+another)


s = input()

num = list(s)

num.sort()
num.reverse()

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



Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a, b, c = map(int, input().split())
[a, b, c] = sorted([a, b, c])
print(10 * a + b + c)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
n = map(int, input().split())
n.sort()
print(n[2]*10 + n[1] + n[0])

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a = list(map(int, input().split()))
a.sort()

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

a = list(map(int, input().split()))
a.sort()

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
a=list(map(int,input().split));print(sum(a)+max(a)*9)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
num=[int(i) for i in input().split()]

num.sort()

print(num[1]+num[2])

num=[int(i) for i in input().split()]

num.sort()

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

Verdicts: Wrong Answer

Accepted