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):
import sys

def odd_def(num):
    if num % 2 == 0:
        return False
    else:
        return True

def main():
    a,b = map(int, input().split())
    for i in range(1,4):
        mal = a*b*c
        if odd_def(mal):
            print('Yes')
            sys.exit()
    print('No')


if __name__ == '__main__' :
    main()

def main():
    l = list(map(int,input().split()))
    l = sorted(l,reverse=True)
    ans = ''

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


    




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):
mod = 10 ** 9 + 7
n, m = map(int, input().split())

f = []
p = 2
while p * p <= m:
    if m % p != 0:
        p += 1
        continue
    c = 0
    while m % p == 0:
        c += 1
        m //= p
    f.append(c)
    p += 1
if m != 1:
    f.append(1)


def comb(a, b):
    ret = 1
    r = min(b, a-b)
    for i in range(a-r+1, a+1):
        ret *= i
    for j in range(1, r+1):
        ret /= j
    return (int)(ret)


res = 1
for ele in f:
    ret = comb(ele+n-1, n-1)
    res *= ret

print(res % mod)


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

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

Verdicts: Runtime Error

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,B+C,C+A))

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


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):
def main():
    ABC = [int(s) for s in input().split()]
    sorted = ABC.sort()
    result = int(str(sorted[0])+str(sorted[1])) + sorted[2]
    print(result)

if __name__ == "__main__":
    main()

def main():
    inputs = [int(s) for s in input().split()]
    sorted_list = sorted(inputs,reverse=True)
    result = int(str(sorted_list[0])+str(sorted_list[1])) + sorted_list[2]
    print(result)

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

lst = list(map(int, input().split()))
print(max(lst)*10+sum(lst)-max(lst))

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):
import math
from scipy.misc import comb
 
N, M = map(int, input().split())
li1 = []
li2 = []
a = 1

for j in range(2, int(math.sqrt(M))):
    dest = int(math.sqrt(j))
    for i in range(2,dest):
        if j % i == 0:
            continue
    li1.append(j)

for k in range(len(li1)):
    if M % li1[k] != 0:
        continue
    c = 0
    x = M
    while x % li1[k] == 0:
        x = x / li1[k]
        c += 1
    li2.append(c)

for l in range(len(li2)):
    a *= comb(li2[l] + N - 1, N - 1)

print(int(a))

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

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

Verdicts: Runtime Error

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

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

array = list(map(int, input().strip().split()))
#array.sort(reverse = True)
N = array[0]
M = array[1]
X = array[2]
Y = array[3]

xarray = list(map(int, input().strip().split()))
xarray.sort(reverse = True)
##print(xarray)
xmax = xarray[0]

yarray = list(map(int, input().strip().split()))
yarray.sort()
##print(yarray)
ymin = yarray[0]
if (ymin > xmax):
    if((abs(ymin) - abs(xmax)) >= 1):
        print("No War")
    else:
        print("War")
else:
    print("War")

##print(array)


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

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

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

if a>=b and a>=c:
  a = a*10
  print(a+b+c)
elif b>=a and b>=c:
  b = b*10
  print(a+b+c)
else:
  c = c*10
  print(a+b+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=map(int,input().split())
x=max(a,b,c)
print(x*10+sum(a,b,c)-x)

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

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())
ans = []
ans.append(A+B)
ans.append(B+C)
ans.append(C+A)
print(max(ans))

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

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


