problem_id
stringlengths 6
6
| user_id
stringlengths 10
10
| time_limit
float64 1k
8k
| memory_limit
float64 262k
1.05M
| problem_description
stringlengths 48
1.55k
| codes
stringlengths 35
98.9k
| status
stringlengths 28
1.7k
| submission_ids
stringlengths 28
1.41k
| memories
stringlengths 13
808
| cpu_times
stringlengths 11
610
| code_sizes
stringlengths 7
505
|
|---|---|---|---|---|---|---|---|---|---|---|
p03250
|
u538568153
| 2,000
| 1,048,576
|
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.
|
['n = sorted( list( map(int, input().split() ) ))\nx = int( str(n[0])+str(n[1]) ) + n[2]\nprint(x)', 'n = sorted( list( map(int, input().split() ) ))[::-1]\nx = int( str(n[0])+str(n[1]) ) + n[2]\nprint(x)']
|
['Wrong Answer', 'Accepted']
|
['s127597940', 's682815164']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[94, 100]
|
p03250
|
u538956308
| 2,000
| 1,048,576
|
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.
|
['import statistics\nN = list(map(int,input().split()))\nA = max(N)\nB = min(N)\nC = median(N)\nprint(A*10+B+C)\n', 'import statistics\nN = list(map(int,input().split()))\nA = max(N)\nB = min(N)\nC = sum(N)-A-B\nprint(A*10+B+C)']
|
['Runtime Error', 'Accepted']
|
['s076803314', 's011082816']
|
[5144.0, 5400.0]
|
[37.0, 42.0]
|
[105, 105]
|
p03250
|
u539953365
| 2,000
| 1,048,576
|
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.
|
["N, M , X, Y = [int(i) for i in input().split()]\nx = [int(i) for i in input().split()]\ny = [int(i) for i in input().split()]\nif X < Y and max(x) < min(y) and min(y) > X and max(x) < Y:\n print('No War')\nelse:\n print('War')", 'A, B, C = input().split()\n#ABC\n#ABC\n#BAC\n#BCA \n#CAB\n#CBA \nprint(max(int(A+B)+int(C), int(A+C)+int(B), int(B+A)+int(C), int(B+C)+int(A), int(C+A)+int(B),int(C+B)+int(A)))']
|
['Runtime Error', 'Accepted']
|
['s098249742', 's022954015']
|
[3060.0, 3188.0]
|
[17.0, 18.0]
|
[227, 169]
|
p03250
|
u543173665
| 2,000
| 1,048,576
|
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.
|
['a = list(map(int,input().split())\na.sort()\nprint(10*a[2]+a[1]+a[0])', 'a = list(int,input().split())\na.sort()\nprint(10*a[2]+a[1]+a[0])', 'a = list(map(int,input().split()))\na.sort()\nprint(10*a[2]+a[1]+a[0])\n']
|
['Runtime Error', 'Runtime Error', 'Accepted']
|
['s194615168', 's471354385', 's938635069']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[67, 63, 69]
|
p03250
|
u546853743
| 2,000
| 1,048,576
|
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.
|
['S=list(map(int,input().split()))\nS.sort()\nall=0\nall += (S[2]+10*S[0]+S[1])\nprint(all)\n', '\nS=list(map(int,input().split()))\nS.sort()\nall=0\nall += (S[0]+10*S[2]+S[1])\nprint(all)']
|
['Wrong Answer', 'Accepted']
|
['s450916983', 's109467715']
|
[9004.0, 8988.0]
|
[29.0, 26.0]
|
[86, 86]
|
p03250
|
u551692187
| 2,000
| 1,048,576
|
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.
|
['A,B,C = map(int, input().split())\nprint(max(A,B,C)*9+sum(A,B,C))\n', 'A,B,C = map(int, input().split())\nprint(max(A,B,C)*9+A+B+C)']
|
['Runtime Error', 'Accepted']
|
['s242161073', 's325368004']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[65, 59]
|
p03250
|
u556225812
| 2,000
| 1,048,576
|
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.
|
['lst = list(map(int, input().split()))\nlst.sort(reverse=True)\nn = lst[0] * 10 + lst[1] + lst[2]\nn', "from collections import Counter\n \ns = input()\nt = input()\n \nc1 = Counter(s).most_common()\nc2 = Counter(t).most_common()\n\nfor i, j in zip(c1, c2):\n if i[1] != j[1]:\n print('No')\n break\nelse:\n print('Yes')", 'lst = list(input().split())\nlst.sort()\nprint(int(lst[2]+lst[0]) + int(lst[1]))\n ']
|
['Wrong Answer', 'Runtime Error', 'Accepted']
|
['s399977372', 's697709370', 's106735252']
|
[2940.0, 3316.0, 2940.0]
|
[17.0, 21.0, 17.0]
|
[96, 211, 91]
|
p03250
|
u556672233
| 2,000
| 1,048,576
|
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.
|
['abc = list(map(int, input().split()))\na, b, c = sorted(abc)\nprint(10 * a + b + c)\n', 'abc = list(map(int, input().split()))\na, b, c = sorted(abc)\nprint(10 * c + b + a)\n']
|
['Wrong Answer', 'Accepted']
|
['s430987201', 's853884265']
|
[2940.0, 2940.0]
|
[17.0, 18.0]
|
[82, 82]
|
p03250
|
u559346857
| 2,000
| 1,048,576
|
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.
|
['a,b,c=sorted(map(int,input().split()))\nprint(c*10+b+c)', 'a,b,c=map(int,input().split())\nprint(c*10+b+c)', 'a,b,c=sorted(map(int,input().split()))\nprint(c*10+b+a)']
|
['Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s187071144', 's790755298', 's496999112']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 18.0, 17.0]
|
[54, 46, 54]
|
p03250
|
u562016607
| 2,000
| 1,048,576
|
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.
|
['L=sorted(map(int,input().split()))\nprint(L[0]*9+sum(L))', 'L=sorted(map(int,input().split()))\nprint(L[2]*9+sum(L))\n']
|
['Wrong Answer', 'Accepted']
|
['s019302829', 's984166952']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[55, 56]
|
p03250
|
u562472335
| 2,000
| 1,048,576
|
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.
|
['a,b,c=map(int.input().split())\nl=sorted([a,b,c])\nprint(l[2]*10 + l[1] + l[0])', 'a,b,c=map(int,input().split())\nl=sorted([a,b,c])\nprint(l[2]*10 + l[1] + l[0])']
|
['Runtime Error', 'Accepted']
|
['s637715165', 's664438410']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[77, 77]
|
p03250
|
u564368158
| 2,000
| 1,048,576
|
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.
|
['a, b, c = map(int, input().split())\nlis = list(map(int, input().split()))\nlis.sort()\nprint(lis[2]*10 + lis[1] + lis[0])', 'lis = list(map(int, input().split()))\nlis.sort()\nprint(lis[2]*10 + lis[1] + lis[0])']
|
['Runtime Error', 'Accepted']
|
['s572014995', 's196584638']
|
[2940.0, 3064.0]
|
[18.0, 18.0]
|
[119, 83]
|
p03250
|
u564589929
| 2,000
| 1,048,576
|
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.
|
["import sys\nsys.setrecursionlimit(10 ** 6)\n# input = sys.stdin.readline ####\nint1 = lambda x: int(x) - 1\ndef II(): return int(input())\n\ndef MI(): return map(int, input().split())\ndef MI1(): return map(int1, input().split())\n\ndef LI(): return list(map(int, input().split()))\ndef LI1(): return list(map(int1, input().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\n\nINF = float('inf')\n\ndef solve():\n S = list(input())\n T = list(input())\n\n ds = {}\n dt = {}\n ids = ''\n idt = ''\n cids = 0\n cidt = 0\n for i in range(len(S)):\n # S\n s = S[i]\n if s in ds: \n idss = ds[s]\n ids = ids + str(idss)\n else: \n cids += 1\n ds[s] = cids\n ids = ids + str(cids)\n\n # T\n t = T[i]\n if t in dt:\n idst = dt[t]\n idt = idt + str(idst)\n else:\n cidt += 1\n dt[t] = cidt\n idt = idt + str(cidt)\n\n if ids != idt:\n print('No')\n return\n\n print('Yes')\n\n\n\nif __name__ == '__main__':\n solve()\n", "L = list(map(int, input().split()))\n\nL = sorted(L)[::-1]\n\ns = '{}{}+{}'.format(L[0], L[1], L[2])\nprint(eval(s))"]
|
['Runtime Error', 'Accepted']
|
['s823239519', 's034962830']
|
[3064.0, 2940.0]
|
[25.0, 18.0]
|
[1270, 111]
|
p03250
|
u568426505
| 2,000
| 1,048,576
|
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.
|
['a,b,c=input()\nif a<b:\n a,b=b,a\nif b<c:\n b,c=c,b\nif a<b:\n a,b=b,a\nprint(10*a+b+c)', '\na,b,c=map(int,input().split())\nif a<b:\n a,b=b,a\nif b<c:\n b,c=c,b\nif a<b:\n a,b=b,a\nprint(10*a+b+c)\n']
|
['Runtime Error', 'Accepted']
|
['s120138206', 's391202948']
|
[8828.0, 9172.0]
|
[29.0, 25.0]
|
[83, 102]
|
p03250
|
u571445182
| 2,000
| 1,048,576
|
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.
|
["Tmp = []\nTmp = input().rstrip().split(',')\n\nAns = []\n\nnA = int(Tmp[0])\nAns.append(nA)\n\nnB = int(Tmp[1])\nAns.append(nB)\n \nnC = int(Tmp[2])\nAns.append(nC)\n\nAns.sort(reverse='True')\n\nnAns = Ans[0]*10+Ans[1]+Ans[2]\nprint(nAns)\n\n", "Tmp = []\nTmp = input().rstrip().split(' ')\n \nAns = []\n \nnA = int(Tmp[0])\nAns.append(nA)\n \nnB = int(Tmp[1])\nAns.append(nB)\n \nnC = int(Tmp[2])\nAns.append(nC)\n \nAns.sort(reverse=True)\n \nnAns = Ans[0]*10+Ans[1]+Ans[2]\nprint(nAns)\n"]
|
['Runtime Error', 'Accepted']
|
['s817186630', 's832922451']
|
[3060.0, 3060.0]
|
[17.0, 18.0]
|
[225, 227]
|
p03250
|
u571969099
| 2,000
| 1,048,576
|
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.
|
['n = [int(i) for i in input().split()]\nn.sort(reverse=True)\nprint(n[0]*10*n[1]+n[2])', 'n = [input(i) for i in input().split()]\nn.sort(reverse=True)\nprint(n[0]*10*n[1]+n[2])', 'n = [int(i) for i in input().split()]\nn.sort(reverse=True)\nprint(n[0]*10+n[1]+n[2])']
|
['Wrong Answer', 'Runtime Error', 'Accepted']
|
['s089710653', 's490315232', 's897908252']
|
[2940.0, 2940.0, 2940.0]
|
[18.0, 19.0, 17.0]
|
[83, 85, 83]
|
p03250
|
u572561929
| 2,000
| 1,048,576
|
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.
|
['A = list(map(int, input().split()))\nA.sort()\nprint(A)\nprint(10 * A[2] + A[0] + A[1])\n', 'A = list(map(int, input().split()))\nA.sort()\nprint(10 * A[2] + A[0] + A[1])\n']
|
['Wrong Answer', 'Accepted']
|
['s800406339', 's949846147']
|
[2940.0, 2940.0]
|
[18.0, 17.0]
|
[85, 76]
|
p03250
|
u576844664
| 2,000
| 1,048,576
|
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.
|
['str = input().split(" ")\nstr.sort()\nprint(int(str[0] + str[1]) + int(str[2]))', 'l = input().split(" ").sort()\nprint(int(l[0] + l[1]) + int(l[2])', 'str = input().split(" ")\nstr.sort(reverse=True)\nprint(int(str[0] + str[1]) + int(str[2]))\n']
|
['Wrong Answer', 'Runtime Error', 'Accepted']
|
['s553164811', 's845390464', 's452445992']
|
[2940.0, 3064.0, 2940.0]
|
[18.0, 17.0, 18.0]
|
[77, 64, 90]
|
p03250
|
u577037250
| 2,000
| 1,048,576
|
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.
|
['A, B, C = map(int, input().split())\nprint(A, B, C)\nnumber = []\nnumber.append([A, B, C])\n\nnumber.sort()\nprint(number[2]*10 + number[1] + number[0])', 'A, B, C = map(int, input().split())\nnumber = []\nnumber.append(A)\nnumber.append(B)\nnumber.append(C)\n\nnumber.sort()\nprint(number[2]*10 + number[1] + number[0])']
|
['Runtime Error', 'Accepted']
|
['s457311358', 's032788720']
|
[3060.0, 3060.0]
|
[17.0, 18.0]
|
[146, 157]
|
p03250
|
u580236524
| 2,000
| 1,048,576
|
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.
|
['s = list(map(int, input().split()))\n\nss = sorted(s)\nprint(s[-1]*10+s[-2]+s[-3])', 's = list(map(int, input().split()))\n\nss = sorted(s)\nprint(ss[-1]*10+ss[-2]+ss[-3])']
|
['Wrong Answer', 'Accepted']
|
['s043599016', 's690318410']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[79, 82]
|
p03250
|
u583276018
| 2,000
| 1,048,576
|
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.
|
['a = list(map(int, input().split()))\nb = a.pop(max(a))\nprint(b*10+sum(a))', 'a = list(map(int, input().split()))\nb = a.pop(a.index(max(a)))\nprint(b*10+sum(a))']
|
['Runtime Error', 'Accepted']
|
['s626124177', 's783117941']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[72, 81]
|
p03250
|
u584558499
| 2,000
| 1,048,576
|
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.
|
["def main():\n nums = sorted([int(i) for i in input().split()], reverse=True)\n max_num = 10 * nums[0] + nums[1] + nums[2]\n print(max_num)\n\n\nif __name__ == '__main__':\n main()\nFujitakes-MacBook-Pro:tmp mas", "def main():\n nums = sorted([int(i) for i in input().split()], reverse=True)\n max_num = 10 * nums[0] + nums[1] + nums[2]\n print(max_num)\n\n\nif __name__ == '__main__':\n main()"]
|
['Runtime Error', 'Accepted']
|
['s410253004', 's903687555']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[214, 184]
|
p03250
|
u591779169
| 2,000
| 1,048,576
|
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.
|
['a,b,c = map(int, raw_input().split())\n\nprint(max([a, b, c])*10+sum([a,b,c])-max([a,b,c]))', 'a,b,c = map(int, input().split())\n\nprint(max([a, b, c])*10+sum([a,b,c])-max([a,b,c]))\n']
|
['Runtime Error', 'Accepted']
|
['s972627153', 's671148105']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[89, 86]
|
p03250
|
u594803920
| 2,000
| 1,048,576
|
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.
|
['li = list(map(int, input().split()))\nans = 0\nli.sort()\nans += li[0]+li[1]+li[2]*10', 'li = list(map(int, input().split()))\nans = 0\nli.sort()\nans += li[0]+li[1]+li[2]*10\nprint(ans)']
|
['Wrong Answer', 'Accepted']
|
['s226782899', 's440206890']
|
[2940.0, 2940.0]
|
[17.0, 18.0]
|
[82, 93]
|
p03250
|
u595952233
| 2,000
| 1,048,576
|
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.
|
['a, b, c = map(int, input().split())\nprint(max(a*10+b+c, a+b*10+c), a+b+c*10)', 'a, b, c = map(int, input().split())\nprint(max(a*10+b+c, a+b*10+c, a+b+c*10))']
|
['Wrong Answer', 'Accepted']
|
['s123089792', 's568391512']
|
[9144.0, 9128.0]
|
[28.0, 28.0]
|
[76, 76]
|
p03250
|
u597455618
| 2,000
| 1,048,576
|
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.
|
['n = list(map(int, input().split()))\nn.reverse()\nprint(n[0]*10 + n[1] + n[2])', "n = list(map(int, input().split()))\nn.reverse()\nprint('n[0]n[1]' +[2])", 'n = list(map(int, input().split()))\nn.sort()\nprint(n[2]*10 + n[1] + n[0])']
|
['Wrong Answer', 'Runtime Error', 'Accepted']
|
['s476482173', 's603202552', 's634719764']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 18.0]
|
[76, 70, 73]
|
p03250
|
u598720217
| 2,000
| 1,048,576
|
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.
|
["import sys\ndef input():\n return sys.stdin.readline()[:-1]\n\na,b,t = map(int,input().split(' '))\nM = max(a,b,t)*10\nm = min(a,b,t)\nprint(min(a,b,t)+max(a,b,t)*10+a+b+t-M-m)", "import sys\ndef input():\n return sys.stdin.readline()[:-1]\na,b,c = map(int,input().split(' '))\nM = max(a,b,c)\nT = a+b+c\nprint((T-M)+M*10)"]
|
['Wrong Answer', 'Accepted']
|
['s565349210', 's968212742']
|
[3060.0, 3060.0]
|
[17.0, 17.0]
|
[172, 139]
|
p03250
|
u600261652
| 2,000
| 1,048,576
|
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.
|
['a, b, c = sorted(map(int, input().split()))\nprint(c*10+b+c)', 'a, b, c = sorted(map(int, input().split()))\nprint(c*10+b+a)']
|
['Wrong Answer', 'Accepted']
|
['s316635227', 's797136260']
|
[2940.0, 2940.0]
|
[18.0, 17.0]
|
[59, 59]
|
p03250
|
u604398799
| 2,000
| 1,048,576
|
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.
|
['import time\nimport collections\nimport scipy.misc\n\ndef prime_decomposition(n):\n i = 2\n table = []\n while i * i <= n:\n while n % i == 0:\n n /= i\n table.append(int(i))\n i += 1\n if n > 1:\n table.append(int(n))\n return table \n\nN, M = map(int, input().split())\nt_strt = time.time() \n\nfactors = collections.Counter(prime_decomposition(M))\nt_elps = time.time()\n#print(f"{t_elps - t_strt} [sec]")\nnum_pattern = 1;\n\nfor exponent in factors.values():\n tmp_num_pattern = scipy.misc.comb(exponent + N -1, N-1, exact = True) \n num_pattern = num_pattern * int(tmp_num_pattern)\n \n#print(num_pattern%(10**9+7))\n\nt_elps = time.time()\nprint(f"{t_elps - t_strt} [sec]")', '\nA, B, C = map(int, input().split())\n\ntmp_max = 10*A + B + C \n\nif tmp_max < 10*B + C +A:\n tmp_max = 10*B + C +A\n\nif tmp_max < 10*C + A +B:\n tmp_max = 10*C + A +B\n\n\nprint("{}".format(tmp_max))']
|
['Runtime Error', 'Accepted']
|
['s918110382', 's669731906']
|
[3064.0, 2940.0]
|
[17.0, 17.0]
|
[684, 222]
|
p03250
|
u604412462
| 2,000
| 1,048,576
|
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.
|
['s = sorted(list(map(int, input().split())))\nprint(s[0]*10+s[1]+s[2])', 's = sorted(list(map(int, input().split())))\nprint(s[2]*10+s[1]+s[0])']
|
['Wrong Answer', 'Accepted']
|
['s472464716', 's816168093']
|
[2940.0, 2940.0]
|
[18.0, 18.0]
|
[68, 68]
|
p03250
|
u606033239
| 2,000
| 1,048,576
|
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.
|
['A = input()\nB = input()\nC = input()\n\nif A>=B and B>=C:\n print(int(A+B)+int(C))\nelif B>A and A>C:\n print(int(B+A)+int(C))\nelif A>C and C>B:\n print(int(A+C)+int(B))\nelif C>B and B>A:\n print(int(C+B)+int(A))\nelif B>C and B>A:\n print(int(B+C)+int(A))\nelse:\n print(int(C+A)+int(B))', 'A = int(input())\nB = int(input())\nC = int(input())\n\nif A>=B and B>=C:\n print(int(str(A)+str(B))+C)\nelif B>A and A>C:\n print(int(str(B)+str(A))+C)\nelif A>C and C>B:\n print(int(str(A)+str(C))+B)\nelif C>B and B>A:\n print(int(str(C)+str(B))+A)\nelif B>C and B>A:\n print(int(str(B)+str(C))+A)\nelse:\n print(int(str(C)+str(A))+B)', 'n,m,X,Y = map(int,input().split())\nx = list(map(int,input().split()))\ny = list(map(int,input().split()))\n\nprint(["War","No War"][X<min(y) and max(x)<Y and max(x)<min(y)])\n\n', 'abc = list(map(int,input().split()))\nprint(max(abc)*10+sum(abc)-max(abc))']
|
['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']
|
['s298592771', 's407532313', 's945729049', 's481194714']
|
[3064.0, 3064.0, 2940.0, 2940.0]
|
[19.0, 18.0, 25.0, 18.0]
|
[294, 339, 172, 73]
|
p03250
|
u611090896
| 2,000
| 1,048,576
|
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.
|
['a,b,c = sorted(int(input().split()))\nprint(c*10+b+a)', 'a,b,c = sorted(map(int,input().split()))\nd=str(b)+str(c)\nprint(a+int(d))\n', 'a,b,c = sorted(input().split())\nd=b+c\nprint(int(a)+int(d))', 'a,b,c= sorted(map(int,input().split()))\nprint(c*10+b+a)']
|
['Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s577063754', 's654625283', 's885293789', 's262793243']
|
[2940.0, 2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0, 18.0]
|
[52, 73, 58, 55]
|
p03250
|
u611655181
| 2,000
| 1,048,576
|
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.
|
["\nA,B,C=input().split(' ')\n\n\n\nA=int(A)\nB=int(B)\nC=int(C)\nnumberList=[A,B,C]\n\nnumberList.sort(reverse=True)\n\nnumberList[0]*10+numberList[1]+numberList[2]", "\nA,B,C=input().split(' ')\n\n\n\nA=int(A)\nB=int(B)\nC=int(C)\nnumberList=[A,B,C]\n\nnumberList.sort(reverse=True)\n\nsum=0\nsum=numberList[0]*10+numberList[1]+numberList[2]\n\nprint(sum)"]
|
['Wrong Answer', 'Accepted']
|
['s693197417', 's684974734']
|
[2940.0, 3064.0]
|
[17.0, 17.0]
|
[216, 238]
|
p03250
|
u619197965
| 2,000
| 1,048,576
|
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.
|
['a,b,c=[int(i) for i in input().split()]\nnum=[a,b,c]\nnum.sort()\nprint(num[0]+int(str(num[1])+str(num[2])))', 'a,b,c=[int(i) for i in input().split()]\nnum=[a,b,c]\nnum.sort()\nprint(num[0]+int(str(num[2])+str(num[1])))\n']
|
['Wrong Answer', 'Accepted']
|
['s758985489', 's746178268']
|
[2940.0, 2940.0]
|
[18.0, 17.0]
|
[105, 106]
|
p03250
|
u619379081
| 2,000
| 1,048,576
|
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.
|
['def C(x, y):\n z = 1\n for i in range(x, x-y, -1):\n z *= i\n for i in range(y, 1, -1):\n z //= i\n return z\ndef H(x, y):\n return C(x+y-1, y) % 1000000007\nn, m = list(map(int, input().split()))\np = 2\nprime_factorization = []\nwhile p * p <= m:\n count = 0\n while m % p == 0:\n m //= p\n count += 1\n if count > 0:\n prime_factorization.append(count)\n p += 1\nif m > 1:\n prime_factorization.append(1)\nans = 1\nfor r in prime_factorization:\n ans *= H(n, r)\nprint(ans % 1000000007)', 'l = list(map(int, input().split()))\nprint(9*max(l)+sum(l))']
|
['Runtime Error', 'Accepted']
|
['s063176762', 's498289615']
|
[3064.0, 2940.0]
|
[17.0, 18.0]
|
[532, 58]
|
p03250
|
u620846115
| 2,000
| 1,048,576
|
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.
|
['a,b,c=input().split()\nprint(max(a,b,c)*9+a+b+c)', 'a,b,c=map(int,input().split())\nprint(max(a,b,c)+a+b+c)', 'a,b,c=map(int, input().split())\nprint(max(a,b,c)+a+b+c)', 'a,b,c=map(int,input().split())\nprint(max(a,b,c)*9+a+b+c)']
|
['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s428935882', 's600160016', 's853201573', 's781519081']
|
[9016.0, 9092.0, 8892.0, 8980.0]
|
[29.0, 24.0, 28.0, 27.0]
|
[47, 54, 55, 56]
|
p03250
|
u626337957
| 2,000
| 1,048,576
|
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.
|
['A, B, C = input()\nprint(max(int(A+B)+int(C),int(B+A)+int(C),int(A+C)+int(B), int(C+A)+int(B), int(B+C)int(A), int(C+B)+int(A)))', 'nums = list(map(int, input().split()))\nnums.sort(key=lambda x: -x)\nprint(int(str(nums[0]) + str(nums[1])) + nums[2])\n']
|
['Runtime Error', 'Accepted']
|
['s513217603', 's504382839']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[127, 117]
|
p03250
|
u626881915
| 2,000
| 1,048,576
|
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.
|
['a,b,c=map(int,input().split())\nprint(max(a,b,c)*9+sum(a,b,c))', 'a,b,c=map(int,input().split())\nprint(max(a,b,c)*9+sum([a,b,c]))\n']
|
['Runtime Error', 'Accepted']
|
['s010634596', 's736392134']
|
[2940.0, 2940.0]
|
[19.0, 17.0]
|
[61, 64]
|
p03250
|
u630004940
| 2,000
| 1,048,576
|
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.
|
['A,B,C=map(int,input().split())\nlist=［A,B,C］\nM=max(list)\nD=9＊M+A+B+C\nprint(D)', 'A,B,C=map(int,input().split())\nlist=[A,B,C]\nM=max(list)\nN=A+B+C\nD=9*M+N\nprint(D)']
|
['Runtime Error', 'Accepted']
|
['s459885103', 's036979362']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[82, 80]
|
p03250
|
u633105820
| 2,000
| 1,048,576
|
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.
|
["import collections\n\n\ndef run(s, t):\n ss = collections.Counter(s)\n tt = collections.Counter(t)\n if sorted(list(ss.values())) == sorted(list(tt.values())):\n return 'Yes'\n else:\n return 'No'\n\n\ndef main():\n s = input()\n t = input()\n print(run(s, t))\n\n\nif __name__ == '__main__':\n main()\n", "def run(a, b, c):\n s = sorted([a, b, c])\n return 10*s[2]+s[1]+s[0]\n\n\ndef main():\n a, b, c = map(int, input().split())\n print(run(a, b, c))\n\n\nif __name__ == '__main__':\n main()\n"]
|
['Runtime Error', 'Accepted']
|
['s994789314', 's413520685']
|
[3316.0, 2940.0]
|
[20.0, 17.0]
|
[321, 191]
|
p03250
|
u633548583
| 2,000
| 1,048,576
|
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.
|
['a,b,c=map(int,input().split())\nprint(max(int(str(a)+str(b))+c,int(str(a)+str(c))+b,int(str(b)+str(c))+a,int(str(b)+str(a)+c,int(str(c)+str(a)+b,int(str(c)+str(b)+a))\n', 'a,b,c=sorted(list(map(int,input().split())))\nprint(c*10+b+a)']
|
['Runtime Error', 'Accepted']
|
['s835250425', 's914147758']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[166, 60]
|
p03250
|
u635339675
| 2,000
| 1,048,576
|
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.
|
['x=list(map(int,input().split()))\nprint(x)\nx.sort()\nprint(int(str(x[-1])+str(x[1]))+x[0])\n', 'x=list(map(int,input().split()))\n#print(x)\nx.sort()\nprint(int(str(x[-1])+str(x[1]))+x[0])\n']
|
['Wrong Answer', 'Accepted']
|
['s960621423', 's992280485']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[89, 90]
|
p03250
|
u637593381
| 2,000
| 1,048,576
|
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.
|
['l = list(map(int, input().split()))\nl.sort(reverse=True)\nprint(sum(l[0:2]) + l[2])', 'l = list(map(int, input().split()))\nl.sort(reverse=True)\nprint(10 * l[0] + l[1] + l[2])\n']
|
['Wrong Answer', 'Accepted']
|
['s268194988', 's080086279']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[82, 88]
|
p03250
|
u637824361
| 2,000
| 1,048,576
|
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.
|
['a, b, c = map(int, input().split())\n\nif a >= b & a >= c:\n print(10 * a + b + c)\nelif b >= a & b >= c: \n print(10 * b + a + c)\nelse:\n print(10 * c + a + b)\n', 'a, b, c = map(int, input().split())\n\nif a >= b and a >= c:\n print(10 * a + b + c)\nelif b >= a and b >= c:\n print(10 * b + a + c)\nelse:\n print(10 * c + a + b)\n']
|
['Wrong Answer', 'Accepted']
|
['s062548733', 's866423228']
|
[2940.0, 2940.0]
|
[18.0, 18.0]
|
[164, 167]
|
p03250
|
u642528832
| 2,000
| 1,048,576
|
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.
|
['l = list(map(int,input().split()))\nl.sort(reverse = 1)\nprint(l)\nprint(l[0]*10 +l[1] + l[2])', 'l = list(map(int,input().split()))\nl.sort(reverse = 1)\n#print(l)\nprint(l[0]*10 +l[1] + l[2])']
|
['Wrong Answer', 'Accepted']
|
['s799438183', 's788473184']
|
[9080.0, 9096.0]
|
[26.0, 28.0]
|
[91, 92]
|
p03250
|
u651047049
| 2,000
| 1,048,576
|
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.
|
['a,b,c=map(int,input().split)\n\nif a+b>=b+c:\n print(10*a+b+c)\n \nelif a+b<=b+c:\n prnt(a+10*b+c)', 'a,b,c=map(int,input().split())\n\nif a>=b and a>=c:\n print(10*a+b+c)\n \nelif b>=a and b>=c:\n prnt(a+10*b+c)\n \nelif c>=a and c>=b:\n print(a+b+10*c)', 'a,b,c=map(int,input().split())\n\nif a>=b and a>=c:\n print(10*a+b+c)\n \nelif b>=a and b>=c:\n print(a+10*b+c)\n \nelif c>=a and c>=b:\n print(a+b+10*c)']
|
['Runtime Error', 'Runtime Error', 'Accepted']
|
['s229691405', 's921526859', 's375210660']
|
[2940.0, 3060.0, 3060.0]
|
[17.0, 17.0, 17.0]
|
[101, 158, 159]
|
p03250
|
u652656291
| 2,000
| 1,048,576
|
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.
|
['a,b,c = map(int,input().split())\nL = [a,b,c]\nM = L.sorted()\nptint(int(str(M[2])+str(M[1]))+int(M[0]))', 'a,b,c = map(int,input().split())\nL = [a,b,c]\nM = L.sorted()\nprint(int(str(M[2])+str(M[1]))+int(M[0]))', 'a,b,c = (map(int,input().split()))\nL = [a,b,c]\nM = L.sort()\n\nprint(L[-1]*10 + L[0] + L[1])\n']
|
['Runtime Error', 'Runtime Error', 'Accepted']
|
['s183231879', 's998185068', 's140550270']
|
[2940.0, 2940.0, 2940.0]
|
[18.0, 17.0, 17.0]
|
[101, 101, 91]
|
p03250
|
u654949547
| 2,000
| 1,048,576
|
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.
|
['n = list(input().split())\nprint(n)\nlist.sort(n, reverse=True)\nprint(int((n[0]+n[1])) + int(n[2]))', 'n = list(input().split())\nlist.sort(n, reverse=True)\nprint(int((n[0]+n[1])) + int(n[2]))']
|
['Wrong Answer', 'Accepted']
|
['s585179686', 's941315124']
|
[2940.0, 2940.0]
|
[18.0, 17.0]
|
[97, 88]
|
p03250
|
u657913472
| 2,000
| 1,048,576
|
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.
|
['a=map(int,input().split());print(sum(a)+9*max(a))', 'a=list(map(int,input().split()));print(sum(a)+9*max(a))']
|
['Runtime Error', 'Accepted']
|
['s019080385', 's307568069']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[49, 55]
|
p03250
|
u657971041
| 2,000
| 1,048,576
|
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.
|
['a,b,c=sorted(map(int,input.split()))\nprint(c*10 + b + a)', 'a,b,c=sorted(map(int,input().split()))\nprint(c*10 + b + a)']
|
['Runtime Error', 'Accepted']
|
['s085796999', 's054546218']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[56, 58]
|
p03250
|
u663438907
| 2,000
| 1,048,576
|
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.
|
['l = sorted(list(map(int, input().split())))\n\nprint(l[0] * 10 + l[1] + l[2])', 'l = sorted(list(map(int, input().split())), reverse = True)\nprint(l[0] * 10 + l[1] + l[2])']
|
['Wrong Answer', 'Accepted']
|
['s765211936', 's464652153']
|
[2940.0, 2940.0]
|
[17.0, 16.0]
|
[75, 90]
|
p03250
|
u665038048
| 2,000
| 1,048,576
|
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.
|
['A,B,C=[int(i) for i in input().split()]\nlist=[]\nlist.append(A)\nlist.append(B)\nlist.append(C)\nmax=max(list)\nlist.remove(max)\n\nreturn 10*max+sum(list)\n', 'A_list =list( map(int, input().split()))\nA_list.sort()\nprint(A_list[-1]*10+A_list[0]+A_list[1])']
|
['Runtime Error', 'Accepted']
|
['s840296059', 's120732591']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[149, 95]
|
p03250
|
u667084803
| 2,000
| 1,048,576
|
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.
|
['A = list(map(int, input().split()))\nA.sort()\nans(A[0]+A[1]+10*A[2])', 'A = list(map(int, input().split()))\nA.sort()\nprint(A[0]+A[1]+10*A[2])']
|
['Runtime Error', 'Accepted']
|
['s045017365', 's345532606']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[67, 69]
|
p03250
|
u668503853
| 2,000
| 1,048,576
|
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.
|
['a,b,c=map(int(input()))\nprint(max(abc)*10 + a + b + c - max(abc))', 'a,b,c=map(int,input().split())\nprint(max(abc)*10 + a + b + c - max(abc))\n', 'ABC = [int(x) for x in input().split()]\n\nABC.sort()\n\nanswer = ABC[-1]*10 + sum(ABC[:2])\n\nprint(answer)\n']
|
['Runtime Error', 'Runtime Error', 'Accepted']
|
['s321239178', 's368102010', 's317801168']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[65, 73, 344]
|
p03250
|
u669382434
| 2,000
| 1,048,576
|
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.
|
['a,b,c=[int(i) for i in input().split()\nprint(max(a,b,c)*9+a+b+c)', ' a,b,c=[int(i) for i in input().split()]\n print(max(a,b,c)*9+a+b+c)', 'a,b,c=[int(i) for i in input().split()]\nprint(max(a,b,c)*9+a+b+c)']
|
['Runtime Error', 'Runtime Error', 'Accepted']
|
['s867090790', 's997267234', 's853645670']
|
[2940.0, 2940.0, 2940.0]
|
[18.0, 18.0, 18.0]
|
[64, 73, 65]
|
p03250
|
u669812251
| 2,000
| 1,048,576
|
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.
|
['# -*- coding: utf-8 -*-\n\n#110_c\n\nS = input()\nT = input()\n\ncombination = []\nfor i, j in zip(S,T):\n combination.append([i,j])\n\nset_S = []\nset_T = []\n\nfor i,j in list(map(list, set(map(tuple, combination)))):\n set_S.append(i)\n set_T.append(j)\n\nif len(set_S) == len(set(set_S))and len(set_T) == len(set(set_T)):\n print("Yes")\nelse:\n print("No")\n', '# -*- coding: utf-8 -*-\n#110_a\n\nA, B, C = [int(i) for i in input().split()]\n\ndesc = sorted([A,B,C], reverse=True)\nprint(desc[0]*10 + desc[1]+desc[2])\n']
|
['Runtime Error', 'Accepted']
|
['s679278529', 's554220599']
|
[3064.0, 2940.0]
|
[17.0, 17.0]
|
[356, 150]
|
p03250
|
u671211357
| 2,000
| 1,048,576
|
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.
|
['A,B,C=input().split()\nichi=10*A+B+C\ntwo=A+10*B+C\nprint(max(ichi,two))\n', 'A,B,C=input().split()\nichi=eval(AB+C)\ntwo=eval(A+BC)\nprint(max(ichi,two))', 'A,B,C=map(int,input().split())\nichi=10*A+B+C\ntwo=A+10*B+C\nthree=C*10+A+B\nprint(max(ichi,two,three))\n']
|
['Wrong Answer', 'Runtime Error', 'Accepted']
|
['s618066141', 's684751753', 's430653241']
|
[9044.0, 8920.0, 8988.0]
|
[29.0, 27.0, 28.0]
|
[70, 73, 100]
|
p03250
|
u672898046
| 2,000
| 1,048,576
|
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.
|
['l = list(map(int, input().split()))\nl = sorted(l, reverse=True)\nprint(l)\na = []\na.append(l[2])\nc = int(str(l[0]) + str(l[1]))\na.append(c)\nprint(sum(a))', 'l = list(map(int, input().split()))\nl = sorted(l, reverse=True)\na = []\na.append(l[2])\nc = int(str(l[0]) + str(l[1]))\na.append(c)\nprint(sum(a))']
|
['Wrong Answer', 'Accepted']
|
['s466495515', 's915386560']
|
[3060.0, 3060.0]
|
[17.0, 17.0]
|
[151, 142]
|
p03250
|
u674064321
| 2,000
| 1,048,576
|
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.
|
['p = sorted(list(map(int, input().split())), reverse = False)\nprint(p[0] * 10 + p[1] + p[2])', 'p = sorted(list(map(int, input().split())), reverse = True)\nprint(p[0] * p[1] + p[2])', 'p = sorted(list(map(int, input().split())), reverse = True)\nprint(p[0] * 10 + p[1] + p[2])']
|
['Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s624847323', 's722362319', 's159380452']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[91, 85, 90]
|
p03250
|
u685662874
| 2,000
| 1,048,576
|
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.
|
['num=list(map(int,input()))\nnum.sort(reverse=True)\nprint(num[0]*10+num[1]+num[2])', 'num=list(map(int,input().split()))\nnum.sort(reverse=True)\nprint(num[0]*10+num[1]+num[2])']
|
['Runtime Error', 'Accepted']
|
['s809177047', 's595149065']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[80, 88]
|
p03250
|
u688055251
| 2,000
| 1,048,576
|
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.
|
["import sys\n\n\ndef solve(a,b,c):\n g=a+(b*10+c)\n print(g)\n\n\ndef readQuestion():\n line = sys.stdin.readline().rstrip()\n [str_a, str_b, str_c] = line.split(' ')\n return (int(str_a), int(str_b), int(str_c))\n\ndef main():\n a, b, c = readQuestion()\n answer = solve(a, b, c)\n print(answer)\n \nif __name__ == '__main__':\n main()", "import sys\n\n\ndef solve(a,b,c):\n g=a+(b*10+c)\n print(g)\n\n\ndef readQuestion():\n line = sys.stdin.readline().rstrip()\n [str_a, str_b, str_c] = line.split(' ')\n return (int(str_a), int(str_b), int(str_c))\n\ndef main():\n a, b, c = readQuestion()\n answer = solve(a, b, c)\n print(answer)\n \nif __name__ == '__main__':\n main()", 'a,b,c=map(int,input().split())\nl=[a,b,c]\nl.sort()\nt=l[2]*10+l[1]+l[0]\nprint(t)']
|
['Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s166252817', 's860153442', 's266052989']
|
[3064.0, 3060.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[507, 507, 78]
|
p03250
|
u690536347
| 2,000
| 1,048,576
|
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.
|
['from collections import Counter as c\nfrom scipy.misc import comb\nfrom functools import reduce\n\ndef f(n):\n d=c()\n for i in range(2,1+int(n**0.5)):\n while n%i==0:\n d[i]+=1\n n//=i\n if n:d[n]+=1\n return d.values()\n\nn,m=map(int,input().split())\nmod=10**9+7\nprint(reduce(lambda x,y:x*y%mod,map(lambda x:comb(x+n-1,x,exact=True),f(m)))%mod)\n', 'l=sorted(map(int,input().split()))\nprint(l[2]*10+sum(l[:2]))']
|
['Runtime Error', 'Accepted']
|
['s148300262', 's936642520']
|
[19848.0, 2940.0]
|
[303.0, 17.0]
|
[351, 60]
|
p03250
|
u691018832
| 2,000
| 1,048,576
|
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.
|
['a,b,c = map(int, input().split())\n\nif (a>b) and (a>c):\n ans = 10*a+b+c\nelif = (b>a) and (b>c):\n ans = 10*b+a+c\nelse:\n ans = 10*c+a+b\nprint(ans)', 'a, b, c = map(int, input().split())\n\nA = 10*a+b+c\nB = 10*b+a+c\nC = 10*c+a+b\nprint(max(A, B, C))']
|
['Runtime Error', 'Accepted']
|
['s393846292', 's384935979']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[152, 95]
|
p03250
|
u693933222
| 2,000
| 1,048,576
|
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.
|
['LX = list(input().split(" "))\nprint(LX)\nLX.sort(reverse=True)\nprint(LX)\nprint(int(LX[0]+LX[1])+int(LX[2]))', 'LX = list(input().split(" "))sort(reverse=True)\nprint(int(LX[0]+LX[1])+int(LX[2]))', 'LX = list(input().split(" "))\nLX.sort(reverse=True)\nprint(int(LX[0]+LX[1])+int(LX[2]))']
|
['Wrong Answer', 'Runtime Error', 'Accepted']
|
['s201605307', 's853257299', 's164532671']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[106, 82, 86]
|
p03250
|
u695230607
| 2,000
| 1,048,576
|
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.
|
['a = input().split()\na = [int(i) for i in a]\nprint(a)\namax = a[0]\nfor i in range(1,3):\n if a[i] > amax:\n amax = a[i]\n count = i\n else:\n pass\na.pop(count)\nprint(amax*10+a[0]+a[1])', 'a = input().split()\na = [int(i) for i in a]\namax = a[0]\ncount = 0\nfor i in range(1,3):\n if a[i] > amax:\n amax = a[i]\n count = i\n else:\n pass\na.pop(count)\nprint(amax*10+a[0]+a[1])']
|
['Runtime Error', 'Accepted']
|
['s902468285', 's951296666']
|
[3060.0, 3060.0]
|
[17.0, 17.0]
|
[204, 205]
|
p03250
|
u697658632
| 2,000
| 1,048,576
|
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.
|
['a, b, c = map(int, input().split())\nprint(max(a, b, c) * 9 + sum(a, b, c))\n', 'a, b, c = map(int, input().split())\nprint(max(a, b, c) * 9 + a + b + c)\n']
|
['Runtime Error', 'Accepted']
|
['s348388771', 's566315502']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[75, 72]
|
p03250
|
u698416089
| 2,000
| 1,048,576
|
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.
|
['data = input().split()\ndata = data.sort()\nprint(data[2]+data[1])', 'data = input().split()\nprint(data.sort()[2]+data.sort()[1])', 'data = input().split()\nprint(int(sorted(data)[2]) + int(sorted(data)[1]))', 'data = input().split()\nprint(int(sorted(data)[2] + sorted(data)[1]) + int(sorted(data)[0]))']
|
['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted']
|
['s202388023', 's923700500', 's981462436', 's640128926']
|
[2940.0, 2940.0, 2940.0, 2940.0]
|
[17.0, 18.0, 17.0, 17.0]
|
[64, 59, 73, 91]
|
p03250
|
u698501671
| 2,000
| 1,048,576
|
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.
|
['import math\n\nN,X = map(int,input().split())\nx = list(map(int,input().split()))\nif N == 1:\n print(abs(x[0] - X))\nelse:\n xlen = [abs(x[0]-X)]\n for i in range(N-1):\n xlen.append(x[i+1]- x[i])\n ans = xlen[0]\n for i in range(N-2):\n ans = math.gcd(ans,xlen[i+1])\n print(ans)', 'num = list(map(int,input().split()))\nnum.sort()\nans = num[2]*10 + num[1] + num[0]\nprint(ans)']
|
['Runtime Error', 'Accepted']
|
['s680399515', 's246501034']
|
[3064.0, 2940.0]
|
[18.0, 17.0]
|
[300, 92]
|
p03250
|
u706695185
| 2,000
| 1,048,576
|
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.
|
['l = [int(i) for i in input().split()]\nl.sort\nprint(l[0]*10 + l[1] + l[2])\n', 'l = [int(i) for i in input().split()]\n\nl = l.sort\nprint(l[0]*10 + l[1] + l[2])', 'l = [int(i) for i in input().split()]\nl.sort\nprint(l[0]*10 + l[1] + l[2])\n', 'l = [int(i) for i in input().split()]\n\n\nl.sort(reverse=True)\nprint(l[0]*10 + l[1] + l[2])\n']
|
['Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Accepted']
|
['s083570109', 's873336241', 's916575447', 's904421381']
|
[2940.0, 2940.0, 2940.0, 2940.0]
|
[17.0, 18.0, 17.0, 17.0]
|
[74, 116, 74, 156]
|
p03250
|
u710398282
| 2,000
| 1,048,576
|
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.
|
['num = list(map(int, input().split()))\n\nnum.sort()\n\nprint(num)\n\ne = (num[2]*10) + num[1] +num[0] \n\nprint(e)', 'num = list(map(int, input().split()))\n\nnum.sort()\n\ne = (num[2]*10) + num[1] +num[0] \n\nprint(e)']
|
['Wrong Answer', 'Accepted']
|
['s840094929', 's793515222']
|
[9092.0, 8940.0]
|
[30.0, 25.0]
|
[106, 94]
|
p03250
|
u713830790
| 2,000
| 1,048,576
|
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.
|
["if __name__ == '__main__':\n S = list(input())\n T = list(input())\n\n letter = []\n for i in range(len(S)):\n letter.append(T[i]) \n if S[i] == T[i]:\n continue\n else:\n if S[i] in letter:\n break\n else:\n s = S[i]\n for j in range(len(S)):\n if S[j] == s:\n S[j] = T[i]\n elif S[j] == T[i]:\n S[j] = s\n\n if S == T:\n print('Yes')\n else:\n print('No')", "if __name__ == '__main__':\n A, B, C = list(map(int, input().split()))\n if A >= B and A >= C:\n print(10*A+B+C)\n elif B >= A and B>=C:\n print(B*10+A+C)\n else:\n print(C*10+A+B)\n"]
|
['Runtime Error', 'Accepted']
|
['s274840721', 's538383025']
|
[3064.0, 2940.0]
|
[17.0, 17.0]
|
[697, 207]
|
p03250
|
u716649090
| 2,000
| 1,048,576
|
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.
|
['a,b,c=map(int,input().split())\nprint(max(10*a+(b+c),10*b+(a+c),10*c+(a+c))', 'a, b, c = map(int, input().split())\nprint(9 * max(a, b, c) + a + b + c)']
|
['Runtime Error', 'Accepted']
|
['s703347857', 's293678059']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[74, 71]
|
p03250
|
u720124072
| 2,000
| 1,048,576
|
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.
|
['a, b, c = input().split()\nif int(a+b) > int(c):\n print(int(a+b) + int(c))\nelse:\n print(int(a) + int(b+c))', 'a, b, c = map(int, input().split())\nnum_max = max(a, b, c)\nprint(num_max*9 + a + b + c)']
|
['Wrong Answer', 'Accepted']
|
['s621794681', 's879294020']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[107, 87]
|
p03250
|
u723583932
| 2,000
| 1,048,576
|
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.
|
['#abc110 a\nnum=list(map(int,input().split()))\nl=max(num)\ns=min(num)\nm=sum(l)-l-s\nans=int(str(l)+str(m))+s\nprint(ans)\n', '#abc110 a\nnum=list(map(int,input().split()))\nl=max(num)\ns=min(num)\nm=sum(num)-l-s\nans=int(str(l)+str(m))+s\nprint(ans)\n']
|
['Runtime Error', 'Accepted']
|
['s507936644', 's319540571']
|
[2940.0, 2940.0]
|
[17.0, 18.0]
|
[116, 118]
|
p03250
|
u726439578
| 2,000
| 1,048,576
|
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.
|
['a=sort(list(int,input(),split())\nb=str(a[2]+a[1])\nprint(int(b)+a[0])', 'a=list(map(int,input().split()))\na.sort\nprint(a[2]*10+a[1]+a[0])', 'a=list(map(int,input().split()))\na.sort()\nprint(a[2]*10+a[1]+a[0])']
|
['Runtime Error', 'Wrong Answer', 'Accepted']
|
['s405236938', 's685282548', 's915388619']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 18.0, 18.0]
|
[68, 64, 66]
|
p03250
|
u729707098
| 2,000
| 1,048,576
|
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.
|
['a,b,c = (int(i) for i in input().split())\nprint(sum(a,b,c)+max(a,b,c)*9)', 'a,b,c = (int(i) for i in input().split())\nprint(a+b+c+max(a,b,c)*9)']
|
['Runtime Error', 'Accepted']
|
['s112680938', 's385918733']
|
[2940.0, 3316.0]
|
[17.0, 20.0]
|
[72, 67]
|
p03250
|
u731702557
| 2,000
| 1,048,576
|
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.
|
['\nCopy\nS = input()\nT = input()\n \nS_list = []\nT_list = []\nalpha = "abcdefghijklmnopqrstuvwxyz"\n \nfor i in alpha:\n SS = S.count(i)\n TT = T.count(i)\n if SS and TT> 0:\n S_list.append(SS)\n T_list.append(TT)\n \nif sorted(S_list) != sorted(T_list):\n print(\'No\')\nelse:\n print(\'Yes\')', 'a,b,c = map(int, input().split())\n\nmax = max([a, b, c])\nprint(max * 10 + a + b + c - max)']
|
['Runtime Error', 'Accepted']
|
['s652539085', 's244356016']
|
[3060.0, 2940.0]
|
[17.0, 17.0]
|
[301, 89]
|
p03250
|
u735211927
| 2,000
| 1,048,576
|
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.
|
['A, B, C = map(int,input().split())\nif A>B:\n\tprint(A*10 +B+C)\nelif A<B:\n print(A+B*10+C)\nelse:\n\tif A*10+B+C>A+B*10+C:\n print(A*10+B+C)\n else:\n print(A+B*10+C)\n \n', 'C,A, B = sorted(map(int,input().split()))\nif A>B:\n print(A*10 +B+C)\nelif A<B:\n print(A+B*10+C)\nelse:\n print(A+B*10+C)']
|
['Runtime Error', 'Accepted']
|
['s348755662', 's586661040']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[181, 120]
|
p03250
|
u739721456
| 2,000
| 1,048,576
|
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.
|
['n_list=input().split()\nn_list_int=[int(n) for n in n_list]\nn_list_int.sort()\nans=n_list_sort[2]*10+n_list_sort[1]+n_list_sort[0]\nprint[ans]', 'abclist=input().split()\nabclist_int=[int(i) for i in abclist]\nabclist_int.sort()\nans=abclist_int[2]*10+abclist_int[1]+abclist_int[0]\nprint(ans)']
|
['Runtime Error', 'Accepted']
|
['s045101583', 's734267767']
|
[2940.0, 2940.0]
|
[17.0, 18.0]
|
[139, 143]
|
p03250
|
u740047492
| 2,000
| 1,048,576
|
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.
|
['a,b,c=map(int,input().split())\nx=[a,b,c]\nx.sort()\nprint(int((x[2]+x[1])+x[0])', 'a,b,c = [input() for i in range(3)]\na.sort()\nprint(int((a[2]+a[1])+a[0])', 'a = [input() for i in range(3)]\na.sort()\nprint(int((a[2]+a[1])+a[0])', 'a=[int(input()) for i in range(3)]\na.sort()\nprint((a[2]*10)+a[1]+a[0])', 'a,b,c=sorted(map(int,input().split()))\nprint(10*c+b+a)']
|
['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']
|
['s173879248', 's269964460', 's553891420', 's995377061', 's880001008']
|
[2940.0, 2940.0, 2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0, 18.0, 17.0]
|
[77, 72, 68, 70, 54]
|
p03250
|
u740767776
| 2,000
| 1,048,576
|
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.
|
['a= list(input())\na.sort()\nprint(a[2] * 10 + a[1] + a[0])', 'a= list(map(int,input()))\na.sort()\nprint(a[2] * 10 + a[1] + a[0])', 'a= list(map(int,input().split()))\na.sort()\nprint(a[2] * 10 + a[1] + a[0])']
|
['Wrong Answer', 'Runtime Error', 'Accepted']
|
['s334859350', 's803609871', 's154061193']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 18.0, 17.0]
|
[56, 65, 73]
|
p03250
|
u747873993
| 2,000
| 1,048,576
|
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.
|
['number=[int(i) for i in input().split()]\nnumber.sort()\nint(str(number[2])+str(number[1]))+number[0]', 'number=[int(i) for i in input().split()]\nnumber.sort()\nprint(int(str(number[2])+str(number[1]))+number[0])']
|
['Wrong Answer', 'Accepted']
|
['s199298512', 's323866043']
|
[2940.0, 2940.0]
|
[18.0, 18.0]
|
[99, 106]
|
p03250
|
u748135969
| 2,000
| 1,048,576
|
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.
|
['nums = list(map(int, input().split()))\n \nmax_num = max(nums)\nmin_num = max(nums)\ntwo = [max_num, min_num]\nmid_num = list(set(nums) - set(two))\n \ntwo_num = str(max_num) + str(mid_num[0])\nprint(int(two_num) + min_num)', 'nums = list(map(int, input().split()))\n\nmax_num = max(nums)\nmin_num = max(nums)\ntwo = [max_num, min_num]\nmid_num = list(set(nums) - set(two))\n\ntwo_num = str(max_num) + str(mid_num[0])\nprint(two_num + min_num)\n\n', 'nums = list(map(int, input().split()))\n \nmax_num = max(nums)\nmin_num = max(nums)\ntwo = [max_num, min_num]\nmid_num = list(set(nums) - set(two))\n \ntwo_num = str(max_num) + str(mid_num[0])\nprint(int(two_num) +int(min_num))', 'nums = list(map(int, input().split()))\n \nmax_num = max(nums)\nmin_num = max(nums)\ntwo = [max_num, min_num]\nmid_num = list(set(nums) - set(two))\n \ntwo_num = str(max_num) + str(mid_num)\nprint(int(two_num) + min_num)', 'num = list(map(int, input().split()))\nnum.sort(reverse=True)\nprint(num[0] * 10 + num[1] + num[2])']
|
['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']
|
['s370199701', 's465254272', 's486333313', 's862350582', 's593302133']
|
[3060.0, 3060.0, 3060.0, 3060.0, 2940.0]
|
[18.0, 18.0, 18.0, 19.0, 18.0]
|
[216, 211, 220, 213, 97]
|
p03250
|
u748311048
| 2,000
| 1,048,576
|
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.
|
['L=sorted(list(map(int, input().split())))\nprint(L[2]*L[1]+L[0])', 'L=sorted(list(map(int, input().split())))\nprint(L[2]*L[1]-L[0])', 'L=sorted(list(map(int, input().split())))\nprint(int(str(L[2])+str(L[1]))+L[0])']
|
['Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s218212404', 's720856828', 's015313390']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[63, 63, 78]
|
p03250
|
u748562597
| 2,000
| 1,048,576
|
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.
|
['a, b, c = input().split()\n\nm = max(a+10*b+c, a+10*c+b)\nm = max(m, 10*a+b+c)\nprint(m)', 'a, b, c = map(int, input().split())\n\nm = max(a+10*b+c, a+10*c+b)\nm = max(m, 10*a+b+c)\nprint(m)']
|
['Wrong Answer', 'Accepted']
|
['s166424144', 's980092908']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[84, 94]
|
p03250
|
u754511616
| 2,000
| 1,048,576
|
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.
|
['a=list(map(int,input().split))\na=sorted(a)\nd=str(a[2])+str(a[1])\nprint(int(d)+a[0])', 'a=list(map(int,input().split()))\na=sorted(a)\nd=str(a[2])+str(a[1])\nprint(int(d)+a[0])']
|
['Runtime Error', 'Accepted']
|
['s489661795', 's533422314']
|
[8984.0, 9088.0]
|
[24.0, 27.0]
|
[83, 85]
|
p03250
|
u756693875
| 2,000
| 1,048,576
|
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.
|
['a = list(map(int,input().split()))\n\nsorted(a)\n\nprint(10 * a[2] + a[1] + a[0])', 'a = list(map(int,input().split()))\n\nb = sorted(a)\n\nprint(10 * b[2] + b[1] + b[0])']
|
['Wrong Answer', 'Accepted']
|
['s558114420', 's979465425']
|
[2940.0, 2940.0]
|
[18.0, 17.0]
|
[77, 81]
|
p03250
|
u756988562
| 2,000
| 1,048,576
|
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.
|
['S = input()\nT = input()\n# print()\nif len(S)>=10**5+5*10**4:\n print("No")\nelse:\n for i in range(len(S)):\n if S[i] != T[i]:\n S = S.translate(str.maketrans({S[i]:T[i],T[i]:S[i]}))\n # S=S.replace(S[i],T[i])\n if S==T:\n print("Yes")\n else:\n print("No")', 'a,b,c= map(int,input().split())\ntemp= [a,b,c]\ntemp.sort()\ntemp1=int(str(temp[-1])+str(temp[-2]))\nprint(temp1+temp[0])']
|
['Runtime Error', 'Accepted']
|
['s370360257', 's055998848']
|
[3060.0, 2940.0]
|
[17.0, 17.0]
|
[301, 118]
|
p03250
|
u757030836
| 2,000
| 1,048,576
|
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.
|
['a,b,c = sorted(map(int,input().split()))\n\nprint(10*a+b+c)', 'a,b,c = sorted(map(int,input().split()))\n\nprint(10*c+b+a)\n']
|
['Wrong Answer', 'Accepted']
|
['s625487876', 's362461591']
|
[2940.0, 2940.0]
|
[18.0, 17.0]
|
[57, 58]
|
p03250
|
u758475901
| 2,000
| 1,048,576
|
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.
|
['A,B,C = map(int,input().split())\nif B >= A and B >= C:\n print(B*10+C+A)\nif C >= A and C >= B:\n print(C*10+A+B)\nif A >= B and A >= C:\n print(A:10+B+C)', 'L = list(map(int,input().split()))\nL.sort(reverse = True)\nprint(L[0]*10+L[1]+L[2])']
|
['Runtime Error', 'Accepted']
|
['s511965360', 's994486312']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[152, 82]
|
p03250
|
u759412327
| 2,000
| 1,048,576
|
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.
|
['a = list(map(int,input().split()))\nb = sorted(a)\nc = str(b[2])+str(b[1])\nprint(b[0]+c)', 'A,B,C = sorted(map(int,input().split()))\nprint(A+B+10*C)']
|
['Runtime Error', 'Accepted']
|
['s514434095', 's177634172']
|
[2940.0, 9148.0]
|
[17.0, 27.0]
|
[86, 56]
|
p03250
|
u770009793
| 2,000
| 1,048,576
|
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.
|
['n, m, X, Y = map(int, input().split())\nxlist = list(map(int, input().split()))\nylist = list(map(int, input().split()))\nxlist.sort()\nylist.sort()\n\nif xlist[-1] <= ylist[0]:\n for i in range(xlist[-1]+1, ylist[0]+1):\n if X < i and i <= Y:\n print("No War")\n break\nelse:\n print("War")\n', 'nums = list(map(int, input().split()))\nnums.sort()\nnums.reverse()\nnum = nums[0]*10 + nums[1] + nums[2]\nprint(num)\n']
|
['Runtime Error', 'Accepted']
|
['s159803072', 's784341779']
|
[3060.0, 2940.0]
|
[17.0, 17.0]
|
[307, 114]
|
p03250
|
u772180307
| 2,000
| 1,048,576
|
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.
|
['n = list(map(int,input().split()))\nn.reverse()\nprint(n[0] * 10 + n[1] + n[2])', 'n = list(map(int,input().split()))\nn.sort()\nn.reverse()\nprint(n)\nprint(n[0] * 10 + n[1] + n[2])', 'n = list(map(int,input().split()))\nn.sort()\nn.reverse()\nprint(n[0] * 10 + n[1] + n[2])']
|
['Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s328189788', 's625136985', 's823442015']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[77, 95, 86]
|
p03250
|
u777394984
| 2,000
| 1,048,576
|
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.
|
['abc = list(map(int,input().split()))\nabc.sort()\nabc[2]*10+abc[1]+abc[0]\n', 'abc = list(map(int,input().split()))\nabc.sort()\nprint(abc[2]*10+abc[1]+abc[0])']
|
['Wrong Answer', 'Accepted']
|
['s077911364', 's522744256']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[72, 78]
|
p03250
|
u777922433
| 2,000
| 1,048,576
|
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.
|
['a,b,c=[int(i) for i in input().split()]\nif(a>b &&a>c):\n print(10*a+b+c)\nelif(b>a && b>c):\n print(10*b+c+a)\nelse:\n print(a+b+10+c)', 'a=list(map(int,input().split()))\na.sort()\nprint(10*a[-1]+a[0]+a[1])\n']
|
['Runtime Error', 'Accepted']
|
['s053352167', 's079546312']
|
[2940.0, 2940.0]
|
[17.0, 18.0]
|
[133, 68]
|
p03250
|
u778700306
| 2,000
| 1,048,576
|
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.
|
['\nx =map(int,input())\nx = sorted(x, reverse=True)\n\nprint(x[0] * 10 + x[1] + x[2])\n', '\nx =map(int,input().split())\nx = sorted(x, reverse=True)\n\nprint(x[0] * 10 + x[1] + x[2])\n']
|
['Runtime Error', 'Accepted']
|
['s866102235', 's823361921']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[81, 89]
|
p03250
|
u779728630
| 2,000
| 1,048,576
|
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.
|
['A = list(map(int, input().split() ) ).sort()\nprint( A[0] + A[1] + 10*A[2] )\n', 'A = sorted( list(map(int, input().split() ) ) )\nprint( A[0] + A[1] + 10*A[2] )\n']
|
['Runtime Error', 'Accepted']
|
['s960172286', 's380925409']
|
[2940.0, 3064.0]
|
[18.0, 18.0]
|
[76, 79]
|
p03250
|
u783589546
| 2,000
| 1,048,576
|
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.
|
['a,b,c=sorted(map(int,input().split()))\nprint(c*10+b+c)', 'a,b,c=sorted(map(int,input().split()))\nprint(10*c+b+c)', 'A,B,C=sorted(map(int,input().split()))\nprint(10*C+B+A)']
|
['Wrong Answer', 'Wrong Answer', 'Accepted']
|
['s368122404', 's784249166', 's806742277']
|
[2940.0, 2940.0, 2940.0]
|
[17.0, 17.0, 17.0]
|
[54, 54, 54]
|
p03250
|
u785578220
| 2,000
| 1,048,576
|
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.
|
['M = list(map(int, input().split()))\nprint(M[2]*10+M[1]+M[0])', 'M = list(map(int, input().split()))\nM.sort()\nprint(M[2]*10+M[1]+M[0])']
|
['Wrong Answer', 'Accepted']
|
['s248571129', 's332325517']
|
[2940.0, 2940.0]
|
[18.0, 18.0]
|
[60, 69]
|
p03250
|
u796044734
| 2,000
| 1,048,576
|
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.
|
['a,b,c = map(int,input().split())\n\nprint(9*max(a+b+c)+a+b+c)', 'a,b,c = map(int,input().split())\n\nprint(9*max(a,b,c)+a+b+c)\n']
|
['Runtime Error', 'Accepted']
|
['s169428424', 's807185050']
|
[2940.0, 2940.0]
|
[17.0, 17.0]
|
[59, 60]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.