node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
18,
13,
2,
2,
4,
13,
13,
13,
17,
17,
41,
28,
13,
13,
4,
13,
4,
13,
13,
2,
13,
39,
17,
4,
2,
13,
13,
0,
13,
4,
18,
4,
18,
17,
13,
13,
13,
17,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
98,
2
],
[
107,
6
],
[
99,
9
],
[
104,
11
],
[
15,
14
],
[
108,
20
],
[
101,
23
],
[
108,
28
],
[
32,
31
],
[
108,
35
],
[
14,
40
],
[
31,
41
],
[
53,
44
],
[
102,
45
],
[
102,
50
],
[
31,
51
],
[
99,
62
],
[
102,
64
],
[
92,
72
],
[
95,
84
],
[
93,
87
],
[
96,
90
],
[
105,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
]
] | [
"S = input()\nN = len(S)\n\nans = 0\nfor i in range(2 ** (N - 1)):\n ptn = [' '] * (N - 1)\n for j in range(N - 1):\n if (i >> j) & 1:\n ptn[len(ptn) - j - 1] = '+'\n\n formula = ''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace(' ', '')\n ans += eval(formula)\n\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (N - 1)):\n ptn = [' '] * (N - 1)\n for j in range(N - 1):\n if (i >> j) & 1:\n ptn[len(ptn) - j - 1] = '+'\n\n formula = ''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace(' ', '')\n ans += eval(formula)",
"i",
"range(2 ** (N - 1))",
"range",
"2 ** (N - 1)",
"2",
"N - 1",
"N",
"1",
"ptn = [' '] * (N - 1)",
"ptn",
"[' '] * (N - 1)",
"[' ']",
"' '",
"N - 1",
"N",
"1",
"for j in range(N - 1):\n if (i >> j) & 1:\n ptn[len(ptn) - j - 1] = '+'\n\n ",
"j",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if (i >> j) & 1:\n ptn[len(ptn) - j - 1] = '+'\n\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"ptn[len(ptn) - j - 1] = '+'",
"ptn[len(ptn) - j - 1]",
"ptn",
"len(ptn) - j - 1",
"len(ptn) - j",
"len(ptn)",
"len",
"ptn",
"j",
"1",
"'+'",
"n + op for n, op in zip(list(S), ptn + [''])",
"for n, op in zip(list(S), ptn + [''])",
"n",
"op",
"zip(list(S), ptn + [''])",
"zip",
"list(S)",
"list",
"S",
"ptn + ['']",
"ptn",
"['']",
"''",
"for n, op in zip(list(S), ptn + [''])",
"n + op",
"n",
"op",
"formula = ''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace(' ', '')",
"formula",
"''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace(' ', '')",
"''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace",
"''.join([n + op for n, op in zip(list(S), ptn + [''])])",
"''.join",
"''",
"join",
"[n + op for n, op in zip(list(S), ptn + [''])]",
"replace",
"' '",
"''",
"ans += eval(formula)",
"ans",
"eval(formula)",
"eval",
"formula",
"print(ans)",
"print",
"ans",
"formula = ''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace(' ', '')",
"''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace(' ', '')",
"formula",
"ans += eval(formula)",
"eval(formula)",
"ans",
"S = input()",
"input()",
"S",
"ptn = [' '] * (N - 1)",
"[' '] * (N - 1)",
"ptn",
"ans = 0",
"0",
"ans",
"N = len(S)",
"len(S)",
"N"
] | S = input()
N = len(S)
ans = 0
for i in range(2 ** (N - 1)):
ptn = [' '] * (N - 1)
for j in range(N - 1):
if (i >> j) & 1:
ptn[len(ptn) - j - 1] = '+'
formula = ''.join([n + op for n, op in zip(list(S), ptn + [''])]).replace(' ', '')
ans += eval(formula)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
2,
13,
17,
18,
13,
13,
14,
2,
13,
2,
17,
13,
0,
13,
13,
0,
13,
17,
0,
13,
2,
2,
13,
17,
18,
13,
17,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13
] | [
[
91,
2
],
[
79,
13
],
[
92,
16
],
[
97,
18
],
[
22,
21
],
[
80,
27
],
[
85,
30
],
[
34,
33
],
[
80,
37
],
[
82,
40
],
[
86,
43
],
[
77,
43
],
[
83,
43
],
[
89,
43
],
[
92,
46
],
[
33,
47
],
[
21,
50
],
[
33,
53
],
[
94,
55
],
[
83,
56
],
[
86,
56
],
[
77,
56
],
[
89,
56
],
[
76,
58
],
[
88,
61
],
[
77,
64
],
[
83,
64
],
[
86,
64
],
[
89,
64
],
[
92,
67
],
[
100,
70
],
[
89,
71
],
[
77,
71
],
[
83,
71
],
[
86,
71
],
[
101,
74
],
[
95,
74
],
[
98,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
83,
94
],
[
86,
94
],
[
77,
94
],
[
89,
94
],
[
94,
95
],
[
97,
98
],
[
89,
100
],
[
77,
100
],
[
83,
100
],
[
86,
100
],
[
100,
101
]
] | [
"S = list(map(int, list(input())))\nL = len(S)\nans = 0\nfor bit in range(2**(L-1)):\n temp = 0\n\n for i in range(L-1):\n temp =temp*10 + S[i]\n if bit & (1<<i):\n ans += temp\n temp = 0\n temp = temp*10 + S[-1]\n ans += temp\n\n\nprint(ans)\n",
"S = list(map(int, list(input())))",
"S",
"list(map(int, list(input())))",
"list",
"map(int, list(input()))",
"map",
"int",
"list(input())",
"list",
"input()",
"input",
"L = len(S)",
"L",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for bit in range(2**(L-1)):\n temp = 0\n\n for i in range(L-1):\n temp =temp*10 + S[i]\n if bit & (1<<i):\n ans += temp\n temp = 0\n temp = temp*10 + S[-1]\n ans += temp",
"bit",
"range(2**(L-1))",
"range",
"2**(L-1)",
"2",
"L-1",
"L",
"1",
"temp = 0",
"temp",
"0",
"for i in range(L-1):\n temp =temp*10 + S[i]\n if bit & (1<<i):\n ans += temp\n temp = 0\n ",
"i",
"range(L-1)",
"range",
"L-1",
"L",
"1",
"temp =temp*10 + S[i]",
"temp",
"temp*10 + S[i]",
"temp*10",
"temp",
"10",
"S[i]",
"S",
"i",
"if bit & (1<<i):\n ans += temp\n temp = 0\n ",
"bit & (1<<i)",
"bit",
"1<<i",
"1",
"i",
"ans += temp",
"ans",
"temp",
"temp = 0",
"temp",
"0",
"temp = temp*10 + S[-1]",
"temp",
"temp*10 + S[-1]",
"temp*10",
"temp",
"10",
"S[-1]",
"S",
"-1",
"ans += temp",
"ans",
"temp",
"print(ans)",
"print",
"ans",
"temp = 0",
"0",
"temp",
"L = len(S)",
"len(S)",
"L",
"temp =temp*10 + S[i]",
"temp*10 + S[i]",
"temp",
"temp = 0",
"0",
"temp",
"temp = temp*10 + S[-1]",
"temp*10 + S[-1]",
"temp",
"S = list(map(int, list(input())))",
"list(map(int, list(input())))",
"S",
"ans += temp",
"temp",
"ans",
"ans = 0",
"0",
"ans",
"ans += temp",
"temp",
"ans"
] | S = list(map(int, list(input())))
L = len(S)
ans = 0
for bit in range(2**(L-1)):
temp = 0
for i in range(L-1):
temp =temp*10 + S[i]
if bit & (1<<i):
ans += temp
temp = 0
temp = temp*10 + S[-1]
ans += temp
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
2,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
0,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13
] | [
[
64,
2
],
[
67,
6
],
[
65,
10
],
[
70,
13
],
[
68,
16
],
[
61,
18
],
[
22,
21
],
[
71,
24
],
[
55,
26
],
[
65,
33
],
[
73,
35
],
[
21,
40
],
[
76,
44
],
[
58,
47
],
[
77,
50
],
[
74,
50
],
[
56,
50
],
[
59,
53
],
[
62,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
]
] | [
"s = input()\nplus_len = len(s) - 1\nnum_search = 2 ** plus_len\nresult = 0\nfor i in range(num_search):\n x = ''\n for index,value in enumerate(s):\n x += value\n if (i >> index) & 1:\n x += '+'\n \n #print(x)\n #print(eval(x))\n result += eval(x)\nprint(result)",
"s = input()",
"s",
"input()",
"input",
"plus_len = len(s) - 1",
"plus_len",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"num_search = 2 ** plus_len",
"num_search",
"2 ** plus_len",
"2",
"plus_len",
"result = 0",
"result",
"0",
"for i in range(num_search):\n x = ''\n for index,value in enumerate(s):\n x += value\n if (i >> index) & 1:\n x += '+'\n \n #print(x)\n #print(eval(x))\n result += eval(x)",
"i",
"range(num_search)",
"range",
"num_search",
"x = ''",
"x",
"''",
"for index,value in enumerate(s):\n x += value\n if (i >> index) & 1:\n x += '+'\n \n #print(x)\n #print(eval(x))\n ",
"index",
"value",
"enumerate(s)",
"enumerate",
"s",
"x += value",
"x",
"value",
"if (i >> index) & 1:\n x += '+'\n \n #print(x)\n #print(eval(x))\n ",
"(i >> index) & 1",
"i >> index",
"i",
"index",
"1",
"x += '+'",
"x",
"'+'",
"result += eval(x)",
"result",
"eval(x)",
"eval",
"x",
"print(result)",
"print",
"result",
"x = ''",
"''",
"x",
"result += eval(x)",
"eval(x)",
"result",
"result = 0",
"0",
"result",
"s = input()",
"input()",
"s",
"plus_len = len(s) - 1",
"len(s) - 1",
"plus_len",
"num_search = 2 ** plus_len",
"2 ** plus_len",
"num_search",
"x += value",
"value",
"x",
"x += '+'",
"'+'",
"x"
] | s = input()
plus_len = len(s) - 1
num_search = 2 ** plus_len
result = 0
for i in range(num_search):
x = ''
for index,value in enumerate(s):
x += value
if (i >> index) & 1:
x += '+'
#print(x)
#print(eval(x))
result += eval(x)
print(result) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
13,
4,
18,
13,
13,
18,
13,
13,
41,
28,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
2,
13,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
17,
4,
18,
13,
13,
13,
4,
18,
13,
13,
2,
18,
13,
17,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13
] | [
[
113,
2
],
[
101,
6
],
[
114,
9
],
[
116,
11
],
[
15,
14
],
[
102,
17
],
[
117,
20
],
[
114,
23
],
[
14,
24
],
[
28,
27
],
[
117,
27
],
[
27,
32
],
[
119,
34
],
[
104,
37
],
[
41,
40
],
[
102,
46
],
[
125,
49
],
[
53,
52
],
[
102,
56
],
[
122,
59
],
[
126,
61
],
[
111,
61
],
[
108,
61
],
[
120,
63
],
[
102,
66
],
[
52,
67
],
[
40,
72
],
[
52,
73
],
[
107,
76
],
[
110,
79
],
[
105,
83
],
[
123,
85
],
[
105,
88
],
[
120,
92
],
[
111,
94
],
[
108,
94
],
[
126,
94
],
[
105,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
]
] | [
"s=input()\nls=len(s)\n\nsl=[]\nfor i in range(ls):\n sl.append(s[i])\nnl=[int(j) for j in sl]\n\n#\"+\"ใๅ
ฅใใใ็ฎๆใฏls-1็ฎๆใใ\nsumn=[]\n#i=0~3\n#i=0x00,0x01,0x10,0x11\nfor i in range(2**(ls-1)):\n #j=0~1\n mul=1\n for j in range(ls-1):\n number=mul*nl[ls-j-1]\n if ((i>>j)&1):\n mul=1\n else:\n mul*=10\n sumn.append(number)\n sumn.append(nl[0]*mul)\nprint(sum(sumn))",
"s=input()",
"s",
"input()",
"input",
"ls=len(s)",
"ls",
"len(s)",
"len",
"s",
"sl=[]",
"sl",
"[]",
"for i in range(ls):\n sl.append(s[i])",
"i",
"range(ls)",
"range",
"ls",
"sl.append(s[i])",
"sl.append",
"sl",
"append",
"s[i]",
"s",
"i",
"int(j) for j in sl",
"for j in sl",
"j",
"sl",
"for j in sl",
"int(j)",
"int",
"j",
"nl=[int(j) for j in sl]",
"nl",
"[int(j) for j in sl]",
"sumn=[]",
"sumn",
"[]",
"for i in range(2**(ls-1)):\n #j=0~1\n mul=1\n for j in range(ls-1):\n number=mul*nl[ls-j-1]\n if ((i>>j)&1):\n mul=1\n else:\n mul*=10\n sumn.append(number)\n sumn.append(nl[0]*mul)",
"i",
"range(2**(ls-1))",
"range",
"2**(ls-1)",
"2",
"ls-1",
"ls",
"1",
"mul=1",
"mul",
"1",
"for j in range(ls-1):\n number=mul*nl[ls-j-1]\n if ((i>>j)&1):\n mul=1\n else:\n mul*=10\n sumn.append(number)\n ",
"j",
"range(ls-1)",
"range",
"ls-1",
"ls",
"1",
"number=mul*nl[ls-j-1]",
"number",
"mul*nl[ls-j-1]",
"mul",
"nl[ls-j-1]",
"nl",
"ls-j-1",
"ls-j",
"ls",
"j",
"1",
"if ((i>>j)&1):\n mul=1\n else:\n mul*=10\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"mul=1",
"mul",
"1",
"mul*=10",
"mul",
"10",
"sumn.append(number)",
"sumn.append",
"sumn",
"append",
"number",
"sumn.append(nl[0]*mul)",
"sumn.append",
"sumn",
"append",
"nl[0]*mul",
"nl[0]",
"nl",
"0",
"mul",
"print(sum(sumn))",
"print",
"sum(sumn)",
"sum",
"sumn",
"ls=len(s)",
"len(s)",
"ls",
"sumn=[]",
"[]",
"sumn",
"mul=1",
"1",
"mul",
"mul*=10",
"10",
"mul",
"s=input()",
"input()",
"s",
"sl=[]",
"[]",
"sl",
"nl=[int(j) for j in sl]",
"[int(j) for j in sl]",
"nl",
"number=mul*nl[ls-j-1]",
"mul*nl[ls-j-1]",
"number",
"mul=1",
"1",
"mul"
] | s=input()
ls=len(s)
sl=[]
for i in range(ls):
sl.append(s[i])
nl=[int(j) for j in sl]
#"+"ใๅ
ฅใใใ็ฎๆใฏls-1็ฎๆใใ
sumn=[]
#i=0~3
#i=0x00,0x01,0x10,0x11
for i in range(2**(ls-1)):
#j=0~1
mul=1
for j in range(ls-1):
number=mul*nl[ls-j-1]
if ((i>>j)&1):
mul=1
else:
mul*=10
sumn.append(number)
sumn.append(nl[0]*mul)
print(sum(sumn))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
39,
4,
18,
13,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
2,
17,
13,
4,
18,
13,
13,
17,
4,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13
] | [
[
80,
2
],
[
77,
8
],
[
81,
11
],
[
74,
13
],
[
17,
16
],
[
78,
22
],
[
83,
25
],
[
84,
29
],
[
81,
32
],
[
36,
35
],
[
78,
39
],
[
16,
43
],
[
35,
46
],
[
84,
49
],
[
84,
54
],
[
81,
57
],
[
35,
59
],
[
86,
62
],
[
84,
69
],
[
87,
72
],
[
75,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] | [
"# C - ใใใใใฎๆฐๅผ\ns = list(input())\nn = len(s)\na = 0\nfor i in range(2 ** (n-1)):\n l = []\n l.append(s[0])\n for j in range(n-1):\n if (i & 1 << j):\n l.append('+')\n l.append(s[j+1])\n a += eval(''.join(l))\n\nprint(a)\n",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"a = 0",
"a",
"0",
"for i in range(2 ** (n-1)):\n l = []\n l.append(s[0])\n for j in range(n-1):\n if (i & 1 << j):\n l.append('+')\n l.append(s[j+1])\n a += eval(''.join(l))",
"i",
"range(2 ** (n-1))",
"range",
"2 ** (n-1)",
"2",
"n-1",
"n",
"1",
"l = []",
"l",
"[]",
"l.append(s[0])",
"l.append",
"l",
"append",
"s[0]",
"s",
"0",
"for j in range(n-1):\n if (i & 1 << j):\n l.append('+')\n l.append(s[j+1])\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i & 1 << j):\n l.append('+')\n ",
"i & 1 << j",
"i",
"1 << j",
"1",
"j",
"l.append('+')",
"l.append",
"l",
"append",
"'+'",
"l.append(s[j+1])",
"l.append",
"l",
"append",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"a += eval(''.join(l))",
"a",
"eval(''.join(l))",
"eval",
"''.join(l)",
"''.join",
"''",
"join",
"l",
"print(a)",
"print",
"a",
"a = 0",
"0",
"a",
"n = len(s)",
"len(s)",
"n",
"s = list(input())",
"list(input())",
"s",
"l = []",
"[]",
"l",
"a += eval(''.join(l))",
"eval(''.join(l))",
"a"
] | # C - ใใใใใฎๆฐๅผ
s = list(input())
n = len(s)
a = 0
for i in range(2 ** (n-1)):
l = []
l.append(s[0])
for j in range(n-1):
if (i & 1 << j):
l.append('+')
l.append(s[j+1])
a += eval(''.join(l))
print(a)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
4,
13,
18,
13,
17,
0,
13,
13,
28,
13,
4,
13,
13,
14,
40,
2,
13,
17,
17,
0,
13,
13,
0,
13,
4,
13,
18,
13,
2,
13,
17,
0,
13,
2,
2,
13,
17,
4,
13,
18,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13
] | [
[
82,
2
],
[
85,
8
],
[
83,
12
],
[
106,
15
],
[
19,
18
],
[
86,
23
],
[
100,
25
],
[
83,
29
],
[
109,
32
],
[
18,
33
],
[
36,
35
],
[
86,
38
],
[
110,
42
],
[
92,
42
],
[
103,
46
],
[
101,
47
],
[
89,
47
],
[
95,
47
],
[
94,
49
],
[
83,
53
],
[
35,
55
],
[
88,
58
],
[
101,
61
],
[
89,
61
],
[
95,
61
],
[
83,
66
],
[
35,
68
],
[
91,
71
],
[
110,
73
],
[
92,
73
],
[
97,
76
],
[
89,
77
],
[
95,
77
],
[
101,
77
],
[
98,
80
],
[
104,
80
],
[
107,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
89,
97
],
[
95,
97
],
[
101,
97
],
[
97,
98
],
[
100,
101
],
[
101,
103
],
[
89,
103
],
[
95,
103
],
[
103,
104
],
[
106,
107
],
[
18,
109
],
[
109,
110
]
] | [
"s = list(input())\nn = len(s) - 1 \np = 0\nfor i in range(2**n):\n m = int(s[0])\n x = i\n for j in range(n):\n if x % 2 != 0:\n p += m\n m = int(s[j+1])\n else:\n m = m * 10 + int(s[j+1])\n x = x // 2\n p += m\nprint(p) ",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"p = 0",
"p",
"0",
"for i in range(2**n):\n m = int(s[0])\n x = i\n for j in range(n):\n if x % 2 != 0:\n p += m\n m = int(s[j+1])\n else:\n m = m * 10 + int(s[j+1])\n x = x // 2\n p += m",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"m = int(s[0])",
"m",
"int(s[0])",
"int",
"s[0]",
"s",
"0",
"x = i",
"x",
"i",
"for j in range(n):\n if x % 2 != 0:\n p += m\n m = int(s[j+1])\n else:\n m = m * 10 + int(s[j+1])\n x = x // 2\n ",
"j",
"range(n)",
"range",
"n",
"if x % 2 != 0:\n p += m\n m = int(s[j+1])\n else:\n m = m * 10 + int(s[j+1])\n ",
"x % 2 != 0",
"x % 2",
"x",
"2",
"0",
"p += m",
"p",
"m",
"m = int(s[j+1])",
"m",
"int(s[j+1])",
"int",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"m = m * 10 + int(s[j+1])",
"m",
"m * 10 + int(s[j+1])",
"m * 10",
"m",
"10",
"int(s[j+1])",
"int",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"x = x // 2",
"x",
"x // 2",
"x",
"2",
"p += m",
"p",
"m",
"print(p)",
"print",
"p",
"s = list(input())",
"list(input())",
"s",
"n = len(s) - 1",
"len(s) - 1",
"n",
"m = m * 10 + int(s[j+1])",
"m * 10 + int(s[j+1])",
"m",
"x = x // 2",
"x // 2",
"x",
"m = int(s[j+1])",
"int(s[j+1])",
"m",
"p += m",
"m",
"p",
"m = int(s[0])",
"int(s[0])",
"m",
"p += m",
"m",
"p",
"p = 0",
"0",
"p",
"x = i",
"i",
"x"
] | s = list(input())
n = len(s) - 1
p = 0
for i in range(2**n):
m = int(s[0])
x = i
for j in range(n):
if x % 2 != 0:
p += m
m = int(s[j+1])
else:
m = m * 10 + int(s[j+1])
x = x // 2
p += m
print(p) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13
] | [
[
70,
2
],
[
64,
6
],
[
71,
10
],
[
82,
13
],
[
17,
16
],
[
65,
21
],
[
76,
23
],
[
71,
25
],
[
29,
28
],
[
65,
31
],
[
16,
34
],
[
28,
37
],
[
79,
39
],
[
67,
42
],
[
71,
44
],
[
28,
46
],
[
73,
49
],
[
68,
57
],
[
80,
57
],
[
77,
57
],
[
74,
62
],
[
83,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
]
] | [
"S = input()\ns = len(S)-1\nans=0\nfor bit in range(1 << s):\n a = S[0]\n for i in range(s):\n if bit & (1<<i):\n a += \"+\"\n a += S[i+1]\n ans += sum(map(int,a.split(\"+\")))\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"s = len(S)-1",
"s",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"ans=0",
"ans",
"0",
"for bit in range(1 << s):\n a = S[0]\n for i in range(s):\n if bit & (1<<i):\n a += \"+\"\n a += S[i+1]\n ans += sum(map(int,a.split(\"+\")))",
"bit",
"range(1 << s)",
"range",
"1 << s",
"1",
"s",
"a = S[0]",
"a",
"S[0]",
"S",
"0",
"for i in range(s):\n if bit & (1<<i):\n a += \"+\"\n a += S[i+1]\n ",
"i",
"range(s)",
"range",
"s",
"if bit & (1<<i):\n a += \"+\"\n ",
"bit & (1<<i)",
"bit",
"1<<i",
"1",
"i",
"a += \"+\"",
"a",
"\"+\"",
"a += S[i+1]",
"a",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"ans += sum(map(int,a.split(\"+\")))",
"ans",
"sum(map(int,a.split(\"+\")))",
"sum",
"map(int,a.split(\"+\"))",
"map",
"int",
"a.split(\"+\")",
"a.split",
"a",
"split",
"\"+\"",
"print(ans)",
"print",
"ans",
"s = len(S)-1",
"len(S)-1",
"s",
"a += S[i+1]",
"S[i+1]",
"a",
"S = input()",
"input()",
"S",
"ans += sum(map(int,a.split(\"+\")))",
"sum(map(int,a.split(\"+\")))",
"ans",
"a = S[0]",
"S[0]",
"a",
"a += \"+\"",
"\"+\"",
"a",
"ans=0",
"0",
"ans"
] | S = input()
s = len(S)-1
ans=0
for bit in range(1 << s):
a = S[0]
for i in range(s):
if bit & (1<<i):
a += "+"
a += S[i+1]
ans += sum(map(int,a.split("+")))
print(ans)
|
[
7,
15,
13,
13,
13,
13,
13,
13,
15,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
39,
17,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
18,
13,
39,
17,
14,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
22,
21
],
[
100,
23
],
[
26,
25
],
[
21,
28
],
[
31,
30
],
[
40,
39
],
[
25,
41
],
[
45,
44
],
[
48,
47
],
[
30,
47
],
[
51,
50
],
[
21,
52
],
[
56,
55
],
[
47,
62
],
[
21,
64
],
[
73,
72
],
[
50,
75
],
[
80,
75
],
[
77,
75
],
[
78,
77
],
[
81,
80
],
[
84,
83
],
[
80,
86
],
[
77,
86
],
[
50,
86
],
[
89,
88
],
[
83,
89
],
[
72,
89
],
[
55,
89
],
[
88,
92
],
[
44,
92
],
[
103,
94
]
] | [
"import bisect,collections,copy,itertools,math,string\nimport sys\ndef I(): return int(sys.stdin.readline().rstrip())\ndef LI(): return list(map(int,sys.stdin.readline().rstrip().split()))\ndef S(): return sys.stdin.readline().rstrip()\ndef LS(): return list(sys.stdin.readline().rstrip().split())\ndef main():\n s = S()\n lenth = len(s)\n itr = itertools.product([0,1],repeat=lenth-1)\n ans = 0\n\n for i in itr:\n tmp = s[0]\n cnt = 0\n for plus,char in zip(i, s[1:]):\n if plus == 1:\n cnt += int(tmp)\n tmp = char\n else:\n tmp += char\n cnt += int(tmp)\n ans += cnt\n\n print(ans) \n \nmain() ",
"import bisect,collections,copy,itertools,math,string",
"bisect",
"collections",
"copy",
"itertools",
"math",
"string",
"import sys",
"sys",
"def I(): return int(sys.stdin.readline().rstrip())",
"I",
"def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))",
"LI",
"def S(): return sys.stdin.readline().rstrip()",
"S",
"def LS(): return list(sys.stdin.readline().rstrip().split())",
"LS",
"def main():\n s = S()\n lenth = len(s)\n itr = itertools.product([0,1],repeat=lenth-1)\n ans = 0\n\n for i in itr:\n tmp = s[0]\n cnt = 0\n for plus,char in zip(i, s[1:]):\n if plus == 1:\n cnt += int(tmp)\n tmp = char\n else:\n tmp += char\n cnt += int(tmp)\n ans += cnt\n\n print(ans) \n ",
"main",
"s = S()",
"s",
"S()",
"S",
"lenth = len(s)",
"lenth",
"len(s)",
"len",
"s",
"itr = itertools.product([0,1],repeat=lenth-1)",
"itr",
"itertools.product([0,1],repeat=lenth-1)",
"itertools.product",
"itertools",
"product",
"[0,1]",
"0",
"1",
"repeat=lenth-1",
"repeat",
"lenth-1",
"lenth",
"1",
"ans = 0",
"ans",
"0",
"for i in itr:\n tmp = s[0]\n cnt = 0\n for plus,char in zip(i, s[1:]):\n if plus == 1:\n cnt += int(tmp)\n tmp = char\n else:\n tmp += char\n cnt += int(tmp)\n ans += cnt\n\n ",
"i",
"itr",
"tmp = s[0]",
"tmp",
"s[0]",
"s",
"0",
"cnt = 0",
"cnt",
"0",
"for plus,char in zip(i, s[1:]):\n if plus == 1:\n cnt += int(tmp)\n tmp = char\n else:\n tmp += char\n ",
"plus",
"char",
"zip(i, s[1:])",
"zip",
"i",
"s[1:]",
"s",
"1:",
"1",
"if plus == 1:\n cnt += int(tmp)\n tmp = char\n else:\n tmp += char\n ",
"plus == 1",
"plus",
"1",
"cnt += int(tmp)",
"cnt",
"int(tmp)",
"int",
"tmp",
"tmp = char",
"tmp",
"char",
"tmp += char",
"tmp",
"char",
"cnt += int(tmp)",
"cnt",
"int(tmp)",
"int",
"tmp",
"ans += cnt",
"ans",
"cnt",
"print(ans)",
"print",
"ans",
"main()",
"main",
"def LS(): return list(sys.stdin.readline().rstrip().split())",
"def LS(): return list(sys.stdin.readline().rstrip().split())",
"LS",
"def S(): return sys.stdin.readline().rstrip()",
"def S(): return sys.stdin.readline().rstrip()",
"S",
"def main():\n s = S()\n lenth = len(s)\n itr = itertools.product([0,1],repeat=lenth-1)\n ans = 0\n\n for i in itr:\n tmp = s[0]\n cnt = 0\n for plus,char in zip(i, s[1:]):\n if plus == 1:\n cnt += int(tmp)\n tmp = char\n else:\n tmp += char\n cnt += int(tmp)\n ans += cnt\n\n print(ans) \n ",
"def main():\n s = S()\n lenth = len(s)\n itr = itertools.product([0,1],repeat=lenth-1)\n ans = 0\n\n for i in itr:\n tmp = s[0]\n cnt = 0\n for plus,char in zip(i, s[1:]):\n if plus == 1:\n cnt += int(tmp)\n tmp = char\n else:\n tmp += char\n cnt += int(tmp)\n ans += cnt\n\n print(ans) \n ",
"main",
"def I(): return int(sys.stdin.readline().rstrip())",
"def I(): return int(sys.stdin.readline().rstrip())",
"I",
"def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))",
"def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))",
"LI"
] | import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
s = S()
lenth = len(s)
itr = itertools.product([0,1],repeat=lenth-1)
ans = 0
for i in itr:
tmp = s[0]
cnt = 0
for plus,char in zip(i, s[1:]):
if plus == 1:
cnt += int(tmp)
tmp = char
else:
tmp += char
cnt += int(tmp)
ans += cnt
print(ans)
main()
|
[
7,
0,
13,
4,
13,
41,
28,
13,
13,
4,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
2,
17,
13,
14,
2,
13,
13,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13
] | [
[
73,
2
],
[
8,
7
],
[
74,
7
],
[
7,
10
],
[
76,
12
],
[
91,
15
],
[
19,
18
],
[
74,
26
],
[
82,
29
],
[
77,
31
],
[
35,
34
],
[
74,
40
],
[
88,
43
],
[
34,
46
],
[
18,
49
],
[
89,
50
],
[
85,
52
],
[
70,
55
],
[
77,
57
],
[
34,
59
],
[
79,
62
],
[
71,
65
],
[
86,
65
],
[
83,
65
],
[
80,
68
],
[
92,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] | [
"s = input()\nsa = [i for i in s]\nr = 0\nfor i in range(2**(len(s)-1)): # ็ถๆ
ๆฐ\n si = sa[0]\n for j in range(len(s) - 1):\n t = 2 ** j # 2^jใชใฎใงๅธธใซ2ใฎๅๆฐใ\n if i & t: # ใฉใใฎใใใใ1ใๅคๅฎใงใใ 2้ฒๆฐใฎใใใๅคๅฎใ10้ฒๆฐใฎใพใพใใฃใฆใใคใกใผใธ\n si += '+' # 1ใชใ+ใๆฟๅ
ฅ\n si += sa[j+1]\n r += eval(si) # evalใฏๆใฎๅฎ่กใชใฎใงๆๅญๅใ้ฝๅใใๆฐๅญใซ่งฃ้ใใฆใใใ\n\nprint(r)",
"s = input()",
"s",
"input()",
"input",
"i for i in s",
"for i in s",
"i",
"s",
"for i in s",
"i",
"sa = [i for i in s]",
"sa",
"[i for i in s]",
"r = 0",
"r",
"0",
"for i in range(2**(len(s)-1)): # ็ถๆ
ๆฐ\n si = sa[0]\n for j in range(len(s) - 1):\n t = 2 ** j # 2^jใชใฎใงๅธธใซ2ใฎๅๆฐใ\n if i & t: # ใฉใใฎใใใใ1ใๅคๅฎใงใใ 2้ฒๆฐใฎใใใๅคๅฎใ10้ฒๆฐใฎใพใพใใฃใฆใใคใกใผใธ\n si += '+' # 1ใชใ+ใๆฟๅ
ฅ\n si += sa[j+1]\n r += eval(si) # evalใฏๆใฎๅฎ่กใชใฎใงๆๅญๅใ้ฝๅใใๆฐๅญใซ่งฃ้ใใฆใใใ",
"i",
"range(2**(len(s)-1))",
"range",
"2**(len(s)-1)",
"2",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"si = sa[0]",
"si",
"sa[0]",
"sa",
"0",
"for j in range(len(s) - 1):\n t = 2 ** j # 2^jใชใฎใงๅธธใซ2ใฎๅๆฐใ\n if i & t: # ใฉใใฎใใใใ1ใๅคๅฎใงใใ 2้ฒๆฐใฎใใใๅคๅฎใ10้ฒๆฐใฎใพใพใใฃใฆใใคใกใผใธ\n si += '+' # 1ใชใ+ใๆฟๅ
ฅ\n si += sa[j+1]\n ",
"j",
"range(len(s) - 1)",
"range",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"t = 2 ** j",
"t",
"2 ** j",
"2",
"j",
"if i & t: # ใฉใใฎใใใใ1ใๅคๅฎใงใใ 2้ฒๆฐใฎใใใๅคๅฎใ10้ฒๆฐใฎใพใพใใฃใฆใใคใกใผใธ\n si += '+' # 1ใชใ+ใๆฟๅ
ฅ\n ",
"i & t",
"i",
"t",
"si += '+'",
"si",
"'+'",
"si += sa[j+1]",
"si",
"sa[j+1]",
"sa",
"j+1",
"j",
"1",
"r += eval(si)",
"r",
"eval(si)",
"eval",
"si",
"print(r)",
"print",
"r",
"si += sa[j+1]",
"sa[j+1]",
"si",
"s = input()",
"input()",
"s",
"sa = [i for i in s]",
"[i for i in s]",
"sa",
"r += eval(si)",
"eval(si)",
"r",
"si = sa[0]",
"sa[0]",
"si",
"si += '+'",
"'+'",
"si",
"t = 2 ** j",
"2 ** j",
"t",
"r = 0",
"0",
"r"
] | s = input()
sa = [i for i in s]
r = 0
for i in range(2**(len(s)-1)): # ็ถๆ
ๆฐ
si = sa[0]
for j in range(len(s) - 1):
t = 2 ** j # 2^jใชใฎใงๅธธใซ2ใฎๅๆฐใ
if i & t: # ใฉใใฎใใใใ1ใๅคๅฎใงใใ 2้ฒๆฐใฎใใใๅคๅฎใ10้ฒๆฐใฎใพใพใใฃใฆใใคใกใผใธ
si += '+' # 1ใชใ+ใๆฟๅ
ฅ
si += sa[j+1]
r += eval(si) # evalใฏๆใฎๅฎ่กใชใฎใงๆๅญๅใ้ฝๅใใๆฐๅญใซ่งฃ้ใใฆใใใ
print(r)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
17,
13,
0,
13,
39,
28,
13,
4,
13,
13,
4,
18,
13,
13,
18,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
17,
4,
18,
13,
13,
18,
13,
17,
4,
18,
13,
13,
17,
0,
13,
17,
0,
13,
39,
14,
2,
17,
13,
28,
13,
13,
14,
40,
13,
17,
0,
13,
13,
4,
18,
13,
13,
4,
13,
13,
0,
13,
17,
4,
18,
13,
13,
4,
13,
13,
4,
13,
4,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13
] | [
[
111,
2
],
[
123,
8
],
[
112,
12
],
[
114,
15
],
[
19,
18
],
[
124,
23
],
[
117,
25
],
[
29,
28
],
[
124,
31
],
[
118,
34
],
[
112,
37
],
[
28,
38
],
[
18,
42
],
[
28,
43
],
[
118,
47
],
[
118,
52
],
[
112,
55
],
[
118,
59
],
[
105,
63
],
[
108,
66
],
[
118,
71
],
[
74,
73
],
[
118,
73
],
[
73,
77
],
[
120,
80
],
[
73,
81
],
[
109,
84
],
[
106,
88
],
[
127,
88
],
[
121,
88
],
[
126,
90
],
[
115,
94
],
[
109,
98
],
[
115,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
73,
120
],
[
120,
121
],
[
123,
124
],
[
126,
127
]
] | [
"# -*- coding: utf-8 -*-\ns = list(input())\nn = len(s)-1\ntrueans = []\nfor i in range(2**n):\n bag = []\n for j in range(n):\n bag.append(s[j])\n if (i>>j) & 1:\n bag.append(\"+\")\n bag.append(s[-1])\n bag.append(\"+\")\n kai = \"\"\n ans = []\n if \"+\" in bag:\n for j in bag:\n if j != \"+\":\n kai += j\n else:\n ans.append(int(kai))\n kai = \"\"\n trueans.append(sum(ans))\nprint(sum(trueans))",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"n = len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"trueans = []",
"trueans",
"[]",
"for i in range(2**n):\n bag = []\n for j in range(n):\n bag.append(s[j])\n if (i>>j) & 1:\n bag.append(\"+\")\n bag.append(s[-1])\n bag.append(\"+\")\n kai = \"\"\n ans = []\n if \"+\" in bag:\n for j in bag:\n if j != \"+\":\n kai += j\n else:\n ans.append(int(kai))\n kai = \"\"\n trueans.append(sum(ans))",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"bag = []",
"bag",
"[]",
"for j in range(n):\n bag.append(s[j])\n if (i>>j) & 1:\n bag.append(\"+\")\n ",
"j",
"range(n)",
"range",
"n",
"bag.append(s[j])",
"bag.append",
"bag",
"append",
"s[j]",
"s",
"j",
"if (i>>j) & 1:\n bag.append(\"+\")\n ",
"(i>>j) & 1",
"i>>j",
"i",
"j",
"1",
"bag.append(\"+\")",
"bag.append",
"bag",
"append",
"\"+\"",
"bag.append(s[-1])",
"bag.append",
"bag",
"append",
"s[-1]",
"s",
"-1",
"bag.append(\"+\")",
"bag.append",
"bag",
"append",
"\"+\"",
"kai = \"\"",
"kai",
"\"\"",
"ans = []",
"ans",
"[]",
"if \"+\" in bag:\n for j in bag:\n if j != \"+\":\n kai += j\n else:\n ans.append(int(kai))\n kai = \"\"\n ",
"\"+\" in bag",
"\"+\"",
"bag",
"for j in bag:\n if j != \"+\":\n kai += j\n else:\n ans.append(int(kai))\n kai = \"\"\n ",
"j",
"bag",
"if j != \"+\":\n kai += j\n else:\n ans.append(int(kai))\n kai = \"\"\n ",
"j != \"+\"",
"j",
"\"+\"",
"kai += j",
"kai",
"j",
"ans.append(int(kai))",
"ans.append",
"ans",
"append",
"int(kai)",
"int",
"kai",
"kai = \"\"",
"kai",
"\"\"",
"trueans.append(sum(ans))",
"trueans.append",
"trueans",
"append",
"sum(ans)",
"sum",
"ans",
"print(sum(trueans))",
"print",
"sum(trueans)",
"sum",
"trueans",
"kai = \"\"",
"\"\"",
"kai",
"ans = []",
"[]",
"ans",
"s = list(input())",
"list(input())",
"s",
"trueans = []",
"[]",
"trueans",
"bag = []",
"[]",
"bag",
"kai += j",
"j",
"kai",
"n = len(s)-1",
"len(s)-1",
"n",
"kai = \"\"",
"\"\"",
"kai"
] | # -*- coding: utf-8 -*-
s = list(input())
n = len(s)-1
trueans = []
for i in range(2**n):
bag = []
for j in range(n):
bag.append(s[j])
if (i>>j) & 1:
bag.append("+")
bag.append(s[-1])
bag.append("+")
kai = ""
ans = []
if "+" in bag:
for j in bag:
if j != "+":
kai += j
else:
ans.append(int(kai))
kai = ""
trueans.append(sum(ans))
print(sum(trueans)) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
12,
13,
0,
13,
4,
13,
18,
13,
13,
14,
2,
13,
2,
13,
17,
0,
13,
2,
13,
13,
29,
13,
0,
13,
2,
4,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
13,
13,
13,
17,
2,
13,
17,
29,
13,
23,
13,
23,
13,
23,
13,
4,
13,
4,
13,
17,
17,
17,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
79,
2
],
[
82,
6
],
[
80,
9
],
[
85,
11
],
[
17,
16
],
[
80,
20
],
[
67,
21
],
[
67,
24
],
[
83,
26
],
[
30,
29
],
[
65,
31
],
[
16,
32
],
[
29,
34
],
[
63,
34
],
[
37,
36
],
[
63,
40
],
[
65,
43
],
[
16,
44
],
[
67,
47
],
[
63,
53
],
[
65,
54
],
[
16,
55
],
[
67,
58
],
[
36,
61
],
[
63,
63
],
[
65,
65
],
[
67,
67
],
[
77,
71
],
[
79,
80
],
[
82,
83
],
[
85,
86
]
] | [
"S = input()\nlenS = len(S)\nans = 0\ndef f(SUM,TMP,N):\n n = int(S[N])\n if N == lenS-1:\n SUM += TMP + n\n return SUM\n else:\n ret = f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)\n return ret\n\nprint(f(0,0,0))",
"S = input()",
"S",
"input()",
"input",
"lenS = len(S)",
"lenS",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"def f(SUM,TMP,N):\n n = int(S[N])\n if N == lenS-1:\n SUM += TMP + n\n return SUM\n else:\n ret = f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)\n return ret",
"f",
"n = int(S[N])",
"n",
"int(S[N])",
"int",
"S[N]",
"S",
"N",
"if N == lenS-1:\n SUM += TMP + n\n return SUM\n else:\n ret = f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)\n return ret",
"N == lenS-1",
"N",
"lenS-1",
"lenS",
"1",
"SUM += TMP + n",
"SUM",
"TMP + n",
"TMP",
"n",
"return SUM",
"SUM",
"ret = f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)",
"ret",
"f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)",
"f(SUM,(TMP+n)*10,N+1)",
"f",
"SUM",
"(TMP+n)*10",
"TMP+n",
"TMP",
"n",
"10",
"N+1",
"N",
"1",
"f(SUM+TMP+n,0,N+1)",
"f",
"SUM+TMP+n",
"SUM+TMP",
"SUM",
"TMP",
"n",
"0",
"N+1",
"N",
"1",
"return ret",
"ret",
"SUM",
"SUM",
"TMP",
"TMP",
"N",
"N",
"print(f(0,0,0))",
"print",
"f(0,0,0)",
"f",
"0",
"0",
"0",
"def f(SUM,TMP,N):\n n = int(S[N])\n if N == lenS-1:\n SUM += TMP + n\n return SUM\n else:\n ret = f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)\n return ret",
"def f(SUM,TMP,N):\n n = int(S[N])\n if N == lenS-1:\n SUM += TMP + n\n return SUM\n else:\n ret = f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)\n return ret",
"f",
"S = input()",
"input()",
"S",
"lenS = len(S)",
"len(S)",
"lenS",
"ans = 0",
"0",
"ans"
] | S = input()
lenS = len(S)
ans = 0
def f(SUM,TMP,N):
n = int(S[N])
if N == lenS-1:
SUM += TMP + n
return SUM
else:
ret = f(SUM,(TMP+n)*10,N+1) + f(SUM+TMP+n,0,N+1)
return ret
print(f(0,0,0))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
0,
18,
13,
13,
17,
0,
13,
2,
39,
17,
2,
4,
13,
13,
13,
0,
18,
13,
39,
17,
13,
0,
18,
13,
39,
17,
17,
13,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
85,
2
],
[
82,
8
],
[
86,
12
],
[
97,
15
],
[
19,
18
],
[
83,
23
],
[
94,
25
],
[
83,
29
],
[
32,
31
],
[
83,
34
],
[
18,
37
],
[
31,
40
],
[
45,
42
],
[
95,
43
],
[
31,
44
],
[
88,
47
],
[
86,
54
],
[
83,
55
],
[
61,
57
],
[
89,
58
],
[
86,
61
],
[
68,
63
],
[
89,
64
],
[
95,
68
],
[
91,
70
],
[
89,
77
],
[
92,
80
],
[
98,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"s = list(input())\nn = len(s) - 1\n\nwa = 0\nfor i in range(2**n):\n lst = [\"\"]*n\n for j in range(n):\n if i&(1<<j):\n lst[j] = \"+\"\n lst_s = [0]*(len(s) + n)\n lst_s[::2] = s\n lst_s[1::2] = lst\n #print(eval(\"\".join(lst_s)))\n wa += eval(\"\".join(lst_s))\nprint(wa)",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"wa = 0",
"wa",
"0",
"for i in range(2**n):\n lst = [\"\"]*n\n for j in range(n):\n if i&(1<<j):\n lst[j] = \"+\"\n lst_s = [0]*(len(s) + n)\n lst_s[::2] = s\n lst_s[1::2] = lst\n #print(eval(\"\".join(lst_s)))\n wa += eval(\"\".join(lst_s))",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"lst = [\"\"]*n",
"lst",
"[\"\"]*n",
"[\"\"]",
"\"\"",
"n",
"for j in range(n):\n if i&(1<<j):\n lst[j] = \"+\"\n ",
"j",
"range(n)",
"range",
"n",
"if i&(1<<j):\n lst[j] = \"+\"\n ",
"i&(1<<j)",
"i",
"1<<j",
"1",
"j",
"lst[j] = \"+\"",
"lst[j]",
"lst",
"j",
"\"+\"",
"lst_s = [0]*(len(s) + n)",
"lst_s",
"[0]*(len(s) + n)",
"[0]",
"0",
"len(s) + n",
"len(s)",
"len",
"s",
"n",
"lst_s[::2] = s",
"lst_s[::2]",
"lst_s",
"::2",
"2",
"s",
"lst_s[1::2] = lst",
"lst_s[1::2]",
"lst_s",
"1::2",
"1",
"2",
"lst",
"wa += eval(\"\".join(lst_s))",
"wa",
"eval(\"\".join(lst_s))",
"eval",
"\"\".join(lst_s)",
"\"\".join",
"\"\"",
"join",
"lst_s",
"print(wa)",
"print",
"wa",
"n = len(s) - 1",
"len(s) - 1",
"n",
"s = list(input())",
"list(input())",
"s",
"lst_s = [0]*(len(s) + n)",
"[0]*(len(s) + n)",
"lst_s",
"wa += eval(\"\".join(lst_s))",
"eval(\"\".join(lst_s))",
"wa",
"lst = [\"\"]*n",
"[\"\"]*n",
"lst",
"wa = 0",
"0",
"wa"
] | s = list(input())
n = len(s) - 1
wa = 0
for i in range(2**n):
lst = [""]*n
for j in range(n):
if i&(1<<j):
lst[j] = "+"
lst_s = [0]*(len(s) + n)
lst_s[::2] = s
lst_s[1::2] = lst
#print(eval("".join(lst_s)))
wa += eval("".join(lst_s))
print(wa) |
[
7,
15,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
13,
4,
13,
18,
13,
13,
18,
13,
39,
17,
0,
13,
2,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13
] | [
[
72,
3
],
[
66,
7
],
[
73,
11
],
[
69,
14
],
[
24,
23
],
[
67,
24
],
[
78,
26
],
[
30,
29
],
[
67,
34
],
[
84,
36
],
[
73,
38
],
[
70,
46
],
[
29,
47
],
[
73,
49
],
[
81,
53
],
[
75,
58
],
[
82,
61
],
[
85,
61
],
[
76,
64
],
[
79,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
]
] | [
"from itertools import *\ns = input()\n\nn = len(s) - 1 # ้้ใฎๆฐ\nplus_list = list(product([\"+\", \"\"], repeat=n))\n\nans = 0\n\nfor bit in range(1 << n):\n formula = s[0]\n for j, k in zip(plus_list[bit], s[1:]):\n formula += (j + k)\n ans += eval(formula)\n\nprint(ans)",
"from itertools import *",
"s = input()",
"s",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"plus_list = list(product([\"+\", \"\"], repeat=n))",
"plus_list",
"list(product([\"+\", \"\"], repeat=n))",
"list",
"product([\"+\", \"\"], repeat=n)",
"product",
"[\"+\", \"\"]",
"\"+\"",
"\"\"",
"repeat=n",
"repeat",
"n",
"ans = 0",
"ans",
"0",
"for bit in range(1 << n):\n formula = s[0]\n for j, k in zip(plus_list[bit], s[1:]):\n formula += (j + k)\n ans += eval(formula)",
"bit",
"range(1 << n)",
"range",
"1 << n",
"1",
"n",
"formula = s[0]",
"formula",
"s[0]",
"s",
"0",
"for j, k in zip(plus_list[bit], s[1:]):\n formula += (j + k)\n ",
"j",
"k",
"zip(plus_list[bit], s[1:])",
"zip",
"plus_list[bit]",
"plus_list",
"bit",
"s[1:]",
"s",
"1:",
"1",
"formula += (j + k)",
"formula",
"j + k",
"j",
"k",
"ans += eval(formula)",
"ans",
"eval(formula)",
"eval",
"formula",
"print(ans)",
"print",
"ans",
"n = len(s) - 1",
"len(s) - 1",
"n",
"plus_list = list(product([\"+\", \"\"], repeat=n))",
"list(product([\"+\", \"\"], repeat=n))",
"plus_list",
"s = input()",
"input()",
"s",
"ans += eval(formula)",
"eval(formula)",
"ans",
"ans = 0",
"0",
"ans",
"formula += (j + k)",
"j + k",
"formula",
"formula = s[0]",
"s[0]",
"formula"
] | from itertools import *
s = input()
n = len(s) - 1 # ้้ใฎๆฐ
plus_list = list(product(["+", ""], repeat=n))
ans = 0
for bit in range(1 << n):
formula = s[0]
for j, k in zip(plus_list[bit], s[1:]):
formula += (j + k)
ans += eval(formula)
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
13,
0,
13,
4,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
2,
4,
13,
13,
4,
13,
13,
17,
4,
17,
0,
13,
2,
13,
18,
13,
39,
17,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
18,
13,
13,
17,
4,
18,
13,
13,
4,
18,
17,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
4,
18,
13,
13,
4,
18,
17,
13,
18,
13,
39,
13,
28,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13
] | [
[
138,
2
],
[
141,
8
],
[
12,
11
],
[
139,
19
],
[
132,
22
],
[
139,
23
],
[
123,
25
],
[
11,
30
],
[
34,
33
],
[
139,
40
],
[
124,
43
],
[
120,
48
],
[
124,
52
],
[
144,
56
],
[
135,
59
],
[
63,
62
],
[
139,
68
],
[
121,
73
],
[
62,
74
],
[
145,
78
],
[
133,
85
],
[
62,
89
],
[
129,
92
],
[
62,
94
],
[
145,
98
],
[
133,
105
],
[
110,
109
],
[
145,
109
],
[
126,
112
],
[
109,
115
],
[
127,
118
],
[
142,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
139,
132
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
]
] | [
"S = list(input())\nans = 0\n\nfor i in range(2**(len(S)-1)):\n tmp = S\n p = list(bin(i))\n flag = ['0' for _ in range(len(S) - len(p) + 1)] + p[2:]\n nums = []\n l = 0\n for j in range(len(S)-1):\n if flag[j] == '1':\n nums.append(\"\".join(tmp[l:j+1]))\n l = j+1\n nums.append(\"\".join(tmp[l:]))\n for n in nums:\n ans += int(n)\n\nprint(ans)",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(2**(len(S)-1)):\n tmp = S\n p = list(bin(i))\n flag = ['0' for _ in range(len(S) - len(p) + 1)] + p[2:]\n nums = []\n l = 0\n for j in range(len(S)-1):\n if flag[j] == '1':\n nums.append(\"\".join(tmp[l:j+1]))\n l = j+1\n nums.append(\"\".join(tmp[l:]))\n for n in nums:\n ans += int(n)",
"i",
"range(2**(len(S)-1))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"tmp = S",
"tmp",
"S",
"p = list(bin(i))",
"p",
"list(bin(i))",
"list",
"bin(i)",
"bin",
"i",
"'0' for _ in range(len(S) - len(p) + 1)",
"for _ in range(len(S) - len(p) + 1)",
"_",
"range(len(S) - len(p) + 1)",
"range",
"len(S) - len(p) + 1",
"len(S) - len(p)",
"len(S)",
"len",
"S",
"len(p)",
"len",
"p",
"1",
"for _ in range(len(S) - len(p) + 1)",
"'0'",
"flag = ['0' for _ in range(len(S) - len(p) + 1)] + p[2:]",
"flag",
"['0' for _ in range(len(S) - len(p) + 1)] + p[2:]",
"['0' for _ in range(len(S) - len(p) + 1)]",
"p[2:]",
"p",
"2:",
"2",
"nums = []",
"nums",
"[]",
"l = 0",
"l",
"0",
"for j in range(len(S)-1):\n if flag[j] == '1':\n nums.append(\"\".join(tmp[l:j+1]))\n l = j+1\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if flag[j] == '1':\n nums.append(\"\".join(tmp[l:j+1]))\n l = j+1\n ",
"flag[j] == '1'",
"flag[j]",
"flag",
"j",
"'1'",
"nums.append(\"\".join(tmp[l:j+1]))",
"nums.append",
"nums",
"append",
"\"\".join(tmp[l:j+1])",
"\"\".join",
"\"\"",
"join",
"tmp[l:j+1]",
"tmp",
"l:j+1",
"l",
"j+1",
"j",
"1",
"l = j+1",
"l",
"j+1",
"j",
"1",
"nums.append(\"\".join(tmp[l:]))",
"nums.append",
"nums",
"append",
"\"\".join(tmp[l:])",
"\"\".join",
"\"\"",
"join",
"tmp[l:]",
"tmp",
"l:",
"l",
"for n in nums:\n ans += int(n)",
"n",
"nums",
"ans += int(n)",
"ans",
"int(n)",
"int",
"n",
"print(ans)",
"print",
"ans",
"flag = ['0' for _ in range(len(S) - len(p) + 1)] + p[2:]",
"['0' for _ in range(len(S) - len(p) + 1)] + p[2:]",
"flag",
"p = list(bin(i))",
"list(bin(i))",
"p",
"ans += int(n)",
"int(n)",
"ans",
"l = j+1",
"j+1",
"l",
"tmp = S",
"S",
"tmp",
"l = 0",
"0",
"l",
"S = list(input())",
"list(input())",
"S",
"ans = 0",
"0",
"ans",
"nums = []",
"[]",
"nums"
] | S = list(input())
ans = 0
for i in range(2**(len(S)-1)):
tmp = S
p = list(bin(i))
flag = ['0' for _ in range(len(S) - len(p) + 1)] + p[2:]
nums = []
l = 0
for j in range(len(S)-1):
if flag[j] == '1':
nums.append("".join(tmp[l:j+1]))
l = j+1
nums.append("".join(tmp[l:]))
for n in nums:
ans += int(n)
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
18,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
71,
2
],
[
77,
6
],
[
72,
9
],
[
59,
11
],
[
15,
14
],
[
78,
20
],
[
65,
23
],
[
27,
26
],
[
78,
29
],
[
62,
31
],
[
66,
33
],
[
69,
33
],
[
63,
33
],
[
72,
35
],
[
26,
36
],
[
14,
40
],
[
26,
41
],
[
68,
44
],
[
63,
46
],
[
66,
46
],
[
69,
46
],
[
74,
49
],
[
60,
51
],
[
75,
51
],
[
69,
54
],
[
63,
54
],
[
66,
54
],
[
75,
57
],
[
60,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
]
] | [
"S=input()\ns_count = len(S)\nans = 0\nfor i in range(2**(s_count-1)):\n calc_str=\"\"\n for j in range(s_count):\n calc_str = calc_str + S[j]\n if (i>>j) & 1:\n calc_str = calc_str + \"+\"\n ans = ans + eval(calc_str)\nprint(ans)",
"S=input()",
"S",
"input()",
"input",
"s_count = len(S)",
"s_count",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for i in range(2**(s_count-1)):\n calc_str=\"\"\n for j in range(s_count):\n calc_str = calc_str + S[j]\n if (i>>j) & 1:\n calc_str = calc_str + \"+\"\n ans = ans + eval(calc_str)",
"i",
"range(2**(s_count-1))",
"range",
"2**(s_count-1)",
"2",
"s_count-1",
"s_count",
"1",
"calc_str=\"\"",
"calc_str",
"\"\"",
"for j in range(s_count):\n calc_str = calc_str + S[j]\n if (i>>j) & 1:\n calc_str = calc_str + \"+\"\n ",
"j",
"range(s_count)",
"range",
"s_count",
"calc_str = calc_str + S[j]",
"calc_str",
"calc_str + S[j]",
"calc_str",
"S[j]",
"S",
"j",
"if (i>>j) & 1:\n calc_str = calc_str + \"+\"\n ",
"(i>>j) & 1",
"i>>j",
"i",
"j",
"1",
"calc_str = calc_str + \"+\"",
"calc_str",
"calc_str + \"+\"",
"calc_str",
"\"+\"",
"ans = ans + eval(calc_str)",
"ans",
"ans + eval(calc_str)",
"ans",
"eval(calc_str)",
"eval",
"calc_str",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"calc_str = calc_str + S[j]",
"calc_str + S[j]",
"calc_str",
"calc_str=\"\"",
"\"\"",
"calc_str",
"calc_str = calc_str + \"+\"",
"calc_str + \"+\"",
"calc_str",
"S=input()",
"input()",
"S",
"ans = ans + eval(calc_str)",
"ans + eval(calc_str)",
"ans",
"s_count = len(S)",
"len(S)",
"s_count"
] | S=input()
s_count = len(S)
ans = 0
for i in range(2**(s_count-1)):
calc_str=""
for j in range(s_count):
calc_str = calc_str + S[j]
if (i>>j) & 1:
calc_str = calc_str + "+"
ans = ans + eval(calc_str)
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
2,
13,
13,
17,
17,
0,
18,
13,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13
] | [
[
97,
2
],
[
112,
6
],
[
98,
9
],
[
115,
11
],
[
15,
14
],
[
113,
20
],
[
100,
23
],
[
113,
28
],
[
32,
31
],
[
113,
35
],
[
14,
41
],
[
31,
42
],
[
49,
46
],
[
101,
47
],
[
31,
48
],
[
118,
51
],
[
98,
53
],
[
57,
56
],
[
101,
61
],
[
101,
65
],
[
56,
66
],
[
94,
69
],
[
103,
72
],
[
98,
74
],
[
56,
76
],
[
109,
79
],
[
98,
81
],
[
56,
83
],
[
106,
86
],
[
110,
89
],
[
104,
89
],
[
95,
89
],
[
119,
89
],
[
107,
92
],
[
116,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
]
] | [
"S = input()\nn = len(S)\nans = 0\n\nfor i in range(2**(n-1)):\n mode = ['-']*(n-1)\n for j in range(n-1):\n if (i >> j) & 1 == 1:\n mode[j] = '+'\n \n val = S[0]\n \n for k in range(len(mode)):\n if mode[k] == '+':\n val += '+'\n val += S[k + 1]\n else:\n val += S[k + 1]\n\n ans += eval(val)\nprint(ans) ",
"S = input()",
"S",
"input()",
"input",
"n = len(S)",
"n",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for i in range(2**(n-1)):\n mode = ['-']*(n-1)\n for j in range(n-1):\n if (i >> j) & 1 == 1:\n mode[j] = '+'\n \n val = S[0]\n \n for k in range(len(mode)):\n if mode[k] == '+':\n val += '+'\n val += S[k + 1]\n else:\n val += S[k + 1]\n\n ans += eval(val)",
"i",
"range(2**(n-1))",
"range",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"mode = ['-']*(n-1)",
"mode",
"['-']*(n-1)",
"['-']",
"'-'",
"n-1",
"n",
"1",
"for j in range(n-1):\n if (i >> j) & 1 == 1:\n mode[j] = '+'\n \n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i >> j) & 1 == 1:\n mode[j] = '+'\n \n ",
"(i >> j) & 1 == 1",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"1",
"mode[j] = '+'",
"mode[j]",
"mode",
"j",
"'+'",
"val = S[0]",
"val",
"S[0]",
"S",
"0",
"for k in range(len(mode)):\n if mode[k] == '+':\n val += '+'\n val += S[k + 1]\n else:\n val += S[k + 1]\n\n ",
"k",
"range(len(mode))",
"range",
"len(mode)",
"len",
"mode",
"if mode[k] == '+':\n val += '+'\n val += S[k + 1]\n else:\n val += S[k + 1]\n\n ",
"mode[k] == '+'",
"mode[k]",
"mode",
"k",
"'+'",
"val += '+'",
"val",
"'+'",
"val += S[k + 1]",
"val",
"S[k + 1]",
"S",
"k + 1",
"k",
"1",
"val += S[k + 1]",
"val",
"S[k + 1]",
"S",
"k + 1",
"k",
"1",
"ans += eval(val)",
"ans",
"eval(val)",
"eval",
"val",
"print(ans)",
"print",
"ans",
"val += '+'",
"'+'",
"val",
"S = input()",
"input()",
"S",
"mode = ['-']*(n-1)",
"['-']*(n-1)",
"mode",
"val += S[k + 1]",
"S[k + 1]",
"val",
"ans += eval(val)",
"eval(val)",
"ans",
"val += S[k + 1]",
"S[k + 1]",
"val",
"n = len(S)",
"len(S)",
"n",
"ans = 0",
"0",
"ans",
"val = S[0]",
"S[0]",
"val"
] | S = input()
n = len(S)
ans = 0
for i in range(2**(n-1)):
mode = ['-']*(n-1)
for j in range(n-1):
if (i >> j) & 1 == 1:
mode[j] = '+'
val = S[0]
for k in range(len(mode)):
if mode[k] == '+':
val += '+'
val += S[k + 1]
else:
val += S[k + 1]
ans += eval(val)
print(ans)
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
15,
28,
13,
4,
13,
39,
17,
17,
0,
13,
2,
13,
17,
0,
13,
18,
13,
17,
28,
13,
13,
4,
13,
18,
13,
39,
17,
13,
0,
13,
2,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
83,
4
],
[
74,
11
],
[
71,
18
],
[
89,
22
],
[
72,
25
],
[
77,
27
],
[
32,
31
],
[
39,
38
],
[
90,
40
],
[
80,
43
],
[
72,
45
],
[
72,
53
],
[
31,
56
],
[
86,
58
],
[
92,
63
],
[
87,
66
],
[
81,
66
],
[
93,
69
],
[
78,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
]
] | [
"# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\n#n,*p = map(int, read().split())\n\n\ns = input()\n\nL = len(s)\nans = 0\nfrom itertools import product\nfor a in product([\"+\",\"\"],repeat=L-1):\n t = s[0]\n for si,i in zip(s[1:],a):\n t += i + si\n \n #print(t)\n ans += eval(t)\n\nprint(ans)\n",
"import sys",
"sys",
"readline = sys.stdin.readline",
"readline",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"read = sys.stdin.read",
"read",
"sys.stdin.read",
"sys.stdin",
"sys",
"stdin",
"read",
"s = input()",
"s",
"input()",
"input",
"L = len(s)",
"L",
"len(s)",
"len",
"s",
"ans = 0",
"ans",
"0",
"from itertools import product",
"for a in product([\"+\",\"\"],repeat=L-1):\n t = s[0]\n for si,i in zip(s[1:],a):\n t += i + si\n \n #print(t)\n ans += eval(t)",
"a",
"product([\"+\",\"\"],repeat=L-1)",
"product",
"[\"+\",\"\"]",
"\"+\"",
"\"\"",
"repeat=L-1",
"repeat",
"L-1",
"L",
"1",
"t = s[0]",
"t",
"s[0]",
"s",
"0",
"for si,i in zip(s[1:],a):\n t += i + si\n \n #print(t)\n ",
"si",
"i",
"zip(s[1:],a)",
"zip",
"s[1:]",
"s",
"1:",
"1",
"a",
"t += i + si",
"t",
"i + si",
"i",
"si",
"ans += eval(t)",
"ans",
"eval(t)",
"eval",
"t",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"read = sys.stdin.read",
"sys.stdin.read",
"read",
"ans = 0",
"0",
"ans",
"t = s[0]",
"s[0]",
"t",
"readline = sys.stdin.readline",
"sys.stdin.readline",
"readline",
"t += i + si",
"i + si",
"t",
"L = len(s)",
"len(s)",
"L",
"ans += eval(t)",
"eval(t)",
"ans"
] | # coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read
#n,*p = map(int, read().split())
s = input()
L = len(s)
ans = 0
from itertools import product
for a in product(["+",""],repeat=L-1):
t = s[0]
for si,i in zip(s[1:],a):
t += i + si
#print(t)
ans += eval(t)
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
4,
18,
13,
13,
18,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
17,
4,
18,
13,
13,
18,
13,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13
] | [
[
73,
2
],
[
79,
6
],
[
74,
9
],
[
82,
11
],
[
15,
14
],
[
80,
20
],
[
76,
23
],
[
27,
26
],
[
80,
30
],
[
77,
34
],
[
74,
37
],
[
26,
38
],
[
14,
42
],
[
26,
43
],
[
77,
47
],
[
77,
52
],
[
74,
55
],
[
70,
58
],
[
77,
65
],
[
71,
68
],
[
83,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
]
] | [
"s = input()\nn = len(s)\nans = 0\nfor i in range(2 ** (n-1)):\n tmp = []\n for k in range(n-1):\n tmp.append(s[k])\n if i>>k & 1:\n tmp.append(\"+\")\n tmp.append(s[-1])\n ans += eval(\"\".join(tmp))\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (n-1)):\n tmp = []\n for k in range(n-1):\n tmp.append(s[k])\n if i>>k & 1:\n tmp.append(\"+\")\n tmp.append(s[-1])\n ans += eval(\"\".join(tmp))",
"i",
"range(2 ** (n-1))",
"range",
"2 ** (n-1)",
"2",
"n-1",
"n",
"1",
"tmp = []",
"tmp",
"[]",
"for k in range(n-1):\n tmp.append(s[k])\n if i>>k & 1:\n tmp.append(\"+\")\n ",
"k",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"tmp.append(s[k])",
"tmp.append",
"tmp",
"append",
"s[k]",
"s",
"k",
"if i>>k & 1:\n tmp.append(\"+\")\n ",
"i>>k & 1",
"i>>k",
"i",
"k",
"1",
"tmp.append(\"+\")",
"tmp.append",
"tmp",
"append",
"\"+\"",
"tmp.append(s[-1])",
"tmp.append",
"tmp",
"append",
"s[-1]",
"s",
"-1",
"ans += eval(\"\".join(tmp))",
"ans",
"eval(\"\".join(tmp))",
"eval",
"\"\".join(tmp)",
"\"\".join",
"\"\"",
"join",
"tmp",
"print(ans)",
"print",
"ans",
"ans += eval(\"\".join(tmp))",
"eval(\"\".join(tmp))",
"ans",
"s = input()",
"input()",
"s",
"tmp = []",
"[]",
"tmp",
"n = len(s)",
"len(s)",
"n",
"ans = 0",
"0",
"ans"
] | s = input()
n = len(s)
ans = 0
for i in range(2 ** (n-1)):
tmp = []
for k in range(n-1):
tmp.append(s[k])
if i>>k & 1:
tmp.append("+")
tmp.append(s[-1])
ans += eval("".join(tmp))
print(ans) |
[
7,
15,
13,
0,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
4,
13,
13,
12,
13,
14,
2,
13,
13,
29,
39,
2,
13,
13,
0,
13,
39,
4,
18,
13,
13,
4,
13,
2,
13,
17,
17,
2,
2,
13,
2,
13,
17,
4,
13,
18,
13,
13,
4,
18,
13,
13,
4,
13,
2,
13,
17,
2,
2,
13,
17,
4,
13,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
4,
13,
2,
4,
13,
4,
13,
17,
17,
17,
17,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
99,
4
],
[
96,
15
],
[
100,
18
],
[
76,
23
],
[
97,
24
],
[
80,
28
],
[
78,
29
],
[
32,
31
],
[
31,
35
],
[
76,
40
],
[
80,
45
],
[
78,
47
],
[
100,
52
],
[
76,
53
],
[
31,
56
],
[
76,
61
],
[
78,
65
],
[
100,
70
],
[
76,
71
],
[
80,
72
],
[
31,
74
],
[
76,
76
],
[
78,
78
],
[
80,
80
],
[
94,
87
],
[
96,
97
],
[
99,
100
]
] | [
"#!/usr/bin/env python3\n# N,M = map(int,sys.stdin.readline().split())\n# a = tuple(map(int,sys.stdin.readline().split())) # single line with multi param\n# a = tuple(int(sys.stdin.readline()) for _ in range(N)) # multi line with single param\n# a = tuple(tuple(map(int,sys.stdin.readline().rstrip().split())) for _ in range(N)) # multi line with multi param\n# s = sys.stdin.readline().rstrip()\n# N = int(sys.stdin.readline())\n# INF = float(\"inf\")\nimport sys\nS = sys.stdin.readline().rstrip()\nN = len(S)\ndef solve(i,c,s):\n #print(i,c,s)\n if i == N:\n return [s+c]\n ret = []\n ret.extend(solve(i+1,0,s+c*10+int(S[i])))\n ret.extend(solve(i+1,c*10+int(S[i]),s))\n return ret\n#print(solve(\"25\"))\nprint(sum(solve(0,0,0))//2)\n#print(sum(solve(S)))",
"import sys",
"sys",
"S = sys.stdin.readline().rstrip()",
"S",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"def solve(i,c,s):\n #print(i,c,s)\n if i == N:\n return [s+c]\n ret = []\n ret.extend(solve(i+1,0,s+c*10+int(S[i])))\n ret.extend(solve(i+1,c*10+int(S[i]),s))\n return ret\n#print(solve(\"25\"))",
"solve",
"if i == N:\n return [s+c]\n ",
"i == N",
"i",
"N",
"return [s+c]",
"[s+c]",
"s+c",
"s",
"c",
"ret = []",
"ret",
"[]",
"ret.extend(solve(i+1,0,s+c*10+int(S[i])))",
"ret.extend",
"ret",
"extend",
"solve(i+1,0,s+c*10+int(S[i]))",
"solve",
"i+1",
"i",
"1",
"0",
"s+c*10+int(S[i])",
"s+c*10",
"s",
"c*10",
"c",
"10",
"int(S[i])",
"int",
"S[i]",
"S",
"i",
"ret.extend(solve(i+1,c*10+int(S[i]),s))",
"ret.extend",
"ret",
"extend",
"solve(i+1,c*10+int(S[i]),s)",
"solve",
"i+1",
"i",
"1",
"c*10+int(S[i])",
"c*10",
"c",
"10",
"int(S[i])",
"int",
"S[i]",
"S",
"i",
"s",
"return ret",
"ret",
"i",
"i",
"c",
"c",
"s",
"s",
"print(sum(solve(0,0,0))//2)",
"print",
"sum(solve(0,0,0))//2",
"sum(solve(0,0,0))",
"sum",
"solve(0,0,0)",
"solve",
"0",
"0",
"0",
"2",
"def solve(i,c,s):\n #print(i,c,s)\n if i == N:\n return [s+c]\n ret = []\n ret.extend(solve(i+1,0,s+c*10+int(S[i])))\n ret.extend(solve(i+1,c*10+int(S[i]),s))\n return ret\n#print(solve(\"25\"))",
"def solve(i,c,s):\n #print(i,c,s)\n if i == N:\n return [s+c]\n ret = []\n ret.extend(solve(i+1,0,s+c*10+int(S[i])))\n ret.extend(solve(i+1,c*10+int(S[i]),s))\n return ret\n#print(solve(\"25\"))",
"solve",
"N = len(S)",
"len(S)",
"N",
"S = sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"S"
] | #!/usr/bin/env python3
# N,M = map(int,sys.stdin.readline().split())
# a = tuple(map(int,sys.stdin.readline().split())) # single line with multi param
# a = tuple(int(sys.stdin.readline()) for _ in range(N)) # multi line with single param
# a = tuple(tuple(map(int,sys.stdin.readline().rstrip().split())) for _ in range(N)) # multi line with multi param
# s = sys.stdin.readline().rstrip()
# N = int(sys.stdin.readline())
# INF = float("inf")
import sys
S = sys.stdin.readline().rstrip()
N = len(S)
def solve(i,c,s):
#print(i,c,s)
if i == N:
return [s+c]
ret = []
ret.extend(solve(i+1,0,s+c*10+int(S[i])))
ret.extend(solve(i+1,c*10+int(S[i]),s))
return ret
#print(solve("25"))
print(sum(solve(0,0,0))//2)
#print(sum(solve(S))) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
2,
13,
13,
17,
17,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] | [
[
64,
2
],
[
76,
6
],
[
65,
9
],
[
73,
11
],
[
15,
14
],
[
77,
20
],
[
61,
23
],
[
65,
25
],
[
29,
28
],
[
77,
32
],
[
14,
38
],
[
28,
39
],
[
79,
43
],
[
70,
46
],
[
65,
48
],
[
28,
50
],
[
67,
53
],
[
71,
56
],
[
80,
56
],
[
62,
56
],
[
68,
59
],
[
74,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
]
] | [
"s = input()\nl = len(s)\n\nans = 0\n\nfor i in range(2**(l-1)):\n a = s[0]\n for j in range(l-1):\n if i >> j & 1 == 1:\n a += '+'\n a += s[j+1]\n ans += eval(a)\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"l = len(s)",
"l",
"len(s)",
"len",
"s",
"ans = 0",
"ans",
"0",
"for i in range(2**(l-1)):\n a = s[0]\n for j in range(l-1):\n if i >> j & 1 == 1:\n a += '+'\n a += s[j+1]\n ans += eval(a)",
"i",
"range(2**(l-1))",
"range",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"a = s[0]",
"a",
"s[0]",
"s",
"0",
"for j in range(l-1):\n if i >> j & 1 == 1:\n a += '+'\n a += s[j+1]\n ",
"j",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if i >> j & 1 == 1:\n a += '+'\n ",
"i >> j & 1 == 1",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"1",
"a += '+'",
"a",
"'+'",
"a += s[j+1]",
"a",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ans += eval(a)",
"ans",
"eval(a)",
"eval",
"a",
"print(ans)",
"print",
"ans",
"a = s[0]",
"s[0]",
"a",
"s = input()",
"input()",
"s",
"ans += eval(a)",
"eval(a)",
"ans",
"a += s[j+1]",
"s[j+1]",
"a",
"ans = 0",
"0",
"ans",
"l = len(s)",
"len(s)",
"l",
"a += '+'",
"'+'",
"a"
] | s = input()
l = len(s)
ans = 0
for i in range(2**(l-1)):
a = s[0]
for j in range(l-1):
if i >> j & 1 == 1:
a += '+'
a += s[j+1]
ans += eval(a)
print(ans) |
[
7,
15,
13,
12,
13,
29,
4,
18,
18,
13,
13,
13,
12,
13,
0,
13,
4,
13,
18,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
0,
13,
2,
13,
13,
29,
13,
0,
13,
2,
4,
13,
13,
2,
13,
17,
13,
2,
2,
13,
13,
17,
4,
13,
13,
2,
13,
17,
2,
2,
13,
13,
13,
17,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
18,
4,
13,
13,
4,
13,
4,
13,
13,
17,
17,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
16,
15
],
[
66,
19
],
[
68,
20
],
[
68,
23
],
[
66,
27
],
[
31,
30
],
[
72,
32
],
[
15,
33
],
[
30,
35
],
[
70,
35
],
[
38,
37
],
[
66,
41
],
[
68,
43
],
[
70,
45
],
[
72,
48
],
[
15,
49
],
[
66,
53
],
[
68,
55
],
[
70,
59
],
[
72,
60
],
[
15,
61
],
[
37,
64
],
[
66,
66
],
[
68,
68
],
[
70,
70
],
[
72,
72
],
[
77,
76
],
[
104,
80
],
[
98,
85
],
[
76,
86
],
[
101,
95
]
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\nimport sys\n\n\ndef input():\n return sys.stdin.readline()\n\n\ndef all_search(s, i, i_sum: int, temp):\n n = int(s[i])\n\n if i == len(s)-1:\n # ใใผในใฑใผใน\n i_sum += temp + n\n return i_sum\n else:\n ret = all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)\n return ret\n\n\n\n\ndef resolve():\n s = input().rstrip()\n\n print(all_search(s, 0, 0, 0))\n\n\n\nif __name__ == \"__main__\":\n resolve()\n",
"import sys",
"sys",
"def input():\n return sys.stdin.readline()",
"input",
"return sys.stdin.readline()",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def all_search(s, i, i_sum: int, temp):\n n = int(s[i])\n\n if i == len(s)-1:\n # ใใผในใฑใผใน\n i_sum += temp + n\n return i_sum\n else:\n ret = all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)\n return ret",
"all_search",
"n = int(s[i])",
"n",
"int(s[i])",
"int",
"s[i]",
"s",
"i",
"if i == len(s)-1:\n # ใใผในใฑใผใน\n i_sum += temp + n\n return i_sum\n else:\n ret = all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)\n return ret",
"i == len(s)-1",
"i",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"i_sum += temp + n",
"i_sum",
"temp + n",
"temp",
"n",
"return i_sum",
"i_sum",
"ret = all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)",
"ret",
"all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)",
"all_search(s, i+1, i_sum, (temp+n)*10)",
"all_search",
"s",
"i+1",
"i",
"1",
"i_sum",
"(temp+n)*10",
"temp+n",
"temp",
"n",
"10",
"all_search(s, i+1, i_sum+temp+n, 0)",
"all_search",
"s",
"i+1",
"i",
"1",
"i_sum+temp+n",
"i_sum+temp",
"i_sum",
"temp",
"n",
"0",
"return ret",
"ret",
"s",
"s",
"i",
"i",
"i_sum: int",
"i_sum",
"temp",
"temp",
"def resolve():\n s = input().rstrip()\n\n print(all_search(s, 0, 0, 0))",
"resolve",
"s = input().rstrip()",
"s",
"input().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"print(all_search(s, 0, 0, 0))",
"print",
"all_search(s, 0, 0, 0)",
"all_search",
"s",
"0",
"0",
"0",
"if __name__ == \"__main__\":\n resolve()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"resolve()",
"resolve",
"def all_search(s, i, i_sum: int, temp):\n n = int(s[i])\n\n if i == len(s)-1:\n # ใใผในใฑใผใน\n i_sum += temp + n\n return i_sum\n else:\n ret = all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)\n return ret",
"def all_search(s, i, i_sum: int, temp):\n n = int(s[i])\n\n if i == len(s)-1:\n # ใใผในใฑใผใน\n i_sum += temp + n\n return i_sum\n else:\n ret = all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)\n return ret",
"all_search",
"def resolve():\n s = input().rstrip()\n\n print(all_search(s, 0, 0, 0))",
"def resolve():\n s = input().rstrip()\n\n print(all_search(s, 0, 0, 0))",
"resolve",
"def input():\n return sys.stdin.readline()",
"def input():\n return sys.stdin.readline()",
"input"
] | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline()
def all_search(s, i, i_sum: int, temp):
n = int(s[i])
if i == len(s)-1:
# ใใผในใฑใผใน
i_sum += temp + n
return i_sum
else:
ret = all_search(s, i+1, i_sum, (temp+n)*10) + all_search(s, i+1, i_sum+temp+n, 0)
return ret
def resolve():
s = input().rstrip()
print(all_search(s, 0, 0, 0))
if __name__ == "__main__":
resolve()
|
[
7,
15,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
39,
17,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
4,
13,
18,
13,
2,
2,
13,
13,
17,
2,
17,
13,
0,
13,
17,
14,
2,
40,
2,
2,
13,
13,
17,
17,
2,
18,
13,
2,
2,
13,
13,
17,
17,
0,
13,
17,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
101,
3
],
[
107,
9
],
[
102,
14
],
[
104,
16
],
[
108,
19
],
[
98,
21
],
[
25,
24
],
[
32,
31
],
[
105,
33
],
[
95,
36
],
[
40,
39
],
[
105,
42
],
[
86,
44
],
[
108,
49
],
[
105,
52
],
[
39,
53
],
[
96,
57
],
[
93,
57
],
[
90,
57
],
[
89,
59
],
[
105,
66
],
[
39,
67
],
[
24,
72
],
[
105,
75
],
[
39,
76
],
[
92,
80
],
[
87,
84
],
[
99,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
]
] | [
"from itertools import product\ns=int(input())\nsl=list(str(s))\nn=len(sl)\nans=0\nfor i in product([0,1],repeat=n-1):\n \n temp=0\n for j in range(n):\n ans+=int(sl[n-j-1])*10**temp\n temp+=1\n if n-j-2>=0 and i[n-j-2]==1:\n temp=0\nprint(ans)",
"from itertools import product",
"s=int(input())",
"s",
"int(input())",
"int",
"input()",
"input",
"sl=list(str(s))",
"sl",
"list(str(s))",
"list",
"str(s)",
"str",
"s",
"n=len(sl)",
"n",
"len(sl)",
"len",
"sl",
"ans=0",
"ans",
"0",
"for i in product([0,1],repeat=n-1):\n \n temp=0\n for j in range(n):\n ans+=int(sl[n-j-1])*10**temp\n temp+=1\n if n-j-2>=0 and i[n-j-2]==1:\n temp=0",
"i",
"product([0,1],repeat=n-1)",
"product",
"[0,1]",
"0",
"1",
"repeat=n-1",
"repeat",
"n-1",
"n",
"1",
"temp=0",
"temp",
"0",
"for j in range(n):\n ans+=int(sl[n-j-1])*10**temp\n temp+=1\n if n-j-2>=0 and i[n-j-2]==1:\n temp=0",
"j",
"range(n)",
"range",
"n",
"ans+=int(sl[n-j-1])*10**temp",
"ans",
"int(sl[n-j-1])*10**temp",
"int(sl[n-j-1])",
"int",
"sl[n-j-1]",
"sl",
"n-j-1",
"n-j",
"n",
"j",
"1",
"10**temp",
"10",
"temp",
"temp+=1",
"temp",
"1",
"if n-j-2>=0 and i[n-j-2]==1:\n temp=0",
"n-j-2>=0 and i[n-j-2]==1",
"n-j-2>=0",
"n-j-2",
"n-j",
"n",
"j",
"2",
"0",
"i[n-j-2]==1",
"i[n-j-2]",
"i",
"n-j-2",
"n-j",
"n",
"j",
"2",
"1",
"temp=0",
"temp",
"0",
"print(ans)",
"print",
"ans",
"ans+=int(sl[n-j-1])*10**temp",
"int(sl[n-j-1])*10**temp",
"ans",
"temp+=1",
"1",
"temp",
"temp=0",
"0",
"temp",
"temp=0",
"0",
"temp",
"ans=0",
"0",
"ans",
"s=int(input())",
"int(input())",
"s",
"n=len(sl)",
"len(sl)",
"n",
"sl=list(str(s))",
"list(str(s))",
"sl"
] | from itertools import product
s=int(input())
sl=list(str(s))
n=len(sl)
ans=0
for i in product([0,1],repeat=n-1):
temp=0
for j in range(n):
ans+=int(sl[n-j-1])*10**temp
temp+=1
if n-j-2>=0 and i[n-j-2]==1:
temp=0
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
0,
13,
39,
39,
17,
17,
17,
42,
13,
0,
13,
4,
18,
13,
13,
13,
13,
14,
40,
13,
13,
0,
13,
2,
13,
4,
13,
18,
13,
39,
13,
13,
4,
18,
13,
13,
39,
13,
13,
2,
13,
17,
4,
18,
13,
13,
39,
2,
13,
4,
13,
18,
13,
39,
13,
13,
13,
2,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
98,
2
],
[
77,
6
],
[
99,
9
],
[
92,
11
],
[
86,
14
],
[
89,
23
],
[
87,
26
],
[
89,
28
],
[
89,
29
],
[
81,
32
],
[
78,
33
],
[
95,
35
],
[
84,
37
],
[
99,
41
],
[
87,
47
],
[
81,
53
],
[
87,
57
],
[
84,
61
],
[
99,
65
],
[
81,
71
],
[
96,
75
],
[
93,
75
],
[
77,
78
],
[
89,
81
],
[
89,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
]
] | [
"S = input()\nN = len(S)\nans = 0\nstack = [(0,0,1)]\nwhile stack:\n t,s,g = stack.pop()\n if g >= N:\n ans+=t+int(S[s:g])\n else:\n stack.append((t,s,g+1))\n stack.append((t+int(S[s:g]),g,g+1))\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"stack = [(0,0,1)]",
"stack",
"[(0,0,1)]",
"(0,0,1)",
"0",
"0",
"1",
"while stack:\n t,s,g = stack.pop()\n if g >= N:\n ans+=t+int(S[s:g])\n else:\n stack.append((t,s,g+1))\n stack.append((t+int(S[s:g]),g,g+1))",
"stack",
"t,s,g = stack.pop()",
"t",
"stack.pop()",
"stack.pop",
"stack",
"pop",
"s",
"g",
"if g >= N:\n ans+=t+int(S[s:g])\n else:\n stack.append((t,s,g+1))\n stack.append((t+int(S[s:g]),g,g+1))",
"g >= N",
"g",
"N",
"ans+=t+int(S[s:g])",
"ans",
"t+int(S[s:g])",
"t",
"int(S[s:g])",
"int",
"S[s:g]",
"S",
"s:g",
"s",
"g",
"stack.append((t,s,g+1))",
"stack.append",
"stack",
"append",
"(t,s,g+1)",
"t",
"s",
"g+1",
"g",
"1",
"stack.append((t+int(S[s:g]),g,g+1))",
"stack.append",
"stack",
"append",
"(t+int(S[s:g]),g,g+1)",
"t+int(S[s:g])",
"t",
"int(S[s:g])",
"int",
"S[s:g]",
"S",
"s:g",
"s",
"g",
"g",
"g+1",
"g",
"1",
"print(ans)",
"print",
"ans",
"N = len(S)",
"len(S)",
"N",
"g = stack.pop()",
"stack.pop()",
"g",
"t,s,g = stack.pop()",
"stack.pop()",
"t",
"stack = [(0,0,1)]",
"[(0,0,1)]",
"stack",
"s,g = stack.pop()",
"stack.pop()",
"s",
"ans = 0",
"0",
"ans",
"ans+=t+int(S[s:g])",
"t+int(S[s:g])",
"ans",
"S = input()",
"input()",
"S"
] | S = input()
N = len(S)
ans = 0
stack = [(0,0,1)]
while stack:
t,s,g = stack.pop()
if g >= N:
ans+=t+int(S[s:g])
else:
stack.append((t,s,g+1))
stack.append((t+int(S[s:g]),g,g+1))
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
17,
0,
13,
39,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
18,
13,
39,
13,
2,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13
] | [
[
85,
2
],
[
97,
6
],
[
86,
9
],
[
109,
11
],
[
15,
14
],
[
98,
20
],
[
88,
23
],
[
106,
26
],
[
30,
29
],
[
98,
32
],
[
14,
36
],
[
29,
37
],
[
100,
40
],
[
86,
42
],
[
29,
46
],
[
91,
49
],
[
29,
51
],
[
107,
55
],
[
101,
59
],
[
95,
59
],
[
94,
61
],
[
86,
63
],
[
98,
67
],
[
107,
71
],
[
95,
75
],
[
101,
75
],
[
103,
77
],
[
107,
80
],
[
104,
83
],
[
110,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] | [
"s = input()\nn = len(s)\nans = 0\n\nfor i in range(2 ** (n - 1)):\n k = 0\n num_list = []\n for j in range(n):\n if (i >> j) & 1:\n num = s[k : j + 1]\n# print(num)\n k = j + 1\n num_list.append(int(num))\n# print(num_list)\n num = s[k : n +1]\n num_list.append(int(num))\n ans += sum(num_list)\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (n - 1)):\n k = 0\n num_list = []\n for j in range(n):\n if (i >> j) & 1:\n num = s[k : j + 1]\n# print(num)\n k = j + 1\n num_list.append(int(num))\n# print(num_list)\n num = s[k : n +1]\n num_list.append(int(num))\n ans += sum(num_list)",
"i",
"range(2 ** (n - 1))",
"range",
"2 ** (n - 1)",
"2",
"n - 1",
"n",
"1",
"k = 0",
"k",
"0",
"num_list = []",
"num_list",
"[]",
"for j in range(n):\n if (i >> j) & 1:\n num = s[k : j + 1]\n# print(num)\n k = j + 1\n num_list.append(int(num))\n# print(num_list)\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1:\n num = s[k : j + 1]\n# print(num)\n k = j + 1\n num_list.append(int(num))\n# print(num_list)\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"num = s[k : j + 1]",
"num",
"s[k : j + 1]",
"s",
"k : j + 1",
"k",
"j + 1",
"j",
"1",
"k = j + 1",
"k",
"j + 1",
"j",
"1",
"num_list.append(int(num))",
"num_list.append",
"num_list",
"append",
"int(num)",
"int",
"num",
"num = s[k : n +1]",
"num",
"s[k : n +1]",
"s",
"k : n +1",
"k",
"n +1",
"n",
"1",
"num_list.append(int(num))",
"num_list.append",
"num_list",
"append",
"int(num)",
"int",
"num",
"ans += sum(num_list)",
"ans",
"sum(num_list)",
"sum",
"num_list",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"k = 0",
"0",
"k",
"k = j + 1",
"j + 1",
"k",
"num = s[k : n +1]",
"s[k : n +1]",
"num",
"n = len(s)",
"len(s)",
"n",
"num = s[k : j + 1]",
"s[k : j + 1]",
"num",
"ans += sum(num_list)",
"sum(num_list)",
"ans",
"num_list = []",
"[]",
"num_list",
"ans = 0",
"0",
"ans"
] | s = input()
n = len(s)
ans = 0
for i in range(2 ** (n - 1)):
k = 0
num_list = []
for j in range(n):
if (i >> j) & 1:
num = s[k : j + 1]
# print(num)
k = j + 1
num_list.append(int(num))
# print(num_list)
num = s[k : n +1]
num_list.append(int(num))
ans += sum(num_list)
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
2,
13,
13,
17,
17,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] | [
[
78,
2
],
[
72,
6
],
[
79,
10
],
[
84,
13
],
[
17,
16
],
[
73,
21
],
[
75,
23
],
[
79,
25
],
[
29,
28
],
[
73,
31
],
[
16,
36
],
[
28,
37
],
[
66,
41
],
[
81,
44
],
[
79,
46
],
[
28,
48
],
[
69,
51
],
[
82,
59
],
[
67,
59
],
[
76,
59
],
[
70,
64
],
[
85,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
]
] | [
"s = input()\nn = len(s) - 1\nans = 0\n\nfor i in range(2 ** n):\n l = s[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n l += '+'\n l += s[j + 1]\n ans += sum(map(int, l.split('+')))\n\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2 ** n):\n l = s[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n l += '+'\n l += s[j + 1]\n ans += sum(map(int, l.split('+')))",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"l = s[0]",
"l",
"s[0]",
"s",
"0",
"for j in range(n):\n if (i >> j) & 1 == 1:\n l += '+'\n l += s[j + 1]\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1 == 1:\n l += '+'\n ",
"(i >> j) & 1 == 1",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"1",
"l += '+'",
"l",
"'+'",
"l += s[j + 1]",
"l",
"s[j + 1]",
"s",
"j + 1",
"j",
"1",
"ans += sum(map(int, l.split('+')))",
"ans",
"sum(map(int, l.split('+')))",
"sum",
"map(int, l.split('+'))",
"map",
"int",
"l.split('+')",
"l.split",
"l",
"split",
"'+'",
"print(ans)",
"print",
"ans",
"l += '+'",
"'+'",
"l",
"ans += sum(map(int, l.split('+')))",
"sum(map(int, l.split('+')))",
"ans",
"n = len(s) - 1",
"len(s) - 1",
"n",
"l = s[0]",
"s[0]",
"l",
"s = input()",
"input()",
"s",
"l += s[j + 1]",
"s[j + 1]",
"l",
"ans = 0",
"0",
"ans"
] | s = input()
n = len(s) - 1
ans = 0
for i in range(2 ** n):
l = s[0]
for j in range(n):
if (i >> j) & 1 == 1:
l += '+'
l += s[j + 1]
ans += sum(map(int, l.split('+')))
print(ans) |
[
7,
12,
13,
28,
13,
39,
17,
17,
0,
18,
13,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
2,
13,
17,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
0,
13,
2,
39,
17,
2,
4,
13,
13,
17,
4,
18,
13,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
4,
13,
13,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
5,
4
],
[
12,
9
],
[
72,
10
],
[
68,
11
],
[
4,
12
],
[
68,
15
],
[
72,
19
],
[
23,
22
],
[
66,
25
],
[
48,
25
],
[
22,
25
],
[
68,
27
],
[
70,
29
],
[
72,
30
],
[
33,
32
],
[
36,
35
],
[
72,
40
],
[
72,
44
],
[
35,
45
],
[
49,
48
],
[
70,
52
],
[
35,
56
],
[
60,
59
],
[
35,
61
],
[
48,
64
],
[
22,
64
],
[
66,
64
],
[
66,
66
],
[
68,
68
],
[
70,
70
],
[
72,
72
],
[
77,
76
],
[
81,
80
],
[
76,
87
],
[
80,
91
],
[
96,
95
],
[
99,
98
],
[
102,
101
],
[
122,
103
],
[
98,
104
],
[
95,
105
],
[
76,
106
],
[
80,
107
],
[
101,
110
],
[
98,
110
],
[
119,
116
]
] | [
"\ndef equa(ans,i,s,p):\n for e in (0,1):\n p[i] = e\n if i < len(p)-2:\n ans = equa(ans,i+1,s,p)\n else:\n #print(i,s,p)\n prii = 0\n for ii in range(len(p)):\n if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n return ans\ndef main():\n s = input()\n p = [0]*(len(s)-1)\n p.append(1)\n i = 0\n ans = 0\n ans = equa(ans,i,s,p)\n print(ans)\n \nif __name__ == '__main__':\n main()",
"def equa(ans,i,s,p):\n for e in (0,1):\n p[i] = e\n if i < len(p)-2:\n ans = equa(ans,i+1,s,p)\n else:\n #print(i,s,p)\n prii = 0\n for ii in range(len(p)):\n if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n return ans",
"equa",
"for e in (0,1):\n p[i] = e\n if i < len(p)-2:\n ans = equa(ans,i+1,s,p)\n else:\n #print(i,s,p)\n prii = 0\n for ii in range(len(p)):\n if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n ",
"e",
"(0,1)",
"0",
"1",
"p[i] = e",
"p[i]",
"p",
"i",
"e",
"if i < len(p)-2:\n ans = equa(ans,i+1,s,p)\n else:\n #print(i,s,p)\n prii = 0\n for ii in range(len(p)):\n if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n ",
"i < len(p)-2",
"i",
"len(p)-2",
"len(p)",
"len",
"p",
"2",
"ans = equa(ans,i+1,s,p)",
"ans",
"equa(ans,i+1,s,p)",
"equa",
"ans",
"i+1",
"i",
"1",
"s",
"p",
"prii = 0",
"prii",
"0",
"for ii in range(len(p)):\n if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n ",
"ii",
"range(len(p))",
"range",
"len(p)",
"len",
"p",
"if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n ",
"p[ii] == 1",
"p[ii]",
"p",
"ii",
"1",
"ans += int(s[prii:ii+1])",
"ans",
"int(s[prii:ii+1])",
"int",
"s[prii:ii+1]",
"s",
"prii:ii+1",
"prii",
"ii+1",
"ii",
"1",
"prii = ii+1",
"prii",
"ii+1",
"ii",
"1",
"return ans",
"ans",
"ans",
"ans",
"i",
"i",
"s",
"s",
"p",
"p",
"def main():\n s = input()\n p = [0]*(len(s)-1)\n p.append(1)\n i = 0\n ans = 0\n ans = equa(ans,i,s,p)\n print(ans)\n ",
"main",
"s = input()",
"s",
"input()",
"input",
"p = [0]*(len(s)-1)",
"p",
"[0]*(len(s)-1)",
"[0]",
"0",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"p.append(1)",
"p.append",
"p",
"append",
"1",
"i = 0",
"i",
"0",
"ans = 0",
"ans",
"0",
"ans = equa(ans,i,s,p)",
"ans",
"equa(ans,i,s,p)",
"equa",
"ans",
"i",
"s",
"p",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n s = input()\n p = [0]*(len(s)-1)\n p.append(1)\n i = 0\n ans = 0\n ans = equa(ans,i,s,p)\n print(ans)\n ",
"def main():\n s = input()\n p = [0]*(len(s)-1)\n p.append(1)\n i = 0\n ans = 0\n ans = equa(ans,i,s,p)\n print(ans)\n ",
"main",
"def equa(ans,i,s,p):\n for e in (0,1):\n p[i] = e\n if i < len(p)-2:\n ans = equa(ans,i+1,s,p)\n else:\n #print(i,s,p)\n prii = 0\n for ii in range(len(p)):\n if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n return ans",
"def equa(ans,i,s,p):\n for e in (0,1):\n p[i] = e\n if i < len(p)-2:\n ans = equa(ans,i+1,s,p)\n else:\n #print(i,s,p)\n prii = 0\n for ii in range(len(p)):\n if p[ii] == 1:\n ans += int(s[prii:ii+1])\n #print(prii,ii+1,int(s[prii:ii+1]))\n prii = ii+1\n return ans",
"equa"
] |
def equa(ans,i,s,p):
for e in (0,1):
p[i] = e
if i < len(p)-2:
ans = equa(ans,i+1,s,p)
else:
#print(i,s,p)
prii = 0
for ii in range(len(p)):
if p[ii] == 1:
ans += int(s[prii:ii+1])
#print(prii,ii+1,int(s[prii:ii+1]))
prii = ii+1
return ans
def main():
s = input()
p = [0]*(len(s)-1)
p.append(1)
i = 0
ans = 0
ans = equa(ans,i,s,p)
print(ans)
if __name__ == '__main__':
main() |
[
7,
0,
13,
17,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
14,
2,
13,
17,
4,
13,
13,
4,
13,
17,
0,
13,
17,
0,
13,
2,
2,
17,
4,
13,
13,
17,
14,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
4,
13,
4,
13,
18,
4,
13,
13,
39,
17,
13,
14,
13,
4,
13,
17,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
8,
2,
13,
17,
17,
17,
14,
13,
4,
13,
13,
0,
13,
18,
13,
17,
14,
13,
4,
13,
13,
4,
13,
13,
4,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
3,
2
],
[
130,
5
],
[
142,
9
],
[
131,
13
],
[
143,
17
],
[
131,
21
],
[
127,
26
],
[
136,
29
],
[
143,
35
],
[
137,
41
],
[
139,
43
],
[
47,
46
],
[
143,
51
],
[
145,
53
],
[
46,
61
],
[
137,
64
],
[
146,
70
],
[
124,
72
],
[
146,
79
],
[
148,
81
],
[
131,
84
],
[
149,
96
],
[
125,
96
],
[
122,
96
],
[
121,
98
],
[
131,
100
],
[
122,
106
],
[
149,
106
],
[
125,
106
],
[
122,
109
],
[
149,
109
],
[
125,
109
],
[
133,
113
],
[
122,
116
],
[
149,
116
],
[
125,
116
],
[
134,
119
],
[
140,
119
],
[
128,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
]
] | [
"__DEUBG__ = 0\nnum = input()\npattern = len(num) -1\n\nif pattern == 0:\n print(num)\n exit(0)\ntotal = 0\nfmt = '0' + str(pattern) + 'd'\nif __DEUBG__:\n print(fmt)\ntotal = 0\nfor i in range(2**pattern):\n binary = format(int(bin(i)[2:]), fmt)\n if __DEUBG__:\n print('binary', binary)\n\n equation = ''\n for idx, sign in enumerate(binary):\n equation += num[idx] + ('+' if sign == '1' else '')\n if __DEUBG__:\n print(equation)\n\n equation += num[-1]\n if __DEUBG__:\n print(equation, eval(equation))\n print()\n total += eval(equation)\n\nprint(total)",
"__DEUBG__ = 0",
"__DEUBG__",
"0",
"num = input()",
"num",
"input()",
"input",
"pattern = len(num) -1",
"pattern",
"len(num) -1",
"len(num)",
"len",
"num",
"1",
"if pattern == 0:\n print(num)\n exit(0)",
"pattern == 0",
"pattern",
"0",
"print(num)",
"print",
"num",
"exit(0)",
"exit",
"0",
"total = 0",
"total",
"0",
"fmt = '0' + str(pattern) + 'd'",
"fmt",
"'0' + str(pattern) + 'd'",
"'0' + str(pattern)",
"'0'",
"str(pattern)",
"str",
"pattern",
"'d'",
"if __DEUBG__:\n print(fmt)",
"__DEUBG__",
"print(fmt)",
"print",
"fmt",
"total = 0",
"total",
"0",
"for i in range(2**pattern):\n binary = format(int(bin(i)[2:]), fmt)\n if __DEUBG__:\n print('binary', binary)\n\n equation = ''\n for idx, sign in enumerate(binary):\n equation += num[idx] + ('+' if sign == '1' else '')\n if __DEUBG__:\n print(equation)\n\n equation += num[-1]\n if __DEUBG__:\n print(equation, eval(equation))\n print()\n total += eval(equation)",
"i",
"range(2**pattern)",
"range",
"2**pattern",
"2",
"pattern",
"binary = format(int(bin(i)[2:]), fmt)",
"binary",
"format(int(bin(i)[2:]), fmt)",
"format",
"int(bin(i)[2:])",
"int",
"bin(i)[2:]",
"(i)",
"bin",
"i",
"2:",
"2",
"fmt",
"if __DEUBG__:\n print('binary', binary)\n\n ",
"__DEUBG__",
"print('binary', binary)",
"print",
"'binary'",
"binary",
"equation = ''",
"equation",
"''",
"for idx, sign in enumerate(binary):\n equation += num[idx] + ('+' if sign == '1' else '')\n if __DEUBG__:\n print(equation)\n\n ",
"idx",
"sign",
"enumerate(binary)",
"enumerate",
"binary",
"equation += num[idx] + ('+' if sign == '1' else '')",
"equation",
"num[idx] + ('+' if sign == '1' else '')",
"num[idx]",
"num",
"idx",
"'+' if sign == '1' else ''",
"sign == '1'",
"sign",
"'1'",
"'+'",
"''",
"if __DEUBG__:\n print(equation)\n\n ",
"__DEUBG__",
"print(equation)",
"print",
"equation",
"equation += num[-1]",
"equation",
"num[-1]",
"num",
"-1",
"if __DEUBG__:\n print(equation, eval(equation))\n print()\n ",
"__DEUBG__",
"print(equation, eval(equation))",
"print",
"equation",
"eval(equation)",
"eval",
"equation",
"print()",
"print",
"total += eval(equation)",
"total",
"eval(equation)",
"eval",
"equation",
"print(total)",
"print",
"total",
"equation += num[-1]",
"num[-1]",
"equation",
"equation = ''",
"''",
"equation",
"total = 0",
"0",
"total",
"num = input()",
"input()",
"num",
"total += eval(equation)",
"eval(equation)",
"total",
"fmt = '0' + str(pattern) + 'd'",
"'0' + str(pattern) + 'd'",
"fmt",
"total = 0",
"0",
"total",
"pattern = len(num) -1",
"len(num) -1",
"pattern",
"binary = format(int(bin(i)[2:]), fmt)",
"format(int(bin(i)[2:]), fmt)",
"binary",
"equation += num[idx] + ('+' if sign == '1' else '')",
"num[idx] + ('+' if sign == '1' else '')",
"equation"
] | __DEUBG__ = 0
num = input()
pattern = len(num) -1
if pattern == 0:
print(num)
exit(0)
total = 0
fmt = '0' + str(pattern) + 'd'
if __DEUBG__:
print(fmt)
total = 0
for i in range(2**pattern):
binary = format(int(bin(i)[2:]), fmt)
if __DEUBG__:
print('binary', binary)
equation = ''
for idx, sign in enumerate(binary):
equation += num[idx] + ('+' if sign == '1' else '')
if __DEUBG__:
print(equation)
equation += num[-1]
if __DEUBG__:
print(equation, eval(equation))
print()
total += eval(equation)
print(total) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
14,
2,
13,
17,
4,
13,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
39,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
17,
4,
18,
13,
13,
17,
0,
13,
18,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
14,
2,
18,
13,
17,
17,
0,
13,
18,
13,
17,
4,
18,
13,
13,
4,
13,
13,
4,
18,
13,
13,
4,
13,
13,
4,
18,
13,
13,
4,
13,
18,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13,
10,
39,
13,
10,
18,
13,
10,
39,
13,
10,
18,
13,
10,
2,
13
] | [
[
140,
2
],
[
167,
6
],
[
141,
10
],
[
168,
14
],
[
141,
18
],
[
146,
22
],
[
26,
25
],
[
168,
30
],
[
155,
32
],
[
36,
35
],
[
168,
38
],
[
25,
42
],
[
35,
43
],
[
156,
47
],
[
156,
52
],
[
152,
56
],
[
141,
58
],
[
161,
61
],
[
65,
64
],
[
168,
68
],
[
156,
73
],
[
64,
74
],
[
162,
78
],
[
153,
82
],
[
159,
82
],
[
150,
82
],
[
165,
82
],
[
149,
84
],
[
141,
86
],
[
64,
88
],
[
158,
91
],
[
141,
93
],
[
64,
95
],
[
156,
100
],
[
164,
104
],
[
141,
106
],
[
162,
110
],
[
165,
114
],
[
159,
114
],
[
150,
114
],
[
153,
114
],
[
162,
117
],
[
159,
121
],
[
150,
121
],
[
153,
121
],
[
165,
121
],
[
162,
124
],
[
141,
129
],
[
143,
132
],
[
162,
135
],
[
144,
138
],
[
147,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
],
[
149,
150
],
[
152,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
]
] | [
"s = input()\nn = len(s)-1\nif n == 0:\n print(s)\n exit()\n\nans = 0\nfor i in range(2**n):\n data = []\n for j in range(n):\n if((i >> j) & 1):\n data.append(1)\n else:\n data.append(0)\n # print(data)\n num = s[0]\n x = []\n for i in range(n-1):\n if data[i] == 1:\n x.append(int(num))\n num = s[i+1]\n else:\n num += s[i+1]\n if data[-1] == 0:\n num += s[-1]\n x.append(int(num))\n else:\n x.append(int(num))\n x.append(int(s[-1]))\n ans += sum(x)\n # print(x)\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"n = len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if n == 0:\n print(s)\n exit()",
"n == 0",
"n",
"0",
"print(s)",
"print",
"s",
"exit()",
"exit",
"ans = 0",
"ans",
"0",
"for i in range(2**n):\n data = []\n for j in range(n):\n if((i >> j) & 1):\n data.append(1)\n else:\n data.append(0)\n # print(data)\n num = s[0]\n x = []\n for i in range(n-1):\n if data[i] == 1:\n x.append(int(num))\n num = s[i+1]\n else:\n num += s[i+1]\n if data[-1] == 0:\n num += s[-1]\n x.append(int(num))\n else:\n x.append(int(num))\n x.append(int(s[-1]))\n ans += sum(x)\n # print(x)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"data = []",
"data",
"[]",
"for j in range(n):\n if((i >> j) & 1):\n data.append(1)\n else:\n data.append(0)\n # print(data)\n ",
"j",
"range(n)",
"range",
"n",
"if((i >> j) & 1):\n data.append(1)\n else:\n data.append(0)\n # print(data)\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"data.append(1)",
"data.append",
"data",
"append",
"1",
"data.append(0)",
"data.append",
"data",
"append",
"0",
"num = s[0]",
"num",
"s[0]",
"s",
"0",
"x = []",
"x",
"[]",
"for i in range(n-1):\n if data[i] == 1:\n x.append(int(num))\n num = s[i+1]\n else:\n num += s[i+1]\n ",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if data[i] == 1:\n x.append(int(num))\n num = s[i+1]\n else:\n num += s[i+1]\n ",
"data[i] == 1",
"data[i]",
"data",
"i",
"1",
"x.append(int(num))",
"x.append",
"x",
"append",
"int(num)",
"int",
"num",
"num = s[i+1]",
"num",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"num += s[i+1]",
"num",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"if data[-1] == 0:\n num += s[-1]\n x.append(int(num))\n else:\n x.append(int(num))\n x.append(int(s[-1]))\n ",
"data[-1] == 0",
"data[-1]",
"data",
"-1",
"0",
"num += s[-1]",
"num",
"s[-1]",
"s",
"-1",
"x.append(int(num))",
"x.append",
"x",
"append",
"int(num)",
"int",
"num",
"x.append(int(num))",
"x.append",
"x",
"append",
"int(num)",
"int",
"num",
"x.append(int(s[-1]))",
"x.append",
"x",
"append",
"int(s[-1])",
"int",
"s[-1]",
"s",
"-1",
"ans += sum(x)",
"ans",
"sum(x)",
"sum",
"x",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"ans += sum(x)",
"sum(x)",
"ans",
"ans = 0",
"0",
"ans",
"num = s[i+1]",
"s[i+1]",
"num",
"num = s[0]",
"s[0]",
"num",
"data = []",
"[]",
"data",
"num += s[i+1]",
"s[i+1]",
"num",
"x = []",
"[]",
"x",
"num += s[-1]",
"s[-1]",
"num",
"n = len(s)-1",
"len(s)-1",
"n"
] | s = input()
n = len(s)-1
if n == 0:
print(s)
exit()
ans = 0
for i in range(2**n):
data = []
for j in range(n):
if((i >> j) & 1):
data.append(1)
else:
data.append(0)
# print(data)
num = s[0]
x = []
for i in range(n-1):
if data[i] == 1:
x.append(int(num))
num = s[i+1]
else:
num += s[i+1]
if data[-1] == 0:
num += s[-1]
x.append(int(num))
else:
x.append(int(num))
x.append(int(s[-1]))
ans += sum(x)
# print(x)
print(ans)
|
[
7,
0,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13
] | [
[
82,
2
],
[
85,
9
],
[
83,
13
],
[
94,
16
],
[
91,
19
],
[
23,
22
],
[
86,
27
],
[
76,
29
],
[
33,
32
],
[
86,
35
],
[
22,
39
],
[
32,
40
],
[
73,
43
],
[
83,
47
],
[
32,
51
],
[
88,
54
],
[
32,
56
],
[
79,
59
],
[
83,
63
],
[
83,
68
],
[
80,
71
],
[
74,
71
],
[
92,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
]
] | [
"S = input().rstrip()\nN = len(S) - 1\np = \"+\"\n\nans = 0\nfor bit in range(1 << N):\n\tmae = 0\n\tfor j in range(N):\n\t\tif (bit >> j) & 1:\n\t\t\tans += int(S[mae: j + 1])\n\t\t\tmae = j + 1\n\tans += int(S[mae: len(S)])\nprint(ans)",
"S = input().rstrip()",
"S",
"input().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"N = len(S) - 1",
"N",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"p = \"+\"",
"p",
"\"+\"",
"ans = 0",
"ans",
"0",
"for bit in range(1 << N):\n\tmae = 0\n\tfor j in range(N):\n\t\tif (bit >> j) & 1:\n\t\t\tans += int(S[mae: j + 1])\n\t\t\tmae = j + 1\n\tans += int(S[mae: len(S)])",
"bit",
"range(1 << N)",
"range",
"1 << N",
"1",
"N",
"mae = 0",
"mae",
"0",
"for j in range(N):\n\t\tif (bit >> j) & 1:\n\t\t\tans += int(S[mae: j + 1])\n\t\t\tmae = j + 1\n\t",
"j",
"range(N)",
"range",
"N",
"if (bit >> j) & 1:\n\t\t\tans += int(S[mae: j + 1])\n\t\t\tmae = j + 1\n\t",
"(bit >> j) & 1",
"bit >> j",
"bit",
"j",
"1",
"ans += int(S[mae: j + 1])",
"ans",
"int(S[mae: j + 1])",
"int",
"S[mae: j + 1]",
"S",
"mae: j + 1",
"mae",
"j + 1",
"j",
"1",
"mae = j + 1",
"mae",
"j + 1",
"j",
"1",
"ans += int(S[mae: len(S)])",
"ans",
"int(S[mae: len(S)])",
"int",
"S[mae: len(S)]",
"S",
"mae: len(S)",
"mae",
"len(S)",
"len",
"S",
"print(ans)",
"print",
"ans",
"ans += int(S[mae: j + 1])",
"int(S[mae: j + 1])",
"ans",
"mae = 0",
"0",
"mae",
"ans += int(S[mae: len(S)])",
"int(S[mae: len(S)])",
"ans",
"S = input().rstrip()",
"input().rstrip()",
"S",
"N = len(S) - 1",
"len(S) - 1",
"N",
"mae = j + 1",
"j + 1",
"mae",
"ans = 0",
"0",
"ans",
"p = \"+\"",
"\"+\"",
"p"
] | S = input().rstrip()
N = len(S) - 1
p = "+"
ans = 0
for bit in range(1 << N):
mae = 0
for j in range(N):
if (bit >> j) & 1:
ans += int(S[mae: j + 1])
mae = j + 1
ans += int(S[mae: len(S)])
print(ans) |
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
39,
0,
13,
18,
13,
17,
0,
13,
39,
17,
17,
28,
13,
4,
18,
13,
13,
13,
0,
13,
2,
4,
13,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
18,
13,
17,
4,
13,
4,
13,
13,
10,
18,
13,
10,
39,
13,
10,
18,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13
] | [
[
89,
4
],
[
77,
10
],
[
74,
13
],
[
90,
15
],
[
83,
18
],
[
24,
23
],
[
84,
28
],
[
31,
30
],
[
90,
34
],
[
38,
37
],
[
90,
43
],
[
86,
46
],
[
23,
49
],
[
37,
50
],
[
90,
52
],
[
37,
54
],
[
78,
58
],
[
87,
62
],
[
75,
62
],
[
81,
62
],
[
80,
64
],
[
90,
66
],
[
78,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] | [
"import itertools\nS = list(input())\nans = []\na = S[0]\npl = [\"+\",\"\"]\n\nfor i in itertools.product(pl, repeat=len(S)-1):\n for j in range(len(S)-1):\n a += i[j]+S[j+1]\n ans.append(eval(a))\n a = S[0]\n\nprint(sum(ans))",
"import itertools",
"itertools",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"ans = []",
"ans",
"[]",
"a = S[0]",
"a",
"S[0]",
"S",
"0",
"pl = [\"+\",\"\"]",
"pl",
"[\"+\",\"\"]",
"\"+\"",
"\"\"",
"for i in itertools.product(pl, repeat=len(S)-1):\n for j in range(len(S)-1):\n a += i[j]+S[j+1]\n ans.append(eval(a))\n a = S[0]",
"i",
"itertools.product(pl, repeat=len(S)-1)",
"itertools.product",
"itertools",
"product",
"pl",
"repeat=len(S)-1",
"repeat",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"for j in range(len(S)-1):\n a += i[j]+S[j+1]\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"a += i[j]+S[j+1]",
"a",
"i[j]+S[j+1]",
"i[j]",
"i",
"j",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"ans.append(eval(a))",
"ans.append",
"ans",
"append",
"eval(a)",
"eval",
"a",
"a = S[0]",
"a",
"S[0]",
"S",
"0",
"print(sum(ans))",
"print",
"sum(ans)",
"sum",
"ans",
"a = S[0]",
"S[0]",
"a",
"ans = []",
"[]",
"ans",
"a = S[0]",
"S[0]",
"a",
"pl = [\"+\",\"\"]",
"[\"+\",\"\"]",
"pl",
"a += i[j]+S[j+1]",
"i[j]+S[j+1]",
"a",
"S = list(input())",
"list(input())",
"S"
] | import itertools
S = list(input())
ans = []
a = S[0]
pl = ["+",""]
for i in itertools.product(pl, repeat=len(S)-1):
for j in range(len(S)-1):
a += i[j]+S[j+1]
ans.append(eval(a))
a = S[0]
print(sum(ans)) |
[
7,
15,
13,
0,
13,
4,
13,
0,
13,
39,
28,
13,
13,
4,
18,
13,
13,
13,
14,
2,
4,
13,
13,
17,
4,
13,
4,
13,
13,
4,
18,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
39,
14,
2,
13,
17,
4,
18,
13,
13,
17,
4,
18,
13,
13,
17,
28,
13,
13,
4,
18,
13,
13,
2,
13,
17,
4,
18,
13,
13,
2,
13,
17,
0,
13,
13,
0,
13,
39,
28,
13,
13,
0,
13,
39,
28,
13,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
39,
28,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
18,
13,
13,
14,
2,
18,
13,
13,
17,
4,
18,
13,
13,
17,
14,
2,
18,
13,
13,
17,
9,
4,
18,
13,
13,
18,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
0,
13,
39,
14,
2,
13,
2,
4,
13,
13,
17,
28,
13,
13,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
13,
14,
2,
18,
13,
13,
17,
28,
13,
13,
0,
13,
13,
0,
13,
39,
28,
13,
13,
4,
18,
13,
13,
2,
13,
17,
4,
18,
13,
13,
4,
13,
18,
13,
13,
0,
13,
13,
4,
13,
13,
10,
39,
13,
10,
17,
13,
10,
39,
13,
10,
39,
13,
10,
2,
13,
10,
13,
13,
10,
39,
13,
10,
39,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
13,
13,
10,
13,
13,
10,
39,
13,
10,
39,
13,
10,
39,
13,
10,
4,
13
] | [
[
269,
4
],
[
242,
8
],
[
12,
11
],
[
270,
11
],
[
243,
15
],
[
11,
17
],
[
243,
22
],
[
270,
28
],
[
251,
34
],
[
38,
37
],
[
243,
43
],
[
266,
46
],
[
37,
50
],
[
267,
54
],
[
267,
59
],
[
64,
63
],
[
252,
63
],
[
258,
63
],
[
267,
67
],
[
63,
70
],
[
267,
74
],
[
63,
77
],
[
257,
80
],
[
267,
81
],
[
287,
83
],
[
87,
86
],
[
258,
86
],
[
252,
86
],
[
272,
89
],
[
93,
92
],
[
86,
92
],
[
273,
96
],
[
267,
96
],
[
92,
98
],
[
288,
101
],
[
273,
103
],
[
267,
103
],
[
281,
105
],
[
109,
108
],
[
288,
108
],
[
284,
111
],
[
115,
114
],
[
243,
120
],
[
285,
124
],
[
273,
124
],
[
267,
124
],
[
243,
127
],
[
114,
128
],
[
108,
132
],
[
114,
133
],
[
285,
137
],
[
273,
137
],
[
267,
137
],
[
108,
143
],
[
114,
144
],
[
285,
149
],
[
273,
149
],
[
267,
149
],
[
243,
152
],
[
282,
156
],
[
285,
158
],
[
273,
158
],
[
267,
158
],
[
245,
160
],
[
164,
163
],
[
282,
163
],
[
263,
166
],
[
170,
169
],
[
163,
174
],
[
260,
176
],
[
169,
180
],
[
163,
184
],
[
188,
187
],
[
264,
187
],
[
276,
187
],
[
249,
187
],
[
254,
190
],
[
187,
192
],
[
290,
195
],
[
163,
199
],
[
169,
200
],
[
163,
204
],
[
169,
205
],
[
209,
208
],
[
264,
208
],
[
276,
208
],
[
249,
208
],
[
278,
211
],
[
208,
212
],
[
248,
214
],
[
218,
217
],
[
264,
217
],
[
276,
217
],
[
249,
217
],
[
261,
221
],
[
217,
224
],
[
261,
228
],
[
163,
233
],
[
169,
234
],
[
275,
236
],
[
261,
237
],
[
279,
240
],
[
291,
240
],
[
255,
240
],
[
246,
240
],
[
242,
243
],
[
245,
246
],
[
248,
249
],
[
251,
252
],
[
254,
255
],
[
267,
257
],
[
257,
258
],
[
260,
261
],
[
263,
264
],
[
266,
267
],
[
269,
270
],
[
272,
273
],
[
261,
275
],
[
275,
276
],
[
208,
278
],
[
278,
279
],
[
281,
282
],
[
284,
285
],
[
287,
288
],
[
290,
291
]
] | [
"import sys\nS=input()\nS_seq=[]\nfor i in S:\n S_seq.append(i)\nif(len(S_seq)==1):\n print(int(S))\n sys.exit()\nseparate=[]\nfor i in range(len(S_seq)-1):\n a=[]\n if(i==0):\n a.append(\"*\")\n a.append(\"_\")\n else:\n for j in separate:\n a.append(j+\"*\")\n a.append(j+\"_\")\n separate=a\n\nseparated=[]\nfor i in separate:\n a=[]\n for j in i:\n a.append(j)\n separated.append(a)\n\npre_calculated=[]\nfor i in separated:\n a=[]\n for j in range(len(S_seq)-1):\n a.append(S_seq[j])\n if(i[j]==\"*\"):\n a.append(\"+\")\n elif(i[j]==\"_\"):\n continue\n a.append(S_seq[-1])\n pre_calculated.append(a)\n\nsumation=0\nfor i in pre_calculated:\n number=[]\n for j in range(len(i)):\n new_number=[]\n if(j==len(i)-1):\n for k in number:\n sumation+=k*10\n sumation+=int(i[j])\n elif(i[j]==\"+\"):\n for k in number:\n sumation+=k\n number=[]\n else:\n for k in number:\n new_number.append(k*10)\n new_number.append(int(i[j]))\n \n number=new_number\nprint(sumation)\n\n ",
"import sys",
"sys",
"S=input()",
"S",
"input()",
"input",
"S_seq=[]",
"S_seq",
"[]",
"for i in S:\n S_seq.append(i)",
"i",
"S",
"S_seq.append(i)",
"S_seq.append",
"S_seq",
"append",
"i",
"if(len(S_seq)==1):\n print(int(S))\n sys.exit()",
"len(S_seq)==1",
"len(S_seq)",
"len",
"S_seq",
"1",
"print(int(S))",
"print",
"int(S)",
"int",
"S",
"sys.exit()",
"sys.exit",
"sys",
"exit",
"separate=[]",
"separate",
"[]",
"for i in range(len(S_seq)-1):\n a=[]\n if(i==0):\n a.append(\"*\")\n a.append(\"_\")\n else:\n for j in separate:\n a.append(j+\"*\")\n a.append(j+\"_\")\n separate=a",
"i",
"range(len(S_seq)-1)",
"range",
"len(S_seq)-1",
"len(S_seq)",
"len",
"S_seq",
"1",
"a=[]",
"a",
"[]",
"if(i==0):\n a.append(\"*\")\n a.append(\"_\")\n else:\n for j in separate:\n a.append(j+\"*\")\n a.append(j+\"_\")\n ",
"i==0",
"i",
"0",
"a.append(\"*\")",
"a.append",
"a",
"append",
"\"*\"",
"a.append(\"_\")",
"a.append",
"a",
"append",
"\"_\"",
"for j in separate:\n a.append(j+\"*\")\n a.append(j+\"_\")\n ",
"j",
"separate",
"a.append(j+\"*\")",
"a.append",
"a",
"append",
"j+\"*\"",
"j",
"\"*\"",
"a.append(j+\"_\")",
"a.append",
"a",
"append",
"j+\"_\"",
"j",
"\"_\"",
"separate=a",
"separate",
"a",
"separated=[]",
"separated",
"[]",
"for i in separate:\n a=[]\n for j in i:\n a.append(j)\n separated.append(a)",
"i",
"separate",
"a=[]",
"a",
"[]",
"for j in i:\n a.append(j)\n ",
"j",
"i",
"a.append(j)",
"a.append",
"a",
"append",
"j",
"separated.append(a)",
"separated.append",
"separated",
"append",
"a",
"pre_calculated=[]",
"pre_calculated",
"[]",
"for i in separated:\n a=[]\n for j in range(len(S_seq)-1):\n a.append(S_seq[j])\n if(i[j]==\"*\"):\n a.append(\"+\")\n elif(i[j]==\"_\"):\n continue\n a.append(S_seq[-1])\n pre_calculated.append(a)",
"i",
"separated",
"a=[]",
"a",
"[]",
"for j in range(len(S_seq)-1):\n a.append(S_seq[j])\n if(i[j]==\"*\"):\n a.append(\"+\")\n elif(i[j]==\"_\"):\n continue\n ",
"j",
"range(len(S_seq)-1)",
"range",
"len(S_seq)-1",
"len(S_seq)",
"len",
"S_seq",
"1",
"a.append(S_seq[j])",
"a.append",
"a",
"append",
"S_seq[j]",
"S_seq",
"j",
"if(i[j]==\"*\"):\n a.append(\"+\")\n elif(i[j]==\"_\"):\n continue\n ",
"i[j]==\"*\"",
"i[j]",
"i",
"j",
"\"*\"",
"a.append(\"+\")",
"a.append",
"a",
"append",
"\"+\"",
"elif(i[j]==\"_\"):\n continue\n ",
"i[j]==\"_\"",
"i[j]",
"i",
"j",
"\"_\"",
"continue",
"a.append(S_seq[-1])",
"a.append",
"a",
"append",
"S_seq[-1]",
"S_seq",
"-1",
"pre_calculated.append(a)",
"pre_calculated.append",
"pre_calculated",
"append",
"a",
"sumation=0",
"sumation",
"0",
"for i in pre_calculated:\n number=[]\n for j in range(len(i)):\n new_number=[]\n if(j==len(i)-1):\n for k in number:\n sumation+=k*10\n sumation+=int(i[j])\n elif(i[j]==\"+\"):\n for k in number:\n sumation+=k\n number=[]\n else:\n for k in number:\n new_number.append(k*10)\n new_number.append(int(i[j]))\n \n number=new_number",
"i",
"pre_calculated",
"number=[]",
"number",
"[]",
"for j in range(len(i)):\n new_number=[]\n if(j==len(i)-1):\n for k in number:\n sumation+=k*10\n sumation+=int(i[j])\n elif(i[j]==\"+\"):\n for k in number:\n sumation+=k\n number=[]\n else:\n for k in number:\n new_number.append(k*10)\n new_number.append(int(i[j]))\n \n number=new_number",
"j",
"range(len(i))",
"range",
"len(i)",
"len",
"i",
"new_number=[]",
"new_number",
"[]",
"if(j==len(i)-1):\n for k in number:\n sumation+=k*10\n sumation+=int(i[j])\n elif(i[j]==\"+\"):\n for k in number:\n sumation+=k\n number=[]\n else:\n for k in number:\n new_number.append(k*10)\n new_number.append(int(i[j]))\n \n ",
"j==len(i)-1",
"j",
"len(i)-1",
"len(i)",
"len",
"i",
"1",
"for k in number:\n sumation+=k*10\n ",
"k",
"number",
"sumation+=k*10",
"sumation",
"k*10",
"k",
"10",
"sumation+=int(i[j])",
"sumation",
"int(i[j])",
"int",
"i[j]",
"i",
"j",
"elif(i[j]==\"+\"):\n for k in number:\n sumation+=k\n number=[]\n ",
"i[j]==\"+\"",
"i[j]",
"i",
"j",
"\"+\"",
"for k in number:\n sumation+=k\n ",
"k",
"number",
"sumation+=k",
"sumation",
"k",
"number=[]",
"number",
"[]",
"for k in number:\n new_number.append(k*10)\n ",
"k",
"number",
"new_number.append(k*10)",
"new_number.append",
"new_number",
"append",
"k*10",
"k",
"10",
"new_number.append(int(i[j]))",
"new_number.append",
"new_number",
"append",
"int(i[j])",
"int",
"i[j]",
"i",
"j",
"number=new_number",
"number",
"new_number",
"print(sumation)",
"print",
"sumation",
"S_seq=[]",
"[]",
"S_seq",
"sumation=0",
"0",
"sumation",
"number=[]",
"[]",
"number",
"separate=[]",
"[]",
"separate",
"sumation+=k*10",
"k*10",
"sumation",
"separate=a",
"a",
"separate",
"new_number=[]",
"[]",
"new_number",
"number=[]",
"[]",
"number",
"a=[]",
"[]",
"a",
"S=input()",
"input()",
"S",
"a=[]",
"[]",
"a",
"number=new_number",
"new_number",
"number",
"sumation+=k",
"k",
"sumation",
"pre_calculated=[]",
"[]",
"pre_calculated",
"a=[]",
"[]",
"a",
"separated=[]",
"[]",
"separated",
"sumation+=int(i[j])",
"int(i[j])",
"sumation"
] | import sys
S=input()
S_seq=[]
for i in S:
S_seq.append(i)
if(len(S_seq)==1):
print(int(S))
sys.exit()
separate=[]
for i in range(len(S_seq)-1):
a=[]
if(i==0):
a.append("*")
a.append("_")
else:
for j in separate:
a.append(j+"*")
a.append(j+"_")
separate=a
separated=[]
for i in separate:
a=[]
for j in i:
a.append(j)
separated.append(a)
pre_calculated=[]
for i in separated:
a=[]
for j in range(len(S_seq)-1):
a.append(S_seq[j])
if(i[j]=="*"):
a.append("+")
elif(i[j]=="_"):
continue
a.append(S_seq[-1])
pre_calculated.append(a)
sumation=0
for i in pre_calculated:
number=[]
for j in range(len(i)):
new_number=[]
if(j==len(i)-1):
for k in number:
sumation+=k*10
sumation+=int(i[j])
elif(i[j]=="+"):
for k in number:
sumation+=k
number=[]
else:
for k in number:
new_number.append(k*10)
new_number.append(int(i[j]))
number=new_number
print(sumation)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
2,
39,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
0,
18,
13,
13,
17,
0,
13,
39,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
4,
13,
13,
14,
2,
2,
13,
17,
17,
4,
18,
13,
13,
18,
13,
13,
0,
13,
17,
4,
18,
13,
13,
18,
13,
13,
0,
13,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
140,
2
],
[
122,
8
],
[
12,
11
],
[
141,
19
],
[
134,
22
],
[
141,
29
],
[
33,
32
],
[
141,
38
],
[
11,
43
],
[
32,
44
],
[
50,
47
],
[
135,
48
],
[
32,
49
],
[
113,
52
],
[
128,
55
],
[
137,
58
],
[
62,
61
],
[
135,
67
],
[
141,
70
],
[
61,
74
],
[
114,
79
],
[
120,
79
],
[
141,
82
],
[
129,
83
],
[
117,
83
],
[
116,
85
],
[
114,
89
],
[
120,
89
],
[
135,
92
],
[
138,
93
],
[
132,
93
],
[
131,
95
],
[
119,
98
],
[
114,
103
],
[
120,
103
],
[
125,
105
],
[
120,
108
],
[
114,
108
],
[
126,
111
],
[
123,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
]
] | [
"S=list(input())\nans=0\nfor i in range(2**(len(S)-1)):\n kari=[\"\"]*(len(S)-1)\n for j in range(len(S)-1):\n if ((i>>j)&1):\n kari[j]=\"+\"\n hako=[]\n kasu=0\n gomi=0\n for j in range(len(kari)+len(S)):\n if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n hako=\"\".join(hako)\n #hako=hako.replace(\",\",\"\")\n #print(hako)\n ans+=eval(hako)\nprint(ans)",
"S=list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"ans=0",
"ans",
"0",
"for i in range(2**(len(S)-1)):\n kari=[\"\"]*(len(S)-1)\n for j in range(len(S)-1):\n if ((i>>j)&1):\n kari[j]=\"+\"\n hako=[]\n kasu=0\n gomi=0\n for j in range(len(kari)+len(S)):\n if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n hako=\"\".join(hako)\n #hako=hako.replace(\",\",\"\")\n #print(hako)\n ans+=eval(hako)",
"i",
"range(2**(len(S)-1))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"kari=[\"\"]*(len(S)-1)",
"kari",
"[\"\"]*(len(S)-1)",
"[\"\"]",
"\"\"",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"for j in range(len(S)-1):\n if ((i>>j)&1):\n kari[j]=\"+\"\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if ((i>>j)&1):\n kari[j]=\"+\"\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"kari[j]=\"+\"",
"kari[j]",
"kari",
"j",
"\"+\"",
"hako=[]",
"hako",
"[]",
"kasu=0",
"kasu",
"0",
"gomi=0",
"gomi",
"0",
"for j in range(len(kari)+len(S)):\n if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n ",
"j",
"range(len(kari)+len(S))",
"range",
"len(kari)+len(S)",
"len(kari)",
"len",
"kari",
"len(S)",
"len",
"S",
"if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n ",
"j%2==0",
"j%2",
"j",
"2",
"0",
"hako.append(S[kasu])",
"hako.append",
"hako",
"append",
"S[kasu]",
"S",
"kasu",
"kasu+=1",
"kasu",
"1",
"hako.append(kari[gomi])",
"hako.append",
"hako",
"append",
"kari[gomi]",
"kari",
"gomi",
"gomi+=1",
"gomi",
"1",
"hako=\"\".join(hako)",
"hako",
"\"\".join(hako)",
"\"\".join",
"\"\"",
"join",
"hako",
"ans+=eval(hako)",
"ans",
"eval(hako)",
"eval",
"hako",
"print(ans)",
"print",
"ans",
"hako=[]",
"[]",
"hako",
"kasu+=1",
"1",
"kasu",
"hako=\"\".join(hako)",
"\"\".join(hako)",
"hako",
"ans=0",
"0",
"ans",
"ans+=eval(hako)",
"eval(hako)",
"ans",
"kasu=0",
"0",
"kasu",
"gomi+=1",
"1",
"gomi",
"kari=[\"\"]*(len(S)-1)",
"[\"\"]*(len(S)-1)",
"kari",
"gomi=0",
"0",
"gomi",
"S=list(input())",
"list(input())",
"S"
] | S=list(input())
ans=0
for i in range(2**(len(S)-1)):
kari=[""]*(len(S)-1)
for j in range(len(S)-1):
if ((i>>j)&1):
kari[j]="+"
hako=[]
kasu=0
gomi=0
for j in range(len(kari)+len(S)):
if j%2==0:
hako.append(S[kasu])
kasu+=1
else:
hako.append(kari[gomi])
gomi+=1
#print(hako)
hako="".join(hako)
#hako=hako.replace(",","")
#print(hako)
ans+=eval(hako)
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13
] | [
[
76,
2
],
[
79,
6
],
[
10,
9
],
[
77,
17
],
[
85,
20
],
[
24,
23
],
[
77,
29
],
[
9,
34
],
[
23,
35
],
[
86,
39
],
[
23,
41
],
[
88,
43
],
[
47,
46
],
[
86,
46
],
[
91,
49
],
[
77,
53
],
[
46,
57
],
[
94,
60
],
[
46,
62
],
[
82,
65
],
[
77,
69
],
[
83,
74
],
[
92,
74
],
[
80,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
]
] | [
"n = input()\n\nsumP = 0\n\nfor i in range(2 ** (len(n)- 1)): #้ใฎๆฐใๆคๆจ็ฎใฎๅ
จๆข็ดข\n plus=[] #๏ผไฝ็ฝฎใฎใชในใ\n for j in range(len(n) - 1): #ไป่ชฟในใใใคใใฉใฎไฝ็ฝฎใซ+ใใใคใ\n if i >> j & 1 : #iใjๅใทใใใใฆใ0ใ1ใๅคๅฎใใใ1ใชใใใใใซ+ใใใใใๆ ผ็ดใใใ\n plus.append(j) \n\n middle_index = 0\n\n for pos in plus:\n sumP += int(n[middle_index:pos + 1]) #ๅๅ้จๅใๅ\n middle_index = pos + 1\n sumP += int(n[middle_index:]) #ๅพๅ้จๅใๅ\n\nprint(sumP)",
"n = input()",
"n",
"input()",
"input",
"sumP = 0",
"sumP",
"0",
"for i in range(2 ** (len(n)- 1)): #้ใฎๆฐใๆคๆจ็ฎใฎๅ
จๆข็ดข\n plus=[] #๏ผไฝ็ฝฎใฎใชในใ\n for j in range(len(n) - 1): #ไป่ชฟในใใใคใใฉใฎไฝ็ฝฎใซ+ใใใคใ\n if i >> j & 1 : #iใjๅใทใใใใฆใ0ใ1ใๅคๅฎใใใ1ใชใใใใใซ+ใใใใใๆ ผ็ดใใใ\n plus.append(j) \n\n middle_index = 0\n\n for pos in plus:\n sumP += int(n[middle_index:pos + 1]) #ๅๅ้จๅใๅ\n middle_index = pos + 1\n sumP += int(n[middle_index:]) #ๅพๅ้จๅใๅ",
"i",
"range(2 ** (len(n)- 1))",
"range",
"2 ** (len(n)- 1)",
"2",
"len(n)- 1",
"len(n)",
"len",
"n",
"1",
"plus=[]",
"plus",
"[]",
"for j in range(len(n) - 1): #ไป่ชฟในใใใคใใฉใฎไฝ็ฝฎใซ+ใใใคใ\n if i >> j & 1 : #iใjๅใทใใใใฆใ0ใ1ใๅคๅฎใใใ1ใชใใใใใซ+ใใใใใๆ ผ็ดใใใ\n plus.append(j) \n\n ",
"j",
"range(len(n) - 1)",
"range",
"len(n) - 1",
"len(n)",
"len",
"n",
"1",
"if i >> j & 1 : #iใjๅใทใใใใฆใ0ใ1ใๅคๅฎใใใ1ใชใใใใใซ+ใใใใใๆ ผ็ดใใใ\n plus.append(j) \n\n ",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"plus.append(j)",
"plus.append",
"plus",
"append",
"j",
"middle_index = 0",
"middle_index",
"0",
"for pos in plus:\n sumP += int(n[middle_index:pos + 1]) #ๅๅ้จๅใๅ\n middle_index = pos + 1\n ",
"pos",
"plus",
"sumP += int(n[middle_index:pos + 1])",
"sumP",
"int(n[middle_index:pos + 1])",
"int",
"n[middle_index:pos + 1]",
"n",
"middle_index:pos + 1",
"middle_index",
"pos + 1",
"pos",
"1",
"middle_index = pos + 1",
"middle_index",
"pos + 1",
"pos",
"1",
"sumP += int(n[middle_index:])",
"sumP",
"int(n[middle_index:])",
"int",
"n[middle_index:]",
"n",
"middle_index:",
"middle_index",
"print(sumP)",
"print",
"sumP",
"n = input()",
"input()",
"n",
"sumP = 0",
"0",
"sumP",
"sumP += int(n[middle_index:])",
"int(n[middle_index:])",
"sumP",
"plus=[]",
"[]",
"plus",
"middle_index = 0",
"0",
"middle_index",
"sumP += int(n[middle_index:pos + 1])",
"int(n[middle_index:pos + 1])",
"sumP",
"middle_index = pos + 1",
"pos + 1",
"middle_index"
] | n = input()
sumP = 0
for i in range(2 ** (len(n)- 1)): #้ใฎๆฐใๆคๆจ็ฎใฎๅ
จๆข็ดข
plus=[] #๏ผไฝ็ฝฎใฎใชในใ
for j in range(len(n) - 1): #ไป่ชฟในใใใคใใฉใฎไฝ็ฝฎใซ+ใใใคใ
if i >> j & 1 : #iใjๅใทใใใใฆใ0ใ1ใๅคๅฎใใใ1ใชใใใใใซ+ใใใใใๆ ผ็ดใใใ
plus.append(j)
middle_index = 0
for pos in plus:
sumP += int(n[middle_index:pos + 1]) #ๅๅ้จๅใๅ
middle_index = pos + 1
sumP += int(n[middle_index:]) #ๅพๅ้จๅใๅ
print(sumP) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
4,
13,
13,
17,
0,
13,
18,
13,
39,
40,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
4,
13,
18,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
86,
2
],
[
77,
6
],
[
87,
10
],
[
98,
13
],
[
17,
16
],
[
78,
21
],
[
101,
23
],
[
16,
26
],
[
89,
29
],
[
102,
31
],
[
90,
31
],
[
78,
34
],
[
92,
36
],
[
40,
39
],
[
78,
42
],
[
90,
47
],
[
102,
47
],
[
39,
48
],
[
83,
50
],
[
87,
54
],
[
39,
58
],
[
95,
61
],
[
39,
63
],
[
80,
66
],
[
87,
70
],
[
81,
75
],
[
84,
75
],
[
99,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
]
] | [
"S = input()\nlng = len(S) - 1\n#print(lng)\ncnt = 0\n\nfor i in range(2**lng):\n A = format(i, '09b')\n A = A[-lng:]\n #print(A)\n slc = 0\n for j in range(lng):\n #print(j)\n #print(int(A[j]))\n if int(A[j]):\n #print(int(S[slc:j+1]))\n cnt += int(S[slc:j+1])\n #cnt += int(S[slc:j+1])\n slc = j +1\n #print(int(S[slc:]))\n cnt += int(S[slc:])\nprint(cnt)",
"S = input()",
"S",
"input()",
"input",
"lng = len(S) - 1",
"lng",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"cnt = 0",
"cnt",
"0",
"for i in range(2**lng):\n A = format(i, '09b')\n A = A[-lng:]\n #print(A)\n slc = 0\n for j in range(lng):\n #print(j)\n #print(int(A[j]))\n if int(A[j]):\n #print(int(S[slc:j+1]))\n cnt += int(S[slc:j+1])\n #cnt += int(S[slc:j+1])\n slc = j +1\n #print(int(S[slc:]))\n cnt += int(S[slc:])",
"i",
"range(2**lng)",
"range",
"2**lng",
"2",
"lng",
"A = format(i, '09b')",
"A",
"format(i, '09b')",
"format",
"i",
"'09b'",
"A = A[-lng:]",
"A",
"A[-lng:]",
"A",
"-lng:",
"-lng",
"lng",
"slc = 0",
"slc",
"0",
"for j in range(lng):\n #print(j)\n #print(int(A[j]))\n if int(A[j]):\n #print(int(S[slc:j+1]))\n cnt += int(S[slc:j+1])\n #cnt += int(S[slc:j+1])\n slc = j +1\n #print(int(S[slc:]))\n ",
"j",
"range(lng)",
"range",
"lng",
"if int(A[j]):\n #print(int(S[slc:j+1]))\n cnt += int(S[slc:j+1])\n #cnt += int(S[slc:j+1])\n slc = j +1\n #print(int(S[slc:]))\n ",
"int(A[j])",
"int",
"A[j]",
"A",
"j",
"cnt += int(S[slc:j+1])",
"cnt",
"int(S[slc:j+1])",
"int",
"S[slc:j+1]",
"S",
"slc:j+1",
"slc",
"j+1",
"j",
"1",
"slc = j +1",
"slc",
"j +1",
"j",
"1",
"cnt += int(S[slc:])",
"cnt",
"int(S[slc:])",
"int",
"S[slc:]",
"S",
"slc:",
"slc",
"print(cnt)",
"print",
"cnt",
"lng = len(S) - 1",
"len(S) - 1",
"lng",
"cnt += int(S[slc:])",
"int(S[slc:])",
"cnt",
"cnt += int(S[slc:j+1])",
"int(S[slc:j+1])",
"cnt",
"S = input()",
"input()",
"S",
"A = A[-lng:]",
"A[-lng:]",
"A",
"slc = 0",
"0",
"slc",
"slc = j +1",
"j +1",
"slc",
"cnt = 0",
"0",
"cnt",
"A = format(i, '09b')",
"format(i, '09b')",
"A"
] | S = input()
lng = len(S) - 1
#print(lng)
cnt = 0
for i in range(2**lng):
A = format(i, '09b')
A = A[-lng:]
#print(A)
slc = 0
for j in range(lng):
#print(j)
#print(int(A[j]))
if int(A[j]):
#print(int(S[slc:j+1]))
cnt += int(S[slc:j+1])
#cnt += int(S[slc:j+1])
slc = j +1
#print(int(S[slc:]))
cnt += int(S[slc:])
print(cnt) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
2,
17,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13
] | [
[
85,
2
],
[
76,
8
],
[
86,
11
],
[
79,
13
],
[
17,
16
],
[
77,
22
],
[
82,
25
],
[
86,
27
],
[
31,
30
],
[
77,
34
],
[
16,
39
],
[
30,
40
],
[
67,
43
],
[
86,
47
],
[
30,
49
],
[
70,
52
],
[
86,
54
],
[
30,
56
],
[
73,
59
],
[
71,
62
],
[
68,
62
],
[
83,
62
],
[
74,
65
],
[
80,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
]
] | [
"s=list(input())\nn=len(s)\nans=0\nfor i in range(2**(n-1)):\n ball=s[0]\n for j in range(n-1):\n if (i>>j)&1:\n ball+=\"+\"+s[j+1]\n else:\n ball+=s[j+1]\n ans+=eval(ball)\nprint(ans)",
"s=list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"n=len(s)",
"n",
"len(s)",
"len",
"s",
"ans=0",
"ans",
"0",
"for i in range(2**(n-1)):\n ball=s[0]\n for j in range(n-1):\n if (i>>j)&1:\n ball+=\"+\"+s[j+1]\n else:\n ball+=s[j+1]\n ans+=eval(ball)",
"i",
"range(2**(n-1))",
"range",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"ball=s[0]",
"ball",
"s[0]",
"s",
"0",
"for j in range(n-1):\n if (i>>j)&1:\n ball+=\"+\"+s[j+1]\n else:\n ball+=s[j+1]\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i>>j)&1:\n ball+=\"+\"+s[j+1]\n else:\n ball+=s[j+1]\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"ball+=\"+\"+s[j+1]",
"ball",
"\"+\"+s[j+1]",
"\"+\"",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ball+=s[j+1]",
"ball",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ans+=eval(ball)",
"ans",
"eval(ball)",
"eval",
"ball",
"print(ans)",
"print",
"ans",
"ball+=\"+\"+s[j+1]",
"\"+\"+s[j+1]",
"ball",
"ball+=s[j+1]",
"s[j+1]",
"ball",
"ans+=eval(ball)",
"eval(ball)",
"ans",
"n=len(s)",
"len(s)",
"n",
"ans=0",
"0",
"ans",
"ball=s[0]",
"s[0]",
"ball",
"s=list(input())",
"list(input())",
"s"
] | s=list(input())
n=len(s)
ans=0
for i in range(2**(n-1)):
ball=s[0]
for j in range(n-1):
if (i>>j)&1:
ball+="+"+s[j+1]
else:
ball+=s[j+1]
ans+=eval(ball)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
13,
2,
2,
17,
13,
17,
0,
13,
17,
14,
2,
13,
17,
4,
13,
13,
4,
13,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
4,
13,
2,
2,
17,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
17,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
4,
13,
18,
4,
13,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
14,
2,
13,
2,
4,
13,
4,
13,
13,
17,
0,
13,
4,
13,
18,
4,
13,
13,
39,
13,
2,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
135,
2
],
[
129,
8
],
[
136,
13
],
[
130,
19
],
[
117,
22
],
[
130,
26
],
[
136,
30
],
[
35,
34
],
[
130,
40
],
[
126,
43
],
[
130,
50
],
[
34,
52
],
[
132,
54
],
[
58,
57
],
[
127,
65
],
[
127,
69
],
[
57,
70
],
[
120,
73
],
[
136,
79
],
[
57,
83
],
[
123,
86
],
[
57,
88
],
[
57,
92
],
[
127,
98
],
[
138,
101
],
[
136,
107
],
[
57,
111
],
[
139,
115
],
[
121,
115
],
[
118,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
]
] | [
"S=int(input())\nleng=len(str(S))\n\nbin(2**leng-1)\nans=0\nif leng==1:\n print(S)\n exit()\nfor i in range(2**(leng-1)):\n bid=bin(2**(leng-1)+i)\n start=0\n for j in range(3,len(str(bid))):\n if bid[j]=='1':\n ans+=int(str(S)[start:j-2])\n start=j-2\n if j==len(str(bid))-1:\n ans+=int(str(S)[start:j-1])\nprint(ans)",
"S=int(input())",
"S",
"int(input())",
"int",
"input()",
"input",
"leng=len(str(S))",
"leng",
"len(str(S))",
"len",
"str(S)",
"str",
"S",
"bin(2**leng-1)",
"bin",
"2**leng-1",
"2**leng",
"2",
"leng",
"1",
"ans=0",
"ans",
"0",
"if leng==1:\n print(S)\n exit()",
"leng==1",
"leng",
"1",
"print(S)",
"print",
"S",
"exit()",
"exit",
"for i in range(2**(leng-1)):\n bid=bin(2**(leng-1)+i)\n start=0\n for j in range(3,len(str(bid))):\n if bid[j]=='1':\n ans+=int(str(S)[start:j-2])\n start=j-2\n if j==len(str(bid))-1:\n ans+=int(str(S)[start:j-1])",
"i",
"range(2**(leng-1))",
"range",
"2**(leng-1)",
"2",
"leng-1",
"leng",
"1",
"bid=bin(2**(leng-1)+i)",
"bid",
"bin(2**(leng-1)+i)",
"bin",
"2**(leng-1)+i",
"2**(leng-1)",
"2",
"leng-1",
"leng",
"1",
"i",
"start=0",
"start",
"0",
"for j in range(3,len(str(bid))):\n if bid[j]=='1':\n ans+=int(str(S)[start:j-2])\n start=j-2\n if j==len(str(bid))-1:\n ans+=int(str(S)[start:j-1])",
"j",
"range(3,len(str(bid)))",
"range",
"3",
"len(str(bid))",
"len",
"str(bid)",
"str",
"bid",
"if bid[j]=='1':\n ans+=int(str(S)[start:j-2])\n start=j-2\n ",
"bid[j]=='1'",
"bid[j]",
"bid",
"j",
"'1'",
"ans+=int(str(S)[start:j-2])",
"ans",
"int(str(S)[start:j-2])",
"int",
"str(S)[start:j-2]",
"(S)",
"str",
"S",
"start:j-2",
"start",
"j-2",
"j",
"2",
"start=j-2",
"start",
"j-2",
"j",
"2",
"if j==len(str(bid))-1:\n ans+=int(str(S)[start:j-1])",
"j==len(str(bid))-1",
"j",
"len(str(bid))-1",
"len(str(bid))",
"len",
"str(bid)",
"str",
"bid",
"1",
"ans+=int(str(S)[start:j-1])",
"ans",
"int(str(S)[start:j-1])",
"int",
"str(S)[start:j-1]",
"(S)",
"str",
"S",
"start:j-1",
"start",
"j-1",
"j",
"1",
"print(ans)",
"print",
"ans",
"ans=0",
"0",
"ans",
"ans+=int(str(S)[start:j-2])",
"int(str(S)[start:j-2])",
"ans",
"start=j-2",
"j-2",
"start",
"bid=bin(2**(leng-1)+i)",
"bin(2**(leng-1)+i)",
"bid",
"leng=len(str(S))",
"len(str(S))",
"leng",
"start=0",
"0",
"start",
"S=int(input())",
"int(input())",
"S",
"ans+=int(str(S)[start:j-1])",
"int(str(S)[start:j-1])",
"ans"
] | S=int(input())
leng=len(str(S))
bin(2**leng-1)
ans=0
if leng==1:
print(S)
exit()
for i in range(2**(leng-1)):
bid=bin(2**(leng-1)+i)
start=0
for j in range(3,len(str(bid))):
if bid[j]=='1':
ans+=int(str(S)[start:j-2])
start=j-2
if j==len(str(bid))-1:
ans+=int(str(S)[start:j-1])
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
14,
2,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
13,
0,
13,
2,
4,
18,
4,
13,
13,
17,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] | [
[
85,
2
],
[
82,
6
],
[
86,
10
],
[
97,
13
],
[
83,
17
],
[
91,
20
],
[
86,
23
],
[
26,
25
],
[
83,
30
],
[
79,
32
],
[
25,
38
],
[
83,
41
],
[
100,
44
],
[
48,
47
],
[
83,
51
],
[
80,
56
],
[
47,
57
],
[
94,
60
],
[
86,
64
],
[
47,
68
],
[
88,
71
],
[
47,
73
],
[
95,
77
],
[
92,
77
],
[
98,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
]
] | [
"s=input()\nn=len(s)-1\n\nres=0\nif n==0:\n res=int(s)\n \nfor i in range(2**n):\n B=format(i,'b').zfill(n)+'1'\n left=0\n for j in range(n+1):\n if B[j]=='1':\n res+=int(s[left:j+1])\n left=j+1\n \nprint(res)\n",
"s=input()",
"s",
"input()",
"input",
"n=len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"res=0",
"res",
"0",
"if n==0:\n res=int(s)\n ",
"n==0",
"n",
"0",
"res=int(s)",
"res",
"int(s)",
"int",
"s",
"for i in range(2**n):\n B=format(i,'b').zfill(n)+'1'\n left=0\n for j in range(n+1):\n if B[j]=='1':\n res+=int(s[left:j+1])\n left=j+1\n ",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"B=format(i,'b').zfill(n)+'1'",
"B",
"format(i,'b').zfill(n)+'1'",
"format(i,'b').zfill(n)",
"(i,'b').zfill",
"(i,'b')",
"format",
"i",
"'b'",
"zfill",
"n",
"'1'",
"left=0",
"left",
"0",
"for j in range(n+1):\n if B[j]=='1':\n res+=int(s[left:j+1])\n left=j+1\n ",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if B[j]=='1':\n res+=int(s[left:j+1])\n left=j+1\n ",
"B[j]=='1'",
"B[j]",
"B",
"j",
"'1'",
"res+=int(s[left:j+1])",
"res",
"int(s[left:j+1])",
"int",
"s[left:j+1]",
"s",
"left:j+1",
"left",
"j+1",
"j",
"1",
"left=j+1",
"left",
"j+1",
"j",
"1",
"print(res)",
"print",
"res",
"B=format(i,'b').zfill(n)+'1'",
"format(i,'b').zfill(n)+'1'",
"B",
"n=len(s)-1",
"len(s)-1",
"n",
"s=input()",
"input()",
"s",
"left=j+1",
"j+1",
"left",
"res=int(s)",
"int(s)",
"res",
"res+=int(s[left:j+1])",
"int(s[left:j+1])",
"res",
"res=0",
"0",
"res",
"left=0",
"0",
"left"
] | s=input()
n=len(s)-1
res=0
if n==0:
res=int(s)
for i in range(2**n):
B=format(i,'b').zfill(n)+'1'
left=0
for j in range(n+1):
if B[j]=='1':
res+=int(s[left:j+1])
left=j+1
print(res)
|
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
2,
17,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13
] | [
[
81,
2
],
[
84,
6
],
[
82,
10
],
[
72,
13
],
[
17,
16
],
[
85,
21
],
[
87,
23
],
[
82,
25
],
[
29,
28
],
[
85,
31
],
[
16,
35
],
[
28,
36
],
[
78,
39
],
[
82,
43
],
[
28,
45
],
[
75,
48
],
[
82,
50
],
[
28,
52
],
[
90,
55
],
[
76,
65
],
[
79,
65
],
[
88,
65
],
[
91,
70
],
[
73,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
]
] | [
"S = input()\nblank_cnt = len(S) - 1\nans = 0\nfor i in range(2 ** blank_cnt):\n formula = S[0]\n for j in range(blank_cnt):\n if (i >> j) & 1:\n formula += \"+\" + S[j + 1]\n else:\n formula += S[j + 1]\n ans += sum(list(map(int, formula.split(\"+\"))))\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"blank_cnt = len(S) - 1",
"blank_cnt",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2 ** blank_cnt):\n formula = S[0]\n for j in range(blank_cnt):\n if (i >> j) & 1:\n formula += \"+\" + S[j + 1]\n else:\n formula += S[j + 1]\n ans += sum(list(map(int, formula.split(\"+\"))))",
"i",
"range(2 ** blank_cnt)",
"range",
"2 ** blank_cnt",
"2",
"blank_cnt",
"formula = S[0]",
"formula",
"S[0]",
"S",
"0",
"for j in range(blank_cnt):\n if (i >> j) & 1:\n formula += \"+\" + S[j + 1]\n else:\n formula += S[j + 1]\n ",
"j",
"range(blank_cnt)",
"range",
"blank_cnt",
"if (i >> j) & 1:\n formula += \"+\" + S[j + 1]\n else:\n formula += S[j + 1]\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"formula += \"+\" + S[j + 1]",
"formula",
"\"+\" + S[j + 1]",
"\"+\"",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"formula += S[j + 1]",
"formula",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"ans += sum(list(map(int, formula.split(\"+\"))))",
"ans",
"sum(list(map(int, formula.split(\"+\"))))",
"sum",
"list(map(int, formula.split(\"+\")))",
"list",
"map(int, formula.split(\"+\"))",
"map",
"int",
"formula.split(\"+\")",
"formula.split",
"formula",
"split",
"\"+\"",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"formula += S[j + 1]",
"S[j + 1]",
"formula",
"formula += \"+\" + S[j + 1]",
"\"+\" + S[j + 1]",
"formula",
"S = input()",
"input()",
"S",
"blank_cnt = len(S) - 1",
"len(S) - 1",
"blank_cnt",
"formula = S[0]",
"S[0]",
"formula",
"ans += sum(list(map(int, formula.split(\"+\"))))",
"sum(list(map(int, formula.split(\"+\"))))",
"ans"
] | S = input()
blank_cnt = len(S) - 1
ans = 0
for i in range(2 ** blank_cnt):
formula = S[0]
for j in range(blank_cnt):
if (i >> j) & 1:
formula += "+" + S[j + 1]
else:
formula += S[j + 1]
ans += sum(list(map(int, formula.split("+"))))
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
12,
13,
41,
14,
2,
13,
13,
0,
13,
4,
13,
13,
29,
4,
13,
2,
13,
17,
2,
13,
18,
13,
13,
14,
40,
13,
2,
13,
17,
23,
13,
23,
13,
17,
4,
13,
17,
4,
13,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
60,
2
],
[
63,
6
],
[
61,
9
],
[
54,
11
],
[
43,
18
],
[
64,
19
],
[
22,
21
],
[
45,
24
],
[
43,
29
],
[
45,
32
],
[
61,
34
],
[
43,
35
],
[
43,
38
],
[
64,
40
],
[
43,
43
],
[
46,
45
],
[
58,
48
],
[
55,
52
],
[
54,
55
],
[
60,
61
],
[
63,
64
]
] | [
"n=input()\ns=len(n)\nans=0\ndef f(i,cur=\"\"):\n global ans\n #print(i,cur)\n if(i==s):\n ans+=eval(cur)\n return\n f(i+1,cur+n[i])\n if(i!=s-1):f(i+1,cur+n[i]+'+')\nf(0)\nprint(ans)",
"n=input()",
"n",
"input()",
"input",
"s=len(n)",
"s",
"len(n)",
"len",
"n",
"ans=0",
"ans",
"0",
"def f(i,cur=\"\"):\n global ans\n #print(i,cur)\n if(i==s):\n ans+=eval(cur)\n return\n f(i+1,cur+n[i])\n if(i!=s-1):f(i+1,cur+n[i]+'+')",
"f",
"global ans",
"if(i==s):\n ans+=eval(cur)\n return\n ",
"i==s",
"i",
"s",
"ans+=eval(cur)",
"ans",
"eval(cur)",
"eval",
"cur",
"return",
"f(i+1,cur+n[i])",
"f",
"i+1",
"i",
"1",
"cur+n[i]",
"cur",
"n[i]",
"n",
"i",
"if(i!=s-1):f(i+1,cur+n[i]+",
"i!=s-1",
"i",
"s-1",
"s",
"1",
"i",
"i",
"cur=\"\"",
"cur",
"\"\"",
"f(0)",
"f",
"0",
"print(ans)",
"print",
"ans",
"ans=0",
"0",
"ans",
"def f(i,cur=\"\"):\n global ans\n #print(i,cur)\n if(i==s):\n ans+=eval(cur)\n return\n f(i+1,cur+n[i])\n if(i!=s-1):f(i+1,cur+n[i]+'+')",
"def f(i,cur=\"\"):\n global ans\n #print(i,cur)\n if(i==s):\n ans+=eval(cur)\n return\n f(i+1,cur+n[i])\n if(i!=s-1):f(i+1,cur+n[i]+'+')",
"f",
"n=input()",
"input()",
"n",
"s=len(n)",
"len(n)",
"s"
] | n=input()
s=len(n)
ans=0
def f(i,cur=""):
global ans
#print(i,cur)
if(i==s):
ans+=eval(cur)
return
f(i+1,cur+n[i])
if(i!=s-1):f(i+1,cur+n[i]+'+')
f(0)
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
2,
17,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13
] | [
[
66,
2
],
[
72,
6
],
[
67,
10
],
[
75,
13
],
[
17,
16
],
[
73,
21
],
[
78,
23
],
[
67,
25
],
[
29,
28
],
[
73,
31
],
[
16,
35
],
[
28,
36
],
[
81,
39
],
[
67,
43
],
[
28,
45
],
[
69,
48
],
[
67,
50
],
[
28,
52
],
[
63,
55
],
[
70,
58
],
[
82,
58
],
[
79,
58
],
[
64,
61
],
[
76,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
]
] | [
"s = input()\nn = len(s) - 1\nans = 0\nfor i in range(1 << n):\n formula = s[0]\n for j in range(n):\n if ((i >> j) & 1):\n formula += '+' + s[j + 1]\n else:\n formula += s[j + 1]\n ans += eval(formula)\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"for i in range(1 << n):\n formula = s[0]\n for j in range(n):\n if ((i >> j) & 1):\n formula += '+' + s[j + 1]\n else:\n formula += s[j + 1]\n ans += eval(formula)",
"i",
"range(1 << n)",
"range",
"1 << n",
"1",
"n",
"formula = s[0]",
"formula",
"s[0]",
"s",
"0",
"for j in range(n):\n if ((i >> j) & 1):\n formula += '+' + s[j + 1]\n else:\n formula += s[j + 1]\n ",
"j",
"range(n)",
"range",
"n",
"if ((i >> j) & 1):\n formula += '+' + s[j + 1]\n else:\n formula += s[j + 1]\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"formula += '+' + s[j + 1]",
"formula",
"'+' + s[j + 1]",
"'+'",
"s[j + 1]",
"s",
"j + 1",
"j",
"1",
"formula += s[j + 1]",
"formula",
"s[j + 1]",
"s",
"j + 1",
"j",
"1",
"ans += eval(formula)",
"ans",
"eval(formula)",
"eval",
"formula",
"print(ans)",
"print",
"ans",
"ans += eval(formula)",
"eval(formula)",
"ans",
"s = input()",
"input()",
"s",
"formula += s[j + 1]",
"s[j + 1]",
"formula",
"n = len(s) - 1",
"len(s) - 1",
"n",
"ans = 0",
"0",
"ans",
"formula = s[0]",
"s[0]",
"formula",
"formula += '+' + s[j + 1]",
"'+' + s[j + 1]",
"formula"
] | s = input()
n = len(s) - 1
ans = 0
for i in range(1 << n):
formula = s[0]
for j in range(n):
if ((i >> j) & 1):
formula += '+' + s[j + 1]
else:
formula += s[j + 1]
ans += eval(formula)
print(ans)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
39,
17,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
18,
13,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13
] | [
[
89,
4
],
[
95,
10
],
[
90,
13
],
[
86,
15
],
[
27,
26
],
[
96,
28
],
[
98,
31
],
[
35,
34
],
[
87,
34
],
[
101,
37
],
[
41,
40
],
[
96,
44
],
[
102,
48
],
[
90,
51
],
[
40,
52
],
[
102,
55
],
[
34,
58
],
[
40,
59
],
[
102,
62
],
[
90,
65
],
[
92,
68
],
[
102,
73
],
[
83,
75
],
[
93,
78
],
[
84,
81
],
[
99,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
]
] | [
"# ARC061A\n\nimport itertools\n\ns = list(input())\nn = len(s)\nbin = list(itertools.product(['', '+'''], repeat=n - 1))\ncount = 0\nfor i in bin:\n t = []\n for j in range(n-1):\n t.append(s[j])\n t.append(i[j])\n t.append(s[-1])\n formula = ''.join(t)\n # print(t)\n count += eval(formula)\nprint(count)",
"import itertools",
"itertools",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"bin = list(itertools.product(['', '+'''], repeat=n - 1))",
"bin",
"list(itertools.product(['', '+'''], repeat=n - 1))",
"list",
"itertools.product(['', '+'''], repeat=n - 1)",
"itertools.product",
"itertools",
"product",
"['', '+''']",
"''",
"'+'''",
"repeat=n - 1",
"repeat",
"n - 1",
"n",
"1",
"count = 0",
"count",
"0",
"for i in bin:\n t = []\n for j in range(n-1):\n t.append(s[j])\n t.append(i[j])\n t.append(s[-1])\n formula = ''.join(t)\n # print(t)\n count += eval(formula)",
"i",
"bin",
"t = []",
"t",
"[]",
"for j in range(n-1):\n t.append(s[j])\n t.append(i[j])\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"t.append(s[j])",
"t.append",
"t",
"append",
"s[j]",
"s",
"j",
"t.append(i[j])",
"t.append",
"t",
"append",
"i[j]",
"i",
"j",
"t.append(s[-1])",
"t.append",
"t",
"append",
"s[-1]",
"s",
"-1",
"formula = ''.join(t)",
"formula",
"''.join(t)",
"''.join",
"''",
"join",
"t",
"count += eval(formula)",
"count",
"eval(formula)",
"eval",
"formula",
"print(count)",
"print",
"count",
"count += eval(formula)",
"eval(formula)",
"count",
"bin = list(itertools.product(['', '+'''], repeat=n - 1))",
"list(itertools.product(['', '+'''], repeat=n - 1))",
"bin",
"s = list(input())",
"list(input())",
"s",
"formula = ''.join(t)",
"''.join(t)",
"formula",
"n = len(s)",
"len(s)",
"n",
"count = 0",
"0",
"count",
"t = []",
"[]",
"t"
] | # ARC061A
import itertools
s = list(input())
n = len(s)
bin = list(itertools.product(['', '+'''], repeat=n - 1))
count = 0
for i in bin:
t = []
for j in range(n-1):
t.append(s[j])
t.append(i[j])
t.append(s[-1])
formula = ''.join(t)
# print(t)
count += eval(formula)
print(count)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
17,
13,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
13,
13,
17,
0,
13,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
0,
13,
4,
18,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
111,
4
],
[
87,
10
],
[
112,
14
],
[
99,
17
],
[
105,
20
],
[
108,
23
],
[
112,
28
],
[
31,
30
],
[
88,
35
],
[
38,
37
],
[
88,
40
],
[
30,
44
],
[
37,
45
],
[
109,
49
],
[
94,
49
],
[
37,
52
],
[
100,
53
],
[
85,
53
],
[
91,
53
],
[
84,
56
],
[
96,
59
],
[
109,
64
],
[
94,
64
],
[
102,
66
],
[
97,
69
],
[
90,
71
],
[
93,
74
],
[
112,
79
],
[
103,
82
],
[
106,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
]
] | [
"import copy\nS = list(input())\nL = len(S)-1 #้ทใ\ntmp = 1\nans = 0\nlocate = copy.deepcopy(S)\nfor i in range (2**L):\n for j in range(L):\n if (i >> j) & 1:\n locate.insert(j+tmp,'+')\n tmp += 1 \n locateSTR = \"\".join(locate)\n ans += (eval(locateSTR))\n tmp = 1\n locate = copy.deepcopy(S)\n \nprint(ans)",
"import copy",
"copy",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"L = len(S)-1",
"L",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"tmp = 1",
"tmp",
"1",
"ans = 0",
"ans",
"0",
"locate = copy.deepcopy(S)",
"locate",
"copy.deepcopy(S)",
"copy.deepcopy",
"copy",
"deepcopy",
"S",
"for i in range (2**L):\n for j in range(L):\n if (i >> j) & 1:\n locate.insert(j+tmp,'+')\n tmp += 1 \n locateSTR = \"\".join(locate)\n ans += (eval(locateSTR))\n tmp = 1\n locate = copy.deepcopy(S)\n ",
"i",
"range (2**L)",
"range",
"2**L",
"2",
"L",
"for j in range(L):\n if (i >> j) & 1:\n locate.insert(j+tmp,'+')\n tmp += 1 \n ",
"j",
"range(L)",
"range",
"L",
"if (i >> j) & 1:\n locate.insert(j+tmp,'+')\n tmp += 1 \n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"locate.insert(j+tmp,'+')",
"locate.insert",
"locate",
"insert",
"j+tmp",
"j",
"tmp",
"'+'",
"tmp += 1",
"tmp",
"1",
"locateSTR = \"\".join(locate)",
"locateSTR",
"\"\".join(locate)",
"\"\".join",
"\"\"",
"join",
"locate",
"ans += (eval(locateSTR))",
"ans",
"eval(locateSTR)",
"eval",
"locateSTR",
"tmp = 1",
"tmp",
"1",
"locate = copy.deepcopy(S)",
"locate",
"copy.deepcopy(S)",
"copy.deepcopy",
"copy",
"deepcopy",
"S",
"print(ans)",
"print",
"ans",
"tmp += 1",
"1",
"tmp",
"L = len(S)-1",
"len(S)-1",
"L",
"tmp = 1",
"1",
"tmp",
"locate = copy.deepcopy(S)",
"copy.deepcopy(S)",
"locate",
"locateSTR = \"\".join(locate)",
"\"\".join(locate)",
"locateSTR",
"tmp = 1",
"1",
"tmp",
"ans += (eval(locateSTR))",
"eval(locateSTR)",
"ans",
"ans = 0",
"0",
"ans",
"locate = copy.deepcopy(S)",
"copy.deepcopy(S)",
"locate",
"S = list(input())",
"list(input())",
"S"
] | import copy
S = list(input())
L = len(S)-1 #้ทใ
tmp = 1
ans = 0
locate = copy.deepcopy(S)
for i in range (2**L):
for j in range(L):
if (i >> j) & 1:
locate.insert(j+tmp,'+')
tmp += 1
locateSTR = "".join(locate)
ans += (eval(locateSTR))
tmp = 1
locate = copy.deepcopy(S)
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
18,
13,
13,
0,
13,
17,
0,
13,
18,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13
] | [
[
82,
2
],
[
91,
6
],
[
83,
9
],
[
70,
11
],
[
15,
14
],
[
92,
20
],
[
67,
23
],
[
27,
26
],
[
92,
30
],
[
14,
35
],
[
26,
36
],
[
85,
39
],
[
83,
41
],
[
26,
42
],
[
79,
44
],
[
88,
47
],
[
83,
49
],
[
26,
50
],
[
73,
52
],
[
83,
54
],
[
92,
56
],
[
76,
59
],
[
74,
62
],
[
89,
62
],
[
80,
62
],
[
86,
62
],
[
68,
62
],
[
77,
65
],
[
71,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] | [
"#bitไฝฟใversion\nS = input()\nN = len(S)\nres = 0\nfor i in range(2**(N-1)):\n formula = \"\"\n for j in range(N-1):\n if (i>>j) & 1: \n formula += S[j]\n formula += \"+\"\n else:\n formula += S[j]\n formula += S[N-1]\n res += eval(formula)\nprint(res) ",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"res = 0",
"res",
"0",
"for i in range(2**(N-1)):\n formula = \"\"\n for j in range(N-1):\n if (i>>j) & 1: \n formula += S[j]\n formula += \"+\"\n else:\n formula += S[j]\n formula += S[N-1]\n res += eval(formula)",
"i",
"range(2**(N-1))",
"range",
"2**(N-1)",
"2",
"N-1",
"N",
"1",
"formula = \"\"",
"formula",
"\"\"",
"for j in range(N-1):\n if (i>>j) & 1: \n formula += S[j]\n formula += \"+\"\n else:\n formula += S[j]\n ",
"j",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if (i>>j) & 1: \n formula += S[j]\n formula += \"+\"\n else:\n formula += S[j]\n ",
"(i>>j) & 1",
"i>>j",
"i",
"j",
"1",
"formula += S[j]",
"formula",
"S[j]",
"S",
"j",
"formula += \"+\"",
"formula",
"\"+\"",
"formula += S[j]",
"formula",
"S[j]",
"S",
"j",
"formula += S[N-1]",
"formula",
"S[N-1]",
"S",
"N-1",
"N",
"1",
"res += eval(formula)",
"res",
"eval(formula)",
"eval",
"formula",
"print(res)",
"print",
"res",
"formula = \"\"",
"\"\"",
"formula",
"res = 0",
"0",
"res",
"formula += S[N-1]",
"S[N-1]",
"formula",
"res += eval(formula)",
"eval(formula)",
"res",
"formula += \"+\"",
"\"+\"",
"formula",
"S = input()",
"input()",
"S",
"formula += S[j]",
"S[j]",
"formula",
"formula += S[j]",
"S[j]",
"formula",
"N = len(S)",
"len(S)",
"N"
] | #bitไฝฟใversion
S = input()
N = len(S)
res = 0
for i in range(2**(N-1)):
formula = ""
for j in range(N-1):
if (i>>j) & 1:
formula += S[j]
formula += "+"
else:
formula += S[j]
formula += S[N-1]
res += eval(formula)
print(res) |
[
7,
0,
13,
4,
13,
0,
13,
39,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
18,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
17,
4,
18,
13,
13,
13,
41,
28,
13,
13,
4,
4,
13,
13,
0,
13,
13,
4,
13,
4,
13,
13,
10,
39,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13
] | [
[
71,
2
],
[
65,
6
],
[
10,
9
],
[
72,
17
],
[
74,
20
],
[
24,
23
],
[
72,
28
],
[
77,
30
],
[
72,
32
],
[
23,
33
],
[
9,
37
],
[
23,
38
],
[
80,
41
],
[
66,
45
],
[
81,
47
],
[
78,
47
],
[
75,
47
],
[
51,
50
],
[
66,
50
],
[
50,
55
],
[
68,
57
],
[
69,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
]
] | [
"S = input()\n\nres_list = []\n\nfor i in range(2**(len(S)-1)):\n temp_s = ''\n for j in range(len(S)):\n temp_s += S[j]\n if ((i >> j) & 1):\n temp_s += '+'\n # print(temp_s)\n res_list.append(temp_s)\n\ntemp_S_list = [eval(item) for item in res_list]\n\nprint(sum(temp_S_list))",
"S = input()",
"S",
"input()",
"input",
"res_list = []",
"res_list",
"[]",
"for i in range(2**(len(S)-1)):\n temp_s = ''\n for j in range(len(S)):\n temp_s += S[j]\n if ((i >> j) & 1):\n temp_s += '+'\n # print(temp_s)\n res_list.append(temp_s)",
"i",
"range(2**(len(S)-1))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"temp_s = ''",
"temp_s",
"''",
"for j in range(len(S)):\n temp_s += S[j]\n if ((i >> j) & 1):\n temp_s += '+'\n # print(temp_s)\n ",
"j",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"temp_s += S[j]",
"temp_s",
"S[j]",
"S",
"j",
"if ((i >> j) & 1):\n temp_s += '+'\n # print(temp_s)\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"temp_s += '+'",
"temp_s",
"'+'",
"res_list.append(temp_s)",
"res_list.append",
"res_list",
"append",
"temp_s",
"eval(item) for item in res_list",
"for item in res_list",
"item",
"res_list",
"for item in res_list",
"eval(item)",
"eval",
"item",
"temp_S_list = [eval(item) for item in res_list]",
"temp_S_list",
"[eval(item) for item in res_list]",
"print(sum(temp_S_list))",
"print",
"sum(temp_S_list)",
"sum",
"temp_S_list",
"res_list = []",
"[]",
"res_list",
"temp_S_list = [eval(item) for item in res_list]",
"[eval(item) for item in res_list]",
"temp_S_list",
"S = input()",
"input()",
"S",
"temp_s = ''",
"''",
"temp_s",
"temp_s += S[j]",
"S[j]",
"temp_s",
"temp_s += '+'",
"'+'",
"temp_s"
] | S = input()
res_list = []
for i in range(2**(len(S)-1)):
temp_s = ''
for j in range(len(S)):
temp_s += S[j]
if ((i >> j) & 1):
temp_s += '+'
# print(temp_s)
res_list.append(temp_s)
temp_S_list = [eval(item) for item in res_list]
print(sum(temp_S_list)) |
[
7,
0,
13,
4,
13,
12,
13,
0,
13,
17,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
13,
0,
13,
4,
13,
2,
13,
17,
2,
2,
13,
17,
18,
13,
2,
13,
17,
0,
13,
4,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
29,
13,
23,
13,
23,
13,
18,
13,
17,
4,
13,
4,
13,
17,
10,
12,
13,
10,
4,
13
] | [
[
70,
2
],
[
9,
8
],
[
55,
12
],
[
71,
16
],
[
57,
21
],
[
24,
23
],
[
55,
27
],
[
57,
31
],
[
71,
34
],
[
55,
36
],
[
40,
39
],
[
55,
43
],
[
57,
46
],
[
71,
48
],
[
55,
50
],
[
39,
53
],
[
23,
53
],
[
8,
53
],
[
55,
55
],
[
58,
57
],
[
71,
59
],
[
68,
64
],
[
70,
71
]
] | [
"S = input()\n\ndef saiki(n, s=S[0]):\n _sum = 0\n \n if n==len(S)-1:\n# print(s)\n return eval(s)\n \n _sum += saiki(n+1, s + \"+\" + S[n+1])\n _sum += saiki(n+1, s + S[n+1])\n \n return _sum\n \nprint(saiki(0))",
"S = input()",
"S",
"input()",
"input",
"def saiki(n, s=S[0]):\n _sum = 0\n \n if n==len(S)-1:\n# print(s)\n return eval(s)\n \n _sum += saiki(n+1, s + \"+\" + S[n+1])\n _sum += saiki(n+1, s + S[n+1])\n \n return _sum\n ",
"saiki",
"_sum = 0",
"_sum",
"0",
"if n==len(S)-1:\n# print(s)\n return eval(s)\n \n ",
"n==len(S)-1",
"n",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"return eval(s)",
"eval(s)",
"eval",
"s",
"_sum += saiki(n+1, s + \"+\" + S[n+1])",
"_sum",
"saiki(n+1, s + \"+\" + S[n+1])",
"saiki",
"n+1",
"n",
"1",
"s + \"+\" + S[n+1]",
"s + \"+\"",
"s",
"\"+\"",
"S[n+1]",
"S",
"n+1",
"n",
"1",
"_sum += saiki(n+1, s + S[n+1])",
"_sum",
"saiki(n+1, s + S[n+1])",
"saiki",
"n+1",
"n",
"1",
"s + S[n+1]",
"s",
"S[n+1]",
"S",
"n+1",
"n",
"1",
"return _sum",
"_sum",
"n",
"n",
"s=S[0]",
"s",
"S[0]",
"S",
"0",
"print(saiki(0))",
"print",
"saiki(0)",
"saiki",
"0",
"def saiki(n, s=S[0]):\n _sum = 0\n \n if n==len(S)-1:\n# print(s)\n return eval(s)\n \n _sum += saiki(n+1, s + \"+\" + S[n+1])\n _sum += saiki(n+1, s + S[n+1])\n \n return _sum\n ",
"def saiki(n, s=S[0]):\n _sum = 0\n \n if n==len(S)-1:\n# print(s)\n return eval(s)\n \n _sum += saiki(n+1, s + \"+\" + S[n+1])\n _sum += saiki(n+1, s + S[n+1])\n \n return _sum\n ",
"saiki",
"S = input()",
"input()",
"S"
] | S = input()
def saiki(n, s=S[0]):
_sum = 0
if n==len(S)-1:
# print(s)
return eval(s)
_sum += saiki(n+1, s + "+" + S[n+1])
_sum += saiki(n+1, s + S[n+1])
return _sum
print(saiki(0)) |
[
7,
15,
13,
12,
13,
29,
4,
18,
18,
13,
13,
13,
12,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
13,
2,
17,
13,
4,
18,
13,
13,
13,
14,
2,
4,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
39,
28,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
18,
13,
13,
18,
13,
39,
2,
13,
17,
4,
18,
13,
13,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
18,
13,
39,
2,
2,
13,
17,
13,
4,
18,
13,
13,
18,
13,
39,
2,
2,
13,
17,
13,
0,
13,
2,
13,
17,
28,
13,
13,
4,
18,
13,
13,
13,
28,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
16,
15
],
[
176,
19
],
[
23,
22
],
[
26,
25
],
[
29,
28
],
[
15,
36
],
[
40,
39
],
[
43,
42
],
[
15,
48
],
[
28,
52
],
[
42,
55
],
[
39,
58
],
[
42,
60
],
[
39,
65
],
[
25,
69
],
[
15,
71
],
[
74,
73
],
[
77,
76
],
[
39,
83
],
[
76,
90
],
[
15,
93
],
[
76,
100
],
[
15,
103
],
[
110,
109
],
[
115,
114
],
[
76,
117
],
[
76,
122
],
[
114,
125
],
[
73,
131
],
[
145,
131
],
[
109,
131
],
[
76,
134
],
[
114,
137
],
[
73,
143
],
[
145,
143
],
[
109,
143
],
[
146,
145
],
[
151,
150
],
[
76,
150
],
[
25,
154
],
[
150,
156
],
[
159,
158
],
[
25,
158
],
[
162,
161
],
[
158,
164
],
[
161,
167
],
[
22,
167
],
[
179,
173
]
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\nimport sys\n\n\ndef input():\n return sys.stdin.readline()\n\n\ndef resolve():\n s = input().rstrip()\n\n ans = 0\n int_list = []\n for bit in range(1<<len(s)-1):\n\n plus_list = []\n for i in range(len(s)-1):\n #print(bit, i)\n if bit & (1<<i):\n plus_list.append(i)\n\n #print(plus_list)\n\n if len(plus_list) == 0:\n int_list.append(s)\n else:\n pre = 0\n temp_list = []\n for i, plus in enumerate(plus_list):\n if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n for s2 in temp_list:\n int_list.append(s2)\n\n\n #print(bit, i, int_list)\n\n\n for num in int_list:\n ans += int(num)\n\n\n\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n resolve()",
"import sys",
"sys",
"def input():\n return sys.stdin.readline()",
"input",
"return sys.stdin.readline()",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def resolve():\n s = input().rstrip()\n\n ans = 0\n int_list = []\n for bit in range(1<<len(s)-1):\n\n plus_list = []\n for i in range(len(s)-1):\n #print(bit, i)\n if bit & (1<<i):\n plus_list.append(i)\n\n #print(plus_list)\n\n if len(plus_list) == 0:\n int_list.append(s)\n else:\n pre = 0\n temp_list = []\n for i, plus in enumerate(plus_list):\n if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n for s2 in temp_list:\n int_list.append(s2)\n\n\n #print(bit, i, int_list)\n\n\n for num in int_list:\n ans += int(num)\n\n\n\n\n print(ans)",
"resolve",
"s = input().rstrip()",
"s",
"input().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"ans = 0",
"ans",
"0",
"int_list = []",
"int_list",
"[]",
"for bit in range(1<<len(s)-1):\n\n plus_list = []\n for i in range(len(s)-1):\n #print(bit, i)\n if bit & (1<<i):\n plus_list.append(i)\n\n #print(plus_list)\n\n if len(plus_list) == 0:\n int_list.append(s)\n else:\n pre = 0\n temp_list = []\n for i, plus in enumerate(plus_list):\n if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n for s2 in temp_list:\n int_list.append(s2)\n\n\n #print(bit, i, int_list)\n\n\n ",
"bit",
"range(1<<len(s)-1)",
"range",
"1<<len(s)-1",
"1",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"plus_list = []",
"plus_list",
"[]",
"for i in range(len(s)-1):\n #print(bit, i)\n if bit & (1<<i):\n plus_list.append(i)\n\n #print(plus_list)\n\n ",
"i",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if bit & (1<<i):\n plus_list.append(i)\n\n #print(plus_list)\n\n ",
"bit & (1<<i)",
"bit",
"1<<i",
"1",
"i",
"plus_list.append(i)",
"plus_list.append",
"plus_list",
"append",
"i",
"if len(plus_list) == 0:\n int_list.append(s)\n else:\n pre = 0\n temp_list = []\n for i, plus in enumerate(plus_list):\n if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n for s2 in temp_list:\n int_list.append(s2)\n\n\n #print(bit, i, int_list)\n\n\n ",
"len(plus_list) == 0",
"len(plus_list)",
"len",
"plus_list",
"0",
"int_list.append(s)",
"int_list.append",
"int_list",
"append",
"s",
"pre = 0",
"pre",
"0",
"temp_list = []",
"temp_list",
"[]",
"for i, plus in enumerate(plus_list):\n if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n ",
"i",
"plus",
"enumerate(plus_list)",
"enumerate",
"plus_list",
"if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n ",
"i == 0",
"i",
"0",
"temp_list.append(s[:plus+1])",
"temp_list.append",
"temp_list",
"append",
"s[:plus+1]",
"s",
":plus+1",
"plus+1",
"plus",
"1",
"temp_list.append(s[plus+1:])",
"temp_list.append",
"temp_list",
"append",
"s[plus+1:]",
"s",
"plus+1:",
"plus+1",
"plus",
"1",
"pre = plus+1",
"pre",
"plus+1",
"plus",
"1",
"temp_s = temp_list.pop(i)",
"temp_s",
"temp_list.pop(i)",
"temp_list.pop",
"temp_list",
"pop",
"i",
"temp_list.append(temp_s[:plus+1-pre])",
"temp_list.append",
"temp_list",
"append",
"temp_s[:plus+1-pre]",
"temp_s",
":plus+1-pre",
"plus+1-pre",
"plus+1",
"plus",
"1",
"pre",
"temp_list.append(temp_s[plus+1-pre:])",
"temp_list.append",
"temp_list",
"append",
"temp_s[plus+1-pre:]",
"temp_s",
"plus+1-pre:",
"plus+1-pre",
"plus+1",
"plus",
"1",
"pre",
"pre = plus+1",
"pre",
"plus+1",
"plus",
"1",
"for s2 in temp_list:\n int_list.append(s2)\n\n\n #print(bit, i, int_list)\n\n\n ",
"s2",
"temp_list",
"int_list.append(s2)",
"int_list.append",
"int_list",
"append",
"s2",
"for num in int_list:\n ans += int(num)\n\n\n\n\n ",
"num",
"int_list",
"ans += int(num)",
"ans",
"int(num)",
"int",
"num",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n resolve()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"resolve()",
"resolve",
"def input():\n return sys.stdin.readline()",
"def input():\n return sys.stdin.readline()",
"input",
"def resolve():\n s = input().rstrip()\n\n ans = 0\n int_list = []\n for bit in range(1<<len(s)-1):\n\n plus_list = []\n for i in range(len(s)-1):\n #print(bit, i)\n if bit & (1<<i):\n plus_list.append(i)\n\n #print(plus_list)\n\n if len(plus_list) == 0:\n int_list.append(s)\n else:\n pre = 0\n temp_list = []\n for i, plus in enumerate(plus_list):\n if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n for s2 in temp_list:\n int_list.append(s2)\n\n\n #print(bit, i, int_list)\n\n\n for num in int_list:\n ans += int(num)\n\n\n\n\n print(ans)",
"def resolve():\n s = input().rstrip()\n\n ans = 0\n int_list = []\n for bit in range(1<<len(s)-1):\n\n plus_list = []\n for i in range(len(s)-1):\n #print(bit, i)\n if bit & (1<<i):\n plus_list.append(i)\n\n #print(plus_list)\n\n if len(plus_list) == 0:\n int_list.append(s)\n else:\n pre = 0\n temp_list = []\n for i, plus in enumerate(plus_list):\n if i == 0:\n temp_list.append(s[:plus+1])\n temp_list.append(s[plus+1:])\n pre = plus+1\n else:\n temp_s = temp_list.pop(i)\n temp_list.append(temp_s[:plus+1-pre])\n temp_list.append(temp_s[plus+1-pre:])\n pre = plus+1\n\n for s2 in temp_list:\n int_list.append(s2)\n\n\n #print(bit, i, int_list)\n\n\n for num in int_list:\n ans += int(num)\n\n\n\n\n print(ans)",
"resolve"
] | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline()
def resolve():
s = input().rstrip()
ans = 0
int_list = []
for bit in range(1<<len(s)-1):
plus_list = []
for i in range(len(s)-1):
#print(bit, i)
if bit & (1<<i):
plus_list.append(i)
#print(plus_list)
if len(plus_list) == 0:
int_list.append(s)
else:
pre = 0
temp_list = []
for i, plus in enumerate(plus_list):
if i == 0:
temp_list.append(s[:plus+1])
temp_list.append(s[plus+1:])
pre = plus+1
else:
temp_s = temp_list.pop(i)
temp_list.append(temp_s[:plus+1-pre])
temp_list.append(temp_s[plus+1-pre:])
pre = plus+1
for s2 in temp_list:
int_list.append(s2)
#print(bit, i, int_list)
for num in int_list:
ans += int(num)
print(ans)
if __name__ == "__main__":
resolve() |
[
7,
15,
0,
13,
4,
13,
0,
13,
4,
13,
39,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
18,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13
] | [
[
65,
3
],
[
74,
7
],
[
15,
14
],
[
66,
18
],
[
71,
21
],
[
25,
24
],
[
75,
24
],
[
62,
27
],
[
24,
34
],
[
56,
36
],
[
66,
39
],
[
68,
43
],
[
66,
45
],
[
59,
48
],
[
69,
51
],
[
57,
51
],
[
63,
51
],
[
60,
54
],
[
72,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] | [
"from itertools import permutations, combinations,combinations_with_replacement,product\ns = input()\nt = product([\"+\",\"\"],repeat=len(s)-1)\nsum=0\nfor i1 in t:\n calc = \"\"\n for j,i2 in enumerate(i1):\n calc+=s[j]+i2\n calc += s[-1]\n sum+=eval(calc)\n\nprint(sum)",
"from itertools import permutations, combinations,combinations_with_replacement,product",
"s = input()",
"s",
"input()",
"input",
"t = product([\"+\",\"\"],repeat=len(s)-1)",
"t",
"product([\"+\",\"\"],repeat=len(s)-1)",
"product",
"[\"+\",\"\"]",
"\"+\"",
"\"\"",
"repeat=len(s)-1",
"repeat",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"sum=0",
"sum",
"0",
"for i1 in t:\n calc = \"\"\n for j,i2 in enumerate(i1):\n calc+=s[j]+i2\n calc += s[-1]\n sum+=eval(calc)",
"i1",
"t",
"calc = \"\"",
"calc",
"\"\"",
"for j,i2 in enumerate(i1):\n calc+=s[j]+i2\n ",
"j",
"i2",
"enumerate(i1)",
"enumerate",
"i1",
"calc+=s[j]+i2",
"calc",
"s[j]+i2",
"s[j]",
"s",
"j",
"i2",
"calc += s[-1]",
"calc",
"s[-1]",
"s",
"-1",
"sum+=eval(calc)",
"sum",
"eval(calc)",
"eval",
"calc",
"print(sum)",
"print",
"sum",
"calc+=s[j]+i2",
"s[j]+i2",
"calc",
"sum+=eval(calc)",
"eval(calc)",
"sum",
"calc = \"\"",
"\"\"",
"calc",
"s = input()",
"input()",
"s",
"calc += s[-1]",
"s[-1]",
"calc",
"sum=0",
"0",
"sum",
"t = product([\"+\",\"\"],repeat=len(s)-1)",
"product([\"+\",\"\"],repeat=len(s)-1)",
"t"
] | from itertools import permutations, combinations,combinations_with_replacement,product
s = input()
t = product(["+",""],repeat=len(s)-1)
sum=0
for i1 in t:
calc = ""
for j,i2 in enumerate(i1):
calc+=s[j]+i2
calc += s[-1]
sum+=eval(calc)
print(sum)
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
2,
17,
13,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
78,
2
],
[
75,
6
],
[
79,
9
],
[
81,
11
],
[
15,
14
],
[
76,
20
],
[
69,
23
],
[
79,
25
],
[
29,
28
],
[
76,
32
],
[
14,
36
],
[
28,
39
],
[
72,
41
],
[
66,
44
],
[
79,
46
],
[
28,
48
],
[
84,
51
],
[
67,
59
],
[
73,
59
],
[
70,
59
],
[
85,
64
],
[
82,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
]
] | [
"s=input()\nn=len(s)\nans=0\n\nfor bit in range(1<<(n-1)):\n f=s[0]\n \n for i in range(n-1):\n \n if bit & 1<<i:\n f+=\"+\"\n \n f+=s[i+1]\n \n ans+=sum(map(int,f.split(\"+\")))\n\nprint(ans)",
"s=input()",
"s",
"input()",
"input",
"n=len(s)",
"n",
"len(s)",
"len",
"s",
"ans=0",
"ans",
"0",
"for bit in range(1<<(n-1)):\n f=s[0]\n \n for i in range(n-1):\n \n if bit & 1<<i:\n f+=\"+\"\n \n f+=s[i+1]\n \n ans+=sum(map(int,f.split(\"+\")))",
"bit",
"range(1<<(n-1))",
"range",
"1<<(n-1)",
"1",
"n-1",
"n",
"1",
"f=s[0]",
"f",
"s[0]",
"s",
"0",
"for i in range(n-1):\n \n if bit & 1<<i:\n f+=\"+\"\n \n f+=s[i+1]\n \n ",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if bit & 1<<i:\n f+=\"+\"\n \n ",
"bit & 1<<i",
"bit",
"1<<i",
"1",
"i",
"f+=\"+\"",
"f",
"\"+\"",
"f+=s[i+1]",
"f",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"ans+=sum(map(int,f.split(\"+\")))",
"ans",
"sum(map(int,f.split(\"+\")))",
"sum",
"map(int,f.split(\"+\"))",
"map",
"int",
"f.split(\"+\")",
"f.split",
"f",
"split",
"\"+\"",
"print(ans)",
"print",
"ans",
"f+=s[i+1]",
"s[i+1]",
"f",
"f=s[0]",
"s[0]",
"f",
"f+=\"+\"",
"\"+\"",
"f",
"n=len(s)",
"len(s)",
"n",
"s=input()",
"input()",
"s",
"ans=0",
"0",
"ans",
"ans+=sum(map(int,f.split(\"+\")))",
"sum(map(int,f.split(\"+\")))",
"ans"
] | s=input()
n=len(s)
ans=0
for bit in range(1<<(n-1)):
f=s[0]
for i in range(n-1):
if bit & 1<<i:
f+="+"
f+=s[i+1]
ans+=sum(map(int,f.split("+")))
print(ans) |
[
7,
0,
13,
4,
13,
12,
13,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
29,
2,
4,
13,
2,
13,
18,
13,
2,
13,
17,
2,
13,
17,
4,
13,
2,
2,
13,
17,
18,
13,
2,
13,
17,
2,
13,
17,
23,
13,
23,
13,
4,
13,
4,
13,
18,
13,
17,
17,
10,
4,
13,
10,
12,
13
] | [
[
67,
2
],
[
57,
9
],
[
68,
13
],
[
55,
23
],
[
55,
31
],
[
68,
33
],
[
57,
35
],
[
57,
38
],
[
55,
44
],
[
68,
47
],
[
57,
49
],
[
57,
52
],
[
55,
55
],
[
57,
57
],
[
71,
61
],
[
68,
63
],
[
67,
68
]
] | [
"S=input()\ndef dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(s+\"+\"+S[i+1],i+1)\nprint(dfs(S[0],0))",
"S=input()",
"S",
"input()",
"input",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(s+\"+\"+S[i+1],i+1)",
"dfs",
"if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n ",
"i==len(S)-1",
"i",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"return sum(map(int,s.split(\"+\")))",
"sum(map(int,s.split(\"+\")))",
"sum",
"map(int,s.split(\"+\"))",
"map",
"int",
"s.split(\"+\")",
"s.split",
"s",
"split",
"\"+\"",
"return dfs(s+S[i+1],i+1)+dfs(s+\"+\"+S[i+1],i+1)",
"dfs(s+S[i+1],i+1)+dfs(s+\"+\"+S[i+1],i+1)",
"dfs(s+S[i+1],i+1)",
"dfs",
"s+S[i+1]",
"s",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"dfs(s+\"+\"+S[i+1],i+1)",
"dfs",
"s+\"+\"+S[i+1]",
"s+\"+\"",
"s",
"\"+\"",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"s",
"s",
"i",
"i",
"print(dfs(S[0],0))",
"print",
"dfs(S[0],0)",
"dfs",
"S[0]",
"S",
"0",
"0",
"S=input()",
"input()",
"S",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(s+\"+\"+S[i+1],i+1)",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(s+\"+\"+S[i+1],i+1)",
"dfs"
] | S=input()
def dfs(s,i):
if i==len(S)-1:
return sum(map(int,s.split("+")))
return dfs(s+S[i+1],i+1)+dfs(s+"+"+S[i+1],i+1)
print(dfs(S[0],0)) |
[
7,
15,
13,
12,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
13,
0,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
13,
13,
28,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
7,
6
],
[
10,
9
],
[
13,
12
],
[
39,
12
],
[
16,
15
],
[
37,
19
],
[
25,
24
],
[
12,
25
],
[
28,
27
],
[
37,
31
],
[
27,
35
],
[
15,
35
],
[
9,
35
],
[
37,
37
],
[
39,
39
],
[
44,
43
],
[
48,
47
],
[
43,
50
],
[
53,
52
],
[
47,
58
],
[
61,
60
],
[
64,
63
],
[
47,
66
],
[
69,
68
],
[
52,
75
],
[
63,
76
],
[
79,
78
],
[
68,
78
],
[
82,
81
],
[
78,
84
],
[
81,
84
],
[
87,
86
],
[
102,
88
],
[
43,
89
],
[
81,
90
],
[
78,
90
],
[
86,
93
],
[
60,
93
],
[
105,
99
]
] | [
"# -*- coding: utf-8 -*-\nimport itertools\n\ndef part_sum(S, clist):\n start = 0\n sum = 0\n for c in clist:\n sum += int(S[start:c])\n start = c\n sum += int(S[start:])\n return sum\n\ndef main():\n s = input()\n # output = int(input())\n length = len(s)\n numlist = list(range(1, length))\n ans = 0\n for i in range(length):\n combi = list(itertools.combinations((numlist), i))\n for clist in combi:\n clist = list(clist)\n ans += part_sum(s, clist)\n print(ans)\n # if ans == output:\n # print('OK')\n # else:\n # print('No')\n \n \n \n \nif __name__ == '__main__':\n main()",
"import itertools",
"itertools",
"def part_sum(S, clist):\n start = 0\n sum = 0\n for c in clist:\n sum += int(S[start:c])\n start = c\n sum += int(S[start:])\n return sum",
"part_sum",
"start = 0",
"start",
"0",
"sum = 0",
"sum",
"0",
"for c in clist:\n sum += int(S[start:c])\n start = c\n ",
"c",
"clist",
"sum += int(S[start:c])",
"sum",
"int(S[start:c])",
"int",
"S[start:c]",
"S",
"start:c",
"start",
"c",
"start = c",
"start",
"c",
"sum += int(S[start:])",
"sum",
"int(S[start:])",
"int",
"S[start:]",
"S",
"start:",
"start",
"return sum",
"sum",
"S",
"S",
"clist",
"clist",
"def main():\n s = input()\n # output = int(input())\n length = len(s)\n numlist = list(range(1, length))\n ans = 0\n for i in range(length):\n combi = list(itertools.combinations((numlist), i))\n for clist in combi:\n clist = list(clist)\n ans += part_sum(s, clist)\n print(ans)\n # if ans == output:\n # print('OK')\n # else:\n # print('No')\n \n \n \n ",
"main",
"s = input()",
"s",
"input()",
"input",
"length = len(s)",
"length",
"len(s)",
"len",
"s",
"numlist = list(range(1, length))",
"numlist",
"list(range(1, length))",
"list",
"range(1, length)",
"range",
"1",
"length",
"ans = 0",
"ans",
"0",
"for i in range(length):\n combi = list(itertools.combinations((numlist), i))\n for clist in combi:\n clist = list(clist)\n ans += part_sum(s, clist)\n ",
"i",
"range(length)",
"range",
"length",
"combi = list(itertools.combinations((numlist), i))",
"combi",
"list(itertools.combinations((numlist), i))",
"list",
"itertools.combinations((numlist), i)",
"itertools.combinations",
"itertools",
"combinations",
"numlist",
"i",
"for clist in combi:\n clist = list(clist)\n ans += part_sum(s, clist)\n ",
"clist",
"combi",
"clist = list(clist)",
"clist",
"list(clist)",
"list",
"clist",
"ans += part_sum(s, clist)",
"ans",
"part_sum(s, clist)",
"part_sum",
"s",
"clist",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def part_sum(S, clist):\n start = 0\n sum = 0\n for c in clist:\n sum += int(S[start:c])\n start = c\n sum += int(S[start:])\n return sum",
"def part_sum(S, clist):\n start = 0\n sum = 0\n for c in clist:\n sum += int(S[start:c])\n start = c\n sum += int(S[start:])\n return sum",
"part_sum",
"def main():\n s = input()\n # output = int(input())\n length = len(s)\n numlist = list(range(1, length))\n ans = 0\n for i in range(length):\n combi = list(itertools.combinations((numlist), i))\n for clist in combi:\n clist = list(clist)\n ans += part_sum(s, clist)\n print(ans)\n # if ans == output:\n # print('OK')\n # else:\n # print('No')\n \n \n \n ",
"def main():\n s = input()\n # output = int(input())\n length = len(s)\n numlist = list(range(1, length))\n ans = 0\n for i in range(length):\n combi = list(itertools.combinations((numlist), i))\n for clist in combi:\n clist = list(clist)\n ans += part_sum(s, clist)\n print(ans)\n # if ans == output:\n # print('OK')\n # else:\n # print('No')\n \n \n \n ",
"main"
] | # -*- coding: utf-8 -*-
import itertools
def part_sum(S, clist):
start = 0
sum = 0
for c in clist:
sum += int(S[start:c])
start = c
sum += int(S[start:])
return sum
def main():
s = input()
# output = int(input())
length = len(s)
numlist = list(range(1, length))
ans = 0
for i in range(length):
combi = list(itertools.combinations((numlist), i))
for clist in combi:
clist = list(clist)
ans += part_sum(s, clist)
print(ans)
# if ans == output:
# print('OK')
# else:
# print('No')
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
17,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
18,
13,
2,
2,
13,
17,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
4,
13,
18,
13,
13,
14,
2,
18,
18,
13,
13,
13,
17,
0,
13,
18,
13,
39,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
18,
18,
13,
13,
13,
18,
13,
39,
2,
13,
17,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
18,
13
] | [
[
130,
2
],
[
145,
6
],
[
131,
10
],
[
127,
13
],
[
17,
16
],
[
146,
21
],
[
124,
23
],
[
146,
27
],
[
30,
29
],
[
146,
32
],
[
16,
36
],
[
29,
37
],
[
47,
40
],
[
125,
41
],
[
146,
44
],
[
29,
46
],
[
128,
50
],
[
125,
52
],
[
139,
54
],
[
58,
57
],
[
128,
62
],
[
133,
64
],
[
131,
66
],
[
70,
69
],
[
128,
75
],
[
57,
76
],
[
128,
81
],
[
57,
82
],
[
69,
83
],
[
148,
86
],
[
131,
88
],
[
69,
91
],
[
69,
94
],
[
142,
97
],
[
134,
100
],
[
143,
100
],
[
149,
100
],
[
128,
103
],
[
57,
104
],
[
69,
105
],
[
131,
107
],
[
69,
110
],
[
69,
113
],
[
136,
116
],
[
143,
119
],
[
149,
119
],
[
134,
119
],
[
137,
122
],
[
140,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
]
] | [
"S=input()\nnum = len(S)-1 #็ฌฆๅทใๅ ใใใใ้้ใฎๆฐ\nx=[]\n\nfor i in range(2**num):\n tmp=['-']*num #ใในใฆใใคใในใๅๆๅคใจใใฆ็จๆใใฆใใ\n for j in range(num):\n if ((i >> j) &1):\n tmp[num-1-j] ='+'\n x.append(tmp)\n \n#print(x) #ใใใงๅ
จ็ฌฆๅทใใฟใผใณใใงใใ\n\nans =0\n\nfor i in range(len(x)):\n now =S[0]\n for j in range(len(x[i])):\n if x[i][j] == '-':\n now += S[j+1:j+2]\n else:\n now = now + x[i][j] + S[j+1:j+2] \n #print(now) #ใใฉในใฎ่จๅทใๆฟๅ
ฅใใ่กจ่จ\n ans += eval(now)\n\nprint(ans)",
"S=input()",
"S",
"input()",
"input",
"num = len(S)-1",
"num",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"x=[]",
"x",
"[]",
"for i in range(2**num):\n tmp=['-']*num #ใในใฆใใคใในใๅๆๅคใจใใฆ็จๆใใฆใใ\n for j in range(num):\n if ((i >> j) &1):\n tmp[num-1-j] ='+'\n x.append(tmp)\n \n#print(x) #ใใใงๅ
จ็ฌฆๅทใใฟใผใณใใงใใ",
"i",
"range(2**num)",
"range",
"2**num",
"2",
"num",
"tmp=['-']*num",
"tmp",
"['-']*num",
"['-']",
"'-'",
"num",
"for j in range(num):\n if ((i >> j) &1):\n tmp[num-1-j] ='+'\n ",
"j",
"range(num)",
"range",
"num",
"if ((i >> j) &1):\n tmp[num-1-j] ='+'\n ",
"(i >> j) &1",
"i >> j",
"i",
"j",
"1",
"tmp[num-1-j] ='+'",
"tmp[num-1-j]",
"tmp",
"num-1-j",
"num-1",
"num",
"1",
"j",
"'+'",
"x.append(tmp)",
"x.append",
"x",
"append",
"tmp",
"ans =0",
"ans",
"0",
"for i in range(len(x)):\n now =S[0]\n for j in range(len(x[i])):\n if x[i][j] == '-':\n now += S[j+1:j+2]\n else:\n now = now + x[i][j] + S[j+1:j+2] \n #print(now) #ใใฉในใฎ่จๅทใๆฟๅ
ฅใใ่กจ่จ\n ans += eval(now)",
"i",
"range(len(x))",
"range",
"len(x)",
"len",
"x",
"now =S[0]",
"now",
"S[0]",
"S",
"0",
"for j in range(len(x[i])):\n if x[i][j] == '-':\n now += S[j+1:j+2]\n else:\n now = now + x[i][j] + S[j+1:j+2] \n #print(now) #ใใฉในใฎ่จๅทใๆฟๅ
ฅใใ่กจ่จ\n ",
"j",
"range(len(x[i]))",
"range",
"len(x[i])",
"len",
"x[i]",
"x",
"i",
"if x[i][j] == '-':\n now += S[j+1:j+2]\n else:\n now = now + x[i][j] + S[j+1:j+2] \n #print(now) #ใใฉในใฎ่จๅทใๆฟๅ
ฅใใ่กจ่จ\n ",
"x[i][j] == '-'",
"x[i][j]",
"[i]",
"x",
"i",
"j",
"'-'",
"now += S[j+1:j+2]",
"now",
"S[j+1:j+2]",
"S",
"j+1:j+2",
"j+1",
"j",
"1",
"j+2",
"j",
"2",
"now = now + x[i][j] + S[j+1:j+2]",
"now",
"now + x[i][j] + S[j+1:j+2]",
"now + x[i][j]",
"now",
"x[i][j]",
"[i]",
"x",
"i",
"j",
"S[j+1:j+2]",
"S",
"j+1:j+2",
"j+1",
"j",
"1",
"j+2",
"j",
"2",
"ans += eval(now)",
"ans",
"eval(now)",
"eval",
"now",
"print(ans)",
"print",
"ans",
"tmp=['-']*num",
"['-']*num",
"tmp",
"x=[]",
"[]",
"x",
"S=input()",
"input()",
"S",
"now =S[0]",
"S[0]",
"now",
"ans += eval(now)",
"eval(now)",
"ans",
"ans =0",
"0",
"ans",
"now = now + x[i][j] + S[j+1:j+2]",
"now + x[i][j] + S[j+1:j+2]",
"now",
"num = len(S)-1",
"len(S)-1",
"num",
"now += S[j+1:j+2]",
"S[j+1:j+2]",
"now"
] | S=input()
num = len(S)-1 #็ฌฆๅทใๅ ใใใใ้้ใฎๆฐ
x=[]
for i in range(2**num):
tmp=['-']*num #ใในใฆใใคใในใๅๆๅคใจใใฆ็จๆใใฆใใ
for j in range(num):
if ((i >> j) &1):
tmp[num-1-j] ='+'
x.append(tmp)
#print(x) #ใใใงๅ
จ็ฌฆๅทใใฟใผใณใใงใใ
ans =0
for i in range(len(x)):
now =S[0]
for j in range(len(x[i])):
if x[i][j] == '-':
now += S[j+1:j+2]
else:
now = now + x[i][j] + S[j+1:j+2]
#print(now) #ใใฉในใฎ่จๅทใๆฟๅ
ฅใใ่กจ่จ
ans += eval(now)
print(ans) |
[
7,
12,
13,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
4,
18,
17,
13,
13,
0,
13,
4,
18,
13,
13,
4,
18,
13,
13,
13,
17,
29,
2,
4,
13,
13,
2,
13,
17,
4,
13,
13,
2,
13,
17,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
4,
13,
4,
13,
13,
17,
10,
4,
13,
10,
12,
13
] | [
[
48,
5
],
[
46,
9
],
[
46,
18
],
[
21,
20
],
[
46,
23
],
[
20,
27
],
[
48,
29
],
[
46,
35
],
[
48,
37
],
[
20,
41
],
[
48,
43
],
[
46,
46
],
[
48,
48
],
[
62,
50
],
[
66,
58
],
[
63,
59
],
[
62,
63
]
] | [
"def RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)\n\n\nS = list(input())\nprint(RecSum(S, 1))",
"def RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum",
"if i > len(S) - 1:\n return eval(''.join(S))\n ",
"i > len(S) - 1",
"i",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"return eval(''.join(S))",
"eval(''.join(S))",
"eval",
"''.join(S)",
"''.join",
"''",
"join",
"S",
"SS = S.copy()",
"SS",
"S.copy()",
"S.copy",
"S",
"copy",
"SS.insert(i, \"+\")",
"SS.insert",
"SS",
"insert",
"i",
"\"+\"",
"return RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum(S, i+1)",
"RecSum",
"S",
"i+1",
"i",
"1",
"RecSum(SS, i+2)",
"RecSum",
"SS",
"i+2",
"i",
"2",
"S",
"S",
"i",
"i",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"print(RecSum(S, 1))",
"print",
"RecSum(S, 1)",
"RecSum",
"S",
"1",
"S = list(input())",
"list(input())",
"S",
"def RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)",
"def RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum"
] | def RecSum(S, i):
if i > len(S) - 1:
return eval(''.join(S))
SS = S.copy()
SS.insert(i, "+")
return RecSum(S, i+1) + RecSum(SS, i+2)
S = list(input())
print(RecSum(S, 1))
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
17,
2,
13,
17,
0,
13,
4,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
4,
13,
18,
13,
2,
13,
17,
0,
13,
17,
0,
13,
4,
13,
18,
13,
2,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13
] | [
[
98,
2
],
[
86,
6
],
[
99,
9
],
[
80,
11
],
[
15,
14
],
[
87,
21
],
[
77,
24
],
[
99,
28
],
[
32,
31
],
[
87,
35
],
[
14,
40
],
[
31,
41
],
[
83,
44
],
[
78,
45
],
[
75,
45
],
[
93,
45
],
[
90,
45
],
[
89,
47
],
[
99,
51
],
[
31,
53
],
[
92,
56
],
[
74,
59
],
[
99,
63
],
[
31,
65
],
[
95,
68
],
[
75,
69
],
[
93,
69
],
[
90,
69
],
[
78,
69
],
[
96,
72
],
[
84,
72
],
[
81,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
78,
83
],
[
75,
83
],
[
93,
83
],
[
90,
83
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
75,
95
],
[
93,
95
],
[
90,
95
],
[
78,
95
],
[
95,
96
],
[
98,
99
]
] | [
"s = input()\nn= len(s)\nans = 0\nfor i in range(0, 2**(n-1)):\n tmp = int(s[0])\n for j in range(n-1):\n if (i >> j) & 1:\n ans += tmp\n tmp = int(s[j+1])\n else:\n tmp *= 10\n tmp += int(s[j+1])\n ans += tmp\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"n= len(s)",
"n",
"len(s)",
"len",
"s",
"ans = 0",
"ans",
"0",
"for i in range(0, 2**(n-1)):\n tmp = int(s[0])\n for j in range(n-1):\n if (i >> j) & 1:\n ans += tmp\n tmp = int(s[j+1])\n else:\n tmp *= 10\n tmp += int(s[j+1])\n ans += tmp",
"i",
"range(0, 2**(n-1))",
"range",
"0",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"tmp = int(s[0])",
"tmp",
"int(s[0])",
"int",
"s[0]",
"s",
"0",
"for j in range(n-1):\n if (i >> j) & 1:\n ans += tmp\n tmp = int(s[j+1])\n else:\n tmp *= 10\n tmp += int(s[j+1])\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i >> j) & 1:\n ans += tmp\n tmp = int(s[j+1])\n else:\n tmp *= 10\n tmp += int(s[j+1])\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"ans += tmp",
"ans",
"tmp",
"tmp = int(s[j+1])",
"tmp",
"int(s[j+1])",
"int",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"tmp *= 10",
"tmp",
"10",
"tmp += int(s[j+1])",
"tmp",
"int(s[j+1])",
"int",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ans += tmp",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"tmp += int(s[j+1])",
"int(s[j+1])",
"tmp",
"tmp = int(s[0])",
"int(s[0])",
"tmp",
"ans = 0",
"0",
"ans",
"ans += tmp",
"tmp",
"ans",
"n= len(s)",
"len(s)",
"n",
"tmp = int(s[j+1])",
"int(s[j+1])",
"tmp",
"tmp *= 10",
"10",
"tmp",
"ans += tmp",
"tmp",
"ans",
"s = input()",
"input()",
"s"
] | s = input()
n= len(s)
ans = 0
for i in range(0, 2**(n-1)):
tmp = int(s[0])
for j in range(n-1):
if (i >> j) & 1:
ans += tmp
tmp = int(s[j+1])
else:
tmp *= 10
tmp += int(s[j+1])
ans += tmp
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
17,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
2,
13,
13,
17,
17,
9,
0,
13,
2,
2,
18,
13,
39,
2,
13,
13,
17,
18,
13,
39,
2,
13,
13,
0,
13,
4,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13
] | [
[
83,
2
],
[
86,
6
],
[
84,
10
],
[
77,
13
],
[
17,
16
],
[
87,
22
],
[
89,
24
],
[
84,
25
],
[
28,
27
],
[
87,
31
],
[
16,
37
],
[
27,
38
],
[
80,
43
],
[
90,
47
],
[
81,
47
],
[
87,
50
],
[
27,
51
],
[
90,
54
],
[
81,
54
],
[
87,
57
],
[
27,
58
],
[
92,
60
],
[
81,
70
],
[
90,
70
],
[
93,
75
],
[
78,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
84,
89
],
[
89,
90
],
[
92,
93
]
] | [
"s=input()\nn=len(s)-1\nans=0\n\nfor bit in range(0, 1<<n):\n st=s\n for i in range(n+1):\n if (bit>>i)%2==0:\n continue\n st=st[:n-i]+'+'+st[n-i:]\n\n ans+=sum(list(map(int,st.split('+'))))\nprint(ans)\n ",
"s=input()",
"s",
"input()",
"input",
"n=len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"ans=0",
"ans",
"0",
"for bit in range(0, 1<<n):\n st=s\n for i in range(n+1):\n if (bit>>i)%2==0:\n continue\n st=st[:n-i]+'+'+st[n-i:]\n\n ans+=sum(list(map(int,st.split('+'))))",
"bit",
"range(0, 1<<n)",
"range",
"0",
"1<<n",
"1",
"n",
"st=s",
"st",
"s",
"for i in range(n+1):\n if (bit>>i)%2==0:\n continue\n st=st[:n-i]+'+'+st[n-i:]\n\n ",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if (bit>>i)%2==0:\n continue\n ",
"(bit>>i)%2==0",
"(bit>>i)%2",
"bit>>i",
"bit",
"i",
"2",
"0",
"continue",
"st=st[:n-i]+'+'+st[n-i:]",
"st",
"st[:n-i]+'+'+st[n-i:]",
"st[:n-i]+'+'",
"st[:n-i]",
"st",
":n-i",
"n-i",
"n",
"i",
"'+'",
"st[n-i:]",
"st",
"n-i:",
"n-i",
"n",
"i",
"ans+=sum(list(map(int,st.split('+'))))",
"ans",
"sum(list(map(int,st.split('+'))))",
"sum",
"list(map(int,st.split('+')))",
"list",
"map(int,st.split('+'))",
"map",
"int",
"st.split('+')",
"st.split",
"st",
"split",
"'+'",
"print(ans)",
"print",
"ans",
"ans=0",
"0",
"ans",
"st=st[:n-i]+'+'+st[n-i:]",
"st[:n-i]+'+'+st[n-i:]",
"st",
"s=input()",
"input()",
"s",
"n=len(s)-1",
"len(s)-1",
"n",
"st=s",
"s",
"st",
"ans+=sum(list(map(int,st.split('+'))))",
"sum(list(map(int,st.split('+'))))",
"ans"
] | s=input()
n=len(s)-1
ans=0
for bit in range(0, 1<<n):
st=s
for i in range(n+1):
if (bit>>i)%2==0:
continue
st=st[:n-i]+'+'+st[n-i:]
ans+=sum(list(map(int,st.split('+'))))
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
86,
2
],
[
89,
6
],
[
87,
9
],
[
74,
11
],
[
15,
14
],
[
90,
20
],
[
68,
23
],
[
87,
25
],
[
29,
28
],
[
90,
32
],
[
14,
37
],
[
28,
38
],
[
77,
41
],
[
69,
43
],
[
84,
43
],
[
81,
43
],
[
78,
43
],
[
80,
46
],
[
69,
48
],
[
84,
48
],
[
81,
48
],
[
78,
48
],
[
83,
51
],
[
81,
53
],
[
78,
53
],
[
69,
53
],
[
84,
53
],
[
87,
55
],
[
28,
57
],
[
71,
60
],
[
84,
63
],
[
81,
63
],
[
78,
63
],
[
69,
63
],
[
72,
66
],
[
75,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] | [
"S = input()\nl = len(S)\nans = 0\n\nfor i in range(2**(l-1)):\n T = S[0]\n for j in range(l-1):\n if i>>j & 1:\n T = T + \"\"\n else:\n T = T + \"+\"\n T = T+S[j+1]\n ans += eval(T)\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"l = len(S)",
"l",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for i in range(2**(l-1)):\n T = S[0]\n for j in range(l-1):\n if i>>j & 1:\n T = T + \"\"\n else:\n T = T + \"+\"\n T = T+S[j+1]\n ans += eval(T)",
"i",
"range(2**(l-1))",
"range",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"T = S[0]",
"T",
"S[0]",
"S",
"0",
"for j in range(l-1):\n if i>>j & 1:\n T = T + \"\"\n else:\n T = T + \"+\"\n T = T+S[j+1]\n ",
"j",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if i>>j & 1:\n T = T + \"\"\n else:\n T = T + \"+\"\n ",
"i>>j & 1",
"i>>j",
"i",
"j",
"1",
"T = T + \"\"",
"T",
"T + \"\"",
"T",
"\"\"",
"T = T + \"+\"",
"T",
"T + \"+\"",
"T",
"\"+\"",
"T = T+S[j+1]",
"T",
"T+S[j+1]",
"T",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"ans += eval(T)",
"ans",
"eval(T)",
"eval",
"T",
"print(ans)",
"print",
"ans",
"T = S[0]",
"S[0]",
"T",
"ans += eval(T)",
"eval(T)",
"ans",
"ans = 0",
"0",
"ans",
"T = T + \"\"",
"T + \"\"",
"T",
"T = T + \"+\"",
"T + \"+\"",
"T",
"T = T+S[j+1]",
"T+S[j+1]",
"T",
"S = input()",
"input()",
"S",
"l = len(S)",
"len(S)",
"l"
] | S = input()
l = len(S)
ans = 0
for i in range(2**(l-1)):
T = S[0]
for j in range(l-1):
if i>>j & 1:
T = T + ""
else:
T = T + "+"
T = T+S[j+1]
ans += eval(T)
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
0,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
58,
2
],
[
52,
6
],
[
59,
10
],
[
67,
13
],
[
17,
16
],
[
53,
21
],
[
61,
23
],
[
59,
30
],
[
55,
32
],
[
16,
37
],
[
64,
41
],
[
70,
44
],
[
65,
47
],
[
56,
47
],
[
62,
47
],
[
71,
50
],
[
68,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
]
] | [
"# C - ใใใใใฎๆฐๅผ\nS =(input())\nn = len(S)-1\ntotal = 0\nfor i in range(2**n):\n bag = \"\"\n for ind,val in enumerate(S):\n bag+=val\n if ((i>>ind)&1):\n bag+=\"+\"\n total+=eval(bag)\nprint(total)",
"S =(input())",
"S",
"input()",
"input",
"n = len(S)-1",
"n",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"total = 0",
"total",
"0",
"for i in range(2**n):\n bag = \"\"\n for ind,val in enumerate(S):\n bag+=val\n if ((i>>ind)&1):\n bag+=\"+\"\n total+=eval(bag)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"bag = \"\"",
"bag",
"\"\"",
"for ind,val in enumerate(S):\n bag+=val\n if ((i>>ind)&1):\n bag+=\"+\"\n ",
"ind",
"val",
"enumerate(S)",
"enumerate",
"S",
"bag+=val",
"bag",
"val",
"if ((i>>ind)&1):\n bag+=\"+\"\n ",
"(i>>ind)&1",
"i>>ind",
"i",
"ind",
"1",
"bag+=\"+\"",
"bag",
"\"+\"",
"total+=eval(bag)",
"total",
"eval(bag)",
"eval",
"bag",
"print(total)",
"print",
"total",
"n = len(S)-1",
"len(S)-1",
"n",
"bag+=val",
"val",
"bag",
"S =(input())",
"input()",
"S",
"bag = \"\"",
"\"\"",
"bag",
"bag+=\"+\"",
"\"+\"",
"bag",
"total = 0",
"0",
"total",
"total+=eval(bag)",
"eval(bag)",
"total"
] | # C - ใใใใใฎๆฐๅผ
S =(input())
n = len(S)-1
total = 0
for i in range(2**n):
bag = ""
for ind,val in enumerate(S):
bag+=val
if ((i>>ind)&1):
bag+="+"
total+=eval(bag)
print(total) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
4,
18,
13,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
4,
18,
13,
13,
4,
13,
18,
13,
39,
13,
0,
13,
2,
13,
4,
13,
13,
4,
13,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13
] | [
[
84,
2
],
[
87,
6
],
[
85,
10
],
[
81,
13
],
[
17,
16
],
[
88,
21
],
[
78,
23
],
[
93,
26
],
[
30,
29
],
[
88,
32
],
[
16,
35
],
[
29,
38
],
[
79,
41
],
[
85,
46
],
[
29,
50
],
[
90,
53
],
[
29,
55
],
[
79,
59
],
[
85,
64
],
[
96,
68
],
[
82,
70
],
[
97,
70
],
[
79,
73
],
[
97,
76
],
[
82,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
]
] | [
"s = input()\nn = len(s)-1\n\ntotal = 0\n#digit loop\nfor b in range(2**n):\n nums = []\n index = 0\n #bit loop / looking for plus location until number of digit\n for i in range(n):\n if ( b & (1 << i) ):\n nums.append(int(s[index:i+1]))\n index = i+1\n nums.append(int(s[index:]))\n total = total + sum(nums)\nprint(total)",
"s = input()",
"s",
"input()",
"input",
"n = len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"total = 0",
"total",
"0",
"for b in range(2**n):\n nums = []\n index = 0\n #bit loop / looking for plus location until number of digit\n for i in range(n):\n if ( b & (1 << i) ):\n nums.append(int(s[index:i+1]))\n index = i+1\n nums.append(int(s[index:]))\n total = total + sum(nums)",
"b",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"nums = []",
"nums",
"[]",
"index = 0",
"index",
"0",
"for i in range(n):\n if ( b & (1 << i) ):\n nums.append(int(s[index:i+1]))\n index = i+1\n ",
"i",
"range(n)",
"range",
"n",
"if ( b & (1 << i) ):\n nums.append(int(s[index:i+1]))\n index = i+1\n ",
"b & (1 << i)",
"b",
"1 << i",
"1",
"i",
"nums.append(int(s[index:i+1]))",
"nums.append",
"nums",
"append",
"int(s[index:i+1])",
"int",
"s[index:i+1]",
"s",
"index:i+1",
"index",
"i+1",
"i",
"1",
"index = i+1",
"index",
"i+1",
"i",
"1",
"nums.append(int(s[index:]))",
"nums.append",
"nums",
"append",
"int(s[index:])",
"int",
"s[index:]",
"s",
"index:",
"index",
"total = total + sum(nums)",
"total",
"total + sum(nums)",
"total",
"sum(nums)",
"sum",
"nums",
"print(total)",
"print",
"total",
"nums = []",
"[]",
"nums",
"total = 0",
"0",
"total",
"s = input()",
"input()",
"s",
"n = len(s)-1",
"len(s)-1",
"n",
"index = i+1",
"i+1",
"index",
"index = 0",
"0",
"index",
"total = total + sum(nums)",
"total + sum(nums)",
"total"
] | s = input()
n = len(s)-1
total = 0
#digit loop
for b in range(2**n):
nums = []
index = 0
#bit loop / looking for plus location until number of digit
for i in range(n):
if ( b & (1 << i) ):
nums.append(int(s[index:i+1]))
index = i+1
nums.append(int(s[index:]))
total = total + sum(nums)
print(total) |
[
7,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
39,
17,
42,
2,
4,
13,
13,
2,
4,
13,
13,
17,
0,
13,
2,
17,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
4,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
14,
40,
18,
13,
39,
13,
4,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13
] | [
[
110,
2
],
[
125,
6
],
[
10,
9
],
[
111,
17
],
[
113,
20
],
[
9,
23
],
[
128,
25
],
[
114,
27
],
[
129,
34
],
[
120,
34
],
[
111,
38
],
[
119,
41
],
[
129,
44
],
[
120,
44
],
[
131,
46
],
[
134,
49
],
[
53,
52
],
[
120,
57
],
[
129,
57
],
[
120,
61
],
[
129,
61
],
[
52,
62
],
[
137,
67
],
[
111,
71
],
[
52,
75
],
[
122,
78
],
[
52,
80
],
[
111,
85
],
[
111,
90
],
[
116,
93
],
[
111,
97
],
[
111,
102
],
[
140,
104
],
[
117,
105
],
[
138,
105
],
[
135,
105
],
[
141,
108
],
[
126,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
117,
140
],
[
138,
140
],
[
135,
140
],
[
140,
141
]
] | [
"S=input()\nans=0\nfor i in range(2**(len(S)-1)):\n a=bin(i)\n b=a[2:]\n while len(b)<len(S)-1:\n b=\"0\"+b\n k=0\n temp=0\n for j in range(len(b)):\n if b[j]==str(1):\n temp+=int(S[k:j+1])\n k=j+1\n if S[k:len(S)]!=\"\": \n temp+=int(S[k:len(S)])\n ans+=temp\nprint(ans)",
"S=input()",
"S",
"input()",
"input",
"ans=0",
"ans",
"0",
"for i in range(2**(len(S)-1)):\n a=bin(i)\n b=a[2:]\n while len(b)<len(S)-1:\n b=\"0\"+b\n k=0\n temp=0\n for j in range(len(b)):\n if b[j]==str(1):\n temp+=int(S[k:j+1])\n k=j+1\n if S[k:len(S)]!=\"\": \n temp+=int(S[k:len(S)])\n ans+=temp",
"i",
"range(2**(len(S)-1))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"a=bin(i)",
"a",
"bin(i)",
"bin",
"i",
"b=a[2:]",
"b",
"a[2:]",
"a",
"2:",
"2",
"while len(b)<len(S)-1:\n b=\"0\"+b\n ",
"len(b)<len(S)-1",
"len(b)",
"len",
"b",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"b=\"0\"+b",
"b",
"\"0\"+b",
"\"0\"",
"b",
"k=0",
"k",
"0",
"temp=0",
"temp",
"0",
"for j in range(len(b)):\n if b[j]==str(1):\n temp+=int(S[k:j+1])\n k=j+1\n ",
"j",
"range(len(b))",
"range",
"len(b)",
"len",
"b",
"if b[j]==str(1):\n temp+=int(S[k:j+1])\n k=j+1\n ",
"b[j]==str(1)",
"b[j]",
"b",
"j",
"str(1)",
"str",
"1",
"temp+=int(S[k:j+1])",
"temp",
"int(S[k:j+1])",
"int",
"S[k:j+1]",
"S",
"k:j+1",
"k",
"j+1",
"j",
"1",
"k=j+1",
"k",
"j+1",
"j",
"1",
"if S[k:len(S)]!=\"\": \n temp+=int(S[k:len(S)])\n ",
"S[k:len(S)]!=\"\"",
"S[k:len(S)]",
"S",
"k:len(S)",
"k",
"len(S)",
"len",
"S",
"\"\"",
"temp+=int(S[k:len(S)])",
"temp",
"int(S[k:len(S)])",
"int",
"S[k:len(S)]",
"S",
"k:len(S)",
"k",
"len(S)",
"len",
"S",
"ans+=temp",
"ans",
"temp",
"print(ans)",
"print",
"ans",
"S=input()",
"input()",
"S",
"a=bin(i)",
"bin(i)",
"a",
"temp+=int(S[k:len(S)])",
"int(S[k:len(S)])",
"temp",
"b=\"0\"+b",
"\"0\"+b",
"b",
"k=j+1",
"j+1",
"k",
"ans=0",
"0",
"ans",
"b=a[2:]",
"a[2:]",
"b",
"k=0",
"0",
"k",
"temp=0",
"0",
"temp",
"temp+=int(S[k:j+1])",
"int(S[k:j+1])",
"temp",
"ans+=temp",
"temp",
"ans"
] | S=input()
ans=0
for i in range(2**(len(S)-1)):
a=bin(i)
b=a[2:]
while len(b)<len(S)-1:
b="0"+b
k=0
temp=0
for j in range(len(b)):
if b[j]==str(1):
temp+=int(S[k:j+1])
k=j+1
if S[k:len(S)]!="":
temp+=int(S[k:len(S)])
ans+=temp
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
15,
13,
0,
13,
39,
17,
12,
13,
14,
2,
13,
2,
13,
17,
4,
18,
13,
13,
13,
0,
18,
13,
17,
4,
13,
13,
29,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
13,
2,
13,
17,
4,
13,
18,
13,
13,
13,
4,
13,
2,
13,
17,
2,
2,
17,
13,
4,
13,
18,
13,
13,
13,
29,
23,
13,
23,
13,
23,
13,
4,
13,
17,
4,
13,
18,
13,
17,
39,
4,
13,
18,
13,
17,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
107,
2
],
[
110,
6
],
[
108,
9
],
[
104,
13
],
[
84,
20
],
[
111,
22
],
[
88,
26
],
[
86,
28
],
[
33,
30
],
[
105,
31
],
[
88,
35
],
[
39,
38
],
[
88,
43
],
[
46,
45
],
[
88,
50
],
[
38,
53
],
[
86,
55
],
[
84,
59
],
[
108,
64
],
[
84,
65
],
[
38,
66
],
[
84,
70
],
[
86,
75
],
[
108,
79
],
[
84,
80
],
[
45,
81
],
[
84,
84
],
[
86,
86
],
[
88,
88
],
[
114,
90
],
[
108,
95
],
[
105,
101
],
[
104,
105
],
[
107,
108
],
[
110,
111
]
] | [
"S = input()\nn = len(S)\nimport copy\n\nans = [0]\n\ndef rec(index,tmp,tmp_list):\n # print(tmp,tmp_list)\n if index > n-1:\n\n tmp_list.append(tmp)\n # print(tmp_list)\n # print(tmp_list)\n ans[0] += sum(tmp_list)\n return\n\n tmp_list1 = copy.deepcopy(tmp_list)\n tmp_list2 = copy.deepcopy(tmp_list)\n \n \n tmp_list1.append(tmp)\n rec(index+1,int(S[index]),tmp_list1)\n\n rec(index+1,10*tmp + int(S[index]),tmp_list2)\n return\n\nrec(1,int(S[0]),[])\nprint(ans[0])",
"S = input()",
"S",
"input()",
"input",
"n = len(S)",
"n",
"len(S)",
"len",
"S",
"import copy",
"copy",
"ans = [0]",
"ans",
"[0]",
"0",
"def rec(index,tmp,tmp_list):\n # print(tmp,tmp_list)\n if index > n-1:\n\n tmp_list.append(tmp)\n # print(tmp_list)\n # print(tmp_list)\n ans[0] += sum(tmp_list)\n return\n\n tmp_list1 = copy.deepcopy(tmp_list)\n tmp_list2 = copy.deepcopy(tmp_list)\n \n \n tmp_list1.append(tmp)\n rec(index+1,int(S[index]),tmp_list1)\n\n rec(index+1,10*tmp + int(S[index]),tmp_list2)\n return",
"rec",
"if index > n-1:\n\n tmp_list.append(tmp)\n # print(tmp_list)\n # print(tmp_list)\n ans[0] += sum(tmp_list)\n return\n\n ",
"index > n-1",
"index",
"n-1",
"n",
"1",
"tmp_list.append(tmp)",
"tmp_list.append",
"tmp_list",
"append",
"tmp",
"ans[0] += sum(tmp_list)",
"ans[0]",
"ans",
"0",
"sum(tmp_list)",
"sum",
"tmp_list",
"return",
"tmp_list1 = copy.deepcopy(tmp_list)",
"tmp_list1",
"copy.deepcopy(tmp_list)",
"copy.deepcopy",
"copy",
"deepcopy",
"tmp_list",
"tmp_list2 = copy.deepcopy(tmp_list)",
"tmp_list2",
"copy.deepcopy(tmp_list)",
"copy.deepcopy",
"copy",
"deepcopy",
"tmp_list",
"tmp_list1.append(tmp)",
"tmp_list1.append",
"tmp_list1",
"append",
"tmp",
"rec(index+1,int(S[index]),tmp_list1)",
"rec",
"index+1",
"index",
"1",
"int(S[index])",
"int",
"S[index]",
"S",
"index",
"tmp_list1",
"rec(index+1,10*tmp + int(S[index]),tmp_list2)",
"rec",
"index+1",
"index",
"1",
"10*tmp + int(S[index])",
"10*tmp",
"10",
"tmp",
"int(S[index])",
"int",
"S[index]",
"S",
"index",
"tmp_list2",
"return",
"index",
"index",
"tmp",
"tmp",
"tmp_list",
"tmp_list",
"rec(1,int(S[0]),[])",
"rec",
"1",
"int(S[0])",
"int",
"S[0]",
"S",
"0",
"[]",
"print(ans[0])",
"print",
"ans[0]",
"ans",
"0",
"ans = [0]",
"[0]",
"ans",
"S = input()",
"input()",
"S",
"n = len(S)",
"len(S)",
"n",
"def rec(index,tmp,tmp_list):\n # print(tmp,tmp_list)\n if index > n-1:\n\n tmp_list.append(tmp)\n # print(tmp_list)\n # print(tmp_list)\n ans[0] += sum(tmp_list)\n return\n\n tmp_list1 = copy.deepcopy(tmp_list)\n tmp_list2 = copy.deepcopy(tmp_list)\n \n \n tmp_list1.append(tmp)\n rec(index+1,int(S[index]),tmp_list1)\n\n rec(index+1,10*tmp + int(S[index]),tmp_list2)\n return",
"def rec(index,tmp,tmp_list):\n # print(tmp,tmp_list)\n if index > n-1:\n\n tmp_list.append(tmp)\n # print(tmp_list)\n # print(tmp_list)\n ans[0] += sum(tmp_list)\n return\n\n tmp_list1 = copy.deepcopy(tmp_list)\n tmp_list2 = copy.deepcopy(tmp_list)\n \n \n tmp_list1.append(tmp)\n rec(index+1,int(S[index]),tmp_list1)\n\n rec(index+1,10*tmp + int(S[index]),tmp_list2)\n return",
"rec"
] | S = input()
n = len(S)
import copy
ans = [0]
def rec(index,tmp,tmp_list):
# print(tmp,tmp_list)
if index > n-1:
tmp_list.append(tmp)
# print(tmp_list)
# print(tmp_list)
ans[0] += sum(tmp_list)
return
tmp_list1 = copy.deepcopy(tmp_list)
tmp_list2 = copy.deepcopy(tmp_list)
tmp_list1.append(tmp)
rec(index+1,int(S[index]),tmp_list1)
rec(index+1,10*tmp + int(S[index]),tmp_list2)
return
rec(1,int(S[0]),[])
print(ans[0]) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
2,
13,
13,
17,
17,
0,
13,
2,
17,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
74,
2
],
[
80,
6
],
[
75,
10
],
[
71,
13
],
[
17,
16
],
[
81,
21
],
[
65,
23
],
[
75,
25
],
[
29,
28
],
[
81,
31
],
[
16,
36
],
[
28,
37
],
[
83,
41
],
[
75,
45
],
[
28,
47
],
[
68,
50
],
[
75,
52
],
[
28,
54
],
[
77,
57
],
[
69,
60
],
[
84,
60
],
[
66,
60
],
[
78,
63
],
[
72,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
]
] | [
"s = input()\nn = len(s)-1\nc = 0\nfor i in range(2**n):\n S = s[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n S += \"+\" + s[j+1]\n else:\n S += s[j+1]\n c += eval(S)\nprint(c) ",
"s = input()",
"s",
"input()",
"input",
"n = len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"c = 0",
"c",
"0",
"for i in range(2**n):\n S = s[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n S += \"+\" + s[j+1]\n else:\n S += s[j+1]\n c += eval(S)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"S = s[0]",
"S",
"s[0]",
"s",
"0",
"for j in range(n):\n if (i >> j) & 1 == 1:\n S += \"+\" + s[j+1]\n else:\n S += s[j+1]\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1 == 1:\n S += \"+\" + s[j+1]\n else:\n S += s[j+1]\n ",
"(i >> j) & 1 == 1",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"1",
"S += \"+\" + s[j+1]",
"S",
"\"+\" + s[j+1]",
"\"+\"",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"S += s[j+1]",
"S",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"c += eval(S)",
"c",
"eval(S)",
"eval",
"S",
"print(c)",
"print",
"c",
"S = s[0]",
"s[0]",
"S",
"S += s[j+1]",
"s[j+1]",
"S",
"c = 0",
"0",
"c",
"s = input()",
"input()",
"s",
"c += eval(S)",
"eval(S)",
"c",
"n = len(s)-1",
"len(s)-1",
"n",
"S += \"+\" + s[j+1]",
"\"+\" + s[j+1]",
"S"
] | s = input()
n = len(s)-1
c = 0
for i in range(2**n):
S = s[0]
for j in range(n):
if (i >> j) & 1 == 1:
S += "+" + s[j+1]
else:
S += s[j+1]
c += eval(S)
print(c) |
[
7,
12,
13,
14,
2,
13,
2,
13,
17,
29,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
29,
2,
4,
13,
2,
13,
18,
13,
2,
13,
17,
2,
13,
17,
4,
13,
2,
2,
13,
17,
18,
13,
2,
13,
17,
2,
13,
17,
23,
13,
23,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
4,
13,
4,
13,
18,
13,
17,
17,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
51,
5
],
[
49,
17
],
[
49,
25
],
[
51,
29
],
[
51,
32
],
[
49,
38
],
[
51,
43
],
[
51,
46
],
[
49,
49
],
[
51,
51
],
[
79,
53
],
[
82,
57
],
[
80,
60
],
[
76,
62
],
[
74,
67
],
[
80,
69
],
[
76,
77
],
[
79,
80
],
[
82,
83
]
] | [
"def a(t,i):\n if i == n-1:\n return sum(map(int,t.split(\"+\")))\n return a(t+s[i+1],i+1)+ a(t+\"+\"+s[i+1],i+1)\n\ns = input()\nn = len(s)\ni=0\nprint(a(s[0],0))",
"def a(t,i):\n if i == n-1:\n return sum(map(int,t.split(\"+\")))\n return a(t+s[i+1],i+1)+ a(t+\"+\"+s[i+1],i+1)",
"a",
"if i == n-1:\n return sum(map(int,t.split(\"+\")))\n ",
"i == n-1",
"i",
"n-1",
"n",
"1",
"return sum(map(int,t.split(\"+\")))",
"sum(map(int,t.split(\"+\")))",
"sum",
"map(int,t.split(\"+\"))",
"map",
"int",
"t.split(\"+\")",
"t.split",
"t",
"split",
"\"+\"",
"return a(t+s[i+1],i+1)+ a(t+\"+\"+s[i+1],i+1)",
"a(t+s[i+1],i+1)+ a(t+\"+\"+s[i+1],i+1)",
"a(t+s[i+1],i+1)",
"a",
"t+s[i+1]",
"t",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"a(t+\"+\"+s[i+1],i+1)",
"a",
"t+\"+\"+s[i+1]",
"t+\"+\"",
"t",
"\"+\"",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"t",
"t",
"i",
"i",
"s = input()",
"s",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"i=0",
"i",
"0",
"print(a(s[0],0))",
"print",
"a(s[0],0)",
"a",
"s[0]",
"s",
"0",
"0",
"def a(t,i):\n if i == n-1:\n return sum(map(int,t.split(\"+\")))\n return a(t+s[i+1],i+1)+ a(t+\"+\"+s[i+1],i+1)",
"def a(t,i):\n if i == n-1:\n return sum(map(int,t.split(\"+\")))\n return a(t+s[i+1],i+1)+ a(t+\"+\"+s[i+1],i+1)",
"a",
"i=0",
"0",
"i",
"s = input()",
"input()",
"s",
"n = len(s)",
"len(s)",
"n"
] | def a(t,i):
if i == n-1:
return sum(map(int,t.split("+")))
return a(t+s[i+1],i+1)+ a(t+"+"+s[i+1],i+1)
s = input()
n = len(s)
i=0
print(a(s[0],0))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
2,
13,
13,
17,
17,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] | [
[
77,
2
],
[
71,
8
],
[
78,
12
],
[
80,
15
],
[
19,
18
],
[
72,
23
],
[
89,
25
],
[
78,
27
],
[
31,
30
],
[
72,
33
],
[
18,
38
],
[
30,
39
],
[
92,
43
],
[
74,
46
],
[
78,
48
],
[
30,
50
],
[
83,
53
],
[
75,
59
],
[
93,
59
],
[
90,
59
],
[
86,
63
],
[
84,
66
],
[
87,
69
],
[
81,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
]
] | [
"X = str(input())\nn = len(X)-1\nans = 0\n\nfor i in range(2**n):\n l = X[0]\n for j in range(n):\n if (i>>j & 1) == 1:\n l += \"+\"\n l += X[j+1]\n #Xใฎjใๅ
ฅใฃใฆใ็ช็ฎใฎ้้ใงsplit\n num = map(int,l.split(\"+\"))\n ans += sum(num)\nprint(ans)",
"X = str(input())",
"X",
"str(input())",
"str",
"input()",
"input",
"n = len(X)-1",
"n",
"len(X)-1",
"len(X)",
"len",
"X",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2**n):\n l = X[0]\n for j in range(n):\n if (i>>j & 1) == 1:\n l += \"+\"\n l += X[j+1]\n #Xใฎjใๅ
ฅใฃใฆใ็ช็ฎใฎ้้ใงsplit\n num = map(int,l.split(\"+\"))\n ans += sum(num)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"l = X[0]",
"l",
"X[0]",
"X",
"0",
"for j in range(n):\n if (i>>j & 1) == 1:\n l += \"+\"\n l += X[j+1]\n #Xใฎjใๅ
ฅใฃใฆใ็ช็ฎใฎ้้ใงsplit\n ",
"j",
"range(n)",
"range",
"n",
"if (i>>j & 1) == 1:\n l += \"+\"\n ",
"(i>>j & 1) == 1",
"i>>j & 1",
"i>>j",
"i",
"j",
"1",
"1",
"l += \"+\"",
"l",
"\"+\"",
"l += X[j+1]",
"l",
"X[j+1]",
"X",
"j+1",
"j",
"1",
"num = map(int,l.split(\"+\"))",
"num",
"map(int,l.split(\"+\"))",
"map",
"int",
"l.split(\"+\")",
"l.split",
"l",
"split",
"\"+\"",
"ans += sum(num)",
"ans",
"sum(num)",
"sum",
"num",
"print(ans)",
"print",
"ans",
"n = len(X)-1",
"len(X)-1",
"n",
"l += X[j+1]",
"X[j+1]",
"l",
"X = str(input())",
"str(input())",
"X",
"ans = 0",
"0",
"ans",
"num = map(int,l.split(\"+\"))",
"map(int,l.split(\"+\"))",
"num",
"ans += sum(num)",
"sum(num)",
"ans",
"l = X[0]",
"X[0]",
"l",
"l += \"+\"",
"\"+\"",
"l"
] | X = str(input())
n = len(X)-1
ans = 0
for i in range(2**n):
l = X[0]
for j in range(n):
if (i>>j & 1) == 1:
l += "+"
l += X[j+1]
#Xใฎjใๅ
ฅใฃใฆใ็ช็ฎใฎ้้ใงsplit
num = map(int,l.split("+"))
ans += sum(num)
print(ans)
|
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
13,
17,
0,
13,
2,
17,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
12,
11
],
[
4,
19
],
[
23,
22
],
[
4,
24
],
[
28,
27
],
[
31,
30
],
[
4,
36
],
[
11,
40
],
[
55,
40
],
[
44,
43
],
[
4,
47
],
[
27,
48
],
[
58,
48
],
[
51,
50
],
[
4,
52
],
[
27,
53
],
[
58,
53
],
[
56,
55
],
[
59,
58
],
[
62,
61
],
[
50,
64
],
[
43,
64
],
[
22,
64
],
[
61,
67
],
[
8,
67
],
[
76,
73
]
] | [
"def main():\n S = input()\n ans = 0\n for n in range(2**(len(S)-1)):\n fig = S[0]\n index = 1\n for _ in range(len(S)-1):\n if n % 2:\n fig += \"+\"+S[index]\n else:\n fig += S[index]\n n >>= 1\n index += 1\n ans += eval(fig)\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"def main():\n S = input()\n ans = 0\n for n in range(2**(len(S)-1)):\n fig = S[0]\n index = 1\n for _ in range(len(S)-1):\n if n % 2:\n fig += \"+\"+S[index]\n else:\n fig += S[index]\n n >>= 1\n index += 1\n ans += eval(fig)\n print(ans)",
"main",
"S = input()",
"S",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for n in range(2**(len(S)-1)):\n fig = S[0]\n index = 1\n for _ in range(len(S)-1):\n if n % 2:\n fig += \"+\"+S[index]\n else:\n fig += S[index]\n n >>= 1\n index += 1\n ans += eval(fig)\n ",
"n",
"range(2**(len(S)-1))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"fig = S[0]",
"fig",
"S[0]",
"S",
"0",
"index = 1",
"index",
"1",
"for _ in range(len(S)-1):\n if n % 2:\n fig += \"+\"+S[index]\n else:\n fig += S[index]\n n >>= 1\n index += 1\n ",
"_",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if n % 2:\n fig += \"+\"+S[index]\n else:\n fig += S[index]\n ",
"n % 2",
"n",
"2",
"fig += \"+\"+S[index]",
"fig",
"\"+\"+S[index]",
"\"+\"",
"S[index]",
"S",
"index",
"fig += S[index]",
"fig",
"S[index]",
"S",
"index",
"n >>= 1",
"n",
"1",
"index += 1",
"index",
"1",
"ans += eval(fig)",
"ans",
"eval(fig)",
"eval",
"fig",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n S = input()\n ans = 0\n for n in range(2**(len(S)-1)):\n fig = S[0]\n index = 1\n for _ in range(len(S)-1):\n if n % 2:\n fig += \"+\"+S[index]\n else:\n fig += S[index]\n n >>= 1\n index += 1\n ans += eval(fig)\n print(ans)",
"def main():\n S = input()\n ans = 0\n for n in range(2**(len(S)-1)):\n fig = S[0]\n index = 1\n for _ in range(len(S)-1):\n if n % 2:\n fig += \"+\"+S[index]\n else:\n fig += S[index]\n n >>= 1\n index += 1\n ans += eval(fig)\n print(ans)",
"main"
] | def main():
S = input()
ans = 0
for n in range(2**(len(S)-1)):
fig = S[0]
index = 1
for _ in range(len(S)-1):
if n % 2:
fig += "+"+S[index]
else:
fig += S[index]
n >>= 1
index += 1
ans += eval(fig)
print(ans)
if __name__ == "__main__":
main()
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
2,
4,
13,
18,
13,
2,
2,
13,
13,
17,
2,
17,
13,
2,
17,
2,
13,
4,
13,
2,
13,
17,
2,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
57,
2
],
[
66,
6
],
[
58,
9
],
[
60,
11
],
[
15,
14
],
[
67,
17
],
[
20,
19
],
[
14,
23
],
[
63,
26
],
[
58,
32
],
[
67,
35
],
[
14,
36
],
[
19,
40
],
[
67,
44
],
[
14,
48
],
[
19,
51
],
[
64,
55
],
[
61,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
]
] | [
"S = input()\nN = len(S)\nans = 0\nfor i in range(N):\n for j in range(i+1):\n ans += int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for i in range(N):\n for j in range(i+1):\n ans += int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))",
"i",
"range(N)",
"range",
"N",
"for j in range(i+1):\n ans += int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))",
"j",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"ans += int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))",
"ans",
"int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))",
"int(S[N-i-1]) * 10 ** j",
"int(S[N-i-1])",
"int",
"S[N-i-1]",
"S",
"N-i-1",
"N-i",
"N",
"i",
"1",
"10 ** j",
"10",
"j",
"2 ** (N-min(i+1, j+2))",
"2",
"N-min(i+1, j+2)",
"N",
"min(i+1, j+2)",
"min",
"i+1",
"i",
"1",
"j+2",
"j",
"2",
"print(ans)",
"print",
"ans",
"S = input()",
"input()",
"S",
"ans = 0",
"0",
"ans",
"ans += int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))",
"int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))",
"ans",
"N = len(S)",
"len(S)",
"N"
] | S = input()
N = len(S)
ans = 0
for i in range(N):
for j in range(i+1):
ans += int(S[N-i-1]) * 10 ** j * 2 ** (N-min(i+1, j+2))
print(ans) |
[
7,
0,
13,
4,
13,
31,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
13,
0,
13,
39,
28,
13,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
13,
0,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13
] | [
[
71,
2
],
[
71,
5
],
[
83,
8
],
[
74,
13
],
[
17,
16
],
[
84,
21
],
[
68,
23
],
[
72,
24
],
[
86,
26
],
[
16,
37
],
[
87,
42
],
[
69,
44
],
[
78,
44
],
[
81,
44
],
[
80,
46
],
[
77,
49
],
[
87,
53
],
[
78,
55
],
[
81,
55
],
[
69,
55
],
[
89,
57
],
[
87,
63
],
[
90,
66
],
[
75,
66
],
[
72,
68
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] | [
"FS, *S = input()\nL = len(S)\nans = 0\nfor bit in range(1 << L):\n tmp = FS\n f = []\n for i, s in enumerate(S):\n if bit >> i & 1:\n f.append(tmp)\n tmp = s\n else:\n tmp += s\n f.append(tmp)\n ans += sum(map(int, f))\nprint(ans)",
"FS, *S = input()",
"FS",
"input()",
"input",
"*S",
"S",
"L = len(S)",
"L",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for bit in range(1 << L):\n tmp = FS\n f = []\n for i, s in enumerate(S):\n if bit >> i & 1:\n f.append(tmp)\n tmp = s\n else:\n tmp += s\n f.append(tmp)\n ans += sum(map(int, f))",
"bit",
"range(1 << L)",
"range",
"1 << L",
"1",
"L",
"tmp = FS",
"tmp",
"FS",
"f = []",
"f",
"[]",
"for i, s in enumerate(S):\n if bit >> i & 1:\n f.append(tmp)\n tmp = s\n else:\n tmp += s\n ",
"i",
"s",
"enumerate(S)",
"enumerate",
"S",
"if bit >> i & 1:\n f.append(tmp)\n tmp = s\n else:\n tmp += s\n ",
"bit >> i & 1",
"bit >> i",
"bit",
"i",
"1",
"f.append(tmp)",
"f.append",
"f",
"append",
"tmp",
"tmp = s",
"tmp",
"s",
"tmp += s",
"tmp",
"s",
"f.append(tmp)",
"f.append",
"f",
"append",
"tmp",
"ans += sum(map(int, f))",
"ans",
"sum(map(int, f))",
"sum",
"map(int, f)",
"map",
"int",
"f",
"print(ans)",
"print",
"ans",
"tmp = FS",
"FS",
"tmp",
"FS, *S = input()",
"input()",
"FS",
"ans = 0",
"0",
"ans",
"tmp += s",
"s",
"tmp",
"tmp = s",
"s",
"tmp",
"L = len(S)",
"len(S)",
"L",
"f = []",
"[]",
"f",
"ans += sum(map(int, f))",
"sum(map(int, f))",
"ans"
] | FS, *S = input()
L = len(S)
ans = 0
for bit in range(1 << L):
tmp = FS
f = []
for i, s in enumerate(S):
if bit >> i & 1:
f.append(tmp)
tmp = s
else:
tmp += s
f.append(tmp)
ans += sum(map(int, f))
print(ans)
|
[
7,
15,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
4,
13,
4,
18,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
6,
5
],
[
12,
11
],
[
5,
14
],
[
17,
16
],
[
20,
19
],
[
23,
22
],
[
5,
30
],
[
34,
33
],
[
5,
38
],
[
16,
41
],
[
75,
41
],
[
11,
47
],
[
70,
47
],
[
22,
52
],
[
33,
53
],
[
16,
57
],
[
75,
57
],
[
62,
61
],
[
16,
68
],
[
75,
68
],
[
71,
70
],
[
5,
73
],
[
76,
75
],
[
61,
79
],
[
19,
79
],
[
88,
85
]
] | [
"from collections import deque\n\ndef main():\n N = list(input())\n Nq = deque(N)\n anstmp = []\n ans = 0\n\n for bit in range(2**(len(N) - 1)):\n for i in range(len(N)):\n anstmp.append(str(Nq.popleft()))\n if ((bit >> i) & 1): \n anstmp.append(\"+\")\n # print(\"\".join(anstmp))\n ans += eval(\"\".join(anstmp))\n\n Nq = deque(N) \n anstmp = [] \n\n print(ans)\n \n \n\nif __name__ == \"__main__\":\n main()",
"from collections import deque",
"def main():\n N = list(input())\n Nq = deque(N)\n anstmp = []\n ans = 0\n\n for bit in range(2**(len(N) - 1)):\n for i in range(len(N)):\n anstmp.append(str(Nq.popleft()))\n if ((bit >> i) & 1): \n anstmp.append(\"+\")\n # print(\"\".join(anstmp))\n ans += eval(\"\".join(anstmp))\n\n Nq = deque(N) \n anstmp = [] \n\n print(ans)\n \n ",
"main",
"N = list(input())",
"N",
"list(input())",
"list",
"input()",
"input",
"Nq = deque(N)",
"Nq",
"deque(N)",
"deque",
"N",
"anstmp = []",
"anstmp",
"[]",
"ans = 0",
"ans",
"0",
"for bit in range(2**(len(N) - 1)):\n for i in range(len(N)):\n anstmp.append(str(Nq.popleft()))\n if ((bit >> i) & 1): \n anstmp.append(\"+\")\n # print(\"\".join(anstmp))\n ans += eval(\"\".join(anstmp))\n\n Nq = deque(N) \n anstmp = [] \n\n ",
"bit",
"range(2**(len(N) - 1))",
"range",
"2**(len(N) - 1)",
"2",
"len(N) - 1",
"len(N)",
"len",
"N",
"1",
"for i in range(len(N)):\n anstmp.append(str(Nq.popleft()))\n if ((bit >> i) & 1): \n anstmp.append(\"+\")\n # print(\"\".join(anstmp))\n ",
"i",
"range(len(N))",
"range",
"len(N)",
"len",
"N",
"anstmp.append(str(Nq.popleft()))",
"anstmp.append",
"anstmp",
"append",
"str(Nq.popleft())",
"str",
"Nq.popleft()",
"Nq.popleft",
"Nq",
"popleft",
"if ((bit >> i) & 1): \n anstmp.append(\"+\")\n # print(\"\".join(anstmp))\n ",
"(bit >> i) & 1",
"bit >> i",
"bit",
"i",
"1",
"anstmp.append(\"+\")",
"anstmp.append",
"anstmp",
"append",
"\"+\"",
"ans += eval(\"\".join(anstmp))",
"ans",
"eval(\"\".join(anstmp))",
"eval",
"\"\".join(anstmp)",
"\"\".join",
"\"\"",
"join",
"anstmp",
"Nq = deque(N)",
"Nq",
"deque(N)",
"deque",
"N",
"anstmp = []",
"anstmp",
"[]",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n N = list(input())\n Nq = deque(N)\n anstmp = []\n ans = 0\n\n for bit in range(2**(len(N) - 1)):\n for i in range(len(N)):\n anstmp.append(str(Nq.popleft()))\n if ((bit >> i) & 1): \n anstmp.append(\"+\")\n # print(\"\".join(anstmp))\n ans += eval(\"\".join(anstmp))\n\n Nq = deque(N) \n anstmp = [] \n\n print(ans)\n \n ",
"def main():\n N = list(input())\n Nq = deque(N)\n anstmp = []\n ans = 0\n\n for bit in range(2**(len(N) - 1)):\n for i in range(len(N)):\n anstmp.append(str(Nq.popleft()))\n if ((bit >> i) & 1): \n anstmp.append(\"+\")\n # print(\"\".join(anstmp))\n ans += eval(\"\".join(anstmp))\n\n Nq = deque(N) \n anstmp = [] \n\n print(ans)\n \n ",
"main"
] | from collections import deque
def main():
N = list(input())
Nq = deque(N)
anstmp = []
ans = 0
for bit in range(2**(len(N) - 1)):
for i in range(len(N)):
anstmp.append(str(Nq.popleft()))
if ((bit >> i) & 1):
anstmp.append("+")
# print("".join(anstmp))
ans += eval("".join(anstmp))
Nq = deque(N)
anstmp = []
print(ans)
if __name__ == "__main__":
main()
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
4,
18,
17,
13,
13,
0,
13,
4,
18,
13,
13,
4,
18,
13,
13,
13,
17,
29,
2,
4,
13,
13,
2,
13,
17,
4,
13,
13,
2,
13,
17,
23,
13,
23,
13,
0,
13,
4,
13,
4,
18,
4,
13,
13,
17,
4,
13,
4,
13,
13,
17,
10,
12,
13,
10,
4,
13,
10,
18,
13
] | [
[
81,
4
],
[
57,
14
],
[
55,
18
],
[
55,
27
],
[
30,
29
],
[
55,
32
],
[
29,
36
],
[
57,
38
],
[
55,
44
],
[
57,
46
],
[
29,
50
],
[
57,
52
],
[
55,
55
],
[
57,
57
],
[
78,
59
],
[
82,
65
],
[
76,
71
],
[
79,
72
],
[
78,
79
],
[
81,
82
]
] | [
"import sys\ninput = sys.stdin.readline\n\n\ndef RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)\n\n\nS = list(input().rstrip('\\n'))\nprint(RecSum(S, 1))",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum",
"if i > len(S) - 1:\n return eval(''.join(S))\n ",
"i > len(S) - 1",
"i",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"return eval(''.join(S))",
"eval(''.join(S))",
"eval",
"''.join(S)",
"''.join",
"''",
"join",
"S",
"SS = S.copy()",
"SS",
"S.copy()",
"S.copy",
"S",
"copy",
"SS.insert(i, \"+\")",
"SS.insert",
"SS",
"insert",
"i",
"\"+\"",
"return RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum(S, i+1)",
"RecSum",
"S",
"i+1",
"i",
"1",
"RecSum(SS, i+2)",
"RecSum",
"SS",
"i+2",
"i",
"2",
"S",
"S",
"i",
"i",
"S = list(input().rstrip('\\n'))",
"S",
"list(input().rstrip('\\n'))",
"list",
"input().rstrip('\\n')",
"().rstrip",
"()",
"input",
"rstrip",
"'\\n'",
"print(RecSum(S, 1))",
"print",
"RecSum(S, 1)",
"RecSum",
"S",
"1",
"def RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)",
"def RecSum(S, i):\n if i > len(S) - 1:\n return eval(''.join(S))\n SS = S.copy()\n SS.insert(i, \"+\")\n return RecSum(S, i+1) + RecSum(SS, i+2)",
"RecSum",
"S = list(input().rstrip('\\n'))",
"list(input().rstrip('\\n'))",
"S",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input"
] | import sys
input = sys.stdin.readline
def RecSum(S, i):
if i > len(S) - 1:
return eval(''.join(S))
SS = S.copy()
SS.insert(i, "+")
return RecSum(S, i+1) + RecSum(SS, i+2)
S = list(input().rstrip('\n'))
print(RecSum(S, 1))
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
39,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
4,
18,
13,
13,
13,
28,
13,
13,
0,
18,
13,
39,
2,
13,
13,
2,
13,
13,
17,
0,
13,
17,
0,
13,
4,
18,
17,
13,
13,
41,
28,
13,
4,
18,
13,
13,
17,
4,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
118,
4
],
[
124,
10
],
[
119,
14
],
[
112,
17
],
[
21,
20
],
[
125,
25
],
[
106,
27
],
[
31,
30
],
[
125,
33
],
[
20,
36
],
[
30,
39
],
[
107,
42
],
[
30,
44
],
[
100,
46
],
[
103,
49
],
[
119,
54
],
[
57,
56
],
[
107,
56
],
[
68,
59
],
[
104,
60
],
[
56,
63
],
[
101,
64
],
[
110,
64
],
[
56,
66
],
[
101,
67
],
[
110,
67
],
[
109,
70
],
[
121,
73
],
[
104,
78
],
[
82,
81
],
[
122,
84
],
[
81,
90
],
[
115,
92
],
[
116,
98
],
[
113,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
]
] | [
"import copy\n\ns = list(input())\nn = len(s) - 1\n\nans = 0\nfor bit in range(1 << n):\n\n #print(bin(bit))\n\n p = []\n for i in range(n):\n if bit & (1 << i):\n p.append(i)\n #print(p)\n\n m = 1\n s_ = copy.copy(s)\n for idx in p:\n s_[idx+m:idx+m] = '+'\n m += 1\n #print(s_)\n\n ss = ''.join(s_)\n #print(ss)\n ans += sum([int(n) for n in ss.split('+')])\n\nprint(ans)",
"import copy",
"copy",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"for bit in range(1 << n):\n\n #print(bin(bit))\n\n p = []\n for i in range(n):\n if bit & (1 << i):\n p.append(i)\n #print(p)\n\n m = 1\n s_ = copy.copy(s)\n for idx in p:\n s_[idx+m:idx+m] = '+'\n m += 1\n #print(s_)\n\n ss = ''.join(s_)\n #print(ss)\n ans += sum([int(n) for n in ss.split('+')])",
"bit",
"range(1 << n)",
"range",
"1 << n",
"1",
"n",
"p = []",
"p",
"[]",
"for i in range(n):\n if bit & (1 << i):\n p.append(i)\n #print(p)\n\n ",
"i",
"range(n)",
"range",
"n",
"if bit & (1 << i):\n p.append(i)\n #print(p)\n\n ",
"bit & (1 << i)",
"bit",
"1 << i",
"1",
"i",
"p.append(i)",
"p.append",
"p",
"append",
"i",
"m = 1",
"m",
"1",
"s_ = copy.copy(s)",
"s_",
"copy.copy(s)",
"copy.copy",
"copy",
"copy",
"s",
"for idx in p:\n s_[idx+m:idx+m] = '+'\n m += 1\n #print(s_)\n\n ",
"idx",
"p",
"s_[idx+m:idx+m] = '+'",
"s_[idx+m:idx+m]",
"s_",
"idx+m:idx+m",
"idx+m",
"idx",
"m",
"idx+m",
"idx",
"m",
"'+'",
"m += 1",
"m",
"1",
"ss = ''.join(s_)",
"ss",
"''.join(s_)",
"''.join",
"''",
"join",
"s_",
"int(n) for n in ss.split('+')",
"for n in ss.split('+')",
"n",
"ss.split('+')",
"ss.split",
"ss",
"split",
"'+'",
"for n in ss.split('+')",
"int(n)",
"int",
"n",
"ans += sum([int(n) for n in ss.split('+')])",
"ans",
"sum([int(n) for n in ss.split('+')])",
"sum",
"[int(n) for n in ss.split('+')]",
"print(ans)",
"print",
"ans",
"m = 1",
"1",
"m",
"s_ = copy.copy(s)",
"copy.copy(s)",
"s_",
"p = []",
"[]",
"p",
"m += 1",
"1",
"m",
"ans = 0",
"0",
"ans",
"ans += sum([int(n) for n in ss.split('+')])",
"sum([int(n) for n in ss.split('+')])",
"ans",
"s = list(input())",
"list(input())",
"s",
"ss = ''.join(s_)",
"''.join(s_)",
"ss",
"n = len(s) - 1",
"len(s) - 1",
"n"
] | import copy
s = list(input())
n = len(s) - 1
ans = 0
for bit in range(1 << n):
#print(bin(bit))
p = []
for i in range(n):
if bit & (1 << i):
p.append(i)
#print(p)
m = 1
s_ = copy.copy(s)
for idx in p:
s_[idx+m:idx+m] = '+'
m += 1
#print(s_)
ss = ''.join(s_)
#print(ss)
ans += sum([int(n) for n in ss.split('+')])
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
15,
0,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
2,
17,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
106,
2
],
[
103,
8
],
[
107,
11
],
[
88,
14
],
[
24,
23
],
[
104,
25
],
[
112,
28
],
[
32,
31
],
[
89,
31
],
[
94,
34
],
[
107,
36
],
[
40,
39
],
[
104,
43
],
[
31,
48
],
[
39,
49
],
[
97,
52
],
[
107,
56
],
[
39,
58
],
[
91,
61
],
[
107,
63
],
[
39,
65
],
[
100,
68
],
[
92,
76
],
[
98,
76
],
[
95,
76
],
[
109,
80
],
[
101,
83
],
[
110,
86
],
[
113,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
]
] | [
"S = list(input())\nN = len(S)\n\nfrom itertools import product\nLS = list(product([0,1], repeat=N-1))\nout = 0\nfor L in LS:\n T = S[0]\n for i in range(N-1):\n if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n A = list(map(int,T.split(\"+\")))\n out += sum(A)\nprint(out)",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"from itertools import product",
"LS = list(product([0,1], repeat=N-1))",
"LS",
"list(product([0,1], repeat=N-1))",
"list",
"product([0,1], repeat=N-1)",
"product",
"[0,1]",
"0",
"1",
"repeat=N-1",
"repeat",
"N-1",
"N",
"1",
"out = 0",
"out",
"0",
"for L in LS:\n T = S[0]\n for i in range(N-1):\n if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n A = list(map(int,T.split(\"+\")))\n out += sum(A)",
"L",
"LS",
"T = S[0]",
"T",
"S[0]",
"S",
"0",
"for i in range(N-1):\n if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n ",
"L[i]==1",
"L[i]",
"L",
"i",
"1",
"T += \"+\"+S[i+1]",
"T",
"\"+\"+S[i+1]",
"\"+\"",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"T += S[i+1]",
"T",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"A = list(map(int,T.split(\"+\")))",
"A",
"list(map(int,T.split(\"+\")))",
"list",
"map(int,T.split(\"+\"))",
"map",
"int",
"T.split(\"+\")",
"T.split",
"T",
"split",
"\"+\"",
"out += sum(A)",
"out",
"sum(A)",
"sum",
"A",
"print(out)",
"print",
"out",
"LS = list(product([0,1], repeat=N-1))",
"list(product([0,1], repeat=N-1))",
"LS",
"T += S[i+1]",
"S[i+1]",
"T",
"T = S[0]",
"S[0]",
"T",
"T += \"+\"+S[i+1]",
"\"+\"+S[i+1]",
"T",
"A = list(map(int,T.split(\"+\")))",
"list(map(int,T.split(\"+\")))",
"A",
"N = len(S)",
"len(S)",
"N",
"S = list(input())",
"list(input())",
"S",
"out += sum(A)",
"sum(A)",
"out",
"out = 0",
"0",
"out"
] | S = list(input())
N = len(S)
from itertools import product
LS = list(product([0,1], repeat=N-1))
out = 0
for L in LS:
T = S[0]
for i in range(N-1):
if L[i]==1:
T += "+"+S[i+1]
else:
T += S[i+1]
A = list(map(int,T.split("+")))
out += sum(A)
print(out) |
[
7,
15,
13,
15,
15,
0,
13,
18,
18,
13,
13,
13,
4,
18,
13,
13,
2,
17,
17,
12,
13,
29,
4,
13,
4,
13,
12,
13,
29,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
4,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
2,
13,
10,
12,
13,
10,
18,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
151,
6
],
[
152,
25
],
[
152,
35
],
[
164,
43
],
[
49,
48
],
[
58,
51
],
[
167,
54
],
[
58,
58
],
[
160,
60
],
[
145,
65
],
[
75,
74
],
[
152,
78
],
[
82,
81
],
[
74,
85
],
[
89,
88
],
[
92,
91
],
[
81,
96
],
[
99,
98
],
[
102,
101
],
[
81,
104
],
[
91,
108
],
[
101,
109
],
[
113,
112
],
[
74,
116
],
[
101,
120
],
[
124,
123
],
[
101,
125
],
[
129,
128
],
[
74,
132
],
[
128,
137
],
[
112,
137
],
[
88,
137
],
[
149,
143
],
[
145,
146
],
[
151,
152
],
[
160,
161
]
] | [
"import sys\nfrom math import sqrt\nfrom collections import Counter, defaultdict, deque\n\ninput = sys.stdin.readline\nsys.setrecursionlimit(10 ** 6)\n\n\ndef I():\n return int(input())\n\n\ndef MI():\n return map(int, input().split())\n\n\ndef LI():\n return list(MI())\n\n\ndef LIN(n: int):\n return [I() for _ in range(n)]\n\n\ninf = float(\"inf\")\nmod = 10 ** 9 + 7\n\n\ndef main():\n s = input().rstrip()\n\n n = len(s) - 1\n ans = 0\n for i in range(2 ** n):\n tmp = 0\n for j in range(n):\n if (i >> j) & 1:\n ans += int(s[tmp : j + 1])\n tmp = j + 1\n ans += int(s[tmp:])\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"from math import sqrt",
"from collections import Counter, defaultdict, deque",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"sys.setrecursionlimit(10 ** 6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 6",
"10",
"6",
"def I():\n return int(input())",
"I",
"return int(input())",
"int(input())",
"int",
"input()",
"input",
"def MI():\n return map(int, input().split())",
"MI",
"return map(int, input().split())",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def LI():\n return list(MI())",
"LI",
"return list(MI())",
"list(MI())",
"list",
"MI()",
"MI",
"def LIN(n: int):\n return [I() for _ in range(n)]",
"LIN",
"I() for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"I()",
"I",
"return [I() for _ in range(n)]",
"[I() for _ in range(n)]",
"n: int",
"n",
"inf = float(\"inf\")",
"inf",
"float(\"inf\")",
"float",
"\"inf\"",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def main():\n s = input().rstrip()\n\n n = len(s) - 1\n ans = 0\n for i in range(2 ** n):\n tmp = 0\n for j in range(n):\n if (i >> j) & 1:\n ans += int(s[tmp : j + 1])\n tmp = j + 1\n ans += int(s[tmp:])\n\n print(ans)",
"main",
"s = input().rstrip()",
"s",
"input().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2 ** n):\n tmp = 0\n for j in range(n):\n if (i >> j) & 1:\n ans += int(s[tmp : j + 1])\n tmp = j + 1\n ans += int(s[tmp:])\n\n ",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"tmp = 0",
"tmp",
"0",
"for j in range(n):\n if (i >> j) & 1:\n ans += int(s[tmp : j + 1])\n tmp = j + 1\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1:\n ans += int(s[tmp : j + 1])\n tmp = j + 1\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"ans += int(s[tmp : j + 1])",
"ans",
"int(s[tmp : j + 1])",
"int",
"s[tmp : j + 1]",
"s",
"tmp : j + 1",
"tmp",
"j + 1",
"j",
"1",
"tmp = j + 1",
"tmp",
"j + 1",
"j",
"1",
"ans += int(s[tmp:])",
"ans",
"int(s[tmp:])",
"int",
"s[tmp:]",
"s",
"tmp:",
"tmp",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"def main():\n s = input().rstrip()\n\n n = len(s) - 1\n ans = 0\n for i in range(2 ** n):\n tmp = 0\n for j in range(n):\n if (i >> j) & 1:\n ans += int(s[tmp : j + 1])\n tmp = j + 1\n ans += int(s[tmp:])\n\n print(ans)",
"def main():\n s = input().rstrip()\n\n n = len(s) - 1\n ans = 0\n for i in range(2 ** n):\n tmp = 0\n for j in range(n):\n if (i >> j) & 1:\n ans += int(s[tmp : j + 1])\n tmp = j + 1\n ans += int(s[tmp:])\n\n print(ans)",
"main",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"def LIN(n: int):\n return [I() for _ in range(n)]",
"def LIN(n: int):\n return [I() for _ in range(n)]",
"LIN",
"def LI():\n return list(MI())",
"def LI():\n return list(MI())",
"LI",
"inf = float(\"inf\")",
"float(\"inf\")",
"inf",
"def MI():\n return map(int, input().split())",
"def MI():\n return map(int, input().split())",
"MI",
"def I():\n return int(input())",
"def I():\n return int(input())",
"I"
] | import sys
from math import sqrt
from collections import Counter, defaultdict, deque
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
def I():
return int(input())
def MI():
return map(int, input().split())
def LI():
return list(MI())
def LIN(n: int):
return [I() for _ in range(n)]
inf = float("inf")
mod = 10 ** 9 + 7
def main():
s = input().rstrip()
n = len(s) - 1
ans = 0
for i in range(2 ** n):
tmp = 0
for j in range(n):
if (i >> j) & 1:
ans += int(s[tmp : j + 1])
tmp = j + 1
ans += int(s[tmp:])
print(ans)
if __name__ == "__main__":
main()
|
[
7,
12,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
2,
13,
17,
4,
13,
18,
13,
13,
14,
2,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
17,
0,
13,
13,
0,
13,
13,
29,
13,
23,
13,
0,
13,
4,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
69,
8
],
[
12,
11
],
[
15,
14
],
[
4,
19
],
[
22,
21
],
[
25,
24
],
[
28,
27
],
[
4,
31
],
[
35,
34
],
[
24,
37
],
[
58,
37
],
[
34,
37
],
[
69,
42
],
[
27,
43
],
[
27,
46
],
[
4,
47
],
[
14,
51
],
[
27,
52
],
[
56,
55
],
[
34,
56
],
[
24,
56
],
[
58,
56
],
[
59,
58
],
[
62,
61
],
[
34,
62
],
[
24,
62
],
[
58,
62
],
[
65,
64
],
[
61,
65
],
[
55,
65
],
[
21,
65
],
[
64,
67
],
[
11,
67
],
[
69,
69
],
[
80,
71
],
[
84,
77
],
[
81,
78
],
[
80,
81
]
] | [
"def solve(S):\n n = len(S) - 1\n result = 0\n for i in range(2**n):\n sum_i = 0\n now = 0\n for j in range(n+1):\n now = now * 10 + int(S[j])\n if j < n:\n if ((i >> j) & 1):\n sum_i += now\n now = 0\n else:\n sum_i += now\n result += sum_i\n return result\nS = input()\nprint(solve(S))",
"def solve(S):\n n = len(S) - 1\n result = 0\n for i in range(2**n):\n sum_i = 0\n now = 0\n for j in range(n+1):\n now = now * 10 + int(S[j])\n if j < n:\n if ((i >> j) & 1):\n sum_i += now\n now = 0\n else:\n sum_i += now\n result += sum_i\n return result",
"solve",
"n = len(S) - 1",
"n",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"result = 0",
"result",
"0",
"for i in range(2**n):\n sum_i = 0\n now = 0\n for j in range(n+1):\n now = now * 10 + int(S[j])\n if j < n:\n if ((i >> j) & 1):\n sum_i += now\n now = 0\n else:\n sum_i += now\n result += sum_i\n ",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"sum_i = 0",
"sum_i",
"0",
"now = 0",
"now",
"0",
"for j in range(n+1):\n now = now * 10 + int(S[j])\n if j < n:\n if ((i >> j) & 1):\n sum_i += now\n now = 0\n else:\n sum_i += now\n ",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"now = now * 10 + int(S[j])",
"now",
"now * 10 + int(S[j])",
"now * 10",
"now",
"10",
"int(S[j])",
"int",
"S[j]",
"S",
"j",
"if j < n:\n if ((i >> j) & 1):\n sum_i += now\n now = 0\n else:\n sum_i += now\n ",
"j < n",
"j",
"n",
"if ((i >> j) & 1):\n sum_i += now\n now = 0\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"sum_i += now",
"sum_i",
"now",
"now = 0",
"now",
"0",
"sum_i += now",
"sum_i",
"now",
"result += sum_i",
"result",
"sum_i",
"return result",
"result",
"S",
"S",
"S = input()",
"S",
"input()",
"input",
"print(solve(S))",
"print",
"solve(S)",
"solve",
"S",
"S = input()",
"input()",
"S",
"def solve(S):\n n = len(S) - 1\n result = 0\n for i in range(2**n):\n sum_i = 0\n now = 0\n for j in range(n+1):\n now = now * 10 + int(S[j])\n if j < n:\n if ((i >> j) & 1):\n sum_i += now\n now = 0\n else:\n sum_i += now\n result += sum_i\n return result",
"def solve(S):\n n = len(S) - 1\n result = 0\n for i in range(2**n):\n sum_i = 0\n now = 0\n for j in range(n+1):\n now = now * 10 + int(S[j])\n if j < n:\n if ((i >> j) & 1):\n sum_i += now\n now = 0\n else:\n sum_i += now\n result += sum_i\n return result",
"solve"
] | def solve(S):
n = len(S) - 1
result = 0
for i in range(2**n):
sum_i = 0
now = 0
for j in range(n+1):
now = now * 10 + int(S[j])
if j < n:
if ((i >> j) & 1):
sum_i += now
now = 0
else:
sum_i += now
result += sum_i
return result
S = input()
print(solve(S)) |
[
7,
12,
13,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
29,
2,
4,
13,
2,
13,
18,
13,
2,
13,
17,
2,
13,
17,
4,
13,
2,
2,
13,
17,
18,
13,
2,
13,
17,
2,
13,
17,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
4,
13,
18,
13,
17,
17,
10,
12,
13,
10,
4,
13
] | [
[
53,
5
],
[
51,
19
],
[
51,
27
],
[
53,
31
],
[
53,
34
],
[
51,
40
],
[
53,
45
],
[
53,
48
],
[
51,
51
],
[
53,
53
],
[
70,
55
],
[
68,
61
],
[
71,
63
],
[
70,
71
]
] | [
"#ๅ
ฅๅ\n#้ขๆฐใธ\n#้ขๆฐ\n #\ndef a(t,i):\n if i == len(s)-1:\n return sum(map(int,t.split('+')))\n return a(t+s[i+1],i+1) + a(t+'+'+s[i+1],i+1) #้ขๆฐใฎไธญใซๅ
ฅใใใจๆๅพใฎ้
ใงใพใจใใฆๅฆ็ใงใใ\ns = input()\nprint(a(s[0],0))",
"def a(t,i):\n if i == len(s)-1:\n return sum(map(int,t.split('+')))\n return a(t+s[i+1],i+1) + a(t+'+'+s[i+1],i+1) #้ขๆฐใฎไธญใซๅ
ฅใใใจๆๅพใฎ้
ใงใพใจใใฆๅฆ็ใงใใ",
"a",
"if i == len(s)-1:\n return sum(map(int,t.split('+')))\n ",
"i == len(s)-1",
"i",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"return sum(map(int,t.split('+')))",
"sum(map(int,t.split('+')))",
"sum",
"map(int,t.split('+'))",
"map",
"int",
"t.split('+')",
"t.split",
"t",
"split",
"'+'",
"return a(t+s[i+1],i+1) + a(t+'+'+s[i+1],i+1)",
"a(t+s[i+1],i+1) + a(t+'+'+s[i+1],i+1)",
"a(t+s[i+1],i+1)",
"a",
"t+s[i+1]",
"t",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"a(t+'+'+s[i+1],i+1)",
"a",
"t+'+'+s[i+1]",
"t+'+'",
"t",
"'+'",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"t",
"t",
"i",
"i",
"s = input()",
"s",
"input()",
"input",
"print(a(s[0],0))",
"print",
"a(s[0],0)",
"a",
"s[0]",
"s",
"0",
"0",
"def a(t,i):\n if i == len(s)-1:\n return sum(map(int,t.split('+')))\n return a(t+s[i+1],i+1) + a(t+'+'+s[i+1],i+1) #้ขๆฐใฎไธญใซๅ
ฅใใใจๆๅพใฎ้
ใงใพใจใใฆๅฆ็ใงใใ",
"def a(t,i):\n if i == len(s)-1:\n return sum(map(int,t.split('+')))\n return a(t+s[i+1],i+1) + a(t+'+'+s[i+1],i+1) #้ขๆฐใฎไธญใซๅ
ฅใใใจๆๅพใฎ้
ใงใพใจใใฆๅฆ็ใงใใ",
"a",
"s = input()",
"input()",
"s"
] | #ๅ
ฅๅ
#้ขๆฐใธ
#้ขๆฐ
#
def a(t,i):
if i == len(s)-1:
return sum(map(int,t.split('+')))
return a(t+s[i+1],i+1) + a(t+'+'+s[i+1],i+1) #้ขๆฐใฎไธญใซๅ
ฅใใใจๆๅพใฎ้
ใงใพใจใใฆๅฆ็ใงใใ
s = input()
print(a(s[0],0)) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
72,
2
],
[
69,
6
],
[
73,
9
],
[
78,
11
],
[
15,
14
],
[
70,
20
],
[
66,
23
],
[
27,
26
],
[
70,
30
],
[
14,
35
],
[
26,
36
],
[
81,
39
],
[
73,
43
],
[
26,
47
],
[
75,
50
],
[
26,
52
],
[
84,
55
],
[
73,
59
],
[
85,
64
],
[
82,
64
],
[
79,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
]
] | [
"s=input()\n\nl=len(s)\n\ncount=0\nfor i in range(2**(l-1)):\n memory=0\n for j in range(l-1):\n if ((i>>j)&1):\n #print(int(s[memory:j+1]))\n count+=int(s[memory:j+1])\n memory=j+1\n #print(int(s[memory:]))\n count+=int(s[memory:])\n\nprint(count)",
"s=input()",
"s",
"input()",
"input",
"l=len(s)",
"l",
"len(s)",
"len",
"s",
"count=0",
"count",
"0",
"for i in range(2**(l-1)):\n memory=0\n for j in range(l-1):\n if ((i>>j)&1):\n #print(int(s[memory:j+1]))\n count+=int(s[memory:j+1])\n memory=j+1\n #print(int(s[memory:]))\n count+=int(s[memory:])",
"i",
"range(2**(l-1))",
"range",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"memory=0",
"memory",
"0",
"for j in range(l-1):\n if ((i>>j)&1):\n #print(int(s[memory:j+1]))\n count+=int(s[memory:j+1])\n memory=j+1\n #print(int(s[memory:]))\n ",
"j",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if ((i>>j)&1):\n #print(int(s[memory:j+1]))\n count+=int(s[memory:j+1])\n memory=j+1\n #print(int(s[memory:]))\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"count+=int(s[memory:j+1])",
"count",
"int(s[memory:j+1])",
"int",
"s[memory:j+1]",
"s",
"memory:j+1",
"memory",
"j+1",
"j",
"1",
"memory=j+1",
"memory",
"j+1",
"j",
"1",
"count+=int(s[memory:])",
"count",
"int(s[memory:])",
"int",
"s[memory:]",
"s",
"memory:",
"memory",
"print(count)",
"print",
"count",
"memory=0",
"0",
"memory",
"l=len(s)",
"len(s)",
"l",
"s=input()",
"input()",
"s",
"memory=j+1",
"j+1",
"memory",
"count=0",
"0",
"count",
"count+=int(s[memory:j+1])",
"int(s[memory:j+1])",
"count",
"count+=int(s[memory:])",
"int(s[memory:])",
"count"
] | s=input()
l=len(s)
count=0
for i in range(2**(l-1)):
memory=0
for j in range(l-1):
if ((i>>j)&1):
#print(int(s[memory:j+1]))
count+=int(s[memory:j+1])
memory=j+1
#print(int(s[memory:]))
count+=int(s[memory:])
print(count) |
[
7,
0,
13,
4,
13,
12,
13,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
29,
2,
4,
13,
2,
13,
18,
13,
2,
13,
17,
2,
13,
17,
4,
13,
17,
2,
13,
17,
23,
13,
23,
13,
4,
13,
4,
13,
18,
13,
17,
17,
10,
12,
13,
10,
4,
13
] | [
[
62,
2
],
[
49,
9
],
[
63,
13
],
[
47,
23
],
[
47,
31
],
[
63,
33
],
[
49,
35
],
[
49,
38
],
[
49,
44
],
[
47,
47
],
[
49,
49
],
[
60,
53
],
[
63,
55
],
[
62,
63
]
] | [
"S=input()\ndef dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)\nprint(dfs(S[0],0))",
"S=input()",
"S",
"input()",
"input",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs",
"if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n ",
"i==len(S)-1",
"i",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"return sum(map(int,s.split(\"+\")))",
"sum(map(int,s.split(\"+\")))",
"sum",
"map(int,s.split(\"+\"))",
"map",
"int",
"s.split(\"+\")",
"s.split",
"s",
"split",
"\"+\"",
"return dfs(s+S[i+1],i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs(s+S[i+1],i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs(s+S[i+1],i+1)",
"dfs",
"s+S[i+1]",
"s",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs",
"f\"{s}+{S[i+1]}\"",
"i+1",
"i",
"1",
"s",
"s",
"i",
"i",
"print(dfs(S[0],0))",
"print",
"dfs(S[0],0)",
"dfs",
"S[0]",
"S",
"0",
"0",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(s+S[i+1],i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs",
"S=input()",
"input()",
"S"
] | S=input()
def dfs(s,i):
if i==len(S)-1:
return sum(map(int,s.split("+")))
return dfs(s+S[i+1],i+1)+dfs(f"{s}+{S[i+1]}",i+1)
print(dfs(S[0],0)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
2,
39,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
0,
18,
13,
13,
17,
0,
13,
39,
0,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
4,
13,
13,
14,
2,
2,
13,
17,
17,
4,
18,
13,
13,
18,
13,
13,
0,
13,
17,
4,
18,
13,
13,
18,
13,
13,
0,
13,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
18,
13,
13,
17,
17,
0,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13
] | [
[
136,
2
],
[
139,
8
],
[
12,
11
],
[
137,
19
],
[
157,
22
],
[
137,
29
],
[
33,
32
],
[
137,
38
],
[
11,
43
],
[
32,
44
],
[
50,
47
],
[
158,
48
],
[
32,
49
],
[
154,
52
],
[
160,
55
],
[
130,
58
],
[
142,
61
],
[
65,
64
],
[
158,
70
],
[
137,
73
],
[
64,
77
],
[
155,
82
],
[
146,
82
],
[
152,
82
],
[
137,
85
],
[
131,
86
],
[
134,
86
],
[
133,
88
],
[
155,
92
],
[
146,
92
],
[
152,
92
],
[
158,
95
],
[
143,
96
],
[
128,
96
],
[
127,
98
],
[
151,
101
],
[
155,
106
],
[
146,
106
],
[
152,
106
],
[
145,
108
],
[
152,
111
],
[
155,
111
],
[
146,
111
],
[
148,
116
],
[
146,
119
],
[
152,
119
],
[
155,
119
],
[
163,
121
],
[
149,
122
],
[
161,
122
],
[
164,
125
],
[
140,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
149,
163
],
[
161,
163
],
[
163,
164
]
] | [
"S=list(input())\nans=0\nfor i in range(2**(len(S)-1)):\n kari=[\"\"]*(len(S)-1)\n for j in range(len(S)-1):\n if ((i>>j)&1):\n kari[j]=\"+\"\n hako=[]\n kotae=0\n kasu=0\n gomi=0\n for j in range(len(kari)+len(S)):\n if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n hako=\",\".join(hako)\n hako=hako.replace(\",\",\"\")\n #print(hako)\n kotae=eval(hako)\n ans+=kotae\nprint(ans)",
"S=list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"ans=0",
"ans",
"0",
"for i in range(2**(len(S)-1)):\n kari=[\"\"]*(len(S)-1)\n for j in range(len(S)-1):\n if ((i>>j)&1):\n kari[j]=\"+\"\n hako=[]\n kotae=0\n kasu=0\n gomi=0\n for j in range(len(kari)+len(S)):\n if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n hako=\",\".join(hako)\n hako=hako.replace(\",\",\"\")\n #print(hako)\n kotae=eval(hako)\n ans+=kotae",
"i",
"range(2**(len(S)-1))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"kari=[\"\"]*(len(S)-1)",
"kari",
"[\"\"]*(len(S)-1)",
"[\"\"]",
"\"\"",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"for j in range(len(S)-1):\n if ((i>>j)&1):\n kari[j]=\"+\"\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if ((i>>j)&1):\n kari[j]=\"+\"\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"kari[j]=\"+\"",
"kari[j]",
"kari",
"j",
"\"+\"",
"hako=[]",
"hako",
"[]",
"kotae=0",
"kotae",
"0",
"kasu=0",
"kasu",
"0",
"gomi=0",
"gomi",
"0",
"for j in range(len(kari)+len(S)):\n if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n ",
"j",
"range(len(kari)+len(S))",
"range",
"len(kari)+len(S)",
"len(kari)",
"len",
"kari",
"len(S)",
"len",
"S",
"if j%2==0:\n hako.append(S[kasu])\n kasu+=1\n else:\n hako.append(kari[gomi])\n gomi+=1\n #print(hako)\n ",
"j%2==0",
"j%2",
"j",
"2",
"0",
"hako.append(S[kasu])",
"hako.append",
"hako",
"append",
"S[kasu]",
"S",
"kasu",
"kasu+=1",
"kasu",
"1",
"hako.append(kari[gomi])",
"hako.append",
"hako",
"append",
"kari[gomi]",
"kari",
"gomi",
"gomi+=1",
"gomi",
"1",
"hako=\",\".join(hako)",
"hako",
"\",\".join(hako)",
"\",\".join",
"\",\"",
"join",
"hako",
"hako=hako.replace(\",\",\"\")",
"hako",
"hako.replace(\",\",\"\")",
"hako.replace",
"hako",
"replace",
"\",\"",
"\"\"",
"kotae=eval(hako)",
"kotae",
"eval(hako)",
"eval",
"hako",
"ans+=kotae",
"ans",
"kotae",
"print(ans)",
"print",
"ans",
"gomi+=1",
"1",
"gomi",
"kasu=0",
"0",
"kasu",
"kasu+=1",
"1",
"kasu",
"S=list(input())",
"list(input())",
"S",
"ans=0",
"0",
"ans",
"gomi=0",
"0",
"gomi",
"hako=hako.replace(\",\",\"\")",
"hako.replace(\",\",\"\")",
"hako",
"kotae=eval(hako)",
"eval(hako)",
"kotae",
"hako=\",\".join(hako)",
"\",\".join(hako)",
"hako",
"hako=[]",
"[]",
"hako",
"kari=[\"\"]*(len(S)-1)",
"[\"\"]*(len(S)-1)",
"kari",
"kotae=0",
"0",
"kotae",
"ans+=kotae",
"kotae",
"ans"
] | S=list(input())
ans=0
for i in range(2**(len(S)-1)):
kari=[""]*(len(S)-1)
for j in range(len(S)-1):
if ((i>>j)&1):
kari[j]="+"
hako=[]
kotae=0
kasu=0
gomi=0
for j in range(len(kari)+len(S)):
if j%2==0:
hako.append(S[kasu])
kasu+=1
else:
hako.append(kari[gomi])
gomi+=1
#print(hako)
hako=",".join(hako)
hako=hako.replace(",","")
#print(hako)
kotae=eval(hako)
ans+=kotae
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
39,
0,
13,
17,
12,
13,
14,
2,
4,
13,
13,
13,
4,
18,
13,
13,
2,
13,
17,
29,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
23,
13,
4,
13,
17,
28,
13,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
17,
14,
40,
4,
13,
18,
13,
39,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
13,
0,
13,
13,
4,
13,
4,
13,
2,
13,
17,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13
] | [
[
114,
2
],
[
96,
6
],
[
115,
9
],
[
93,
11
],
[
99,
14
],
[
43,
22
],
[
97,
23
],
[
94,
26
],
[
43,
29
],
[
43,
35
],
[
43,
40
],
[
43,
43
],
[
106,
45
],
[
49,
48
],
[
94,
48
],
[
108,
51
],
[
48,
58
],
[
115,
68
],
[
102,
74
],
[
115,
78
],
[
111,
83
],
[
103,
90
],
[
100,
90
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
108,
109
],
[
111,
112
],
[
114,
115
]
] | [
"S = input()\nsize = len(S)\npatterns = []\nans = 0\n\ndef flagfun(flag):\n if len(flag) == size:\n patterns.append(flag+\"1\")\n return\n \n flagfun(flag+'0')\n flagfun(flag+'1')\n\nflagfun('')\n\nfor pattern in patterns:\n lastKey = 0\n for k, v in enumerate(pattern):\n if v == \"1\":\n if len(S[lastKey:k]) != 0:\n ans += int(S[lastKey:k])\n lastKey = k\n\nprint(int(ans/2))",
"S = input()",
"S",
"input()",
"input",
"size = len(S)",
"size",
"len(S)",
"len",
"S",
"patterns = []",
"patterns",
"[]",
"ans = 0",
"ans",
"0",
"def flagfun(flag):\n if len(flag) == size:\n patterns.append(flag+\"1\")\n return\n \n flagfun(flag+'0')\n flagfun(flag+'1')",
"flagfun",
"if len(flag) == size:\n patterns.append(flag+\"1\")\n return\n \n ",
"len(flag) == size",
"len(flag)",
"len",
"flag",
"size",
"patterns.append(flag+\"1\")",
"patterns.append",
"patterns",
"append",
"flag+\"1\"",
"flag",
"\"1\"",
"return",
"flagfun(flag+'0')",
"flagfun",
"flag+'0'",
"flag",
"'0'",
"flagfun(flag+'1')",
"flagfun",
"flag+'1'",
"flag",
"'1'",
"flag",
"flag",
"flagfun('')",
"flagfun",
"''",
"for pattern in patterns:\n lastKey = 0\n for k, v in enumerate(pattern):\n if v == \"1\":\n if len(S[lastKey:k]) != 0:\n ans += int(S[lastKey:k])\n lastKey = k",
"pattern",
"patterns",
"lastKey = 0",
"lastKey",
"0",
"for k, v in enumerate(pattern):\n if v == \"1\":\n if len(S[lastKey:k]) != 0:\n ans += int(S[lastKey:k])\n lastKey = k",
"k",
"v",
"enumerate(pattern)",
"enumerate",
"pattern",
"if v == \"1\":\n if len(S[lastKey:k]) != 0:\n ans += int(S[lastKey:k])\n lastKey = k",
"v == \"1\"",
"v",
"\"1\"",
"if len(S[lastKey:k]) != 0:\n ans += int(S[lastKey:k])\n lastKey = k",
"len(S[lastKey:k]) != 0",
"len(S[lastKey:k])",
"len",
"S[lastKey:k]",
"S",
"lastKey:k",
"lastKey",
"k",
"0",
"ans += int(S[lastKey:k])",
"ans",
"int(S[lastKey:k])",
"int",
"S[lastKey:k]",
"S",
"lastKey:k",
"lastKey",
"k",
"lastKey = k",
"lastKey",
"k",
"print(int(ans/2))",
"print",
"int(ans/2)",
"int",
"ans/2",
"ans",
"2",
"patterns = []",
"[]",
"patterns",
"size = len(S)",
"len(S)",
"size",
"ans = 0",
"0",
"ans",
"ans += int(S[lastKey:k])",
"int(S[lastKey:k])",
"ans",
"def flagfun(flag):\n if len(flag) == size:\n patterns.append(flag+\"1\")\n return\n \n flagfun(flag+'0')\n flagfun(flag+'1')",
"def flagfun(flag):\n if len(flag) == size:\n patterns.append(flag+\"1\")\n return\n \n flagfun(flag+'0')\n flagfun(flag+'1')",
"flagfun",
"lastKey = 0",
"0",
"lastKey",
"lastKey = k",
"k",
"lastKey",
"S = input()",
"input()",
"S"
] | S = input()
size = len(S)
patterns = []
ans = 0
def flagfun(flag):
if len(flag) == size:
patterns.append(flag+"1")
return
flagfun(flag+'0')
flagfun(flag+'1')
flagfun('')
for pattern in patterns:
lastKey = 0
for k, v in enumerate(pattern):
if v == "1":
if len(S[lastKey:k]) != 0:
ans += int(S[lastKey:k])
lastKey = k
print(int(ans/2)) |
[
7,
15,
13,
12,
13,
0,
13,
4,
13,
0,
13,
39,
12,
13,
14,
2,
13,
17,
4,
18,
13,
13,
39,
18,
13,
17,
0,
13,
39,
28,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
4,
18,
13,
13,
2,
18,
13,
17,
18,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
13,
13,
13,
23,
13,
28,
13,
4,
13,
4,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
18,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
11,
10
],
[
97,
16
],
[
10,
20
],
[
6,
24
],
[
28,
27
],
[
31,
30
],
[
10,
32
],
[
97,
34
],
[
38,
37
],
[
30,
44
],
[
37,
47
],
[
66,
47
],
[
37,
51
],
[
66,
51
],
[
30,
55
],
[
6,
58
],
[
97,
59
],
[
27,
62
],
[
37,
64
],
[
66,
64
],
[
67,
66
],
[
30,
73
],
[
66,
76
],
[
37,
76
],
[
6,
79
],
[
97,
80
],
[
27,
83
],
[
66,
85
],
[
37,
85
],
[
88,
87
],
[
27,
90
],
[
10,
93
],
[
87,
95
],
[
27,
95
],
[
97,
97
],
[
100,
99
],
[
6,
104
],
[
13,
106
],
[
99,
107
],
[
110,
109
],
[
113,
112
],
[
10,
114
],
[
118,
117
],
[
112,
117
],
[
121,
120
],
[
117,
123
],
[
120,
126
],
[
109,
126
],
[
135,
132
]
] | [
"import copy\n\n\ndef main():\n target = input()\n\n num_list = []\n\n def function(n):\n if n == 0:\n num_list.append([(target[0], )])\n else:\n ans = []\n for i in num_list[n-1]:\n m = list(copy.copy(i))\n m.pop()\n m.append(i[-1] + target[n])\n ans.append(m)\n m = list(copy.copy(i))\n m.append(target[n])\n ans.append(m)\n ans = tuple(ans)\n num_list.append(ans)\n for x in range(len(target)):\n function(x)\n # print(num_list[-1])\n answer = 0\n for x in num_list[-1]:\n for y in x:\n answer += int(y)\n print(answer)\n\n\nif __name__ == '__main__':\n main()",
"import copy",
"copy",
"def main():\n target = input()\n\n num_list = []\n\n def function(n):\n if n == 0:\n num_list.append([(target[0], )])\n else:\n ans = []\n for i in num_list[n-1]:\n m = list(copy.copy(i))\n m.pop()\n m.append(i[-1] + target[n])\n ans.append(m)\n m = list(copy.copy(i))\n m.append(target[n])\n ans.append(m)\n ans = tuple(ans)\n num_list.append(ans)\n for x in range(len(target)):\n function(x)\n # print(num_list[-1])\n answer = 0\n for x in num_list[-1]:\n for y in x:\n answer += int(y)\n print(answer)",
"main",
"target = input()",
"target",
"input()",
"input",
"num_list = []",
"num_list",
"[]",
"def function(n):\n if n == 0:\n num_list.append([(target[0], )])\n else:\n ans = []\n for i in num_list[n-1]:\n m = list(copy.copy(i))\n m.pop()\n m.append(i[-1] + target[n])\n ans.append(m)\n m = list(copy.copy(i))\n m.append(target[n])\n ans.append(m)\n ans = tuple(ans)\n num_list.append(ans)\n ",
"function",
"if n == 0:\n num_list.append([(target[0], )])\n else:\n ans = []\n for i in num_list[n-1]:\n m = list(copy.copy(i))\n m.pop()\n m.append(i[-1] + target[n])\n ans.append(m)\n m = list(copy.copy(i))\n m.append(target[n])\n ans.append(m)\n ans = tuple(ans)\n num_list.append(ans)\n ",
"n == 0",
"n",
"0",
"num_list.append([(target[0], )])",
"num_list.append",
"num_list",
"append",
"[(target[0], )]",
"target[0]",
"target",
"0",
"ans = []",
"ans",
"[]",
"for i in num_list[n-1]:\n m = list(copy.copy(i))\n m.pop()\n m.append(i[-1] + target[n])\n ans.append(m)\n m = list(copy.copy(i))\n m.append(target[n])\n ans.append(m)\n ",
"i",
"num_list[n-1]",
"num_list",
"n-1",
"n",
"1",
"m = list(copy.copy(i))",
"m",
"list(copy.copy(i))",
"list",
"copy.copy(i)",
"copy.copy",
"copy",
"copy",
"i",
"m.pop()",
"m.pop",
"m",
"pop",
"m.append(i[-1] + target[n])",
"m.append",
"m",
"append",
"i[-1] + target[n]",
"i[-1]",
"i",
"-1",
"target[n]",
"target",
"n",
"ans.append(m)",
"ans.append",
"ans",
"append",
"m",
"m = list(copy.copy(i))",
"m",
"list(copy.copy(i))",
"list",
"copy.copy(i)",
"copy.copy",
"copy",
"copy",
"i",
"m.append(target[n])",
"m.append",
"m",
"append",
"target[n]",
"target",
"n",
"ans.append(m)",
"ans.append",
"ans",
"append",
"m",
"ans = tuple(ans)",
"ans",
"tuple(ans)",
"tuple",
"ans",
"num_list.append(ans)",
"num_list.append",
"num_list",
"append",
"ans",
"n",
"n",
"for x in range(len(target)):\n function(x)\n # print(num_list[-1])\n ",
"x",
"range(len(target))",
"range",
"len(target)",
"len",
"target",
"function(x)",
"function",
"x",
"answer = 0",
"answer",
"0",
"for x in num_list[-1]:\n for y in x:\n answer += int(y)\n ",
"x",
"num_list[-1]",
"num_list",
"-1",
"for y in x:\n answer += int(y)\n ",
"y",
"x",
"answer += int(y)",
"answer",
"int(y)",
"int",
"y",
"print(answer)",
"print",
"answer",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n target = input()\n\n num_list = []\n\n def function(n):\n if n == 0:\n num_list.append([(target[0], )])\n else:\n ans = []\n for i in num_list[n-1]:\n m = list(copy.copy(i))\n m.pop()\n m.append(i[-1] + target[n])\n ans.append(m)\n m = list(copy.copy(i))\n m.append(target[n])\n ans.append(m)\n ans = tuple(ans)\n num_list.append(ans)\n for x in range(len(target)):\n function(x)\n # print(num_list[-1])\n answer = 0\n for x in num_list[-1]:\n for y in x:\n answer += int(y)\n print(answer)",
"def main():\n target = input()\n\n num_list = []\n\n def function(n):\n if n == 0:\n num_list.append([(target[0], )])\n else:\n ans = []\n for i in num_list[n-1]:\n m = list(copy.copy(i))\n m.pop()\n m.append(i[-1] + target[n])\n ans.append(m)\n m = list(copy.copy(i))\n m.append(target[n])\n ans.append(m)\n ans = tuple(ans)\n num_list.append(ans)\n for x in range(len(target)):\n function(x)\n # print(num_list[-1])\n answer = 0\n for x in num_list[-1]:\n for y in x:\n answer += int(y)\n print(answer)",
"main"
] | import copy
def main():
target = input()
num_list = []
def function(n):
if n == 0:
num_list.append([(target[0], )])
else:
ans = []
for i in num_list[n-1]:
m = list(copy.copy(i))
m.pop()
m.append(i[-1] + target[n])
ans.append(m)
m = list(copy.copy(i))
m.append(target[n])
ans.append(m)
ans = tuple(ans)
num_list.append(ans)
for x in range(len(target)):
function(x)
# print(num_list[-1])
answer = 0
for x in num_list[-1]:
for y in x:
answer += int(y)
print(answer)
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
2,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
18,
17,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13
] | [
[
91,
2
],
[
106,
6
],
[
100,
9
],
[
92,
15
],
[
19,
18
],
[
101,
21
],
[
115,
23
],
[
92,
31
],
[
103,
34
],
[
18,
37
],
[
116,
38
],
[
109,
40
],
[
94,
43
],
[
47,
46
],
[
92,
52
],
[
104,
57
],
[
46,
58
],
[
112,
61
],
[
92,
65
],
[
46,
69
],
[
118,
72
],
[
46,
74
],
[
97,
77
],
[
92,
81
],
[
121,
85
],
[
98,
86
],
[
113,
86
],
[
110,
86
],
[
122,
89
],
[
107,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
98,
121
],
[
113,
121
],
[
110,
121
],
[
121,
122
]
] | [
"s = input()\n\nsum = 0\ntmp = 2 ** (len(s) -1)\n\nfor i in range(tmp):\n format_spec = '0{}b'.format(len(s)-1)\n flag = format(i, format_spec)\n my_sum = 0\n before = 0\n for j in range(len(s) - 1):\n if flag[j] == '1':\n my_sum += int(s[before:j+1])\n before = j+1\n my_sum += int(s[before:])\n sum += my_sum\n\nprint(sum)",
"s = input()",
"s",
"input()",
"input",
"sum = 0",
"sum",
"0",
"tmp = 2 ** (len(s) -1)",
"tmp",
"2 ** (len(s) -1)",
"2",
"len(s) -1",
"len(s)",
"len",
"s",
"1",
"for i in range(tmp):\n format_spec = '0{}b'.format(len(s)-1)\n flag = format(i, format_spec)\n my_sum = 0\n before = 0\n for j in range(len(s) - 1):\n if flag[j] == '1':\n my_sum += int(s[before:j+1])\n before = j+1\n my_sum += int(s[before:])\n sum += my_sum",
"i",
"range(tmp)",
"range",
"tmp",
"format_spec = '0{}b'.format(len(s)-1)",
"format_spec",
"'0{}b'.format(len(s)-1)",
"'0{}b'.format",
"'0{}b'",
"format",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"flag = format(i, format_spec)",
"flag",
"format(i, format_spec)",
"format",
"i",
"format_spec",
"my_sum = 0",
"my_sum",
"0",
"before = 0",
"before",
"0",
"for j in range(len(s) - 1):\n if flag[j] == '1':\n my_sum += int(s[before:j+1])\n before = j+1\n ",
"j",
"range(len(s) - 1)",
"range",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"if flag[j] == '1':\n my_sum += int(s[before:j+1])\n before = j+1\n ",
"flag[j] == '1'",
"flag[j]",
"flag",
"j",
"'1'",
"my_sum += int(s[before:j+1])",
"my_sum",
"int(s[before:j+1])",
"int",
"s[before:j+1]",
"s",
"before:j+1",
"before",
"j+1",
"j",
"1",
"before = j+1",
"before",
"j+1",
"j",
"1",
"my_sum += int(s[before:])",
"my_sum",
"int(s[before:])",
"int",
"s[before:]",
"s",
"before:",
"before",
"sum += my_sum",
"sum",
"my_sum",
"print(sum)",
"print",
"sum",
"s = input()",
"input()",
"s",
"before = 0",
"0",
"before",
"my_sum += int(s[before:])",
"int(s[before:])",
"my_sum",
"tmp = 2 ** (len(s) -1)",
"2 ** (len(s) -1)",
"tmp",
"flag = format(i, format_spec)",
"format(i, format_spec)",
"flag",
"sum = 0",
"0",
"sum",
"my_sum = 0",
"0",
"my_sum",
"my_sum += int(s[before:j+1])",
"int(s[before:j+1])",
"my_sum",
"format_spec = '0{}b'.format(len(s)-1)",
"'0{}b'.format(len(s)-1)",
"format_spec",
"before = j+1",
"j+1",
"before",
"sum += my_sum",
"my_sum",
"sum"
] | s = input()
sum = 0
tmp = 2 ** (len(s) -1)
for i in range(tmp):
format_spec = '0{}b'.format(len(s)-1)
flag = format(i, format_spec)
my_sum = 0
before = 0
for j in range(len(s) - 1):
if flag[j] == '1':
my_sum += int(s[before:j+1])
before = j+1
my_sum += int(s[before:])
sum += my_sum
print(sum) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
85,
2
],
[
73,
6
],
[
86,
9
],
[
76,
11
],
[
74,
13
],
[
70,
16
],
[
20,
19
],
[
77,
24
],
[
79,
26
],
[
86,
28
],
[
32,
31
],
[
77,
34
],
[
19,
37
],
[
31,
40
],
[
88,
42
],
[
67,
45
],
[
86,
47
],
[
31,
49
],
[
82,
52
],
[
68,
60
],
[
89,
60
],
[
80,
60
],
[
83,
65
],
[
71,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] | [
"S = input() #lๆกใฎๆฐๅญใๆๅญๅๅใงๅ
ฅๅ\nl = len(S) # ๆๅญๅใฎ้ทใ\nn = l - 1 # ๆๅญๅใฎ้ใฎๆฐ\nans = 0\nfor bit in range(1 << n): # 0ใใ((1ใnใ ใๅณใทใใใใๆฐ)-1)ใพใงใฎforๆ\n s = S[0]\n for i in range(n):\n if (bit & (1 << i)):\n s += '+'\n s += S[i+1]\n ans += sum(map(int, s.split('+')))\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"l = len(S)",
"l",
"len(S)",
"len",
"S",
"n = l - 1",
"n",
"l - 1",
"l",
"1",
"ans = 0",
"ans",
"0",
"for bit in range(1 << n): # 0ใใ((1ใnใ ใๅณใทใใใใๆฐ)-1)ใพใงใฎforๆ\n s = S[0]\n for i in range(n):\n if (bit & (1 << i)):\n s += '+'\n s += S[i+1]\n ans += sum(map(int, s.split('+')))",
"bit",
"range(1 << n)",
"range",
"1 << n",
"1",
"n",
"s = S[0]",
"s",
"S[0]",
"S",
"0",
"for i in range(n):\n if (bit & (1 << i)):\n s += '+'\n s += S[i+1]\n ",
"i",
"range(n)",
"range",
"n",
"if (bit & (1 << i)):\n s += '+'\n ",
"bit & (1 << i)",
"bit",
"1 << i",
"1",
"i",
"s += '+'",
"s",
"'+'",
"s += S[i+1]",
"s",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"ans += sum(map(int, s.split('+')))",
"ans",
"sum(map(int, s.split('+')))",
"sum",
"map(int, s.split('+'))",
"map",
"int",
"s.split('+')",
"s.split",
"s",
"split",
"'+'",
"print(ans)",
"print",
"ans",
"s += S[i+1]",
"S[i+1]",
"s",
"ans = 0",
"0",
"ans",
"l = len(S)",
"len(S)",
"l",
"n = l - 1",
"l - 1",
"n",
"s = S[0]",
"S[0]",
"s",
"ans += sum(map(int, s.split('+')))",
"sum(map(int, s.split('+')))",
"ans",
"S = input()",
"input()",
"S",
"s += '+'",
"'+'",
"s"
] | S = input() #lๆกใฎๆฐๅญใๆๅญๅๅใงๅ
ฅๅ
l = len(S) # ๆๅญๅใฎ้ทใ
n = l - 1 # ๆๅญๅใฎ้ใฎๆฐ
ans = 0
for bit in range(1 << n): # 0ใใ((1ใnใ ใๅณใทใใใใๆฐ)-1)ใพใงใฎforๆ
s = S[0]
for i in range(n):
if (bit & (1 << i)):
s += '+'
s += S[i+1]
ans += sum(map(int, s.split('+')))
print(ans) |
[
7,
15,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
39,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
13,
28,
13,
4,
13,
4,
13,
13,
14,
18,
13,
13,
0,
13,
2,
4,
13,
13,
2,
13,
17,
0,
13,
2,
2,
18,
13,
39,
13,
17,
18,
13,
39,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13
] | [
[
83,
3
],
[
74,
7
],
[
11,
10
],
[
18,
17
],
[
84,
21
],
[
89,
24
],
[
84,
25
],
[
28,
27
],
[
10,
32
],
[
10,
35
],
[
27,
36
],
[
80,
38
],
[
84,
42
],
[
27,
44
],
[
86,
47
],
[
90,
51
],
[
87,
51
],
[
90,
56
],
[
87,
56
],
[
77,
60
],
[
87,
68
],
[
90,
68
],
[
78,
72
],
[
75,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
84,
89
],
[
89,
90
]
] | [
"from itertools import product\n\nS = input()\n\ns = 0\nfor bits in product((False, True), repeat=len(S) - 1):\n buf = S\n for i in range(len(bits)):\n if bits[i]:\n sep = len(S) - (i + 1)\n buf = buf[:sep] + ' ' + buf[sep:]\n s += sum(map(int, buf.split()))\n\nprint(s)",
"from itertools import product",
"S = input()",
"S",
"input()",
"input",
"s = 0",
"s",
"0",
"for bits in product((False, True), repeat=len(S) - 1):\n buf = S\n for i in range(len(bits)):\n if bits[i]:\n sep = len(S) - (i + 1)\n buf = buf[:sep] + ' ' + buf[sep:]\n s += sum(map(int, buf.split()))",
"bits",
"product((False, True), repeat=len(S) - 1)",
"product",
"(False, True)",
"False",
"True",
"repeat=len(S) - 1",
"repeat",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"buf = S",
"buf",
"S",
"for i in range(len(bits)):\n if bits[i]:\n sep = len(S) - (i + 1)\n buf = buf[:sep] + ' ' + buf[sep:]\n ",
"i",
"range(len(bits))",
"range",
"len(bits)",
"len",
"bits",
"if bits[i]:\n sep = len(S) - (i + 1)\n buf = buf[:sep] + ' ' + buf[sep:]\n ",
"bits[i]",
"bits",
"i",
"sep = len(S) - (i + 1)",
"sep",
"len(S) - (i + 1)",
"len(S)",
"len",
"S",
"i + 1",
"i",
"1",
"buf = buf[:sep] + ' ' + buf[sep:]",
"buf",
"buf[:sep] + ' ' + buf[sep:]",
"buf[:sep] + ' '",
"buf[:sep]",
"buf",
":sep",
"sep",
"' '",
"buf[sep:]",
"buf",
"sep:",
"sep",
"s += sum(map(int, buf.split()))",
"s",
"sum(map(int, buf.split()))",
"sum",
"map(int, buf.split())",
"map",
"int",
"buf.split()",
"buf.split",
"buf",
"split",
"print(s)",
"print",
"s",
"s = 0",
"0",
"s",
"s += sum(map(int, buf.split()))",
"sum(map(int, buf.split()))",
"s",
"sep = len(S) - (i + 1)",
"len(S) - (i + 1)",
"sep",
"S = input()",
"input()",
"S",
"buf = buf[:sep] + ' ' + buf[sep:]",
"buf[:sep] + ' ' + buf[sep:]",
"buf",
"buf = S",
"S",
"buf"
] | from itertools import product
S = input()
s = 0
for bits in product((False, True), repeat=len(S) - 1):
buf = S
for i in range(len(bits)):
if bits[i]:
sep = len(S) - (i + 1)
buf = buf[:sep] + ' ' + buf[sep:]
s += sum(map(int, buf.split()))
print(s)
|
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
2,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13
] | [
[
79,
2
],
[
76,
6
],
[
70,
9
],
[
80,
15
],
[
19,
18
],
[
71,
21
],
[
85,
23
],
[
80,
25
],
[
29,
28
],
[
80,
34
],
[
18,
39
],
[
28,
40
],
[
88,
43
],
[
86,
46
],
[
83,
46
],
[
92,
46
],
[
91,
48
],
[
80,
50
],
[
28,
52
],
[
82,
55
],
[
80,
57
],
[
28,
59
],
[
73,
62
],
[
83,
65
],
[
92,
65
],
[
86,
65
],
[
74,
68
],
[
89,
68
],
[
77,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] | [
"s = input()\ntotal = 0\nn = 2**(len(s)-1)\nfor i in range(n):\n buf = s[0]\n for j in range(len(s)-1):\n if (i>>j)&1:\n total += int(buf)\n buf = s[j+1]\n else:\n buf += s[j+1]\n total += int(buf)\nprint(total)",
"s = input()",
"s",
"input()",
"input",
"total = 0",
"total",
"0",
"n = 2**(len(s)-1)",
"n",
"2**(len(s)-1)",
"2",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"for i in range(n):\n buf = s[0]\n for j in range(len(s)-1):\n if (i>>j)&1:\n total += int(buf)\n buf = s[j+1]\n else:\n buf += s[j+1]\n total += int(buf)",
"i",
"range(n)",
"range",
"n",
"buf = s[0]",
"buf",
"s[0]",
"s",
"0",
"for j in range(len(s)-1):\n if (i>>j)&1:\n total += int(buf)\n buf = s[j+1]\n else:\n buf += s[j+1]\n ",
"j",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if (i>>j)&1:\n total += int(buf)\n buf = s[j+1]\n else:\n buf += s[j+1]\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"total += int(buf)",
"total",
"int(buf)",
"int",
"buf",
"buf = s[j+1]",
"buf",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"buf += s[j+1]",
"buf",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"total += int(buf)",
"total",
"int(buf)",
"int",
"buf",
"print(total)",
"print",
"total",
"n = 2**(len(s)-1)",
"2**(len(s)-1)",
"n",
"total += int(buf)",
"int(buf)",
"total",
"total = 0",
"0",
"total",
"s = input()",
"input()",
"s",
"buf += s[j+1]",
"s[j+1]",
"buf",
"buf = s[0]",
"s[0]",
"buf",
"total += int(buf)",
"int(buf)",
"total",
"buf = s[j+1]",
"s[j+1]",
"buf"
] | s = input()
total = 0
n = 2**(len(s)-1)
for i in range(n):
buf = s[0]
for j in range(len(s)-1):
if (i>>j)&1:
total += int(buf)
buf = s[j+1]
else:
buf += s[j+1]
total += int(buf)
print(total) |
[
7,
0,
13,
4,
13,
12,
13,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
29,
2,
4,
13,
17,
2,
13,
17,
4,
13,
17,
2,
13,
17,
23,
13,
23,
13,
4,
13,
4,
13,
18,
13,
17,
17,
10,
4,
13,
10,
12,
13
] | [
[
53,
2
],
[
43,
9
],
[
54,
13
],
[
41,
23
],
[
43,
32
],
[
43,
38
],
[
41,
41
],
[
43,
43
],
[
57,
47
],
[
54,
49
],
[
53,
54
]
] | [
"S=input()\ndef dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(f\"{s}{S[i+1]}\",i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)\nprint(dfs(S[0],0))",
"S=input()",
"S",
"input()",
"input",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(f\"{s}{S[i+1]}\",i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs",
"if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n ",
"i==len(S)-1",
"i",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"return sum(map(int,s.split(\"+\")))",
"sum(map(int,s.split(\"+\")))",
"sum",
"map(int,s.split(\"+\"))",
"map",
"int",
"s.split(\"+\")",
"s.split",
"s",
"split",
"\"+\"",
"return dfs(f\"{s}{S[i+1]}\",i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs(f\"{s}{S[i+1]}\",i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs(f\"{s}{S[i+1]}\",i+1)",
"dfs",
"f\"{s}{S[i+1]}\"",
"i+1",
"i",
"1",
"dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs",
"f\"{s}+{S[i+1]}\"",
"i+1",
"i",
"1",
"s",
"s",
"i",
"i",
"print(dfs(S[0],0))",
"print",
"dfs(S[0],0)",
"dfs",
"S[0]",
"S",
"0",
"0",
"S=input()",
"input()",
"S",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(f\"{s}{S[i+1]}\",i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"def dfs(s,i):\n if i==len(S)-1:\n return sum(map(int,s.split(\"+\")))\n return dfs(f\"{s}{S[i+1]}\",i+1)+dfs(f\"{s}+{S[i+1]}\",i+1)",
"dfs"
] | S=input()
def dfs(s,i):
if i==len(S)-1:
return sum(map(int,s.split("+")))
return dfs(f"{s}{S[i+1]}",i+1)+dfs(f"{s}+{S[i+1]}",i+1)
print(dfs(S[0],0)) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
39,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
2,
13,
13,
17,
0,
13,
2,
13,
18,
13,
2,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
12,
13,
17,
0,
13,
39,
41,
28,
13,
13,
4,
39,
2,
18,
13,
17,
39,
4,
13,
18,
13,
17,
18,
13,
2,
13,
17,
4,
18,
13,
13,
13,
41,
28,
13,
13,
4,
39,
18,
13,
17,
2,
18,
13,
17,
18,
13,
2,
13,
17,
4,
18,
13,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
41,
28,
13,
13,
4,
2,
18,
13,
17,
39,
4,
13,
18,
13,
17,
0,
13,
13,
29,
13,
29,
4,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
23,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
39,
13,
10,
4,
13,
10,
12,
13
] | [
[
189,
2
],
[
180,
6
],
[
190,
9
],
[
183,
11
],
[
15,
14
],
[
181,
20
],
[
198,
23
],
[
186,
26
],
[
190,
28
],
[
32,
31
],
[
181,
35
],
[
14,
41
],
[
31,
42
],
[
192,
45
],
[
187,
47
],
[
196,
47
],
[
193,
47
],
[
190,
49
],
[
31,
51
],
[
199,
55
],
[
187,
59
],
[
196,
59
],
[
193,
59
],
[
195,
61
],
[
190,
63
],
[
31,
65
],
[
199,
69
],
[
196,
73
],
[
193,
73
],
[
187,
73
],
[
201,
75
],
[
199,
78
],
[
202,
81
],
[
184,
81
],
[
87,
86
],
[
91,
90
],
[
178,
90
],
[
90,
96
],
[
90,
102
],
[
174,
105
],
[
176,
107
],
[
86,
111
],
[
117,
116
],
[
178,
116
],
[
116,
121
],
[
116,
125
],
[
174,
128
],
[
176,
130
],
[
86,
134
],
[
176,
139
],
[
174,
143
],
[
148,
147
],
[
86,
147
],
[
147,
152
],
[
147,
158
],
[
162,
161
],
[
161,
164
],
[
86,
164
],
[
174,
168
],
[
176,
170
],
[
161,
172
],
[
86,
172
],
[
174,
174
],
[
176,
176
],
[
178,
178
],
[
180,
181
],
[
183,
184
],
[
186,
187
],
[
189,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
201,
202
]
] | [
"# -*- coding: utf-8 -*-\nS = input()\n\nn = len(S)\n\nsum_formula = 0\n# bitๅ
จๆข็ดข\nfor bit in range(2 ** (n-1)):\n nums = []\n # ไฝใใใใทใใใใใใ\n num = S[0]\n for shift in range(n-1):\n if not ((bit >> shift)&1):\n num = num + S[shift+1]\n else:\n nums.append(int(num))\n num = S[shift+1]\n nums.append(int(num))\n sum_formula += sum(nums)\n\nprint(sum_formula)\n\n\n# ๅๅธฐ้ขๆฐ\ndef calc_all_formula(S, i, lists):\n '''\n listsใฎ่ฆ็ด : ([ๆฐๅญlist], temp_str)\n '''\n new_lists = []\n # i - i+1็ช็ฎใฎ้ใซ+ใๅ
ฅใ\n new_lists.extend(\n [(lst[0]+[int(lst[1])], S[i+1]) for lst in lists]\n )\n new_lists.extend(\n [(lst[0], lst[1]+S[i+1]) for lst in lists]\n )\n\n # base case\n if i == len(S)-2:\n new_lists = [\n lst[0]+[int(lst[1])] for lst in new_lists\n ]\n return new_lists\n \n return calc_all_formula(S, i+1, new_lists)\n\n# base_cand = [([], S[0])]\n\n# if len(S) >= 2:\n# sum_formula = sum([sum(lst) for lst in calc_all_formula(S, 0, base_cand)])\n# print(sum_formula)\n# else:\n# print(int(S))",
"S = input()",
"S",
"input()",
"input",
"n = len(S)",
"n",
"len(S)",
"len",
"S",
"sum_formula = 0",
"sum_formula",
"0",
"for bit in range(2 ** (n-1)):\n nums = []\n # ไฝใใใใทใใใใใใ\n num = S[0]\n for shift in range(n-1):\n if not ((bit >> shift)&1):\n num = num + S[shift+1]\n else:\n nums.append(int(num))\n num = S[shift+1]\n nums.append(int(num))\n sum_formula += sum(nums)",
"bit",
"range(2 ** (n-1))",
"range",
"2 ** (n-1)",
"2",
"n-1",
"n",
"1",
"nums = []",
"nums",
"[]",
"num = S[0]",
"num",
"S[0]",
"S",
"0",
"for shift in range(n-1):\n if not ((bit >> shift)&1):\n num = num + S[shift+1]\n else:\n nums.append(int(num))\n num = S[shift+1]\n ",
"shift",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if not ((bit >> shift)&1):\n num = num + S[shift+1]\n else:\n nums.append(int(num))\n num = S[shift+1]\n ",
"not ((bit >> shift)&1)",
"(bit >> shift)&1",
"bit >> shift",
"bit",
"shift",
"1",
"num = num + S[shift+1]",
"num",
"num + S[shift+1]",
"num",
"S[shift+1]",
"S",
"shift+1",
"shift",
"1",
"nums.append(int(num))",
"nums.append",
"nums",
"append",
"int(num)",
"int",
"num",
"num = S[shift+1]",
"num",
"S[shift+1]",
"S",
"shift+1",
"shift",
"1",
"nums.append(int(num))",
"nums.append",
"nums",
"append",
"int(num)",
"int",
"num",
"sum_formula += sum(nums)",
"sum_formula",
"sum(nums)",
"sum",
"nums",
"print(sum_formula)",
"print",
"sum_formula",
"def calc_all_formula(S, i, lists):\n '''\n listsใฎ่ฆ็ด : ([ๆฐๅญlist], temp_str)\n '''\n new_lists = []\n # i - i+1็ช็ฎใฎ้ใซ+ใๅ
ฅใ\n new_lists.extend(\n [(lst[0]+[int(lst[1])], S[i+1]) for lst in lists]\n )\n new_lists.extend(\n [(lst[0], lst[1]+S[i+1]) for lst in lists]\n )\n\n # base case\n if i == len(S)-2:\n new_lists = [\n lst[0]+[int(lst[1])] for lst in new_lists\n ]\n return new_lists\n \n return calc_all_formula(S, i+1, new_lists)\n\n# base_cand = [([], S[0])]\n\n# if len(S) >= 2:\n# sum_formula = sum([sum(lst) for lst in calc_all_formula(S, 0, base_cand)])\n# print(sum_formula)\n# else:\n# print(int(S))",
"calc_all_formula",
"'''\n listsใฎ่ฆ็ด : ([ๆฐๅญlist], temp_str)\n '''",
"new_lists = []",
"new_lists",
"[]",
"(lst[0]+[int(lst[1])], S[i+1]) for lst in lists",
"for lst in lists",
"lst",
"lists",
"for lst in lists",
"(lst[0]+[int(lst[1])], S[i+1])",
"lst[0]+[int(lst[1])]",
"lst[0]",
"lst",
"0",
"[int(lst[1])]",
"int(lst[1])",
"int",
"lst[1]",
"lst",
"1",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"new_lists.extend(\n [(lst[0]+[int(lst[1])], S[i+1]) for lst in lists]\n )",
"new_lists.extend",
"new_lists",
"extend",
"[(lst[0]+[int(lst[1])], S[i+1]) for lst in lists]",
"(lst[0], lst[1]+S[i+1]) for lst in lists",
"for lst in lists",
"lst",
"lists",
"for lst in lists",
"(lst[0], lst[1]+S[i+1])",
"lst[0]",
"lst",
"0",
"lst[1]+S[i+1]",
"lst[1]",
"lst",
"1",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"new_lists.extend(\n [(lst[0], lst[1]+S[i+1]) for lst in lists]\n )",
"new_lists.extend",
"new_lists",
"extend",
"[(lst[0], lst[1]+S[i+1]) for lst in lists]",
"if i == len(S)-2:\n new_lists = [\n lst[0]+[int(lst[1])] for lst in new_lists\n ]\n return new_lists\n \n ",
"i == len(S)-2",
"i",
"len(S)-2",
"len(S)",
"len",
"S",
"2",
"lst[0]+[int(lst[1])] for lst in new_lists",
"for lst in new_lists",
"lst",
"new_lists",
"for lst in new_lists",
"lst[0]+[int(lst[1])]",
"lst[0]",
"lst",
"0",
"[int(lst[1])]",
"int(lst[1])",
"int",
"lst[1]",
"lst",
"1",
"new_lists = [\n lst[0]+[int(lst[1])] for lst in new_lists\n ]",
"new_lists",
"[\n lst[0]+[int(lst[1])] for lst in new_lists\n ]",
"return new_lists",
"new_lists",
"return calc_all_formula(S, i+1, new_lists)",
"calc_all_formula(S, i+1, new_lists)",
"calc_all_formula",
"S",
"i+1",
"i",
"1",
"new_lists",
"S",
"S",
"i",
"i",
"lists",
"lists",
"n = len(S)",
"len(S)",
"n",
"sum_formula = 0",
"0",
"sum_formula",
"num = S[0]",
"S[0]",
"num",
"S = input()",
"input()",
"S",
"num = num + S[shift+1]",
"num + S[shift+1]",
"num",
"num = S[shift+1]",
"S[shift+1]",
"num",
"nums = []",
"[]",
"nums",
"sum_formula += sum(nums)",
"sum(nums)",
"sum_formula",
"def calc_all_formula(S, i, lists):\n '''\n listsใฎ่ฆ็ด : ([ๆฐๅญlist], temp_str)\n '''\n new_lists = []\n # i - i+1็ช็ฎใฎ้ใซ+ใๅ
ฅใ\n new_lists.extend(\n [(lst[0]+[int(lst[1])], S[i+1]) for lst in lists]\n )\n new_lists.extend(\n [(lst[0], lst[1]+S[i+1]) for lst in lists]\n )\n\n # base case\n if i == len(S)-2:\n new_lists = [\n lst[0]+[int(lst[1])] for lst in new_lists\n ]\n return new_lists\n \n return calc_all_formula(S, i+1, new_lists)\n\n# base_cand = [([], S[0])]\n\n# if len(S) >= 2:\n# sum_formula = sum([sum(lst) for lst in calc_all_formula(S, 0, base_cand)])\n# print(sum_formula)\n# else:\n# print(int(S))",
"def calc_all_formula(S, i, lists):\n '''\n listsใฎ่ฆ็ด : ([ๆฐๅญlist], temp_str)\n '''\n new_lists = []\n # i - i+1็ช็ฎใฎ้ใซ+ใๅ
ฅใ\n new_lists.extend(\n [(lst[0]+[int(lst[1])], S[i+1]) for lst in lists]\n )\n new_lists.extend(\n [(lst[0], lst[1]+S[i+1]) for lst in lists]\n )\n\n # base case\n if i == len(S)-2:\n new_lists = [\n lst[0]+[int(lst[1])] for lst in new_lists\n ]\n return new_lists\n \n return calc_all_formula(S, i+1, new_lists)\n\n# base_cand = [([], S[0])]\n\n# if len(S) >= 2:\n# sum_formula = sum([sum(lst) for lst in calc_all_formula(S, 0, base_cand)])\n# print(sum_formula)\n# else:\n# print(int(S))",
"calc_all_formula"
] | # -*- coding: utf-8 -*-
S = input()
n = len(S)
sum_formula = 0
# bitๅ
จๆข็ดข
for bit in range(2 ** (n-1)):
nums = []
# ไฝใใใใทใใใใใใ
num = S[0]
for shift in range(n-1):
if not ((bit >> shift)&1):
num = num + S[shift+1]
else:
nums.append(int(num))
num = S[shift+1]
nums.append(int(num))
sum_formula += sum(nums)
print(sum_formula)
# ๅๅธฐ้ขๆฐ
def calc_all_formula(S, i, lists):
'''
listsใฎ่ฆ็ด : ([ๆฐๅญlist], temp_str)
'''
new_lists = []
# i - i+1็ช็ฎใฎ้ใซ+ใๅ
ฅใ
new_lists.extend(
[(lst[0]+[int(lst[1])], S[i+1]) for lst in lists]
)
new_lists.extend(
[(lst[0], lst[1]+S[i+1]) for lst in lists]
)
# base case
if i == len(S)-2:
new_lists = [
lst[0]+[int(lst[1])] for lst in new_lists
]
return new_lists
return calc_all_formula(S, i+1, new_lists)
# base_cand = [([], S[0])]
# if len(S) >= 2:
# sum_formula = sum([sum(lst) for lst in calc_all_formula(S, 0, base_cand)])
# print(sum_formula)
# else:
# print(int(S)) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
13,
0,
13,
17,
0,
13,
4,
18,
4,
13,
13,
17,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
4,
18,
13,
13,
2,
2,
17,
13,
17,
17,
4,
18,
13,
13,
2,
2,
17,
13,
17,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
18,
13,
13,
17,
17,
0,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
132,
2
],
[
138,
6
],
[
133,
9
],
[
135,
11
],
[
15,
14
],
[
139,
20
],
[
114,
23
],
[
133,
24
],
[
123,
26
],
[
117,
29
],
[
14,
34
],
[
139,
38
],
[
42,
41
],
[
139,
45
],
[
126,
48
],
[
115,
51
],
[
121,
51
],
[
127,
51
],
[
130,
51
],
[
142,
51
],
[
118,
55
],
[
41,
56
],
[
127,
60
],
[
115,
60
],
[
121,
60
],
[
130,
60
],
[
142,
60
],
[
41,
65
],
[
127,
70
],
[
115,
70
],
[
121,
70
],
[
130,
70
],
[
142,
70
],
[
41,
75
],
[
120,
79
],
[
127,
84
],
[
115,
84
],
[
121,
84
],
[
130,
84
],
[
142,
84
],
[
141,
86
],
[
121,
89
],
[
127,
89
],
[
115,
89
],
[
130,
89
],
[
142,
89
],
[
129,
94
],
[
142,
100
],
[
121,
100
],
[
127,
100
],
[
115,
100
],
[
130,
100
],
[
144,
104
],
[
130,
107
],
[
142,
107
],
[
121,
107
],
[
127,
107
],
[
115,
107
],
[
145,
112
],
[
136,
112
],
[
133,
114
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
]
] | [
"#\nA = input()\na_len = len(A)\n\nanswer = 0\nfor i in range(2**(a_len-1)):\n a_tmp = A\n total = 0\n bin_index = format(i, 'b').zfill(a_len-1)\n for j in range(a_len-1):\n a_tmp = list(a_tmp)\n if bin_index[j] == '1':\n a_tmp.insert(2*j+1, '+')\n else:\n a_tmp.insert(2*j+1, '#')\n a_tmp = ''.join(a_tmp)\n a_tmp = a_tmp.replace('#', '')\n a_tmp = map(int, a_tmp.split('+'))\n answer += sum(a_tmp)\nprint(str(answer))",
"A = input()",
"A",
"input()",
"input",
"a_len = len(A)",
"a_len",
"len(A)",
"len",
"A",
"answer = 0",
"answer",
"0",
"for i in range(2**(a_len-1)):\n a_tmp = A\n total = 0\n bin_index = format(i, 'b').zfill(a_len-1)\n for j in range(a_len-1):\n a_tmp = list(a_tmp)\n if bin_index[j] == '1':\n a_tmp.insert(2*j+1, '+')\n else:\n a_tmp.insert(2*j+1, '#')\n a_tmp = ''.join(a_tmp)\n a_tmp = a_tmp.replace('#', '')\n a_tmp = map(int, a_tmp.split('+'))\n answer += sum(a_tmp)",
"i",
"range(2**(a_len-1))",
"range",
"2**(a_len-1)",
"2",
"a_len-1",
"a_len",
"1",
"a_tmp = A",
"a_tmp",
"A",
"total = 0",
"total",
"0",
"bin_index = format(i, 'b').zfill(a_len-1)",
"bin_index",
"format(i, 'b').zfill(a_len-1)",
"(i, 'b').zfill",
"(i, 'b')",
"format",
"i",
"'b'",
"zfill",
"a_len-1",
"a_len",
"1",
"for j in range(a_len-1):\n a_tmp = list(a_tmp)\n if bin_index[j] == '1':\n a_tmp.insert(2*j+1, '+')\n else:\n a_tmp.insert(2*j+1, '#')\n a_tmp = ''.join(a_tmp)\n ",
"j",
"range(a_len-1)",
"range",
"a_len-1",
"a_len",
"1",
"a_tmp = list(a_tmp)",
"a_tmp",
"list(a_tmp)",
"list",
"a_tmp",
"if bin_index[j] == '1':\n a_tmp.insert(2*j+1, '+')\n else:\n a_tmp.insert(2*j+1, '#')\n ",
"bin_index[j] == '1'",
"bin_index[j]",
"bin_index",
"j",
"'1'",
"a_tmp.insert(2*j+1, '+')",
"a_tmp.insert",
"a_tmp",
"insert",
"2*j+1",
"2*j",
"2",
"j",
"1",
"'+'",
"a_tmp.insert(2*j+1, '#')",
"a_tmp.insert",
"a_tmp",
"insert",
"2*j+1",
"2*j",
"2",
"j",
"1",
"'#'",
"a_tmp = ''.join(a_tmp)",
"a_tmp",
"''.join(a_tmp)",
"''.join",
"''",
"join",
"a_tmp",
"a_tmp = a_tmp.replace('#', '')",
"a_tmp",
"a_tmp.replace('#', '')",
"a_tmp.replace",
"a_tmp",
"replace",
"'#'",
"''",
"a_tmp = map(int, a_tmp.split('+'))",
"a_tmp",
"map(int, a_tmp.split('+'))",
"map",
"int",
"a_tmp.split('+')",
"a_tmp.split",
"a_tmp",
"split",
"'+'",
"answer += sum(a_tmp)",
"answer",
"sum(a_tmp)",
"sum",
"a_tmp",
"print(str(answer))",
"print",
"str(answer)",
"str",
"answer",
"a_tmp = A",
"A",
"a_tmp",
"bin_index = format(i, 'b').zfill(a_len-1)",
"format(i, 'b').zfill(a_len-1)",
"bin_index",
"a_tmp = ''.join(a_tmp)",
"''.join(a_tmp)",
"a_tmp",
"total = 0",
"0",
"total",
"a_tmp = list(a_tmp)",
"list(a_tmp)",
"a_tmp",
"a_tmp = map(int, a_tmp.split('+'))",
"map(int, a_tmp.split('+'))",
"a_tmp",
"A = input()",
"input()",
"A",
"answer = 0",
"0",
"answer",
"a_len = len(A)",
"len(A)",
"a_len",
"a_tmp = a_tmp.replace('#', '')",
"a_tmp.replace('#', '')",
"a_tmp",
"answer += sum(a_tmp)",
"sum(a_tmp)",
"answer"
] | #
A = input()
a_len = len(A)
answer = 0
for i in range(2**(a_len-1)):
a_tmp = A
total = 0
bin_index = format(i, 'b').zfill(a_len-1)
for j in range(a_len-1):
a_tmp = list(a_tmp)
if bin_index[j] == '1':
a_tmp.insert(2*j+1, '+')
else:
a_tmp.insert(2*j+1, '#')
a_tmp = ''.join(a_tmp)
a_tmp = a_tmp.replace('#', '')
a_tmp = map(int, a_tmp.split('+'))
answer += sum(a_tmp)
print(str(answer)) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
39,
17,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
18,
13,
13,
18,
13,
2,
13,
17,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
105,
2
],
[
99,
6
],
[
106,
9
],
[
93,
11
],
[
15,
14
],
[
100,
20
],
[
108,
23
],
[
29,
28
],
[
100,
32
],
[
14,
37
],
[
28,
38
],
[
109,
42
],
[
103,
42
],
[
28,
45
],
[
102,
48
],
[
109,
51
],
[
103,
51
],
[
90,
53
],
[
57,
56
],
[
103,
62
],
[
109,
62
],
[
96,
65
],
[
106,
69
],
[
103,
72
],
[
109,
72
],
[
56,
73
],
[
103,
75
],
[
109,
75
],
[
56,
77
],
[
94,
81
],
[
97,
83
],
[
91,
83
],
[
94,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
]
] | [
"s = input()\nsn = len(s)\n\nlis_2 = []\nfor i in range(1 << (sn - 1)):\n lis = [0, sn]\n for j in range(sn - 1):\n if (i >> j) & 1:\n lis.append(j + 1)\n lis = sorted(lis)\n #print(lis)\n sum1 = 0\n for j in range(len(lis) - 1):\n sum1 += int(s[lis[j]:lis[j + 1]])\n lis_2.append(sum1)\n#print(lis_2)\nprint(sum(lis_2))",
"s = input()",
"s",
"input()",
"input",
"sn = len(s)",
"sn",
"len(s)",
"len",
"s",
"lis_2 = []",
"lis_2",
"[]",
"for i in range(1 << (sn - 1)):\n lis = [0, sn]\n for j in range(sn - 1):\n if (i >> j) & 1:\n lis.append(j + 1)\n lis = sorted(lis)\n #print(lis)\n sum1 = 0\n for j in range(len(lis) - 1):\n sum1 += int(s[lis[j]:lis[j + 1]])\n lis_2.append(sum1)\n#print(lis_2)",
"i",
"range(1 << (sn - 1))",
"range",
"1 << (sn - 1)",
"1",
"sn - 1",
"sn",
"1",
"lis = [0, sn]",
"lis",
"[0, sn]",
"0",
"sn",
"for j in range(sn - 1):\n if (i >> j) & 1:\n lis.append(j + 1)\n ",
"j",
"range(sn - 1)",
"range",
"sn - 1",
"sn",
"1",
"if (i >> j) & 1:\n lis.append(j + 1)\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"lis.append(j + 1)",
"lis.append",
"lis",
"append",
"j + 1",
"j",
"1",
"lis = sorted(lis)",
"lis",
"sorted(lis)",
"sorted",
"lis",
"sum1 = 0",
"sum1",
"0",
"for j in range(len(lis) - 1):\n sum1 += int(s[lis[j]:lis[j + 1]])\n ",
"j",
"range(len(lis) - 1)",
"range",
"len(lis) - 1",
"len(lis)",
"len",
"lis",
"1",
"sum1 += int(s[lis[j]:lis[j + 1]])",
"sum1",
"int(s[lis[j]:lis[j + 1]])",
"int",
"s[lis[j]:lis[j + 1]]",
"s",
"lis[j]:lis[j + 1]",
"lis[j]",
"lis",
"j",
"lis[j + 1]",
"lis",
"j + 1",
"j",
"1",
"lis_2.append(sum1)",
"lis_2.append",
"lis_2",
"append",
"sum1",
"print(sum(lis_2))",
"print",
"sum(lis_2)",
"sum",
"lis_2",
"sum1 = 0",
"0",
"sum1",
"lis_2 = []",
"[]",
"lis_2",
"sum1 += int(s[lis[j]:lis[j + 1]])",
"int(s[lis[j]:lis[j + 1]])",
"sum1",
"sn = len(s)",
"len(s)",
"sn",
"lis = sorted(lis)",
"sorted(lis)",
"lis",
"s = input()",
"input()",
"s",
"lis = [0, sn]",
"[0, sn]",
"lis"
] | s = input()
sn = len(s)
lis_2 = []
for i in range(1 << (sn - 1)):
lis = [0, sn]
for j in range(sn - 1):
if (i >> j) & 1:
lis.append(j + 1)
lis = sorted(lis)
#print(lis)
sum1 = 0
for j in range(len(lis) - 1):
sum1 += int(s[lis[j]:lis[j + 1]])
lis_2.append(sum1)
#print(lis_2)
print(sum(lis_2))
|
[
7,
0,
13,
4,
13,
0,
13,
39,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
2,
17,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
0,
13,
18,
13,
13,
14,
2,
18,
18,
4,
13,
4,
13,
13,
39,
17,
13,
17,
0,
13,
18,
13,
13,
0,
13,
2,
18,
13,
13,
17,
14,
2,
18,
13,
17,
17,
0,
13,
18,
13,
39,
17,
4,
18,
13,
13,
4,
13,
13,
4,
13,
4,
13,
13,
10,
39,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
18,
13
] | [
[
106,
2
],
[
97,
6
],
[
10,
9
],
[
107,
17
],
[
107,
23
],
[
100,
25
],
[
29,
28
],
[
107,
33
],
[
28,
36
],
[
107,
40
],
[
109,
43
],
[
107,
45
],
[
28,
46
],
[
9,
55
],
[
28,
58
],
[
103,
61
],
[
107,
63
],
[
28,
64
],
[
112,
66
],
[
107,
69
],
[
28,
70
],
[
113,
75
],
[
104,
75
],
[
110,
75
],
[
101,
75
],
[
116,
75
],
[
115,
79
],
[
113,
81
],
[
104,
81
],
[
110,
81
],
[
101,
81
],
[
116,
81
],
[
98,
86
],
[
116,
90
],
[
113,
90
],
[
104,
90
],
[
110,
90
],
[
101,
90
],
[
98,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
]
] | [
"S=input()\nres=[]\nfor i in range(2**(len(S)-1),2**(len(S))):\n tmp=''\n for j in range(len(S)):\n if j==len(S)-1:\n tmp+=S[j]\n elif (str(bin(i))[3:])[j]=='1':\n tmp+=S[j]\n else:\n tmp+=S[j]+'+'\n if tmp[-1]=='+':\n tmp=tmp[:-1]\n res.append(eval(tmp))\nprint(sum(res))",
"S=input()",
"S",
"input()",
"input",
"res=[]",
"res",
"[]",
"for i in range(2**(len(S)-1),2**(len(S))):\n tmp=''\n for j in range(len(S)):\n if j==len(S)-1:\n tmp+=S[j]\n elif (str(bin(i))[3:])[j]=='1':\n tmp+=S[j]\n else:\n tmp+=S[j]+'+'\n if tmp[-1]=='+':\n tmp=tmp[:-1]\n res.append(eval(tmp))",
"i",
"range(2**(len(S)-1),2**(len(S)))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"2**(len(S))",
"2",
"len(S)",
"len",
"S",
"tmp=''",
"tmp",
"''",
"for j in range(len(S)):\n if j==len(S)-1:\n tmp+=S[j]\n elif (str(bin(i))[3:])[j]=='1':\n tmp+=S[j]\n else:\n tmp+=S[j]+'+'\n ",
"j",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"if j==len(S)-1:\n tmp+=S[j]\n elif (str(bin(i))[3:])[j]=='1':\n tmp+=S[j]\n else:\n tmp+=S[j]+'+'\n ",
"j==len(S)-1",
"j",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"tmp+=S[j]",
"tmp",
"S[j]",
"S",
"j",
"elif (str(bin(i))[3:])[j]=='1':\n tmp+=S[j]\n ",
"(str(bin(i))[3:])[j]=='1'",
"(str(bin(i))[3:])[j]",
"str(bin(i))[3:]",
"(bin(i))",
"str",
"bin(i)",
"bin",
"i",
"3:",
"3",
"j",
"'1'",
"tmp+=S[j]",
"tmp",
"S[j]",
"S",
"j",
"tmp+=S[j]+'+'",
"tmp",
"S[j]+'+'",
"S[j]",
"S",
"j",
"'+'",
"if tmp[-1]=='+':\n tmp=tmp[:-1]\n ",
"tmp[-1]=='+'",
"tmp[-1]",
"tmp",
"-1",
"'+'",
"tmp=tmp[:-1]",
"tmp",
"tmp[:-1]",
"tmp",
":-1",
"-1",
"res.append(eval(tmp))",
"res.append",
"res",
"append",
"eval(tmp)",
"eval",
"tmp",
"print(sum(res))",
"print",
"sum(res)",
"sum",
"res",
"res=[]",
"[]",
"res",
"tmp=''",
"''",
"tmp",
"tmp+=S[j]",
"S[j]",
"tmp",
"S=input()",
"input()",
"S",
"tmp+=S[j]",
"S[j]",
"tmp",
"tmp+=S[j]+'+'",
"S[j]+'+'",
"tmp",
"tmp=tmp[:-1]",
"tmp[:-1]",
"tmp"
] | S=input()
res=[]
for i in range(2**(len(S)-1),2**(len(S))):
tmp=''
for j in range(len(S)):
if j==len(S)-1:
tmp+=S[j]
elif (str(bin(i))[3:])[j]=='1':
tmp+=S[j]
else:
tmp+=S[j]+'+'
if tmp[-1]=='+':
tmp=tmp[:-1]
res.append(eval(tmp))
print(sum(res)) |
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
17,
4,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
2,
17,
18,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
13,
12
],
[
4,
19
],
[
22,
21
],
[
4,
23
],
[
27,
26
],
[
4,
32
],
[
12,
36
],
[
26,
37
],
[
41,
40
],
[
4,
44
],
[
26,
45
],
[
48,
47
],
[
4,
49
],
[
26,
50
],
[
8,
53
],
[
47,
55
],
[
40,
55
],
[
21,
55
],
[
58,
57
],
[
61,
60
],
[
8,
60
],
[
64,
63
],
[
60,
66
],
[
63,
69
],
[
57,
69
],
[
78,
75
]
] | [
"def main():\n S = input()\n s = set()\n for i in range(2**len(S)):\n tmp = S[0]\n for j in range(1,len(S)):\n if (i >> j) & 1:\n tmp += '+' + S[j]\n else:\n tmp += S[j]\n s.add(tmp)\n ans = 0\n for a in s:\n ans += eval(a)\n print(ans)\n\n\n\nif __name__ == \"__main__\":\n main()",
"def main():\n S = input()\n s = set()\n for i in range(2**len(S)):\n tmp = S[0]\n for j in range(1,len(S)):\n if (i >> j) & 1:\n tmp += '+' + S[j]\n else:\n tmp += S[j]\n s.add(tmp)\n ans = 0\n for a in s:\n ans += eval(a)\n print(ans)",
"main",
"S = input()",
"S",
"input()",
"input",
"s = set()",
"s",
"set()",
"set",
"for i in range(2**len(S)):\n tmp = S[0]\n for j in range(1,len(S)):\n if (i >> j) & 1:\n tmp += '+' + S[j]\n else:\n tmp += S[j]\n s.add(tmp)\n ",
"i",
"range(2**len(S))",
"range",
"2**len(S)",
"2",
"len(S)",
"len",
"S",
"tmp = S[0]",
"tmp",
"S[0]",
"S",
"0",
"for j in range(1,len(S)):\n if (i >> j) & 1:\n tmp += '+' + S[j]\n else:\n tmp += S[j]\n ",
"j",
"range(1,len(S))",
"range",
"1",
"len(S)",
"len",
"S",
"if (i >> j) & 1:\n tmp += '+' + S[j]\n else:\n tmp += S[j]\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"tmp += '+' + S[j]",
"tmp",
"'+' + S[j]",
"'+'",
"S[j]",
"S",
"j",
"tmp += S[j]",
"tmp",
"S[j]",
"S",
"j",
"s.add(tmp)",
"s.add",
"s",
"add",
"tmp",
"ans = 0",
"ans",
"0",
"for a in s:\n ans += eval(a)\n ",
"a",
"s",
"ans += eval(a)",
"ans",
"eval(a)",
"eval",
"a",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n S = input()\n s = set()\n for i in range(2**len(S)):\n tmp = S[0]\n for j in range(1,len(S)):\n if (i >> j) & 1:\n tmp += '+' + S[j]\n else:\n tmp += S[j]\n s.add(tmp)\n ans = 0\n for a in s:\n ans += eval(a)\n print(ans)",
"def main():\n S = input()\n s = set()\n for i in range(2**len(S)):\n tmp = S[0]\n for j in range(1,len(S)):\n if (i >> j) & 1:\n tmp += '+' + S[j]\n else:\n tmp += S[j]\n s.add(tmp)\n ans = 0\n for a in s:\n ans += eval(a)\n print(ans)",
"main"
] | def main():
S = input()
s = set()
for i in range(2**len(S)):
tmp = S[0]
for j in range(1,len(S)):
if (i >> j) & 1:
tmp += '+' + S[j]
else:
tmp += S[j]
s.add(tmp)
ans = 0
for a in s:
ans += eval(a)
print(ans)
if __name__ == "__main__":
main() |
[
7,
41,
28,
13,
4,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
2,
39,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
18,
13,
2,
2,
13,
17,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
2,
13,
39,
17,
0,
13,
2,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13
] | [
[
4,
3
],
[
3,
9
],
[
119,
11
],
[
101,
14
],
[
120,
18
],
[
122,
21
],
[
25,
24
],
[
102,
29
],
[
125,
31
],
[
102,
35
],
[
128,
37
],
[
41,
40
],
[
102,
43
],
[
24,
47
],
[
40,
48
],
[
58,
51
],
[
126,
52
],
[
102,
55
],
[
40,
57
],
[
110,
60
],
[
120,
67
],
[
126,
69
],
[
104,
73
],
[
107,
80
],
[
105,
83
],
[
111,
83
],
[
129,
83
],
[
108,
83
],
[
113,
87
],
[
91,
90
],
[
108,
90
],
[
105,
90
],
[
111,
90
],
[
129,
90
],
[
116,
93
],
[
90,
96
],
[
117,
99
],
[
123,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
]
] | [
"n = [int(x) for x in input()]\nop_cnt = len(n) - 1 \nout=0\nfor i in range(2 ** op_cnt):\n op = [\"+\"] * op_cnt \n box=\"\"\n for j in range(op_cnt):\n if ((i >> j) & 1):\n op[op_cnt - 1 - j] = \"\" \n box=\"\" \n for a,b in zip(n,op+[\"\"]):\n box+=(str(a)+b)\n box=box.split('+')\n ou=0\n for k in box:\n out+=int(k)\nprint(out)",
"int(x) for x in input()",
"for x in input()",
"x",
"input()",
"input",
"for x in input()",
"int(x)",
"int",
"x",
"n = [int(x) for x in input()]",
"n",
"[int(x) for x in input()]",
"op_cnt = len(n) - 1",
"op_cnt",
"len(n) - 1",
"len(n)",
"len",
"n",
"1",
"out=0",
"out",
"0",
"for i in range(2 ** op_cnt):\n op = [\"+\"] * op_cnt \n box=\"\"\n for j in range(op_cnt):\n if ((i >> j) & 1):\n op[op_cnt - 1 - j] = \"\" \n box=\"\" \n for a,b in zip(n,op+[\"\"]):\n box+=(str(a)+b)\n box=box.split('+')\n ou=0\n for k in box:\n out+=int(k)",
"i",
"range(2 ** op_cnt)",
"range",
"2 ** op_cnt",
"2",
"op_cnt",
"op = [\"+\"] * op_cnt",
"op",
"[\"+\"] * op_cnt",
"[\"+\"]",
"\"+\"",
"op_cnt",
"box=\"\"",
"box",
"\"\"",
"for j in range(op_cnt):\n if ((i >> j) & 1):\n op[op_cnt - 1 - j] = \"\" \n box=\"\" \n ",
"j",
"range(op_cnt)",
"range",
"op_cnt",
"if ((i >> j) & 1):\n op[op_cnt - 1 - j] = \"\" \n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"op[op_cnt - 1 - j] = \"\"",
"op[op_cnt - 1 - j]",
"op",
"op_cnt - 1 - j",
"op_cnt - 1",
"op_cnt",
"1",
"j",
"\"\"",
"box=\"\"",
"box",
"\"\"",
"for a,b in zip(n,op+[\"\"]):\n box+=(str(a)+b)\n ",
"a",
"b",
"zip(n,op+[\"\"])",
"zip",
"n",
"op+[\"\"]",
"op",
"[\"\"]",
"\"\"",
"box+=(str(a)+b)",
"box",
"str(a)+b",
"str(a)",
"str",
"a",
"b",
"box=box.split('+')",
"box",
"box.split('+')",
"box.split",
"box",
"split",
"'+'",
"ou=0",
"ou",
"0",
"for k in box:\n out+=int(k)",
"k",
"box",
"out+=int(k)",
"out",
"int(k)",
"int",
"k",
"print(out)",
"print",
"out",
"op_cnt = len(n) - 1",
"len(n) - 1",
"op_cnt",
"box+=(str(a)+b)",
"str(a)+b",
"box",
"box=box.split('+')",
"box.split('+')",
"box",
"box=\"\"",
"\"\"",
"box",
"ou=0",
"0",
"ou",
"out+=int(k)",
"int(k)",
"out",
"n = [int(x) for x in input()]",
"[int(x) for x in input()]",
"n",
"out=0",
"0",
"out",
"op = [\"+\"] * op_cnt",
"[\"+\"] * op_cnt",
"op",
"box=\"\"",
"\"\"",
"box"
] | n = [int(x) for x in input()]
op_cnt = len(n) - 1
out=0
for i in range(2 ** op_cnt):
op = ["+"] * op_cnt
box=""
for j in range(op_cnt):
if ((i >> j) & 1):
op[op_cnt - 1 - j] = ""
box=""
for a,b in zip(n,op+[""]):
box+=(str(a)+b)
box=box.split('+')
ou=0
for k in box:
out+=int(k)
print(out) |
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
2,
4,
13,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
18,
13,
2,
2,
13,
17,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
18,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13
] | [
[
88,
2
],
[
82,
6
],
[
91,
9
],
[
89,
13
],
[
17,
16
],
[
92,
21
],
[
97,
23
],
[
92,
27
],
[
30,
29
],
[
92,
32
],
[
16,
36
],
[
29,
37
],
[
47,
40
],
[
98,
41
],
[
92,
44
],
[
29,
46
],
[
79,
49
],
[
53,
52
],
[
92,
55
],
[
85,
57
],
[
89,
60
],
[
52,
61
],
[
98,
63
],
[
52,
64
],
[
100,
66
],
[
89,
68
],
[
94,
71
],
[
101,
74
],
[
86,
74
],
[
80,
74
],
[
95,
77
],
[
83,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
]
] | [
"# -*- coding: utf-8 -*-\nS = input()\nresult = 0\nspace_cnt = len(S)-1\nfor i in range(2 ** space_cnt):\n space = [\"\"] * space_cnt\n for j in range(space_cnt):\n if ((i >> j) & 1):\n space[space_cnt -1 -j] = \"+\"\n formula = \"\"\n for i in range(space_cnt):\n formula += S[i]+space[i]\n formula += S[-1]\n result += eval(formula)\nprint(result)",
"S = input()",
"S",
"input()",
"input",
"result = 0",
"result",
"0",
"space_cnt = len(S)-1",
"space_cnt",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"for i in range(2 ** space_cnt):\n space = [\"\"] * space_cnt\n for j in range(space_cnt):\n if ((i >> j) & 1):\n space[space_cnt -1 -j] = \"+\"\n formula = \"\"\n for i in range(space_cnt):\n formula += S[i]+space[i]\n formula += S[-1]\n result += eval(formula)",
"i",
"range(2 ** space_cnt)",
"range",
"2 ** space_cnt",
"2",
"space_cnt",
"space = [\"\"] * space_cnt",
"space",
"[\"\"] * space_cnt",
"[\"\"]",
"\"\"",
"space_cnt",
"for j in range(space_cnt):\n if ((i >> j) & 1):\n space[space_cnt -1 -j] = \"+\"\n ",
"j",
"range(space_cnt)",
"range",
"space_cnt",
"if ((i >> j) & 1):\n space[space_cnt -1 -j] = \"+\"\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"space[space_cnt -1 -j] = \"+\"",
"space[space_cnt -1 -j]",
"space",
"space_cnt -1 -j",
"space_cnt -1",
"space_cnt",
"1",
"j",
"\"+\"",
"formula = \"\"",
"formula",
"\"\"",
"for i in range(space_cnt):\n formula += S[i]+space[i]\n ",
"i",
"range(space_cnt)",
"range",
"space_cnt",
"formula += S[i]+space[i]",
"formula",
"S[i]+space[i]",
"S[i]",
"S",
"i",
"space[i]",
"space",
"i",
"formula += S[-1]",
"formula",
"S[-1]",
"S",
"-1",
"result += eval(formula)",
"result",
"eval(formula)",
"eval",
"formula",
"print(result)",
"print",
"result",
"formula = \"\"",
"\"\"",
"formula",
"result = 0",
"0",
"result",
"formula += S[i]+space[i]",
"S[i]+space[i]",
"formula",
"S = input()",
"input()",
"S",
"space_cnt = len(S)-1",
"len(S)-1",
"space_cnt",
"result += eval(formula)",
"eval(formula)",
"result",
"space = [\"\"] * space_cnt",
"[\"\"] * space_cnt",
"space",
"formula += S[-1]",
"S[-1]",
"formula"
] | # -*- coding: utf-8 -*-
S = input()
result = 0
space_cnt = len(S)-1
for i in range(2 ** space_cnt):
space = [""] * space_cnt
for j in range(space_cnt):
if ((i >> j) & 1):
space[space_cnt -1 -j] = "+"
formula = ""
for i in range(space_cnt):
formula += S[i]+space[i]
formula += S[-1]
result += eval(formula)
print(result)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
2,
39,
17,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
0,
18,
13,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13
] | [
[
80,
2
],
[
83,
8
],
[
12,
11
],
[
81,
19
],
[
77,
22
],
[
81,
28
],
[
92,
30
],
[
34,
33
],
[
81,
39
],
[
11,
44
],
[
33,
45
],
[
51,
48
],
[
78,
49
],
[
33,
50
],
[
54,
53
],
[
81,
58
],
[
86,
60
],
[
81,
63
],
[
53,
64
],
[
78,
66
],
[
53,
67
],
[
89,
69
],
[
87,
72
],
[
93,
72
],
[
90,
75
],
[
84,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
]
] | [
"n = list(input())\nans = 0\nfor i in range(2**(len(n)-1)):\n plus = [\"\"]*(len(n))\n fomula = \"\"\n for j in range(len(n)-1):\n if(i>>j & 1):\n plus[j] = \"+\"\n for i in range(len(n)):\n fomula += n[i] + plus[i]\n ans += eval(fomula)\nprint(ans)\n",
"n = list(input())",
"n",
"list(input())",
"list",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(2**(len(n)-1)):\n plus = [\"\"]*(len(n))\n fomula = \"\"\n for j in range(len(n)-1):\n if(i>>j & 1):\n plus[j] = \"+\"\n for i in range(len(n)):\n fomula += n[i] + plus[i]\n ans += eval(fomula)",
"i",
"range(2**(len(n)-1))",
"range",
"2**(len(n)-1)",
"2",
"len(n)-1",
"len(n)",
"len",
"n",
"1",
"plus = [\"\"]*(len(n))",
"plus",
"[\"\"]*(len(n))",
"[\"\"]",
"\"\"",
"len(n)",
"len",
"n",
"fomula = \"\"",
"fomula",
"\"\"",
"for j in range(len(n)-1):\n if(i>>j & 1):\n plus[j] = \"+\"\n ",
"j",
"range(len(n)-1)",
"range",
"len(n)-1",
"len(n)",
"len",
"n",
"1",
"if(i>>j & 1):\n plus[j] = \"+\"\n ",
"i>>j & 1",
"i>>j",
"i",
"j",
"1",
"plus[j] = \"+\"",
"plus[j]",
"plus",
"j",
"\"+\"",
"for i in range(len(n)):\n fomula += n[i] + plus[i]\n ",
"i",
"range(len(n))",
"range",
"len(n)",
"len",
"n",
"fomula += n[i] + plus[i]",
"fomula",
"n[i] + plus[i]",
"n[i]",
"n",
"i",
"plus[i]",
"plus",
"i",
"ans += eval(fomula)",
"ans",
"eval(fomula)",
"eval",
"fomula",
"print(ans)",
"print",
"ans",
"plus = [\"\"]*(len(n))",
"[\"\"]*(len(n))",
"plus",
"n = list(input())",
"list(input())",
"n",
"ans = 0",
"0",
"ans",
"fomula += n[i] + plus[i]",
"n[i] + plus[i]",
"fomula",
"ans += eval(fomula)",
"eval(fomula)",
"ans",
"fomula = \"\"",
"\"\"",
"fomula"
] | n = list(input())
ans = 0
for i in range(2**(len(n)-1)):
plus = [""]*(len(n))
fomula = ""
for j in range(len(n)-1):
if(i>>j & 1):
plus[j] = "+"
for i in range(len(n)):
fomula += n[i] + plus[i]
ans += eval(fomula)
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
12,
13,
14,
2,
13,
2,
13,
17,
29,
4,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
29,
2,
4,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
4,
13,
2,
13,
17,
2,
2,
13,
17,
18,
13,
2,
13,
17,
23,
13,
23,
13,
4,
13,
4,
13,
17,
18,
13,
17,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
75,
2
],
[
78,
6
],
[
76,
9
],
[
60,
14
],
[
79,
16
],
[
62,
28
],
[
60,
36
],
[
62,
39
],
[
76,
41
],
[
60,
43
],
[
60,
48
],
[
62,
52
],
[
76,
55
],
[
60,
57
],
[
60,
60
],
[
62,
62
],
[
73,
66
],
[
76,
69
],
[
75,
76
],
[
78,
79
]
] | [
"s = input()\nn = len(s)\n\ndef dfs(i: int, t: str):\n if i == n - 1:\n return sum(list(map(int, t.split('+'))))\n return dfs(i + 1, t + s[i + 1]) + dfs(i + 1, t + '+' + s[i + 1])\n\nprint(dfs(0, s[0]))",
"s = input()",
"s",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"def dfs(i: int, t: str):\n if i == n - 1:\n return sum(list(map(int, t.split('+'))))\n return dfs(i + 1, t + s[i + 1]) + dfs(i + 1, t + '+' + s[i + 1])",
"dfs",
"if i == n - 1:\n return sum(list(map(int, t.split('+'))))\n ",
"i == n - 1",
"i",
"n - 1",
"n",
"1",
"return sum(list(map(int, t.split('+'))))",
"sum(list(map(int, t.split('+'))))",
"sum",
"list(map(int, t.split('+')))",
"list",
"map(int, t.split('+'))",
"map",
"int",
"t.split('+')",
"t.split",
"t",
"split",
"'+'",
"return dfs(i + 1, t + s[i + 1]) + dfs(i + 1, t + '+' + s[i + 1])",
"dfs(i + 1, t + s[i + 1]) + dfs(i + 1, t + '+' + s[i + 1])",
"dfs(i + 1, t + s[i + 1])",
"dfs",
"i + 1",
"i",
"1",
"t + s[i + 1]",
"t",
"s[i + 1]",
"s",
"i + 1",
"i",
"1",
"dfs(i + 1, t + '+' + s[i + 1])",
"dfs",
"i + 1",
"i",
"1",
"t + '+' + s[i + 1]",
"t + '+'",
"t",
"'+'",
"s[i + 1]",
"s",
"i + 1",
"i",
"1",
"i: int",
"i",
"t: str",
"t",
"print(dfs(0, s[0]))",
"print",
"dfs(0, s[0])",
"dfs",
"0",
"s[0]",
"s",
"0",
"def dfs(i: int, t: str):\n if i == n - 1:\n return sum(list(map(int, t.split('+'))))\n return dfs(i + 1, t + s[i + 1]) + dfs(i + 1, t + '+' + s[i + 1])",
"def dfs(i: int, t: str):\n if i == n - 1:\n return sum(list(map(int, t.split('+'))))\n return dfs(i + 1, t + s[i + 1]) + dfs(i + 1, t + '+' + s[i + 1])",
"dfs",
"s = input()",
"input()",
"s",
"n = len(s)",
"len(s)",
"n"
] | s = input()
n = len(s)
def dfs(i: int, t: str):
if i == n - 1:
return sum(list(map(int, t.split('+'))))
return dfs(i + 1, t + s[i + 1]) + dfs(i + 1, t + '+' + s[i + 1])
print(dfs(0, s[0])) |
[
7,
0,
13,
4,
13,
12,
13,
14,
2,
13,
17,
0,
13,
17,
28,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
29,
13,
29,
2,
4,
13,
2,
13,
17,
13,
4,
13,
2,
13,
17,
2,
2,
18,
13,
39,
2,
40,
13,
17,
17,
18,
13,
39,
2,
40,
13,
17,
23,
13,
23,
13,
4,
13,
4,
13,
4,
13,
13,
13,
10,
12,
13,
10,
4,
13
] | [
[
74,
2
],
[
59,
9
],
[
13,
12
],
[
16,
15
],
[
61,
18
],
[
23,
22
],
[
15,
25
],
[
22,
27
],
[
12,
27
],
[
59,
33
],
[
61,
35
],
[
59,
39
],
[
61,
44
],
[
59,
48
],
[
61,
52
],
[
59,
56
],
[
59,
59
],
[
61,
61
],
[
72,
65
],
[
75,
68
],
[
75,
69
],
[
74,
75
]
] | [
"S = input()\n\ndef rec(n, s):\n if n == 1:\n ans = 0\n for i in s.split(\"+\"):\n ans += int(i)\n return ans\n \n # ๆๅญๅใฎๅพใใใn็ช็ฎใซ\"+\"ใๅ
ฅใใใๅฆใ\n return rec(n-1, s) + rec(n-1, s[:-n+1]+\"+\"+s[-n+1:])\n\nprint(rec(len(S), S))",
"S = input()",
"S",
"input()",
"input",
"def rec(n, s):\n if n == 1:\n ans = 0\n for i in s.split(\"+\"):\n ans += int(i)\n return ans\n \n # ๆๅญๅใฎๅพใใใn็ช็ฎใซ\"+\"ใๅ
ฅใใใๅฆใ\n return rec(n-1, s) + rec(n-1, s[:-n+1]+\"+\"+s[-n+1:])",
"rec",
"if n == 1:\n ans = 0\n for i in s.split(\"+\"):\n ans += int(i)\n return ans\n \n # ๆๅญๅใฎๅพใใใn็ช็ฎใซ\"+\"ใๅ
ฅใใใๅฆใ\n ",
"n == 1",
"n",
"1",
"ans = 0",
"ans",
"0",
"for i in s.split(\"+\"):\n ans += int(i)\n ",
"i",
"s.split(\"+\")",
"s.split",
"s",
"split",
"\"+\"",
"ans += int(i)",
"ans",
"int(i)",
"int",
"i",
"return ans",
"ans",
"return rec(n-1, s) + rec(n-1, s[:-n+1]+\"+\"+s[-n+1:])",
"rec(n-1, s) + rec(n-1, s[:-n+1]+\"+\"+s[-n+1:])",
"rec(n-1, s)",
"rec",
"n-1",
"n",
"1",
"s",
"rec(n-1, s[:-n+1]+\"+\"+s[-n+1:])",
"rec",
"n-1",
"n",
"1",
"s[:-n+1]+\"+\"+s[-n+1:]",
"s[:-n+1]+\"+\"",
"s[:-n+1]",
"s",
":-n+1",
"-n+1",
"-n",
"n",
"1",
"\"+\"",
"s[-n+1:]",
"s",
"-n+1:",
"-n+1",
"-n",
"n",
"1",
"n",
"n",
"s",
"s",
"print(rec(len(S), S))",
"print",
"rec(len(S), S)",
"rec",
"len(S)",
"len",
"S",
"S",
"def rec(n, s):\n if n == 1:\n ans = 0\n for i in s.split(\"+\"):\n ans += int(i)\n return ans\n \n # ๆๅญๅใฎๅพใใใn็ช็ฎใซ\"+\"ใๅ
ฅใใใๅฆใ\n return rec(n-1, s) + rec(n-1, s[:-n+1]+\"+\"+s[-n+1:])",
"def rec(n, s):\n if n == 1:\n ans = 0\n for i in s.split(\"+\"):\n ans += int(i)\n return ans\n \n # ๆๅญๅใฎๅพใใใn็ช็ฎใซ\"+\"ใๅ
ฅใใใๅฆใ\n return rec(n-1, s) + rec(n-1, s[:-n+1]+\"+\"+s[-n+1:])",
"rec",
"S = input()",
"input()",
"S"
] | S = input()
def rec(n, s):
if n == 1:
ans = 0
for i in s.split("+"):
ans += int(i)
return ans
# ๆๅญๅใฎๅพใใใn็ช็ฎใซ"+"ใๅ
ฅใใใๅฆใ
return rec(n-1, s) + rec(n-1, s[:-n+1]+"+"+s[-n+1:])
print(rec(len(S), S)) |
[
7,
12,
13,
14,
2,
4,
13,
13,
17,
0,
13,
2,
4,
13,
18,
13,
39,
17,
17,
29,
2,
2,
4,
13,
18,
13,
39,
17,
17,
2,
2,
18,
13,
17,
2,
17,
13,
2,
17,
13,
2,
4,
13,
18,
13,
39,
17,
2,
13,
17,
2,
2,
18,
13,
17,
2,
17,
13,
2,
17,
13,
29,
2,
18,
13,
17,
2,
17,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
4,
13,
13,
4,
13,
4,
13,
4,
13,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
70,
7
],
[
11,
10
],
[
70,
15
],
[
70,
25
],
[
70,
32
],
[
72,
36
],
[
10,
39
],
[
70,
44
],
[
72,
48
],
[
70,
53
],
[
72,
57
],
[
10,
60
],
[
70,
64
],
[
72,
68
],
[
70,
70
],
[
72,
72
],
[
77,
76
],
[
98,
87
],
[
76,
88
],
[
101,
95
]
] | [
"def sum(list, index):\n if (len(list) > 1):\n d = len(list[:-1]) - 1\n return (sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)\n else:\n return (list[-1] * 10**index)\n\ndef resolve():\n s = list(map(int,input()))\n print(sum(s,0))\n\n\nif __name__ == \"__main__\":\n resolve()",
"def sum(list, index):\n if (len(list) > 1):\n d = len(list[:-1]) - 1\n return (sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)\n else:\n return (list[-1] * 10**index)",
"sum",
"if (len(list) > 1):\n d = len(list[:-1]) - 1\n return (sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)\n else:\n return (list[-1] * 10**index)",
"len(list) > 1",
"len(list)",
"len",
"list",
"1",
"d = len(list[:-1]) - 1",
"d",
"len(list[:-1]) - 1",
"len(list[:-1])",
"len",
"list[:-1]",
"list",
":-1",
"-1",
"1",
"return (sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)",
"(sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)",
"sum(list[:-1], 0) + list[-1] * 10**index * 2**d",
"sum(list[:-1], 0)",
"sum",
"list[:-1]",
"list",
":-1",
"-1",
"0",
"list[-1] * 10**index * 2**d",
"list[-1] * 10**index",
"list[-1]",
"list",
"-1",
"10**index",
"10",
"index",
"2**d",
"2",
"d",
"sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d",
"sum(list[:-1], index + 1 )",
"sum",
"list[:-1]",
"list",
":-1",
"-1",
"index + 1",
"index",
"1",
"list[-1] * 10**index * 2**d",
"list[-1] * 10**index",
"list[-1]",
"list",
"-1",
"10**index",
"10",
"index",
"2**d",
"2",
"d",
"return (list[-1] * 10**index)",
"list[-1] * 10**index",
"list[-1]",
"list",
"-1",
"10**index",
"10",
"index",
"list",
"list",
"index",
"index",
"def resolve():\n s = list(map(int,input()))\n print(sum(s,0))",
"resolve",
"s = list(map(int,input()))",
"s",
"list(map(int,input()))",
"list",
"map(int,input())",
"map",
"int",
"input()",
"input",
"print(sum(s,0))",
"print",
"sum(s,0)",
"sum",
"s",
"0",
"if __name__ == \"__main__\":\n resolve()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"resolve()",
"resolve",
"def sum(list, index):\n if (len(list) > 1):\n d = len(list[:-1]) - 1\n return (sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)\n else:\n return (list[-1] * 10**index)",
"def sum(list, index):\n if (len(list) > 1):\n d = len(list[:-1]) - 1\n return (sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)\n else:\n return (list[-1] * 10**index)",
"sum",
"def resolve():\n s = list(map(int,input()))\n print(sum(s,0))",
"def resolve():\n s = list(map(int,input()))\n print(sum(s,0))",
"resolve"
] | def sum(list, index):
if (len(list) > 1):
d = len(list[:-1]) - 1
return (sum(list[:-1], 0) + list[-1] * 10**index * 2**d ) + (sum(list[:-1], index + 1 ) + list[-1] * 10**index * 2**d)
else:
return (list[-1] * 10**index)
def resolve():
s = list(map(int,input()))
print(sum(s,0))
if __name__ == "__main__":
resolve() |
[
7,
15,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
4,
13,
13,
41,
28,
13,
13,
40,
2,
18,
13,
17,
17,
4,
13,
0,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
69,
3
],
[
87,
7
],
[
17,
16
],
[
70,
19
],
[
23,
22
],
[
88,
22
],
[
22,
27
],
[
22,
31
],
[
72,
33
],
[
78,
36
],
[
40,
39
],
[
73,
39
],
[
88,
39
],
[
81,
42
],
[
46,
45
],
[
39,
50
],
[
84,
52
],
[
70,
55
],
[
45,
56
],
[
39,
58
],
[
45,
59
],
[
75,
61
],
[
85,
64
],
[
82,
64
],
[
76,
67
],
[
79,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
]
] | [
"from itertools import product\ns = input()\nop = list(product([\"\", \"+\"], repeat=len(s)))\nop = [a for a in op if not a[-1] == \"+\"]\nans = 0\nfor q in op:\n e = \"\"\n for w in range(len(q)):\n e += s[w] + q[w]\n ans += eval(e)\nprint(ans)",
"from itertools import product",
"s = input()",
"s",
"input()",
"input",
"op = list(product([\"\", \"+\"], repeat=len(s)))",
"op",
"list(product([\"\", \"+\"], repeat=len(s)))",
"list",
"product([\"\", \"+\"], repeat=len(s))",
"product",
"[\"\", \"+\"]",
"\"\"",
"\"+\"",
"repeat=len(s)",
"repeat",
"len(s)",
"len",
"s",
"a for a in op if not a[-1] == \"+\"",
"for a in op if not a[-1] == \"+\"",
"a",
"op",
"not a[-1] == \"+\"",
"a[-1] == \"+\"",
"a[-1]",
"a",
"-1",
"\"+\"",
"if not a[-1] == \"+\"",
"a",
"op = [a for a in op if not a[-1] == \"+\"]",
"op",
"[a for a in op if not a[-1] == \"+\"]",
"ans = 0",
"ans",
"0",
"for q in op:\n e = \"\"\n for w in range(len(q)):\n e += s[w] + q[w]\n ans += eval(e)",
"q",
"op",
"e = \"\"",
"e",
"\"\"",
"for w in range(len(q)):\n e += s[w] + q[w]\n ",
"w",
"range(len(q))",
"range",
"len(q)",
"len",
"q",
"e += s[w] + q[w]",
"e",
"s[w] + q[w]",
"s[w]",
"s",
"w",
"q[w]",
"q",
"w",
"ans += eval(e)",
"ans",
"eval(e)",
"eval",
"e",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"op = [a for a in op if not a[-1] == \"+\"]",
"[a for a in op if not a[-1] == \"+\"]",
"op",
"ans += eval(e)",
"eval(e)",
"ans",
"ans = 0",
"0",
"ans",
"e = \"\"",
"\"\"",
"e",
"e += s[w] + q[w]",
"s[w] + q[w]",
"e",
"op = list(product([\"\", \"+\"], repeat=len(s)))",
"list(product([\"\", \"+\"], repeat=len(s)))",
"op"
] | from itertools import product
s = input()
op = list(product(["", "+"], repeat=len(s)))
op = [a for a in op if not a[-1] == "+"]
ans = 0
for q in op:
e = ""
for w in range(len(q)):
e += s[w] + q[w]
ans += eval(e)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
17,
42,
40,
18,
13,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
13,
0,
13,
17,
0,
13,
17,
9,
0,
13,
2,
2,
17,
13,
4,
13,
18,
13,
13,
0,
13,
17,
0,
13,
13,
29,
13,
23,
13,
15,
0,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
2,
17,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
141,
2
],
[
162,
8
],
[
142,
11
],
[
16,
15
],
[
70,
18
],
[
21,
20
],
[
24,
23
],
[
27,
26
],
[
70,
31
],
[
20,
32
],
[
62,
32
],
[
47,
32
],
[
70,
37
],
[
20,
38
],
[
62,
38
],
[
47,
38
],
[
42,
41
],
[
26,
42
],
[
51,
42
],
[
44,
42
],
[
45,
44
],
[
48,
47
],
[
52,
51
],
[
26,
55
],
[
51,
55
],
[
44,
55
],
[
70,
59
],
[
20,
60
],
[
62,
60
],
[
47,
60
],
[
63,
62
],
[
66,
65
],
[
51,
66
],
[
44,
66
],
[
26,
66
],
[
65,
68
],
[
41,
68
],
[
23,
68
],
[
70,
70
],
[
165,
73
],
[
83,
82
],
[
163,
84
],
[
144,
87
],
[
91,
90
],
[
166,
90
],
[
147,
93
],
[
142,
95
],
[
99,
98
],
[
163,
102
],
[
90,
107
],
[
98,
108
],
[
153,
111
],
[
142,
115
],
[
98,
117
],
[
159,
120
],
[
142,
122
],
[
98,
124
],
[
156,
127
],
[
138,
130
],
[
151,
132
],
[
157,
133
],
[
160,
133
],
[
154,
133
],
[
148,
133
],
[
139,
136
],
[
145,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
153,
154
],
[
156,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
]
] | [
"S = list(input())\nN = len(S)\n\ndef calc(T):\n N = len(T)\n t = 0\n ans = 0\n tmp = 0\n while T[t]!=\"=\":\n if T[t]==\"+\":\n ans += tmp\n tmp = 0\n t+=1\n continue\n else:\n tmp = 10*tmp+int(T[t])\n t+=1\n ans += tmp\n return ans\n\nfrom itertools import product\nLS = list(product([0,1], repeat=N-1))\nout = 0\nfor L in LS:\n T = S[0]\n for i in range(N-1):\n if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n T += \"=\"\n out += calc(T)\nprint(out)",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"def calc(T):\n N = len(T)\n t = 0\n ans = 0\n tmp = 0\n while T[t]!=\"=\":\n if T[t]==\"+\":\n ans += tmp\n tmp = 0\n t+=1\n continue\n else:\n tmp = 10*tmp+int(T[t])\n t+=1\n ans += tmp\n return ans",
"calc",
"N = len(T)",
"N",
"len(T)",
"len",
"T",
"t = 0",
"t",
"0",
"ans = 0",
"ans",
"0",
"tmp = 0",
"tmp",
"0",
"while T[t]!=\"=\":\n if T[t]==\"+\":\n ans += tmp\n tmp = 0\n t+=1\n continue\n else:\n tmp = 10*tmp+int(T[t])\n t+=1\n ",
"T[t]!=\"=\"",
"T[t]",
"T",
"t",
"\"=\"",
"if T[t]==\"+\":\n ans += tmp\n tmp = 0\n t+=1\n continue\n else:\n tmp = 10*tmp+int(T[t])\n t+=1\n ",
"T[t]==\"+\"",
"T[t]",
"T",
"t",
"\"+\"",
"ans += tmp",
"ans",
"tmp",
"tmp = 0",
"tmp",
"0",
"t+=1",
"t",
"1",
"continue",
"tmp = 10*tmp+int(T[t])",
"tmp",
"10*tmp+int(T[t])",
"10*tmp",
"10",
"tmp",
"int(T[t])",
"int",
"T[t]",
"T",
"t",
"t+=1",
"t",
"1",
"ans += tmp",
"ans",
"tmp",
"return ans",
"ans",
"T",
"T",
"from itertools import product",
"LS = list(product([0,1], repeat=N-1))",
"LS",
"list(product([0,1], repeat=N-1))",
"list",
"product([0,1], repeat=N-1)",
"product",
"[0,1]",
"0",
"1",
"repeat=N-1",
"repeat",
"N-1",
"N",
"1",
"out = 0",
"out",
"0",
"for L in LS:\n T = S[0]\n for i in range(N-1):\n if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n T += \"=\"\n out += calc(T)",
"L",
"LS",
"T = S[0]",
"T",
"S[0]",
"S",
"0",
"for i in range(N-1):\n if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if L[i]==1:\n T += \"+\"+S[i+1]\n else:\n T += S[i+1]\n ",
"L[i]==1",
"L[i]",
"L",
"i",
"1",
"T += \"+\"+S[i+1]",
"T",
"\"+\"+S[i+1]",
"\"+\"",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"T += S[i+1]",
"T",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"T += \"=\"",
"T",
"\"=\"",
"out += calc(T)",
"out",
"calc(T)",
"calc",
"T",
"print(out)",
"print",
"out",
"out += calc(T)",
"calc(T)",
"out",
"S = list(input())",
"list(input())",
"S",
"out = 0",
"0",
"out",
"T = S[0]",
"S[0]",
"T",
"def calc(T):\n N = len(T)\n t = 0\n ans = 0\n tmp = 0\n while T[t]!=\"=\":\n if T[t]==\"+\":\n ans += tmp\n tmp = 0\n t+=1\n continue\n else:\n tmp = 10*tmp+int(T[t])\n t+=1\n ans += tmp\n return ans",
"def calc(T):\n N = len(T)\n t = 0\n ans = 0\n tmp = 0\n while T[t]!=\"=\":\n if T[t]==\"+\":\n ans += tmp\n tmp = 0\n t+=1\n continue\n else:\n tmp = 10*tmp+int(T[t])\n t+=1\n ans += tmp\n return ans",
"calc",
"T += \"+\"+S[i+1]",
"\"+\"+S[i+1]",
"T",
"T += \"=\"",
"\"=\"",
"T",
"T += S[i+1]",
"S[i+1]",
"T",
"N = len(S)",
"len(S)",
"N",
"LS = list(product([0,1], repeat=N-1))",
"list(product([0,1], repeat=N-1))",
"LS"
] | S = list(input())
N = len(S)
def calc(T):
N = len(T)
t = 0
ans = 0
tmp = 0
while T[t]!="=":
if T[t]=="+":
ans += tmp
tmp = 0
t+=1
continue
else:
tmp = 10*tmp+int(T[t])
t+=1
ans += tmp
return ans
from itertools import product
LS = list(product([0,1], repeat=N-1))
out = 0
for L in LS:
T = S[0]
for i in range(N-1):
if L[i]==1:
T += "+"+S[i+1]
else:
T += S[i+1]
T += "="
out += calc(T)
print(out) |
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] | [
[
74,
2
],
[
71,
6
],
[
65,
9
],
[
75,
12
],
[
15,
14
],
[
66,
20
],
[
68,
23
],
[
75,
25
],
[
29,
28
],
[
66,
32
],
[
14,
37
],
[
28,
38
],
[
77,
41
],
[
62,
44
],
[
75,
46
],
[
28,
48
],
[
59,
51
],
[
63,
54
],
[
78,
54
],
[
69,
54
],
[
60,
57
],
[
72,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
]
] | [
"S = input()\nans = 0\nn = len(S)\nfor i in range(2 ** (n - 1)):\n ex = S[0]\n for j in range(n - 1):\n if (i >> j) & 1:\n ex += \"+\"\n ex += S[j + 1]\n ans += eval(ex)\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"ans = 0",
"ans",
"0",
"n = len(S)",
"n",
"len(S)",
"len",
"S",
"for i in range(2 ** (n - 1)):\n ex = S[0]\n for j in range(n - 1):\n if (i >> j) & 1:\n ex += \"+\"\n ex += S[j + 1]\n ans += eval(ex)",
"i",
"range(2 ** (n - 1))",
"range",
"2 ** (n - 1)",
"2",
"n - 1",
"n",
"1",
"ex = S[0]",
"ex",
"S[0]",
"S",
"0",
"for j in range(n - 1):\n if (i >> j) & 1:\n ex += \"+\"\n ex += S[j + 1]\n ",
"j",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if (i >> j) & 1:\n ex += \"+\"\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"ex += \"+\"",
"ex",
"\"+\"",
"ex += S[j + 1]",
"ex",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"ans += eval(ex)",
"ans",
"eval(ex)",
"eval",
"ex",
"print(ans)",
"print",
"ans",
"ans += eval(ex)",
"eval(ex)",
"ans",
"ex += S[j + 1]",
"S[j + 1]",
"ex",
"n = len(S)",
"len(S)",
"n",
"ex = S[0]",
"S[0]",
"ex",
"ans = 0",
"0",
"ans",
"S = input()",
"input()",
"S",
"ex += \"+\"",
"\"+\"",
"ex"
] | S = input()
ans = 0
n = len(S)
for i in range(2 ** (n - 1)):
ex = S[0]
for j in range(n - 1):
if (i >> j) & 1:
ex += "+"
ex += S[j + 1]
ans += eval(ex)
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
2,
13,
13,
17,
17,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
17,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
18,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13
] | [
[
82,
2
],
[
91,
6
],
[
10,
9
],
[
83,
17
],
[
85,
20
],
[
24,
23
],
[
83,
29
],
[
9,
35
],
[
23,
36
],
[
86,
41
],
[
83,
44
],
[
23,
45
],
[
86,
48
],
[
86,
53
],
[
83,
56
],
[
23,
57
],
[
86,
60
],
[
83,
63
],
[
83,
67
],
[
88,
70
],
[
86,
77
],
[
89,
80
],
[
92,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] | [
"s=input()\nans=0\nfor i in range(1 << len(s)-1):\n l=[]\n for j in range(len(s)-1):\n if (i>>j)&1==1:\n l.append(s[j])\n l.append(\"+\")\n else:\n l.append(s[j])\n l.append(s[len(s)-1])\n ans+=eval(''.join(l))\nprint(ans)",
"s=input()",
"s",
"input()",
"input",
"ans=0",
"ans",
"0",
"for i in range(1 << len(s)-1):\n l=[]\n for j in range(len(s)-1):\n if (i>>j)&1==1:\n l.append(s[j])\n l.append(\"+\")\n else:\n l.append(s[j])\n l.append(s[len(s)-1])\n ans+=eval(''.join(l))",
"i",
"range(1 << len(s)-1)",
"range",
"1 << len(s)-1",
"1",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"l=[]",
"l",
"[]",
"for j in range(len(s)-1):\n if (i>>j)&1==1:\n l.append(s[j])\n l.append(\"+\")\n else:\n l.append(s[j])\n ",
"j",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if (i>>j)&1==1:\n l.append(s[j])\n l.append(\"+\")\n else:\n l.append(s[j])\n ",
"(i>>j)&1==1",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"1",
"l.append(s[j])",
"l.append",
"l",
"append",
"s[j]",
"s",
"j",
"l.append(\"+\")",
"l.append",
"l",
"append",
"\"+\"",
"l.append(s[j])",
"l.append",
"l",
"append",
"s[j]",
"s",
"j",
"l.append(s[len(s)-1])",
"l.append",
"l",
"append",
"s[len(s)-1]",
"s",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"ans+=eval(''.join(l))",
"ans",
"eval(''.join(l))",
"eval",
"''.join(l)",
"''.join",
"''",
"join",
"l",
"print(ans)",
"print",
"ans",
"s=input()",
"input()",
"s",
"l=[]",
"[]",
"l",
"ans+=eval(''.join(l))",
"eval(''.join(l))",
"ans",
"ans=0",
"0",
"ans"
] | s=input()
ans=0
for i in range(1 << len(s)-1):
l=[]
for j in range(len(s)-1):
if (i>>j)&1==1:
l.append(s[j])
l.append("+")
else:
l.append(s[j])
l.append(s[len(s)-1])
ans+=eval(''.join(l))
print(ans) |
[
7,
12,
13,
0,
13,
4,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
18,
13,
13,
17,
0,
13,
2,
39,
17,
2,
4,
13,
13,
4,
13,
13,
0,
18,
13,
39,
17,
17,
13,
18,
13,
39,
17,
13,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
13,
12
],
[
4,
16
],
[
20,
19
],
[
23,
22
],
[
12,
27
],
[
30,
29
],
[
12,
33
],
[
36,
35
],
[
12,
38
],
[
22,
42
],
[
35,
43
],
[
49,
46
],
[
29,
47
],
[
35,
48
],
[
52,
51
],
[
4,
58
],
[
29,
61
],
[
68,
63
],
[
51,
64
],
[
29,
68
],
[
73,
69
],
[
51,
70
],
[
4,
73
],
[
76,
75
],
[
51,
80
],
[
83,
82
],
[
75,
85
],
[
82,
88
],
[
19,
88
],
[
97,
94
]
] | [
"def main():\n\tS = list(str(input()))\n\tLenP = len(S)-1\n\tans = 0\n\tfor i in range(2**LenP):\n\t\tP = [\"\"]*LenP\n\t\tfor j in range(LenP):\n\t\t\tif i >> j & 1:\n\t\t\t\tP[j] = \"+\"\n\t\tRes = [None] * (len(S)+len(P))\n\t\tRes[1::2],Res[::2] = P,S\n\t\tResEval = \"\".join(Res)\n\t\tans += eval(ResEval)\n\tprint(ans)\n\nif __name__ == '__main__':\n\tmain()",
"def main():\n\tS = list(str(input()))\n\tLenP = len(S)-1\n\tans = 0\n\tfor i in range(2**LenP):\n\t\tP = [\"\"]*LenP\n\t\tfor j in range(LenP):\n\t\t\tif i >> j & 1:\n\t\t\t\tP[j] = \"+\"\n\t\tRes = [None] * (len(S)+len(P))\n\t\tRes[1::2],Res[::2] = P,S\n\t\tResEval = \"\".join(Res)\n\t\tans += eval(ResEval)\n\tprint(ans)",
"main",
"S = list(str(input()))",
"S",
"list(str(input()))",
"list",
"str(input())",
"str",
"input()",
"input",
"LenP = len(S)-1",
"LenP",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2**LenP):\n\t\tP = [\"\"]*LenP\n\t\tfor j in range(LenP):\n\t\t\tif i >> j & 1:\n\t\t\t\tP[j] = \"+\"\n\t\tRes = [None] * (len(S)+len(P))\n\t\tRes[1::2],Res[::2] = P,S\n\t\tResEval = \"\".join(Res)\n\t\tans += eval(ResEval)\n\t",
"i",
"range(2**LenP)",
"range",
"2**LenP",
"2",
"LenP",
"P = [\"\"]*LenP",
"P",
"[\"\"]*LenP",
"[\"\"]",
"\"\"",
"LenP",
"for j in range(LenP):\n\t\t\tif i >> j & 1:\n\t\t\t\tP[j] = \"+\"\n\t\t",
"j",
"range(LenP)",
"range",
"LenP",
"if i >> j & 1:\n\t\t\t\tP[j] = \"+\"\n\t\t",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"P[j] = \"+\"",
"P[j]",
"P",
"j",
"\"+\"",
"Res = [None] * (len(S)+len(P))",
"Res",
"[None] * (len(S)+len(P))",
"[None]",
"None",
"len(S)+len(P)",
"len(S)",
"len",
"S",
"len(P)",
"len",
"P",
"Res[1::2],Res[::2] = P,S",
"Res[1::2]",
"Res",
"1::2",
"1",
"2",
"P",
"Res[::2]",
"Res",
"::2",
"2",
"S",
"ResEval = \"\".join(Res)",
"ResEval",
"\"\".join(Res)",
"\"\".join",
"\"\"",
"join",
"Res",
"ans += eval(ResEval)",
"ans",
"eval(ResEval)",
"eval",
"ResEval",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n\tmain()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n\tS = list(str(input()))\n\tLenP = len(S)-1\n\tans = 0\n\tfor i in range(2**LenP):\n\t\tP = [\"\"]*LenP\n\t\tfor j in range(LenP):\n\t\t\tif i >> j & 1:\n\t\t\t\tP[j] = \"+\"\n\t\tRes = [None] * (len(S)+len(P))\n\t\tRes[1::2],Res[::2] = P,S\n\t\tResEval = \"\".join(Res)\n\t\tans += eval(ResEval)\n\tprint(ans)",
"def main():\n\tS = list(str(input()))\n\tLenP = len(S)-1\n\tans = 0\n\tfor i in range(2**LenP):\n\t\tP = [\"\"]*LenP\n\t\tfor j in range(LenP):\n\t\t\tif i >> j & 1:\n\t\t\t\tP[j] = \"+\"\n\t\tRes = [None] * (len(S)+len(P))\n\t\tRes[1::2],Res[::2] = P,S\n\t\tResEval = \"\".join(Res)\n\t\tans += eval(ResEval)\n\tprint(ans)",
"main"
] | def main():
S = list(str(input()))
LenP = len(S)-1
ans = 0
for i in range(2**LenP):
P = [""]*LenP
for j in range(LenP):
if i >> j & 1:
P[j] = "+"
Res = [None] * (len(S)+len(P))
Res[1::2],Res[::2] = P,S
ResEval = "".join(Res)
ans += eval(ResEval)
print(ans)
if __name__ == '__main__':
main() |
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
2,
13,
13,
17,
17,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
4,
12
],
[
16,
15
],
[
19,
18
],
[
8,
23
],
[
26,
25
],
[
4,
27
],
[
31,
30
],
[
8,
33
],
[
18,
38
],
[
30,
39
],
[
44,
43
],
[
47,
46
],
[
4,
48
],
[
30,
50
],
[
54,
53
],
[
46,
61
],
[
43,
61
],
[
25,
61
],
[
66,
65
],
[
53,
68
],
[
65,
71
],
[
15,
71
],
[
80,
77
]
] | [
"def main():\n S = input()\n n = len(S) - 1\n ans = 0\n\n for i in range(2 ** n):\n c = S[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n c += \"+\"\n c += S[j + 1]\n t = list(map(int, c.split(\"+\")))\n ans += sum(t)\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"def main():\n S = input()\n n = len(S) - 1\n ans = 0\n\n for i in range(2 ** n):\n c = S[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n c += \"+\"\n c += S[j + 1]\n t = list(map(int, c.split(\"+\")))\n ans += sum(t)\n\n print(ans)",
"main",
"S = input()",
"S",
"input()",
"input",
"n = len(S) - 1",
"n",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2 ** n):\n c = S[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n c += \"+\"\n c += S[j + 1]\n t = list(map(int, c.split(\"+\")))\n ans += sum(t)\n\n ",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"c = S[0]",
"c",
"S[0]",
"S",
"0",
"for j in range(n):\n if (i >> j) & 1 == 1:\n c += \"+\"\n c += S[j + 1]\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1 == 1:\n c += \"+\"\n ",
"(i >> j) & 1 == 1",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"1",
"c += \"+\"",
"c",
"\"+\"",
"c += S[j + 1]",
"c",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"t = list(map(int, c.split(\"+\")))",
"t",
"list(map(int, c.split(\"+\")))",
"list",
"map(int, c.split(\"+\"))",
"map",
"int",
"c.split(\"+\")",
"c.split",
"c",
"split",
"\"+\"",
"ans += sum(t)",
"ans",
"sum(t)",
"sum",
"t",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n S = input()\n n = len(S) - 1\n ans = 0\n\n for i in range(2 ** n):\n c = S[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n c += \"+\"\n c += S[j + 1]\n t = list(map(int, c.split(\"+\")))\n ans += sum(t)\n\n print(ans)",
"def main():\n S = input()\n n = len(S) - 1\n ans = 0\n\n for i in range(2 ** n):\n c = S[0]\n for j in range(n):\n if (i >> j) & 1 == 1:\n c += \"+\"\n c += S[j + 1]\n t = list(map(int, c.split(\"+\")))\n ans += sum(t)\n\n print(ans)",
"main"
] | def main():
S = input()
n = len(S) - 1
ans = 0
for i in range(2 ** n):
c = S[0]
for j in range(n):
if (i >> j) & 1 == 1:
c += "+"
c += S[j + 1]
t = list(map(int, c.split("+")))
ans += sum(t)
print(ans)
if __name__ == "__main__":
main()
|
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13
] | [
[
67,
2
],
[
73,
6
],
[
68,
10
],
[
82,
13
],
[
17,
16
],
[
74,
21
],
[
85,
23
],
[
27,
26
],
[
16,
29
],
[
16,
32
],
[
26,
35
],
[
76,
37
],
[
68,
41
],
[
26,
45
],
[
79,
48
],
[
26,
50
],
[
70,
53
],
[
68,
57
],
[
68,
62
],
[
71,
65
],
[
77,
65
],
[
83,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
]
] | [
"s = input()\nn = len(s) - 1\nans = 0\nfor bit in range(1 << n):\n now = 0\n for i in range(bit):\n if bit & (1 << i):\n ans += int(s[now : i + 1])\n now = i + 1\n ans += int(s[now : len(s)])\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"for bit in range(1 << n):\n now = 0\n for i in range(bit):\n if bit & (1 << i):\n ans += int(s[now : i + 1])\n now = i + 1\n ans += int(s[now : len(s)])",
"bit",
"range(1 << n)",
"range",
"1 << n",
"1",
"n",
"now = 0",
"now",
"0",
"for i in range(bit):\n if bit & (1 << i):\n ans += int(s[now : i + 1])\n now = i + 1\n ",
"i",
"range(bit)",
"range",
"bit",
"if bit & (1 << i):\n ans += int(s[now : i + 1])\n now = i + 1\n ",
"bit & (1 << i)",
"bit",
"1 << i",
"1",
"i",
"ans += int(s[now : i + 1])",
"ans",
"int(s[now : i + 1])",
"int",
"s[now : i + 1]",
"s",
"now : i + 1",
"now",
"i + 1",
"i",
"1",
"now = i + 1",
"now",
"i + 1",
"i",
"1",
"ans += int(s[now : len(s)])",
"ans",
"int(s[now : len(s)])",
"int",
"s[now : len(s)]",
"s",
"now : len(s)",
"now",
"len(s)",
"len",
"s",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"ans += int(s[now : len(s)])",
"int(s[now : len(s)])",
"ans",
"n = len(s) - 1",
"len(s) - 1",
"n",
"ans += int(s[now : i + 1])",
"int(s[now : i + 1])",
"ans",
"now = i + 1",
"i + 1",
"now",
"ans = 0",
"0",
"ans",
"now = 0",
"0",
"now"
] | s = input()
n = len(s) - 1
ans = 0
for bit in range(1 << n):
now = 0
for i in range(bit):
if bit & (1 << i):
ans += int(s[now : i + 1])
now = i + 1
ans += int(s[now : len(s)])
print(ans)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.