Verdicts: Wrong Answer

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):
from sys import stdin
a,b,c=[x for x in stdin.readline().rstrip().split()]
print(max(int(a)+int(b+c),int(a+b)+int(c))

from sys import stdin
a,b,c=[x for x in stdin.readline().rstrip().split()]
print(max(int(a)+int(b+c),int(a+b)+int(c),int(c+b)+int(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):
N, M, X, Y = map(int, input().split())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.append(X)
y.append(Y)
if max(x) < min(y):
    print('No War')
else:
    print('War')

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

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

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

numbers = [int(input()) for i in range(3)]

numbers.sort()
numbers.reverse()

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

numbers = [int(input()) for i in range(3)]

numbers.sort()
numbers.reverse()

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

numbers = [int(input()) for i in range(3)]

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

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

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

Verdicts: 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):
num = [int(i) for i in input().split()]
num = num.sorted(reverse=True)
ans = 10*num[0] + num[1] + num[2]
print(ans)

num = [int(i) for i in input().split()]
num.sort()
print(sum(num)+num[-1]*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):
NMXY = list(map(int,input().split()))
N=NMXY[0]
M=NMXY[1]
X=NMXY[2]
Y=NMXY[3]
x=list(map(int,input().split()))
y=list(map(int,input().split()))
flag1=[]
flag2=[]

Z=list(range(X+1,Y))

for k in Z:
    flag1.append(all([i<k for i in x]))
    flag2.append(all([j>=k for j in y]))
print(flag1)
print(flag2)
if any(flag1) and any(flag2):
    print('No War')
else:
    print('War')


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

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

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

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

p = [A, B, C]

p.sort()

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

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

p = [A, B, C]

p.sort()

print(int(str(p[2]) + str(p[1])) + p[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):
S=list(input().split())
AS=sorted(S)
print(int((S[2]+S[1])+int(S[0]))

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


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


Verdicts: Runtime Error

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=[int(input()) for i in range(3)]
N.sort (reverse=True)
ans1=10*N[0]+N[1]
ans2=N[-1]
print(ans1+ans2)

a,b,c=map(int,input().split())
N=[a,b,c]
N.sort (reverse=True)
print(10*N[0]+N[1]+N[-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):
iptA=list(map(int,input().split()))
X=list(map(int,input().split())).append(iptA[2])
Y=list(map(int,input().split())).append(iptA[3])

xmax,ymax=max(X),max(Y)
if xmax>=ymax:
    print('War')
 else:
     print('No War')

iptA=list(map(int,input().split()))
X=list(map(int,input().split()))
Y=list(map(int,input().split()))
X.append(iptA[2])
Y.append(iptA[3])
     
xmax,ymin=max(X),min(Y)
if xmax>=ymax:
    print('War')
else:
    print('No War')

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

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


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


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


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 = input().split()
a.sort
print(int(a[2]+a[1]) + int(a[0]))

a = input().split()
b = sorted(a, key = int)
print(int(b[2]+ b[1]) + int(b[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):
k=list(map(str,input().split()))
print(int(max(k)+max(k)[1])+int(min(k)))


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

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

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


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


Verdicts: Runtime Error

Wrong Answer

Wrong Answer

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

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

A=list(input().split())
A=sorted(A)
b=A[0]+A[1]
print(int(b)+int(A[2]))

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

Verdicts: Wrong Answer

Wrong Answer

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


def main():
    """Function."""
    a, b, c = map(int, input().split())
    print(max([a+b, a+c, b+c]))


if __name__ == "__main__":
    main()


# -*- coding: utf-8 -*-


def main():
    """Function."""
    a = list(map(str, input().split()))
    a.sort(reverse=True)
    print(int(a[0]+a[2]) + int(a[1]))


if __name__ == "__main__":
    main()


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):
 = list(input())
b = [int(i) for i in a]
c=sorted(b,reverse=True)
d =10*c[0]+c[1]+c[2]
print(d)

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

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

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

a, b, c = list(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)   

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(input().split()))
print(10*C+A+B)

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


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

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

x = [int(a) for a in input().split(' ')]
x = sorted(x)
print(x[0] + x[1] + x[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):
n = [int(x) for x in input().split()].sort()
print(10*n[2]+n[1]+n[0])

n = [int(x) for x in input().split()]
n.sort()
print(10*n[2]+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, B, C = map(int, input().split())
S = sum(A,B,C)
print(max(S+9*A, S+9*B, S+9*C))

A, B, C = map(int, input().split())
S = A+B+C
print(max(S+9*A, S+9*B, S+9*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(input(), reverse=False)
print(int(S[0:2])+int(S[2]))


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

s = sorted.[a, b, c]

print(s)

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

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


S = list(input().split())
S.sort(reverse=True)
a = int("".join(S[:2]))
b = int(S[2])
print(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):
nums = sorted(list(map(int, input().split())))
print(int(str(nums[0]) + str(nums[1])) + nums[2])

a, b, c = map(int, input().split())
print(max(a, b, c) * 9 + 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 = map(int(input().split()))
li.sort()
print(li[0]*10+li[1]+li[2])

import collections
s=input()
t=input()
s = collections.Count(s)
t = collections.Count(t)
if sorted(s.values()) == sorted(t.values()):
  print("Yes")
else:
  print("No")

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

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=input().split()
L.sort()
X=10*L[2]+L[1]+L[0]
print(X)

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

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

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

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


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


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

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


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


Verdicts: Runtime Error

Runtime Error

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

ls = list(map(int,input().split()))
ls = sorted(ls)
print(ls[2]*10+ls[1]+ls[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):
s, t = [input() for _ in range(2)]

for i in range(len(s)):
    if s[i] == t[i]:
        pass
    else:
        s_diff = s[i]
        t_diff = t[i]
        s = s.translate(str.maketrans({s_diff: "", t_diff: ""}))
        t = t.translate(str.maketrans({s_diff: "", t_diff: ""}))
if s == t:
    print("Yes")
else:
    print("No")


num = list(map(int, input().split()))
num.sort()
num.reverse()
m_ = int(str(num[0]) + str(num[1]))
_m = num[2]
sum_ = m_ + _m
print(sum_)


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])
int(str(l[2])+str(l[1]))+l[0]

a,b,c = map(int,input().split())
l=sorted([a,b,c])
print(int(str(l[2])+str(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):
N,M,X,Y=map(int,input().split())
x_list =list(map(int,input().split()))
y_list=list(map(int,input().split()))

for i in range(1,100):

     if(max(x_list)<i and i<=min(y_list)):
        print('No War')
        exit(0)
print('War')
exit(0)

lists=input().split()

for i in range(len(lists)):
    lists[i]=int(lists[i])

lists=sorted(lists,reverse=True)
print(lists[0]*10+lists[1]+lists[2])

Verdicts: Runtime Error

Accepted