node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
2,
4,
13,
13,
13,
17,
0,
13,
2,
2,
2,
4,
13,
18,
13,
13,
2,
17,
2,
13,
17,
2,
17,
13,
2,
17,
4,
13,
17,
2,
2,
2,
4,
13,
13,
13,
13,
17,
4,
13,
13,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
12,
11
],
[
4,
16
],
[
19,
18
],
[
4,
26
],
[
11,
27
],
[
31,
30
],
[
4,
37
],
[
11,
38
],
[
18,
42
],
[
11,
46
],
[
4,
57
],
[
11,
58
],
[
18,
59
],
[
30,
63
],
[
8,
63
],
[
68,
65
]
] | [
"def main():\n S = input()\n ans = 0\n for i in range(len(S)):\n for j in range(1,len(S)-i+1):\n # 数値S[i]を下からj桁目の数として受け取るパターン数は\n # (1) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[:i]\n # (2) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[i:]\n # の積に他ならない\n ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))\n print(ans)\nmain()",
"def main():\n S = input()\n ans = 0\n for i in range(len(S)):\n for j in range(1,len(S)-i+1):\n # 数値S[i]を下からj桁目の数として受け取るパターン数は\n # (1) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[:i]\n # (2) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[i:]\n # の積に他ならない\n ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))\n print(ans)",
"main",
"S = input()",
"S",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(len(S)):\n for j in range(1,len(S)-i+1):\n # 数値S[i]を下からj桁目の数として受け取るパターン数は\n # (1) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[:i]\n # (2) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[i:]\n # の積に他ならない\n ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))\n ",
"i",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"for j in range(1,len(S)-i+1):\n # 数値S[i]を下からj桁目の数として受け取るパターン数は\n # (1) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[:i]\n # (2) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[i:]\n # の積に他ならない\n ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))\n ",
"j",
"range(1,len(S)-i+1)",
"range",
"1",
"len(S)-i+1",
"len(S)-i",
"len(S)",
"len",
"S",
"i",
"1",
"ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))",
"ans",
"int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))",
"int(S[i])*(10**(j-1)) * (2**i)",
"int(S[i])*(10**(j-1))",
"int(S[i])",
"int",
"S[i]",
"S",
"i",
"10**(j-1)",
"10",
"j-1",
"j",
"1",
"2**i",
"2",
"i",
"2**max(0,(len(S)-i-j-1))",
"2",
"max(0,(len(S)-i-j-1))",
"max",
"0",
"len(S)-i-j-1",
"len(S)-i-j",
"len(S)-i",
"len(S)",
"len",
"S",
"i",
"j",
"1",
"print(ans)",
"print",
"ans",
"main()",
"main",
"def main():\n S = input()\n ans = 0\n for i in range(len(S)):\n for j in range(1,len(S)-i+1):\n # 数値S[i]を下からj桁目の数として受け取るパターン数は\n # (1) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[:i]\n # (2) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[i:]\n # の積に他ならない\n ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))\n print(ans)",
"def main():\n S = input()\n ans = 0\n for i in range(len(S)):\n for j in range(1,len(S)-i+1):\n # 数値S[i]を下からj桁目の数として受け取るパターン数は\n # (1) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[:i]\n # (2) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[i:]\n # の積に他ならない\n ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))\n print(ans)",
"main"
] | def main():
S = input()
ans = 0
for i in range(len(S)):
for j in range(1,len(S)-i+1):
# 数値S[i]を下からj桁目の数として受け取るパターン数は
# (1) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[:i]
# (2) (残りのSの長さ-1)個の場所に'+'をいれるパターン数 S[i:]
# の積に他ならない
ans += int(S[i])*(10**(j-1)) * (2**i) * (2**max(0,(len(S)-i-j-1)))
print(ans)
main()
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
17,
13,
0,
13,
4,
18,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
13,
17,
14,
2,
13,
17,
4,
18,
13,
13,
2,
13,
13,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13
] | [
[
79,
2
],
[
73,
8
],
[
80,
12
],
[
76,
15
],
[
82,
18
],
[
22,
21
],
[
74,
26
],
[
85,
28
],
[
80,
31
],
[
35,
34
],
[
74,
37
],
[
88,
39
],
[
21,
42
],
[
34,
43
],
[
89,
47
],
[
86,
51
],
[
74,
54
],
[
34,
55
],
[
70,
58
],
[
86,
65
],
[
71,
68
],
[
77,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] | [
"s = list(input())\nn = len(s)-1\nans = 0\nl = []\nfor i in range(2**n):\n ss = s.copy()\n for j in range(n):\n bit = (i >> j) & 1\n if bit == 1:\n ss.insert(n - j, '+')\n\n ans += eval(''.join(ss)) \n\n \nprint(ans)",
"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",
"l = []",
"l",
"[]",
"for i in range(2**n):\n ss = s.copy()\n for j in range(n):\n bit = (i >> j) & 1\n if bit == 1:\n ss.insert(n - j, '+')\n\n ans += eval(''.join(ss)) \n\n ",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"ss = s.copy()",
"ss",
"s.copy()",
"s.copy",
"s",
"copy",
"for j in range(n):\n bit = (i >> j) & 1\n if bit == 1:\n ss.insert(n - j, '+')\n\n ",
"j",
"range(n)",
"range",
"n",
"bit = (i >> j) & 1",
"bit",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"if bit == 1:\n ss.insert(n - j, '+')\n\n ",
"bit == 1",
"bit",
"1",
"ss.insert(n - j, '+')",
"ss.insert",
"ss",
"insert",
"n - j",
"n",
"j",
"'+'",
"ans += eval(''.join(ss))",
"ans",
"eval(''.join(ss))",
"eval",
"''.join(ss)",
"''.join",
"''",
"join",
"ss",
"print(ans)",
"print",
"ans",
"ans += eval(''.join(ss))",
"eval(''.join(ss))",
"ans",
"n = len(s)-1",
"len(s)-1",
"n",
"ans = 0",
"0",
"ans",
"s = list(input())",
"list(input())",
"s",
"l = []",
"[]",
"l",
"ss = s.copy()",
"s.copy()",
"ss",
"bit = (i >> j) & 1",
"(i >> j) & 1",
"bit"
] | s = list(input())
n = len(s)-1
ans = 0
l = []
for i in range(2**n):
ss = s.copy()
for j in range(n):
bit = (i >> j) & 1
if bit == 1:
ss.insert(n - j, '+')
ans += eval(''.join(ss))
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
0,
13,
18,
13,
13,
14,
40,
13,
2,
4,
13,
13,
17,
14,
2,
13,
2,
17,
13,
0,
13,
39,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
39,
13
] | [
[
76,
2
],
[
70,
6
],
[
85,
9
],
[
77,
12
],
[
15,
14
],
[
77,
22
],
[
73,
25
],
[
29,
28
],
[
77,
33
],
[
82,
35
],
[
86,
37
],
[
28,
38
],
[
28,
41
],
[
77,
45
],
[
14,
49
],
[
28,
52
],
[
88,
54
],
[
79,
58
],
[
89,
65
],
[
83,
65
],
[
74,
65
],
[
80,
68
],
[
71,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] | [
"s = input()\nr = 0\nl = list(s)\nfor i in range(1 << len(s)-1):\n li = []\n for j in range(len(s)):\n# print(i,j)\n li += l[j]\n if j != len(s)-1:\n if i & 1 <<j:\n li += ['+']\n# print(li)\n \n r += eval(''.join(li))\nprint(r)",
"s = input()",
"s",
"input()",
"input",
"r = 0",
"r",
"0",
"l = list(s)",
"l",
"list(s)",
"list",
"s",
"for i in range(1 << len(s)-1):\n li = []\n for j in range(len(s)):\n# print(i,j)\n li += l[j]\n if j != len(s)-1:\n if i & 1 <<j:\n li += ['+']\n# print(li)\n \n r += eval(''.join(li))",
"i",
"range(1 << len(s)-1)",
"range",
"1 << len(s)-1",
"1",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"li = []",
"li",
"[]",
"for j in range(len(s)):\n# print(i,j)\n li += l[j]\n if j != len(s)-1:\n if i & 1 <<j:\n li += ['+']\n# print(li)\n \n ",
"j",
"range(len(s))",
"range",
"len(s)",
"len",
"s",
"li += l[j]",
"li",
"l[j]",
"l",
"j",
"if j != len(s)-1:\n if i & 1 <<j:\n li += ['+']\n# print(li)\n \n ",
"j != len(s)-1",
"j",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if i & 1 <<j:\n li += ['+']\n# print(li)\n \n ",
"i & 1 <<j",
"i",
"1 <<j",
"1",
"j",
"li += ['+']",
"li",
"['+']",
"'+'",
"r += eval(''.join(li))",
"r",
"eval(''.join(li))",
"eval",
"''.join(li)",
"''.join",
"''",
"join",
"li",
"print(r)",
"print",
"r",
"r = 0",
"0",
"r",
"li = []",
"[]",
"li",
"s = input()",
"input()",
"s",
"r += eval(''.join(li))",
"eval(''.join(li))",
"r",
"li += l[j]",
"l[j]",
"li",
"l = list(s)",
"list(s)",
"l",
"li += ['+']",
"['+']",
"li"
] | s = input()
r = 0
l = list(s)
for i in range(1 << len(s)-1):
li = []
for j in range(len(s)):
# print(i,j)
li += l[j]
if j != len(s)-1:
if i & 1 <<j:
li += ['+']
# print(li)
r += eval(''.join(li))
print(r) |
[
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,
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,
4,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] | [
[
77,
2
],
[
83,
8
],
[
78,
11
],
[
80,
13
],
[
17,
16
],
[
84,
22
],
[
71,
25
],
[
78,
27
],
[
31,
30
],
[
84,
34
],
[
16,
38
],
[
30,
41
],
[
86,
43
],
[
74,
46
],
[
78,
48
],
[
30,
50
],
[
68,
53
],
[
75,
61
],
[
87,
61
],
[
72,
61
],
[
69,
66
],
[
81,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] | [
"S = list(input())\nl = len(S)\n\nans = 0\n\nfor bit in range(1 << (l-1)):\n # print(bit)\n f = S[0]\n for i in range(l-1):\n if bit & (1 << i):\n f += \"+\"\n f += S[i+1]\n\n ans += sum(map(int, f.split(\"+\")))\nprint(ans)",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"l = len(S)",
"l",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for bit in range(1 << (l-1)):\n # print(bit)\n f = S[0]\n for i in range(l-1):\n if bit & (1 << i):\n f += \"+\"\n f += S[i+1]\n\n ans += sum(map(int, f.split(\"+\")))",
"bit",
"range(1 << (l-1))",
"range",
"1 << (l-1)",
"1",
"l-1",
"l",
"1",
"f = S[0]",
"f",
"S[0]",
"S",
"0",
"for i in range(l-1):\n if bit & (1 << i):\n f += \"+\"\n f += S[i+1]\n\n ",
"i",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if bit & (1 << i):\n f += \"+\"\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",
"ans += sum(map(int, f.split(\"+\")))",
"sum(map(int, f.split(\"+\")))",
"ans",
"f = S[0]",
"S[0]",
"f",
"f += S[i+1]",
"S[i+1]",
"f",
"S = list(input())",
"list(input())",
"S",
"ans = 0",
"0",
"ans",
"l = len(S)",
"len(S)",
"l",
"f += \"+\"",
"\"+\"",
"f"
] | S = list(input())
l = len(S)
ans = 0
for bit in range(1 << (l-1)):
# print(bit)
f = S[0]
for i in range(l-1):
if bit & (1 << i):
f += "+"
f += S[i+1]
ans += sum(map(int, f.split("+")))
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
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,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
56,
2
],
[
68,
6
],
[
71,
9
],
[
57,
12
],
[
15,
14
],
[
72,
20
],
[
53,
23
],
[
27,
26
],
[
72,
29
],
[
62,
31
],
[
57,
33
],
[
26,
34
],
[
14,
38
],
[
26,
39
],
[
59,
42
],
[
65,
45
],
[
60,
48
],
[
63,
48
],
[
54,
48
],
[
66,
51
],
[
69,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
]
] | [
"s = input()\n\nans = 0\nl = len(s)\nfor i in range(2**(l-1)):\n ss = ''\n for j in range(l):\n ss += s[j]\n if (i >> j) & 1:\n ss += '+'\n ans += eval(ss)\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"ans = 0",
"ans",
"0",
"l = len(s)",
"l",
"len(s)",
"len",
"s",
"for i in range(2**(l-1)):\n ss = ''\n for j in range(l):\n ss += s[j]\n if (i >> j) & 1:\n ss += '+'\n ans += eval(ss)",
"i",
"range(2**(l-1))",
"range",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"ss = ''",
"ss",
"''",
"for j in range(l):\n ss += s[j]\n if (i >> j) & 1:\n ss += '+'\n ",
"j",
"range(l)",
"range",
"l",
"ss += s[j]",
"ss",
"s[j]",
"s",
"j",
"if (i >> j) & 1:\n ss += '+'\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"ss += '+'",
"ss",
"'+'",
"ans += eval(ss)",
"ans",
"eval(ss)",
"eval",
"ss",
"print(ans)",
"print",
"ans",
"ss = ''",
"''",
"ss",
"s = input()",
"input()",
"s",
"ss += '+'",
"'+'",
"ss",
"ss += s[j]",
"s[j]",
"ss",
"ans += eval(ss)",
"eval(ss)",
"ans",
"ans = 0",
"0",
"ans",
"l = len(s)",
"len(s)",
"l"
] | s = input()
ans = 0
l = len(s)
for i in range(2**(l-1)):
ss = ''
for j in range(l):
ss += s[j]
if (i >> j) & 1:
ss += '+'
ans += eval(ss)
print(ans) |
[
7,
15,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] | [
[
97,
3
],
[
94,
7
],
[
11,
10
],
[
20,
19
],
[
98,
23
],
[
103,
26
],
[
91,
29
],
[
98,
31
],
[
35,
34
],
[
98,
40
],
[
10,
45
],
[
34,
46
],
[
82,
49
],
[
98,
51
],
[
34,
53
],
[
85,
56
],
[
92,
59
],
[
101,
59
],
[
83,
59
],
[
100,
61
],
[
98,
63
],
[
34,
65
],
[
88,
68
],
[
101,
71
],
[
83,
71
],
[
92,
71
],
[
79,
73
],
[
89,
74
],
[
86,
74
],
[
104,
74
],
[
80,
77
],
[
95,
77
],
[
89,
79
],
[
86,
79
],
[
104,
79
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
]
] | [
"from itertools import product\n\nS=input()\nans=0\nfor i in list(product([False,True],repeat=len(S)-1)):\n b=0\n a=S[0]\n for j in range(len(S)-1):\n if i[j]==False:\n a+=S[j+1]\n else:\n b+=int(a)\n a=S[j+1]\n b+=int(a)\n ans+=b\nprint(ans)",
"from itertools import product",
"S=input()",
"S",
"input()",
"input",
"ans=0",
"ans",
"0",
"for i in list(product([False,True],repeat=len(S)-1)):\n b=0\n a=S[0]\n for j in range(len(S)-1):\n if i[j]==False:\n a+=S[j+1]\n else:\n b+=int(a)\n a=S[j+1]\n b+=int(a)\n ans+=b",
"i",
"list(product([False,True],repeat=len(S)-1))",
"list",
"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",
"b=0",
"b",
"0",
"a=S[0]",
"a",
"S[0]",
"S",
"0",
"for j in range(len(S)-1):\n if i[j]==False:\n a+=S[j+1]\n else:\n b+=int(a)\n a=S[j+1]\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if i[j]==False:\n a+=S[j+1]\n else:\n b+=int(a)\n a=S[j+1]\n ",
"i[j]==False",
"i[j]",
"i",
"j",
"False",
"a+=S[j+1]",
"a",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"b+=int(a)",
"b",
"int(a)",
"int",
"a",
"a=S[j+1]",
"a",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"b+=int(a)",
"b",
"int(a)",
"int",
"a",
"ans+=b",
"ans",
"b",
"print(ans)",
"print",
"ans",
"ans+=b",
"b",
"ans",
"a+=S[j+1]",
"S[j+1]",
"a",
"b+=int(a)",
"int(a)",
"b",
"b+=int(a)",
"int(a)",
"b",
"a=S[0]",
"S[0]",
"a",
"ans=0",
"0",
"ans",
"S=input()",
"input()",
"S",
"a=S[j+1]",
"S[j+1]",
"a",
"b=0",
"0",
"b"
] | from itertools import product
S=input()
ans=0
for i in list(product([False,True],repeat=len(S)-1)):
b=0
a=S[0]
for j in range(len(S)-1):
if i[j]==False:
a+=S[j+1]
else:
b+=int(a)
a=S[j+1]
b+=int(a)
ans+=b
print(ans)
|
[
7,
0,
13,
4,
13,
14,
2,
4,
13,
13,
17,
4,
13,
13,
4,
13,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
2,
13,
17,
14,
2,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
17,
41,
28,
13,
13,
4,
4,
13,
13,
0,
13,
13,
4,
13,
4,
13,
13,
10,
2,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] | [
[
112,
2
],
[
113,
9
],
[
113,
13
],
[
106,
17
],
[
109,
20
],
[
24,
23
],
[
113,
31
],
[
35,
34
],
[
113,
40
],
[
23,
45
],
[
34,
46
],
[
107,
50
],
[
113,
53
],
[
34,
57
],
[
103,
60
],
[
34,
62
],
[
34,
66
],
[
113,
70
],
[
107,
74
],
[
113,
77
],
[
34,
81
],
[
118,
84
],
[
89,
88
],
[
107,
88
],
[
88,
93
],
[
115,
95
],
[
116,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
]
] | [
"n = input()\n\nif len(n) < 2:\n print(n)\n exit()\n\nkumi = []\niti = 0\n\nfor x in range(2 ** (len(n) -1)):\n for m in range(len(n) -1):\n if (x >> m) & 1:\n kumi.append(n[iti:m+1])\n iti = m+1\n if m == len(n) -2:\n kumi.append(n[iti:m+2])\n iti = 0\n\nkumi_int =[int(s) for s in kumi]\nprint(sum(kumi_int))",
"n = input()",
"n",
"input()",
"input",
"if len(n) < 2:\n print(n)\n exit()",
"len(n) < 2",
"len(n)",
"len",
"n",
"2",
"print(n)",
"print",
"n",
"exit()",
"exit",
"kumi = []",
"kumi",
"[]",
"iti = 0",
"iti",
"0",
"for x in range(2 ** (len(n) -1)):\n for m in range(len(n) -1):\n if (x >> m) & 1:\n kumi.append(n[iti:m+1])\n iti = m+1\n if m == len(n) -2:\n kumi.append(n[iti:m+2])\n iti = 0",
"x",
"range(2 ** (len(n) -1))",
"range",
"2 ** (len(n) -1)",
"2",
"len(n) -1",
"len(n)",
"len",
"n",
"1",
"for m in range(len(n) -1):\n if (x >> m) & 1:\n kumi.append(n[iti:m+1])\n iti = m+1\n if m == len(n) -2:\n kumi.append(n[iti:m+2])\n ",
"m",
"range(len(n) -1)",
"range",
"len(n) -1",
"len(n)",
"len",
"n",
"1",
"if (x >> m) & 1:\n kumi.append(n[iti:m+1])\n iti = m+1\n ",
"(x >> m) & 1",
"x >> m",
"x",
"m",
"1",
"kumi.append(n[iti:m+1])",
"kumi.append",
"kumi",
"append",
"n[iti:m+1]",
"n",
"iti:m+1",
"iti",
"m+1",
"m",
"1",
"iti = m+1",
"iti",
"m+1",
"m",
"1",
"if m == len(n) -2:\n kumi.append(n[iti:m+2])\n ",
"m == len(n) -2",
"m",
"len(n) -2",
"len(n)",
"len",
"n",
"2",
"kumi.append(n[iti:m+2])",
"kumi.append",
"kumi",
"append",
"n[iti:m+2]",
"n",
"iti:m+2",
"iti",
"m+2",
"m",
"2",
"iti = 0",
"iti",
"0",
"int(s) for s in kumi",
"for s in kumi",
"s",
"kumi",
"for s in kumi",
"int(s)",
"int",
"s",
"kumi_int =[int(s) for s in kumi]",
"kumi_int",
"[int(s) for s in kumi]",
"print(sum(kumi_int))",
"print",
"sum(kumi_int)",
"sum",
"kumi_int",
"iti = m+1",
"m+1",
"iti",
"kumi = []",
"[]",
"kumi",
"iti = 0",
"0",
"iti",
"n = input()",
"input()",
"n",
"kumi_int =[int(s) for s in kumi]",
"[int(s) for s in kumi]",
"kumi_int",
"iti = 0",
"0",
"iti"
] | n = input()
if len(n) < 2:
print(n)
exit()
kumi = []
iti = 0
for x in range(2 ** (len(n) -1)):
for m in range(len(n) -1):
if (x >> m) & 1:
kumi.append(n[iti:m+1])
iti = m+1
if m == len(n) -2:
kumi.append(n[iti:m+2])
iti = 0
kumi_int =[int(s) for s in kumi]
print(sum(kumi_int)) |
[
7,
15,
13,
15,
13,
4,
18,
13,
13,
17,
15,
15,
13,
15,
13,
0,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
17,
12,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
2,
17,
18,
13,
2,
13,
17,
29,
13,
23,
13,
0,
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,
2,
2,
13,
13,
17,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
17,
0,
13,
39,
28,
13,
4,
13,
17,
4,
13,
13,
14,
2,
18,
13,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
17,
0,
13,
18,
13,
13,
4,
18,
13,
13,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13
] | [
[
200,
16
],
[
182,
21
],
[
206,
26
],
[
32,
31
],
[
37,
36
],
[
67,
41
],
[
67,
45
],
[
36,
46
],
[
50,
49
],
[
36,
53
],
[
57,
56
],
[
36,
62
],
[
56,
65
],
[
49,
65
],
[
31,
65
],
[
67,
67
],
[
212,
69
],
[
191,
73
],
[
213,
77
],
[
188,
80
],
[
84,
83
],
[
192,
88
],
[
173,
90
],
[
192,
94
],
[
97,
96
],
[
192,
99
],
[
83,
103
],
[
96,
104
],
[
114,
107
],
[
174,
108
],
[
192,
111
],
[
96,
112
],
[
197,
116
],
[
204,
118
],
[
174,
119
],
[
194,
121
],
[
198,
123
],
[
209,
126
],
[
130,
129
],
[
198,
135
],
[
198,
139
],
[
129,
140
],
[
210,
144
],
[
195,
148
],
[
180,
148
],
[
177,
148
],
[
176,
150
],
[
179,
153
],
[
198,
155
],
[
129,
156
],
[
210,
159
],
[
180,
163
],
[
177,
163
],
[
195,
163
],
[
185,
165
],
[
210,
168
],
[
186,
171
],
[
189,
171
],
[
173,
174
],
[
176,
177
],
[
179,
180
],
[
182,
183
],
[
185,
186
],
[
188,
189
],
[
191,
192
],
[
194,
195
],
[
197,
198
],
[
200,
201
],
[
206,
207
],
[
209,
210
],
[
212,
213
]
] | [
"import sys\nimport itertools\nsys.setrecursionlimit(1000000000)\nfrom heapq import heapify,heappop,heappush,heappushpop\nimport math\nimport collections\nMAX = 10**18\nMIN = -10**18\nMOD = 998244353\n\n\ndef judge(li):\n c = s[0]\n for i in range(len(li)):\n if li[i] == False:\n c += s[i+1]\n else:\n c += \"+\" + s[i+1]\n return c\ns = input()\nn = len(s)-1\nans = 0\nfor i in range(2**n):\n li = [False]*(n)\n for j in range(n):\n if (i>>j)&1:\n li[n-j-1] = True\n a = judge(li)\n e = a[0]\n sumli = []\n for j in range(1,len(a)):\n if a[j] == \"+\":\n sumli.append(int(e))\n e = \"\"\n else:\n e += a[j]\n sumli.append(int(e))\n ans += sum(sumli)\nprint(ans)",
"import sys",
"sys",
"import itertools",
"itertools",
"sys.setrecursionlimit(1000000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000000",
"from heapq import heapify,heappop,heappush,heappushpop",
"import math",
"math",
"import collections",
"collections",
"MAX = 10**18",
"MAX",
"10**18",
"10",
"18",
"MIN = -10**18",
"MIN",
"-10**18",
"-10",
"18",
"MOD = 998244353",
"MOD",
"998244353",
"def judge(li):\n c = s[0]\n for i in range(len(li)):\n if li[i] == False:\n c += s[i+1]\n else:\n c += \"+\" + s[i+1]\n return c",
"judge",
"c = s[0]",
"c",
"s[0]",
"s",
"0",
"for i in range(len(li)):\n if li[i] == False:\n c += s[i+1]\n else:\n c += \"+\" + s[i+1]\n ",
"i",
"range(len(li))",
"range",
"len(li)",
"len",
"li",
"if li[i] == False:\n c += s[i+1]\n else:\n c += \"+\" + s[i+1]\n ",
"li[i] == False",
"li[i]",
"li",
"i",
"False",
"c += s[i+1]",
"c",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"c += \"+\" + s[i+1]",
"c",
"\"+\" + s[i+1]",
"\"+\"",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"return c",
"c",
"li",
"li",
"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 li = [False]*(n)\n for j in range(n):\n if (i>>j)&1:\n li[n-j-1] = True\n a = judge(li)\n e = a[0]\n sumli = []\n for j in range(1,len(a)):\n if a[j] == \"+\":\n sumli.append(int(e))\n e = \"\"\n else:\n e += a[j]\n sumli.append(int(e))\n ans += sum(sumli)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"li = [False]*(n)",
"li",
"[False]*(n)",
"[False]",
"False",
"n",
"for j in range(n):\n if (i>>j)&1:\n li[n-j-1] = True\n ",
"j",
"range(n)",
"range",
"n",
"if (i>>j)&1:\n li[n-j-1] = True\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"li[n-j-1] = True",
"li[n-j-1]",
"li",
"n-j-1",
"n-j",
"n",
"j",
"1",
"True",
"a = judge(li)",
"a",
"judge(li)",
"judge",
"li",
"e = a[0]",
"e",
"a[0]",
"a",
"0",
"sumli = []",
"sumli",
"[]",
"for j in range(1,len(a)):\n if a[j] == \"+\":\n sumli.append(int(e))\n e = \"\"\n else:\n e += a[j]\n ",
"j",
"range(1,len(a))",
"range",
"1",
"len(a)",
"len",
"a",
"if a[j] == \"+\":\n sumli.append(int(e))\n e = \"\"\n else:\n e += a[j]\n ",
"a[j] == \"+\"",
"a[j]",
"a",
"j",
"\"+\"",
"sumli.append(int(e))",
"sumli.append",
"sumli",
"append",
"int(e)",
"int",
"e",
"e = \"\"",
"e",
"\"\"",
"e += a[j]",
"e",
"a[j]",
"a",
"j",
"sumli.append(int(e))",
"sumli.append",
"sumli",
"append",
"int(e)",
"int",
"e",
"ans += sum(sumli)",
"ans",
"sum(sumli)",
"sum",
"sumli",
"print(ans)",
"print",
"ans",
"li = [False]*(n)",
"[False]*(n)",
"li",
"e = \"\"",
"\"\"",
"e",
"e += a[j]",
"a[j]",
"e",
"MIN = -10**18",
"-10**18",
"MIN",
"ans += sum(sumli)",
"sum(sumli)",
"ans",
"ans = 0",
"0",
"ans",
"n = len(s)-1",
"len(s)-1",
"n",
"e = a[0]",
"a[0]",
"e",
"a = judge(li)",
"judge(li)",
"a",
"MAX = 10**18",
"10**18",
"MAX",
"def judge(li):\n c = s[0]\n for i in range(len(li)):\n if li[i] == False:\n c += s[i+1]\n else:\n c += \"+\" + s[i+1]\n return c",
"def judge(li):\n c = s[0]\n for i in range(len(li)):\n if li[i] == False:\n c += s[i+1]\n else:\n c += \"+\" + s[i+1]\n return c",
"judge",
"MOD = 998244353",
"998244353",
"MOD",
"sumli = []",
"[]",
"sumli",
"s = input()",
"input()",
"s"
] | import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
MAX = 10**18
MIN = -10**18
MOD = 998244353
def judge(li):
c = s[0]
for i in range(len(li)):
if li[i] == False:
c += s[i+1]
else:
c += "+" + s[i+1]
return c
s = input()
n = len(s)-1
ans = 0
for i in range(2**n):
li = [False]*(n)
for j in range(n):
if (i>>j)&1:
li[n-j-1] = True
a = judge(li)
e = a[0]
sumli = []
for j in range(1,len(a)):
if a[j] == "+":
sumli.append(int(e))
e = ""
else:
e += a[j]
sumli.append(int(e))
ans += sum(sumli)
print(ans) |
[
7,
12,
13,
27,
4,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
18,
13,
39,
2,
13,
17,
0,
13,
18,
13,
39,
2,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
13,
27,
2,
13,
13,
23,
13,
0,
13,
4,
13,
4,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
12,
13
] | [
[
47,
6
],
[
9,
8
],
[
47,
14
],
[
18,
17
],
[
47,
19
],
[
8,
22
],
[
26,
25
],
[
47,
27
],
[
8,
30
],
[
34,
33
],
[
17,
36
],
[
39,
38
],
[
25,
41
],
[
33,
44
],
[
38,
45
],
[
47,
47
],
[
60,
49
],
[
64,
57
],
[
61,
58
],
[
60,
61
]
] | [
"def gen(s):\n yield int(s)\n for i in range(len(s)-1):\n l = s[:i+1]\n r = s[i+1:]\n x = int(l)\n for y in gen(r):\n yield x + y\ns = input()\nprint(sum(gen(s)))",
"def gen(s):\n yield int(s)\n for i in range(len(s)-1):\n l = s[:i+1]\n r = s[i+1:]\n x = int(l)\n for y in gen(r):\n yield x + y",
"gen",
"yield int(s)",
"int(s)",
"int",
"s",
"for i in range(len(s)-1):\n l = s[:i+1]\n r = s[i+1:]\n x = int(l)\n for y in gen(r):\n yield x + y",
"i",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"l = s[:i+1]",
"l",
"s[:i+1]",
"s",
":i+1",
"i+1",
"i",
"1",
"r = s[i+1:]",
"r",
"s[i+1:]",
"s",
"i+1:",
"i+1",
"i",
"1",
"x = int(l)",
"x",
"int(l)",
"int",
"l",
"for y in gen(r):\n yield x + y",
"y",
"gen(r)",
"gen",
"r",
"yield x + y",
"x + y",
"x",
"y",
"s",
"s",
"s = input()",
"s",
"input()",
"input",
"print(sum(gen(s)))",
"print",
"sum(gen(s))",
"sum",
"gen(s)",
"gen",
"s",
"s = input()",
"input()",
"s",
"def gen(s):\n yield int(s)\n for i in range(len(s)-1):\n l = s[:i+1]\n r = s[i+1:]\n x = int(l)\n for y in gen(r):\n yield x + y",
"def gen(s):\n yield int(s)\n for i in range(len(s)-1):\n l = s[:i+1]\n r = s[i+1:]\n x = int(l)\n for y in gen(r):\n yield x + y",
"gen"
] | def gen(s):
yield int(s)
for i in range(len(s)-1):
l = s[:i+1]
r = s[i+1:]
x = int(l)
for y in gen(r):
yield x + y
s = input()
print(sum(gen(s))) |
[
7,
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,
2,
13,
13,
17,
0,
13,
2,
2,
13,
17,
18,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
13,
17,
0,
13,
4,
18,
13,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
18,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
108,
2
],
[
105,
6
],
[
10,
9
],
[
109,
17
],
[
96,
20
],
[
109,
22
],
[
90,
25
],
[
29,
28
],
[
109,
34
],
[
9,
39
],
[
28,
40
],
[
87,
43
],
[
97,
46
],
[
100,
46
],
[
88,
46
],
[
109,
49
],
[
28,
51
],
[
99,
54
],
[
97,
56
],
[
100,
56
],
[
88,
56
],
[
109,
58
],
[
28,
60
],
[
93,
63
],
[
100,
66
],
[
88,
66
],
[
97,
66
],
[
71,
70
],
[
94,
75
],
[
91,
75
],
[
102,
77
],
[
94,
81
],
[
91,
81
],
[
70,
82
],
[
103,
85
],
[
106,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
]
] | [
"S = input()\nans = 0\nfor i in range(2**(len(S)-1)):\n moji = S[0]\n tmp = 0\n for j in range(len(S)-1):\n if ((i >>j) & 1):\n moji = moji + '+' + S[j +1]\n else:\n moji = moji + S[j+1]\n tmp = moji.split('+')\n for k in range(len(tmp)):\n ans += int(tmp[k])\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(2**(len(S)-1)):\n moji = S[0]\n tmp = 0\n for j in range(len(S)-1):\n if ((i >>j) & 1):\n moji = moji + '+' + S[j +1]\n else:\n moji = moji + S[j+1]\n tmp = moji.split('+')\n for k in range(len(tmp)):\n ans += int(tmp[k])",
"i",
"range(2**(len(S)-1))",
"range",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"moji = S[0]",
"moji",
"S[0]",
"S",
"0",
"tmp = 0",
"tmp",
"0",
"for j in range(len(S)-1):\n if ((i >>j) & 1):\n moji = moji + '+' + S[j +1]\n else:\n moji = moji + S[j+1]\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if ((i >>j) & 1):\n moji = moji + '+' + S[j +1]\n else:\n moji = moji + S[j+1]\n ",
"(i >>j) & 1",
"i >>j",
"i",
"j",
"1",
"moji = moji + '+' + S[j +1]",
"moji",
"moji + '+' + S[j +1]",
"moji + '+'",
"moji",
"'+'",
"S[j +1]",
"S",
"j +1",
"j",
"1",
"moji = moji + S[j+1]",
"moji",
"moji + S[j+1]",
"moji",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"tmp = moji.split('+')",
"tmp",
"moji.split('+')",
"moji.split",
"moji",
"split",
"'+'",
"for k in range(len(tmp)):\n ans += int(tmp[k])",
"k",
"range(len(tmp))",
"range",
"len(tmp)",
"len",
"tmp",
"ans += int(tmp[k])",
"ans",
"int(tmp[k])",
"int",
"tmp[k]",
"tmp",
"k",
"print(ans)",
"print",
"ans",
"moji = moji + '+' + S[j +1]",
"moji + '+' + S[j +1]",
"moji",
"tmp = 0",
"0",
"tmp",
"tmp = moji.split('+')",
"moji.split('+')",
"tmp",
"moji = S[0]",
"S[0]",
"moji",
"moji = moji + S[j+1]",
"moji + S[j+1]",
"moji",
"ans += int(tmp[k])",
"int(tmp[k])",
"ans",
"ans = 0",
"0",
"ans",
"S = input()",
"input()",
"S"
] | S = input()
ans = 0
for i in range(2**(len(S)-1)):
moji = S[0]
tmp = 0
for j in range(len(S)-1):
if ((i >>j) & 1):
moji = moji + '+' + S[j +1]
else:
moji = moji + S[j+1]
tmp = moji.split('+')
for k in range(len(tmp)):
ans += int(tmp[k])
print(ans)
|
[
7,
0,
13,
4,
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,
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,
17,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13
] | [
[
80,
2
],
[
74,
6
],
[
10,
9
],
[
81,
17
],
[
71,
20
],
[
81,
22
],
[
26,
25
],
[
81,
31
],
[
9,
35
],
[
25,
38
],
[
65,
40
],
[
77,
43
],
[
81,
45
],
[
25,
47
],
[
68,
50
],
[
78,
58
],
[
66,
58
],
[
72,
58
],
[
69,
63
],
[
75,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
]
] | [
"S = input()\nanswer = 0\nfor bit in range(2 ** (len(S) - 1)):\n f = S[0]\n for i in range(len(S) - 1):\n if bit & (1 << i):\n f += '+'\n f += S[i + 1]\n answer += sum(map(int, f.split('+')))\nprint(answer)",
"S = input()",
"S",
"input()",
"input",
"answer = 0",
"answer",
"0",
"for bit in range(2 ** (len(S) - 1)):\n f = S[0]\n for i in range(len(S) - 1):\n if bit & (1 << i):\n f += '+'\n f += S[i + 1]\n answer += sum(map(int, f.split('+')))",
"bit",
"range(2 ** (len(S) - 1))",
"range",
"2 ** (len(S) - 1)",
"2",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"f = S[0]",
"f",
"S[0]",
"S",
"0",
"for i in range(len(S) - 1):\n if bit & (1 << i):\n f += '+'\n f += S[i + 1]\n ",
"i",
"range(len(S) - 1)",
"range",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"if bit & (1 << i):\n f += '+'\n ",
"bit & (1 << i)",
"bit",
"1 << i",
"1",
"i",
"f += '+'",
"f",
"'+'",
"f += S[i + 1]",
"f",
"S[i + 1]",
"S",
"i + 1",
"i",
"1",
"answer += sum(map(int, f.split('+')))",
"answer",
"sum(map(int, f.split('+')))",
"sum",
"map(int, f.split('+'))",
"map",
"int",
"f.split('+')",
"f.split",
"f",
"split",
"'+'",
"print(answer)",
"print",
"answer",
"f += '+'",
"'+'",
"f",
"answer += sum(map(int, f.split('+')))",
"sum(map(int, f.split('+')))",
"answer",
"f = S[0]",
"S[0]",
"f",
"answer = 0",
"0",
"answer",
"f += S[i + 1]",
"S[i + 1]",
"f",
"S = input()",
"input()",
"S"
] | S = input()
answer = 0
for bit in range(2 ** (len(S) - 1)):
f = S[0]
for i in range(len(S) - 1):
if bit & (1 << i):
f += '+'
f += S[i + 1]
answer += sum(map(int, f.split('+')))
print(answer)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
17,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
14,
2,
2,
2,
13,
13,
17,
17,
0,
18,
13,
13,
17,
28,
13,
4,
13,
13,
4,
18,
13,
13,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
103,
4
],
[
94,
10
],
[
112,
19
],
[
104,
23
],
[
109,
26
],
[
30,
29
],
[
113,
34
],
[
106,
36
],
[
104,
41
],
[
100,
43
],
[
113,
47
],
[
50,
49
],
[
113,
52
],
[
29,
57
],
[
49,
58
],
[
65,
62
],
[
101,
63
],
[
49,
64
],
[
68,
67
],
[
113,
70
],
[
107,
73
],
[
95,
76
],
[
67,
77
],
[
101,
79
],
[
67,
80
],
[
97,
82
],
[
107,
89
],
[
98,
92
],
[
110,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
]
] | [
"import copy\na=list(input())\nano=list(range(1,100,2))\nn=len(a)-1\nans=0\nfor i in range(2**n):\n c=copy.deepcopy(a)\n b=['']*n\n for j in range(n):\n if ((i>>j)&1)==1:\n b[j]='+'\n for k in range(n):\n c.insert(ano[k],b[k])\n ans+=eval(''.join(c))\nprint(ans)\n",
"import copy",
"copy",
"a=list(input())",
"a",
"list(input())",
"list",
"input()",
"input",
"ano=list(range(1,100,2))",
"ano",
"list(range(1,100,2))",
"list",
"range(1,100,2)",
"range",
"1",
"100",
"2",
"n=len(a)-1",
"n",
"len(a)-1",
"len(a)",
"len",
"a",
"1",
"ans=0",
"ans",
"0",
"for i in range(2**n):\n c=copy.deepcopy(a)\n b=['']*n\n for j in range(n):\n if ((i>>j)&1)==1:\n b[j]='+'\n for k in range(n):\n c.insert(ano[k],b[k])\n ans+=eval(''.join(c))",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"c=copy.deepcopy(a)",
"c",
"copy.deepcopy(a)",
"copy.deepcopy",
"copy",
"deepcopy",
"a",
"b=['']*n",
"b",
"['']*n",
"['']",
"''",
"n",
"for j in range(n):\n if ((i>>j)&1)==1:\n b[j]='+'\n ",
"j",
"range(n)",
"range",
"n",
"if ((i>>j)&1)==1:\n b[j]='+'\n ",
"((i>>j)&1)==1",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"1",
"b[j]='+'",
"b[j]",
"b",
"j",
"'+'",
"for k in range(n):\n c.insert(ano[k],b[k])\n ",
"k",
"range(n)",
"range",
"n",
"c.insert(ano[k],b[k])",
"c.insert",
"c",
"insert",
"ano[k]",
"ano",
"k",
"b[k]",
"b",
"k",
"ans+=eval(''.join(c))",
"ans",
"eval(''.join(c))",
"eval",
"''.join(c)",
"''.join",
"''",
"join",
"c",
"print(ans)",
"print",
"ans",
"ano=list(range(1,100,2))",
"list(range(1,100,2))",
"ano",
"ans+=eval(''.join(c))",
"eval(''.join(c))",
"ans",
"b=['']*n",
"['']*n",
"b",
"a=list(input())",
"list(input())",
"a",
"c=copy.deepcopy(a)",
"copy.deepcopy(a)",
"c",
"ans=0",
"0",
"ans",
"n=len(a)-1",
"len(a)-1",
"n"
] | import copy
a=list(input())
ano=list(range(1,100,2))
n=len(a)-1
ans=0
for i in range(2**n):
c=copy.deepcopy(a)
b=['']*n
for j in range(n):
if ((i>>j)&1)==1:
b[j]='+'
for k in range(n):
c.insert(ano[k],b[k])
ans+=eval(''.join(c))
print(ans)
|
[
7,
15,
13,
4,
18,
13,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
13,
12,
13,
0,
13,
17,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
28,
13,
4,
13,
2,
17,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
18,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
18,
13,
13,
14,
40,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
158,
9
],
[
164,
16
],
[
167,
28
],
[
165,
33
],
[
173,
35
],
[
165,
43
],
[
161,
46
],
[
174,
51
],
[
170,
53
],
[
165,
56
],
[
61,
60
],
[
64,
63
],
[
171,
65
],
[
68,
67
],
[
63,
71
],
[
75,
74
],
[
67,
79
],
[
83,
82
],
[
67,
85
],
[
90,
89
],
[
93,
92
],
[
67,
95
],
[
74,
99
],
[
92,
100
],
[
106,
103
],
[
89,
104
],
[
92,
105
],
[
109,
108
],
[
112,
111
],
[
63,
116
],
[
108,
119
],
[
63,
122
],
[
111,
123
],
[
111,
126
],
[
63,
130
],
[
108,
134
],
[
89,
137
],
[
111,
138
],
[
141,
140
],
[
108,
147
],
[
140,
150
],
[
60,
150
],
[
177,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
],
[
170,
171
],
[
173,
174
]
] | [
"import sys\n\nsys.setrecursionlimit(1000000)\nMOD = 10 ** 9 + 7\ninput = lambda: sys.stdin.readline().strip()\nNI = lambda: int(input())\nNMI = lambda: map(int, input().split())\nNLI = lambda: list(NMI())\nSI = lambda: input()\n\ndef main():\n ans = 0\n S = SI()\n bit_len = len(S)-1\n for i in range(2**bit_len):\n ls = [\"\" for _ in range(bit_len)]\n for j in range(bit_len):\n if (i >> j) & 1:\n ls[j] = \"+\"\n \n calc = []\n for n in range(len(S)):\n calc.append(S[n])\n if n != len(S)-1:\n calc.append(ls[n])\n ans += eval(\"\".join(calc))\n print(ans)\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"sys.setrecursionlimit(1000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"input = lambda: sys.stdin.readline().strip()",
"input",
"lambda: sys.stdin.readline().strip()",
"sys.stdin.readline().strip()",
"sys.stdin.readline().strip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"strip",
"NI = lambda: int(input())",
"NI",
"lambda: int(input())",
"int(input())",
"int",
"input()",
"input",
"NMI = lambda: map(int, input().split())",
"NMI",
"lambda: map(int, input().split())",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"NLI = lambda: list(NMI())",
"NLI",
"lambda: list(NMI())",
"list(NMI())",
"list",
"NMI()",
"NMI",
"SI = lambda: input()",
"SI",
"lambda: input()",
"input()",
"input",
"def main():\n ans = 0\n S = SI()\n bit_len = len(S)-1\n for i in range(2**bit_len):\n ls = [\"\" for _ in range(bit_len)]\n for j in range(bit_len):\n if (i >> j) & 1:\n ls[j] = \"+\"\n \n calc = []\n for n in range(len(S)):\n calc.append(S[n])\n if n != len(S)-1:\n calc.append(ls[n])\n ans += eval(\"\".join(calc))\n print(ans)",
"main",
"ans = 0",
"ans",
"0",
"S = SI()",
"S",
"SI()",
"SI",
"bit_len = len(S)-1",
"bit_len",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"for i in range(2**bit_len):\n ls = [\"\" for _ in range(bit_len)]\n for j in range(bit_len):\n if (i >> j) & 1:\n ls[j] = \"+\"\n \n calc = []\n for n in range(len(S)):\n calc.append(S[n])\n if n != len(S)-1:\n calc.append(ls[n])\n ans += eval(\"\".join(calc))\n ",
"i",
"range(2**bit_len)",
"range",
"2**bit_len",
"2",
"bit_len",
"\"\" for _ in range(bit_len)",
"for _ in range(bit_len)",
"_",
"range(bit_len)",
"range",
"bit_len",
"for _ in range(bit_len)",
"\"\"",
"ls = [\"\" for _ in range(bit_len)]",
"ls",
"[\"\" for _ in range(bit_len)]",
"for j in range(bit_len):\n if (i >> j) & 1:\n ls[j] = \"+\"\n \n ",
"j",
"range(bit_len)",
"range",
"bit_len",
"if (i >> j) & 1:\n ls[j] = \"+\"\n \n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"ls[j] = \"+\"",
"ls[j]",
"ls",
"j",
"\"+\"",
"calc = []",
"calc",
"[]",
"for n in range(len(S)):\n calc.append(S[n])\n if n != len(S)-1:\n calc.append(ls[n])\n ",
"n",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"calc.append(S[n])",
"calc.append",
"calc",
"append",
"S[n]",
"S",
"n",
"if n != len(S)-1:\n calc.append(ls[n])\n ",
"n != len(S)-1",
"n",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"calc.append(ls[n])",
"calc.append",
"calc",
"append",
"ls[n]",
"ls",
"n",
"ans += eval(\"\".join(calc))",
"ans",
"eval(\"\".join(calc))",
"eval",
"\"\".join(calc)",
"\"\".join",
"\"\"",
"join",
"calc",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"NLI = lambda: list(NMI())",
"lambda: list(NMI())",
"NLI",
"input = lambda: sys.stdin.readline().strip()",
"lambda: sys.stdin.readline().strip()",
"input",
"NI = lambda: int(input())",
"lambda: int(input())",
"NI",
"SI = lambda: input()",
"lambda: input()",
"SI",
"NMI = lambda: map(int, input().split())",
"lambda: map(int, input().split())",
"NMI",
"def main():\n ans = 0\n S = SI()\n bit_len = len(S)-1\n for i in range(2**bit_len):\n ls = [\"\" for _ in range(bit_len)]\n for j in range(bit_len):\n if (i >> j) & 1:\n ls[j] = \"+\"\n \n calc = []\n for n in range(len(S)):\n calc.append(S[n])\n if n != len(S)-1:\n calc.append(ls[n])\n ans += eval(\"\".join(calc))\n print(ans)",
"def main():\n ans = 0\n S = SI()\n bit_len = len(S)-1\n for i in range(2**bit_len):\n ls = [\"\" for _ in range(bit_len)]\n for j in range(bit_len):\n if (i >> j) & 1:\n ls[j] = \"+\"\n \n calc = []\n for n in range(len(S)):\n calc.append(S[n])\n if n != len(S)-1:\n calc.append(ls[n])\n ans += eval(\"\".join(calc))\n print(ans)",
"main"
] | import sys
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def main():
ans = 0
S = SI()
bit_len = len(S)-1
for i in range(2**bit_len):
ls = ["" for _ in range(bit_len)]
for j in range(bit_len):
if (i >> j) & 1:
ls[j] = "+"
calc = []
for n in range(len(S)):
calc.append(S[n])
if n != len(S)-1:
calc.append(ls[n])
ans += eval("".join(calc))
print(ans)
if __name__ == '__main__':
main() |
[
7,
17,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
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,
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,
29,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
6,
5
],
[
10,
9
],
[
5,
12
],
[
61,
17
],
[
9,
19
],
[
63,
29
],
[
61,
37
],
[
63,
40
],
[
5,
42
],
[
61,
44
],
[
61,
49
],
[
63,
53
],
[
5,
56
],
[
61,
58
],
[
61,
61
],
[
63,
63
],
[
14,
67
],
[
5,
70
],
[
81,
78
]
] | [
"\"\"\"\nDFS（深さ優先探索）\n\"\"\"\n\n\ndef main():\n S = input()\n N = len(S)\n\n def dfs(i, s):\n if i == N - 1:\n return sum(map(int, s.split('+')))\n return dfs(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])\n\n print(dfs(0, S[0]))\n return\n\n\nif __name__ == '__main__':\n main()\n\n\n\n",
"\"\"\"\nDFS（深さ優先探索）\n\"\"\"",
"def main():\n S = input()\n N = len(S)\n\n def dfs(i, s):\n if i == N - 1:\n return sum(map(int, s.split('+')))\n return dfs(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])\n\n print(dfs(0, S[0]))\n return",
"main",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"def dfs(i, s):\n if i == N - 1:\n return sum(map(int, s.split('+')))\n return dfs(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])\n\n ",
"dfs",
"if i == N - 1:\n return sum(map(int, s.split('+')))\n ",
"i == N - 1",
"i",
"N - 1",
"N",
"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(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])",
"dfs(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])",
"dfs(i + 1, s + S[i + 1])",
"dfs",
"i + 1",
"i",
"1",
"s + S[i + 1]",
"s",
"S[i + 1]",
"S",
"i + 1",
"i",
"1",
"dfs(i + 1, s + '+' + S[i + 1])",
"dfs",
"i + 1",
"i",
"1",
"s + '+' + S[i + 1]",
"s + '+'",
"s",
"'+'",
"S[i + 1]",
"S",
"i + 1",
"i",
"1",
"i",
"i",
"s",
"s",
"print(dfs(0, S[0]))",
"print",
"dfs(0, S[0])",
"dfs",
"0",
"S[0]",
"S",
"0",
"return",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n S = input()\n N = len(S)\n\n def dfs(i, s):\n if i == N - 1:\n return sum(map(int, s.split('+')))\n return dfs(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])\n\n print(dfs(0, S[0]))\n return",
"def main():\n S = input()\n N = len(S)\n\n def dfs(i, s):\n if i == N - 1:\n return sum(map(int, s.split('+')))\n return dfs(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])\n\n print(dfs(0, S[0]))\n return",
"main"
] | """
DFS（深さ優先探索）
"""
def main():
S = input()
N = len(S)
def dfs(i, s):
if i == N - 1:
return sum(map(int, s.split('+')))
return dfs(i + 1, s + S[i + 1]) + dfs(i + 1, s + '+' + S[i + 1])
print(dfs(0, S[0]))
return
if __name__ == '__main__':
main()
|
[
7,
15,
13,
12,
13,
12,
13,
4,
18,
13,
13,
2,
17,
17,
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,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
0,
13,
39,
4,
18,
13,
13,
18,
13,
2,
13,
17,
14,
13,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
95,
15
],
[
117,
19
],
[
110,
21
],
[
96,
24
],
[
98,
26
],
[
30,
29
],
[
111,
35
],
[
104,
38
],
[
96,
41
],
[
45,
44
],
[
111,
48
],
[
29,
53
],
[
44,
54
],
[
107,
57
],
[
105,
64
],
[
93,
64
],
[
92,
66
],
[
93,
70
],
[
105,
70
],
[
96,
73
],
[
44,
75
],
[
113,
80
],
[
93,
87
],
[
105,
87
],
[
114,
90
],
[
108,
90
],
[
99,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
]
] | [
"import sys\ndef input(): return sys.stdin.readline().strip()\ndef mapint(): return map(int, input().split())\nsys.setrecursionlimit(10**9)\n\nS = list(input())\nleng = len(S)\nans = 0\nfor i in range(1<<(leng-1)):\n lis = [S[0]]\n for j in range(leng-1):\n if (i>>j)&1:\n ans += int(''.join(lis))\n lis = []\n lis.append(S[j+1])\n else:\n if lis:\n ans += int(''.join(lis))\nprint(ans)",
"import sys",
"sys",
"def input(): return sys.stdin.readline().strip()",
"input",
"def mapint(): return map(int, input().split())",
"mapint",
"sys.setrecursionlimit(10**9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**9",
"10",
"9",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"leng = len(S)",
"leng",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for i in range(1<<(leng-1)):\n lis = [S[0]]\n for j in range(leng-1):\n if (i>>j)&1:\n ans += int(''.join(lis))\n lis = []\n lis.append(S[j+1])\n else:\n if lis:\n ans += int(''.join(lis))",
"i",
"range(1<<(leng-1))",
"range",
"1<<(leng-1)",
"1",
"leng-1",
"leng",
"1",
"lis = [S[0]]",
"lis",
"[S[0]]",
"S[0]",
"S",
"0",
"for j in range(leng-1):\n if (i>>j)&1:\n ans += int(''.join(lis))\n lis = []\n lis.append(S[j+1])\n else:\n if lis:\n ans += int(''.join(lis))",
"j",
"range(leng-1)",
"range",
"leng-1",
"leng",
"1",
"if (i>>j)&1:\n ans += int(''.join(lis))\n lis = []\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"ans += int(''.join(lis))",
"ans",
"int(''.join(lis))",
"int",
"''.join(lis)",
"''.join",
"''",
"join",
"lis",
"lis = []",
"lis",
"[]",
"lis.append(S[j+1])",
"lis.append",
"lis",
"append",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"if lis:\n ans += int(''.join(lis))",
"lis",
"ans += int(''.join(lis))",
"ans",
"int(''.join(lis))",
"int",
"''.join(lis)",
"''.join",
"''",
"join",
"lis",
"print(ans)",
"print",
"ans",
"lis = []",
"[]",
"lis",
"S = list(input())",
"list(input())",
"S",
"ans = 0",
"0",
"ans",
"def mapint(): return map(int, input().split())",
"def mapint(): return map(int, input().split())",
"mapint",
"lis = [S[0]]",
"[S[0]]",
"lis",
"ans += int(''.join(lis))",
"int(''.join(lis))",
"ans",
"leng = len(S)",
"len(S)",
"leng",
"ans += int(''.join(lis))",
"int(''.join(lis))",
"ans",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input"
] | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
S = list(input())
leng = len(S)
ans = 0
for i in range(1<<(leng-1)):
lis = [S[0]]
for j in range(leng-1):
if (i>>j)&1:
ans += int(''.join(lis))
lis = []
lis.append(S[j+1])
else:
if lis:
ans += int(''.join(lis))
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,
4,
13,
4,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
18,
13,
13,
14,
2,
18,
13,
40,
2,
13,
17,
17,
0,
13,
17,
0,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
4,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
93,
2
],
[
96,
6
],
[
94,
9
],
[
84,
11
],
[
15,
14
],
[
97,
20
],
[
90,
23
],
[
102,
26
],
[
14,
31
],
[
35,
34
],
[
97,
37
],
[
99,
39
],
[
94,
43
],
[
34,
44
],
[
103,
48
],
[
34,
51
],
[
87,
55
],
[
78,
58
],
[
88,
61
],
[
100,
61
],
[
91,
61
],
[
79,
61
],
[
81,
65
],
[
79,
73
],
[
88,
73
],
[
100,
73
],
[
91,
73
],
[
82,
76
],
[
85,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
]
] | [
"S = input()\n\nlength = len(S)\nans = 0\n\nfor x in range(2 ** (length - 1)):\n res = \"\"\n b = str(format(x, '010b'))\n for i in range(length):\n res += str(S[i])\n if b[-(i + 1)] == \"1\":\n res += \"+\"\n res = res.split(\"+\")\n ans += sum(list(map(int,res)))\n \nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"length = len(S)",
"length",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for x in range(2 ** (length - 1)):\n res = \"\"\n b = str(format(x, '010b'))\n for i in range(length):\n res += str(S[i])\n if b[-(i + 1)] == \"1\":\n res += \"+\"\n res = res.split(\"+\")\n ans += sum(list(map(int,res)))\n ",
"x",
"range(2 ** (length - 1))",
"range",
"2 ** (length - 1)",
"2",
"length - 1",
"length",
"1",
"res = \"\"",
"res",
"\"\"",
"b = str(format(x, '010b'))",
"b",
"str(format(x, '010b'))",
"str",
"format(x, '010b')",
"format",
"x",
"'010b'",
"for i in range(length):\n res += str(S[i])\n if b[-(i + 1)] == \"1\":\n res += \"+\"\n ",
"i",
"range(length)",
"range",
"length",
"res += str(S[i])",
"res",
"str(S[i])",
"str",
"S[i]",
"S",
"i",
"if b[-(i + 1)] == \"1\":\n res += \"+\"\n ",
"b[-(i + 1)] == \"1\"",
"b[-(i + 1)]",
"b",
"-(i + 1)",
"i + 1",
"i",
"1",
"\"1\"",
"res += \"+\"",
"res",
"\"+\"",
"res = res.split(\"+\")",
"res",
"res.split(\"+\")",
"res.split",
"res",
"split",
"\"+\"",
"ans += sum(list(map(int,res)))",
"ans",
"sum(list(map(int,res)))",
"sum",
"list(map(int,res))",
"list",
"map(int,res)",
"map",
"int",
"res",
"print(ans)",
"print",
"ans",
"res = res.split(\"+\")",
"res.split(\"+\")",
"res",
"ans += sum(list(map(int,res)))",
"sum(list(map(int,res)))",
"ans",
"ans = 0",
"0",
"ans",
"res += \"+\"",
"\"+\"",
"res",
"res = \"\"",
"\"\"",
"res",
"S = input()",
"input()",
"S",
"length = len(S)",
"len(S)",
"length",
"res += str(S[i])",
"str(S[i])",
"res",
"b = str(format(x, '010b'))",
"str(format(x, '010b'))",
"b"
] | S = input()
length = len(S)
ans = 0
for x in range(2 ** (length - 1)):
res = ""
b = str(format(x, '010b'))
for i in range(length):
res += str(S[i])
if b[-(i + 1)] == "1":
res += "+"
res = res.split("+")
ans += sum(list(map(int,res)))
print(ans) |
[
7,
15,
13,
41,
28,
13,
4,
13,
4,
13,
0,
13,
13,
0,
13,
39,
39,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
39,
13,
39,
28,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
39,
28,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
13,
4,
13,
18,
13,
13,
14,
2,
2,
13,
2,
4,
13,
13,
17,
2,
18,
13,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
17,
14,
40,
13,
17,
4,
18,
13,
13,
4,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
17,
13
] | [
[
6,
5
],
[
5,
9
],
[
148,
11
],
[
157,
14
],
[
19,
18
],
[
149,
24
],
[
163,
27
],
[
166,
29
],
[
33,
32
],
[
158,
32
],
[
155,
32
],
[
139,
35
],
[
32,
40
],
[
140,
43
],
[
164,
48
],
[
140,
50
],
[
160,
52
],
[
32,
57
],
[
161,
60
],
[
167,
65
],
[
161,
67
],
[
154,
69
],
[
164,
71
],
[
167,
72
],
[
145,
74
],
[
78,
77
],
[
155,
77
],
[
158,
77
],
[
142,
80
],
[
84,
83
],
[
149,
88
],
[
151,
90
],
[
143,
92
],
[
170,
92
],
[
152,
92
],
[
149,
96
],
[
83,
97
],
[
83,
101
],
[
149,
105
],
[
77,
109
],
[
83,
110
],
[
146,
114
],
[
152,
118
],
[
143,
118
],
[
170,
118
],
[
169,
120
],
[
170,
124
],
[
152,
124
],
[
143,
124
],
[
146,
128
],
[
170,
132
],
[
152,
132
],
[
143,
132
],
[
146,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
]
] | [
"import copy\nS = [c for c in input()]\n\nX = [[]]\nfor i in range(len(S) - 1):\n X0, X1 = [], []\n for x in X:\n x0 = copy.deepcopy(x)\n x0.append(0)\n X0.append(x0)\n x1 = copy.deepcopy(x)\n x1.append(1)\n X1.append(x1)\n X = X0 + X1\nY = []\nfor x in X:\n bf = ''\n for i in range(len(S)):\n bf = bf + str(S[i])\n if i == len(S) - 1 or x[i] == 1:\n Y.append(int(bf))\n bf = ''\n if bf != '':\n Y.append(int(bf))\nprint(sum(Y))",
"import copy",
"copy",
"c for c in input()",
"for c in input()",
"c",
"input()",
"input",
"for c in input()",
"c",
"S = [c for c in input()]",
"S",
"[c for c in input()]",
"X = [[]]",
"X",
"[[]]",
"[]",
"for i in range(len(S) - 1):\n X0, X1 = [], []\n for x in X:\n x0 = copy.deepcopy(x)\n x0.append(0)\n X0.append(x0)\n x1 = copy.deepcopy(x)\n x1.append(1)\n X1.append(x1)\n X = X0 + X1",
"i",
"range(len(S) - 1)",
"range",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"X0, X1 = [], []",
"X0",
"[]",
"X1",
"[]",
"for x in X:\n x0 = copy.deepcopy(x)\n x0.append(0)\n X0.append(x0)\n x1 = copy.deepcopy(x)\n x1.append(1)\n X1.append(x1)\n ",
"x",
"X",
"x0 = copy.deepcopy(x)",
"x0",
"copy.deepcopy(x)",
"copy.deepcopy",
"copy",
"deepcopy",
"x",
"x0.append(0)",
"x0.append",
"x0",
"append",
"0",
"X0.append(x0)",
"X0.append",
"X0",
"append",
"x0",
"x1 = copy.deepcopy(x)",
"x1",
"copy.deepcopy(x)",
"copy.deepcopy",
"copy",
"deepcopy",
"x",
"x1.append(1)",
"x1.append",
"x1",
"append",
"1",
"X1.append(x1)",
"X1.append",
"X1",
"append",
"x1",
"X = X0 + X1",
"X",
"X0 + X1",
"X0",
"X1",
"Y = []",
"Y",
"[]",
"for x in X:\n bf = ''\n for i in range(len(S)):\n bf = bf + str(S[i])\n if i == len(S) - 1 or x[i] == 1:\n Y.append(int(bf))\n bf = ''\n if bf != '':\n Y.append(int(bf))",
"x",
"X",
"bf = ''",
"bf",
"''",
"for i in range(len(S)):\n bf = bf + str(S[i])\n if i == len(S) - 1 or x[i] == 1:\n Y.append(int(bf))\n bf = ''\n ",
"i",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"bf = bf + str(S[i])",
"bf",
"bf + str(S[i])",
"bf",
"str(S[i])",
"str",
"S[i]",
"S",
"i",
"if i == len(S) - 1 or x[i] == 1:\n Y.append(int(bf))\n bf = ''\n ",
"i == len(S) - 1 or x[i] == 1",
"i == len(S) - 1",
"i",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"x[i] == 1",
"x[i]",
"x",
"i",
"1",
"Y.append(int(bf))",
"Y.append",
"Y",
"append",
"int(bf)",
"int",
"bf",
"bf = ''",
"bf",
"''",
"if bf != '':\n Y.append(int(bf))",
"bf != ''",
"bf",
"''",
"Y.append(int(bf))",
"Y.append",
"Y",
"append",
"int(bf)",
"int",
"bf",
"print(sum(Y))",
"print",
"sum(Y)",
"sum",
"Y",
"x0 = copy.deepcopy(x)",
"copy.deepcopy(x)",
"x0",
"bf = ''",
"''",
"bf",
"Y = []",
"[]",
"Y",
"S = [c for c in input()]",
"[c for c in input()]",
"S",
"bf = bf + str(S[i])",
"bf + str(S[i])",
"bf",
"X = X0 + X1",
"X0 + X1",
"X",
"X = [[]]",
"[[]]",
"X",
"x1 = copy.deepcopy(x)",
"copy.deepcopy(x)",
"x1",
"X0, X1 = [], []",
"[]",
"X0",
"X1 = [], []",
"[]",
"X1",
"bf = ''",
"''",
"bf"
] | import copy
S = [c for c in input()]
X = [[]]
for i in range(len(S) - 1):
X0, X1 = [], []
for x in X:
x0 = copy.deepcopy(x)
x0.append(0)
X0.append(x0)
x1 = copy.deepcopy(x)
x1.append(1)
X1.append(x1)
X = X0 + X1
Y = []
for x in X:
bf = ''
for i in range(len(S)):
bf = bf + str(S[i])
if i == len(S) - 1 or x[i] == 1:
Y.append(int(bf))
bf = ''
if bf != '':
Y.append(int(bf))
print(sum(Y))
|
[
7,
0,
13,
4,
13,
12,
13,
0,
13,
17,
42,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
4,
13,
13,
0,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
17,
13,
0,
13,
4,
18,
17,
13,
4,
13,
13,
0,
13,
4,
13,
13,
17,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
4,
18,
13,
13,
17,
13,
41,
28,
13,
13,
40,
13,
17,
4,
13,
0,
13,
4,
13,
4,
13,
13,
28,
13,
13,
0,
13,
2,
2,
18,
13,
39,
2,
2,
17,
13,
17,
17,
18,
13,
39,
2,
17,
2,
13,
17,
0,
13,
4,
18,
13,
13,
17,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
160,
2
],
[
9,
8
],
[
30,
12
],
[
25,
12
],
[
16,
15
],
[
30,
17
],
[
25,
17
],
[
32,
18
],
[
21,
20
],
[
15,
23
],
[
26,
25
],
[
32,
26
],
[
20,
28
],
[
8,
28
],
[
30,
30
],
[
32,
32
],
[
172,
34
],
[
161,
38
],
[
178,
41
],
[
161,
44
],
[
47,
46
],
[
173,
52
],
[
163,
54
],
[
161,
61
],
[
187,
63
],
[
158,
65
],
[
46,
66
],
[
188,
66
],
[
181,
69
],
[
73,
72
],
[
188,
77
],
[
46,
77
],
[
182,
80
],
[
170,
80
],
[
188,
84
],
[
46,
84
],
[
72,
87
],
[
91,
90
],
[
182,
90
],
[
170,
90
],
[
90,
93
],
[
90,
96
],
[
169,
98
],
[
106,
105
],
[
170,
105
],
[
182,
105
],
[
175,
108
],
[
164,
112
],
[
176,
112
],
[
185,
112
],
[
105,
117
],
[
164,
121
],
[
176,
121
],
[
185,
121
],
[
105,
126
],
[
184,
129
],
[
176,
132
],
[
164,
132
],
[
185,
132
],
[
166,
137
],
[
185,
145
],
[
176,
145
],
[
164,
145
],
[
190,
149
],
[
167,
152
],
[
191,
155
],
[
179,
155
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
],
[
181,
182
],
[
184,
185
],
[
187,
188
],
[
190,
191
]
] | [
"s0 = input()\ndef convert(n, m):\n ans = \"\"\n while n > 0:\n amari = n % m\n ans += str(amari)\n n //= m\n return ans\nn = len(s0) - 1\nSUM = int(s0)\nfor i in range(1, 2**n):\n s1 = \" \".join(list(s0))\n i = convert(i, 2)\n list_index = []\n for j in range(len(i)):\n list_index.append(i.find(\"1\", j))\n list_index = list(set([x for x in list_index if x != -1]))\n for k in list_index:\n s1 = s1[:2*k+1] + \"+\" + s1[2*(k+1):]\n s1 = s1.replace(\" \", \"\")\n sum_list = list(map(int, s1.split(\"+\")))\n SUM += sum(sum_list)\nprint(SUM)",
"s0 = input()",
"s0",
"input()",
"input",
"def convert(n, m):\n ans = \"\"\n while n > 0:\n amari = n % m\n ans += str(amari)\n n //= m\n return ans",
"convert",
"ans = \"\"",
"ans",
"\"\"",
"while n > 0:\n amari = n % m\n ans += str(amari)\n n //= m\n ",
"n > 0",
"n",
"0",
"amari = n % m",
"amari",
"n % m",
"n",
"m",
"ans += str(amari)",
"ans",
"str(amari)",
"str",
"amari",
"n //= m",
"n",
"m",
"return ans",
"ans",
"n",
"n",
"m",
"m",
"n = len(s0) - 1",
"n",
"len(s0) - 1",
"len(s0)",
"len",
"s0",
"1",
"SUM = int(s0)",
"SUM",
"int(s0)",
"int",
"s0",
"for i in range(1, 2**n):\n s1 = \" \".join(list(s0))\n i = convert(i, 2)\n list_index = []\n for j in range(len(i)):\n list_index.append(i.find(\"1\", j))\n list_index = list(set([x for x in list_index if x != -1]))\n for k in list_index:\n s1 = s1[:2*k+1] + \"+\" + s1[2*(k+1):]\n s1 = s1.replace(\" \", \"\")\n sum_list = list(map(int, s1.split(\"+\")))\n SUM += sum(sum_list)",
"i",
"range(1, 2**n)",
"range",
"1",
"2**n",
"2",
"n",
"s1 = \" \".join(list(s0))",
"s1",
"\" \".join(list(s0))",
"\" \".join",
"\" \"",
"join",
"list(s0)",
"list",
"s0",
"i = convert(i, 2)",
"i",
"convert(i, 2)",
"convert",
"i",
"2",
"list_index = []",
"list_index",
"[]",
"for j in range(len(i)):\n list_index.append(i.find(\"1\", j))\n ",
"j",
"range(len(i))",
"range",
"len(i)",
"len",
"i",
"list_index.append(i.find(\"1\", j))",
"list_index.append",
"list_index",
"append",
"i.find(\"1\", j)",
"i.find",
"i",
"find",
"\"1\"",
"j",
"x for x in list_index if x != -1",
"for x in list_index if x != -1",
"x",
"list_index",
"x != -1",
"x",
"-1",
"if x != -1",
"x",
"list_index = list(set([x for x in list_index if x != -1]))",
"list_index",
"list(set([x for x in list_index if x != -1]))",
"list",
"set([x for x in list_index if x != -1])",
"set",
"[x for x in list_index if x != -1]",
"for k in list_index:\n s1 = s1[:2*k+1] + \"+\" + s1[2*(k+1):]\n ",
"k",
"list_index",
"s1 = s1[:2*k+1] + \"+\" + s1[2*(k+1):]",
"s1",
"s1[:2*k+1] + \"+\" + s1[2*(k+1):]",
"s1[:2*k+1] + \"+\"",
"s1[:2*k+1]",
"s1",
":2*k+1",
"2*k+1",
"2*k",
"2",
"k",
"1",
"\"+\"",
"s1[2*(k+1):]",
"s1",
"2*(k+1):",
"2*(k+1)",
"2",
"k+1",
"k",
"1",
"s1 = s1.replace(\" \", \"\")",
"s1",
"s1.replace(\" \", \"\")",
"s1.replace",
"s1",
"replace",
"\" \"",
"\"\"",
"sum_list = list(map(int, s1.split(\"+\")))",
"sum_list",
"list(map(int, s1.split(\"+\")))",
"list",
"map(int, s1.split(\"+\"))",
"map",
"int",
"s1.split(\"+\")",
"s1.split",
"s1",
"split",
"\"+\"",
"SUM += sum(sum_list)",
"SUM",
"sum(sum_list)",
"sum",
"sum_list",
"print(SUM)",
"print",
"SUM",
"def convert(n, m):\n ans = \"\"\n while n > 0:\n amari = n % m\n ans += str(amari)\n n //= m\n return ans",
"def convert(n, m):\n ans = \"\"\n while n > 0:\n amari = n % m\n ans += str(amari)\n n //= m\n return ans",
"convert",
"s0 = input()",
"input()",
"s0",
"s1 = \" \".join(list(s0))",
"\" \".join(list(s0))",
"s1",
"sum_list = list(map(int, s1.split(\"+\")))",
"list(map(int, s1.split(\"+\")))",
"sum_list",
"list_index = list(set([x for x in list_index if x != -1]))",
"list(set([x for x in list_index if x != -1]))",
"list_index",
"n = len(s0) - 1",
"len(s0) - 1",
"n",
"s1 = s1[:2*k+1] + \"+\" + s1[2*(k+1):]",
"s1[:2*k+1] + \"+\" + s1[2*(k+1):]",
"s1",
"SUM = int(s0)",
"int(s0)",
"SUM",
"list_index = []",
"[]",
"list_index",
"s1 = s1.replace(\" \", \"\")",
"s1.replace(\" \", \"\")",
"s1",
"i = convert(i, 2)",
"convert(i, 2)",
"i",
"SUM += sum(sum_list)",
"sum(sum_list)",
"SUM"
] | s0 = input()
def convert(n, m):
ans = ""
while n > 0:
amari = n % m
ans += str(amari)
n //= m
return ans
n = len(s0) - 1
SUM = int(s0)
for i in range(1, 2**n):
s1 = " ".join(list(s0))
i = convert(i, 2)
list_index = []
for j in range(len(i)):
list_index.append(i.find("1", j))
list_index = list(set([x for x in list_index if x != -1]))
for k in list_index:
s1 = s1[:2*k+1] + "+" + s1[2*(k+1):]
s1 = s1.replace(" ", "")
sum_list = list(map(int, s1.split("+")))
SUM += sum(sum_list)
print(SUM) |
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
4,
13,
13,
17,
0,
13,
18,
13,
39,
17,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
39,
0,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
39,
18,
13,
17,
28,
13,
13,
4,
13,
18,
13,
13,
14,
2,
13,
17,
4,
18,
13,
13,
2,
2,
13,
17,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
17,
0,
18,
13,
17,
13,
0,
13,
4,
13,
18,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
39,
13
] | [
[
143,
4
],
[
140,
10
],
[
144,
13
],
[
158,
15
],
[
19,
18
],
[
141,
24
],
[
128,
27
],
[
18,
30
],
[
146,
33
],
[
129,
35
],
[
147,
35
],
[
159,
40
],
[
147,
42
],
[
129,
42
],
[
152,
44
],
[
48,
47
],
[
141,
53
],
[
137,
56
],
[
149,
59
],
[
144,
64
],
[
155,
66
],
[
134,
69
],
[
144,
72
],
[
159,
80
],
[
47,
81
],
[
150,
88
],
[
138,
88
],
[
156,
94
],
[
126,
94
],
[
125,
97
],
[
150,
104
],
[
138,
104
],
[
113,
110
],
[
135,
111
],
[
47,
113
],
[
131,
115
],
[
135,
119
],
[
132,
123
],
[
153,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
],
[
149,
150
],
[
152,
153
],
[
155,
156
],
[
158,
159
]
] | [
"import copy\na = list(input())\nN=len(a)\nbit_list =[]\nfor i in range(2**(N-1)):\n b = format(i,\"09b\")\n b = b[::-1]\n bit_list.append(b)\ncount = 0\nfor i in range(2**(N-1)):\n a_list = []\n a_list=copy.copy(a)\n num = 0\n num_li =[a[0]]\n for k,j in enumerate(bit_list[i]):\n if j == '1':\n a_list.insert(k+1+num,\"+\")\n num+=1\n for j,i in enumerate(a_list):\n if j>0:\n num_li[0] +=i\n count+= eval(num_li[0])\nprint(count)",
"import copy",
"copy",
"a = list(input())",
"a",
"list(input())",
"list",
"input()",
"input",
"N=len(a)",
"N",
"len(a)",
"len",
"a",
"bit_list =[]",
"bit_list",
"[]",
"for i in range(2**(N-1)):\n b = format(i,\"09b\")\n b = b[::-1]\n bit_list.append(b)",
"i",
"range(2**(N-1))",
"range",
"2**(N-1)",
"2",
"N-1",
"N",
"1",
"b = format(i,\"09b\")",
"b",
"format(i,\"09b\")",
"format",
"i",
"\"09b\"",
"b = b[::-1]",
"b",
"b[::-1]",
"b",
"::-1",
"-1",
"bit_list.append(b)",
"bit_list.append",
"bit_list",
"append",
"b",
"count = 0",
"count",
"0",
"for i in range(2**(N-1)):\n a_list = []\n a_list=copy.copy(a)\n num = 0\n num_li =[a[0]]\n for k,j in enumerate(bit_list[i]):\n if j == '1':\n a_list.insert(k+1+num,\"+\")\n num+=1\n for j,i in enumerate(a_list):\n if j>0:\n num_li[0] +=i\n count+= eval(num_li[0])",
"i",
"range(2**(N-1))",
"range",
"2**(N-1)",
"2",
"N-1",
"N",
"1",
"a_list = []",
"a_list",
"[]",
"a_list=copy.copy(a)",
"a_list",
"copy.copy(a)",
"copy.copy",
"copy",
"copy",
"a",
"num = 0",
"num",
"0",
"num_li =[a[0]]",
"num_li",
"[a[0]]",
"a[0]",
"a",
"0",
"for k,j in enumerate(bit_list[i]):\n if j == '1':\n a_list.insert(k+1+num,\"+\")\n num+=1\n ",
"k",
"j",
"enumerate(bit_list[i])",
"enumerate",
"bit_list[i]",
"bit_list",
"i",
"if j == '1':\n a_list.insert(k+1+num,\"+\")\n num+=1\n ",
"j == '1'",
"j",
"'1'",
"a_list.insert(k+1+num,\"+\")",
"a_list.insert",
"a_list",
"insert",
"k+1+num",
"k+1",
"k",
"1",
"num",
"\"+\"",
"num+=1",
"num",
"1",
"for j,i in enumerate(a_list):\n if j>0:\n num_li[0] +=i\n ",
"j",
"i",
"enumerate(a_list)",
"enumerate",
"a_list",
"if j>0:\n num_li[0] +=i\n ",
"j>0",
"j",
"0",
"num_li[0] +=i",
"num_li[0]",
"num_li",
"0",
"i",
"count+= eval(num_li[0])",
"count",
"eval(num_li[0])",
"eval",
"num_li[0]",
"num_li",
"0",
"print(count)",
"print",
"count",
"num+=1",
"1",
"num",
"b = format(i,\"09b\")",
"format(i,\"09b\")",
"b",
"count+= eval(num_li[0])",
"eval(num_li[0])",
"count",
"num_li =[a[0]]",
"[a[0]]",
"num_li",
"a_list = []",
"[]",
"a_list",
"N=len(a)",
"len(a)",
"N",
"a = list(input())",
"list(input())",
"a",
"b = b[::-1]",
"b[::-1]",
"b",
"a_list=copy.copy(a)",
"copy.copy(a)",
"a_list",
"count = 0",
"0",
"count",
"num = 0",
"0",
"num",
"bit_list =[]",
"[]",
"bit_list"
] | import copy
a = list(input())
N=len(a)
bit_list =[]
for i in range(2**(N-1)):
b = format(i,"09b")
b = b[::-1]
bit_list.append(b)
count = 0
for i in range(2**(N-1)):
a_list = []
a_list=copy.copy(a)
num = 0
num_li =[a[0]]
for k,j in enumerate(bit_list[i]):
if j == '1':
a_list.insert(k+1+num,"+")
num+=1
for j,i in enumerate(a_list):
if j>0:
num_li[0] +=i
count+= eval(num_li[0])
print(count) |
[
7,
12,
13,
14,
2,
13,
39,
29,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
18,
13,
13,
14,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
17,
18,
13,
13,
9,
0,
13,
4,
13,
18,
13,
39,
18,
13,
2,
13,
17,
18,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
4,
13,
18,
13,
2,
2,
4,
13,
13,
17,
13,
2,
17,
13,
29,
13,
23,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
39,
14,
2,
2,
13,
17,
2,
13,
2,
17,
13,
9,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13
] | [
[
75,
5
],
[
73,
10
],
[
13,
12
],
[
16,
15
],
[
75,
20
],
[
15,
23
],
[
75,
27
],
[
31,
30
],
[
73,
34
],
[
75,
37
],
[
15,
38
],
[
15,
41
],
[
45,
44
],
[
73,
48
],
[
75,
52
],
[
15,
53
],
[
57,
56
],
[
73,
60
],
[
75,
63
],
[
15,
65
],
[
75,
68
],
[
15,
69
],
[
56,
71
],
[
44,
71
],
[
30,
71
],
[
12,
71
],
[
73,
73
],
[
75,
75
],
[
80,
79
],
[
83,
82
],
[
108,
87
],
[
90,
89
],
[
108,
94
],
[
108,
99
],
[
82,
101
],
[
82,
104
],
[
89,
106
],
[
79,
106
],
[
108,
108
],
[
171,
110
],
[
180,
114
],
[
172,
117
],
[
183,
119
],
[
123,
122
],
[
181,
127
],
[
174,
129
],
[
122,
134
],
[
122,
137
],
[
181,
140
],
[
144,
143
],
[
181,
146
],
[
122,
149
],
[
143,
152
],
[
175,
155
],
[
143,
157
],
[
168,
159
],
[
178,
161
],
[
172,
162
],
[
175,
163
],
[
169,
166
],
[
184,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
180,
181
],
[
183,
184
]
] | [
"def separate_and_calc(S,plus_list):\n if plus_list == []:\n return array_to_num(S)\n \n result = 0\n for i in range(len(plus_list)):\n if i == len(plus_list)-1:\n result += array_to_num(S[plus_list[i]:])\n if i == 0:\n result += array_to_num(S[0:plus_list[i]])\n continue\n result += array_to_num(S[plus_list[i-1]:plus_list[i]])\n\n return result\n\ndef array_to_num(S):\n result = 0\n for i in range(len(S)):\n result += int(S[len(S) -1 - i]) * (10**(i))\n return result\n\nS = input()\nN = len(S)\nresult = 0\nfor bit in range(2**N):\n plus_list = []\n if bit & 1 or bit & (1<<N):\n continue\n\n for i in range(N):\n if (bit & (1<<i)):\n plus_list.append(i)\n \n result += separate_and_calc(S,plus_list)\n \n # print(\" }\")\nprint(result)",
"def separate_and_calc(S,plus_list):\n if plus_list == []:\n return array_to_num(S)\n \n result = 0\n for i in range(len(plus_list)):\n if i == len(plus_list)-1:\n result += array_to_num(S[plus_list[i]:])\n if i == 0:\n result += array_to_num(S[0:plus_list[i]])\n continue\n result += array_to_num(S[plus_list[i-1]:plus_list[i]])\n\n return result",
"separate_and_calc",
"if plus_list == []:\n return array_to_num(S)\n \n ",
"plus_list == []",
"plus_list",
"[]",
"return array_to_num(S)",
"array_to_num(S)",
"array_to_num",
"S",
"result = 0",
"result",
"0",
"for i in range(len(plus_list)):\n if i == len(plus_list)-1:\n result += array_to_num(S[plus_list[i]:])\n if i == 0:\n result += array_to_num(S[0:plus_list[i]])\n continue\n result += array_to_num(S[plus_list[i-1]:plus_list[i]])\n\n ",
"i",
"range(len(plus_list))",
"range",
"len(plus_list)",
"len",
"plus_list",
"if i == len(plus_list)-1:\n result += array_to_num(S[plus_list[i]:])\n ",
"i == len(plus_list)-1",
"i",
"len(plus_list)-1",
"len(plus_list)",
"len",
"plus_list",
"1",
"result += array_to_num(S[plus_list[i]:])",
"result",
"array_to_num(S[plus_list[i]:])",
"array_to_num",
"S[plus_list[i]:]",
"S",
"plus_list[i]:",
"plus_list[i]",
"plus_list",
"i",
"if i == 0:\n result += array_to_num(S[0:plus_list[i]])\n continue\n ",
"i == 0",
"i",
"0",
"result += array_to_num(S[0:plus_list[i]])",
"result",
"array_to_num(S[0:plus_list[i]])",
"array_to_num",
"S[0:plus_list[i]]",
"S",
"0:plus_list[i]",
"0",
"plus_list[i]",
"plus_list",
"i",
"continue",
"result += array_to_num(S[plus_list[i-1]:plus_list[i]])",
"result",
"array_to_num(S[plus_list[i-1]:plus_list[i]])",
"array_to_num",
"S[plus_list[i-1]:plus_list[i]]",
"S",
"plus_list[i-1]:plus_list[i]",
"plus_list[i-1]",
"plus_list",
"i-1",
"i",
"1",
"plus_list[i]",
"plus_list",
"i",
"return result",
"result",
"S",
"S",
"plus_list",
"plus_list",
"def array_to_num(S):\n result = 0\n for i in range(len(S)):\n result += int(S[len(S) -1 - i]) * (10**(i))\n return result",
"array_to_num",
"result = 0",
"result",
"0",
"for i in range(len(S)):\n result += int(S[len(S) -1 - i]) * (10**(i))\n ",
"i",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"result += int(S[len(S) -1 - i]) * (10**(i))",
"result",
"int(S[len(S) -1 - i]) * (10**(i))",
"int(S[len(S) -1 - i])",
"int",
"S[len(S) -1 - i]",
"S",
"len(S) -1 - i",
"len(S) -1",
"len(S)",
"len",
"S",
"1",
"i",
"10**(i)",
"10",
"i",
"return result",
"result",
"S",
"S",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"result = 0",
"result",
"0",
"for bit in range(2**N):\n plus_list = []\n if bit & 1 or bit & (1<<N):\n continue\n\n for i in range(N):\n if (bit & (1<<i)):\n plus_list.append(i)\n \n result += separate_and_calc(S,plus_list)\n \n # print(\" }\")",
"bit",
"range(2**N)",
"range",
"2**N",
"2",
"N",
"plus_list = []",
"plus_list",
"[]",
"if bit & 1 or bit & (1<<N):\n continue\n\n ",
"bit & 1 or bit & (1<<N)",
"bit & 1",
"bit",
"1",
"bit & (1<<N)",
"bit",
"1<<N",
"1",
"N",
"continue",
"for i in range(N):\n if (bit & (1<<i)):\n plus_list.append(i)\n \n ",
"i",
"range(N)",
"range",
"N",
"if (bit & (1<<i)):\n plus_list.append(i)\n \n ",
"bit & (1<<i)",
"bit",
"1<<i",
"1",
"i",
"plus_list.append(i)",
"plus_list.append",
"plus_list",
"append",
"i",
"result += separate_and_calc(S,plus_list)",
"result",
"separate_and_calc(S,plus_list)",
"separate_and_calc",
"S",
"plus_list",
"print(result)",
"print",
"result",
"result += separate_and_calc(S,plus_list)",
"separate_and_calc(S,plus_list)",
"result",
"S = input()",
"input()",
"S",
"plus_list = []",
"[]",
"plus_list",
"def separate_and_calc(S,plus_list):\n if plus_list == []:\n return array_to_num(S)\n \n result = 0\n for i in range(len(plus_list)):\n if i == len(plus_list)-1:\n result += array_to_num(S[plus_list[i]:])\n if i == 0:\n result += array_to_num(S[0:plus_list[i]])\n continue\n result += array_to_num(S[plus_list[i-1]:plus_list[i]])\n\n return result",
"def separate_and_calc(S,plus_list):\n if plus_list == []:\n return array_to_num(S)\n \n result = 0\n for i in range(len(plus_list)):\n if i == len(plus_list)-1:\n result += array_to_num(S[plus_list[i]:])\n if i == 0:\n result += array_to_num(S[0:plus_list[i]])\n continue\n result += array_to_num(S[plus_list[i-1]:plus_list[i]])\n\n return result",
"separate_and_calc",
"N = len(S)",
"len(S)",
"N",
"result = 0",
"0",
"result",
"def array_to_num(S):\n result = 0\n for i in range(len(S)):\n result += int(S[len(S) -1 - i]) * (10**(i))\n return result",
"def array_to_num(S):\n result = 0\n for i in range(len(S)):\n result += int(S[len(S) -1 - i]) * (10**(i))\n return result",
"array_to_num"
] | def separate_and_calc(S,plus_list):
if plus_list == []:
return array_to_num(S)
result = 0
for i in range(len(plus_list)):
if i == len(plus_list)-1:
result += array_to_num(S[plus_list[i]:])
if i == 0:
result += array_to_num(S[0:plus_list[i]])
continue
result += array_to_num(S[plus_list[i-1]:plus_list[i]])
return result
def array_to_num(S):
result = 0
for i in range(len(S)):
result += int(S[len(S) -1 - i]) * (10**(i))
return result
S = input()
N = len(S)
result = 0
for bit in range(2**N):
plus_list = []
if bit & 1 or bit & (1<<N):
continue
for i in range(N):
if (bit & (1<<i)):
plus_list.append(i)
result += separate_and_calc(S,plus_list)
# print(" }")
print(result) |
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
18,
13,
17,
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,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
18,
13,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
4,
10
],
[
14,
13
],
[
4,
17
],
[
21,
20
],
[
24,
23
],
[
13,
28
],
[
31,
30
],
[
13,
34
],
[
37,
36
],
[
13,
39
],
[
23,
43
],
[
36,
44
],
[
50,
47
],
[
30,
48
],
[
36,
49
],
[
53,
52
],
[
56,
55
],
[
4,
57
],
[
36,
59
],
[
63,
62
],
[
55,
70
],
[
52,
70
],
[
8,
70
],
[
74,
70
],
[
75,
74
],
[
4,
76
],
[
62,
80
],
[
20,
80
],
[
89,
86
]
] | [
"def main():\n s = input()\n f = s[0]\n n = len(s) - 1\n ans = 0\n \n for i in range(2 ** (n)):\n res = [0] * (n)\n for j in range(n):\n if (i >> j) & 1:\n res[j] = 1\n f += '+'\n f += s[j+1]\n ans += sum(map(int, f.split(\"+\")))\n # print(f)\n # print('b', res)\n f = s[0]\n print(ans)\n\nif __name__ == '__main__':\n main()",
"def main():\n s = input()\n f = s[0]\n n = len(s) - 1\n ans = 0\n \n for i in range(2 ** (n)):\n res = [0] * (n)\n for j in range(n):\n if (i >> j) & 1:\n res[j] = 1\n f += '+'\n f += s[j+1]\n ans += sum(map(int, f.split(\"+\")))\n # print(f)\n # print('b', res)\n f = s[0]\n print(ans)",
"main",
"s = input()",
"s",
"input()",
"input",
"f = s[0]",
"f",
"s[0]",
"s",
"0",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (n)):\n res = [0] * (n)\n for j in range(n):\n if (i >> j) & 1:\n res[j] = 1\n f += '+'\n f += s[j+1]\n ans += sum(map(int, f.split(\"+\")))\n # print(f)\n # print('b', res)\n f = s[0]\n ",
"i",
"range(2 ** (n))",
"range",
"2 ** (n)",
"2",
"n",
"res = [0] * (n)",
"res",
"[0] * (n)",
"[0]",
"0",
"n",
"for j in range(n):\n if (i >> j) & 1:\n res[j] = 1\n f += '+'\n f += s[j+1]\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1:\n res[j] = 1\n f += '+'\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"res[j] = 1",
"res[j]",
"res",
"j",
"1",
"f += '+'",
"f",
"'+'",
"f += s[j+1]",
"f",
"s[j+1]",
"s",
"j+1",
"j",
"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",
"\"+\"",
"f = s[0]",
"f",
"s[0]",
"s",
"0",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n s = input()\n f = s[0]\n n = len(s) - 1\n ans = 0\n \n for i in range(2 ** (n)):\n res = [0] * (n)\n for j in range(n):\n if (i >> j) & 1:\n res[j] = 1\n f += '+'\n f += s[j+1]\n ans += sum(map(int, f.split(\"+\")))\n # print(f)\n # print('b', res)\n f = s[0]\n print(ans)",
"def main():\n s = input()\n f = s[0]\n n = len(s) - 1\n ans = 0\n \n for i in range(2 ** (n)):\n res = [0] * (n)\n for j in range(n):\n if (i >> j) & 1:\n res[j] = 1\n f += '+'\n f += s[j+1]\n ans += sum(map(int, f.split(\"+\")))\n # print(f)\n # print('b', res)\n f = s[0]\n print(ans)",
"main"
] | def main():
s = input()
f = s[0]
n = len(s) - 1
ans = 0
for i in range(2 ** (n)):
res = [0] * (n)
for j in range(n):
if (i >> j) & 1:
res[j] = 1
f += '+'
f += s[j+1]
ans += sum(map(int, f.split("+")))
# print(f)
# print('b', res)
f = s[0]
print(ans)
if __name__ == '__main__':
main() |
[
7,
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,
13,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
4,
13,
18,
13,
13,
2,
17,
13,
2,
17,
2,
13,
4,
13,
17,
2,
2,
2,
13,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
73,
2
],
[
76,
8
],
[
74,
13
],
[
64,
15
],
[
77,
18
],
[
67,
20
],
[
24,
23
],
[
65,
26
],
[
29,
28
],
[
65,
32
],
[
23,
33
],
[
70,
35
],
[
77,
41
],
[
23,
42
],
[
28,
45
],
[
23,
49
],
[
65,
56
],
[
23,
57
],
[
28,
58
],
[
71,
62
],
[
68,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
]
] | [
"s=int(input())\nsl=list(str(s))\nn=len(sl)\ntemp=0\nfor i in range(n):\n for j in range(n-i):\n temp+=(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))\nprint(temp)",
"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",
"temp=0",
"temp",
"0",
"for i in range(n):\n for j in range(n-i):\n temp+=(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))",
"i",
"range(n)",
"range",
"n",
"for j in range(n-i):\n temp+=(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))",
"j",
"range(n-i)",
"range",
"n-i",
"n",
"i",
"temp+=(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))",
"temp",
"(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))",
"int(sl[i])*(10**j)",
"int(sl[i])",
"int",
"sl[i]",
"sl",
"i",
"10**j",
"10",
"j",
"2**(i+max(0,(n-i-j-2)))",
"2",
"i+max(0,(n-i-j-2))",
"i",
"max(0,(n-i-j-2))",
"max",
"0",
"n-i-j-2",
"n-i-j",
"n-i",
"n",
"i",
"j",
"2",
"print(temp)",
"print",
"temp",
"n=len(sl)",
"len(sl)",
"n",
"temp=0",
"0",
"temp",
"temp+=(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))",
"(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))",
"temp",
"s=int(input())",
"int(input())",
"s",
"sl=list(str(s))",
"list(str(s))",
"sl"
] | s=int(input())
sl=list(str(s))
n=len(sl)
temp=0
for i in range(n):
for j in range(n-i):
temp+=(int(sl[i])*(10**j))*(2**(i+max(0,(n-i-j-2))))
print(temp) |
[
7,
15,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
13,
17,
0,
13,
2,
13,
18,
13,
13,
14,
2,
18,
13,
2,
13,
17,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
13,
18,
13,
13,
0,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
100,
3
],
[
94,
7
],
[
17,
16
],
[
101,
20
],
[
103,
23
],
[
27,
26
],
[
95,
26
],
[
112,
29
],
[
109,
32
],
[
36,
35
],
[
26,
41
],
[
35,
45
],
[
91,
48
],
[
110,
50
],
[
122,
50
],
[
98,
50
],
[
92,
50
],
[
101,
52
],
[
35,
53
],
[
26,
57
],
[
35,
59
],
[
118,
63
],
[
110,
66
],
[
122,
66
],
[
98,
66
],
[
92,
66
],
[
97,
68
],
[
101,
70
],
[
35,
71
],
[
121,
73
],
[
110,
75
],
[
122,
75
],
[
98,
75
],
[
92,
75
],
[
101,
77
],
[
35,
78
],
[
115,
80
],
[
122,
83
],
[
98,
83
],
[
92,
83
],
[
110,
83
],
[
106,
85
],
[
116,
86
],
[
119,
86
],
[
113,
86
],
[
107,
89
],
[
104,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
116,
106
],
[
119,
106
],
[
113,
106
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
]
] | [
"from itertools import product\n\nS = input()\n\npatterns = list(product([\"\",\"+\"],repeat=len(S)-1))\n\nans = 0\n\nfor pattern in patterns:\n cnt = 0\n num = \"\"\n for i in range(len(pattern)+1):\n if i == 0:\n num = num + S[i]\n else:\n if pattern[i-1] == \"+\":\n cnt += int(num)\n num = S[i]\n else:\n num = num + S[i]\n cnt += int(num)\n ans += cnt\n\n\nprint(ans)",
"from itertools import product",
"S = input()",
"S",
"input()",
"input",
"patterns = list(product([\"\",\"+\"],repeat=len(S)-1))",
"patterns",
"list(product([\"\",\"+\"],repeat=len(S)-1))",
"list",
"product([\"\",\"+\"],repeat=len(S)-1)",
"product",
"[\"\",\"+\"]",
"\"\"",
"\"+\"",
"repeat=len(S)-1",
"repeat",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"ans = 0",
"ans",
"0",
"for pattern in patterns:\n cnt = 0\n num = \"\"\n for i in range(len(pattern)+1):\n if i == 0:\n num = num + S[i]\n else:\n if pattern[i-1] == \"+\":\n cnt += int(num)\n num = S[i]\n else:\n num = num + S[i]\n cnt += int(num)\n ans += cnt",
"pattern",
"patterns",
"cnt = 0",
"cnt",
"0",
"num = \"\"",
"num",
"\"\"",
"for i in range(len(pattern)+1):\n if i == 0:\n num = num + S[i]\n else:\n if pattern[i-1] == \"+\":\n cnt += int(num)\n num = S[i]\n else:\n num = num + S[i]\n ",
"i",
"range(len(pattern)+1)",
"range",
"len(pattern)+1",
"len(pattern)",
"len",
"pattern",
"1",
"if i == 0:\n num = num + S[i]\n else:\n if pattern[i-1] == \"+\":\n cnt += int(num)\n num = S[i]\n else:\n num = num + S[i]\n ",
"i == 0",
"i",
"0",
"num = num + S[i]",
"num",
"num + S[i]",
"num",
"S[i]",
"S",
"i",
"if pattern[i-1] == \"+\":\n cnt += int(num)\n num = S[i]\n else:\n num = num + S[i]\n ",
"pattern[i-1] == \"+\"",
"pattern[i-1]",
"pattern",
"i-1",
"i",
"1",
"\"+\"",
"cnt += int(num)",
"cnt",
"int(num)",
"int",
"num",
"num = S[i]",
"num",
"S[i]",
"S",
"i",
"num = num + S[i]",
"num",
"num + S[i]",
"num",
"S[i]",
"S",
"i",
"cnt += int(num)",
"cnt",
"int(num)",
"int",
"num",
"ans += cnt",
"ans",
"cnt",
"print(ans)",
"print",
"ans",
"num = num + S[i]",
"num + S[i]",
"num",
"patterns = list(product([\"\",\"+\"],repeat=len(S)-1))",
"list(product([\"\",\"+\"],repeat=len(S)-1))",
"patterns",
"num = S[i]",
"S[i]",
"num",
"S = input()",
"input()",
"S",
"ans = 0",
"0",
"ans",
"ans += cnt",
"cnt",
"ans",
"num = \"\"",
"\"\"",
"num",
"cnt = 0",
"0",
"cnt",
"cnt += int(num)",
"int(num)",
"cnt",
"cnt += int(num)",
"int(num)",
"cnt",
"num = num + S[i]",
"num + S[i]",
"num"
] | from itertools import product
S = input()
patterns = list(product(["","+"],repeat=len(S)-1))
ans = 0
for pattern in patterns:
cnt = 0
num = ""
for i in range(len(pattern)+1):
if i == 0:
num = num + S[i]
else:
if pattern[i-1] == "+":
cnt += int(num)
num = S[i]
else:
num = num + S[i]
cnt += int(num)
ans += cnt
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
4,
13,
18,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
13,
2,
17,
13,
0,
13,
13,
0,
13,
17,
0,
13,
2,
2,
13,
17,
4,
13,
18,
13,
2,
13,
17,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
91,
2
],
[
76,
6
],
[
10,
9
],
[
92,
17
],
[
97,
20
],
[
92,
24
],
[
79,
27
],
[
31,
30
],
[
92,
36
],
[
9,
40
],
[
30,
43
],
[
82,
45
],
[
98,
46
],
[
95,
46
],
[
74,
46
],
[
73,
48
],
[
94,
51
],
[
74,
54
],
[
98,
54
],
[
95,
54
],
[
92,
59
],
[
30,
61
],
[
85,
64
],
[
95,
65
],
[
74,
65
],
[
98,
65
],
[
88,
67
],
[
86,
68
],
[
83,
68
],
[
80,
68
],
[
89,
71
],
[
77,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
98,
82
],
[
95,
82
],
[
74,
82
],
[
82,
83
],
[
95,
85
],
[
74,
85
],
[
98,
85
],
[
85,
86
],
[
86,
88
],
[
83,
88
],
[
80,
88
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"S = input()\n\nans=0\nfor i in range(1<<(len(S)-1)):\n num = int(S[0])\n cur=0\n for j in range(len(S)-1):\n if i & (1<<j):\n cur+=num\n num=0\n num=num*10+int(S[j+1])\n cur += num\n ans+=cur\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"ans=0",
"ans",
"0",
"for i in range(1<<(len(S)-1)):\n num = int(S[0])\n cur=0\n for j in range(len(S)-1):\n if i & (1<<j):\n cur+=num\n num=0\n num=num*10+int(S[j+1])\n cur += num\n ans+=cur",
"i",
"range(1<<(len(S)-1))",
"range",
"1<<(len(S)-1)",
"1",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"num = int(S[0])",
"num",
"int(S[0])",
"int",
"S[0]",
"S",
"0",
"cur=0",
"cur",
"0",
"for j in range(len(S)-1):\n if i & (1<<j):\n cur+=num\n num=0\n num=num*10+int(S[j+1])\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if i & (1<<j):\n cur+=num\n num=0\n ",
"i & (1<<j)",
"i",
"1<<j",
"1",
"j",
"cur+=num",
"cur",
"num",
"num=0",
"num",
"0",
"num=num*10+int(S[j+1])",
"num",
"num*10+int(S[j+1])",
"num*10",
"num",
"10",
"int(S[j+1])",
"int",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"cur += num",
"cur",
"num",
"ans+=cur",
"ans",
"cur",
"print(ans)",
"print",
"ans",
"num=0",
"0",
"num",
"ans=0",
"0",
"ans",
"cur=0",
"0",
"cur",
"cur+=num",
"num",
"cur",
"cur += num",
"num",
"cur",
"ans+=cur",
"cur",
"ans",
"S = input()",
"input()",
"S",
"num=num*10+int(S[j+1])",
"num*10+int(S[j+1])",
"num",
"num = int(S[0])",
"int(S[0])",
"num"
] | S = input()
ans=0
for i in range(1<<(len(S)-1)):
num = int(S[0])
cur=0
for j in range(len(S)-1):
if i & (1<<j):
cur+=num
num=0
num=num*10+int(S[j+1])
cur += num
ans+=cur
print(ans) |
[
7,
15,
13,
15,
13,
15,
13,
12,
13,
28,
13,
4,
13,
17,
4,
13,
13,
0,
13,
18,
13,
39,
17,
13,
0,
13,
18,
13,
39,
13,
27,
39,
13,
13,
28,
13,
4,
13,
13,
0,
13,
39,
13,
4,
18,
13,
13,
13,
27,
13,
23,
13,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
18,
13,
13,
0,
13,
4,
13,
18,
18,
13,
13,
13,
4,
13,
13,
29,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
11,
10
],
[
51,
16
],
[
19,
18
],
[
51,
20
],
[
26,
25
],
[
51,
27
],
[
36,
35
],
[
25,
38
],
[
41,
40
],
[
40,
45
],
[
35,
47
],
[
40,
49
],
[
51,
51
],
[
56,
55
],
[
60,
59
],
[
110,
63
],
[
55,
64
],
[
67,
66
],
[
55,
69
],
[
72,
71
],
[
59,
76
],
[
79,
78
],
[
59,
84
],
[
71,
85
],
[
88,
87
],
[
59,
92
],
[
71,
93
],
[
78,
94
],
[
87,
97
],
[
66,
97
],
[
107,
104
]
] | [
"#! env python\n# -*- coding: utf-8 -*-\n\nimport os\nimport sys\nimport itertools\n\n\n# atcoder.main\n# Date: 2020/06/20\n# Filename: main \n# Author: acto_mini\n\ndef splitter(str):\n for i in range(1, len(str)):\n start = str[0:i]\n end = str[i:]\n yield (start, end)\n for split in splitter(end):\n result = [start]\n result.extend(split)\n yield result\n\n\ndef main():\n S = input()\n A = list(splitter(S))\n\n ans = int(S)\n for i in range(len(A)):\n for j in range(len(A[i])):\n ans += int(A[i][j])\n\n print(ans)\n return\n\n\nif __name__ == '__main__':\n main()",
"import os",
"os",
"import sys",
"sys",
"import itertools",
"itertools",
"def splitter(str):\n for i in range(1, len(str)):\n start = str[0:i]\n end = str[i:]\n yield (start, end)\n for split in splitter(end):\n result = [start]\n result.extend(split)\n yield result",
"splitter",
"for i in range(1, len(str)):\n start = str[0:i]\n end = str[i:]\n yield (start, end)\n for split in splitter(end):\n result = [start]\n result.extend(split)\n yield result",
"i",
"range(1, len(str))",
"range",
"1",
"len(str)",
"len",
"str",
"start = str[0:i]",
"start",
"str[0:i]",
"str",
"0:i",
"0",
"i",
"end = str[i:]",
"end",
"str[i:]",
"str",
"i:",
"i",
"yield (start, end)",
"(start, end)",
"start",
"end",
"for split in splitter(end):\n result = [start]\n result.extend(split)\n yield result",
"split",
"splitter(end)",
"splitter",
"end",
"result = [start]",
"result",
"[start]",
"start",
"result.extend(split)",
"result.extend",
"result",
"extend",
"split",
"yield result",
"result",
"str",
"str",
"def main():\n S = input()\n A = list(splitter(S))\n\n ans = int(S)\n for i in range(len(A)):\n for j in range(len(A[i])):\n ans += int(A[i][j])\n\n print(ans)\n return",
"main",
"S = input()",
"S",
"input()",
"input",
"A = list(splitter(S))",
"A",
"list(splitter(S))",
"list",
"splitter(S)",
"splitter",
"S",
"ans = int(S)",
"ans",
"int(S)",
"int",
"S",
"for i in range(len(A)):\n for j in range(len(A[i])):\n ans += int(A[i][j])\n\n ",
"i",
"range(len(A))",
"range",
"len(A)",
"len",
"A",
"for j in range(len(A[i])):\n ans += int(A[i][j])\n\n ",
"j",
"range(len(A[i]))",
"range",
"len(A[i])",
"len",
"A[i]",
"A",
"i",
"ans += int(A[i][j])",
"ans",
"int(A[i][j])",
"int",
"A[i][j]",
"[i]",
"A",
"i",
"j",
"print(ans)",
"print",
"ans",
"return",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n S = input()\n A = list(splitter(S))\n\n ans = int(S)\n for i in range(len(A)):\n for j in range(len(A[i])):\n ans += int(A[i][j])\n\n print(ans)\n return",
"def main():\n S = input()\n A = list(splitter(S))\n\n ans = int(S)\n for i in range(len(A)):\n for j in range(len(A[i])):\n ans += int(A[i][j])\n\n print(ans)\n return",
"main",
"def splitter(str):\n for i in range(1, len(str)):\n start = str[0:i]\n end = str[i:]\n yield (start, end)\n for split in splitter(end):\n result = [start]\n result.extend(split)\n yield result",
"def splitter(str):\n for i in range(1, len(str)):\n start = str[0:i]\n end = str[i:]\n yield (start, end)\n for split in splitter(end):\n result = [start]\n result.extend(split)\n yield result",
"splitter"
] | #! env python
# -*- coding: utf-8 -*-
import os
import sys
import itertools
# atcoder.main
# Date: 2020/06/20
# Filename: main
# Author: acto_mini
def splitter(str):
for i in range(1, len(str)):
start = str[0:i]
end = str[i:]
yield (start, end)
for split in splitter(end):
result = [start]
result.extend(split)
yield result
def main():
S = input()
A = list(splitter(S))
ans = int(S)
for i in range(len(A)):
for j in range(len(A[i])):
ans += int(A[i][j])
print(ans)
return
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
12,
13,
14,
2,
13,
2,
13,
17,
29,
4,
13,
13,
29,
2,
4,
13,
2,
13,
17,
2,
2,
13,
17,
18,
13,
2,
13,
17,
4,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
23,
13,
23,
13,
4,
13,
4,
13,
17,
18,
13,
17,
10,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
66,
2
],
[
63,
6
],
[
67,
9
],
[
51,
14
],
[
64,
16
],
[
53,
21
],
[
51,
27
],
[
53,
31
],
[
67,
34
],
[
51,
36
],
[
51,
41
],
[
53,
44
],
[
67,
46
],
[
51,
48
],
[
51,
51
],
[
53,
53
],
[
70,
57
],
[
67,
60
],
[
63,
64
],
[
66,
67
]
] | [
"s = input()\nn = len(s)\n\n\ndef dfs(i, f):\n if i == n-1:\n return eval(f)\n\n return dfs(i+1, f+'+' + s[i+1]) + \\\n dfs(i+1, f+s[i+1])\n\n\nprint(dfs(0, s[0]))",
"s = input()",
"s",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"def dfs(i, f):\n if i == n-1:\n return eval(f)\n\n return dfs(i+1, f+'+' + s[i+1]) + \\\n dfs(i+1, f+s[i+1])",
"dfs",
"if i == n-1:\n return eval(f)\n\n ",
"i == n-1",
"i",
"n-1",
"n",
"1",
"return eval(f)",
"eval(f)",
"eval",
"f",
"return dfs(i+1, f+'+' + s[i+1]) + \\\n dfs(i+1, f+s[i+1])",
"dfs(i+1, f+'+' + s[i+1]) + \\\n dfs(i+1, f+s[i+1])",
"dfs(i+1, f+'+' + s[i+1])",
"dfs",
"i+1",
"i",
"1",
"f+'+' + s[i+1]",
"f+'+'",
"f",
"'+'",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"dfs(i+1, f+s[i+1])",
"dfs",
"i+1",
"i",
"1",
"f+s[i+1]",
"f",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"i",
"i",
"f",
"f",
"print(dfs(0, s[0]))",
"print",
"dfs(0, s[0])",
"dfs",
"0",
"s[0]",
"s",
"0",
"n = len(s)",
"len(s)",
"n",
"s = input()",
"input()",
"s",
"def dfs(i, f):\n if i == n-1:\n return eval(f)\n\n return dfs(i+1, f+'+' + s[i+1]) + \\\n dfs(i+1, f+s[i+1])",
"def dfs(i, f):\n if i == n-1:\n return eval(f)\n\n return dfs(i+1, f+'+' + s[i+1]) + \\\n dfs(i+1, f+s[i+1])",
"dfs"
] | s = input()
n = len(s)
def dfs(i, f):
if i == n-1:
return eval(f)
return dfs(i+1, f+'+' + s[i+1]) + \
dfs(i+1, f+s[i+1])
print(dfs(0, s[0]))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
15,
0,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
40,
13,
2,
13,
17,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] | [
[
94,
2
],
[
85,
8
],
[
95,
12
],
[
73,
16
],
[
26,
25
],
[
86,
26
],
[
76,
28
],
[
32,
31
],
[
74,
31
],
[
82,
34
],
[
38,
37
],
[
95,
42
],
[
37,
45
],
[
86,
47
],
[
88,
50
],
[
95,
52
],
[
37,
53
],
[
97,
55
],
[
31,
57
],
[
37,
58
],
[
79,
60
],
[
95,
62
],
[
37,
63
],
[
91,
65
],
[
80,
68
],
[
98,
68
],
[
89,
68
],
[
83,
68
],
[
92,
71
],
[
77,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"S = list(input())\ns = len(S)-1\nfrom itertools import product\na = list(product([\"+\",\"\"],repeat=s))\nans = 0\nfor i in a:\n b = \"\"\n for j in range(len(S)):\n if j<=s-1:\n b += S[j]\n b += i[j]\n else:\n b += S[j]\n ans += eval(b)\nprint(ans)",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"s = len(S)-1",
"s",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"from itertools import product",
"a = list(product([\"+\",\"\"],repeat=s))",
"a",
"list(product([\"+\",\"\"],repeat=s))",
"list",
"product([\"+\",\"\"],repeat=s)",
"product",
"[\"+\",\"\"]",
"\"+\"",
"\"\"",
"repeat=s",
"repeat",
"s",
"ans = 0",
"ans",
"0",
"for i in a:\n b = \"\"\n for j in range(len(S)):\n if j<=s-1:\n b += S[j]\n b += i[j]\n else:\n b += S[j]\n ans += eval(b)",
"i",
"a",
"b = \"\"",
"b",
"\"\"",
"for j in range(len(S)):\n if j<=s-1:\n b += S[j]\n b += i[j]\n else:\n b += S[j]\n ",
"j",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"if j<=s-1:\n b += S[j]\n b += i[j]\n else:\n b += S[j]\n ",
"j<=s-1",
"j",
"s-1",
"s",
"1",
"b += S[j]",
"b",
"S[j]",
"S",
"j",
"b += i[j]",
"b",
"i[j]",
"i",
"j",
"b += S[j]",
"b",
"S[j]",
"S",
"j",
"ans += eval(b)",
"ans",
"eval(b)",
"eval",
"b",
"print(ans)",
"print",
"ans",
"a = list(product([\"+\",\"\"],repeat=s))",
"list(product([\"+\",\"\"],repeat=s))",
"a",
"ans = 0",
"0",
"ans",
"b += S[j]",
"S[j]",
"b",
"b = \"\"",
"\"\"",
"b",
"s = len(S)-1",
"len(S)-1",
"s",
"b += S[j]",
"S[j]",
"b",
"ans += eval(b)",
"eval(b)",
"ans",
"S = list(input())",
"list(input())",
"S",
"b += i[j]",
"i[j]",
"b"
] | S = list(input())
s = len(S)-1
from itertools import product
a = list(product(["+",""],repeat=s))
ans = 0
for i in a:
b = ""
for j in range(len(S)):
if j<=s-1:
b += S[j]
b += i[j]
else:
b += S[j]
ans += eval(b)
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,
4,
13,
4,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
18,
13,
13,
14,
2,
18,
13,
40,
2,
13,
17,
17,
0,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
75,
2
],
[
81,
6
],
[
76,
9
],
[
72,
11
],
[
15,
14
],
[
82,
20
],
[
84,
23
],
[
87,
26
],
[
14,
31
],
[
35,
34
],
[
82,
37
],
[
78,
39
],
[
76,
43
],
[
34,
44
],
[
88,
48
],
[
34,
51
],
[
69,
55
],
[
66,
58
],
[
70,
61
],
[
79,
61
],
[
85,
61
],
[
67,
64
],
[
73,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
]
] | [
"S = input()\n\nlength = len(S)\nans = 0\n\nfor x in range(2 ** (length - 1)):\n res = \"\"\n b = str(format(x, '010b'))\n for i in range(length):\n res += str(S[i])\n if b[-(i + 1)] == \"1\":\n res += \"+\"\n else:\n pass\n ans += eval(res)\n \nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"length = len(S)",
"length",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for x in range(2 ** (length - 1)):\n res = \"\"\n b = str(format(x, '010b'))\n for i in range(length):\n res += str(S[i])\n if b[-(i + 1)] == \"1\":\n res += \"+\"\n else:\n pass\n ans += eval(res)\n ",
"x",
"range(2 ** (length - 1))",
"range",
"2 ** (length - 1)",
"2",
"length - 1",
"length",
"1",
"res = \"\"",
"res",
"\"\"",
"b = str(format(x, '010b'))",
"b",
"str(format(x, '010b'))",
"str",
"format(x, '010b')",
"format",
"x",
"'010b'",
"for i in range(length):\n res += str(S[i])\n if b[-(i + 1)] == \"1\":\n res += \"+\"\n else:\n pass\n ",
"i",
"range(length)",
"range",
"length",
"res += str(S[i])",
"res",
"str(S[i])",
"str",
"S[i]",
"S",
"i",
"if b[-(i + 1)] == \"1\":\n res += \"+\"\n else:\n pass\n ",
"b[-(i + 1)] == \"1\"",
"b[-(i + 1)]",
"b",
"-(i + 1)",
"i + 1",
"i",
"1",
"\"1\"",
"res += \"+\"",
"res",
"\"+\"",
"ans += eval(res)",
"ans",
"eval(res)",
"eval",
"res",
"print(ans)",
"print",
"ans",
"ans += eval(res)",
"eval(res)",
"ans",
"res += \"+\"",
"\"+\"",
"res",
"ans = 0",
"0",
"ans",
"S = input()",
"input()",
"S",
"res += str(S[i])",
"str(S[i])",
"res",
"length = len(S)",
"len(S)",
"length",
"res = \"\"",
"\"\"",
"res",
"b = str(format(x, '010b'))",
"str(format(x, '010b'))",
"b"
] | S = input()
length = len(S)
ans = 0
for x in range(2 ** (length - 1)):
res = ""
b = str(format(x, '010b'))
for i in range(length):
res += str(S[i])
if b[-(i + 1)] == "1":
res += "+"
else:
pass
ans += eval(res)
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,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
17,
13,
13,
0,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13
] | [
[
74,
2
],
[
77,
6
],
[
75,
9
],
[
95,
11
],
[
15,
14
],
[
78,
20
],
[
98,
23
],
[
83,
26
],
[
75,
28
],
[
32,
31
],
[
78,
35
],
[
31,
41
],
[
14,
42
],
[
89,
44
],
[
84,
47
],
[
81,
47
],
[
102,
47
],
[
101,
49
],
[
75,
51
],
[
31,
53
],
[
80,
56
],
[
75,
58
],
[
31,
60
],
[
86,
63
],
[
81,
66
],
[
102,
66
],
[
84,
66
],
[
92,
68
],
[
87,
69
],
[
90,
69
],
[
99,
69
],
[
93,
72
],
[
96,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
87,
92
],
[
90,
92
],
[
99,
92
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
]
] | [
"S = input()\nn = len(S)\n\nanswer = 0\nfor i in range(2 ** (n - 1)):\n total_sum = 0\n tmp = S[0]\n for j in range(n - 1):\n if (1 << j) & i:\n total_sum += int(tmp)\n tmp = S[j + 1]\n else:\n tmp += S[j + 1]\n total_sum += int(tmp)\n answer += total_sum\n\nprint(answer)",
"S = input()",
"S",
"input()",
"input",
"n = len(S)",
"n",
"len(S)",
"len",
"S",
"answer = 0",
"answer",
"0",
"for i in range(2 ** (n - 1)):\n total_sum = 0\n tmp = S[0]\n for j in range(n - 1):\n if (1 << j) & i:\n total_sum += int(tmp)\n tmp = S[j + 1]\n else:\n tmp += S[j + 1]\n total_sum += int(tmp)\n answer += total_sum",
"i",
"range(2 ** (n - 1))",
"range",
"2 ** (n - 1)",
"2",
"n - 1",
"n",
"1",
"total_sum = 0",
"total_sum",
"0",
"tmp = S[0]",
"tmp",
"S[0]",
"S",
"0",
"for j in range(n - 1):\n if (1 << j) & i:\n total_sum += int(tmp)\n tmp = S[j + 1]\n else:\n tmp += S[j + 1]\n ",
"j",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if (1 << j) & i:\n total_sum += int(tmp)\n tmp = S[j + 1]\n else:\n tmp += S[j + 1]\n ",
"(1 << j) & i",
"1 << j",
"1",
"j",
"i",
"total_sum += int(tmp)",
"total_sum",
"int(tmp)",
"int",
"tmp",
"tmp = S[j + 1]",
"tmp",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"tmp += S[j + 1]",
"tmp",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"total_sum += int(tmp)",
"total_sum",
"int(tmp)",
"int",
"tmp",
"answer += total_sum",
"answer",
"total_sum",
"print(answer)",
"print",
"answer",
"S = input()",
"input()",
"S",
"n = len(S)",
"len(S)",
"n",
"tmp += S[j + 1]",
"S[j + 1]",
"tmp",
"tmp = S[0]",
"S[0]",
"tmp",
"total_sum += int(tmp)",
"int(tmp)",
"total_sum",
"total_sum += int(tmp)",
"int(tmp)",
"total_sum",
"answer += total_sum",
"total_sum",
"answer",
"answer = 0",
"0",
"answer",
"total_sum = 0",
"0",
"total_sum",
"tmp = S[j + 1]",
"S[j + 1]",
"tmp"
] | S = input()
n = len(S)
answer = 0
for i in range(2 ** (n - 1)):
total_sum = 0
tmp = S[0]
for j in range(n - 1):
if (1 << j) & i:
total_sum += int(tmp)
tmp = S[j + 1]
else:
tmp += S[j + 1]
total_sum += int(tmp)
answer += total_sum
print(answer) |
[
7,
15,
13,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
2,
2,
18,
13,
39,
2,
13,
13,
17,
18,
13,
39,
2,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
86,
4
],
[
77,
8
],
[
87,
12
],
[
80,
15
],
[
19,
18
],
[
78,
23
],
[
89,
25
],
[
87,
30
],
[
92,
32
],
[
36,
35
],
[
78,
38
],
[
18,
42
],
[
35,
43
],
[
83,
46
],
[
90,
50
],
[
84,
50
],
[
35,
53
],
[
93,
54
],
[
75,
54
],
[
90,
57
],
[
84,
57
],
[
35,
60
],
[
93,
61
],
[
75,
61
],
[
74,
63
],
[
95,
66
],
[
84,
69
],
[
90,
69
],
[
96,
72
],
[
81,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
]
] | [
"import copy\n\ns = input()\nn = len(s)-1\nans = 0\n\nfor i in range(2 ** n):\n x = copy.deepcopy(s)\n y = 1\n for j in range(n):\n if ((i >> j) & 1): #フラグが立っていたら\n x = x[:j+y] + \"+\" + x[j+y:]\n y += 1\n ans += eval(x)\n\nprint(ans)",
"import copy",
"copy",
"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 x = copy.deepcopy(s)\n y = 1\n for j in range(n):\n if ((i >> j) & 1): #フラグが立っていたら\n x = x[:j+y] + \"+\" + x[j+y:]\n y += 1\n ans += eval(x)",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"x = copy.deepcopy(s)",
"x",
"copy.deepcopy(s)",
"copy.deepcopy",
"copy",
"deepcopy",
"s",
"y = 1",
"y",
"1",
"for j in range(n):\n if ((i >> j) & 1): #フラグが立っていたら\n x = x[:j+y] + \"+\" + x[j+y:]\n y += 1\n ",
"j",
"range(n)",
"range",
"n",
"if ((i >> j) & 1): #フラグが立っていたら\n x = x[:j+y] + \"+\" + x[j+y:]\n y += 1\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"x = x[:j+y] + \"+\" + x[j+y:]",
"x",
"x[:j+y] + \"+\" + x[j+y:]",
"x[:j+y] + \"+\"",
"x[:j+y]",
"x",
":j+y",
"j+y",
"j",
"y",
"\"+\"",
"x[j+y:]",
"x",
"j+y:",
"j+y",
"j",
"y",
"y += 1",
"y",
"1",
"ans += eval(x)",
"ans",
"eval(x)",
"eval",
"x",
"print(ans)",
"print",
"ans",
"y += 1",
"1",
"y",
"n = len(s)-1",
"len(s)-1",
"n",
"ans = 0",
"0",
"ans",
"x = x[:j+y] + \"+\" + x[j+y:]",
"x[:j+y] + \"+\" + x[j+y:]",
"x",
"s = input()",
"input()",
"s",
"x = copy.deepcopy(s)",
"copy.deepcopy(s)",
"x",
"y = 1",
"1",
"y",
"ans += eval(x)",
"eval(x)",
"ans"
] | import copy
s = input()
n = len(s)-1
ans = 0
for i in range(2 ** n):
x = copy.deepcopy(s)
y = 1
for j in range(n):
if ((i >> j) & 1): #フラグが立っていたら
x = x[:j+y] + "+" + x[j+y:]
y += 1
ans += eval(x)
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,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13
] | [
[
57,
2
],
[
69,
6
],
[
58,
10
],
[
63,
13
],
[
17,
16
],
[
70,
21
],
[
66,
23
],
[
58,
25
],
[
29,
28
],
[
70,
31
],
[
16,
35
],
[
28,
36
],
[
60,
39
],
[
75,
42
],
[
58,
44
],
[
28,
46
],
[
72,
49
],
[
76,
52
],
[
61,
52
],
[
67,
52
],
[
73,
55
],
[
64,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
]
] | [
"s = input()\nn = len(s) -1\nans = 0\nfor i in range(2**n):\n e = s[0]\n for j in range(n):\n if i >> j & 1:\n e +='+'\n e += s[j+1]\n ans += eval(e)\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 e = s[0]\n for j in range(n):\n if i >> j & 1:\n e +='+'\n e += s[j+1]\n ans += eval(e)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"e = s[0]",
"e",
"s[0]",
"s",
"0",
"for j in range(n):\n if i >> j & 1:\n e +='+'\n e += s[j+1]\n ",
"j",
"range(n)",
"range",
"n",
"if i >> j & 1:\n e +='+'\n ",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"e +='+'",
"e",
"'+'",
"e += s[j+1]",
"e",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ans += eval(e)",
"ans",
"eval(e)",
"eval",
"e",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"e +='+'",
"'+'",
"e",
"ans = 0",
"0",
"ans",
"e = s[0]",
"s[0]",
"e",
"n = len(s) -1",
"len(s) -1",
"n",
"ans += eval(e)",
"eval(e)",
"ans",
"e += s[j+1]",
"s[j+1]",
"e"
] | s = input()
n = len(s) -1
ans = 0
for i in range(2**n):
e = s[0]
for j in range(n):
if i >> j & 1:
e +='+'
e += s[j+1]
ans += eval(e)
print(ans)
|
[
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,
4,
18,
13,
13,
0,
13,
39,
4,
18,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
4,
18,
13,
13,
17,
0,
18,
13,
2,
4,
13,
13,
17,
2,
18,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
17,
0,
13,
4,
13,
4,
13,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13
] | [
[
104,
2
],
[
101,
8
],
[
105,
11
],
[
98,
13
],
[
17,
16
],
[
102,
22
],
[
113,
25
],
[
105,
28
],
[
110,
31
],
[
114,
35
],
[
40,
39
],
[
102,
43
],
[
16,
48
],
[
39,
49
],
[
111,
53
],
[
117,
53
],
[
114,
57
],
[
68,
61
],
[
111,
62
],
[
117,
62
],
[
111,
66
],
[
117,
66
],
[
111,
70
],
[
117,
70
],
[
111,
74
],
[
117,
74
],
[
114,
78
],
[
116,
82
],
[
111,
88
],
[
117,
88
],
[
107,
90
],
[
117,
93
],
[
111,
93
],
[
108,
96
],
[
99,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
]
] | [
"s = list(input())\nn = len(s)\n\n\nans = 0\n\nfor i in range(2 ** (n-1)):\n s_temp = s.copy()\n numbers = [s_temp.pop(0)]\n for j in range(n-1):\n if (i >> j) & 1:\n numbers.append(s_temp.pop(0))\n else:\n numbers[len(numbers)-1] = numbers[len(numbers)-1] + s_temp.pop(0)\n\n numbers = list(map(int, numbers))\n\n ans += sum(numbers)\n\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 s_temp = s.copy()\n numbers = [s_temp.pop(0)]\n for j in range(n-1):\n if (i >> j) & 1:\n numbers.append(s_temp.pop(0))\n else:\n numbers[len(numbers)-1] = numbers[len(numbers)-1] + s_temp.pop(0)\n\n numbers = list(map(int, numbers))\n\n ans += sum(numbers)",
"i",
"range(2 ** (n-1))",
"range",
"2 ** (n-1)",
"2",
"n-1",
"n",
"1",
"s_temp = s.copy()",
"s_temp",
"s.copy()",
"s.copy",
"s",
"copy",
"numbers = [s_temp.pop(0)]",
"numbers",
"[s_temp.pop(0)]",
"s_temp.pop(0)",
"s_temp.pop",
"s_temp",
"pop",
"0",
"for j in range(n-1):\n if (i >> j) & 1:\n numbers.append(s_temp.pop(0))\n else:\n numbers[len(numbers)-1] = numbers[len(numbers)-1] + s_temp.pop(0)\n\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i >> j) & 1:\n numbers.append(s_temp.pop(0))\n else:\n numbers[len(numbers)-1] = numbers[len(numbers)-1] + s_temp.pop(0)\n\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"numbers.append(s_temp.pop(0))",
"numbers.append",
"numbers",
"append",
"s_temp.pop(0)",
"s_temp.pop",
"s_temp",
"pop",
"0",
"numbers[len(numbers)-1] = numbers[len(numbers)-1] + s_temp.pop(0)",
"numbers[len(numbers)-1]",
"numbers",
"len(numbers)-1",
"len(numbers)",
"len",
"numbers",
"1",
"numbers[len(numbers)-1] + s_temp.pop(0)",
"numbers[len(numbers)-1]",
"numbers",
"len(numbers)-1",
"len(numbers)",
"len",
"numbers",
"1",
"s_temp.pop(0)",
"s_temp.pop",
"s_temp",
"pop",
"0",
"numbers = list(map(int, numbers))",
"numbers",
"list(map(int, numbers))",
"list",
"map(int, numbers)",
"map",
"int",
"numbers",
"ans += sum(numbers)",
"ans",
"sum(numbers)",
"sum",
"numbers",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"n = len(s)",
"len(s)",
"n",
"s = list(input())",
"list(input())",
"s",
"ans += sum(numbers)",
"sum(numbers)",
"ans",
"numbers = [s_temp.pop(0)]",
"[s_temp.pop(0)]",
"numbers",
"s_temp = s.copy()",
"s.copy()",
"s_temp",
"numbers = list(map(int, numbers))",
"list(map(int, numbers))",
"numbers"
] | s = list(input())
n = len(s)
ans = 0
for i in range(2 ** (n-1)):
s_temp = s.copy()
numbers = [s_temp.pop(0)]
for j in range(n-1):
if (i >> j) & 1:
numbers.append(s_temp.pop(0))
else:
numbers[len(numbers)-1] = numbers[len(numbers)-1] + s_temp.pop(0)
numbers = list(map(int, numbers))
ans += sum(numbers)
print(ans)
|
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
2,
2,
18,
13,
39,
2,
2,
2,
13,
17,
17,
17,
17,
18,
13,
39,
2,
2,
13,
17,
17,
0,
13,
4,
13,
4,
18,
13,
13,
17,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
4,
12
],
[
16,
15
],
[
4,
17
],
[
21,
20
],
[
8,
23
],
[
26,
25
],
[
29,
28
],
[
4,
30
],
[
20,
32
],
[
36,
35
],
[
39,
38
],
[
8,
43
],
[
46,
45
],
[
28,
46
],
[
25,
46
],
[
15,
46
],
[
49,
48
],
[
8,
51
],
[
38,
55
],
[
48,
56
],
[
60,
59
],
[
45,
63
],
[
59,
63
],
[
48,
68
],
[
45,
74
],
[
59,
74
],
[
48,
78
],
[
83,
82
],
[
59,
87
],
[
45,
87
],
[
82,
93
],
[
35,
93
],
[
102,
99
]
] | [
"def solve():\n S = input()\n n = len(S) - 1\n ieS = S[0]\n for i in range(n):\n ieS += '*'\n ieS += S[i+1]\n ans = 0\n for i in range(2 ** n):\n eS = ieS\n for j in range(n):\n if (i >> j) & 1:\n eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]\n ans += eval(eS.replace('*', ''))\n print(ans)\n\n\n\n\n\nif __name__ == '__main__':\n solve()",
"def solve():\n S = input()\n n = len(S) - 1\n ieS = S[0]\n for i in range(n):\n ieS += '*'\n ieS += S[i+1]\n ans = 0\n for i in range(2 ** n):\n eS = ieS\n for j in range(n):\n if (i >> j) & 1:\n eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]\n ans += eval(eS.replace('*', ''))\n print(ans)",
"solve",
"S = input()",
"S",
"input()",
"input",
"n = len(S) - 1",
"n",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"ieS = S[0]",
"ieS",
"S[0]",
"S",
"0",
"for i in range(n):\n ieS += '*'\n ieS += S[i+1]\n ",
"i",
"range(n)",
"range",
"n",
"ieS += '*'",
"ieS",
"'*'",
"ieS += S[i+1]",
"ieS",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2 ** n):\n eS = ieS\n for j in range(n):\n if (i >> j) & 1:\n eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]\n ans += eval(eS.replace('*', ''))\n ",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"eS = ieS",
"eS",
"ieS",
"for j in range(n):\n if (i >> j) & 1:\n eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1:\n eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]",
"eS",
"eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]",
"eS[:(j+1)*2-1] + '+'",
"eS[:(j+1)*2-1]",
"eS",
":(j+1)*2-1",
"(j+1)*2-1",
"(j+1)*2",
"j+1",
"j",
"1",
"2",
"1",
"'+'",
"eS[(j+1)*2:]",
"eS",
"(j+1)*2:",
"(j+1)*2",
"j+1",
"j",
"1",
"2",
"ans += eval(eS.replace('*', ''))",
"ans",
"eval(eS.replace('*', ''))",
"eval",
"eS.replace('*', '')",
"eS.replace",
"eS",
"replace",
"'*'",
"''",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n solve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"solve()",
"solve",
"def solve():\n S = input()\n n = len(S) - 1\n ieS = S[0]\n for i in range(n):\n ieS += '*'\n ieS += S[i+1]\n ans = 0\n for i in range(2 ** n):\n eS = ieS\n for j in range(n):\n if (i >> j) & 1:\n eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]\n ans += eval(eS.replace('*', ''))\n print(ans)",
"def solve():\n S = input()\n n = len(S) - 1\n ieS = S[0]\n for i in range(n):\n ieS += '*'\n ieS += S[i+1]\n ans = 0\n for i in range(2 ** n):\n eS = ieS\n for j in range(n):\n if (i >> j) & 1:\n eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]\n ans += eval(eS.replace('*', ''))\n print(ans)",
"solve"
] | def solve():
S = input()
n = len(S) - 1
ieS = S[0]
for i in range(n):
ieS += '*'
ieS += S[i+1]
ans = 0
for i in range(2 ** n):
eS = ieS
for j in range(n):
if (i >> j) & 1:
eS = eS[:(j+1)*2-1] + '+' + eS[(j+1)*2:]
ans += eval(eS.replace('*', ''))
print(ans)
if __name__ == '__main__':
solve()
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
2,
17,
2,
13,
17,
0,
13,
39,
28,
13,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
18,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
2,
17,
13,
14,
2,
13,
2,
17,
13,
0,
13,
17,
0,
13,
17,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13
] | [
[
100,
2
],
[
109,
6
],
[
101,
9
],
[
112,
11
],
[
110,
14
],
[
91,
16
],
[
113,
20
],
[
106,
23
],
[
27,
26
],
[
92,
29
],
[
82,
31
],
[
103,
34
],
[
38,
37
],
[
113,
40
],
[
94,
42
],
[
110,
46
],
[
113,
49
],
[
37,
50
],
[
88,
53
],
[
95,
55
],
[
104,
58
],
[
98,
58
],
[
86,
58
],
[
26,
61
],
[
37,
64
],
[
85,
66
],
[
97,
69
],
[
107,
73
],
[
89,
75
],
[
83,
75
],
[
107,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
]
] | [
"S = input()\nL = list(S)\nN = len(L)\nbitmask = 2 ** (N - 1)\n\ntotals = []\nfor mask in range(bitmask):\n total = 0\n digit = 0\n for i in range(N):\n num = int(L[N - i - 1])\n total += num * (10 ** digit)\n # bitにi番目のフラグが立っているかどうか\n if mask & (1 << i):\n digit = 0\n else:\n digit += 1\n totals.append(total)\n\nprint(sum(totals))",
"S = input()",
"S",
"input()",
"input",
"L = list(S)",
"L",
"list(S)",
"list",
"S",
"N = len(L)",
"N",
"len(L)",
"len",
"L",
"bitmask = 2 ** (N - 1)",
"bitmask",
"2 ** (N - 1)",
"2",
"N - 1",
"N",
"1",
"totals = []",
"totals",
"[]",
"for mask in range(bitmask):\n total = 0\n digit = 0\n for i in range(N):\n num = int(L[N - i - 1])\n total += num * (10 ** digit)\n # bitにi番目のフラグが立っているかどうか\n if mask & (1 << i):\n digit = 0\n else:\n digit += 1\n totals.append(total)",
"mask",
"range(bitmask)",
"range",
"bitmask",
"total = 0",
"total",
"0",
"digit = 0",
"digit",
"0",
"for i in range(N):\n num = int(L[N - i - 1])\n total += num * (10 ** digit)\n # bitにi番目のフラグが立っているかどうか\n if mask & (1 << i):\n digit = 0\n else:\n digit += 1\n ",
"i",
"range(N)",
"range",
"N",
"num = int(L[N - i - 1])",
"num",
"int(L[N - i - 1])",
"int",
"L[N - i - 1]",
"L",
"N - i - 1",
"N - i",
"N",
"i",
"1",
"total += num * (10 ** digit)",
"total",
"num * (10 ** digit)",
"num",
"10 ** digit",
"10",
"digit",
"if mask & (1 << i):\n digit = 0\n else:\n digit += 1\n ",
"mask & (1 << i)",
"mask",
"1 << i",
"1",
"i",
"digit = 0",
"digit",
"0",
"digit += 1",
"digit",
"1",
"totals.append(total)",
"totals.append",
"totals",
"append",
"total",
"print(sum(totals))",
"print",
"sum(totals)",
"sum",
"totals",
"total = 0",
"0",
"total",
"digit = 0",
"0",
"digit",
"total += num * (10 ** digit)",
"num * (10 ** digit)",
"total",
"bitmask = 2 ** (N - 1)",
"2 ** (N - 1)",
"bitmask",
"num = int(L[N - i - 1])",
"int(L[N - i - 1])",
"num",
"digit += 1",
"1",
"digit",
"S = input()",
"input()",
"S",
"digit = 0",
"0",
"digit",
"totals = []",
"[]",
"totals",
"L = list(S)",
"list(S)",
"L",
"N = len(L)",
"len(L)",
"N"
] | S = input()
L = list(S)
N = len(L)
bitmask = 2 ** (N - 1)
totals = []
for mask in range(bitmask):
total = 0
digit = 0
for i in range(N):
num = int(L[N - i - 1])
total += num * (10 ** digit)
# bitにi番目のフラグが立っているかどうか
if mask & (1 << i):
digit = 0
else:
digit += 1
totals.append(total)
print(sum(totals)) |
[
7,
0,
13,
4,
13,
0,
13,
39,
12,
13,
14,
2,
13,
4,
13,
13,
4,
18,
13,
13,
13,
29,
14,
2,
13,
2,
4,
13,
13,
17,
29,
4,
13,
2,
13,
17,
2,
13,
39,
18,
13,
13,
29,
39,
4,
13,
2,
13,
17,
2,
13,
39,
18,
13,
13,
4,
13,
2,
13,
17,
2,
13,
39,
18,
13,
13,
17,
23,
13,
23,
13,
4,
13,
17,
39,
0,
13,
17,
28,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
4,
13,
18,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
39,
13,
10,
12,
13,
10,
17,
13
] | [
[
135,
2
],
[
153,
6
],
[
68,
12
],
[
136,
15
],
[
154,
18
],
[
70,
20
],
[
68,
24
],
[
136,
28
],
[
68,
34
],
[
70,
37
],
[
136,
40
],
[
68,
41
],
[
68,
47
],
[
70,
50
],
[
136,
53
],
[
68,
54
],
[
68,
58
],
[
70,
61
],
[
136,
64
],
[
68,
65
],
[
68,
68
],
[
70,
70
],
[
157,
72
],
[
159,
76
],
[
80,
79
],
[
154,
79
],
[
144,
82
],
[
147,
85
],
[
89,
88
],
[
79,
93
],
[
79,
97
],
[
88,
98
],
[
150,
101
],
[
148,
102
],
[
139,
102
],
[
127,
102
],
[
130,
102
],
[
129,
104
],
[
126,
107
],
[
138,
110
],
[
79,
114
],
[
88,
115
],
[
141,
117
],
[
139,
118
],
[
127,
118
],
[
130,
118
],
[
148,
118
],
[
132,
120
],
[
142,
121
],
[
151,
121
],
[
145,
121
],
[
133,
124
],
[
160,
124
],
[
126,
127
],
[
129,
130
],
[
142,
132
],
[
151,
132
],
[
145,
132
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
139,
141
],
[
127,
141
],
[
130,
141
],
[
148,
141
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
148,
150
],
[
139,
150
],
[
127,
150
],
[
130,
150
],
[
150,
151
],
[
153,
154
],
[
159,
160
]
] | [
"S = input()\n\n# TODO: 再帰関数でリストを作成 [s1, \"+\", s2, s3, \"+\", s4]とか\nresult = []\ndef dfs(i, list):\n if i == len(S):\n result.append(list)\n return\n else:\n if i == len(S) - 1:\n return dfs(i+1, list+[S[i]])\n else:\n return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])\n\n# TODO: リストに従って和を計算\ndfs(0, [])\nans = 0\nfor l in result:\n sum_of_l = 0\n sequence = 0\n for id in range(len(l)):\n if l[id] == \"+\":\n sum_of_l += sequence\n sequence = 0\n else:\n sequence *= 10\n sequence += int(l[id])\n sum_of_l += sequence\n ans += sum_of_l\n\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"result = []",
"result",
"[]",
"def dfs(i, list):\n if i == len(S):\n result.append(list)\n return\n else:\n if i == len(S) - 1:\n return dfs(i+1, list+[S[i]])\n else:\n return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])\n\n# TODO: リストに従って和を計算",
"dfs",
"if i == len(S):\n result.append(list)\n return\n else:\n if i == len(S) - 1:\n return dfs(i+1, list+[S[i]])\n else:\n return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])\n\n# TODO: リストに従って和を計算",
"i == len(S)",
"i",
"len(S)",
"len",
"S",
"result.append(list)",
"result.append",
"result",
"append",
"list",
"return",
"if i == len(S) - 1:\n return dfs(i+1, list+[S[i]])\n else:\n return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])\n\n# TODO: リストに従って和を計算",
"i == len(S) - 1",
"i",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"return dfs(i+1, list+[S[i]])",
"dfs(i+1, list+[S[i]])",
"dfs",
"i+1",
"i",
"1",
"list+[S[i]]",
"list",
"[S[i]]",
"S[i]",
"S",
"i",
"return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])",
"return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])",
"dfs(i+1, list+[S[i]])",
"dfs",
"i+1",
"i",
"1",
"list+[S[i]]",
"list",
"[S[i]]",
"S[i]",
"S",
"i",
"dfs(i+1, list+[S[i], \"+\"])",
"dfs",
"i+1",
"i",
"1",
"list+[S[i], \"+\"]",
"list",
"[S[i], \"+\"]",
"S[i]",
"S",
"i",
"\"+\"",
"i",
"i",
"list",
"list",
"dfs(0, [])",
"dfs",
"0",
"[]",
"ans = 0",
"ans",
"0",
"for l in result:\n sum_of_l = 0\n sequence = 0\n for id in range(len(l)):\n if l[id] == \"+\":\n sum_of_l += sequence\n sequence = 0\n else:\n sequence *= 10\n sequence += int(l[id])\n sum_of_l += sequence\n ans += sum_of_l",
"l",
"result",
"sum_of_l = 0",
"sum_of_l",
"0",
"sequence = 0",
"sequence",
"0",
"for id in range(len(l)):\n if l[id] == \"+\":\n sum_of_l += sequence\n sequence = 0\n else:\n sequence *= 10\n sequence += int(l[id])\n ",
"id",
"range(len(l))",
"range",
"len(l)",
"len",
"l",
"if l[id] == \"+\":\n sum_of_l += sequence\n sequence = 0\n else:\n sequence *= 10\n sequence += int(l[id])\n ",
"l[id] == \"+\"",
"l[id]",
"l",
"id",
"\"+\"",
"sum_of_l += sequence",
"sum_of_l",
"sequence",
"sequence = 0",
"sequence",
"0",
"sequence *= 10",
"sequence",
"10",
"sequence += int(l[id])",
"sequence",
"int(l[id])",
"int",
"l[id]",
"l",
"id",
"sum_of_l += sequence",
"sum_of_l",
"sequence",
"ans += sum_of_l",
"ans",
"sum_of_l",
"print(ans)",
"print",
"ans",
"sequence *= 10",
"10",
"sequence",
"sequence = 0",
"0",
"sequence",
"ans += sum_of_l",
"sum_of_l",
"ans",
"S = input()",
"input()",
"S",
"sequence += int(l[id])",
"int(l[id])",
"sequence",
"sum_of_l += sequence",
"sequence",
"sum_of_l",
"sum_of_l = 0",
"0",
"sum_of_l",
"sequence = 0",
"0",
"sequence",
"sum_of_l += sequence",
"sequence",
"sum_of_l",
"result = []",
"[]",
"result",
"def dfs(i, list):\n if i == len(S):\n result.append(list)\n return\n else:\n if i == len(S) - 1:\n return dfs(i+1, list+[S[i]])\n else:\n return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])\n\n# TODO: リストに従って和を計算",
"def dfs(i, list):\n if i == len(S):\n result.append(list)\n return\n else:\n if i == len(S) - 1:\n return dfs(i+1, list+[S[i]])\n else:\n return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], \"+\"])\n\n# TODO: リストに従って和を計算",
"dfs",
"ans = 0",
"0",
"ans"
] | S = input()
# TODO: 再帰関数でリストを作成 [s1, "+", s2, s3, "+", s4]とか
result = []
def dfs(i, list):
if i == len(S):
result.append(list)
return
else:
if i == len(S) - 1:
return dfs(i+1, list+[S[i]])
else:
return dfs(i+1, list+[S[i]]), dfs(i+1, list+[S[i], "+"])
# TODO: リストに従って和を計算
dfs(0, [])
ans = 0
for l in result:
sum_of_l = 0
sequence = 0
for id in range(len(l)):
if l[id] == "+":
sum_of_l += sequence
sequence = 0
else:
sequence *= 10
sequence += int(l[id])
sum_of_l += sequence
ans += sum_of_l
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
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,
2,
13,
13,
17,
17,
0,
18,
13,
2,
2,
13,
17,
13,
17,
4,
18,
13,
13,
13,
28,
13,
13,
41,
28,
13,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
2,
2,
17,
13,
17,
18,
13,
13,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
39,
13,
10,
2,
13
] | [
[
102,
2
],
[
108,
6
],
[
103,
10
],
[
114,
13
],
[
117,
16
],
[
20,
19
],
[
109,
24
],
[
120,
26
],
[
109,
30
],
[
33,
32
],
[
109,
35
],
[
19,
40
],
[
32,
41
],
[
52,
45
],
[
121,
46
],
[
109,
49
],
[
32,
51
],
[
118,
55
],
[
121,
57
],
[
60,
59
],
[
118,
59
],
[
64,
63
],
[
103,
63
],
[
63,
66
],
[
111,
68
],
[
72,
71
],
[
59,
76
],
[
112,
79
],
[
71,
84
],
[
59,
87
],
[
71,
88
],
[
105,
90
],
[
112,
97
],
[
106,
100
],
[
115,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
]
] | [
"# -*- coding: utf-8 -*-\ns = input()\nl = len(s)-1\nans = 0\nops = []\n\n# +あり/なしの全探索のため、桁数-1の2乗\nfor i in range(2**l):\n op = [\"\"] * l\n for j in range(l):\n if ((i >> j) & 1) == 1:\n op[l-1-j] = \"+\"\n ops.append(op)\n\nfor o in ops:\n str = [str for str in s]\n for k in range(len(o)):\n str.insert(2*k+1, o[k])\n ans += eval(''.join(str))\n\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"l = len(s)-1",
"l",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"ops = []",
"ops",
"[]",
"for i in range(2**l):\n op = [\"\"] * l\n for j in range(l):\n if ((i >> j) & 1) == 1:\n op[l-1-j] = \"+\"\n ops.append(op)",
"i",
"range(2**l)",
"range",
"2**l",
"2",
"l",
"op = [\"\"] * l",
"op",
"[\"\"] * l",
"[\"\"]",
"\"\"",
"l",
"for j in range(l):\n if ((i >> j) & 1) == 1:\n op[l-1-j] = \"+\"\n ",
"j",
"range(l)",
"range",
"l",
"if ((i >> j) & 1) == 1:\n op[l-1-j] = \"+\"\n ",
"((i >> j) & 1) == 1",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"1",
"op[l-1-j] = \"+\"",
"op[l-1-j]",
"op",
"l-1-j",
"l-1",
"l",
"1",
"j",
"\"+\"",
"ops.append(op)",
"ops.append",
"ops",
"append",
"op",
"for o in ops:\n str = [str for str in s]\n for k in range(len(o)):\n str.insert(2*k+1, o[k])\n ans += eval(''.join(str))",
"o",
"ops",
"str for str in s",
"for str in s",
"str",
"s",
"for str in s",
"str",
"str = [str for str in s]",
"str",
"[str for str in s]",
"for k in range(len(o)):\n str.insert(2*k+1, o[k])\n ",
"k",
"range(len(o))",
"range",
"len(o)",
"len",
"o",
"str.insert(2*k+1, o[k])",
"str.insert",
"str",
"insert",
"2*k+1",
"2*k",
"2",
"k",
"1",
"o[k]",
"o",
"k",
"ans += eval(''.join(str))",
"ans",
"eval(''.join(str))",
"eval",
"''.join(str)",
"''.join",
"''",
"join",
"str",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"ans += eval(''.join(str))",
"eval(''.join(str))",
"ans",
"l = len(s)-1",
"len(s)-1",
"l",
"str = [str for str in s]",
"[str for str in s]",
"str",
"ans = 0",
"0",
"ans",
"ops = []",
"[]",
"ops",
"op = [\"\"] * l",
"[\"\"] * l",
"op"
] | # -*- coding: utf-8 -*-
s = input()
l = len(s)-1
ans = 0
ops = []
# +あり/なしの全探索のため、桁数-1の2乗
for i in range(2**l):
op = [""] * l
for j in range(l):
if ((i >> j) & 1) == 1:
op[l-1-j] = "+"
ops.append(op)
for o in ops:
str = [str for str in s]
for k in range(len(o)):
str.insert(2*k+1, o[k])
ans += eval(''.join(str))
print(ans)
|
[
7,
0,
13,
4,
13,
0,
13,
13,
0,
13,
17,
0,
13,
2,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
2,
2,
4,
13,
13,
17,
13,
14,
13,
0,
13,
18,
13,
39,
2,
2,
4,
13,
13,
17,
13,
14,
2,
2,
13,
2,
4,
13,
13,
17,
13,
0,
13,
4,
13,
13,
0,
13,
13,
14,
2,
4,
13,
13,
17,
4,
13,
13,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] | [
[
105,
2
],
[
99,
6
],
[
106,
7
],
[
111,
9
],
[
102,
12
],
[
106,
18
],
[
22,
21
],
[
103,
24
],
[
27,
26
],
[
106,
32
],
[
21,
37
],
[
26,
38
],
[
114,
41
],
[
100,
45
],
[
121,
45
],
[
109,
45
],
[
106,
51
],
[
26,
53
],
[
120,
57
],
[
100,
59
],
[
121,
59
],
[
109,
59
],
[
106,
65
],
[
26,
67
],
[
26,
71
],
[
106,
75
],
[
121,
77
],
[
100,
77
],
[
109,
77
],
[
117,
79
],
[
121,
82
],
[
100,
82
],
[
109,
82
],
[
108,
84
],
[
106,
85
],
[
106,
90
],
[
106,
94
],
[
118,
97
],
[
115,
97
],
[
112,
97
],
[
106,
99
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
106,
108
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
]
] | [
"S = input()\nS_damy = S\nsum_S = 0\nplus = 2**(len(S)-1)\nfor i in range(plus):\n for j in range(len(S)-1):\n if i >> j & 0b1:\n sum_S += int(S_damy[len(S)-1-j:])\n if S_damy:\n S_damy = S_damy[:len(S)-1-j]\n\n if j == len(S)-2 and S_damy:\n sum_S += int(S_damy)\n S_damy = S\nif len(S) == 1:\n print(S)\nelse:\n print(sum_S)",
"S = input()",
"S",
"input()",
"input",
"S_damy = S",
"S_damy",
"S",
"sum_S = 0",
"sum_S",
"0",
"plus = 2**(len(S)-1)",
"plus",
"2**(len(S)-1)",
"2",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"for i in range(plus):\n for j in range(len(S)-1):\n if i >> j & 0b1:\n sum_S += int(S_damy[len(S)-1-j:])\n if S_damy:\n S_damy = S_damy[:len(S)-1-j]\n\n if j == len(S)-2 and S_damy:\n sum_S += int(S_damy)\n S_damy = S",
"i",
"range(plus)",
"range",
"plus",
"for j in range(len(S)-1):\n if i >> j & 0b1:\n sum_S += int(S_damy[len(S)-1-j:])\n if S_damy:\n S_damy = S_damy[:len(S)-1-j]\n\n if j == len(S)-2 and S_damy:\n sum_S += int(S_damy)\n ",
"j",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if i >> j & 0b1:\n sum_S += int(S_damy[len(S)-1-j:])\n if S_damy:\n S_damy = S_damy[:len(S)-1-j]\n\n ",
"i >> j & 0b1",
"i >> j",
"i",
"j",
"0b1",
"sum_S += int(S_damy[len(S)-1-j:])",
"sum_S",
"int(S_damy[len(S)-1-j:])",
"int",
"S_damy[len(S)-1-j:]",
"S_damy",
"len(S)-1-j:",
"len(S)-1-j",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"j",
"if S_damy:\n S_damy = S_damy[:len(S)-1-j]\n\n ",
"S_damy",
"S_damy = S_damy[:len(S)-1-j]",
"S_damy",
"S_damy[:len(S)-1-j]",
"S_damy",
":len(S)-1-j",
"len(S)-1-j",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"j",
"if j == len(S)-2 and S_damy:\n sum_S += int(S_damy)\n ",
"j == len(S)-2 and S_damy",
"j == len(S)-2",
"j",
"len(S)-2",
"len(S)",
"len",
"S",
"2",
"S_damy",
"sum_S += int(S_damy)",
"sum_S",
"int(S_damy)",
"int",
"S_damy",
"S_damy = S",
"S_damy",
"S",
"if len(S) == 1:\n print(S)\nelse:\n print(sum_S)",
"len(S) == 1",
"len(S)",
"len",
"S",
"1",
"print(S)",
"print",
"S",
"print(sum_S)",
"print",
"sum_S",
"S_damy = S",
"S",
"S_damy",
"plus = 2**(len(S)-1)",
"2**(len(S)-1)",
"plus",
"S = input()",
"input()",
"S",
"S_damy = S",
"S",
"S_damy",
"sum_S = 0",
"0",
"sum_S",
"sum_S += int(S_damy[len(S)-1-j:])",
"int(S_damy[len(S)-1-j:])",
"sum_S",
"sum_S += int(S_damy)",
"int(S_damy)",
"sum_S",
"S_damy = S_damy[:len(S)-1-j]",
"S_damy[:len(S)-1-j]",
"S_damy"
] | S = input()
S_damy = S
sum_S = 0
plus = 2**(len(S)-1)
for i in range(plus):
for j in range(len(S)-1):
if i >> j & 0b1:
sum_S += int(S_damy[len(S)-1-j:])
if S_damy:
S_damy = S_damy[:len(S)-1-j]
if j == len(S)-2 and S_damy:
sum_S += int(S_damy)
S_damy = S
if len(S) == 1:
print(S)
else:
print(sum_S) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
2,
4,
13,
18,
13,
2,
13,
17,
2,
17,
2,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
2,
2,
2,
13,
13,
17,
17,
0,
13,
17,
0,
13,
17,
0,
13,
2,
4,
13,
18,
13,
13,
13,
0,
13,
13,
0,
13,
17,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
109,
2
],
[
85,
6
],
[
110,
9
],
[
91,
11
],
[
110,
16
],
[
86,
18
],
[
86,
23
],
[
103,
26
],
[
94,
29
],
[
33,
32
],
[
86,
38
],
[
42,
41
],
[
86,
45
],
[
32,
53
],
[
41,
54
],
[
106,
58
],
[
97,
61
],
[
82,
64
],
[
110,
69
],
[
41,
70
],
[
98,
71
],
[
107,
71
],
[
104,
71
],
[
101,
71
],
[
88,
73
],
[
83,
74
],
[
95,
74
],
[
100,
76
],
[
89,
80
],
[
92,
80
],
[
82,
83
],
[
85,
86
],
[
83,
88
],
[
95,
88
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] | [
"s=input()\nl=len(s)\nans=int(s[l-1])*(2**(l-1))\nak=1\nsk=0\n\nfor i in range(2**(l-1)):\n for j in range(l-2,-1,-1):\n if (i>>j)&1==1:\n ak=1\n else:\n ak*=10\n sk=int(s[j])*ak\n ans+=sk\n ak=1\n\nprint(ans)",
"s=input()",
"s",
"input()",
"input",
"l=len(s)",
"l",
"len(s)",
"len",
"s",
"ans=int(s[l-1])*(2**(l-1))",
"ans",
"int(s[l-1])*(2**(l-1))",
"int(s[l-1])",
"int",
"s[l-1]",
"s",
"l-1",
"l",
"1",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"ak=1",
"ak",
"1",
"sk=0",
"sk",
"0",
"for i in range(2**(l-1)):\n for j in range(l-2,-1,-1):\n if (i>>j)&1==1:\n ak=1\n else:\n ak*=10\n sk=int(s[j])*ak\n ans+=sk\n ak=1",
"i",
"range(2**(l-1))",
"range",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"for j in range(l-2,-1,-1):\n if (i>>j)&1==1:\n ak=1\n else:\n ak*=10\n sk=int(s[j])*ak\n ans+=sk\n ",
"j",
"range(l-2,-1,-1)",
"range",
"l-2",
"l",
"2",
"-1",
"-1",
"if (i>>j)&1==1:\n ak=1\n else:\n ak*=10\n ",
"(i>>j)&1==1",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"1",
"ak=1",
"ak",
"1",
"ak*=10",
"ak",
"10",
"sk=int(s[j])*ak",
"sk",
"int(s[j])*ak",
"int(s[j])",
"int",
"s[j]",
"s",
"j",
"ak",
"ans+=sk",
"ans",
"sk",
"ak=1",
"ak",
"1",
"print(ans)",
"print",
"ans",
"sk=int(s[j])*ak",
"int(s[j])*ak",
"sk",
"l=len(s)",
"len(s)",
"l",
"ans+=sk",
"sk",
"ans",
"ans=int(s[l-1])*(2**(l-1))",
"int(s[l-1])*(2**(l-1))",
"ans",
"sk=0",
"0",
"sk",
"ak*=10",
"10",
"ak",
"ak=1",
"1",
"ak",
"ak=1",
"1",
"ak",
"ak=1",
"1",
"ak",
"s=input()",
"input()",
"s"
] | s=input()
l=len(s)
ans=int(s[l-1])*(2**(l-1))
ak=1
sk=0
for i in range(2**(l-1)):
for j in range(l-2,-1,-1):
if (i>>j)&1==1:
ak=1
else:
ak*=10
sk=int(s[j])*ak
ans+=sk
ak=1
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
13,
4,
13,
12,
17,
23,
13,
0,
13,
17,
12,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
4,
18,
13,
13,
14,
13,
14,
2,
13,
13,
0,
13,
39,
18,
13,
13,
0,
13,
18,
13,
39,
13,
2,
4,
13,
13,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
13,
0,
13,
18,
13,
39,
13,
0,
13,
4,
13,
4,
18,
17,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
13,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
18,
13,
2,
2,
13,
17,
13,
17,
0,
18,
13,
2,
2,
13,
17,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
174,
2
],
[
195,
6
],
[
175,
9
],
[
192,
11
],
[
196,
19
],
[
189,
22
],
[
193,
27
],
[
193,
35
],
[
186,
37
],
[
43,
42
],
[
46,
45
],
[
116,
52
],
[
45,
58
],
[
78,
58
],
[
62,
61
],
[
114,
64
],
[
45,
65
],
[
78,
65
],
[
68,
67
],
[
114,
69
],
[
79,
78
],
[
86,
85
],
[
67,
90
],
[
61,
90
],
[
93,
92
],
[
85,
95
],
[
98,
97
],
[
114,
99
],
[
104,
103
],
[
97,
110
],
[
67,
110
],
[
61,
110
],
[
103,
112
],
[
92,
112
],
[
42,
112
],
[
114,
114
],
[
116,
116
],
[
180,
118
],
[
190,
121
],
[
124,
123
],
[
181,
128
],
[
177,
130
],
[
190,
131
],
[
134,
133
],
[
181,
136
],
[
123,
140
],
[
133,
141
],
[
151,
144
],
[
178,
145
],
[
181,
148
],
[
133,
150
],
[
160,
153
],
[
178,
154
],
[
181,
157
],
[
133,
159
],
[
183,
162
],
[
172,
164
],
[
196,
165
],
[
178,
166
],
[
184,
169
],
[
187,
169
],
[
174,
175
],
[
190,
177
],
[
177,
178
],
[
180,
181
],
[
183,
184
],
[
186,
187
],
[
189,
190
],
[
192,
193
],
[
195,
196
]
] | [
"# -*- coding: utf-8 -*-\n\ns = input()\n\ns_list = list(s)\noperator_box = list(range(len(s_list) - 1))\noperators = dict(zip(operator_box, list(map(lambda x: False, operator_box))))\n\nresult = 0\n\n# あるオペレータの組み合わせにおける数の和を出す\ndef calc(nums, operators):\n sums = 0\n _index = 0\n for index, operator in operators.items():\n if operator:\n if _index == index:\n chars = [nums[_index]]\n else:\n chars = nums[_index: int(index) + 1]\n\n _index = int(index) + 1\n number = ''.join(chars)\n sums += int(number)\n\n chars = nums[_index:]\n sums += int(''.join(chars))\n return sums\n\nlength = len(operators)\n\nfor i in range(2 ** length):\n _operators = operators\n for j in range(length):\n if ((i >> j) & 1):\n _operators[length - 1 - j] = True\n else: \n _operators[length - 1 - j] = False\n\n result += calc(s_list, _operators)\n\nprint(result)\n",
"s = input()",
"s",
"input()",
"input",
"s_list = list(s)",
"s_list",
"list(s)",
"list",
"s",
"operator_box = list(range(len(s_list) - 1))",
"operator_box",
"list(range(len(s_list) - 1))",
"list",
"range(len(s_list) - 1)",
"range",
"len(s_list) - 1",
"len(s_list)",
"len",
"s_list",
"1",
"operators = dict(zip(operator_box, list(map(lambda x: False, operator_box))))",
"operators",
"dict(zip(operator_box, list(map(lambda x: False, operator_box))))",
"dict",
"zip(operator_box, list(map(lambda x: False, operator_box)))",
"zip",
"operator_box",
"list(map(lambda x: False, operator_box))",
"list",
"map(lambda x: False, operator_box)",
"map",
"lambda x: False",
"False",
"x",
"operator_box",
"result = 0",
"result",
"0",
"def calc(nums, operators):\n sums = 0\n _index = 0\n for index, operator in operators.items():\n if operator:\n if _index == index:\n chars = [nums[_index]]\n else:\n chars = nums[_index: int(index) + 1]\n\n _index = int(index) + 1\n number = ''.join(chars)\n sums += int(number)\n\n chars = nums[_index:]\n sums += int(''.join(chars))\n return sums",
"calc",
"sums = 0",
"sums",
"0",
"_index = 0",
"_index",
"0",
"for index, operator in operators.items():\n if operator:\n if _index == index:\n chars = [nums[_index]]\n else:\n chars = nums[_index: int(index) + 1]\n\n _index = int(index) + 1\n number = ''.join(chars)\n sums += int(number)\n\n ",
"index",
"operator",
"operators.items()",
"operators.items",
"operators",
"items",
"if operator:\n if _index == index:\n chars = [nums[_index]]\n else:\n chars = nums[_index: int(index) + 1]\n\n _index = int(index) + 1\n number = ''.join(chars)\n sums += int(number)\n\n ",
"operator",
"if _index == index:\n chars = [nums[_index]]\n else:\n chars = nums[_index: int(index) + 1]\n\n ",
"_index == index",
"_index",
"index",
"chars = [nums[_index]]",
"chars",
"[nums[_index]]",
"nums[_index]",
"nums",
"_index",
"chars = nums[_index: int(index) + 1]",
"chars",
"nums[_index: int(index) + 1]",
"nums",
"_index: int(index) + 1",
"_index",
"int(index) + 1",
"int(index)",
"int",
"index",
"1",
"_index = int(index) + 1",
"_index",
"int(index) + 1",
"int(index)",
"int",
"index",
"1",
"number = ''.join(chars)",
"number",
"''.join(chars)",
"''.join",
"''",
"join",
"chars",
"sums += int(number)",
"sums",
"int(number)",
"int",
"number",
"chars = nums[_index:]",
"chars",
"nums[_index:]",
"nums",
"_index:",
"_index",
"sums += int(''.join(chars))",
"sums",
"int(''.join(chars))",
"int",
"''.join(chars)",
"''.join",
"''",
"join",
"chars",
"return sums",
"sums",
"nums",
"nums",
"operators",
"operators",
"length = len(operators)",
"length",
"len(operators)",
"len",
"operators",
"for i in range(2 ** length):\n _operators = operators\n for j in range(length):\n if ((i >> j) & 1):\n _operators[length - 1 - j] = True\n else: \n _operators[length - 1 - j] = False\n\n result += calc(s_list, _operators)",
"i",
"range(2 ** length)",
"range",
"2 ** length",
"2",
"length",
"_operators = operators",
"_operators",
"operators",
"for j in range(length):\n if ((i >> j) & 1):\n _operators[length - 1 - j] = True\n else: \n _operators[length - 1 - j] = False\n\n ",
"j",
"range(length)",
"range",
"length",
"if ((i >> j) & 1):\n _operators[length - 1 - j] = True\n else: \n _operators[length - 1 - j] = False\n\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"_operators[length - 1 - j] = True",
"_operators[length - 1 - j]",
"_operators",
"length - 1 - j",
"length - 1",
"length",
"1",
"j",
"True",
"_operators[length - 1 - j] = False",
"_operators[length - 1 - j]",
"_operators",
"length - 1 - j",
"length - 1",
"length",
"1",
"j",
"False",
"result += calc(s_list, _operators)",
"result",
"calc(s_list, _operators)",
"calc",
"s_list",
"_operators",
"print(result)",
"print",
"result",
"def calc(nums, operators):\n sums = 0\n _index = 0\n for index, operator in operators.items():\n if operator:\n if _index == index:\n chars = [nums[_index]]\n else:\n chars = nums[_index: int(index) + 1]\n\n _index = int(index) + 1\n number = ''.join(chars)\n sums += int(number)\n\n chars = nums[_index:]\n sums += int(''.join(chars))\n return sums",
"def calc(nums, operators):\n sums = 0\n _index = 0\n for index, operator in operators.items():\n if operator:\n if _index == index:\n chars = [nums[_index]]\n else:\n chars = nums[_index: int(index) + 1]\n\n _index = int(index) + 1\n number = ''.join(chars)\n sums += int(number)\n\n chars = nums[_index:]\n sums += int(''.join(chars))\n return sums",
"calc",
"s = input()",
"input()",
"s",
"_operators = operators",
"operators",
"_operators",
"length = len(operators)",
"len(operators)",
"length",
"result += calc(s_list, _operators)",
"calc(s_list, _operators)",
"result",
"result = 0",
"0",
"result",
"operators = dict(zip(operator_box, list(map(lambda x: False, operator_box))))",
"dict(zip(operator_box, list(map(lambda x: False, operator_box))))",
"operators",
"operator_box = list(range(len(s_list) - 1))",
"list(range(len(s_list) - 1))",
"operator_box",
"s_list = list(s)",
"list(s)",
"s_list"
] | # -*- coding: utf-8 -*-
s = input()
s_list = list(s)
operator_box = list(range(len(s_list) - 1))
operators = dict(zip(operator_box, list(map(lambda x: False, operator_box))))
result = 0
# あるオペレータの組み合わせにおける数の和を出す
def calc(nums, operators):
sums = 0
_index = 0
for index, operator in operators.items():
if operator:
if _index == index:
chars = [nums[_index]]
else:
chars = nums[_index: int(index) + 1]
_index = int(index) + 1
number = ''.join(chars)
sums += int(number)
chars = nums[_index:]
sums += int(''.join(chars))
return sums
length = len(operators)
for i in range(2 ** length):
_operators = operators
for j in range(length):
if ((i >> j) & 1):
_operators[length - 1 - j] = True
else:
_operators[length - 1 - j] = False
result += calc(s_list, _operators)
print(result)
|
[
7,
0,
13,
4,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
17,
14,
2,
13,
40,
4,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
13,
14,
2,
13,
2,
17,
13,
0,
13,
4,
13,
18,
13,
39,
13,
13,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] | [
[
87,
2
],
[
96,
11
],
[
15,
14
],
[
88,
22
],
[
90,
25
],
[
99,
28
],
[
32,
31
],
[
88,
36
],
[
84,
38
],
[
85,
42
],
[
100,
42
],
[
88,
46
],
[
81,
48
],
[
88,
52
],
[
14,
58
],
[
31,
61
],
[
93,
63
],
[
88,
67
],
[
78,
72
],
[
85,
73
],
[
100,
73
],
[
94,
76
],
[
82,
76
],
[
97,
76
],
[
85,
78
],
[
100,
78
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
]
] | [
"S = str(input().strip())\n\ncnt = 0\nfor i in range(1 << len(S)-1):\n y = None\n x = 0\n for j in range(len(S)):\n x -= 1\n if x == -len(S):\n cnt += int(S[x:y])\n elif i & (1 << j):\n cnt += int(S[x:y])\n y = x\n\nprint(cnt)",
"S = str(input().strip())",
"S",
"str(input().strip())",
"str",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"cnt = 0",
"cnt",
"0",
"for i in range(1 << len(S)-1):\n y = None\n x = 0\n for j in range(len(S)):\n x -= 1\n if x == -len(S):\n cnt += int(S[x:y])\n elif i & (1 << j):\n cnt += int(S[x:y])\n y = x",
"i",
"range(1 << len(S)-1)",
"range",
"1 << len(S)-1",
"1",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"y = None",
"y",
"None",
"x = 0",
"x",
"0",
"for j in range(len(S)):\n x -= 1\n if x == -len(S):\n cnt += int(S[x:y])\n elif i & (1 << j):\n cnt += int(S[x:y])\n y = x",
"j",
"range(len(S))",
"range",
"len(S)",
"len",
"S",
"x -= 1",
"x",
"1",
"if x == -len(S):\n cnt += int(S[x:y])\n elif i & (1 << j):\n cnt += int(S[x:y])\n y = x",
"x == -len(S)",
"x",
"-len(S)",
"len(S)",
"len",
"S",
"cnt += int(S[x:y])",
"cnt",
"int(S[x:y])",
"int",
"S[x:y]",
"S",
"x:y",
"x",
"y",
"elif i & (1 << j):\n cnt += int(S[x:y])\n y = x",
"i & (1 << j)",
"i",
"1 << j",
"1",
"j",
"cnt += int(S[x:y])",
"cnt",
"int(S[x:y])",
"int",
"S[x:y]",
"S",
"x:y",
"x",
"y",
"y = x",
"y",
"x",
"print(cnt)",
"print",
"cnt",
"y = x",
"x",
"y",
"cnt += int(S[x:y])",
"int(S[x:y])",
"cnt",
"x -= 1",
"1",
"x",
"S = str(input().strip())",
"str(input().strip())",
"S",
"y = None",
"None",
"y",
"cnt += int(S[x:y])",
"int(S[x:y])",
"cnt",
"cnt = 0",
"0",
"cnt",
"x = 0",
"0",
"x"
] | S = str(input().strip())
cnt = 0
for i in range(1 << len(S)-1):
y = None
x = 0
for j in range(len(S)):
x -= 1
if x == -len(S):
cnt += int(S[x:y])
elif i & (1 << j):
cnt += int(S[x:y])
y = x
print(cnt) |
[
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,
13,
13,
17,
0,
13,
2,
17,
18,
13,
2,
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,
2,
13
] | [
[
64,
2
],
[
58,
8
],
[
65,
12
],
[
67,
15
],
[
19,
18
],
[
59,
23
],
[
61,
25
],
[
65,
27
],
[
31,
30
],
[
59,
33
],
[
18,
37
],
[
30,
38
],
[
73,
41
],
[
65,
45
],
[
30,
47
],
[
70,
50
],
[
74,
53
],
[
62,
53
],
[
71,
56
],
[
68,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
]
] | [
"S = list(input())\nl = len(S)-1\nsu = 0\nfor i in range(2**l):\n q = S[0]\n for j in range(l):\n if (i>>j) & 1:\n q += '+' + S[j+1]\n else:q += S[j+1]\n su += eval(q)\nprint(su)",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"l = len(S)-1",
"l",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"su = 0",
"su",
"0",
"for i in range(2**l):\n q = S[0]\n for j in range(l):\n if (i>>j) & 1:\n q += '+' + S[j+1]\n else:q += S[j+1]\n su += eval(q)",
"i",
"range(2**l)",
"range",
"2**l",
"2",
"l",
"q = S[0]",
"q",
"S[0]",
"S",
"0",
"for j in range(l):\n if (i>>j) & 1:\n q += '+' + S[j+1]\n else:q += S[j+1]\n ",
"j",
"range(l)",
"range",
"l",
"if (i>>j) & 1:\n q += '+' + S[j+1]\n else:q += S[j+1]\n ",
"(i>>j) & 1",
"i>>j",
"i",
"j",
"1",
"q += '+' + S[j+1]",
"q",
"'+' + S[j+1]",
"'+'",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"su += eval(q)",
"su",
"eval(q)",
"eval",
"q",
"print(su)",
"print",
"su",
"l = len(S)-1",
"len(S)-1",
"l",
"q = S[0]",
"S[0]",
"q",
"S = list(input())",
"list(input())",
"S",
"su = 0",
"0",
"su",
"su += eval(q)",
"eval(q)",
"su",
"q += '+' + S[j+1]",
"'+' + S[j+1]",
"q"
] | S = list(input())
l = len(S)-1
su = 0
for i in range(2**l):
q = S[0]
for j in range(l):
if (i>>j) & 1:
q += '+' + S[j+1]
else:q += S[j+1]
su += eval(q)
print(su) |
[
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,
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,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
86,
2
],
[
83,
8
],
[
87,
11
],
[
71,
13
],
[
17,
16
],
[
84,
22
],
[
80,
25
],
[
87,
27
],
[
31,
30
],
[
84,
34
],
[
16,
39
],
[
30,
40
],
[
74,
43
],
[
68,
46
],
[
87,
48
],
[
30,
50
],
[
77,
53
],
[
69,
61
],
[
75,
61
],
[
81,
61
],
[
78,
66
],
[
72,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] | [
"s = list(input())\nl = len(s)\n\nans = 0\n\nfor bit in range(2 ** (l-1)):\n f = s[0]\n for i in range(l-1):\n if ((bit >> i) & 1):\n f += '+'\n f += s[i+1]\n\n ans += sum(map(int, f.split(\"+\")))\nprint(ans)",
"s = list(input())",
"s",
"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 f = s[0]\n for i in range(l-1):\n if ((bit >> i) & 1):\n f += '+'\n f += s[i+1]\n\n ans += sum(map(int, f.split(\"+\")))",
"bit",
"range(2 ** (l-1))",
"range",
"2 ** (l-1)",
"2",
"l-1",
"l",
"1",
"f = s[0]",
"f",
"s[0]",
"s",
"0",
"for i in range(l-1):\n if ((bit >> i) & 1):\n f += '+'\n f += s[i+1]\n\n ",
"i",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if ((bit >> i) & 1):\n f += '+'\n ",
"(bit >> i) & 1",
"bit >> i",
"bit",
"i",
"1",
"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",
"ans = 0",
"0",
"ans",
"f += '+'",
"'+'",
"f",
"ans += sum(map(int, f.split(\"+\")))",
"sum(map(int, f.split(\"+\")))",
"ans",
"f = s[0]",
"s[0]",
"f",
"l = len(s)",
"len(s)",
"l",
"s = list(input())",
"list(input())",
"s"
] | s = list(input())
l = len(s)
ans = 0
for bit in range(2 ** (l-1)):
f = s[0]
for i in range(l-1):
if ((bit >> i) & 1):
f += '+'
f += s[i+1]
ans += sum(map(int, f.split("+")))
print(ans) |
[
7,
15,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
18,
13,
13,
39,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
18,
13,
10,
17,
13
] | [
[
91,
4
],
[
97,
8
],
[
12,
11
],
[
23,
22
],
[
92,
26
],
[
106,
29
],
[
103,
32
],
[
92,
34
],
[
38,
37
],
[
92,
43
],
[
11,
48
],
[
37,
49
],
[
82,
52
],
[
92,
54
],
[
37,
56
],
[
94,
59
],
[
104,
62
],
[
86,
62
],
[
83,
62
],
[
85,
64
],
[
92,
66
],
[
37,
68
],
[
88,
71
],
[
86,
74
],
[
83,
74
],
[
104,
74
],
[
100,
76
],
[
89,
77
],
[
95,
77
],
[
107,
77
],
[
101,
80
],
[
98,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
89,
100
],
[
95,
100
],
[
107,
100
],
[
100,
101
],
[
103,
104
],
[
106,
107
]
] | [
"import itertools\ns = input()\nans=0\nfor i in list(itertools.product([0,1], repeat=len(s)-1)):\n b = 0\n a = s[0]\n for j in range(len(s)-1):\n if i[j] == 0:\n a+=s[j+1]\n else:\n b+=int(a)\n a=s[j+1]\n b+=int(a)\n ans+=b\nprint(ans)",
"import itertools",
"itertools",
"s = input()",
"s",
"input()",
"input",
"ans=0",
"ans",
"0",
"for i in list(itertools.product([0,1], repeat=len(s)-1)):\n b = 0\n a = s[0]\n for j in range(len(s)-1):\n if i[j] == 0:\n a+=s[j+1]\n else:\n b+=int(a)\n a=s[j+1]\n b+=int(a)\n ans+=b",
"i",
"list(itertools.product([0,1], repeat=len(s)-1))",
"list",
"itertools.product([0,1], repeat=len(s)-1)",
"itertools.product",
"itertools",
"product",
"[0,1]",
"0",
"1",
"repeat=len(s)-1",
"repeat",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"b = 0",
"b",
"0",
"a = s[0]",
"a",
"s[0]",
"s",
"0",
"for j in range(len(s)-1):\n if i[j] == 0:\n a+=s[j+1]\n else:\n b+=int(a)\n a=s[j+1]\n ",
"j",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if i[j] == 0:\n a+=s[j+1]\n else:\n b+=int(a)\n a=s[j+1]\n ",
"i[j] == 0",
"i[j]",
"i",
"j",
"0",
"a+=s[j+1]",
"a",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"b+=int(a)",
"b",
"int(a)",
"int",
"a",
"a=s[j+1]",
"a",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"b+=int(a)",
"b",
"int(a)",
"int",
"a",
"ans+=b",
"ans",
"b",
"print(ans)",
"print",
"ans",
"a+=s[j+1]",
"s[j+1]",
"a",
"a=s[j+1]",
"s[j+1]",
"a",
"b+=int(a)",
"int(a)",
"b",
"s = input()",
"input()",
"s",
"b+=int(a)",
"int(a)",
"b",
"ans=0",
"0",
"ans",
"ans+=b",
"b",
"ans",
"a = s[0]",
"s[0]",
"a",
"b = 0",
"0",
"b"
] | import itertools
s = input()
ans=0
for i in list(itertools.product([0,1], repeat=len(s)-1)):
b = 0
a = s[0]
for j in range(len(s)-1):
if i[j] == 0:
a+=s[j+1]
else:
b+=int(a)
a=s[j+1]
b+=int(a)
ans+=b
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
39,
0,
13,
39,
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,
4,
18,
13,
13,
13,
28,
13,
13,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
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,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13
] | [
[
127,
2
],
[
115,
6
],
[
128,
10
],
[
139,
13
],
[
118,
16
],
[
121,
19
],
[
23,
22
],
[
116,
27
],
[
142,
29
],
[
116,
33
],
[
36,
35
],
[
116,
38
],
[
22,
42
],
[
35,
43
],
[
49,
46
],
[
143,
47
],
[
35,
48
],
[
140,
52
],
[
143,
54
],
[
57,
56
],
[
140,
56
],
[
130,
59
],
[
133,
62
],
[
66,
65
],
[
116,
68
],
[
56,
72
],
[
65,
73
],
[
131,
77
],
[
128,
82
],
[
65,
86
],
[
136,
89
],
[
65,
91
],
[
131,
95
],
[
128,
100
],
[
128,
105
],
[
124,
107
],
[
131,
110
],
[
125,
113
],
[
122,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
]
] | [
"s=input()\nn=len(s)-1\nl=[]\nl3=[]\nSum=0\nfor i in range(2**n):\n bag=[\" \"]*n\n #print(\"pattern:\",i)\n for j in range(n):\n if ((i>>j) & 1):\n bag[j]=\"+\"\n l.append(bag)\n#print(l)\n\nfor b in l:\n ll=[]\n inc=0\n for ii in range(n):\n if b[ii] == \"+\":\n ll.append(int(s[inc:ii+1]))\n inc=ii+1\n ll.append(int(s[inc:len(s)]))\n #print(ll)\n Sum+=sum(ll)\nprint(Sum)",
"s=input()",
"s",
"input()",
"input",
"n=len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"l=[]",
"l",
"[]",
"l3=[]",
"l3",
"[]",
"Sum=0",
"Sum",
"0",
"for i in range(2**n):\n bag=[\" \"]*n\n #print(\"pattern:\",i)\n for j in range(n):\n if ((i>>j) & 1):\n bag[j]=\"+\"\n l.append(bag)\n#print(l)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"bag=[\" \"]*n",
"bag",
"[\" \"]*n",
"[\" \"]",
"\" \"",
"n",
"for j in range(n):\n if ((i>>j) & 1):\n bag[j]=\"+\"\n ",
"j",
"range(n)",
"range",
"n",
"if ((i>>j) & 1):\n bag[j]=\"+\"\n ",
"(i>>j) & 1",
"i>>j",
"i",
"j",
"1",
"bag[j]=\"+\"",
"bag[j]",
"bag",
"j",
"\"+\"",
"l.append(bag)",
"l.append",
"l",
"append",
"bag",
"for b in l:\n ll=[]\n inc=0\n for ii in range(n):\n if b[ii] == \"+\":\n ll.append(int(s[inc:ii+1]))\n inc=ii+1\n ll.append(int(s[inc:len(s)]))\n #print(ll)\n Sum+=sum(ll)",
"b",
"l",
"ll=[]",
"ll",
"[]",
"inc=0",
"inc",
"0",
"for ii in range(n):\n if b[ii] == \"+\":\n ll.append(int(s[inc:ii+1]))\n inc=ii+1\n ",
"ii",
"range(n)",
"range",
"n",
"if b[ii] == \"+\":\n ll.append(int(s[inc:ii+1]))\n inc=ii+1\n ",
"b[ii] == \"+\"",
"b[ii]",
"b",
"ii",
"\"+\"",
"ll.append(int(s[inc:ii+1]))",
"ll.append",
"ll",
"append",
"int(s[inc:ii+1])",
"int",
"s[inc:ii+1]",
"s",
"inc:ii+1",
"inc",
"ii+1",
"ii",
"1",
"inc=ii+1",
"inc",
"ii+1",
"ii",
"1",
"ll.append(int(s[inc:len(s)]))",
"ll.append",
"ll",
"append",
"int(s[inc:len(s)])",
"int",
"s[inc:len(s)]",
"s",
"inc:len(s)",
"inc",
"len(s)",
"len",
"s",
"Sum+=sum(ll)",
"Sum",
"sum(ll)",
"sum",
"ll",
"print(Sum)",
"print",
"Sum",
"n=len(s)-1",
"len(s)-1",
"n",
"l3=[]",
"[]",
"l3",
"Sum=0",
"0",
"Sum",
"Sum+=sum(ll)",
"sum(ll)",
"Sum",
"s=input()",
"input()",
"s",
"ll=[]",
"[]",
"ll",
"inc=0",
"0",
"inc",
"inc=ii+1",
"ii+1",
"inc",
"l=[]",
"[]",
"l",
"bag=[\" \"]*n",
"[\" \"]*n",
"bag"
] | s=input()
n=len(s)-1
l=[]
l3=[]
Sum=0
for i in range(2**n):
bag=[" "]*n
#print("pattern:",i)
for j in range(n):
if ((i>>j) & 1):
bag[j]="+"
l.append(bag)
#print(l)
for b in l:
ll=[]
inc=0
for ii in range(n):
if b[ii] == "+":
ll.append(int(s[inc:ii+1]))
inc=ii+1
ll.append(int(s[inc:len(s)]))
#print(ll)
Sum+=sum(ll)
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,
39,
4,
18,
13,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
17,
4,
18,
13,
13,
18,
13,
2,
13,
17,
4,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
39,
28,
13,
13,
14,
40,
13,
17,
4,
18,
13,
13,
13,
41,
28,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
41,
28,
13,
13,
4,
4,
13,
13,
0,
13,
13,
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,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
13,
13
] | [
[
139,
2
],
[
142,
6
],
[
140,
9
],
[
148,
11
],
[
15,
14
],
[
143,
20
],
[
157,
23
],
[
158,
27
],
[
140,
30
],
[
34,
33
],
[
143,
37
],
[
14,
42
],
[
33,
43
],
[
158,
47
],
[
158,
52
],
[
140,
55
],
[
33,
57
],
[
158,
61
],
[
140,
64
],
[
33,
66
],
[
151,
69
],
[
73,
72
],
[
158,
72
],
[
72,
76
],
[
152,
80
],
[
164,
80
],
[
72,
82
],
[
86,
85
],
[
152,
85
],
[
164,
85
],
[
85,
90
],
[
169,
92
],
[
160,
95
],
[
170,
100
],
[
161,
100
],
[
137,
100
],
[
146,
100
],
[
154,
102
],
[
161,
105
],
[
170,
105
],
[
137,
105
],
[
146,
105
],
[
163,
107
],
[
112,
111
],
[
164,
111
],
[
152,
111
],
[
111,
116
],
[
145,
118
],
[
136,
121
],
[
146,
126
],
[
161,
126
],
[
170,
126
],
[
137,
126
],
[
166,
128
],
[
137,
131
],
[
146,
131
],
[
161,
131
],
[
170,
131
],
[
167,
134
],
[
155,
134
],
[
149,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
]
] | [
"S=input()\nN=len(S)\ngoukei=0\nfor i in range(2 **(N-1)):\n T=[]\n T.append(S[0])\n for j in range(N-1):\n if ((i >> j) & 1):\n #print(i,j)のjbitがONの意味\n #print(i,j)\n T.append(\"+\")\n T.append(S[j+1])\n else:\n T.append(S[j+1])\n \n #T.append(S[N-1])\n #print(T)\n tmp=[]\n for m in T:\n if m!=\"+\":\n tmp.append(m)\n else:\n Z=[str(a) for a in tmp]\n Z=\"\".join(Z)\n goukei+=int(Z)\n tmp=[]\n Z=[str(a) for a in tmp]\n Z=\"\".join(Z)\n goukei+=int(Z)\n \nprint(goukei)",
"S=input()",
"S",
"input()",
"input",
"N=len(S)",
"N",
"len(S)",
"len",
"S",
"goukei=0",
"goukei",
"0",
"for i in range(2 **(N-1)):\n T=[]\n T.append(S[0])\n for j in range(N-1):\n if ((i >> j) & 1):\n #print(i,j)のjbitがONの意味\n #print(i,j)\n T.append(\"+\")\n T.append(S[j+1])\n else:\n T.append(S[j+1])\n \n #T.append(S[N-1])\n #print(T)\n tmp=[]\n for m in T:\n if m!=\"+\":\n tmp.append(m)\n else:\n Z=[str(a) for a in tmp]\n Z=\"\".join(Z)\n goukei+=int(Z)\n tmp=[]\n Z=[str(a) for a in tmp]\n Z=\"\".join(Z)\n goukei+=int(Z)\n ",
"i",
"range(2 **(N-1))",
"range",
"2 **(N-1)",
"2",
"N-1",
"N",
"1",
"T=[]",
"T",
"[]",
"T.append(S[0])",
"T.append",
"T",
"append",
"S[0]",
"S",
"0",
"for j in range(N-1):\n if ((i >> j) & 1):\n #print(i,j)のjbitがONの意味\n #print(i,j)\n T.append(\"+\")\n T.append(S[j+1])\n else:\n T.append(S[j+1])\n \n #T.append(S[N-1])\n #print(T)\n ",
"j",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if ((i >> j) & 1):\n #print(i,j)のjbitがONの意味\n #print(i,j)\n T.append(\"+\")\n T.append(S[j+1])\n else:\n T.append(S[j+1])\n \n #T.append(S[N-1])\n #print(T)\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"T.append(\"+\")",
"T.append",
"T",
"append",
"\"+\"",
"T.append(S[j+1])",
"T.append",
"T",
"append",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"T.append(S[j+1])",
"T.append",
"T",
"append",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"tmp=[]",
"tmp",
"[]",
"for m in T:\n if m!=\"+\":\n tmp.append(m)\n else:\n Z=[str(a) for a in tmp]\n Z=\"\".join(Z)\n goukei+=int(Z)\n tmp=[]\n ",
"m",
"T",
"if m!=\"+\":\n tmp.append(m)\n else:\n Z=[str(a) for a in tmp]\n Z=\"\".join(Z)\n goukei+=int(Z)\n tmp=[]\n ",
"m!=\"+\"",
"m",
"\"+\"",
"tmp.append(m)",
"tmp.append",
"tmp",
"append",
"m",
"str(a) for a in tmp",
"for a in tmp",
"a",
"tmp",
"for a in tmp",
"str(a)",
"str",
"a",
"Z=[str(a) for a in tmp]",
"Z",
"[str(a) for a in tmp]",
"Z=\"\".join(Z)",
"Z",
"\"\".join(Z)",
"\"\".join",
"\"\"",
"join",
"Z",
"goukei+=int(Z)",
"goukei",
"int(Z)",
"int",
"Z",
"tmp=[]",
"tmp",
"[]",
"str(a) for a in tmp",
"for a in tmp",
"a",
"tmp",
"for a in tmp",
"str(a)",
"str",
"a",
"Z=[str(a) for a in tmp]",
"Z",
"[str(a) for a in tmp]",
"Z=\"\".join(Z)",
"Z",
"\"\".join(Z)",
"\"\".join",
"\"\"",
"join",
"Z",
"goukei+=int(Z)",
"goukei",
"int(Z)",
"int",
"Z",
"print(goukei)",
"print",
"goukei",
"Z=\"\".join(Z)",
"\"\".join(Z)",
"Z",
"S=input()",
"input()",
"S",
"N=len(S)",
"len(S)",
"N",
"Z=[str(a) for a in tmp]",
"[str(a) for a in tmp]",
"Z",
"goukei=0",
"0",
"goukei",
"tmp=[]",
"[]",
"tmp",
"goukei+=int(Z)",
"int(Z)",
"goukei",
"T=[]",
"[]",
"T",
"Z=\"\".join(Z)",
"\"\".join(Z)",
"Z",
"tmp=[]",
"[]",
"tmp",
"goukei+=int(Z)",
"int(Z)",
"goukei",
"Z=[str(a) for a in tmp]",
"[str(a) for a in tmp]",
"Z"
] | S=input()
N=len(S)
goukei=0
for i in range(2 **(N-1)):
T=[]
T.append(S[0])
for j in range(N-1):
if ((i >> j) & 1):
#print(i,j)のjbitがONの意味
#print(i,j)
T.append("+")
T.append(S[j+1])
else:
T.append(S[j+1])
#T.append(S[N-1])
#print(T)
tmp=[]
for m in T:
if m!="+":
tmp.append(m)
else:
Z=[str(a) for a in tmp]
Z="".join(Z)
goukei+=int(Z)
tmp=[]
Z=[str(a) for a in tmp]
Z="".join(Z)
goukei+=int(Z)
print(goukei) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
14,
2,
13,
17,
4,
13,
4,
13,
13,
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,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
14,
40,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
14,
2,
40,
13,
17,
2,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13
] | [
[
117,
2
],
[
111,
6
],
[
118,
10
],
[
126,
13
],
[
112,
17
],
[
118,
23
],
[
26,
25
],
[
112,
30
],
[
132,
32
],
[
112,
36
],
[
39,
38
],
[
112,
41
],
[
25,
45
],
[
38,
46
],
[
52,
49
],
[
133,
50
],
[
38,
51
],
[
135,
54
],
[
118,
56
],
[
60,
59
],
[
112,
62
],
[
133,
66
],
[
59,
67
],
[
136,
71
],
[
121,
71
],
[
115,
71
],
[
129,
74
],
[
136,
77
],
[
121,
77
],
[
115,
77
],
[
114,
79
],
[
118,
81
],
[
59,
83
],
[
120,
86
],
[
118,
88
],
[
59,
90
],
[
121,
95
],
[
115,
95
],
[
136,
95
],
[
59,
98
],
[
112,
100
],
[
123,
103
],
[
121,
106
],
[
115,
106
],
[
136,
106
],
[
124,
109
],
[
130,
109
],
[
127,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
]
] | [
"s = input()\nnum = len(s)-1\nans = 0\n\nif num == 0:\n print(int(s))\nelse:\n for i in range(2**num):\n mode = ['-']*num\n for j in range(num):\n if (i>>j)&1:\n mode[j] = '+'\n val = s[0]\n for k in range(num):\n if mode[k] == '+':\n if val != '':\n ans += int(val)\n val = s[k+1]\n else:\n val += s[k+1]\n if val != '' and k == num-1:\n ans += int(val)\n print(ans)\n ",
"s = input()",
"s",
"input()",
"input",
"num = len(s)-1",
"num",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"if num == 0:\n print(int(s))\nelse:\n for i in range(2**num):\n mode = ['-']*num\n for j in range(num):\n if (i>>j)&1:\n mode[j] = '+'\n val = s[0]\n for k in range(num):\n if mode[k] == '+':\n if val != '':\n ans += int(val)\n val = s[k+1]\n else:\n val += s[k+1]\n if val != '' and k == num-1:\n ans += int(val)\n print(ans)\n ",
"num == 0",
"num",
"0",
"print(int(s))",
"print",
"int(s)",
"int",
"s",
"for i in range(2**num):\n mode = ['-']*num\n for j in range(num):\n if (i>>j)&1:\n mode[j] = '+'\n val = s[0]\n for k in range(num):\n if mode[k] == '+':\n if val != '':\n ans += int(val)\n val = s[k+1]\n else:\n val += s[k+1]\n if val != '' and k == num-1:\n ans += int(val)\n ",
"i",
"range(2**num)",
"range",
"2**num",
"2",
"num",
"mode = ['-']*num",
"mode",
"['-']*num",
"['-']",
"'-'",
"num",
"for j in range(num):\n if (i>>j)&1:\n mode[j] = '+'\n ",
"j",
"range(num)",
"range",
"num",
"if (i>>j)&1:\n mode[j] = '+'\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"mode[j] = '+'",
"mode[j]",
"mode",
"j",
"'+'",
"val = s[0]",
"val",
"s[0]",
"s",
"0",
"for k in range(num):\n if mode[k] == '+':\n if val != '':\n ans += int(val)\n val = s[k+1]\n else:\n val += s[k+1]\n if val != '' and k == num-1:\n ans += int(val)\n ",
"k",
"range(num)",
"range",
"num",
"if mode[k] == '+':\n if val != '':\n ans += int(val)\n val = s[k+1]\n else:\n val += s[k+1]\n ",
"mode[k] == '+'",
"mode[k]",
"mode",
"k",
"'+'",
"if val != '':\n ans += int(val)\n ",
"val != ''",
"val",
"''",
"ans += int(val)",
"ans",
"int(val)",
"int",
"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",
"if val != '' and k == num-1:\n ans += int(val)\n ",
"val != '' and k == num-1",
"val != ''",
"val",
"''",
"k == num-1",
"k",
"num-1",
"num",
"1",
"ans += int(val)",
"ans",
"int(val)",
"int",
"val",
"print(ans)",
"print",
"ans",
"num = len(s)-1",
"len(s)-1",
"num",
"val = s[k+1]",
"s[k+1]",
"val",
"s = input()",
"input()",
"s",
"val += s[k+1]",
"s[k+1]",
"val",
"ans += int(val)",
"int(val)",
"ans",
"ans = 0",
"0",
"ans",
"ans += int(val)",
"int(val)",
"ans",
"mode = ['-']*num",
"['-']*num",
"mode",
"val = s[0]",
"s[0]",
"val"
] | s = input()
num = len(s)-1
ans = 0
if num == 0:
print(int(s))
else:
for i in range(2**num):
mode = ['-']*num
for j in range(num):
if (i>>j)&1:
mode[j] = '+'
val = s[0]
for k in range(num):
if mode[k] == '+':
if val != '':
ans += int(val)
val = s[k+1]
else:
val += s[k+1]
if val != '' and k == num-1:
ans += int(val)
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,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
39,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
91,
2
],
[
70,
6
],
[
92,
9
],
[
88,
11
],
[
15,
14
],
[
71,
20
],
[
82,
23
],
[
76,
26
],
[
30,
29
],
[
71,
32
],
[
79,
34
],
[
92,
36
],
[
29,
37
],
[
14,
41
],
[
29,
42
],
[
83,
46
],
[
80,
50
],
[
77,
50
],
[
86,
50
],
[
85,
52
],
[
83,
56
],
[
86,
60
],
[
80,
60
],
[
77,
60
],
[
73,
62
],
[
83,
65
],
[
74,
68
],
[
89,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] | [
"S = input()\nN = len(S)\n\nans = 0\nfor i in range(2 ** (N - 1)):\n nums = []\n num = ''\n for j in range(N):\n num += S[j]\n if (i >> j) & 1:\n nums.append(int(num))\n num = ''\n else:\n nums.append(int(num))\n ans += sum(nums)\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 nums = []\n num = ''\n for j in range(N):\n num += S[j]\n if (i >> j) & 1:\n nums.append(int(num))\n num = ''\n else:\n nums.append(int(num))\n ans += sum(nums)",
"i",
"range(2 ** (N - 1))",
"range",
"2 ** (N - 1)",
"2",
"N - 1",
"N",
"1",
"nums = []",
"nums",
"[]",
"num = ''",
"num",
"''",
"for j in range(N):\n num += S[j]\n if (i >> j) & 1:\n nums.append(int(num))\n num = ''\n else:\n nums.append(int(num))\n ",
"j",
"range(N)",
"range",
"N",
"num += S[j]",
"num",
"S[j]",
"S",
"j",
"if (i >> j) & 1:\n nums.append(int(num))\n num = ''\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"nums.append(int(num))",
"nums.append",
"nums",
"append",
"int(num)",
"int",
"num",
"num = ''",
"num",
"''",
"nums.append(int(num))",
"nums.append",
"nums",
"append",
"int(num)",
"int",
"num",
"ans += sum(nums)",
"ans",
"sum(nums)",
"sum",
"nums",
"print(ans)",
"print",
"ans",
"N = len(S)",
"len(S)",
"N",
"ans += sum(nums)",
"sum(nums)",
"ans",
"num = ''",
"''",
"num",
"num += S[j]",
"S[j]",
"num",
"nums = []",
"[]",
"nums",
"num = ''",
"''",
"num",
"ans = 0",
"0",
"ans",
"S = input()",
"input()",
"S"
] | S = input()
N = len(S)
ans = 0
for i in range(2 ** (N - 1)):
nums = []
num = ''
for j in range(N):
num += S[j]
if (i >> j) & 1:
nums.append(int(num))
num = ''
else:
nums.append(int(num))
ans += sum(nums)
print(ans)
|
[
7,
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,
0,
13,
4,
13,
0,
13,
4,
13,
13,
4,
13,
4,
13,
17,
18,
13,
17,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
51,
5
],
[
53,
19
],
[
51,
27
],
[
53,
30
],
[
51,
34
],
[
51,
39
],
[
53,
43
],
[
51,
48
],
[
51,
51
],
[
53,
53
],
[
78,
55
],
[
72,
59
],
[
79,
62
],
[
76,
66
],
[
79,
69
],
[
72,
73
],
[
78,
79
]
] | [
"def dfs(i, f):\n if i == n - 1:\n return sum(list(map(int, f.split(\"+\"))))\n \n # 式 f の末尾に \"+\" を追加するかしないかして次の数字を追加\n return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])\n \n \ns = input()\nn = len(s)\n \nprint(dfs(0, s[0]))",
"def dfs(i, f):\n if i == n - 1:\n return sum(list(map(int, f.split(\"+\"))))\n \n # 式 f の末尾に \"+\" を追加するかしないかして次の数字を追加\n return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])\n \n ",
"dfs",
"if i == n - 1:\n return sum(list(map(int, f.split(\"+\"))))\n \n # 式 f の末尾に \"+\" を追加するかしないかして次の数字を追加\n ",
"i == n - 1",
"i",
"n - 1",
"n",
"1",
"return sum(list(map(int, f.split(\"+\"))))",
"sum(list(map(int, f.split(\"+\"))))",
"sum",
"list(map(int, f.split(\"+\")))",
"list",
"map(int, f.split(\"+\"))",
"map",
"int",
"f.split(\"+\")",
"f.split",
"f",
"split",
"\"+\"",
"return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])",
"dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])",
"dfs(i + 1, f + s[i + 1])",
"dfs",
"i + 1",
"i",
"1",
"f + s[i + 1]",
"f",
"s[i + 1]",
"s",
"i + 1",
"i",
"1",
"dfs(i + 1, f + \"+\" + s[i + 1])",
"dfs",
"i + 1",
"i",
"1",
"f + \"+\" + s[i + 1]",
"f + \"+\"",
"f",
"\"+\"",
"s[i + 1]",
"s",
"i + 1",
"i",
"1",
"i",
"i",
"f",
"f",
"s = input()",
"s",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"print(dfs(0, s[0]))",
"print",
"dfs(0, s[0])",
"dfs",
"0",
"s[0]",
"s",
"0",
"n = len(s)",
"len(s)",
"n",
"def dfs(i, f):\n if i == n - 1:\n return sum(list(map(int, f.split(\"+\"))))\n \n # 式 f の末尾に \"+\" を追加するかしないかして次の数字を追加\n return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])\n \n ",
"def dfs(i, f):\n if i == n - 1:\n return sum(list(map(int, f.split(\"+\"))))\n \n # 式 f の末尾に \"+\" を追加するかしないかして次の数字を追加\n return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])\n \n ",
"dfs",
"s = input()",
"input()",
"s"
] | def dfs(i, f):
if i == n - 1:
return sum(list(map(int, f.split("+"))))
# 式 f の末尾に "+" を追加するかしないかして次の数字を追加
return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + "+" + s[i + 1])
s = input()
n = len(s)
print(dfs(0, s[0])) |
[
7,
0,
13,
4,
18,
4,
13,
13,
0,
13,
39,
17,
28,
13,
4,
13,
17,
4,
18,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
4,
13,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
18,
13,
2,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13
] | [
[
86,
2
],
[
83,
9
],
[
14,
13
],
[
84,
19
],
[
84,
23
],
[
80,
25
],
[
29,
28
],
[
87,
33
],
[
36,
35
],
[
28,
39
],
[
87,
44
],
[
74,
47
],
[
87,
51
],
[
77,
56
],
[
75,
59
],
[
84,
61
],
[
28,
62
],
[
84,
64
],
[
87,
68
],
[
35,
69
],
[
78,
72
],
[
81,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] | [
"s = input().strip()\n\ncnt = [1]\nfor i in range(20):\n cnt.append(sum(cnt))\nans = 0\nfor i in range(len(s)):\n for f in range(i + 1, len(s) + 1):\n num = int(s[i:f])\n ans += num * cnt[i] * cnt[len(s) - f]\nprint(ans)",
"s = input().strip()",
"s",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"cnt = [1]",
"cnt",
"[1]",
"1",
"for i in range(20):\n cnt.append(sum(cnt))",
"i",
"range(20)",
"range",
"20",
"cnt.append(sum(cnt))",
"cnt.append",
"cnt",
"append",
"sum(cnt)",
"sum",
"cnt",
"ans = 0",
"ans",
"0",
"for i in range(len(s)):\n for f in range(i + 1, len(s) + 1):\n num = int(s[i:f])\n ans += num * cnt[i] * cnt[len(s) - f]",
"i",
"range(len(s))",
"range",
"len(s)",
"len",
"s",
"for f in range(i + 1, len(s) + 1):\n num = int(s[i:f])\n ans += num * cnt[i] * cnt[len(s) - f]",
"f",
"range(i + 1, len(s) + 1)",
"range",
"i + 1",
"i",
"1",
"len(s) + 1",
"len(s)",
"len",
"s",
"1",
"num = int(s[i:f])",
"num",
"int(s[i:f])",
"int",
"s[i:f]",
"s",
"i:f",
"i",
"f",
"ans += num * cnt[i] * cnt[len(s) - f]",
"ans",
"num * cnt[i] * cnt[len(s) - f]",
"num * cnt[i]",
"num",
"cnt[i]",
"cnt",
"i",
"cnt[len(s) - f]",
"cnt",
"len(s) - f",
"len(s)",
"len",
"s",
"f",
"print(ans)",
"print",
"ans",
"num = int(s[i:f])",
"int(s[i:f])",
"num",
"ans += num * cnt[i] * cnt[len(s) - f]",
"num * cnt[i] * cnt[len(s) - f]",
"ans",
"ans = 0",
"0",
"ans",
"cnt = [1]",
"[1]",
"cnt",
"s = input().strip()",
"input().strip()",
"s"
] | s = input().strip()
cnt = [1]
for i in range(20):
cnt.append(sum(cnt))
ans = 0
for i in range(len(s)):
for f in range(i + 1, len(s) + 1):
num = int(s[i:f])
ans += num * cnt[i] * cnt[len(s) - f]
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,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
2,
17,
13,
0,
13,
13,
0,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
2,
13,
17,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
85,
2
],
[
97,
6
],
[
86,
10
],
[
79,
13
],
[
17,
16
],
[
98,
21
],
[
82,
23
],
[
88,
26
],
[
30,
29
],
[
98,
33
],
[
16,
37
],
[
29,
40
],
[
73,
42
],
[
89,
43
],
[
77,
43
],
[
76,
45
],
[
29,
47
],
[
91,
50
],
[
86,
54
],
[
94,
59
],
[
86,
63
],
[
98,
67
],
[
95,
71
],
[
92,
71
],
[
80,
71
],
[
89,
73
],
[
77,
73
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"s=input()\nn=len(s)-1\nsum=0\nfor bit in range(1<<n):\n\tleft=0\n\tright=0\n\tfor i in range(n+1):\n\t\tif (bit & (1<<i)):\n\t\t\tleft=right\n\t\t\tright=i+1\n\t\t\tsum+=int(s[left:right])\n\tsum+=int(s[right:n+1])\nprint(sum)",
"s=input()",
"s",
"input()",
"input",
"n=len(s)-1",
"n",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"sum=0",
"sum",
"0",
"for bit in range(1<<n):\n\tleft=0\n\tright=0\n\tfor i in range(n+1):\n\t\tif (bit & (1<<i)):\n\t\t\tleft=right\n\t\t\tright=i+1\n\t\t\tsum+=int(s[left:right])\n\tsum+=int(s[right:n+1])",
"bit",
"range(1<<n)",
"range",
"1<<n",
"1",
"n",
"left=0",
"left",
"0",
"right=0",
"right",
"0",
"for i in range(n+1):\n\t\tif (bit & (1<<i)):\n\t\t\tleft=right\n\t\t\tright=i+1\n\t\t\tsum+=int(s[left:right])\n\t",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if (bit & (1<<i)):\n\t\t\tleft=right\n\t\t\tright=i+1\n\t\t\tsum+=int(s[left:right])\n\t",
"bit & (1<<i)",
"bit",
"1<<i",
"1",
"i",
"left=right",
"left",
"right",
"right=i+1",
"right",
"i+1",
"i",
"1",
"sum+=int(s[left:right])",
"sum",
"int(s[left:right])",
"int",
"s[left:right]",
"s",
"left:right",
"left",
"right",
"sum+=int(s[right:n+1])",
"sum",
"int(s[right:n+1])",
"int",
"s[right:n+1]",
"s",
"right:n+1",
"right",
"n+1",
"n",
"1",
"print(sum)",
"print",
"sum",
"left=right",
"right",
"left",
"right=i+1",
"i+1",
"right",
"sum=0",
"0",
"sum",
"left=0",
"0",
"left",
"s=input()",
"input()",
"s",
"right=0",
"0",
"right",
"sum+=int(s[left:right])",
"int(s[left:right])",
"sum",
"sum+=int(s[right:n+1])",
"int(s[right:n+1])",
"sum",
"n=len(s)-1",
"len(s)-1",
"n"
] | s=input()
n=len(s)-1
sum=0
for bit in range(1<<n):
left=0
right=0
for i in range(n+1):
if (bit & (1<<i)):
left=right
right=i+1
sum+=int(s[left:right])
sum+=int(s[right:n+1])
print(sum) |
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
2,
17,
13,
14,
2,
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,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
12,
11
],
[
4,
19
],
[
23,
22
],
[
26,
25
],
[
4,
31
],
[
35,
34
],
[
25,
37
],
[
11,
40
],
[
34,
41
],
[
44,
43
],
[
4,
47
],
[
25,
51
],
[
55,
54
],
[
25,
56
],
[
60,
59
],
[
4,
63
],
[
59,
68
],
[
43,
68
],
[
8,
68
],
[
77,
74
]
] | [
"def main():\n # S = list(input())\n S = input()\n\n sum_ = 0\n for bit in range(1 << len(S)-1):\n pre = 0\n for i in range(len(S)-1):\n mask = 1 << i\n if (bit & mask):\n # print(S[pre:i+1])\n sum_ += int(S[pre:i+1])\n pre = i+1\n # print('bit:', bin(bit))\n # print('mask', bin(mask))\n # print(S[pre:])\n sum_ += int(S[pre:])\n print(sum_)\n\n\nif(__name__ == '__main__'):\n main()",
"def main():\n # S = list(input())\n S = input()\n\n sum_ = 0\n for bit in range(1 << len(S)-1):\n pre = 0\n for i in range(len(S)-1):\n mask = 1 << i\n if (bit & mask):\n # print(S[pre:i+1])\n sum_ += int(S[pre:i+1])\n pre = i+1\n # print('bit:', bin(bit))\n # print('mask', bin(mask))\n # print(S[pre:])\n sum_ += int(S[pre:])\n print(sum_)",
"main",
"S = input()",
"S",
"input()",
"input",
"sum_ = 0",
"sum_",
"0",
"for bit in range(1 << len(S)-1):\n pre = 0\n for i in range(len(S)-1):\n mask = 1 << i\n if (bit & mask):\n # print(S[pre:i+1])\n sum_ += int(S[pre:i+1])\n pre = i+1\n # print('bit:', bin(bit))\n # print('mask', bin(mask))\n # print(S[pre:])\n sum_ += int(S[pre:])\n ",
"bit",
"range(1 << len(S)-1)",
"range",
"1 << len(S)-1",
"1",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"pre = 0",
"pre",
"0",
"for i in range(len(S)-1):\n mask = 1 << i\n if (bit & mask):\n # print(S[pre:i+1])\n sum_ += int(S[pre:i+1])\n pre = i+1\n # print('bit:', bin(bit))\n # print('mask', bin(mask))\n # print(S[pre:])\n ",
"i",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"mask = 1 << i",
"mask",
"1 << i",
"1",
"i",
"if (bit & mask):\n # print(S[pre:i+1])\n sum_ += int(S[pre:i+1])\n pre = i+1\n # print('bit:', bin(bit))\n # print('mask', bin(mask))\n # print(S[pre:])\n ",
"bit & mask",
"bit",
"mask",
"sum_ += int(S[pre:i+1])",
"sum_",
"int(S[pre:i+1])",
"int",
"S[pre:i+1]",
"S",
"pre:i+1",
"pre",
"i+1",
"i",
"1",
"pre = i+1",
"pre",
"i+1",
"i",
"1",
"sum_ += int(S[pre:])",
"sum_",
"int(S[pre:])",
"int",
"S[pre:]",
"S",
"pre:",
"pre",
"print(sum_)",
"print",
"sum_",
"if(__name__ == '__main__'):\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n # S = list(input())\n S = input()\n\n sum_ = 0\n for bit in range(1 << len(S)-1):\n pre = 0\n for i in range(len(S)-1):\n mask = 1 << i\n if (bit & mask):\n # print(S[pre:i+1])\n sum_ += int(S[pre:i+1])\n pre = i+1\n # print('bit:', bin(bit))\n # print('mask', bin(mask))\n # print(S[pre:])\n sum_ += int(S[pre:])\n print(sum_)",
"def main():\n # S = list(input())\n S = input()\n\n sum_ = 0\n for bit in range(1 << len(S)-1):\n pre = 0\n for i in range(len(S)-1):\n mask = 1 << i\n if (bit & mask):\n # print(S[pre:i+1])\n sum_ += int(S[pre:i+1])\n pre = i+1\n # print('bit:', bin(bit))\n # print('mask', bin(mask))\n # print(S[pre:])\n sum_ += int(S[pre:])\n print(sum_)",
"main"
] | def main():
# S = list(input())
S = input()
sum_ = 0
for bit in range(1 << len(S)-1):
pre = 0
for i in range(len(S)-1):
mask = 1 << i
if (bit & mask):
# print(S[pre:i+1])
sum_ += int(S[pre:i+1])
pre = i+1
# print('bit:', bin(bit))
# print('mask', bin(mask))
# print(S[pre:])
sum_ += int(S[pre:])
print(sum_)
if(__name__ == '__main__'):
main() |
[
7,
15,
4,
13,
2,
17,
17,
12,
13,
12,
13,
14,
2,
4,
13,
13,
17,
29,
2,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
17,
0,
13,
17,
14,
2,
17,
4,
13,
13,
0,
13,
18,
13,
39,
0,
13,
4,
13,
13,
17,
2,
13,
4,
13,
13,
0,
13,
18,
13,
39,
0,
13,
4,
13,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
17,
17,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
70,
15
],
[
72,
21
],
[
74,
22
],
[
25,
24
],
[
70,
27
],
[
32,
31
],
[
70,
38
],
[
41,
40
],
[
70,
42
],
[
46,
45
],
[
40,
48
],
[
74,
51
],
[
24,
54
],
[
72,
54
],
[
57,
56
],
[
70,
58
],
[
62,
61
],
[
56,
64
],
[
40,
64
],
[
24,
65
],
[
72,
65
],
[
74,
66
],
[
61,
68
],
[
45,
68
],
[
31,
68
],
[
70,
70
],
[
72,
72
],
[
74,
74
],
[
104,
76
],
[
96,
78
],
[
98,
80
],
[
105,
83
],
[
107,
85
],
[
102,
87
],
[
99,
88
],
[
108,
93
],
[
98,
99
],
[
104,
105
],
[
107,
108
]
] | [
"from sys import stdin,setrecursionlimit\nsetrecursionlimit(10**6)\ndef S(): return stdin.readline().rstrip()\n\ndef f(ls,stock,save):\n if len(ls)<1:\n return int(stock)+save\n else:\n stock += ls.pop(0)\n sum = 0 \n if 0<len(ls):\n buff = ls[:]\n sum += f(buff,'0',save+int(stock))\n buff = ls[:]\n sum += f(buff,stock,save)\n return sum\n\ns = S()\nls = list(s)\nans = f(ls,'0',0)\nprint(ans)",
"from sys import stdin,setrecursionlimit",
"setrecursionlimit(10**6)",
"setrecursionlimit",
"10**6",
"10",
"6",
"def S(): return stdin.readline().rstrip()",
"S",
"def f(ls,stock,save):\n if len(ls)<1:\n return int(stock)+save\n else:\n stock += ls.pop(0)\n sum = 0 \n if 0<len(ls):\n buff = ls[:]\n sum += f(buff,'0',save+int(stock))\n buff = ls[:]\n sum += f(buff,stock,save)\n return sum",
"f",
"if len(ls)<1:\n return int(stock)+save\n else:\n stock += ls.pop(0)\n sum = 0 \n if 0<len(ls):\n buff = ls[:]\n sum += f(buff,'0',save+int(stock))\n buff = ls[:]\n sum += f(buff,stock,save)\n return sum",
"len(ls)<1",
"len(ls)",
"len",
"ls",
"1",
"return int(stock)+save",
"int(stock)+save",
"int(stock)",
"int",
"stock",
"save",
"stock += ls.pop(0)",
"stock",
"ls.pop(0)",
"ls.pop",
"ls",
"pop",
"0",
"sum = 0",
"sum",
"0",
"if 0<len(ls):\n buff = ls[:]\n sum += f(buff,'0',save+int(stock))\n ",
"0<len(ls)",
"0",
"len(ls)",
"len",
"ls",
"buff = ls[:]",
"buff",
"ls[:]",
"ls",
":",
"sum += f(buff,'0',save+int(stock))",
"sum",
"f(buff,'0',save+int(stock))",
"f",
"buff",
"'0'",
"save+int(stock)",
"save",
"int(stock)",
"int",
"stock",
"buff = ls[:]",
"buff",
"ls[:]",
"ls",
":",
"sum += f(buff,stock,save)",
"sum",
"f(buff,stock,save)",
"f",
"buff",
"stock",
"save",
"return sum",
"sum",
"ls",
"ls",
"stock",
"stock",
"save",
"save",
"s = S()",
"s",
"S()",
"S",
"ls = list(s)",
"ls",
"list(s)",
"list",
"s",
"ans = f(ls,'0',0)",
"ans",
"f(ls,'0',0)",
"f",
"ls",
"'0'",
"0",
"print(ans)",
"print",
"ans",
"def S(): return stdin.readline().rstrip()",
"def S(): return stdin.readline().rstrip()",
"S",
"ls = list(s)",
"list(s)",
"ls",
"def f(ls,stock,save):\n if len(ls)<1:\n return int(stock)+save\n else:\n stock += ls.pop(0)\n sum = 0 \n if 0<len(ls):\n buff = ls[:]\n sum += f(buff,'0',save+int(stock))\n buff = ls[:]\n sum += f(buff,stock,save)\n return sum",
"def f(ls,stock,save):\n if len(ls)<1:\n return int(stock)+save\n else:\n stock += ls.pop(0)\n sum = 0 \n if 0<len(ls):\n buff = ls[:]\n sum += f(buff,'0',save+int(stock))\n buff = ls[:]\n sum += f(buff,stock,save)\n return sum",
"f",
"s = S()",
"S()",
"s",
"ans = f(ls,'0',0)",
"f(ls,'0',0)",
"ans"
] | from sys import stdin,setrecursionlimit
setrecursionlimit(10**6)
def S(): return stdin.readline().rstrip()
def f(ls,stock,save):
if len(ls)<1:
return int(stock)+save
else:
stock += ls.pop(0)
sum = 0
if 0<len(ls):
buff = ls[:]
sum += f(buff,'0',save+int(stock))
buff = ls[:]
sum += f(buff,stock,save)
return sum
s = S()
ls = list(s)
ans = f(ls,'0',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,
13,
4,
13,
18,
13,
39,
17,
0,
13,
8,
2,
2,
2,
13,
13,
17,
17,
17,
17,
0,
13,
8,
13,
13,
2,
17,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
8,
13,
10,
17,
13,
10,
4,
13,
10,
8,
13
] | [
[
65,
2
],
[
68,
6
],
[
66,
10
],
[
77,
13
],
[
17,
16
],
[
69,
21
],
[
71,
23
],
[
66,
25
],
[
66,
33
],
[
83,
37
],
[
16,
42
],
[
74,
49
],
[
84,
51
],
[
80,
57
],
[
75,
60
],
[
72,
60
],
[
81,
63
],
[
78,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
]
] | [
"s=input()\nl=len(s)-1\nres = 0\n\nfor i in range(2**l):\n s_new = s[0]\n for j, c in enumerate(s[1:]):\n flag = True if (i>>j)%2==1 else False\n s_new += c if flag else \"+\"+c\n res += eval(s_new)\nprint(res)",
"s=input()",
"s",
"input()",
"input",
"l=len(s)-1",
"l",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"res = 0",
"res",
"0",
"for i in range(2**l):\n s_new = s[0]\n for j, c in enumerate(s[1:]):\n flag = True if (i>>j)%2==1 else False\n s_new += c if flag else \"+\"+c\n res += eval(s_new)",
"i",
"range(2**l)",
"range",
"2**l",
"2",
"l",
"s_new = s[0]",
"s_new",
"s[0]",
"s",
"0",
"for j, c in enumerate(s[1:]):\n flag = True if (i>>j)%2==1 else False\n s_new += c if flag else \"+\"+c\n ",
"j",
"c",
"enumerate(s[1:])",
"enumerate",
"s[1:]",
"s",
"1:",
"1",
"flag = True if (i>>j)%2==1 else False",
"flag",
"True if (i>>j)%2==1 else False",
"(i>>j)%2==1",
"(i>>j)%2",
"i>>j",
"i",
"j",
"2",
"1",
"True",
"False",
"s_new += c if flag else \"+\"+c",
"s_new",
"c if flag else \"+\"+c",
"flag",
"c",
"\"+\"+c",
"\"+\"",
"c",
"res += eval(s_new)",
"res",
"eval(s_new)",
"eval",
"s_new",
"print(res)",
"print",
"res",
"s=input()",
"input()",
"s",
"l=len(s)-1",
"len(s)-1",
"l",
"s_new = s[0]",
"s[0]",
"s_new",
"s_new += c if flag else \"+\"+c",
"c if flag else \"+\"+c",
"s_new",
"res = 0",
"0",
"res",
"res += eval(s_new)",
"eval(s_new)",
"res",
"flag = True if (i>>j)%2==1 else False",
"True if (i>>j)%2==1 else False",
"flag"
] | s=input()
l=len(s)-1
res = 0
for i in range(2**l):
s_new = s[0]
for j, c in enumerate(s[1:]):
flag = True if (i>>j)%2==1 else False
s_new += c if flag else "+"+c
res += eval(s_new)
print(res)
|
[
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,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
86,
2
],
[
77,
8
],
[
12,
11
],
[
87,
19
],
[
80,
22
],
[
87,
28
],
[
89,
30
],
[
34,
33
],
[
87,
39
],
[
11,
44
],
[
33,
45
],
[
51,
48
],
[
81,
49
],
[
33,
50
],
[
54,
53
],
[
87,
58
],
[
92,
60
],
[
87,
63
],
[
53,
64
],
[
81,
66
],
[
53,
67
],
[
83,
69
],
[
93,
72
],
[
90,
72
],
[
84,
75
],
[
78,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
]
] | [
"s = list(input())\n\nans = 0\nfor i in range(2**(len(s)-1)):\n p = ['']*len(s)\n f = ''\n for j in range(len(s)-1):\n if (i>>j & 1):\n p[j] = '+'\n \n for i in range(len(s)):\n f += s[i] + p[i]\n ans += eval(f)\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 p = ['']*len(s)\n f = ''\n for j in range(len(s)-1):\n if (i>>j & 1):\n p[j] = '+'\n \n for i in range(len(s)):\n f += s[i] + p[i]\n ans += eval(f)\n ",
"i",
"range(2**(len(s)-1))",
"range",
"2**(len(s)-1)",
"2",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"p = ['']*len(s)",
"p",
"['']*len(s)",
"['']",
"''",
"len(s)",
"len",
"s",
"f = ''",
"f",
"''",
"for j in range(len(s)-1):\n if (i>>j & 1):\n p[j] = '+'\n \n ",
"j",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if (i>>j & 1):\n p[j] = '+'\n \n ",
"i>>j & 1",
"i>>j",
"i",
"j",
"1",
"p[j] = '+'",
"p[j]",
"p",
"j",
"'+'",
"for i in range(len(s)):\n f += s[i] + p[i]\n ",
"i",
"range(len(s))",
"range",
"len(s)",
"len",
"s",
"f += s[i] + p[i]",
"f",
"s[i] + p[i]",
"s[i]",
"s",
"i",
"p[i]",
"p",
"i",
"ans += eval(f)",
"ans",
"eval(f)",
"eval",
"f",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"p = ['']*len(s)",
"['']*len(s)",
"p",
"ans += eval(f)",
"eval(f)",
"ans",
"s = list(input())",
"list(input())",
"s",
"f = ''",
"''",
"f",
"f += s[i] + p[i]",
"s[i] + p[i]",
"f"
] | s = list(input())
ans = 0
for i in range(2**(len(s)-1)):
p = ['']*len(s)
f = ''
for j in range(len(s)-1):
if (i>>j & 1):
p[j] = '+'
for i in range(len(s)):
f += s[i] + p[i]
ans += eval(f)
print(ans) |
[
7,
15,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
18,
13,
13,
39,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
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,
17,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
92,
4
],
[
83,
8
],
[
20,
19
],
[
93,
23
],
[
104,
26
],
[
30,
29
],
[
84,
29
],
[
86,
32
],
[
89,
35
],
[
39,
38
],
[
93,
44
],
[
29,
49
],
[
38,
50
],
[
107,
53
],
[
93,
57
],
[
38,
61
],
[
98,
64
],
[
38,
66
],
[
101,
69
],
[
93,
73
],
[
95,
77
],
[
102,
78
],
[
108,
78
],
[
90,
78
],
[
96,
81
],
[
105,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
102,
95
],
[
108,
95
],
[
90,
95
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
]
] | [
"import itertools\nS=input()\nlis = list(itertools.product([0,1], repeat=len(S)-1))\nans=0\nfor li in lis:\n st=0\n x=0\n for i in range(len(S)-1):\n if li[i]==1:\n x += int(S[st:i+1])\n st = i+1\n \n x += int(S[st:])\n \n ans += x \nprint(ans)",
"import itertools",
"itertools",
"S=input()",
"S",
"input()",
"input",
"lis = list(itertools.product([0,1], repeat=len(S)-1))",
"lis",
"list(itertools.product([0,1], repeat=len(S)-1))",
"list",
"itertools.product([0,1], repeat=len(S)-1)",
"itertools.product",
"itertools",
"product",
"[0,1]",
"0",
"1",
"repeat=len(S)-1",
"repeat",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"ans=0",
"ans",
"0",
"for li in lis:\n st=0\n x=0\n for i in range(len(S)-1):\n if li[i]==1:\n x += int(S[st:i+1])\n st = i+1\n \n x += int(S[st:])\n \n ans += x ",
"li",
"lis",
"st=0",
"st",
"0",
"x=0",
"x",
"0",
"for i in range(len(S)-1):\n if li[i]==1:\n x += int(S[st:i+1])\n st = i+1\n \n ",
"i",
"range(len(S)-1)",
"range",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"if li[i]==1:\n x += int(S[st:i+1])\n st = i+1\n \n ",
"li[i]==1",
"li[i]",
"li",
"i",
"1",
"x += int(S[st:i+1])",
"x",
"int(S[st:i+1])",
"int",
"S[st:i+1]",
"S",
"st:i+1",
"st",
"i+1",
"i",
"1",
"st = i+1",
"st",
"i+1",
"i",
"1",
"x += int(S[st:])",
"x",
"int(S[st:])",
"int",
"S[st:]",
"S",
"st:",
"st",
"ans += x",
"ans",
"x",
"print(ans)",
"print",
"ans",
"lis = list(itertools.product([0,1], repeat=len(S)-1))",
"list(itertools.product([0,1], repeat=len(S)-1))",
"lis",
"st=0",
"0",
"st",
"x=0",
"0",
"x",
"S=input()",
"input()",
"S",
"ans += x",
"x",
"ans",
"st = i+1",
"i+1",
"st",
"x += int(S[st:])",
"int(S[st:])",
"x",
"ans=0",
"0",
"ans",
"x += int(S[st:i+1])",
"int(S[st:i+1])",
"x"
] | import itertools
S=input()
lis = list(itertools.product([0,1], repeat=len(S)-1))
ans=0
for li in lis:
st=0
x=0
for i in range(len(S)-1):
if li[i]==1:
x += int(S[st:i+1])
st = i+1
x += int(S[st:])
ans += x
print(ans)
|
[
7,
0,
13,
4,
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,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
2,
13,
39,
17,
0,
13,
2,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
91,
2
],
[
79,
8
],
[
88,
11
],
[
92,
15
],
[
19,
18
],
[
89,
23
],
[
94,
25
],
[
89,
29
],
[
32,
31
],
[
89,
34
],
[
18,
38
],
[
31,
39
],
[
45,
42
],
[
95,
43
],
[
31,
44
],
[
85,
47
],
[
92,
54
],
[
95,
56
],
[
82,
60
],
[
97,
65
],
[
76,
68
],
[
98,
71
],
[
83,
71
],
[
86,
71
],
[
77,
74
],
[
80,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"S=list(input())\ns=0\nop_count=len(S)-1\nfor i in range(2**op_count) :\n op=[\"\"]*op_count\n for j in range(op_count) :\n if (i>>j) & 1 :\n op[j]=\"+\"\n \n formula=\"\"\n for p,q in zip(S,op+[\"+\"]) :\n formula+=(p+q)\n formula+=\"0\"\n s+=eval(formula)\nprint(s)",
"S=list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"s=0",
"s",
"0",
"op_count=len(S)-1",
"op_count",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"for i in range(2**op_count) :\n op=[\"\"]*op_count\n for j in range(op_count) :\n if (i>>j) & 1 :\n op[j]=\"+\"\n \n formula=\"\"\n for p,q in zip(S,op+[\"+\"]) :\n formula+=(p+q)\n formula+=\"0\"\n s+=eval(formula)",
"i",
"range(2**op_count)",
"range",
"2**op_count",
"2",
"op_count",
"op=[\"\"]*op_count",
"op",
"[\"\"]*op_count",
"[\"\"]",
"\"\"",
"op_count",
"for j in range(op_count) :\n if (i>>j) & 1 :\n op[j]=\"+\"\n \n ",
"j",
"range(op_count)",
"range",
"op_count",
"if (i>>j) & 1 :\n op[j]=\"+\"\n \n ",
"(i>>j) & 1",
"i>>j",
"i",
"j",
"1",
"op[j]=\"+\"",
"op[j]",
"op",
"j",
"\"+\"",
"formula=\"\"",
"formula",
"\"\"",
"for p,q in zip(S,op+[\"+\"]) :\n formula+=(p+q)\n ",
"p",
"q",
"zip(S,op+[\"+\"])",
"zip",
"S",
"op+[\"+\"]",
"op",
"[\"+\"]",
"\"+\"",
"formula+=(p+q)",
"formula",
"p+q",
"p",
"q",
"formula+=\"0\"",
"formula",
"\"0\"",
"s+=eval(formula)",
"s",
"eval(formula)",
"eval",
"formula",
"print(s)",
"print",
"s",
"s+=eval(formula)",
"eval(formula)",
"s",
"s=0",
"0",
"s",
"formula+=(p+q)",
"p+q",
"formula",
"formula=\"\"",
"\"\"",
"formula",
"op_count=len(S)-1",
"len(S)-1",
"op_count",
"S=list(input())",
"list(input())",
"S",
"op=[\"\"]*op_count",
"[\"\"]*op_count",
"op",
"formula+=\"0\"",
"\"0\"",
"formula"
] | S=list(input())
s=0
op_count=len(S)-1
for i in range(2**op_count) :
op=[""]*op_count
for j in range(op_count) :
if (i>>j) & 1 :
op[j]="+"
formula=""
for p,q in zip(S,op+["+"]) :
formula+=(p+q)
formula+="0"
s+=eval(formula)
print(s)
|
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
14,
2,
13,
17,
4,
13,
4,
13,
13,
29,
28,
13,
4,
13,
2,
17,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
14,
2,
2,
2,
13,
13,
17,
17,
0,
18,
13,
2,
2,
13,
17,
13,
17,
0,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
2,
13,
17,
14,
2,
18,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
14,
2,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
4,
12
],
[
16,
15
],
[
8,
19
],
[
4,
25
],
[
29,
28
],
[
8,
33
],
[
36,
35
],
[
8,
39
],
[
42,
41
],
[
8,
44
],
[
28,
49
],
[
41,
50
],
[
61,
54
],
[
35,
55
],
[
8,
58
],
[
41,
60
],
[
64,
63
],
[
67,
66
],
[
4,
68
],
[
72,
71
],
[
8,
74
],
[
35,
78
],
[
71,
79
],
[
83,
82
],
[
4,
84
],
[
71,
86
],
[
35,
91
],
[
71,
92
],
[
96,
95
],
[
82,
98
],
[
66,
98
],
[
100,
98
],
[
101,
100
],
[
4,
102
],
[
71,
104
],
[
71,
108
],
[
8,
110
],
[
114,
113
],
[
100,
116
],
[
82,
116
],
[
66,
116
],
[
119,
118
],
[
113,
119
],
[
95,
119
],
[
63,
119
],
[
118,
122
],
[
15,
122
],
[
131,
128
]
] | [
"def main():\n S = input()\n n = len(S) - 1\n ans = 0\n\n if n == 0:\n print(int(S))\n return\n\n for i in range(2 ** n):\n plus_lst = [0] * n\n for j in range(n):\n if (i >> j) & 1 == 1:\n plus_lst[n - 1 - j] = 1 # 0: \"\", 1: \"+\"\n\n res = 0\n num = S[0]\n for j in range(n):\n if plus_lst[j] == 0:\n num += S[j + 1]\n\n if plus_lst[j] == 1:\n res += int(num)\n num = S[j + 1]\n\n if j == n - 1:\n res += int(num)\n\n ans += res\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 if n == 0:\n print(int(S))\n return\n\n for i in range(2 ** n):\n plus_lst = [0] * n\n for j in range(n):\n if (i >> j) & 1 == 1:\n plus_lst[n - 1 - j] = 1 # 0: \"\", 1: \"+\"\n\n res = 0\n num = S[0]\n for j in range(n):\n if plus_lst[j] == 0:\n num += S[j + 1]\n\n if plus_lst[j] == 1:\n res += int(num)\n num = S[j + 1]\n\n if j == n - 1:\n res += int(num)\n\n ans += res\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",
"if n == 0:\n print(int(S))\n return\n\n ",
"n == 0",
"n",
"0",
"print(int(S))",
"print",
"int(S)",
"int",
"S",
"return",
"for i in range(2 ** n):\n plus_lst = [0] * n\n for j in range(n):\n if (i >> j) & 1 == 1:\n plus_lst[n - 1 - j] = 1 # 0: \"\", 1: \"+\"\n\n res = 0\n num = S[0]\n for j in range(n):\n if plus_lst[j] == 0:\n num += S[j + 1]\n\n if plus_lst[j] == 1:\n res += int(num)\n num = S[j + 1]\n\n if j == n - 1:\n res += int(num)\n\n ans += res\n\n ",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"plus_lst = [0] * n",
"plus_lst",
"[0] * n",
"[0]",
"0",
"n",
"for j in range(n):\n if (i >> j) & 1 == 1:\n plus_lst[n - 1 - j] = 1 # 0: \"\", 1: \"+\"\n\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1 == 1:\n plus_lst[n - 1 - j] = 1 # 0: \"\", 1: \"+\"\n\n ",
"(i >> j) & 1 == 1",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"1",
"plus_lst[n - 1 - j] = 1",
"plus_lst[n - 1 - j]",
"plus_lst",
"n - 1 - j",
"n - 1",
"n",
"1",
"j",
"1",
"res = 0",
"res",
"0",
"num = S[0]",
"num",
"S[0]",
"S",
"0",
"for j in range(n):\n if plus_lst[j] == 0:\n num += S[j + 1]\n\n if plus_lst[j] == 1:\n res += int(num)\n num = S[j + 1]\n\n if j == n - 1:\n res += int(num)\n\n ",
"j",
"range(n)",
"range",
"n",
"if plus_lst[j] == 0:\n num += S[j + 1]\n\n ",
"plus_lst[j] == 0",
"plus_lst[j]",
"plus_lst",
"j",
"0",
"num += S[j + 1]",
"num",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"if plus_lst[j] == 1:\n res += int(num)\n num = S[j + 1]\n\n ",
"plus_lst[j] == 1",
"plus_lst[j]",
"plus_lst",
"j",
"1",
"res += int(num)",
"res",
"int(num)",
"int",
"num",
"num = S[j + 1]",
"num",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"if j == n - 1:\n res += int(num)\n\n ",
"j == n - 1",
"j",
"n - 1",
"n",
"1",
"res += int(num)",
"res",
"int(num)",
"int",
"num",
"ans += res",
"ans",
"res",
"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 if n == 0:\n print(int(S))\n return\n\n for i in range(2 ** n):\n plus_lst = [0] * n\n for j in range(n):\n if (i >> j) & 1 == 1:\n plus_lst[n - 1 - j] = 1 # 0: \"\", 1: \"+\"\n\n res = 0\n num = S[0]\n for j in range(n):\n if plus_lst[j] == 0:\n num += S[j + 1]\n\n if plus_lst[j] == 1:\n res += int(num)\n num = S[j + 1]\n\n if j == n - 1:\n res += int(num)\n\n ans += res\n\n print(ans)",
"def main():\n S = input()\n n = len(S) - 1\n ans = 0\n\n if n == 0:\n print(int(S))\n return\n\n for i in range(2 ** n):\n plus_lst = [0] * n\n for j in range(n):\n if (i >> j) & 1 == 1:\n plus_lst[n - 1 - j] = 1 # 0: \"\", 1: \"+\"\n\n res = 0\n num = S[0]\n for j in range(n):\n if plus_lst[j] == 0:\n num += S[j + 1]\n\n if plus_lst[j] == 1:\n res += int(num)\n num = S[j + 1]\n\n if j == n - 1:\n res += int(num)\n\n ans += res\n\n print(ans)",
"main"
] | def main():
S = input()
n = len(S) - 1
ans = 0
if n == 0:
print(int(S))
return
for i in range(2 ** n):
plus_lst = [0] * n
for j in range(n):
if (i >> j) & 1 == 1:
plus_lst[n - 1 - j] = 1 # 0: "", 1: "+"
res = 0
num = S[0]
for j in range(n):
if plus_lst[j] == 0:
num += S[j + 1]
if plus_lst[j] == 1:
res += int(num)
num = S[j + 1]
if j == n - 1:
res += int(num)
ans += res
print(ans)
if __name__ == "__main__":
main()
|
[
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,
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,
4,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
77,
2
],
[
83,
6
],
[
78,
9
],
[
80,
11
],
[
15,
14
],
[
84,
20
],
[
71,
23
],
[
78,
25
],
[
29,
28
],
[
84,
32
],
[
14,
37
],
[
28,
38
],
[
74,
41
],
[
78,
45
],
[
28,
47
],
[
65,
50
],
[
78,
52
],
[
28,
54
],
[
68,
57
],
[
66,
60
],
[
75,
60
],
[
72,
60
],
[
69,
63
],
[
81,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
]
] | [
"S=input()\nl=len(S)\nans=0\nfor bit in range(2**(l-1)):\n temp=S[0]\n for i in range(l-1):\n if bit>>i&1:\n temp+=\"+\"+S[i+1]\n else:\n temp+=S[i+1]\n ans+=eval(temp)\nprint(ans)",
"S=input()",
"S",
"input()",
"input",
"l=len(S)",
"l",
"len(S)",
"len",
"S",
"ans=0",
"ans",
"0",
"for bit in range(2**(l-1)):\n temp=S[0]\n for i in range(l-1):\n if bit>>i&1:\n temp+=\"+\"+S[i+1]\n else:\n temp+=S[i+1]\n ans+=eval(temp)",
"bit",
"range(2**(l-1))",
"range",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"temp=S[0]",
"temp",
"S[0]",
"S",
"0",
"for i in range(l-1):\n if bit>>i&1:\n temp+=\"+\"+S[i+1]\n else:\n temp+=S[i+1]\n ",
"i",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if bit>>i&1:\n temp+=\"+\"+S[i+1]\n else:\n temp+=S[i+1]\n ",
"bit>>i&1",
"bit>>i",
"bit",
"i",
"1",
"temp+=\"+\"+S[i+1]",
"temp",
"\"+\"+S[i+1]",
"\"+\"",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"temp+=S[i+1]",
"temp",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"ans+=eval(temp)",
"ans",
"eval(temp)",
"eval",
"temp",
"print(ans)",
"print",
"ans",
"temp+=S[i+1]",
"S[i+1]",
"temp",
"ans+=eval(temp)",
"eval(temp)",
"ans",
"temp=S[0]",
"S[0]",
"temp",
"temp+=\"+\"+S[i+1]",
"\"+\"+S[i+1]",
"temp",
"S=input()",
"input()",
"S",
"ans=0",
"0",
"ans",
"l=len(S)",
"len(S)",
"l"
] | S=input()
l=len(S)
ans=0
for bit in range(2**(l-1)):
temp=S[0]
for i in range(l-1):
if bit>>i&1:
temp+="+"+S[i+1]
else:
temp+=S[i+1]
ans+=eval(temp)
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,
13,
4,
18,
13,
13,
18,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
17,
0,
13,
18,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13
] | [
[
94,
2
],
[
118,
6
],
[
95,
9
],
[
109,
11
],
[
15,
14
],
[
119,
20
],
[
115,
23
],
[
27,
26
],
[
119,
29
],
[
116,
32
],
[
95,
35
],
[
26,
36
],
[
14,
40
],
[
26,
41
],
[
116,
45
],
[
106,
49
],
[
53,
52
],
[
116,
57
],
[
116,
61
],
[
52,
62
],
[
97,
65
],
[
107,
68
],
[
104,
68
],
[
101,
68
],
[
100,
70
],
[
103,
73
],
[
116,
75
],
[
52,
76
],
[
52,
79
],
[
116,
83
],
[
112,
86
],
[
104,
89
],
[
101,
89
],
[
107,
89
],
[
113,
92
],
[
98,
92
],
[
110,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
]
] | [
"S = input()\nN = len(S)\nSum = 0\nfor i in range(2**(N-1)):\n exp = []\n for j in range(N):\n exp.append(S[j])\n if ((i >> j) & 1):\n exp.append('+')\n \n a = ''\n for j in range(len(exp)):\n if exp[j] == '+':\n Sum += int(a)\n a = ''\n else:\n a += exp[j]\n if j == (len(exp)-1):\n Sum += int(a)\n \nprint(Sum)",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"Sum = 0",
"Sum",
"0",
"for i in range(2**(N-1)):\n exp = []\n for j in range(N):\n exp.append(S[j])\n if ((i >> j) & 1):\n exp.append('+')\n \n a = ''\n for j in range(len(exp)):\n if exp[j] == '+':\n Sum += int(a)\n a = ''\n else:\n a += exp[j]\n if j == (len(exp)-1):\n Sum += int(a)\n ",
"i",
"range(2**(N-1))",
"range",
"2**(N-1)",
"2",
"N-1",
"N",
"1",
"exp = []",
"exp",
"[]",
"for j in range(N):\n exp.append(S[j])\n if ((i >> j) & 1):\n exp.append('+')\n \n ",
"j",
"range(N)",
"range",
"N",
"exp.append(S[j])",
"exp.append",
"exp",
"append",
"S[j]",
"S",
"j",
"if ((i >> j) & 1):\n exp.append('+')\n \n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"exp.append('+')",
"exp.append",
"exp",
"append",
"'+'",
"a = ''",
"a",
"''",
"for j in range(len(exp)):\n if exp[j] == '+':\n Sum += int(a)\n a = ''\n else:\n a += exp[j]\n if j == (len(exp)-1):\n Sum += int(a)\n ",
"j",
"range(len(exp))",
"range",
"len(exp)",
"len",
"exp",
"if exp[j] == '+':\n Sum += int(a)\n a = ''\n else:\n a += exp[j]\n ",
"exp[j] == '+'",
"exp[j]",
"exp",
"j",
"'+'",
"Sum += int(a)",
"Sum",
"int(a)",
"int",
"a",
"a = ''",
"a",
"''",
"a += exp[j]",
"a",
"exp[j]",
"exp",
"j",
"if j == (len(exp)-1):\n Sum += int(a)\n ",
"j == (len(exp)-1)",
"j",
"len(exp)-1",
"len(exp)",
"len",
"exp",
"1",
"Sum += int(a)",
"Sum",
"int(a)",
"int",
"a",
"print(Sum)",
"print",
"Sum",
"S = input()",
"input()",
"S",
"Sum += int(a)",
"int(a)",
"Sum",
"a = ''",
"''",
"a",
"a += exp[j]",
"exp[j]",
"a",
"a = ''",
"''",
"a",
"Sum = 0",
"0",
"Sum",
"Sum += int(a)",
"int(a)",
"Sum",
"exp = []",
"[]",
"exp",
"N = len(S)",
"len(S)",
"N"
] | S = input()
N = len(S)
Sum = 0
for i in range(2**(N-1)):
exp = []
for j in range(N):
exp.append(S[j])
if ((i >> j) & 1):
exp.append('+')
a = ''
for j in range(len(exp)):
if exp[j] == '+':
Sum += int(a)
a = ''
else:
a += exp[j]
if j == (len(exp)-1):
Sum += int(a)
print(Sum) |
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
39,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
18,
13,
39,
13,
2,
13,
17,
0,
13,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
0,
18,
13,
17,
13,
14,
40,
13,
17,
4,
18,
13,
13,
13,
0,
13,
4,
13,
4,
13,
4,
13,
13,
13,
4,
13,
13,
10,
18,
13,
10,
17,
13,
10,
39,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
107,
2
],
[
101,
6
],
[
116,
9
],
[
108,
12
],
[
15,
14
],
[
117,
20
],
[
98,
23
],
[
95,
27
],
[
31,
30
],
[
117,
34
],
[
14,
39
],
[
30,
40
],
[
104,
43
],
[
108,
45
],
[
30,
49
],
[
92,
52
],
[
108,
54
],
[
30,
57
],
[
113,
60
],
[
30,
62
],
[
68,
65
],
[
99,
66
],
[
105,
68
],
[
93,
71
],
[
99,
75
],
[
93,
77
],
[
110,
79
],
[
99,
87
],
[
111,
90
],
[
102,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
]
] | [
"s = input()\nans = 0\nl = len(s)\nfor i in range(2**(l-1)):\n nums = [s]\n idx = 0\n #print(f'i={i}')\n for j in range(l-1):\n if i>>j&1:\n a = s[idx:j+1]\n b = s[j+1:]\n #print(f'j={j}')\n #print(f'idx={idx}, a={a}, b={b}')\n idx = j+1\n nums[-1] = a\n if b != '':\n nums.append(b)\n ans += sum(list(map(int, nums)))\n #print(nums)\n #print('----------------')\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"ans = 0",
"ans",
"0",
"l = len(s)",
"l",
"len(s)",
"len",
"s",
"for i in range(2**(l-1)):\n nums = [s]\n idx = 0\n #print(f'i={i}')\n for j in range(l-1):\n if i>>j&1:\n a = s[idx:j+1]\n b = s[j+1:]\n #print(f'j={j}')\n #print(f'idx={idx}, a={a}, b={b}')\n idx = j+1\n nums[-1] = a\n if b != '':\n nums.append(b)\n ans += sum(list(map(int, nums)))\n #print(nums)\n #print('----------------')",
"i",
"range(2**(l-1))",
"range",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"nums = [s]",
"nums",
"[s]",
"s",
"idx = 0",
"idx",
"0",
"for j in range(l-1):\n if i>>j&1:\n a = s[idx:j+1]\n b = s[j+1:]\n #print(f'j={j}')\n #print(f'idx={idx}, a={a}, b={b}')\n idx = j+1\n nums[-1] = a\n if b != '':\n nums.append(b)\n ",
"j",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if i>>j&1:\n a = s[idx:j+1]\n b = s[j+1:]\n #print(f'j={j}')\n #print(f'idx={idx}, a={a}, b={b}')\n idx = j+1\n nums[-1] = a\n if b != '':\n nums.append(b)\n ",
"i>>j&1",
"i>>j",
"i",
"j",
"1",
"a = s[idx:j+1]",
"a",
"s[idx:j+1]",
"s",
"idx:j+1",
"idx",
"j+1",
"j",
"1",
"b = s[j+1:]",
"b",
"s[j+1:]",
"s",
"j+1:",
"j+1",
"j",
"1",
"idx = j+1",
"idx",
"j+1",
"j",
"1",
"nums[-1] = a",
"nums[-1]",
"nums",
"-1",
"a",
"if b != '':\n nums.append(b)\n ",
"b != ''",
"b",
"''",
"nums.append(b)",
"nums.append",
"nums",
"append",
"b",
"ans += sum(list(map(int, nums)))",
"ans",
"sum(list(map(int, nums)))",
"sum",
"list(map(int, nums))",
"list",
"map(int, nums)",
"map",
"int",
"nums",
"print(ans)",
"print",
"ans",
"b = s[j+1:]",
"s[j+1:]",
"b",
"idx = 0",
"0",
"idx",
"nums = [s]",
"[s]",
"nums",
"ans = 0",
"0",
"ans",
"a = s[idx:j+1]",
"s[idx:j+1]",
"a",
"s = input()",
"input()",
"s",
"ans += sum(list(map(int, nums)))",
"sum(list(map(int, nums)))",
"ans",
"idx = j+1",
"j+1",
"idx",
"l = len(s)",
"len(s)",
"l"
] | s = input()
ans = 0
l = len(s)
for i in range(2**(l-1)):
nums = [s]
idx = 0
#print(f'i={i}')
for j in range(l-1):
if i>>j&1:
a = s[idx:j+1]
b = s[j+1:]
#print(f'j={j}')
#print(f'idx={idx}, a={a}, b={b}')
idx = j+1
nums[-1] = a
if b != '':
nums.append(b)
ans += sum(list(map(int, nums)))
#print(nums)
#print('----------------')
print(ans) |
[
7,
15,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
18,
13,
13,
39,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
4,
13,
13,
14,
2,
18,
13,
2,
13,
17,
17,
0,
13,
4,
13,
18,
13,
39,
13,
13,
0,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13
] | [
[
75,
4
],
[
78,
8
],
[
12,
11
],
[
21,
20
],
[
76,
24
],
[
84,
27
],
[
87,
30
],
[
34,
33
],
[
76,
39
],
[
11,
43
],
[
33,
45
],
[
96,
49
],
[
76,
53
],
[
93,
58
],
[
33,
59
],
[
81,
61
],
[
76,
65
],
[
90,
69
],
[
97,
70
],
[
88,
70
],
[
91,
73
],
[
82,
73
],
[
79,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
97,
90
],
[
88,
90
],
[
90,
91
],
[
33,
93
],
[
93,
94
],
[
96,
97
]
] | [
"import itertools\nS = input()\n\nans = 0\nfor v in itertools.product([1,0], repeat=len(S)-1):\n idx = 0\n sum = 0\n for i in range(1,len(S)):\n if v[i-1] == 1:\n sum += int(S[idx:i])\n idx = i\n ans += int(S[idx:])\n ans += sum\nprint(ans)",
"import itertools",
"itertools",
"S = input()",
"S",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for v in itertools.product([1,0], repeat=len(S)-1):\n idx = 0\n sum = 0\n for i in range(1,len(S)):\n if v[i-1] == 1:\n sum += int(S[idx:i])\n idx = i\n ans += int(S[idx:])\n ans += sum",
"v",
"itertools.product([1,0], repeat=len(S)-1)",
"itertools.product",
"itertools",
"product",
"[1,0]",
"1",
"0",
"repeat=len(S)-1",
"repeat",
"len(S)-1",
"len(S)",
"len",
"S",
"1",
"idx = 0",
"idx",
"0",
"sum = 0",
"sum",
"0",
"for i in range(1,len(S)):\n if v[i-1] == 1:\n sum += int(S[idx:i])\n idx = i\n ",
"i",
"range(1,len(S))",
"range",
"1",
"len(S)",
"len",
"S",
"if v[i-1] == 1:\n sum += int(S[idx:i])\n idx = i\n ",
"v[i-1] == 1",
"v[i-1]",
"v",
"i-1",
"i",
"1",
"1",
"sum += int(S[idx:i])",
"sum",
"int(S[idx:i])",
"int",
"S[idx:i]",
"S",
"idx:i",
"idx",
"i",
"idx = i",
"idx",
"i",
"ans += int(S[idx:])",
"ans",
"int(S[idx:])",
"int",
"S[idx:]",
"S",
"idx:",
"idx",
"ans += sum",
"ans",
"sum",
"print(ans)",
"print",
"ans",
"S = input()",
"input()",
"S",
"ans = 0",
"0",
"ans",
"ans += int(S[idx:])",
"int(S[idx:])",
"ans",
"idx = 0",
"0",
"idx",
"sum = 0",
"0",
"sum",
"ans += sum",
"sum",
"ans",
"idx = i",
"i",
"idx",
"sum += int(S[idx:i])",
"int(S[idx:i])",
"sum"
] | import itertools
S = input()
ans = 0
for v in itertools.product([1,0], repeat=len(S)-1):
idx = 0
sum = 0
for i in range(1,len(S)):
if v[i-1] == 1:
sum += int(S[idx:i])
idx = i
ans += int(S[idx:])
ans += sum
print(ans) |
[
7,
15,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
12,
13,
12,
13,
0,
13,
4,
13,
17,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
2,
17,
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,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
18,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13
] | [
[
12,
11
],
[
163,
17
],
[
21,
21
],
[
25,
24
],
[
169,
30
],
[
34,
34
],
[
38,
37
],
[
47,
47
],
[
129,
53
],
[
159,
58
],
[
157,
60
],
[
135,
62
],
[
160,
65
],
[
174,
67
],
[
71,
70
],
[
136,
76
],
[
147,
79
],
[
160,
83
],
[
87,
86
],
[
136,
90
],
[
70,
95
],
[
86,
96
],
[
138,
99
],
[
144,
102
],
[
160,
104
],
[
86,
106
],
[
177,
109
],
[
145,
117
],
[
139,
117
],
[
148,
117
],
[
178,
117
],
[
165,
121
],
[
178,
124
],
[
145,
124
],
[
139,
124
],
[
148,
124
],
[
166,
127
],
[
175,
127
],
[
129,
130
],
[
135,
136
],
[
138,
139
],
[
144,
145
],
[
147,
148
],
[
159,
160
],
[
165,
166
],
[
174,
175
],
[
177,
178
]
] | [
"import sys\n\n\ndef input(): return sys.stdin.readline().strip()\ndef I(): return int(input())\ndef LI(): return list(map(int, input().split()))\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef S(): return input()\ndef LS(): return input().split()\n\n\nINF = float('inf')\n\n\ns = S()\nn = len(s)\nans = 0\nfor i in range(2 ** (n - 1)):\n res = '' + s[0]\n for j in range(n - 1):\n if i >> j & 1:\n res += '+'\n res += s[j + 1]\n res = list(map(int, res.split('+')))\n ans += sum(res)\nprint(ans)",
"import sys",
"sys",
"def input(): return sys.stdin.readline().strip()",
"input",
"def I(): return int(input())",
"I",
"def LI(): return list(map(int, input().split()))",
"LI",
"I() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"I()",
"I",
"def IR(n): return [I() for i in range(n)]",
"IR",
"n",
"n",
"LI() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LI()",
"LI",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"n",
"n",
"S() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"S()",
"S",
"def SR(n): return [S() for i in range(n)]",
"SR",
"n",
"n",
"def S(): return input()",
"S",
"def LS(): return input().split()",
"LS",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"s = S()",
"s",
"S()",
"S",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (n - 1)):\n res = '' + s[0]\n for j in range(n - 1):\n if i >> j & 1:\n res += '+'\n res += s[j + 1]\n res = list(map(int, res.split('+')))\n ans += sum(res)",
"i",
"range(2 ** (n - 1))",
"range",
"2 ** (n - 1)",
"2",
"n - 1",
"n",
"1",
"res = '' + s[0]",
"res",
"'' + s[0]",
"''",
"s[0]",
"s",
"0",
"for j in range(n - 1):\n if i >> j & 1:\n res += '+'\n res += s[j + 1]\n ",
"j",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if i >> j & 1:\n res += '+'\n ",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"res += '+'",
"res",
"'+'",
"res += s[j + 1]",
"res",
"s[j + 1]",
"s",
"j + 1",
"j",
"1",
"res = list(map(int, res.split('+')))",
"res",
"list(map(int, res.split('+')))",
"list",
"map(int, res.split('+'))",
"map",
"int",
"res.split('+')",
"res.split",
"res",
"split",
"'+'",
"ans += sum(res)",
"ans",
"sum(res)",
"sum",
"res",
"print(ans)",
"print",
"ans",
"INF = float('inf')",
"float('inf')",
"INF",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"n = len(s)",
"len(s)",
"n",
"res += '+'",
"'+'",
"res",
"def SR(n): return [S() for i in range(n)]",
"def SR(n): return [S() for i in range(n)]",
"SR",
"res += s[j + 1]",
"s[j + 1]",
"res",
"res = '' + s[0]",
"'' + s[0]",
"res",
"def IR(n): return [I() for i in range(n)]",
"def IR(n): return [I() for i in range(n)]",
"IR",
"def LIR(n): return [LI() for i in range(n)]",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"def S(): return input()",
"def S(): return input()",
"S",
"s = S()",
"S()",
"s",
"def I(): return int(input())",
"def I(): return int(input())",
"I",
"ans += sum(res)",
"sum(res)",
"ans",
"def LI(): return list(map(int, input().split()))",
"def LI(): return list(map(int, input().split()))",
"LI",
"def LS(): return input().split()",
"def LS(): return input().split()",
"LS",
"ans = 0",
"0",
"ans",
"res = list(map(int, res.split('+')))",
"list(map(int, res.split('+')))",
"res"
] | import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()
INF = float('inf')
s = S()
n = len(s)
ans = 0
for i in range(2 ** (n - 1)):
res = '' + s[0]
for j in range(n - 1):
if i >> j & 1:
res += '+'
res += s[j + 1]
res = list(map(int, res.split('+')))
ans += sum(res)
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,
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,
4,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] | [
[
69,
2
],
[
66,
6
],
[
70,
9
],
[
81,
11
],
[
15,
14
],
[
67,
20
],
[
72,
23
],
[
70,
25
],
[
29,
28
],
[
67,
32
],
[
14,
36
],
[
28,
39
],
[
84,
41
],
[
75,
44
],
[
70,
46
],
[
28,
48
],
[
78,
51
],
[
76,
59
],
[
85,
59
],
[
73,
59
],
[
79,
64
],
[
82,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
]
] | [
"s=input()\nn=len(s)\nans=0\nfor i in range(2**(n-1)):\n res=s[0]\n for j in range(n-1):\n if i & (1<<j):\n res+='+'\n res+=s[j+1]\n ans+=sum(map(int,res.split('+')))\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 res=s[0]\n for j in range(n-1):\n if i & (1<<j):\n res+='+'\n res+=s[j+1]\n ans+=sum(map(int,res.split('+')))",
"i",
"range(2**(n-1))",
"range",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"res=s[0]",
"res",
"s[0]",
"s",
"0",
"for j in range(n-1):\n if i & (1<<j):\n res+='+'\n res+=s[j+1]\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if i & (1<<j):\n res+='+'\n ",
"i & (1<<j)",
"i",
"1<<j",
"1",
"j",
"res+='+'",
"res",
"'+'",
"res+=s[j+1]",
"res",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ans+=sum(map(int,res.split('+')))",
"ans",
"sum(map(int,res.split('+')))",
"sum",
"map(int,res.split('+'))",
"map",
"int",
"res.split('+')",
"res.split",
"res",
"split",
"'+'",
"print(ans)",
"print",
"ans",
"n=len(s)",
"len(s)",
"n",
"s=input()",
"input()",
"s",
"res=s[0]",
"s[0]",
"res",
"res+=s[j+1]",
"s[j+1]",
"res",
"ans+=sum(map(int,res.split('+')))",
"sum(map(int,res.split('+')))",
"ans",
"ans=0",
"0",
"ans",
"res+='+'",
"'+'",
"res"
] | s=input()
n=len(s)
ans=0
for i in range(2**(n-1)):
res=s[0]
for j in range(n-1):
if i & (1<<j):
res+='+'
res+=s[j+1]
ans+=sum(map(int,res.split('+')))
print(ans) |
[
7,
15,
0,
13,
4,
18,
4,
18,
13,
13,
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,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
78,
3
],
[
84,
12
],
[
79,
15
],
[
66,
20
],
[
85,
22
],
[
68,
34
],
[
66,
42
],
[
68,
45
],
[
79,
47
],
[
66,
49
],
[
66,
54
],
[
68,
58
],
[
79,
61
],
[
66,
63
],
[
66,
66
],
[
68,
68
],
[
82,
72
],
[
79,
75
],
[
78,
79
],
[
84,
85
]
] | [
"from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i == n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])\nprint(dfs(0, S[0]))",
"from sys import stdin",
"S = stdin.readline().rstrip()",
"S",
"stdin.readline().rstrip()",
"stdin.readline().rstrip",
"stdin.readline()",
"stdin.readline",
"stdin",
"readline",
"rstrip",
"n = len(S)",
"n",
"len(S)",
"len",
"S",
"def dfs(i, f):\n if i == n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])",
"dfs",
"if i == n-1:\n return sum(list(map(int, f.split('+'))))\n ",
"i == n-1",
"i",
"n-1",
"n",
"1",
"return sum(list(map(int, f.split('+'))))",
"sum(list(map(int, f.split('+'))))",
"sum",
"list(map(int, f.split('+')))",
"list",
"map(int, f.split('+'))",
"map",
"int",
"f.split('+')",
"f.split",
"f",
"split",
"'+'",
"return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])",
"dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])",
"dfs(i+1, f + S[i + 1])",
"dfs",
"i+1",
"i",
"1",
"f + S[i + 1]",
"f",
"S[i + 1]",
"S",
"i + 1",
"i",
"1",
"dfs(i + 1, f + '+' + S[i+1])",
"dfs",
"i + 1",
"i",
"1",
"f + '+' + S[i+1]",
"f + '+'",
"f",
"'+'",
"S[i+1]",
"S",
"i+1",
"i",
"1",
"i",
"i",
"f",
"f",
"print(dfs(0, S[0]))",
"print",
"dfs(0, S[0])",
"dfs",
"0",
"S[0]",
"S",
"0",
"S = stdin.readline().rstrip()",
"stdin.readline().rstrip()",
"S",
"def dfs(i, f):\n if i == n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])",
"def dfs(i, f):\n if i == n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])",
"dfs",
"n = len(S)",
"len(S)",
"n"
] | from sys import stdin
S = stdin.readline().rstrip()
n = len(S)
def dfs(i, f):
if i == n-1:
return sum(list(map(int, f.split('+'))))
return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])
print(dfs(0, S[0]))
|
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
39,
41,
28,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
0,
13,
13,
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,
13,
0,
13,
2,
39,
17,
4,
13,
13,
28,
13,
13,
0,
18,
13,
13,
17,
0,
13,
39,
28,
13,
13,
4,
13,
13,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
41,
28,
13,
13,
40,
13,
17,
4,
13,
0,
13,
13,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
18,
13,
13,
17,
41,
28,
13,
13,
40,
13,
17,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
39,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13
] | [
[
154,
2
],
[
157,
6
],
[
155,
10
],
[
181,
13
],
[
18,
17
],
[
155,
22
],
[
155,
25
],
[
17,
26
],
[
163,
28
],
[
32,
31
],
[
158,
36
],
[
178,
38
],
[
42,
41
],
[
158,
44
],
[
31,
48
],
[
41,
49
],
[
179,
53
],
[
41,
55
],
[
169,
57
],
[
155,
63
],
[
66,
65
],
[
179,
65
],
[
71,
68
],
[
170,
69
],
[
65,
70
],
[
148,
73
],
[
164,
80
],
[
170,
81
],
[
149,
84
],
[
176,
84
],
[
161,
84
],
[
167,
84
],
[
173,
84
],
[
152,
84
],
[
149,
89
],
[
176,
89
],
[
161,
89
],
[
167,
89
],
[
173,
89
],
[
152,
89
],
[
95,
94
],
[
149,
94
],
[
176,
94
],
[
161,
94
],
[
167,
94
],
[
173,
94
],
[
152,
94
],
[
94,
97
],
[
94,
100
],
[
151,
102
],
[
172,
105
],
[
152,
110
],
[
149,
110
],
[
176,
110
],
[
161,
110
],
[
167,
110
],
[
173,
110
],
[
166,
112
],
[
173,
115
],
[
152,
115
],
[
149,
115
],
[
176,
115
],
[
161,
115
],
[
167,
115
],
[
121,
120
],
[
167,
120
],
[
173,
120
],
[
152,
120
],
[
149,
120
],
[
176,
120
],
[
161,
120
],
[
120,
123
],
[
120,
128
],
[
160,
130
],
[
175,
133
],
[
161,
136
],
[
167,
136
],
[
173,
136
],
[
152,
136
],
[
149,
136
],
[
176,
136
],
[
182,
139
],
[
176,
141
],
[
161,
141
],
[
167,
141
],
[
173,
141
],
[
152,
141
],
[
149,
141
],
[
182,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
],
[
181,
182
]
] | [
"s = input()\nn = len(s) - 1\nanswers = []\nsl = [s[i] for i in range(len(s))]\nfor i in range(2 ** n):\n tmp = []\n for j in range(n):\n if ((i >> j) & 1):\n tmp.append(j)\n ll = ['*']*len(s)\n for k in tmp:\n ll[k] = '+'\n ans = []\n for k, _ in zip(sl, ll):\n ans.append(k)\n ans.append(_)\n ans = [_ for _ in ans if _ != '*']\n ans = ''.join(ans)\n ans = ans.split('+')\n ans = [int(_) for _ in ans if _ != '+']\n ans = sum(ans)\n answers.append(ans)\nprint(sum(answers))",
"s = input()",
"s",
"input()",
"input",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"answers = []",
"answers",
"[]",
"s[i] for i in range(len(s))",
"for i in range(len(s))",
"i",
"range(len(s))",
"range",
"len(s)",
"len",
"s",
"for i in range(len(s))",
"s[i]",
"s",
"i",
"sl = [s[i] for i in range(len(s))]",
"sl",
"[s[i] for i in range(len(s))]",
"for i in range(2 ** n):\n tmp = []\n for j in range(n):\n if ((i >> j) & 1):\n tmp.append(j)\n ll = ['*']*len(s)\n for k in tmp:\n ll[k] = '+'\n ans = []\n for k, _ in zip(sl, ll):\n ans.append(k)\n ans.append(_)\n ans = [_ for _ in ans if _ != '*']\n ans = ''.join(ans)\n ans = ans.split('+')\n ans = [int(_) for _ in ans if _ != '+']\n ans = sum(ans)\n answers.append(ans)",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"tmp = []",
"tmp",
"[]",
"for j in range(n):\n if ((i >> j) & 1):\n tmp.append(j)\n ",
"j",
"range(n)",
"range",
"n",
"if ((i >> j) & 1):\n tmp.append(j)\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"tmp.append(j)",
"tmp.append",
"tmp",
"append",
"j",
"ll = ['*']*len(s)",
"ll",
"['*']*len(s)",
"['*']",
"'*'",
"len(s)",
"len",
"s",
"for k in tmp:\n ll[k] = '+'\n ",
"k",
"tmp",
"ll[k] = '+'",
"ll[k]",
"ll",
"k",
"'+'",
"ans = []",
"ans",
"[]",
"for k, _ in zip(sl, ll):\n ans.append(k)\n ans.append(_)\n ",
"k",
"_",
"zip(sl, ll)",
"zip",
"sl",
"ll",
"ans.append(k)",
"ans.append",
"ans",
"append",
"k",
"ans.append(_)",
"ans.append",
"ans",
"append",
"_",
"_ for _ in ans if _ != '*'",
"for _ in ans if _ != '*'",
"_",
"ans",
"_ != '*'",
"_",
"'*'",
"if _ != '*'",
"_",
"ans = [_ for _ in ans if _ != '*']",
"ans",
"[_ for _ in ans if _ != '*']",
"ans = ''.join(ans)",
"ans",
"''.join(ans)",
"''.join",
"''",
"join",
"ans",
"ans = ans.split('+')",
"ans",
"ans.split('+')",
"ans.split",
"ans",
"split",
"'+'",
"int(_) for _ in ans if _ != '+'",
"for _ in ans if _ != '+'",
"_",
"ans",
"_ != '+'",
"_",
"'+'",
"if _ != '+'",
"int(_)",
"int",
"_",
"ans = [int(_) for _ in ans if _ != '+']",
"ans",
"[int(_) for _ in ans if _ != '+']",
"ans = sum(ans)",
"ans",
"sum(ans)",
"sum",
"ans",
"answers.append(ans)",
"answers.append",
"answers",
"append",
"ans",
"print(sum(answers))",
"print",
"sum(answers)",
"sum",
"answers",
"ans = []",
"[]",
"ans",
"ans = [_ for _ in ans if _ != '*']",
"[_ for _ in ans if _ != '*']",
"ans",
"s = input()",
"input()",
"s",
"n = len(s) - 1",
"len(s) - 1",
"n",
"ans = [int(_) for _ in ans if _ != '+']",
"[int(_) for _ in ans if _ != '+']",
"ans",
"sl = [s[i] for i in range(len(s))]",
"[s[i] for i in range(len(s))]",
"sl",
"ans = ans.split('+')",
"ans.split('+')",
"ans",
"ll = ['*']*len(s)",
"['*']*len(s)",
"ll",
"ans = ''.join(ans)",
"''.join(ans)",
"ans",
"ans = sum(ans)",
"sum(ans)",
"ans",
"tmp = []",
"[]",
"tmp",
"answers = []",
"[]",
"answers"
] | s = input()
n = len(s) - 1
answers = []
sl = [s[i] for i in range(len(s))]
for i in range(2 ** n):
tmp = []
for j in range(n):
if ((i >> j) & 1):
tmp.append(j)
ll = ['*']*len(s)
for k in tmp:
ll[k] = '+'
ans = []
for k, _ in zip(sl, ll):
ans.append(k)
ans.append(_)
ans = [_ for _ in ans if _ != '*']
ans = ''.join(ans)
ans = ans.split('+')
ans = [int(_) for _ in ans if _ != '+']
ans = sum(ans)
answers.append(ans)
print(sum(answers))
|
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
17,
17,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
13,
17,
17,
0,
13,
4,
13,
4,
18,
17,
13,
13,
4,
13,
13,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
12,
11
],
[
4,
19
],
[
23,
22
],
[
4,
25
],
[
28,
27
],
[
4,
33
],
[
11,
40
],
[
27,
41
],
[
22,
45
],
[
27,
48
],
[
53,
52
],
[
22,
59
],
[
52,
62
],
[
8,
62
],
[
67,
64
]
] | [
"def resolve():\n S = input()\n sumA = 0\n for i in range(2**(len(S) - 1)):\n Stmp = list(S)\n for j in range(len(S) - 2, -1, -1):\n if (i >> j) & 1:\n Stmp.insert(j + 1, \"+\")\n sumA += eval(\"\".join(Stmp))\n print(sumA)\n\n\nresolve()",
"def resolve():\n S = input()\n sumA = 0\n for i in range(2**(len(S) - 1)):\n Stmp = list(S)\n for j in range(len(S) - 2, -1, -1):\n if (i >> j) & 1:\n Stmp.insert(j + 1, \"+\")\n sumA += eval(\"\".join(Stmp))\n print(sumA)",
"resolve",
"S = input()",
"S",
"input()",
"input",
"sumA = 0",
"sumA",
"0",
"for i in range(2**(len(S) - 1)):\n Stmp = list(S)\n for j in range(len(S) - 2, -1, -1):\n if (i >> j) & 1:\n Stmp.insert(j + 1, \"+\")\n sumA += eval(\"\".join(Stmp))\n ",
"i",
"range(2**(len(S) - 1))",
"range",
"2**(len(S) - 1)",
"2",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"Stmp = list(S)",
"Stmp",
"list(S)",
"list",
"S",
"for j in range(len(S) - 2, -1, -1):\n if (i >> j) & 1:\n Stmp.insert(j + 1, \"+\")\n ",
"j",
"range(len(S) - 2, -1, -1)",
"range",
"len(S) - 2",
"len(S)",
"len",
"S",
"2",
"-1",
"-1",
"if (i >> j) & 1:\n Stmp.insert(j + 1, \"+\")\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"Stmp.insert(j + 1, \"+\")",
"Stmp.insert",
"Stmp",
"insert",
"j + 1",
"j",
"1",
"\"+\"",
"sumA += eval(\"\".join(Stmp))",
"sumA",
"eval(\"\".join(Stmp))",
"eval",
"\"\".join(Stmp)",
"\"\".join",
"\"\"",
"join",
"Stmp",
"print(sumA)",
"print",
"sumA",
"resolve()",
"resolve",
"def resolve():\n S = input()\n sumA = 0\n for i in range(2**(len(S) - 1)):\n Stmp = list(S)\n for j in range(len(S) - 2, -1, -1):\n if (i >> j) & 1:\n Stmp.insert(j + 1, \"+\")\n sumA += eval(\"\".join(Stmp))\n print(sumA)",
"def resolve():\n S = input()\n sumA = 0\n for i in range(2**(len(S) - 1)):\n Stmp = list(S)\n for j in range(len(S) - 2, -1, -1):\n if (i >> j) & 1:\n Stmp.insert(j + 1, \"+\")\n sumA += eval(\"\".join(Stmp))\n print(sumA)",
"resolve"
] | def resolve():
S = input()
sumA = 0
for i in range(2**(len(S) - 1)):
Stmp = list(S)
for j in range(len(S) - 2, -1, -1):
if (i >> j) & 1:
Stmp.insert(j + 1, "+")
sumA += eval("".join(Stmp))
print(sumA)
resolve()
|
[
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,
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,
4,
13,
10,
18,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
68,
2
],
[
80,
6
],
[
69,
10
],
[
83,
13
],
[
17,
16
],
[
81,
21
],
[
74,
23
],
[
69,
25
],
[
29,
28
],
[
81,
31
],
[
16,
36
],
[
28,
37
],
[
86,
41
],
[
75,
44
],
[
78,
44
],
[
72,
44
],
[
71,
46
],
[
69,
48
],
[
28,
50
],
[
77,
53
],
[
69,
55
],
[
28,
57
],
[
89,
60
],
[
78,
63
],
[
72,
63
],
[
75,
63
],
[
90,
66
],
[
87,
66
],
[
84,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] | [
"s = input()\nn = len(s)-1\nans = 0\nfor i in range(2**n):\n now = s[0]\n for j in range(n):\n if (i>>j) & 1 == 1:\n ans += int(now)\n now = s[j+1]\n else:\n now += s[j+1]\n ans += int(now)\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 now = s[0]\n for j in range(n):\n if (i>>j) & 1 == 1:\n ans += int(now)\n now = s[j+1]\n else:\n now += s[j+1]\n ans += int(now)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"now = s[0]",
"now",
"s[0]",
"s",
"0",
"for j in range(n):\n if (i>>j) & 1 == 1:\n ans += int(now)\n now = s[j+1]\n else:\n now += s[j+1]\n ",
"j",
"range(n)",
"range",
"n",
"if (i>>j) & 1 == 1:\n ans += int(now)\n now = s[j+1]\n else:\n now += s[j+1]\n ",
"(i>>j) & 1 == 1",
"(i>>j) & 1",
"i>>j",
"i",
"j",
"1",
"1",
"ans += int(now)",
"ans",
"int(now)",
"int",
"now",
"now = s[j+1]",
"now",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"now += s[j+1]",
"now",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ans += int(now)",
"ans",
"int(now)",
"int",
"now",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"now = s[j+1]",
"s[j+1]",
"now",
"now = s[0]",
"s[0]",
"now",
"now += s[j+1]",
"s[j+1]",
"now",
"n = len(s)-1",
"len(s)-1",
"n",
"ans = 0",
"0",
"ans",
"ans += int(now)",
"int(now)",
"ans",
"ans += int(now)",
"int(now)",
"ans"
] | s = input()
n = len(s)-1
ans = 0
for i in range(2**n):
now = s[0]
for j in range(n):
if (i>>j) & 1 == 1:
ans += int(now)
now = s[j+1]
else:
now += s[j+1]
ans += int(now)
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,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
72,
2
],
[
75,
6
],
[
73,
9
],
[
60,
14
],
[
76,
16
],
[
62,
28
],
[
60,
36
],
[
62,
39
],
[
73,
41
],
[
60,
43
],
[
60,
48
],
[
62,
52
],
[
73,
55
],
[
60,
57
],
[
60,
60
],
[
62,
62
],
[
79,
66
],
[
73,
69
],
[
72,
73
],
[
75,
76
]
] | [
"s = input()\nn = len(s)\n\ndef self(i,w):\n if(i == n-1):\n return sum(list(map(int, w.split(\"+\"))))\n return self(i+1,w+s[i+1]) + self(i+1,w+\"+\"+s[i+1])\n\nprint(self(0,s[0]))",
"s = input()",
"s",
"input()",
"input",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"def self(i,w):\n if(i == n-1):\n return sum(list(map(int, w.split(\"+\"))))\n return self(i+1,w+s[i+1]) + self(i+1,w+\"+\"+s[i+1])",
"self",
"if(i == n-1):\n return sum(list(map(int, w.split(\"+\"))))\n ",
"i == n-1",
"i",
"n-1",
"n",
"1",
"return sum(list(map(int, w.split(\"+\"))))",
"sum(list(map(int, w.split(\"+\"))))",
"sum",
"list(map(int, w.split(\"+\")))",
"list",
"map(int, w.split(\"+\"))",
"map",
"int",
"w.split(\"+\")",
"w.split",
"w",
"split",
"\"+\"",
"return self(i+1,w+s[i+1]) + self(i+1,w+\"+\"+s[i+1])",
"self(i+1,w+s[i+1]) + self(i+1,w+\"+\"+s[i+1])",
"self(i+1,w+s[i+1])",
"self",
"i+1",
"i",
"1",
"w+s[i+1]",
"w",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"self(i+1,w+\"+\"+s[i+1])",
"self",
"i+1",
"i",
"1",
"w+\"+\"+s[i+1]",
"w+\"+\"",
"w",
"\"+\"",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"i",
"i",
"w",
"w",
"print(self(0,s[0]))",
"print",
"self(0,s[0])",
"self",
"0",
"s[0]",
"s",
"0",
"s = input()",
"input()",
"s",
"n = len(s)",
"len(s)",
"n",
"def self(i,w):\n if(i == n-1):\n return sum(list(map(int, w.split(\"+\"))))\n return self(i+1,w+s[i+1]) + self(i+1,w+\"+\"+s[i+1])",
"def self(i,w):\n if(i == n-1):\n return sum(list(map(int, w.split(\"+\"))))\n return self(i+1,w+s[i+1]) + self(i+1,w+\"+\"+s[i+1])",
"self"
] | s = input()
n = len(s)
def self(i,w):
if(i == n-1):
return sum(list(map(int, w.split("+"))))
return self(i+1,w+s[i+1]) + self(i+1,w+"+"+s[i+1])
print(self(0,s[0]))
|
[
7,
15,
14,
2,
13,
17,
41,
28,
13,
4,
18,
13,
13,
4,
4,
18,
13,
13,
0,
13,
13,
0,
13,
18,
13,
17,
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,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
39,
13
] | [
[
9,
8
],
[
8,
16
],
[
106,
19
],
[
115,
22
],
[
107,
24
],
[
112,
27
],
[
116,
31
],
[
109,
34
],
[
38,
37
],
[
113,
42
],
[
118,
44
],
[
100,
47
],
[
51,
50
],
[
113,
53
],
[
37,
56
],
[
50,
59
],
[
119,
62
],
[
116,
67
],
[
50,
71
],
[
97,
74
],
[
50,
76
],
[
119,
80
],
[
116,
85
],
[
103,
89
],
[
119,
92
],
[
104,
95
],
[
110,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
]
] | [
"from sys import stdin\n\n\nif __name__ == \"__main__\":\n _in = [_.rstrip() for _ in stdin.readlines()]\n S_arr = _in[0] # type:list(int)\n # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n N = len(S_arr)-1\n cnt = 0\n for bit in range(1<<N):\n # bit = 0: '', 1: '+'\n tmp = []\n pointa = 0\n for i in range(N):\n if bit&(1<<i):\n tmp.append(int(S_arr[pointa:i+1]))\n pointa = i+1\n else:\n tmp.append(int(S_arr[pointa:]))\n cnt += sum(tmp)\n # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n print(cnt)",
"from sys import stdin",
"if __name__ == \"__main__\":\n _in = [_.rstrip() for _ in stdin.readlines()]\n S_arr = _in[0] # type:list(int)\n # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n N = len(S_arr)-1\n cnt = 0\n for bit in range(1<<N):\n # bit = 0: '', 1: '+'\n tmp = []\n pointa = 0\n for i in range(N):\n if bit&(1<<i):\n tmp.append(int(S_arr[pointa:i+1]))\n pointa = i+1\n else:\n tmp.append(int(S_arr[pointa:]))\n cnt += sum(tmp)\n # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n print(cnt)",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"_.rstrip() for _ in stdin.readlines()",
"for _ in stdin.readlines()",
"_",
"stdin.readlines()",
"stdin.readlines",
"stdin",
"readlines",
"for _ in stdin.readlines()",
"_.rstrip()",
"_.rstrip",
"_",
"rstrip",
"_in = [_.rstrip() for _ in stdin.readlines()]",
"_in",
"[_.rstrip() for _ in stdin.readlines()]",
"S_arr = _in[0]",
"S_arr",
"_in[0]",
"_in",
"0",
"N = len(S_arr)-1",
"N",
"len(S_arr)-1",
"len(S_arr)",
"len",
"S_arr",
"1",
"cnt = 0",
"cnt",
"0",
"for bit in range(1<<N):\n # bit = 0: '', 1: '+'\n tmp = []\n pointa = 0\n for i in range(N):\n if bit&(1<<i):\n tmp.append(int(S_arr[pointa:i+1]))\n pointa = i+1\n else:\n tmp.append(int(S_arr[pointa:]))\n cnt += sum(tmp)\n # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n ",
"bit",
"range(1<<N)",
"range",
"1<<N",
"1",
"N",
"tmp = []",
"tmp",
"[]",
"pointa = 0",
"pointa",
"0",
"for i in range(N):\n if bit&(1<<i):\n tmp.append(int(S_arr[pointa:i+1]))\n pointa = i+1\n else:\n tmp.append(int(S_arr[pointa:]))\n ",
"i",
"range(N)",
"range",
"N",
"if bit&(1<<i):\n tmp.append(int(S_arr[pointa:i+1]))\n pointa = i+1\n ",
"bit&(1<<i)",
"bit",
"1<<i",
"1",
"i",
"tmp.append(int(S_arr[pointa:i+1]))",
"tmp.append",
"tmp",
"append",
"int(S_arr[pointa:i+1])",
"int",
"S_arr[pointa:i+1]",
"S_arr",
"pointa:i+1",
"pointa",
"i+1",
"i",
"1",
"pointa = i+1",
"pointa",
"i+1",
"i",
"1",
"tmp.append(int(S_arr[pointa:]))",
"tmp.append",
"tmp",
"append",
"int(S_arr[pointa:])",
"int",
"S_arr[pointa:]",
"S_arr",
"pointa:",
"pointa",
"cnt += sum(tmp)",
"cnt",
"sum(tmp)",
"sum",
"tmp",
"print(cnt)",
"print",
"cnt",
"pointa = i+1",
"i+1",
"pointa",
"pointa = 0",
"0",
"pointa",
"cnt += sum(tmp)",
"sum(tmp)",
"cnt",
"_in = [_.rstrip() for _ in stdin.readlines()]",
"[_.rstrip() for _ in stdin.readlines()]",
"_in",
"cnt = 0",
"0",
"cnt",
"N = len(S_arr)-1",
"len(S_arr)-1",
"N",
"S_arr = _in[0]",
"_in[0]",
"S_arr",
"tmp = []",
"[]",
"tmp"
] | from sys import stdin
if __name__ == "__main__":
_in = [_.rstrip() for _ in stdin.readlines()]
S_arr = _in[0] # type:list(int)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
N = len(S_arr)-1
cnt = 0
for bit in range(1<<N):
# bit = 0: '', 1: '+'
tmp = []
pointa = 0
for i in range(N):
if bit&(1<<i):
tmp.append(int(S_arr[pointa:i+1]))
pointa = i+1
else:
tmp.append(int(S_arr[pointa:]))
cnt += sum(tmp)
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(cnt)
|
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
4,
13,
13,
0,
13,
2,
17,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
2,
13,
13,
17,
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,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
17,
13,
10,
18,
13
] | [
[
73,
2
],
[
94,
6
],
[
85,
9
],
[
74,
12
],
[
88,
14
],
[
86,
18
],
[
22,
21
],
[
89,
24
],
[
97,
26
],
[
74,
28
],
[
32,
31
],
[
86,
35
],
[
21,
41
],
[
31,
42
],
[
76,
46
],
[
98,
49
],
[
80,
49
],
[
92,
49
],
[
91,
51
],
[
74,
53
],
[
31,
55
],
[
79,
58
],
[
74,
60
],
[
31,
62
],
[
82,
65
],
[
80,
68
],
[
92,
68
],
[
98,
68
],
[
83,
71
],
[
77,
71
],
[
95,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"s=input()\nans=0\nl=len(s)\nnum=2**(l-1)\nfor i in range(num):\n now=s[0]\n for j in range(l-1):\n if (i>>j)&1==1:\n ans+=eval(now)\n now=s[j+1]\n else:\n now+=s[j+1]\n ans+=eval(now)\nprint(ans)",
"s=input()",
"s",
"input()",
"input",
"ans=0",
"ans",
"0",
"l=len(s)",
"l",
"len(s)",
"len",
"s",
"num=2**(l-1)",
"num",
"2**(l-1)",
"2",
"l-1",
"l",
"1",
"for i in range(num):\n now=s[0]\n for j in range(l-1):\n if (i>>j)&1==1:\n ans+=eval(now)\n now=s[j+1]\n else:\n now+=s[j+1]\n ans+=eval(now)",
"i",
"range(num)",
"range",
"num",
"now=s[0]",
"now",
"s[0]",
"s",
"0",
"for j in range(l-1):\n if (i>>j)&1==1:\n ans+=eval(now)\n now=s[j+1]\n else:\n now+=s[j+1]\n ",
"j",
"range(l-1)",
"range",
"l-1",
"l",
"1",
"if (i>>j)&1==1:\n ans+=eval(now)\n now=s[j+1]\n else:\n now+=s[j+1]\n ",
"(i>>j)&1==1",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"1",
"ans+=eval(now)",
"ans",
"eval(now)",
"eval",
"now",
"now=s[j+1]",
"now",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"now+=s[j+1]",
"now",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"ans+=eval(now)",
"ans",
"eval(now)",
"eval",
"now",
"print(ans)",
"print",
"ans",
"s=input()",
"input()",
"s",
"ans+=eval(now)",
"eval(now)",
"ans",
"now+=s[j+1]",
"s[j+1]",
"now",
"ans+=eval(now)",
"eval(now)",
"ans",
"l=len(s)",
"len(s)",
"l",
"num=2**(l-1)",
"2**(l-1)",
"num",
"now=s[j+1]",
"s[j+1]",
"now",
"ans=0",
"0",
"ans",
"now=s[0]",
"s[0]",
"now"
] | s=input()
ans=0
l=len(s)
num=2**(l-1)
for i in range(num):
now=s[0]
for j in range(l-1):
if (i>>j)&1==1:
ans+=eval(now)
now=s[j+1]
else:
now+=s[j+1]
ans+=eval(now)
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,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
14,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
13,
0,
18,
13,
13,
17,
4,
18,
13,
13,
17,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
18,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
113,
2
],
[
131,
6
],
[
114,
9
],
[
116,
11
],
[
15,
14
],
[
132,
20
],
[
119,
23
],
[
27,
26
],
[
132,
30
],
[
14,
35
],
[
26,
36
],
[
120,
40
],
[
26,
42
],
[
120,
47
],
[
122,
50
],
[
114,
53
],
[
56,
55
],
[
120,
60
],
[
65,
62
],
[
120,
63
],
[
55,
64
],
[
120,
68
],
[
134,
73
],
[
120,
76
],
[
79,
78
],
[
135,
82
],
[
128,
85
],
[
114,
89
],
[
120,
92
],
[
78,
93
],
[
120,
95
],
[
78,
97
],
[
125,
100
],
[
114,
104
],
[
120,
107
],
[
126,
111
],
[
129,
111
],
[
123,
111
],
[
117,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
],
[
134,
135
]
] | [
"#https://atcoder.jp/contests/arc061/tasks/arc061_a\n\ns=input()\nn=len(s)\n\nnum=0\nfor i in range(2**(n-1)):\n flag=[]\n\n for j in range(n-1):\n if (i>>j)&1:\n flag.append(j)\n\n if len(flag)==0:\n num+=int(s)\n #print(int(s))\n else:\n for i in range(len(flag)):\n flag[i]+=1\n flag.insert(0,0)\n flag_num=len(flag)\n for k in range(flag_num-1):\n num+=int(s[flag[k]:flag[k+1]])\n #print(int(s[flag[k]:flag[k+1]]))\n num+=int(s[flag[-1]:])\n #print(int(s[flag[-1]:]))\n\nprint(num)\n",
"s=input()",
"s",
"input()",
"input",
"n=len(s)",
"n",
"len(s)",
"len",
"s",
"num=0",
"num",
"0",
"for i in range(2**(n-1)):\n flag=[]\n\n for j in range(n-1):\n if (i>>j)&1:\n flag.append(j)\n\n if len(flag)==0:\n num+=int(s)\n #print(int(s))\n else:\n for i in range(len(flag)):\n flag[i]+=1\n flag.insert(0,0)\n flag_num=len(flag)\n for k in range(flag_num-1):\n num+=int(s[flag[k]:flag[k+1]])\n #print(int(s[flag[k]:flag[k+1]]))\n num+=int(s[flag[-1]:])\n #print(int(s[flag[-1]:]))",
"i",
"range(2**(n-1))",
"range",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"flag=[]",
"flag",
"[]",
"for j in range(n-1):\n if (i>>j)&1:\n flag.append(j)\n\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i>>j)&1:\n flag.append(j)\n\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"flag.append(j)",
"flag.append",
"flag",
"append",
"j",
"if len(flag)==0:\n num+=int(s)\n #print(int(s))\n else:\n for i in range(len(flag)):\n flag[i]+=1\n flag.insert(0,0)\n flag_num=len(flag)\n for k in range(flag_num-1):\n num+=int(s[flag[k]:flag[k+1]])\n #print(int(s[flag[k]:flag[k+1]]))\n num+=int(s[flag[-1]:])\n #print(int(s[flag[-1]:]))",
"len(flag)==0",
"len(flag)",
"len",
"flag",
"0",
"num+=int(s)",
"num",
"int(s)",
"int",
"s",
"for i in range(len(flag)):\n flag[i]+=1\n ",
"i",
"range(len(flag))",
"range",
"len(flag)",
"len",
"flag",
"flag[i]+=1",
"flag[i]",
"flag",
"i",
"1",
"flag.insert(0,0)",
"flag.insert",
"flag",
"insert",
"0",
"0",
"flag_num=len(flag)",
"flag_num",
"len(flag)",
"len",
"flag",
"for k in range(flag_num-1):\n num+=int(s[flag[k]:flag[k+1]])\n #print(int(s[flag[k]:flag[k+1]]))\n ",
"k",
"range(flag_num-1)",
"range",
"flag_num-1",
"flag_num",
"1",
"num+=int(s[flag[k]:flag[k+1]])",
"num",
"int(s[flag[k]:flag[k+1]])",
"int",
"s[flag[k]:flag[k+1]]",
"s",
"flag[k]:flag[k+1]",
"flag[k]",
"flag",
"k",
"flag[k+1]",
"flag",
"k+1",
"k",
"1",
"num+=int(s[flag[-1]:])",
"num",
"int(s[flag[-1]:])",
"int",
"s[flag[-1]:]",
"s",
"flag[-1]:",
"flag[-1]",
"flag",
"-1",
"print(num)",
"print",
"num",
"s=input()",
"input()",
"s",
"num=0",
"0",
"num",
"flag=[]",
"[]",
"flag",
"num+=int(s)",
"int(s)",
"num",
"num+=int(s[flag[-1]:])",
"int(s[flag[-1]:])",
"num",
"num+=int(s[flag[k]:flag[k+1]])",
"int(s[flag[k]:flag[k+1]])",
"num",
"n=len(s)",
"len(s)",
"n",
"flag_num=len(flag)",
"len(flag)",
"flag_num"
] | #https://atcoder.jp/contests/arc061/tasks/arc061_a
s=input()
n=len(s)
num=0
for i in range(2**(n-1)):
flag=[]
for j in range(n-1):
if (i>>j)&1:
flag.append(j)
if len(flag)==0:
num+=int(s)
#print(int(s))
else:
for i in range(len(flag)):
flag[i]+=1
flag.insert(0,0)
flag_num=len(flag)
for k in range(flag_num-1):
num+=int(s[flag[k]:flag[k+1]])
#print(int(s[flag[k]:flag[k+1]]))
num+=int(s[flag[-1]:])
#print(int(s[flag[-1]:]))
print(num)
|
[
7,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
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,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13
] | [
[
65,
2
],
[
77,
6
],
[
10,
9
],
[
66,
17
],
[
80,
20
],
[
24,
23
],
[
66,
29
],
[
9,
34
],
[
23,
35
],
[
68,
38
],
[
66,
42
],
[
23,
46
],
[
74,
49
],
[
23,
51
],
[
71,
54
],
[
66,
58
],
[
72,
63
],
[
69,
63
],
[
78,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
]
] | [
"s = input()\n\nres = 0\nfor i in range(2**(len(s)-1)):\n pos = 0\n for j in range(len(s)-1):\n if (i >> j) & 1:\n res += int(s[pos:j+1])\n pos = j + 1\n res += int(s[pos:])\n\nprint(res)",
"s = input()",
"s",
"input()",
"input",
"res = 0",
"res",
"0",
"for i in range(2**(len(s)-1)):\n pos = 0\n for j in range(len(s)-1):\n if (i >> j) & 1:\n res += int(s[pos:j+1])\n pos = j + 1\n res += int(s[pos:])",
"i",
"range(2**(len(s)-1))",
"range",
"2**(len(s)-1)",
"2",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"pos = 0",
"pos",
"0",
"for j in range(len(s)-1):\n if (i >> j) & 1:\n res += int(s[pos:j+1])\n pos = j + 1\n ",
"j",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if (i >> j) & 1:\n res += int(s[pos:j+1])\n pos = j + 1\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"res += int(s[pos:j+1])",
"res",
"int(s[pos:j+1])",
"int",
"s[pos:j+1]",
"s",
"pos:j+1",
"pos",
"j+1",
"j",
"1",
"pos = j + 1",
"pos",
"j + 1",
"j",
"1",
"res += int(s[pos:])",
"res",
"int(s[pos:])",
"int",
"s[pos:]",
"s",
"pos:",
"pos",
"print(res)",
"print",
"res",
"s = input()",
"input()",
"s",
"res += int(s[pos:j+1])",
"int(s[pos:j+1])",
"res",
"res += int(s[pos:])",
"int(s[pos:])",
"res",
"pos = j + 1",
"j + 1",
"pos",
"res = 0",
"0",
"res",
"pos = 0",
"0",
"pos"
] | s = input()
res = 0
for i in range(2**(len(s)-1)):
pos = 0
for j in range(len(s)-1):
if (i >> j) & 1:
res += int(s[pos:j+1])
pos = j + 1
res += int(s[pos:])
print(res) |
[
7,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
17,
14,
13,
23,
13,
17,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
17,
14,
13,
23,
13,
17,
41,
28,
13,
4,
13,
13,
4,
17,
12,
13,
23,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
2,
13,
39,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
12,
13,
10,
12,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13
] | [
[
36,
35
],
[
44,
38
],
[
45,
44
],
[
53,
52
],
[
61,
55
],
[
62,
61
],
[
66,
65
],
[
74,
74
],
[
221,
83
],
[
194,
90
],
[
230,
97
],
[
218,
102
],
[
185,
107
],
[
197,
112
],
[
189,
114
],
[
200,
116
],
[
198,
120
],
[
182,
123
],
[
127,
126
],
[
201,
131
],
[
135,
134
],
[
201,
137
],
[
227,
141
],
[
148,
147
],
[
201,
150
],
[
126,
154
],
[
147,
155
],
[
224,
158
],
[
162,
161
],
[
201,
165
],
[
179,
168
],
[
225,
171
],
[
180,
174
],
[
183,
174
],
[
179,
180
],
[
182,
183
],
[
185,
186
],
[
194,
195
],
[
197,
198
],
[
200,
201
],
[
218,
219
],
[
221,
222
],
[
224,
225
],
[
227,
228
],
[
230,
231
]
] | [
"import numpy as np\nimport scipy.sparse as sps\nimport scipy.misc as spm\nimport collections as col\nimport functools as func\nimport itertools as ite\nimport fractions as frac\nimport math as ma\nimport cmath as cma\nimport copy as cp\nimport sys\ndef sinput(): return sys.stdin.readline().strip()\ndef iinput(): return int(sinput())\ndef imap(): return map(int, sinput().split())\ndef fmap(): return map(float, sinput().split())\ndef iarr(n=0):\n if n: return [0 for _ in range(n)]\n else: return list(imap())\ndef farr(): return list(fmap())\ndef sarr(n=0):\n if n: return [\"\" for _ in range(n)]\n else: return sinput().split()\ndef barr(n): return [False for _ in range(n)]\nsys.setrecursionlimit(10**7)\nMOD = 10**9 + 7; EPS = sys.float_info.epsilon\nPI = np.pi; EXP = np.e; INF = np.inf\n\ns = sinput()\nn = len(s) - 1\n\nsum = 0\nfor i in range(2**n):\n plus = [\"\" for i in range(n)] + [\"\"]\n for j in range(n):\n if i>>j&1: plus[j] = \"+\"\n equa = \"\"\n for k in range(n+1): equa += s[k] + plus[k]\n sum += eval(equa)\n\nprint(sum)",
"import numpy as np",
"numpy",
"import scipy.sparse as sps",
"scipy.sparse",
"import scipy.misc as spm",
"scipy.misc",
"import collections as col",
"collections",
"import functools as func",
"functools",
"import itertools as ite",
"itertools",
"import fractions as frac",
"fractions",
"import math as ma",
"math",
"import cmath as cma",
"cmath",
"import copy as cp",
"copy",
"import sys",
"sys",
"def sinput(): return sys.stdin.readline().strip()",
"sinput",
"def iinput(): return int(sinput())",
"iinput",
"def imap(): return map(int, sinput().split())",
"imap",
"def fmap(): return map(float, sinput().split())",
"fmap",
"def iarr(n=0):\n if n: return [0 for _ in range(n)]\n else: return list(imap())",
"iarr",
"0 for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"0",
"if n: return [0 for _ in range(n)]\n else: return list(imap())",
"n",
"n=0",
"n",
"0",
"def farr(): return list(fmap())",
"farr",
"def sarr(n=0):\n if n: return [\"\" for _ in range(n)]\n else: return sinput().split()",
"sarr",
"\"\" for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"\"\"",
"if n: return [\"\" for _ in range(n)]\n else: return sinput().split()",
"n",
"n=0",
"n",
"0",
"False for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"False",
"def barr(n): return [False for _ in range(n)]",
"barr",
"n",
"n",
"sys.setrecursionlimit(10**7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**7",
"10",
"7",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"EPS = sys.float_info.epsilon",
"EPS",
"sys.float_info.epsilon",
"sys.float_info",
"sys",
"float_info",
"epsilon",
"PI = np.pi",
"PI",
"np.pi",
"np",
"pi",
"EXP = np.e",
"EXP",
"np.e",
"np",
"e",
"INF = np.inf",
"INF",
"np.inf",
"np",
"inf",
"s = sinput()",
"s",
"sinput()",
"sinput",
"n = len(s) - 1",
"n",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"sum = 0",
"sum",
"0",
"for i in range(2**n):\n plus = [\"\" for i in range(n)] + [\"\"]\n for j in range(n):\n if i>>j&1: plus[j] = \"+\"\n equa = \"\"\n for k in range(n+1): equa += s[k] + plus[k]\n sum += eval(equa)",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"\"\" for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"\"\"",
"plus = [\"\" for i in range(n)] + [\"\"]",
"plus",
"[\"\" for i in range(n)] + [\"\"]",
"[\"\" for i in range(n)]",
"[\"\"]",
"\"\"",
"for j in range(n):\n if i>>j&1: plus[j] = \"+\"\n ",
"j",
"range(n)",
"range",
"n",
"if i>>j&1: plus[j] = \"+\"\n ",
"i>>j&1",
"i>>j",
"i",
"j",
"1",
"equa = \"\"",
"equa",
"\"\"",
"for k in range(n+1): equa += s[k] + plus[k]\n ",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"sum += eval(equa)",
"sum",
"eval(equa)",
"eval",
"equa",
"print(sum)",
"print",
"sum",
"def barr(n): return [False for _ in range(n)]",
"def barr(n): return [False for _ in range(n)]",
"barr",
"sum += eval(equa)",
"eval(equa)",
"sum",
"sum = 0",
"0",
"sum",
"INF = np.inf",
"np.inf",
"INF",
"def sinput(): return sys.stdin.readline().strip()",
"def sinput(): return sys.stdin.readline().strip()",
"sinput",
"def fmap(): return map(float, sinput().split())",
"def fmap(): return map(float, sinput().split())",
"fmap",
"EPS = sys.float_info.epsilon",
"sys.float_info.epsilon",
"EPS",
"s = sinput()",
"sinput()",
"s",
"n = len(s) - 1",
"len(s) - 1",
"n",
"def imap(): return map(int, sinput().split())",
"def imap(): return map(int, sinput().split())",
"imap",
"def iinput(): return int(sinput())",
"def iinput(): return int(sinput())",
"iinput",
"def farr(): return list(fmap())",
"def farr(): return list(fmap())",
"farr",
"def iarr(n=0):\n if n: return [0 for _ in range(n)]\n else: return list(imap())",
"def iarr(n=0):\n if n: return [0 for _ in range(n)]\n else: return list(imap())",
"iarr",
"def sarr(n=0):\n if n: return [\"\" for _ in range(n)]\n else: return sinput().split()",
"def sarr(n=0):\n if n: return [\"\" for _ in range(n)]\n else: return sinput().split()",
"sarr",
"EXP = np.e",
"np.e",
"EXP",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"equa = \"\"",
"\"\"",
"equa",
"plus = [\"\" for i in range(n)] + [\"\"]",
"[\"\" for i in range(n)] + [\"\"]",
"plus",
"PI = np.pi",
"np.pi",
"PI"
] | import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
import cmath as cma
import copy as cp
import sys
def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
if n: return [0 for _ in range(n)]
else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
if n: return ["" for _ in range(n)]
else: return sinput().split()
def barr(n): return [False for _ in range(n)]
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7; EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf
s = sinput()
n = len(s) - 1
sum = 0
for i in range(2**n):
plus = ["" for i in range(n)] + [""]
for j in range(n):
if i>>j&1: plus[j] = "+"
equa = ""
for k in range(n+1): equa += s[k] + plus[k]
sum += eval(equa)
print(sum)
|
[
7,
15,
13,
12,
13,
14,
2,
13,
4,
13,
13,
29,
4,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
29,
2,
4,
13,
2,
13,
18,
13,
13,
2,
13,
17,
4,
13,
2,
2,
13,
17,
18,
13,
13,
2,
13,
17,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
4,
13,
4,
13,
18,
13,
17,
17,
10,
4,
13,
10,
12,
13
] | [
[
51,
7
],
[
49,
21
],
[
49,
29
],
[
51,
32
],
[
51,
34
],
[
49,
40
],
[
51,
44
],
[
51,
46
],
[
49,
49
],
[
51,
51
],
[
67,
53
],
[
71,
61
],
[
68,
63
],
[
67,
68
]
] | [
"import sys\n# -*- coding: utf-8 -*-\n\n#calc(\"\",1234) = calc(\"1\",234) + calc(\"1+\"\",234)\n#calc(\"1\",234) = calc(\"12\",34) + calc(\"12+\",34)\n#calc(\"12+\",34) = calc(\"12+3\",4) + calc(\"12+3+\",4)\n#calc(\"12+3\",4) = calc(\"12+34\")\ndef calc(express,i):\n if i == len(nums):\n return sum(list(map(int,express.split(\"+\"))))\n return calc(express + nums[i],i+1) + calc(express + \"+\"+ nums[i] ,i+1) \n\nnums = list(input())\nprint(calc(nums[0],1))",
"import sys",
"sys",
"def calc(express,i):\n if i == len(nums):\n return sum(list(map(int,express.split(\"+\"))))\n return calc(express + nums[i],i+1) + calc(express + \"+\"+ nums[i] ,i+1) ",
"calc",
"if i == len(nums):\n return sum(list(map(int,express.split(\"+\"))))\n ",
"i == len(nums)",
"i",
"len(nums)",
"len",
"nums",
"return sum(list(map(int,express.split(\"+\"))))",
"sum(list(map(int,express.split(\"+\"))))",
"sum",
"list(map(int,express.split(\"+\")))",
"list",
"map(int,express.split(\"+\"))",
"map",
"int",
"express.split(\"+\")",
"express.split",
"express",
"split",
"\"+\"",
"return calc(express + nums[i],i+1) + calc(express + \"+\"+ nums[i] ,i+1)",
"calc(express + nums[i],i+1) + calc(express + \"+\"+ nums[i] ,i+1)",
"calc(express + nums[i],i+1)",
"calc",
"express + nums[i]",
"express",
"nums[i]",
"nums",
"i",
"i+1",
"i",
"1",
"calc(express + \"+\"+ nums[i] ,i+1)",
"calc",
"express + \"+\"+ nums[i]",
"express + \"+\"",
"express",
"\"+\"",
"nums[i]",
"nums",
"i",
"i+1",
"i",
"1",
"express",
"express",
"i",
"i",
"nums = list(input())",
"nums",
"list(input())",
"list",
"input()",
"input",
"print(calc(nums[0],1))",
"print",
"calc(nums[0],1)",
"calc",
"nums[0]",
"nums",
"0",
"1",
"nums = list(input())",
"list(input())",
"nums",
"def calc(express,i):\n if i == len(nums):\n return sum(list(map(int,express.split(\"+\"))))\n return calc(express + nums[i],i+1) + calc(express + \"+\"+ nums[i] ,i+1) ",
"def calc(express,i):\n if i == len(nums):\n return sum(list(map(int,express.split(\"+\"))))\n return calc(express + nums[i],i+1) + calc(express + \"+\"+ nums[i] ,i+1) ",
"calc"
] | import sys
# -*- coding: utf-8 -*-
#calc("",1234) = calc("1",234) + calc("1+"",234)
#calc("1",234) = calc("12",34) + calc("12+",34)
#calc("12+",34) = calc("12+3",4) + calc("12+3+",4)
#calc("12+3",4) = calc("12+34")
def calc(express,i):
if i == len(nums):
return sum(list(map(int,express.split("+"))))
return calc(express + nums[i],i+1) + calc(express + "+"+ nums[i] ,i+1)
nums = list(input())
print(calc(nums[0],1))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
39,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
17,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
18,
13,
13,
17,
4,
18,
13,
13,
13,
28,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
4,
13,
13,
14,
2,
2,
13,
17,
17,
0,
13,
18,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
2,
13,
17,
17,
0,
13,
17,
4,
18,
13,
13,
13,
28,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
39,
13
] | [
[
127,
2
],
[
142,
8
],
[
128,
11
],
[
151,
13
],
[
133,
16
],
[
139,
19
],
[
23,
22
],
[
143,
28
],
[
33,
32
],
[
143,
36
],
[
124,
41
],
[
45,
44
],
[
143,
48
],
[
22,
53
],
[
44,
54
],
[
60,
57
],
[
125,
58
],
[
44,
59
],
[
152,
63
],
[
125,
65
],
[
68,
67
],
[
152,
67
],
[
136,
70
],
[
74,
73
],
[
143,
77
],
[
67,
80
],
[
73,
84
],
[
148,
88
],
[
128,
90
],
[
73,
94
],
[
67,
99
],
[
73,
101
],
[
130,
105
],
[
134,
109
],
[
131,
111
],
[
149,
111
],
[
137,
111
],
[
114,
113
],
[
134,
113
],
[
145,
116
],
[
113,
119
],
[
146,
122
],
[
140,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
]
] | [
"N = str(input())\nt = len(N)\nbi_li =[]\nli_formula = []\ntotal = 0\n\nfor i in range(2**(t-1)):\n temp =[0 for _ in range(t-1)]\n for p in range(t-1):\n if ((i >> p) & 1):\n temp[p] =1\n bi_li.append(temp)\n\nfor k in bi_li:\n formula =\"\"\n for j in range(t+len(k)):\n if j%2==0:\n formula+=N[int(j/2)]\n else:\n if k[j//2] == 1:\n formula+=\"+\"\n li_formula.append(formula)\n\nfor l in li_formula:\n total += eval(l)\nprint(total)",
"N = str(input())",
"N",
"str(input())",
"str",
"input()",
"input",
"t = len(N)",
"t",
"len(N)",
"len",
"N",
"bi_li =[]",
"bi_li",
"[]",
"li_formula = []",
"li_formula",
"[]",
"total = 0",
"total",
"0",
"for i in range(2**(t-1)):\n temp =[0 for _ in range(t-1)]\n for p in range(t-1):\n if ((i >> p) & 1):\n temp[p] =1\n bi_li.append(temp)",
"i",
"range(2**(t-1))",
"range",
"2**(t-1)",
"2",
"t-1",
"t",
"1",
"0 for _ in range(t-1)",
"for _ in range(t-1)",
"_",
"range(t-1)",
"range",
"t-1",
"t",
"1",
"for _ in range(t-1)",
"0",
"temp =[0 for _ in range(t-1)]",
"temp",
"[0 for _ in range(t-1)]",
"for p in range(t-1):\n if ((i >> p) & 1):\n temp[p] =1\n ",
"p",
"range(t-1)",
"range",
"t-1",
"t",
"1",
"if ((i >> p) & 1):\n temp[p] =1\n ",
"(i >> p) & 1",
"i >> p",
"i",
"p",
"1",
"temp[p] =1",
"temp[p]",
"temp",
"p",
"1",
"bi_li.append(temp)",
"bi_li.append",
"bi_li",
"append",
"temp",
"for k in bi_li:\n formula =\"\"\n for j in range(t+len(k)):\n if j%2==0:\n formula+=N[int(j/2)]\n else:\n if k[j//2] == 1:\n formula+=\"+\"\n li_formula.append(formula)",
"k",
"bi_li",
"formula =\"\"",
"formula",
"\"\"",
"for j in range(t+len(k)):\n if j%2==0:\n formula+=N[int(j/2)]\n else:\n if k[j//2] == 1:\n formula+=\"+\"\n ",
"j",
"range(t+len(k))",
"range",
"t+len(k)",
"t",
"len(k)",
"len",
"k",
"if j%2==0:\n formula+=N[int(j/2)]\n else:\n if k[j//2] == 1:\n formula+=\"+\"\n ",
"j%2==0",
"j%2",
"j",
"2",
"0",
"formula+=N[int(j/2)]",
"formula",
"N[int(j/2)]",
"N",
"int(j/2)",
"int",
"j/2",
"j",
"2",
"if k[j//2] == 1:\n formula+=\"+\"\n ",
"k[j//2] == 1",
"k[j//2]",
"k",
"j//2",
"j",
"2",
"1",
"formula+=\"+\"",
"formula",
"\"+\"",
"li_formula.append(formula)",
"li_formula.append",
"li_formula",
"append",
"formula",
"for l in li_formula:\n total += eval(l)",
"l",
"li_formula",
"total += eval(l)",
"total",
"eval(l)",
"eval",
"l",
"print(total)",
"print",
"total",
"temp =[0 for _ in range(t-1)]",
"[0 for _ in range(t-1)]",
"temp",
"N = str(input())",
"str(input())",
"N",
"formula+=\"+\"",
"\"+\"",
"formula",
"li_formula = []",
"[]",
"li_formula",
"formula =\"\"",
"\"\"",
"formula",
"total = 0",
"0",
"total",
"t = len(N)",
"len(N)",
"t",
"total += eval(l)",
"eval(l)",
"total",
"formula+=N[int(j/2)]",
"N[int(j/2)]",
"formula",
"bi_li =[]",
"[]",
"bi_li"
] | N = str(input())
t = len(N)
bi_li =[]
li_formula = []
total = 0
for i in range(2**(t-1)):
temp =[0 for _ in range(t-1)]
for p in range(t-1):
if ((i >> p) & 1):
temp[p] =1
bi_li.append(temp)
for k in bi_li:
formula =""
for j in range(t+len(k)):
if j%2==0:
formula+=N[int(j/2)]
else:
if k[j//2] == 1:
formula+="+"
li_formula.append(formula)
for l in li_formula:
total += eval(l)
print(total) |
[
7,
12,
13,
14,
2,
13,
13,
0,
13,
17,
0,
13,
18,
13,
17,
0,
13,
4,
18,
13,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
29,
13,
29,
2,
4,
13,
13,
2,
13,
17,
13,
2,
2,
13,
18,
13,
2,
13,
17,
17,
4,
13,
13,
2,
13,
17,
13,
2,
13,
18,
13,
2,
13,
17,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
17,
0,
13,
4,
13,
4,
13,
4,
13,
4,
13,
13,
17,
13,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13
] | [
[
65,
5
],
[
67,
6
],
[
9,
8
],
[
12,
11
],
[
69,
13
],
[
17,
16
],
[
11,
19
],
[
71,
19
],
[
24,
23
],
[
16,
23
],
[
27,
26
],
[
23,
29
],
[
26,
31
],
[
8,
31
],
[
65,
36
],
[
67,
38
],
[
69,
40
],
[
11,
43
],
[
71,
43
],
[
69,
45
],
[
67,
47
],
[
65,
52
],
[
67,
54
],
[
69,
56
],
[
11,
58
],
[
71,
58
],
[
69,
60
],
[
67,
62
],
[
65,
65
],
[
67,
67
],
[
69,
69
],
[
71,
71
],
[
96,
73
],
[
90,
76
],
[
94,
82
],
[
91,
85
],
[
91,
87
],
[
97,
88
],
[
90,
91
],
[
96,
97
]
] | [
"def func(i,x,s,new):\n if i==x:\n count=0\n #print(i,x,s,new+[s[-1]])\n new+=s[-1]\n li=new.split(\"+\")\n for j in li:\n count+=int(j)\n\n return count\n\n #print(i,x,s,new)\n return func(i,x+1,s,new+s[x-1]+\"+\") + func(i,x+1,s,new+s[x-1])\n\nnew=\"\"\nS=input()\nprint(func(len(S),1,S,new))",
"def func(i,x,s,new):\n if i==x:\n count=0\n #print(i,x,s,new+[s[-1]])\n new+=s[-1]\n li=new.split(\"+\")\n for j in li:\n count+=int(j)\n\n return count\n\n #print(i,x,s,new)\n return func(i,x+1,s,new+s[x-1]+\"+\") + func(i,x+1,s,new+s[x-1])",
"func",
"if i==x:\n count=0\n #print(i,x,s,new+[s[-1]])\n new+=s[-1]\n li=new.split(\"+\")\n for j in li:\n count+=int(j)\n\n return count\n\n #print(i,x,s,new)\n ",
"i==x",
"i",
"x",
"count=0",
"count",
"0",
"new+=s[-1]",
"new",
"s[-1]",
"s",
"-1",
"li=new.split(\"+\")",
"li",
"new.split(\"+\")",
"new.split",
"new",
"split",
"\"+\"",
"for j in li:\n count+=int(j)\n\n ",
"j",
"li",
"count+=int(j)",
"count",
"int(j)",
"int",
"j",
"return count",
"count",
"return func(i,x+1,s,new+s[x-1]+\"+\") + func(i,x+1,s,new+s[x-1])",
"func(i,x+1,s,new+s[x-1]+\"+\") + func(i,x+1,s,new+s[x-1])",
"func(i,x+1,s,new+s[x-1]+\"+\")",
"func",
"i",
"x+1",
"x",
"1",
"s",
"new+s[x-1]+\"+\"",
"new+s[x-1]",
"new",
"s[x-1]",
"s",
"x-1",
"x",
"1",
"\"+\"",
"func(i,x+1,s,new+s[x-1])",
"func",
"i",
"x+1",
"x",
"1",
"s",
"new+s[x-1]",
"new",
"s[x-1]",
"s",
"x-1",
"x",
"1",
"i",
"i",
"x",
"x",
"s",
"s",
"new",
"new",
"new=\"\"",
"new",
"\"\"",
"S=input()",
"S",
"input()",
"input",
"print(func(len(S),1,S,new))",
"print",
"func(len(S),1,S,new)",
"func",
"len(S)",
"len",
"S",
"1",
"S",
"new",
"S=input()",
"input()",
"S",
"def func(i,x,s,new):\n if i==x:\n count=0\n #print(i,x,s,new+[s[-1]])\n new+=s[-1]\n li=new.split(\"+\")\n for j in li:\n count+=int(j)\n\n return count\n\n #print(i,x,s,new)\n return func(i,x+1,s,new+s[x-1]+\"+\") + func(i,x+1,s,new+s[x-1])",
"def func(i,x,s,new):\n if i==x:\n count=0\n #print(i,x,s,new+[s[-1]])\n new+=s[-1]\n li=new.split(\"+\")\n for j in li:\n count+=int(j)\n\n return count\n\n #print(i,x,s,new)\n return func(i,x+1,s,new+s[x-1]+\"+\") + func(i,x+1,s,new+s[x-1])",
"func",
"new=\"\"",
"\"\"",
"new"
] | def func(i,x,s,new):
if i==x:
count=0
#print(i,x,s,new+[s[-1]])
new+=s[-1]
li=new.split("+")
for j in li:
count+=int(j)
return count
#print(i,x,s,new)
return func(i,x+1,s,new+s[x-1]+"+") + func(i,x+1,s,new+s[x-1])
new=""
S=input()
print(func(len(S),1,S,new))
|
[
7,
0,
13,
4,
13,
4,
13,
13,
4,
13,
0,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
18,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
17,
13,
0,
13,
4,
13,
4,
13,
4,
13,
2,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
17,
0,
13,
2,
39,
17,
13,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
40,
2,
13,
17,
4,
13,
13,
0,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
17,
13,
14,
2,
4,
13,
18,
13,
2,
2,
13,
13,
17,
17,
0,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
2,
4,
13,
13,
17,
13,
0,
13,
17,
0,
13,
18,
13,
2,
2,
4,
13,
13,
17,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] | [
[
175,
2
],
[
181,
11
],
[
176,
14
],
[
182,
17
],
[
176,
22
],
[
178,
25
],
[
182,
27
],
[
169,
30
],
[
179,
34
],
[
182,
34
],
[
184,
36
],
[
170,
44
],
[
151,
48
],
[
52,
51
],
[
170,
54
],
[
166,
56
],
[
51,
61
],
[
157,
64
],
[
185,
68
],
[
187,
70
],
[
176,
72
],
[
190,
75
],
[
79,
78
],
[
185,
81
],
[
78,
85
],
[
167,
89
],
[
98,
91
],
[
158,
92
],
[
185,
95
],
[
78,
96
],
[
167,
99
],
[
78,
102
],
[
158,
108
],
[
185,
111
],
[
78,
112
],
[
163,
116
],
[
191,
118
],
[
161,
118
],
[
164,
118
],
[
154,
121
],
[
164,
123
],
[
191,
123
],
[
161,
123
],
[
176,
125
],
[
176,
130
],
[
78,
132
],
[
160,
134
],
[
172,
137
],
[
176,
139
],
[
176,
144
],
[
78,
146
],
[
173,
149
],
[
155,
149
],
[
188,
149
],
[
152,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
],
[
181,
182
],
[
184,
185
],
[
187,
188
],
[
190,
191
]
] | [
"S=list(map(int,input()))\ns=len(S)\nif s==1:\n print(S[0])\nelse:\n\n s=s-1\n t=pow(2,s)\n l=len(list(format(t-1,'b')))\n x=0\n for i in range(t):\n k=list(format(i,'b'))\n L=[0]*l\n x+=S[-1]\n v=1\n for i in range(l):\n if i+1<=len(k):\n L[l-i-1]=k[-1-i]\n if int(L[l-i-1])==0:\n v=v*10\n x+=v*S[len(S)-2-i]\n else:\n v=1\n x+=S[len(S)-2-i]\n print(x)\n\n \n \n\n",
"S=list(map(int,input()))",
"S",
"list(map(int,input()))",
"list",
"map(int,input())",
"map",
"int",
"input()",
"input",
"s=len(S)",
"s",
"len(S)",
"len",
"S",
"if s==1:\n print(S[0])\nelse:\n\n s=s-1\n t=pow(2,s)\n l=len(list(format(t-1,'b')))\n x=0\n for i in range(t):\n k=list(format(i,'b'))\n L=[0]*l\n x+=S[-1]\n v=1\n for i in range(l):\n if i+1<=len(k):\n L[l-i-1]=k[-1-i]\n if int(L[l-i-1])==0:\n v=v*10\n x+=v*S[len(S)-2-i]\n else:\n v=1\n x+=S[len(S)-2-i]\n print(x)\n\n \n ",
"s==1",
"s",
"1",
"print(S[0])",
"print",
"S[0]",
"S",
"0",
"s=s-1",
"s",
"s-1",
"s",
"1",
"t=pow(2,s)",
"t",
"pow(2,s)",
"pow",
"2",
"s",
"l=len(list(format(t-1,'b')))",
"l",
"len(list(format(t-1,'b')))",
"len",
"list(format(t-1,'b'))",
"list",
"format(t-1,'b')",
"format",
"t-1",
"t",
"1",
"'b'",
"x=0",
"x",
"0",
"for i in range(t):\n k=list(format(i,'b'))\n L=[0]*l\n x+=S[-1]\n v=1\n for i in range(l):\n if i+1<=len(k):\n L[l-i-1]=k[-1-i]\n if int(L[l-i-1])==0:\n v=v*10\n x+=v*S[len(S)-2-i]\n else:\n v=1\n x+=S[len(S)-2-i]\n ",
"i",
"range(t)",
"range",
"t",
"k=list(format(i,'b'))",
"k",
"list(format(i,'b'))",
"list",
"format(i,'b')",
"format",
"i",
"'b'",
"L=[0]*l",
"L",
"[0]*l",
"[0]",
"0",
"l",
"x+=S[-1]",
"x",
"S[-1]",
"S",
"-1",
"v=1",
"v",
"1",
"for i in range(l):\n if i+1<=len(k):\n L[l-i-1]=k[-1-i]\n if int(L[l-i-1])==0:\n v=v*10\n x+=v*S[len(S)-2-i]\n else:\n v=1\n x+=S[len(S)-2-i]\n ",
"i",
"range(l)",
"range",
"l",
"if i+1<=len(k):\n L[l-i-1]=k[-1-i]\n ",
"i+1<=len(k)",
"i+1",
"i",
"1",
"len(k)",
"len",
"k",
"L[l-i-1]=k[-1-i]",
"L[l-i-1]",
"L",
"l-i-1",
"l-i",
"l",
"i",
"1",
"k[-1-i]",
"k",
"-1-i",
"-1",
"i",
"if int(L[l-i-1])==0:\n v=v*10\n x+=v*S[len(S)-2-i]\n else:\n v=1\n x+=S[len(S)-2-i]\n ",
"int(L[l-i-1])==0",
"int(L[l-i-1])",
"int",
"L[l-i-1]",
"L",
"l-i-1",
"l-i",
"l",
"i",
"1",
"0",
"v=v*10",
"v",
"v*10",
"v",
"10",
"x+=v*S[len(S)-2-i]",
"x",
"v*S[len(S)-2-i]",
"v",
"S[len(S)-2-i]",
"S",
"len(S)-2-i",
"len(S)-2",
"len(S)",
"len",
"S",
"2",
"i",
"v=1",
"v",
"1",
"x+=S[len(S)-2-i]",
"x",
"S[len(S)-2-i]",
"S",
"len(S)-2-i",
"len(S)-2",
"len(S)",
"len",
"S",
"2",
"i",
"print(x)",
"print",
"x",
"x=0",
"0",
"x",
"x+=v*S[len(S)-2-i]",
"v*S[len(S)-2-i]",
"x",
"L=[0]*l",
"[0]*l",
"L",
"v=1",
"1",
"v",
"v=v*10",
"v*10",
"v",
"k=list(format(i,'b'))",
"list(format(i,'b'))",
"k",
"t=pow(2,s)",
"pow(2,s)",
"t",
"x+=S[len(S)-2-i]",
"S[len(S)-2-i]",
"x",
"S=list(map(int,input()))",
"list(map(int,input()))",
"S",
"s=s-1",
"s-1",
"s",
"s=len(S)",
"len(S)",
"s",
"l=len(list(format(t-1,'b')))",
"len(list(format(t-1,'b')))",
"l",
"x+=S[-1]",
"S[-1]",
"x",
"v=1",
"1",
"v"
] | S=list(map(int,input()))
s=len(S)
if s==1:
print(S[0])
else:
s=s-1
t=pow(2,s)
l=len(list(format(t-1,'b')))
x=0
for i in range(t):
k=list(format(i,'b'))
L=[0]*l
x+=S[-1]
v=1
for i in range(l):
if i+1<=len(k):
L[l-i-1]=k[-1-i]
if int(L[l-i-1])==0:
v=v*10
x+=v*S[len(S)-2-i]
else:
v=1
x+=S[len(S)-2-i]
print(x)
|
[
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,
28,
13,
4,
13,
13,
14,
2,
13,
2,
17,
13,
0,
18,
13,
13,
2,
18,
13,
13,
17,
0,
13,
4,
18,
17,
13,
13,
14,
2,
17,
13,
0,
13,
2,
13,
4,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
2,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
91,
2
],
[
88,
6
],
[
92,
10
],
[
94,
13
],
[
17,
16
],
[
89,
21
],
[
97,
23
],
[
92,
26
],
[
29,
28
],
[
89,
31
],
[
16,
34
],
[
28,
37
],
[
42,
39
],
[
98,
40
],
[
101,
40
],
[
28,
41
],
[
39,
43
],
[
98,
44
],
[
101,
44
],
[
28,
45
],
[
100,
48
],
[
98,
53
],
[
101,
53
],
[
101,
57
],
[
98,
57
],
[
85,
59
],
[
95,
61
],
[
104,
61
],
[
86,
61
],
[
101,
71
],
[
98,
71
],
[
103,
75
],
[
95,
77
],
[
104,
77
],
[
86,
77
],
[
101,
80
],
[
98,
80
],
[
104,
83
],
[
86,
83
],
[
95,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
]
] | [
"s = input()\n#word = []\n#for i in range(len(s)):\n# word.append(int(s[i]))\ninterval = len(s) - 1\nans = 0\nfor i in range(2**interval):\n f = list(s)\n for j in range(interval):\n if (i & (1<<j)):\n f[j] = f[j] + '+'\n f = \"\".join(f)\n #print(f)\n if '+' in f:\n #print(f.split('+'))\n ans = ans + sum(list(map(int,f.split('+'))))\n else:\n ans = ans + int(f)\nprint(ans)",
"s = input()",
"s",
"input()",
"input",
"interval = len(s) - 1",
"interval",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"ans = 0",
"ans",
"0",
"for i in range(2**interval):\n f = list(s)\n for j in range(interval):\n if (i & (1<<j)):\n f[j] = f[j] + '+'\n f = \"\".join(f)\n #print(f)\n if '+' in f:\n #print(f.split('+'))\n ans = ans + sum(list(map(int,f.split('+'))))\n else:\n ans = ans + int(f)",
"i",
"range(2**interval)",
"range",
"2**interval",
"2",
"interval",
"f = list(s)",
"f",
"list(s)",
"list",
"s",
"for j in range(interval):\n if (i & (1<<j)):\n f[j] = f[j] + '+'\n ",
"j",
"range(interval)",
"range",
"interval",
"if (i & (1<<j)):\n f[j] = f[j] + '+'\n ",
"i & (1<<j)",
"i",
"1<<j",
"1",
"j",
"f[j] = f[j] + '+'",
"f[j]",
"f",
"j",
"f[j] + '+'",
"f[j]",
"f",
"j",
"'+'",
"f = \"\".join(f)",
"f",
"\"\".join(f)",
"\"\".join",
"\"\"",
"join",
"f",
"if '+' in f:\n #print(f.split('+'))\n ans = ans + sum(list(map(int,f.split('+'))))\n else:\n ans = ans + int(f)",
"'+' in f",
"'+'",
"f",
"ans = ans + sum(list(map(int,f.split('+'))))",
"ans",
"ans + sum(list(map(int,f.split('+'))))",
"ans",
"sum(list(map(int,f.split('+'))))",
"sum",
"list(map(int,f.split('+')))",
"list",
"map(int,f.split('+'))",
"map",
"int",
"f.split('+')",
"f.split",
"f",
"split",
"'+'",
"ans = ans + int(f)",
"ans",
"ans + int(f)",
"ans",
"int(f)",
"int",
"f",
"print(ans)",
"print",
"ans",
"ans = ans + sum(list(map(int,f.split('+'))))",
"ans + sum(list(map(int,f.split('+'))))",
"ans",
"interval = len(s) - 1",
"len(s) - 1",
"interval",
"s = input()",
"input()",
"s",
"ans = 0",
"0",
"ans",
"f = list(s)",
"list(s)",
"f",
"f = \"\".join(f)",
"\"\".join(f)",
"f",
"ans = ans + int(f)",
"ans + int(f)",
"ans"
] | s = input()
#word = []
#for i in range(len(s)):
# word.append(int(s[i]))
interval = len(s) - 1
ans = 0
for i in range(2**interval):
f = list(s)
for j in range(interval):
if (i & (1<<j)):
f[j] = f[j] + '+'
f = "".join(f)
#print(f)
if '+' in f:
#print(f.split('+'))
ans = ans + sum(list(map(int,f.split('+'))))
else:
ans = ans + int(f)
print(ans) |
[
7,
0,
13,
4,
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,
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,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13
] | [
[
81,
2
],
[
78,
6
],
[
10,
9
],
[
82,
17
],
[
75,
20
],
[
82,
22
],
[
26,
25
],
[
82,
31
],
[
9,
36
],
[
25,
37
],
[
84,
40
],
[
82,
44
],
[
25,
46
],
[
87,
49
],
[
82,
51
],
[
25,
53
],
[
72,
56
],
[
88,
66
],
[
85,
66
],
[
76,
66
],
[
73,
70
],
[
79,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
]
] | [
"S = input()\nans = 0\nfor i in range(2 ** (len(S) - 1)):\n txt = S[0]\n for j in range(len(S) - 1):\n if i >> j & 1:\n txt += \" \" + S[j + 1]\n else:\n txt += S[j + 1]\n ans += sum(list(map(int, txt.split())))\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (len(S) - 1)):\n txt = S[0]\n for j in range(len(S) - 1):\n if i >> j & 1:\n txt += \" \" + S[j + 1]\n else:\n txt += S[j + 1]\n ans += sum(list(map(int, txt.split())))",
"i",
"range(2 ** (len(S) - 1))",
"range",
"2 ** (len(S) - 1)",
"2",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"txt = S[0]",
"txt",
"S[0]",
"S",
"0",
"for j in range(len(S) - 1):\n if i >> j & 1:\n txt += \" \" + S[j + 1]\n else:\n txt += S[j + 1]\n ",
"j",
"range(len(S) - 1)",
"range",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"if i >> j & 1:\n txt += \" \" + S[j + 1]\n else:\n txt += S[j + 1]\n ",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"txt += \" \" + S[j + 1]",
"txt",
"\" \" + S[j + 1]",
"\" \"",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"txt += S[j + 1]",
"txt",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"ans += sum(list(map(int, txt.split())))",
"ans",
"sum(list(map(int, txt.split())))",
"sum",
"list(map(int, txt.split()))",
"list",
"map(int, txt.split())",
"map",
"int",
"txt.split()",
"txt.split",
"txt",
"split",
"print(ans)",
"print",
"ans",
"ans += sum(list(map(int, txt.split())))",
"sum(list(map(int, txt.split())))",
"ans",
"txt = S[0]",
"S[0]",
"txt",
"ans = 0",
"0",
"ans",
"S = input()",
"input()",
"S",
"txt += \" \" + S[j + 1]",
"\" \" + S[j + 1]",
"txt",
"txt += S[j + 1]",
"S[j + 1]",
"txt"
] | S = input()
ans = 0
for i in range(2 ** (len(S) - 1)):
txt = S[0]
for j in range(len(S) - 1):
if i >> j & 1:
txt += " " + S[j + 1]
else:
txt += S[j + 1]
ans += sum(list(map(int, txt.split())))
print(ans) |
[
7,
12,
13,
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,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
4,
11
],
[
14,
13
],
[
17,
16
],
[
8,
22
],
[
26,
25
],
[
4,
27
],
[
31,
30
],
[
8,
34
],
[
16,
38
],
[
30,
41
],
[
44,
43
],
[
25,
45
],
[
48,
45
],
[
43,
45
],
[
49,
48
],
[
43,
50
],
[
25,
50
],
[
48,
50
],
[
4,
52
],
[
30,
54
],
[
58,
57
],
[
48,
60
],
[
43,
60
],
[
25,
60
],
[
57,
63
],
[
13,
63
],
[
72,
69
]
] | [
"def main():\n a = input()\n p = len(a)\n ans =0\n for i in range(2**(p-1)):\n t =a[0]\n for j in range(p-1):\n if (i & 1 <<j):\n t = t + '+'\n t = t + a[j+1]\n ans += eval(t)\n print(ans)\nif __name__ =='__main__':\n main()",
"def main():\n a = input()\n p = len(a)\n ans =0\n for i in range(2**(p-1)):\n t =a[0]\n for j in range(p-1):\n if (i & 1 <<j):\n t = t + '+'\n t = t + a[j+1]\n ans += eval(t)\n print(ans)",
"main",
"a = input()",
"a",
"input()",
"input",
"p = len(a)",
"p",
"len(a)",
"len",
"a",
"ans =0",
"ans",
"0",
"for i in range(2**(p-1)):\n t =a[0]\n for j in range(p-1):\n if (i & 1 <<j):\n t = t + '+'\n t = t + a[j+1]\n ans += eval(t)\n ",
"i",
"range(2**(p-1))",
"range",
"2**(p-1)",
"2",
"p-1",
"p",
"1",
"t =a[0]",
"t",
"a[0]",
"a",
"0",
"for j in range(p-1):\n if (i & 1 <<j):\n t = t + '+'\n t = t + a[j+1]\n ",
"j",
"range(p-1)",
"range",
"p-1",
"p",
"1",
"if (i & 1 <<j):\n t = t + '+'\n ",
"i & 1 <<j",
"i",
"1 <<j",
"1",
"j",
"t = t + '+'",
"t",
"t + '+'",
"t",
"'+'",
"t = t + a[j+1]",
"t",
"t + a[j+1]",
"t",
"a[j+1]",
"a",
"j+1",
"j",
"1",
"ans += eval(t)",
"ans",
"eval(t)",
"eval",
"t",
"print(ans)",
"print",
"ans",
"if __name__ =='__main__':\n main()",
"__name__ =='__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n a = input()\n p = len(a)\n ans =0\n for i in range(2**(p-1)):\n t =a[0]\n for j in range(p-1):\n if (i & 1 <<j):\n t = t + '+'\n t = t + a[j+1]\n ans += eval(t)\n print(ans)",
"def main():\n a = input()\n p = len(a)\n ans =0\n for i in range(2**(p-1)):\n t =a[0]\n for j in range(p-1):\n if (i & 1 <<j):\n t = t + '+'\n t = t + a[j+1]\n ans += eval(t)\n print(ans)",
"main"
] | def main():
a = input()
p = len(a)
ans =0
for i in range(2**(p-1)):
t =a[0]
for j in range(p-1):
if (i & 1 <<j):
t = t + '+'
t = t + a[j+1]
ans += eval(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,
0,
13,
18,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
18,
13,
13,
0,
13,
4,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13
] | [
[
79,
2
],
[
76,
6
],
[
80,
10
],
[
82,
13
],
[
17,
16
],
[
77,
21
],
[
73,
23
],
[
27,
26
],
[
77,
29
],
[
85,
31
],
[
80,
33
],
[
26,
34
],
[
16,
38
],
[
26,
39
],
[
70,
42
],
[
88,
45
],
[
80,
47
],
[
77,
48
],
[
67,
50
],
[
89,
60
],
[
71,
60
],
[
86,
60
],
[
74,
60
],
[
68,
65
],
[
83,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] | [
"S = input()\nN = len(S) - 1\n \nans = 0\nfor i in range(2 ** N):\n equation = \"\"\n for j in range(N):\n equation += S[j]\n if (i >> j) & 1:\n equation += \"+\"\n equation += S[N]\n ans += sum(list(map(int, equation.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 equation = \"\"\n for j in range(N):\n equation += S[j]\n if (i >> j) & 1:\n equation += \"+\"\n equation += S[N]\n ans += sum(list(map(int, equation.split(\"+\"))))\n ",
"i",
"range(2 ** N)",
"range",
"2 ** N",
"2",
"N",
"equation = \"\"",
"equation",
"\"\"",
"for j in range(N):\n equation += S[j]\n if (i >> j) & 1:\n equation += \"+\"\n ",
"j",
"range(N)",
"range",
"N",
"equation += S[j]",
"equation",
"S[j]",
"S",
"j",
"if (i >> j) & 1:\n equation += \"+\"\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"equation += \"+\"",
"equation",
"\"+\"",
"equation += S[N]",
"equation",
"S[N]",
"S",
"N",
"ans += sum(list(map(int, equation.split(\"+\"))))",
"ans",
"sum(list(map(int, equation.split(\"+\"))))",
"sum",
"list(map(int, equation.split(\"+\")))",
"list",
"map(int, equation.split(\"+\"))",
"map",
"int",
"equation.split(\"+\")",
"equation.split",
"equation",
"split",
"\"+\"",
"print(ans)",
"print",
"ans",
"ans += sum(list(map(int, equation.split(\"+\"))))",
"sum(list(map(int, equation.split(\"+\"))))",
"ans",
"equation += \"+\"",
"\"+\"",
"equation",
"equation = \"\"",
"\"\"",
"equation",
"N = len(S) - 1",
"len(S) - 1",
"N",
"S = input()",
"input()",
"S",
"ans = 0",
"0",
"ans",
"equation += S[j]",
"S[j]",
"equation",
"equation += S[N]",
"S[N]",
"equation"
] | S = input()
N = len(S) - 1
ans = 0
for i in range(2 ** N):
equation = ""
for j in range(N):
equation += S[j]
if (i >> j) & 1:
equation += "+"
equation += S[N]
ans += sum(list(map(int, equation.split("+"))))
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
39,
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,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
18,
13,
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,
18,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13
] | [
[
132,
2
],
[
108,
6
],
[
133,
10
],
[
126,
13
],
[
123,
16
],
[
20,
19
],
[
109,
24
],
[
129,
26
],
[
109,
30
],
[
33,
32
],
[
109,
35
],
[
19,
39
],
[
32,
40
],
[
46,
43
],
[
130,
44
],
[
32,
45
],
[
127,
49
],
[
130,
51
],
[
54,
53
],
[
109,
58
],
[
105,
60
],
[
133,
62
],
[
66,
65
],
[
109,
68
],
[
127,
73
],
[
53,
74
],
[
65,
75
],
[
111,
78
],
[
106,
81
],
[
121,
81
],
[
118,
81
],
[
117,
83
],
[
133,
85
],
[
65,
87
],
[
120,
90
],
[
133,
92
],
[
65,
94
],
[
114,
97
],
[
121,
100
],
[
118,
100
],
[
106,
100
],
[
115,
103
],
[
112,
103
],
[
124,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
]
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nS = input()\nn = len(S) - 1\npattern = []\nans = 0\n\nfor i in range(2 ** n):\n tmp = [0] * n\n for j in range(n):\n if i >> j & 1:\n tmp[j] = \"+\"\n pattern.append(tmp)\n\nfor i in range(2 ** n):\n X = S[0]\n for j in range(n):\n if pattern[i][j] == \"+\":\n ans += int(X)\n X = S[j+1]\n else:\n X += S[j+1]\n ans += int(X)\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"n = len(S) - 1",
"n",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"pattern = []",
"pattern",
"[]",
"ans = 0",
"ans",
"0",
"for i in range(2 ** n):\n tmp = [0] * n\n for j in range(n):\n if i >> j & 1:\n tmp[j] = \"+\"\n pattern.append(tmp)",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"tmp = [0] * n",
"tmp",
"[0] * n",
"[0]",
"0",
"n",
"for j in range(n):\n if i >> j & 1:\n tmp[j] = \"+\"\n ",
"j",
"range(n)",
"range",
"n",
"if i >> j & 1:\n tmp[j] = \"+\"\n ",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"tmp[j] = \"+\"",
"tmp[j]",
"tmp",
"j",
"\"+\"",
"pattern.append(tmp)",
"pattern.append",
"pattern",
"append",
"tmp",
"for i in range(2 ** n):\n X = S[0]\n for j in range(n):\n if pattern[i][j] == \"+\":\n ans += int(X)\n X = S[j+1]\n else:\n X += S[j+1]\n ans += int(X)",
"i",
"range(2 ** n)",
"range",
"2 ** n",
"2",
"n",
"X = S[0]",
"X",
"S[0]",
"S",
"0",
"for j in range(n):\n if pattern[i][j] == \"+\":\n ans += int(X)\n X = S[j+1]\n else:\n X += S[j+1]\n ",
"j",
"range(n)",
"range",
"n",
"if pattern[i][j] == \"+\":\n ans += int(X)\n X = S[j+1]\n else:\n X += S[j+1]\n ",
"pattern[i][j] == \"+\"",
"pattern[i][j]",
"[i]",
"pattern",
"i",
"j",
"\"+\"",
"ans += int(X)",
"ans",
"int(X)",
"int",
"X",
"X = S[j+1]",
"X",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"X += S[j+1]",
"X",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"ans += int(X)",
"ans",
"int(X)",
"int",
"X",
"print(ans)",
"print",
"ans",
"X = S[0]",
"S[0]",
"X",
"n = len(S) - 1",
"len(S) - 1",
"n",
"ans += int(X)",
"int(X)",
"ans",
"ans += int(X)",
"int(X)",
"ans",
"X = S[j+1]",
"S[j+1]",
"X",
"X += S[j+1]",
"S[j+1]",
"X",
"ans = 0",
"0",
"ans",
"pattern = []",
"[]",
"pattern",
"tmp = [0] * n",
"[0] * n",
"tmp",
"S = input()",
"input()",
"S"
] | #!/usr/bin/env python
# -*- coding: utf-8 -*-
S = input()
n = len(S) - 1
pattern = []
ans = 0
for i in range(2 ** n):
tmp = [0] * n
for j in range(n):
if i >> j & 1:
tmp[j] = "+"
pattern.append(tmp)
for i in range(2 ** n):
X = S[0]
for j in range(n):
if pattern[i][j] == "+":
ans += int(X)
X = S[j+1]
else:
X += S[j+1]
ans += int(X)
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,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
0,
13,
2,
2,
18,
13,
39,
2,
2,
13,
17,
13,
17,
18,
13,
39,
2,
2,
13,
17,
13,
0,
13,
17,
0,
13,
4,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
84,
2
],
[
90,
6
],
[
85,
10
],
[
102,
13
],
[
17,
16
],
[
91,
21
],
[
93,
23
],
[
85,
24
],
[
81,
26
],
[
30,
29
],
[
91,
32
],
[
16,
36
],
[
29,
37
],
[
99,
40
],
[
94,
44
],
[
100,
44
],
[
29,
48
],
[
82,
50
],
[
88,
50
],
[
94,
53
],
[
100,
53
],
[
29,
57
],
[
82,
59
],
[
88,
59
],
[
87,
61
],
[
96,
64
],
[
100,
74
],
[
94,
74
],
[
97,
79
],
[
103,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
85,
93
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
]
] | [
"S=input()\nn=len(S)-1\nans=0\nfor i in range(2**n):\n tmp=S\n cnt=0\n for j in range(n):\n if (i>>j)&1:\n tmp=tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]\n cnt+=1\n ans+=sum(list(map(int,tmp.split(\" \"))))\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 tmp=S\n cnt=0\n for j in range(n):\n if (i>>j)&1:\n tmp=tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]\n cnt+=1\n ans+=sum(list(map(int,tmp.split(\" \"))))",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"tmp=S",
"tmp",
"S",
"cnt=0",
"cnt",
"0",
"for j in range(n):\n if (i>>j)&1:\n tmp=tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]\n cnt+=1\n ",
"j",
"range(n)",
"range",
"n",
"if (i>>j)&1:\n tmp=tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]\n cnt+=1\n ",
"(i>>j)&1",
"i>>j",
"i",
"j",
"1",
"tmp=tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]",
"tmp",
"tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]",
"tmp[:j+1+cnt]+\" \"",
"tmp[:j+1+cnt]",
"tmp",
":j+1+cnt",
"j+1+cnt",
"j+1",
"j",
"1",
"cnt",
"\" \"",
"tmp[j+1+cnt:]",
"tmp",
"j+1+cnt:",
"j+1+cnt",
"j+1",
"j",
"1",
"cnt",
"cnt+=1",
"cnt",
"1",
"ans+=sum(list(map(int,tmp.split(\" \"))))",
"ans",
"sum(list(map(int,tmp.split(\" \"))))",
"sum",
"list(map(int,tmp.split(\" \")))",
"list",
"map(int,tmp.split(\" \"))",
"map",
"int",
"tmp.split(\" \")",
"tmp.split",
"tmp",
"split",
"\" \"",
"print(ans)",
"print",
"ans",
"cnt=0",
"0",
"cnt",
"S=input()",
"input()",
"S",
"cnt+=1",
"1",
"cnt",
"n=len(S)-1",
"len(S)-1",
"n",
"tmp=S",
"S",
"tmp",
"ans+=sum(list(map(int,tmp.split(\" \"))))",
"sum(list(map(int,tmp.split(\" \"))))",
"ans",
"tmp=tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]",
"tmp[:j+1+cnt]+\" \"+tmp[j+1+cnt:]",
"tmp",
"ans=0",
"0",
"ans"
] | S=input()
n=len(S)-1
ans=0
for i in range(2**n):
tmp=S
cnt=0
for j in range(n):
if (i>>j)&1:
tmp=tmp[:j+1+cnt]+" "+tmp[j+1+cnt:]
cnt+=1
ans+=sum(list(map(int,tmp.split(" "))))
print(ans) |
[
7,
15,
13,
13,
15,
15,
15,
15,
15,
15,
15,
15,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
23,
13,
23,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
39,
17,
17,
0,
13,
2,
4,
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,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
21,
20
],
[
213,
26
],
[
30,
30
],
[
34,
33
],
[
180,
39
],
[
43,
43
],
[
53,
52
],
[
204,
57
],
[
61,
61
],
[
65,
64
],
[
183,
70
],
[
74,
74
],
[
86,
86
],
[
88,
88
],
[
218,
97
],
[
185,
102
],
[
112,
111
],
[
204,
113
],
[
116,
115
],
[
119,
118
],
[
128,
127
],
[
111,
131
],
[
135,
134
],
[
111,
136
],
[
140,
139
],
[
118,
144
],
[
118,
148
],
[
139,
149
],
[
153,
152
],
[
156,
155
],
[
111,
157
],
[
139,
159
],
[
163,
162
],
[
155,
165
],
[
152,
165
],
[
134,
165
],
[
162,
168
],
[
115,
168
],
[
225,
174
],
[
185,
186
],
[
218,
219
]
] | [
"import sys, re\nfrom math import ceil, floor, sqrt, pi, factorial#, gcd\nfrom copy import deepcopy\nfrom collections import Counter, deque\nfrom heapq import heapify, heappop, heappush\nfrom itertools import accumulate, product, combinations, combinations_with_replacement\nfrom bisect import bisect, bisect_left\nfrom functools import reduce\nfrom decimal import Decimal, getcontext\n# input = sys.stdin.readline \ndef i_input(): return int(input())\ndef i_map(): return map(int, input().split())\ndef i_list(): return list(i_map())\ndef i_row(N): return [i_input() for _ in range(N)]\ndef i_row_list(N): return [i_list() for _ in range(N)]\ndef s_input(): return input()\ndef s_map(): return input().split()\ndef s_list(): return list(s_map())\ndef s_row(N): return [s_input for _ in range(N)]\ndef s_row_list(N): return [s_list() for _ in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\ndef lcm(a, b): return a * b // gcd(a, b)\nsys.setrecursionlimit(10 ** 6)\nINF = float('inf')\nMOD = 10 ** 9 + 7\n\ndef main():\n s = s_input()\n\n count = 0\n for bit in list(product([0,1], repeat=len(s)-1)):\n eval_s = s[0]\n for i in range(len(bit)):\n if bit[i] == 1:\n eval_s += '+'\n eval_s += s[i+1]\n count += eval(eval_s)\n\n print(count)\n\nif __name__ == '__main__':\n main()",
"import sys, re",
"sys",
"re",
"from math import ceil, floor, sqrt, pi, factorial",
"from copy import deepcopy",
"from collections import Counter, deque",
"from heapq import heapify, heappop, heappush",
"from itertools import accumulate, product, combinations, combinations_with_replacement",
"from bisect import bisect, bisect_left",
"from functools import reduce",
"from decimal import Decimal, getcontext",
"def i_input(): return int(input())",
"i_input",
"def i_map(): return map(int, input().split())",
"i_map",
"def i_list(): return list(i_map())",
"i_list",
"i_input() for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"i_input()",
"i_input",
"def i_row(N): return [i_input() for _ in range(N)]",
"i_row",
"N",
"N",
"i_list() for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"i_list()",
"i_list",
"def i_row_list(N): return [i_list() for _ in range(N)]",
"i_row_list",
"N",
"N",
"def s_input(): return input()",
"s_input",
"def s_map(): return input().split()",
"s_map",
"def s_list(): return list(s_map())",
"s_list",
"s_input for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"s_input",
"def s_row(N): return [s_input for _ in range(N)]",
"s_row",
"N",
"N",
"s_list() for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"s_list()",
"s_list",
"def s_row_list(N): return [s_list() for _ in range(N)]",
"s_row_list",
"N",
"N",
"def Yes(): print('Yes')",
"Yes",
"def No(): print('No')",
"No",
"def YES(): print('YES')",
"YES",
"def NO(): print('NO')",
"NO",
"def lcm(a, b): return a * b // gcd(a, b)",
"lcm",
"a",
"a",
"b",
"b",
"sys.setrecursionlimit(10 ** 6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 6",
"10",
"6",
"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 = s_input()\n\n count = 0\n for bit in list(product([0,1], repeat=len(s)-1)):\n eval_s = s[0]\n for i in range(len(bit)):\n if bit[i] == 1:\n eval_s += '+'\n eval_s += s[i+1]\n count += eval(eval_s)\n\n print(count)",
"main",
"s = s_input()",
"s",
"s_input()",
"s_input",
"count = 0",
"count",
"0",
"for bit in list(product([0,1], repeat=len(s)-1)):\n eval_s = s[0]\n for i in range(len(bit)):\n if bit[i] == 1:\n eval_s += '+'\n eval_s += s[i+1]\n count += eval(eval_s)\n\n ",
"bit",
"list(product([0,1], repeat=len(s)-1))",
"list",
"product([0,1], repeat=len(s)-1)",
"product",
"[0,1]",
"0",
"1",
"repeat=len(s)-1",
"repeat",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"eval_s = s[0]",
"eval_s",
"s[0]",
"s",
"0",
"for i in range(len(bit)):\n if bit[i] == 1:\n eval_s += '+'\n eval_s += s[i+1]\n ",
"i",
"range(len(bit))",
"range",
"len(bit)",
"len",
"bit",
"if bit[i] == 1:\n eval_s += '+'\n ",
"bit[i] == 1",
"bit[i]",
"bit",
"i",
"1",
"eval_s += '+'",
"eval_s",
"'+'",
"eval_s += s[i+1]",
"eval_s",
"s[i+1]",
"s",
"i+1",
"i",
"1",
"count += eval(eval_s)",
"count",
"eval(eval_s)",
"eval",
"eval_s",
"print(count)",
"print",
"count",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def YES(): print('YES')",
"def YES(): print('YES')",
"YES",
"def i_list(): return list(i_map())",
"def i_list(): return list(i_map())",
"i_list",
"def s_list(): return list(s_map())",
"def s_list(): return list(s_map())",
"s_list",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def lcm(a, b): return a * b // gcd(a, b)",
"def lcm(a, b): return a * b // gcd(a, b)",
"lcm",
"def i_map(): return map(int, input().split())",
"def i_map(): return map(int, input().split())",
"i_map",
"def i_row_list(N): return [i_list() for _ in range(N)]",
"def i_row_list(N): return [i_list() for _ in range(N)]",
"i_row_list",
"def s_map(): return input().split()",
"def s_map(): return input().split()",
"s_map",
"def No(): print('No')",
"def No(): print('No')",
"No",
"def s_input(): return input()",
"def s_input(): return input()",
"s_input",
"def Yes(): print('Yes')",
"def Yes(): print('Yes')",
"Yes",
"def NO(): print('NO')",
"def NO(): print('NO')",
"NO",
"def i_input(): return int(input())",
"def i_input(): return int(input())",
"i_input",
"def s_row_list(N): return [s_list() for _ in range(N)]",
"def s_row_list(N): return [s_list() for _ in range(N)]",
"s_row_list",
"INF = float('inf')",
"float('inf')",
"INF",
"def s_row(N): return [s_input for _ in range(N)]",
"def s_row(N): return [s_input for _ in range(N)]",
"s_row",
"def main():\n s = s_input()\n\n count = 0\n for bit in list(product([0,1], repeat=len(s)-1)):\n eval_s = s[0]\n for i in range(len(bit)):\n if bit[i] == 1:\n eval_s += '+'\n eval_s += s[i+1]\n count += eval(eval_s)\n\n print(count)",
"def main():\n s = s_input()\n\n count = 0\n for bit in list(product([0,1], repeat=len(s)-1)):\n eval_s = s[0]\n for i in range(len(bit)):\n if bit[i] == 1:\n eval_s += '+'\n eval_s += s[i+1]\n count += eval(eval_s)\n\n print(count)",
"main",
"def i_row(N): return [i_input() for _ in range(N)]",
"def i_row(N): return [i_input() for _ in range(N)]",
"i_row"
] | import sys, re
from math import ceil, floor, sqrt, pi, factorial#, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
s = s_input()
count = 0
for bit in list(product([0,1], repeat=len(s)-1)):
eval_s = s[0]
for i in range(len(bit)):
if bit[i] == 1:
eval_s += '+'
eval_s += s[i+1]
count += eval(eval_s)
print(count)
if __name__ == '__main__':
main()
|
[
7,
41,
28,
13,
4,
13,
4,
4,
13,
13,
0,
13,
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,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
2,
2,
13,
17,
18,
13,
2,
13,
17,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
18,
13,
10,
13,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13
] | [
[
4,
3
],
[
3,
9
],
[
82,
11
],
[
97,
14
],
[
83,
17
],
[
85,
19
],
[
23,
22
],
[
98,
28
],
[
79,
31
],
[
83,
33
],
[
37,
36
],
[
98,
40
],
[
22,
45
],
[
36,
46
],
[
91,
49
],
[
80,
50
],
[
95,
50
],
[
89,
50
],
[
88,
52
],
[
83,
54
],
[
36,
56
],
[
94,
59
],
[
80,
62
],
[
95,
62
],
[
89,
62
],
[
83,
65
],
[
36,
67
],
[
76,
70
],
[
95,
71
],
[
89,
71
],
[
80,
71
],
[
77,
74
],
[
92,
74
],
[
86,
74
],
[
95,
76
],
[
89,
76
],
[
80,
76
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
80,
91
],
[
95,
91
],
[
89,
91
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"a = [int(x) for x in input()]\nn = len(a)\n\nsum_val = 0\nfor i in range(1 << (n - 1)):\n tmp_val = a[0]\n for j in range(n - 1):\n if (i >> j) & 1:\n sum_val += tmp_val\n tmp_val = a[j + 1]\n else:\n tmp_val = tmp_val * 10 + a[j + 1]\n sum_val += tmp_val\nprint(sum_val)",
"int(x) for x in input()",
"for x in input()",
"x",
"input()",
"input",
"for x in input()",
"int(x)",
"int",
"x",
"a = [int(x) for x in input()]",
"a",
"[int(x) for x in input()]",
"n = len(a)",
"n",
"len(a)",
"len",
"a",
"sum_val = 0",
"sum_val",
"0",
"for i in range(1 << (n - 1)):\n tmp_val = a[0]\n for j in range(n - 1):\n if (i >> j) & 1:\n sum_val += tmp_val\n tmp_val = a[j + 1]\n else:\n tmp_val = tmp_val * 10 + a[j + 1]\n sum_val += tmp_val",
"i",
"range(1 << (n - 1))",
"range",
"1 << (n - 1)",
"1",
"n - 1",
"n",
"1",
"tmp_val = a[0]",
"tmp_val",
"a[0]",
"a",
"0",
"for j in range(n - 1):\n if (i >> j) & 1:\n sum_val += tmp_val\n tmp_val = a[j + 1]\n else:\n tmp_val = tmp_val * 10 + a[j + 1]\n ",
"j",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if (i >> j) & 1:\n sum_val += tmp_val\n tmp_val = a[j + 1]\n else:\n tmp_val = tmp_val * 10 + a[j + 1]\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"sum_val += tmp_val",
"sum_val",
"tmp_val",
"tmp_val = a[j + 1]",
"tmp_val",
"a[j + 1]",
"a",
"j + 1",
"j",
"1",
"tmp_val = tmp_val * 10 + a[j + 1]",
"tmp_val",
"tmp_val * 10 + a[j + 1]",
"tmp_val * 10",
"tmp_val",
"10",
"a[j + 1]",
"a",
"j + 1",
"j",
"1",
"sum_val += tmp_val",
"sum_val",
"tmp_val",
"print(sum_val)",
"print",
"sum_val",
"sum_val += tmp_val",
"tmp_val",
"sum_val",
"tmp_val = a[0]",
"a[0]",
"tmp_val",
"a = [int(x) for x in input()]",
"[int(x) for x in input()]",
"a",
"sum_val = 0",
"0",
"sum_val",
"tmp_val = a[j + 1]",
"a[j + 1]",
"tmp_val",
"sum_val += tmp_val",
"tmp_val",
"sum_val",
"tmp_val = tmp_val * 10 + a[j + 1]",
"tmp_val * 10 + a[j + 1]",
"tmp_val",
"n = len(a)",
"len(a)",
"n"
] | a = [int(x) for x in input()]
n = len(a)
sum_val = 0
for i in range(1 << (n - 1)):
tmp_val = a[0]
for j in range(n - 1):
if (i >> j) & 1:
sum_val += tmp_val
tmp_val = a[j + 1]
else:
tmp_val = tmp_val * 10 + a[j + 1]
sum_val += tmp_val
print(sum_val) |
[
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,
13,
17,
0,
13,
4,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
18,
13,
13,
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,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13
] | [
[
106,
2
],
[
124,
6
],
[
107,
9
],
[
97,
11
],
[
15,
14
],
[
125,
20
],
[
121,
23
],
[
125,
28
],
[
32,
31
],
[
125,
35
],
[
14,
40
],
[
31,
41
],
[
47,
44
],
[
122,
45
],
[
31,
46
],
[
100,
49
],
[
107,
53
],
[
57,
56
],
[
125,
60
],
[
122,
64
],
[
56,
65
],
[
115,
67
],
[
101,
68
],
[
104,
68
],
[
113,
68
],
[
110,
68
],
[
109,
70
],
[
107,
74
],
[
56,
76
],
[
112,
79
],
[
103,
82
],
[
107,
86
],
[
56,
88
],
[
118,
91
],
[
104,
92
],
[
113,
92
],
[
110,
92
],
[
101,
92
],
[
119,
95
],
[
116,
95
],
[
98,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
101,
115
],
[
104,
115
],
[
113,
115
],
[
110,
115
],
[
115,
116
],
[
104,
118
],
[
113,
118
],
[
110,
118
],
[
101,
118
],
[
118,
119
],
[
121,
122
],
[
124,
125
]
] | [
"s = input()\nn = len(s)\nans = 0\nfor i in range(2**(n-1)):\n flag = [False] * (n-1)\n for j in range(n-1):\n if (i >> j) & 1:\n flag[j] = True\n tmp = int(s[0])\n for k in range(n-1):\n if flag[k]:\n ans += tmp\n tmp = int(s[k+1])\n else:\n tmp *= 10\n tmp += int(s[k+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(2**(n-1)):\n flag = [False] * (n-1)\n for j in range(n-1):\n if (i >> j) & 1:\n flag[j] = True\n tmp = int(s[0])\n for k in range(n-1):\n if flag[k]:\n ans += tmp\n tmp = int(s[k+1])\n else:\n tmp *= 10\n tmp += int(s[k+1])\n ans += tmp",
"i",
"range(2**(n-1))",
"range",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"flag = [False] * (n-1)",
"flag",
"[False] * (n-1)",
"[False]",
"False",
"n-1",
"n",
"1",
"for j in range(n-1):\n if (i >> j) & 1:\n flag[j] = True\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i >> j) & 1:\n flag[j] = True\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"flag[j] = True",
"flag[j]",
"flag",
"j",
"True",
"tmp = int(s[0])",
"tmp",
"int(s[0])",
"int",
"s[0]",
"s",
"0",
"for k in range(n-1):\n if flag[k]:\n ans += tmp\n tmp = int(s[k+1])\n else:\n tmp *= 10\n tmp += int(s[k+1])\n ",
"k",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if flag[k]:\n ans += tmp\n tmp = int(s[k+1])\n else:\n tmp *= 10\n tmp += int(s[k+1])\n ",
"flag[k]",
"flag",
"k",
"ans += tmp",
"ans",
"tmp",
"tmp = int(s[k+1])",
"tmp",
"int(s[k+1])",
"int",
"s[k+1]",
"s",
"k+1",
"k",
"1",
"tmp *= 10",
"tmp",
"10",
"tmp += int(s[k+1])",
"tmp",
"int(s[k+1])",
"int",
"s[k+1]",
"s",
"k+1",
"k",
"1",
"ans += tmp",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"tmp = int(s[0])",
"int(s[0])",
"tmp",
"tmp += int(s[k+1])",
"int(s[k+1])",
"tmp",
"s = input()",
"input()",
"s",
"tmp = int(s[k+1])",
"int(s[k+1])",
"tmp",
"tmp *= 10",
"10",
"tmp",
"ans += tmp",
"tmp",
"ans",
"ans += tmp",
"tmp",
"ans",
"flag = [False] * (n-1)",
"[False] * (n-1)",
"flag",
"n = len(s)",
"len(s)",
"n"
] | s = input()
n = len(s)
ans = 0
for i in range(2**(n-1)):
flag = [False] * (n-1)
for j in range(n-1):
if (i >> j) & 1:
flag[j] = True
tmp = int(s[0])
for k in range(n-1):
if flag[k]:
ans += tmp
tmp = int(s[k+1])
else:
tmp *= 10
tmp += int(s[k+1])
ans += tmp
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
17,
4,
18,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
13,
17,
0,
18,
13,
2,
2,
17,
13,
17,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
17,
0,
13,
39,
0,
13,
4,
13,
4,
18,
13,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
18,
13,
2,
2,
17,
13,
17,
17,
4,
13,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
148,
2
],
[
127,
8
],
[
12,
11
],
[
149,
16
],
[
128,
19
],
[
149,
22
],
[
11,
23
],
[
128,
26
],
[
128,
31
],
[
151,
35
],
[
39,
38
],
[
149,
46
],
[
50,
49
],
[
149,
55
],
[
38,
60
],
[
49,
61
],
[
71,
64
],
[
128,
65
],
[
49,
69
],
[
145,
73
],
[
128,
78
],
[
139,
80
],
[
142,
83
],
[
133,
86
],
[
146,
91
],
[
96,
95
],
[
134,
95
],
[
143,
95
],
[
130,
98
],
[
95,
101
],
[
136,
103
],
[
131,
104
],
[
140,
104
],
[
107,
106
],
[
149,
112
],
[
122,
115
],
[
128,
116
],
[
106,
120
],
[
137,
125
],
[
152,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
131,
136
],
[
140,
136
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
]
] | [
"li=list(input())\nlis=[]\nfor i in range(len(li)):\n lis.append(li[i])\n lis.append('')\nlis.pop(-1)\nsum=0\nfor i in range(2**(len(li)-1)):\n for j in range(len(li)-1):\n if (i >> j)&1:\n lis[2*j+1]='+'\n str=''.join(lis)\n calc=0\n a=[]\n #計算\n a=list(str.split('+'))\n for j in a:\n calc+=int(j)\n sum+=calc\n #戻す\n for j in range(len(li)-1):\n lis[2*j+1]=''\nprint(sum)",
"li=list(input())",
"li",
"list(input())",
"list",
"input()",
"input",
"lis=[]",
"lis",
"[]",
"for i in range(len(li)):\n lis.append(li[i])\n lis.append('')",
"i",
"range(len(li))",
"range",
"len(li)",
"len",
"li",
"lis.append(li[i])",
"lis.append",
"lis",
"append",
"li[i]",
"li",
"i",
"lis.append('')",
"lis.append",
"lis",
"append",
"''",
"lis.pop(-1)",
"lis.pop",
"lis",
"pop",
"-1",
"sum=0",
"sum",
"0",
"for i in range(2**(len(li)-1)):\n for j in range(len(li)-1):\n if (i >> j)&1:\n lis[2*j+1]='+'\n str=''.join(lis)\n calc=0\n a=[]\n #計算\n a=list(str.split('+'))\n for j in a:\n calc+=int(j)\n sum+=calc\n #戻す\n for j in range(len(li)-1):\n lis[2*j+1]=''",
"i",
"range(2**(len(li)-1))",
"range",
"2**(len(li)-1)",
"2",
"len(li)-1",
"len(li)",
"len",
"li",
"1",
"for j in range(len(li)-1):\n if (i >> j)&1:\n lis[2*j+1]='+'\n ",
"j",
"range(len(li)-1)",
"range",
"len(li)-1",
"len(li)",
"len",
"li",
"1",
"if (i >> j)&1:\n lis[2*j+1]='+'\n ",
"(i >> j)&1",
"i >> j",
"i",
"j",
"1",
"lis[2*j+1]='+'",
"lis[2*j+1]",
"lis",
"2*j+1",
"2*j",
"2",
"j",
"1",
"'+'",
"str=''.join(lis)",
"str",
"''.join(lis)",
"''.join",
"''",
"join",
"lis",
"calc=0",
"calc",
"0",
"a=[]",
"a",
"[]",
"a=list(str.split('+'))",
"a",
"list(str.split('+'))",
"list",
"str.split('+')",
"str.split",
"str",
"split",
"'+'",
"for j in a:\n calc+=int(j)\n ",
"j",
"a",
"calc+=int(j)",
"calc",
"int(j)",
"int",
"j",
"sum+=calc",
"sum",
"calc",
"for j in range(len(li)-1):\n lis[2*j+1]=''",
"j",
"range(len(li)-1)",
"range",
"len(li)-1",
"len(li)",
"len",
"li",
"1",
"lis[2*j+1]=''",
"lis[2*j+1]",
"lis",
"2*j+1",
"2*j",
"2",
"j",
"1",
"''",
"print(sum)",
"print",
"sum",
"lis=[]",
"[]",
"lis",
"calc+=int(j)",
"int(j)",
"calc",
"a=list(str.split('+'))",
"list(str.split('+'))",
"a",
"sum+=calc",
"calc",
"sum",
"calc=0",
"0",
"calc",
"a=[]",
"[]",
"a",
"str=''.join(lis)",
"''.join(lis)",
"str",
"li=list(input())",
"list(input())",
"li",
"sum=0",
"0",
"sum"
] | li=list(input())
lis=[]
for i in range(len(li)):
lis.append(li[i])
lis.append('')
lis.pop(-1)
sum=0
for i in range(2**(len(li)-1)):
for j in range(len(li)-1):
if (i >> j)&1:
lis[2*j+1]='+'
str=''.join(lis)
calc=0
a=[]
#計算
a=list(str.split('+'))
for j in a:
calc+=int(j)
sum+=calc
#戻す
for j in range(len(li)-1):
lis[2*j+1]=''
print(sum) |
[
7,
14,
2,
13,
17,
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,
0,
13,
17,
0,
13,
4,
13,
18,
13,
13,
14,
2,
13,
2,
17,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
4,
13,
18,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] | [
[
96,
6
],
[
99,
10
],
[
97,
13
],
[
87,
15
],
[
19,
18
],
[
100,
24
],
[
84,
27
],
[
31,
30
],
[
100,
34
],
[
105,
37
],
[
90,
40
],
[
97,
44
],
[
30,
45
],
[
18,
48
],
[
30,
51
],
[
93,
53
],
[
91,
54
],
[
106,
54
],
[
85,
54
],
[
79,
54
],
[
76,
54
],
[
103,
54
],
[
78,
56
],
[
102,
59
],
[
75,
62
],
[
97,
66
],
[
81,
69
],
[
76,
70
],
[
103,
70
],
[
79,
70
],
[
91,
70
],
[
106,
70
],
[
85,
70
],
[
82,
73
],
[
94,
73
],
[
88,
73
],
[
75,
76
],
[
78,
79
],
[
76,
81
],
[
103,
81
],
[
79,
81
],
[
91,
81
],
[
106,
81
],
[
85,
81
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
91,
93
],
[
106,
93
],
[
85,
93
],
[
79,
93
],
[
76,
93
],
[
103,
93
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
]
] | [
"if __name__ == '__main__':\n s = input()\n N = len(s)\n res = 0\n for bit in range(1 << N - 1):\n tmp = 0\n for i in range(N - 1):\n tmp *= 10\n tmp += int(s[i])\n if bit & (1 << i):\n res += tmp\n tmp = 0\n tmp *= 10\n tmp += int(s[-1])\n res += tmp\n \n print(res)",
"if __name__ == '__main__':\n s = input()\n N = len(s)\n res = 0\n for bit in range(1 << N - 1):\n tmp = 0\n for i in range(N - 1):\n tmp *= 10\n tmp += int(s[i])\n if bit & (1 << i):\n res += tmp\n tmp = 0\n tmp *= 10\n tmp += int(s[-1])\n res += tmp\n \n print(res)",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"s = input()",
"s",
"input()",
"input",
"N = len(s)",
"N",
"len(s)",
"len",
"s",
"res = 0",
"res",
"0",
"for bit in range(1 << N - 1):\n tmp = 0\n for i in range(N - 1):\n tmp *= 10\n tmp += int(s[i])\n if bit & (1 << i):\n res += tmp\n tmp = 0\n tmp *= 10\n tmp += int(s[-1])\n res += tmp\n \n ",
"bit",
"range(1 << N - 1)",
"range",
"1 << N - 1",
"1",
"N - 1",
"N",
"1",
"tmp = 0",
"tmp",
"0",
"for i in range(N - 1):\n tmp *= 10\n tmp += int(s[i])\n if bit & (1 << i):\n res += tmp\n tmp = 0\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"tmp *= 10",
"tmp",
"10",
"tmp += int(s[i])",
"tmp",
"int(s[i])",
"int",
"s[i]",
"s",
"i",
"if bit & (1 << i):\n res += tmp\n tmp = 0\n ",
"bit & (1 << i)",
"bit",
"1 << i",
"1",
"i",
"res += tmp",
"res",
"tmp",
"tmp = 0",
"tmp",
"0",
"tmp *= 10",
"tmp",
"10",
"tmp += int(s[-1])",
"tmp",
"int(s[-1])",
"int",
"s[-1]",
"s",
"-1",
"res += tmp",
"res",
"tmp",
"print(res)",
"print",
"res",
"tmp += int(s[-1])",
"int(s[-1])",
"tmp",
"tmp = 0",
"0",
"tmp",
"res += tmp",
"tmp",
"res",
"tmp = 0",
"0",
"tmp",
"res = 0",
"0",
"res",
"tmp += int(s[i])",
"int(s[i])",
"tmp",
"res += tmp",
"tmp",
"res",
"s = input()",
"input()",
"s",
"N = len(s)",
"len(s)",
"N",
"tmp *= 10",
"10",
"tmp",
"tmp *= 10",
"10",
"tmp"
] | if __name__ == '__main__':
s = input()
N = len(s)
res = 0
for bit in range(1 << N - 1):
tmp = 0
for i in range(N - 1):
tmp *= 10
tmp += int(s[i])
if bit & (1 << i):
res += tmp
tmp = 0
tmp *= 10
tmp += int(s[-1])
res += tmp
print(res) |
[
7,
0,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
12,
13,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
2,
2,
13,
2,
13,
17,
17,
14,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
13,
18,
13,
13,
0,
13,
4,
13,
13,
29,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13
] | [
[
98,
2
],
[
92,
9
],
[
99,
12
],
[
17,
16
],
[
99,
18
],
[
22,
21
],
[
25,
24
],
[
93,
28
],
[
31,
30
],
[
67,
33
],
[
24,
35
],
[
30,
40
],
[
44,
43
],
[
16,
46
],
[
53,
46
],
[
48,
46
],
[
49,
48
],
[
99,
50
],
[
24,
51
],
[
54,
53
],
[
16,
55
],
[
53,
55
],
[
48,
55
],
[
99,
57
],
[
24,
58
],
[
61,
60
],
[
53,
63
],
[
48,
63
],
[
16,
63
],
[
60,
65
],
[
43,
65
],
[
21,
65
],
[
67,
67
],
[
101,
69
],
[
73,
72
],
[
93,
78
],
[
89,
81
],
[
96,
83
],
[
72,
84
],
[
90,
87
],
[
102,
87
],
[
89,
90
],
[
92,
93
],
[
98,
99
],
[
101,
102
]
] | [
"s = input().rstrip()\nn = len(s)\n\ndef value(m):\n num = s[0]\n ans = 0\n for i in range(1, n):\n t = (m>>(i-1)) & 1\n if t ==1:\n ans += int(num)\n num = s[i]\n else:\n num = num + s[i]\n ans += int(num)\n return ans\n\ncount = 0\nfor i in range(2**(n-1)):\n count +=value(i)\n\nprint(count)",
"s = input().rstrip()",
"s",
"input().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"n = len(s)",
"n",
"len(s)",
"len",
"s",
"def value(m):\n num = s[0]\n ans = 0\n for i in range(1, n):\n t = (m>>(i-1)) & 1\n if t ==1:\n ans += int(num)\n num = s[i]\n else:\n num = num + s[i]\n ans += int(num)\n return ans",
"value",
"num = s[0]",
"num",
"s[0]",
"s",
"0",
"ans = 0",
"ans",
"0",
"for i in range(1, n):\n t = (m>>(i-1)) & 1\n if t ==1:\n ans += int(num)\n num = s[i]\n else:\n num = num + s[i]\n ",
"i",
"range(1, n)",
"range",
"1",
"n",
"t = (m>>(i-1)) & 1",
"t",
"(m>>(i-1)) & 1",
"m>>(i-1)",
"m",
"i-1",
"i",
"1",
"1",
"if t ==1:\n ans += int(num)\n num = s[i]\n else:\n num = num + s[i]\n ",
"t ==1",
"t",
"1",
"ans += int(num)",
"ans",
"int(num)",
"int",
"num",
"num = s[i]",
"num",
"s[i]",
"s",
"i",
"num = num + s[i]",
"num",
"num + s[i]",
"num",
"s[i]",
"s",
"i",
"ans += int(num)",
"ans",
"int(num)",
"int",
"num",
"return ans",
"ans",
"m",
"m",
"count = 0",
"count",
"0",
"for i in range(2**(n-1)):\n count +=value(i)",
"i",
"range(2**(n-1))",
"range",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"count +=value(i)",
"count",
"value(i)",
"value",
"i",
"print(count)",
"print",
"count",
"count +=value(i)",
"value(i)",
"count",
"n = len(s)",
"len(s)",
"n",
"def value(m):\n num = s[0]\n ans = 0\n for i in range(1, n):\n t = (m>>(i-1)) & 1\n if t ==1:\n ans += int(num)\n num = s[i]\n else:\n num = num + s[i]\n ans += int(num)\n return ans",
"def value(m):\n num = s[0]\n ans = 0\n for i in range(1, n):\n t = (m>>(i-1)) & 1\n if t ==1:\n ans += int(num)\n num = s[i]\n else:\n num = num + s[i]\n ans += int(num)\n return ans",
"value",
"s = input().rstrip()",
"input().rstrip()",
"s",
"count = 0",
"0",
"count"
] | s = input().rstrip()
n = len(s)
def value(m):
num = s[0]
ans = 0
for i in range(1, n):
t = (m>>(i-1)) & 1
if t ==1:
ans += int(num)
num = s[i]
else:
num = num + s[i]
ans += int(num)
return ans
count = 0
for i in range(2**(n-1)):
count +=value(i)
print(count) |
[
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,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13
] | [
[
69,
2
],
[
72,
6
],
[
70,
9
],
[
75,
11
],
[
15,
14
],
[
73,
20
],
[
81,
23
],
[
70,
25
],
[
29,
28
],
[
73,
32
],
[
14,
37
],
[
28,
38
],
[
84,
41
],
[
78,
44
],
[
70,
46
],
[
28,
48
],
[
66,
51
],
[
79,
59
],
[
85,
59
],
[
82,
59
],
[
67,
64
],
[
76,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
]
] | [
"S = input()\nN = len(S) \nans = 0\nfor i in range(2**(N-1)):\n f = S[0]\n for j in range(N-1):\n if ( i >> j ) & 1 :\n f += '+'\n f += S[j+1]\n ans += sum(map(int,f.split('+')))\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 f = S[0]\n for j in range(N-1):\n if ( i >> j ) & 1 :\n f += '+'\n f += S[j+1]\n ans += sum(map(int,f.split('+')))",
"i",
"range(2**(N-1))",
"range",
"2**(N-1)",
"2",
"N-1",
"N",
"1",
"f = S[0]",
"f",
"S[0]",
"S",
"0",
"for j in range(N-1):\n if ( i >> j ) & 1 :\n f += '+'\n f += S[j+1]\n ",
"j",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if ( i >> j ) & 1 :\n f += '+'\n ",
"( i >> j ) & 1",
"i >> j",
"i",
"j",
"1",
"f += '+'",
"f",
"'+'",
"f += S[j+1]",
"f",
"S[j+1]",
"S",
"j+1",
"j",
"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",
"ans += sum(map(int,f.split('+')))",
"sum(map(int,f.split('+')))",
"ans",
"S = input()",
"input()",
"S",
"N = len(S)",
"len(S)",
"N",
"ans = 0",
"0",
"ans",
"f += S[j+1]",
"S[j+1]",
"f",
"f = S[0]",
"S[0]",
"f",
"f += '+'",
"'+'",
"f"
] | S = input()
N = len(S)
ans = 0
for i in range(2**(N-1)):
f = S[0]
for j in range(N-1):
if ( i >> j ) & 1 :
f += '+'
f += S[j+1]
ans += sum(map(int,f.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,
4,
13,
13,
17,
39,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
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,
4,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13
] | [
[
101,
2
],
[
92,
6
],
[
102,
9
],
[
86,
11
],
[
15,
14
],
[
93,
20
],
[
83,
23
],
[
14,
27
],
[
80,
32
],
[
102,
34
],
[
38,
37
],
[
93,
41
],
[
84,
46
],
[
37,
47
],
[
95,
50
],
[
81,
53
],
[
99,
53
],
[
90,
53
],
[
89,
55
],
[
102,
57
],
[
37,
59
],
[
98,
62
],
[
102,
64
],
[
37,
66
],
[
77,
69
],
[
99,
72
],
[
90,
72
],
[
81,
72
],
[
78,
75
],
[
96,
75
],
[
87,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
]
] | [
"S = input()\nN = len(S)\n\ns = 0\nfor i in range(1 << (N - 1)):\n bs = format(i, f'0{N - 1}b')[::-1]\n t = S[0]\n for j in range(N - 1):\n if bs[j] == '1':\n s += int(t)\n t = S[j + 1]\n else:\n t += S[j + 1]\n s += int(t)\nprint(s)",
"S = input()",
"S",
"input()",
"input",
"N = len(S)",
"N",
"len(S)",
"len",
"S",
"s = 0",
"s",
"0",
"for i in range(1 << (N - 1)):\n bs = format(i, f'0{N - 1}b')[::-1]\n t = S[0]\n for j in range(N - 1):\n if bs[j] == '1':\n s += int(t)\n t = S[j + 1]\n else:\n t += S[j + 1]\n s += int(t)",
"i",
"range(1 << (N - 1))",
"range",
"1 << (N - 1)",
"1",
"N - 1",
"N",
"1",
"bs = format(i, f'0{N - 1}b')[::-1]",
"bs",
"format(i, f'0{N - 1}b')[::-1]",
"(i, f'0{N - 1}b')",
"format",
"i",
"f'0{N - 1}b'",
"::-1",
"-1",
"t = S[0]",
"t",
"S[0]",
"S",
"0",
"for j in range(N - 1):\n if bs[j] == '1':\n s += int(t)\n t = S[j + 1]\n else:\n t += S[j + 1]\n ",
"j",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if bs[j] == '1':\n s += int(t)\n t = S[j + 1]\n else:\n t += S[j + 1]\n ",
"bs[j] == '1'",
"bs[j]",
"bs",
"j",
"'1'",
"s += int(t)",
"s",
"int(t)",
"int",
"t",
"t = S[j + 1]",
"t",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"t += S[j + 1]",
"t",
"S[j + 1]",
"S",
"j + 1",
"j",
"1",
"s += int(t)",
"s",
"int(t)",
"int",
"t",
"print(s)",
"print",
"s",
"s += int(t)",
"int(t)",
"s",
"t = S[0]",
"S[0]",
"t",
"bs = format(i, f'0{N - 1}b')[::-1]",
"format(i, f'0{N - 1}b')[::-1]",
"bs",
"s = 0",
"0",
"s",
"t = S[j + 1]",
"S[j + 1]",
"t",
"N = len(S)",
"len(S)",
"N",
"s += int(t)",
"int(t)",
"s",
"t += S[j + 1]",
"S[j + 1]",
"t",
"S = input()",
"input()",
"S"
] | S = input()
N = len(S)
s = 0
for i in range(1 << (N - 1)):
bs = format(i, f'0{N - 1}b')[::-1]
t = S[0]
for j in range(N - 1):
if bs[j] == '1':
s += int(t)
t = S[j + 1]
else:
t += S[j + 1]
s += int(t)
print(s)
|
[
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,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
2,
40,
13,
17,
13,
17,
0,
13,
17,
0,
13,
4,
18,
17,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
105,
2
],
[
108,
8
],
[
106,
11
],
[
96,
13
],
[
17,
16
],
[
109,
22
],
[
99,
25
],
[
93,
28
],
[
34,
33
],
[
109,
37
],
[
16,
42
],
[
33,
43
],
[
94,
47
],
[
106,
47
],
[
33,
52
],
[
100,
54
],
[
91,
54
],
[
90,
57
],
[
87,
60
],
[
94,
65
],
[
106,
65
],
[
111,
67
],
[
88,
75
],
[
102,
79
],
[
112,
82
],
[
103,
85
],
[
97,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
]
] | [
"s=list(input())\nn=len(s)\nans=0\nfor i in range(2**(n-1)):\n d=0\n s=list(x for x in s if x!=\"a\")\n for j in range(n-1):\n if (i >> j)&1:\n s.insert(-j-1-d,\"a\")\n d+=1\n z=\"\".join(s)\n y=list(map(int,z.split(\"a\")))\n ans+=sum(y)\nprint(ans)\n \n \n ",
"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 d=0\n s=list(x for x in s if x!=\"a\")\n for j in range(n-1):\n if (i >> j)&1:\n s.insert(-j-1-d,\"a\")\n d+=1\n z=\"\".join(s)\n y=list(map(int,z.split(\"a\")))\n ans+=sum(y)",
"i",
"range(2**(n-1))",
"range",
"2**(n-1)",
"2",
"n-1",
"n",
"1",
"d=0",
"d",
"0",
"s=list(x for x in s if x!=\"a\")",
"s",
"list(x for x in s if x!=\"a\")",
"list",
"x",
"for j in range(n-1):\n if (i >> j)&1:\n s.insert(-j-1-d,\"a\")\n d+=1\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if (i >> j)&1:\n s.insert(-j-1-d,\"a\")\n d+=1\n ",
"(i >> j)&1",
"i >> j",
"i",
"j",
"1",
"s.insert(-j-1-d,\"a\")",
"s.insert",
"s",
"insert",
"-j-1-d",
"-j-1",
"-j",
"j",
"1",
"d",
"\"a\"",
"d+=1",
"d",
"1",
"z=\"\".join(s)",
"z",
"\"\".join(s)",
"\"\".join",
"\"\"",
"join",
"s",
"y=list(map(int,z.split(\"a\")))",
"y",
"list(map(int,z.split(\"a\")))",
"list",
"map(int,z.split(\"a\"))",
"map",
"int",
"z.split(\"a\")",
"z.split",
"z",
"split",
"\"a\"",
"ans+=sum(y)",
"ans",
"sum(y)",
"sum",
"y",
"print(ans)",
"print",
"ans",
"z=\"\".join(s)",
"\"\".join(s)",
"z",
"d+=1",
"1",
"d",
"s=list(x for x in s if x!=\"a\")",
"list(x for x in s if x!=\"a\")",
"s",
"ans=0",
"0",
"ans",
"d=0",
"0",
"d",
"ans+=sum(y)",
"sum(y)",
"ans",
"s=list(input())",
"list(input())",
"s",
"n=len(s)",
"len(s)",
"n",
"y=list(map(int,z.split(\"a\")))",
"list(map(int,z.split(\"a\")))",
"y"
] | s=list(input())
n=len(s)
ans=0
for i in range(2**(n-1)):
d=0
s=list(x for x in s if x!="a")
for j in range(n-1):
if (i >> j)&1:
s.insert(-j-1-d,"a")
d+=1
z="".join(s)
y=list(map(int,z.split("a")))
ans+=sum(y)
print(ans)
|
[
7,
15,
13,
13,
13,
13,
13,
13,
13,
13,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
12,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
2,
4,
13,
13,
17,
12,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
12,
13,
12,
13,
12,
13,
0,
13,
4,
13,
0,
13,
4,
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,
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,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
187,
11
],
[
178,
30
],
[
43,
42
],
[
188,
46
],
[
42,
51
],
[
57,
56
],
[
188,
60
],
[
56,
66
],
[
73,
72
],
[
188,
76
],
[
72,
81
],
[
90,
89
],
[
167,
91
],
[
94,
93
],
[
89,
96
],
[
99,
98
],
[
102,
101
],
[
89,
109
],
[
113,
112
],
[
89,
114
],
[
118,
117
],
[
93,
121
],
[
101,
126
],
[
117,
127
],
[
131,
130
],
[
112,
133
],
[
142,
133
],
[
135,
133
],
[
136,
135
],
[
89,
137
],
[
117,
139
],
[
143,
142
],
[
89,
144
],
[
117,
146
],
[
150,
149
],
[
142,
152
],
[
135,
152
],
[
112,
152
],
[
149,
155
],
[
130,
155
],
[
98,
155
],
[
176,
161
],
[
178,
179
],
[
187,
188
]
] | [
"import bisect, collections, copy, heapq, itertools, math, string, sys\ninput = lambda: sys.stdin.readline().rstrip() \nsys.setrecursionlimit(10**7)\nINF = float('inf')\ndef I(): return int(input())\ndef F(): return float(input())\ndef SS(): return input()\ndef LI(): return [int(x) for x in input().split()]\ndef LI_(): return [int(x)-1 for x in input().split()]\ndef LF(): return [float(x) for x in input().split()]\ndef LSS(): return input().split()\n\ndef resolve():\n S = SS()\n len_S = len(S)\n\n ans = 0\n for i in range(2 ** (len(S) - 1)):\n tmp = S[0]\n for j in range(len_S - 1):\n if i >> j & 1:\n ans += int(tmp)\n tmp = S[j+1]\n else:\n tmp += S[j+1]\n ans += int(tmp)\n\n print(ans)\n\nif __name__ == '__main__':\n resolve()",
"import bisect, collections, copy, heapq, itertools, math, string, sys",
"bisect",
"collections",
"copy",
"heapq",
"itertools",
"math",
"string",
"sys",
"input = lambda: sys.stdin.readline().rstrip()",
"input",
"lambda: sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"sys.setrecursionlimit(10**7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**7",
"10",
"7",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"def I(): return int(input())",
"I",
"def F(): return float(input())",
"F",
"def SS(): return input()",
"SS",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"def LI(): return [int(x) for x in input().split()]",
"LI",
"int(x)-1 for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)-1",
"int(x)",
"int",
"x",
"1",
"def LI_(): return [int(x)-1 for x in input().split()]",
"LI_",
"float(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"float(x)",
"float",
"x",
"def LF(): return [float(x) for x in input().split()]",
"LF",
"def LSS(): return input().split()",
"LSS",
"def resolve():\n S = SS()\n len_S = len(S)\n\n ans = 0\n for i in range(2 ** (len(S) - 1)):\n tmp = S[0]\n for j in range(len_S - 1):\n if i >> j & 1:\n ans += int(tmp)\n tmp = S[j+1]\n else:\n tmp += S[j+1]\n ans += int(tmp)\n\n print(ans)",
"resolve",
"S = SS()",
"S",
"SS()",
"SS",
"len_S = len(S)",
"len_S",
"len(S)",
"len",
"S",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (len(S) - 1)):\n tmp = S[0]\n for j in range(len_S - 1):\n if i >> j & 1:\n ans += int(tmp)\n tmp = S[j+1]\n else:\n tmp += S[j+1]\n ans += int(tmp)\n\n ",
"i",
"range(2 ** (len(S) - 1))",
"range",
"2 ** (len(S) - 1)",
"2",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"tmp = S[0]",
"tmp",
"S[0]",
"S",
"0",
"for j in range(len_S - 1):\n if i >> j & 1:\n ans += int(tmp)\n tmp = S[j+1]\n else:\n tmp += S[j+1]\n ",
"j",
"range(len_S - 1)",
"range",
"len_S - 1",
"len_S",
"1",
"if i >> j & 1:\n ans += int(tmp)\n tmp = S[j+1]\n else:\n tmp += S[j+1]\n ",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"ans += int(tmp)",
"ans",
"int(tmp)",
"int",
"tmp",
"tmp = S[j+1]",
"tmp",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"tmp += S[j+1]",
"tmp",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"ans += int(tmp)",
"ans",
"int(tmp)",
"int",
"tmp",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n resolve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"resolve()",
"resolve",
"def LI(): return [int(x) for x in input().split()]",
"def LI(): return [int(x) for x in input().split()]",
"LI",
"def SS(): return input()",
"def SS(): return input()",
"SS",
"def F(): return float(input())",
"def F(): return float(input())",
"F",
"def LI_(): return [int(x)-1 for x in input().split()]",
"def LI_(): return [int(x)-1 for x in input().split()]",
"LI_",
"def resolve():\n S = SS()\n len_S = len(S)\n\n ans = 0\n for i in range(2 ** (len(S) - 1)):\n tmp = S[0]\n for j in range(len_S - 1):\n if i >> j & 1:\n ans += int(tmp)\n tmp = S[j+1]\n else:\n tmp += S[j+1]\n ans += int(tmp)\n\n print(ans)",
"def resolve():\n S = SS()\n len_S = len(S)\n\n ans = 0\n for i in range(2 ** (len(S) - 1)):\n tmp = S[0]\n for j in range(len_S - 1):\n if i >> j & 1:\n ans += int(tmp)\n tmp = S[j+1]\n else:\n tmp += S[j+1]\n ans += int(tmp)\n\n print(ans)",
"resolve",
"INF = float('inf')",
"float('inf')",
"INF",
"def LF(): return [float(x) for x in input().split()]",
"def LF(): return [float(x) for x in input().split()]",
"LF",
"def LSS(): return input().split()",
"def LSS(): return input().split()",
"LSS",
"input = lambda: sys.stdin.readline().rstrip()",
"lambda: sys.stdin.readline().rstrip()",
"input",
"def I(): return int(input())",
"def I(): return int(input())",
"I"
] | import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()
def resolve():
S = SS()
len_S = len(S)
ans = 0
for i in range(2 ** (len(S) - 1)):
tmp = S[0]
for j in range(len_S - 1):
if i >> j & 1:
ans += int(tmp)
tmp = S[j+1]
else:
tmp += S[j+1]
ans += int(tmp)
print(ans)
if __name__ == '__main__':
resolve()
|
[
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,
28,
13,
4,
13,
13,
14,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
13,
17,
0,
13,
39,
14,
40,
13,
4,
18,
13,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
13,
14,
2,
13,
17,
4,
18,
13,
13,
4,
13,
18,
13,
39,
18,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
4,
13,
18,
13,
39,
18,
13,
13,
4,
18,
13,
13,
4,
13,
18,
13,
39,
18,
13,
2,
13,
17,
18,
13,
13,
14,
2,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
4,
13,
18,
13,
39,
18,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
17,
13,
10,
39,
13
] | [
[
148,
2
],
[
154,
6
],
[
149,
10
],
[
157,
13
],
[
17,
16
],
[
155,
21
],
[
160,
23
],
[
27,
26
],
[
155,
29
],
[
16,
33
],
[
26,
34
],
[
161,
38
],
[
26,
41
],
[
151,
44
],
[
161,
48
],
[
152,
51
],
[
149,
55
],
[
58,
57
],
[
161,
62
],
[
57,
65
],
[
152,
69
],
[
149,
74
],
[
161,
77
],
[
57,
78
],
[
57,
81
],
[
161,
85
],
[
152,
89
],
[
149,
94
],
[
161,
97
],
[
57,
98
],
[
152,
101
],
[
149,
106
],
[
161,
109
],
[
57,
111
],
[
161,
114
],
[
57,
115
],
[
57,
118
],
[
161,
122
],
[
152,
126
],
[
149,
131
],
[
161,
134
],
[
57,
135
],
[
145,
137
],
[
152,
140
],
[
146,
143
],
[
158,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
]
] | [
"S = input()\nN = len(S) - 1\n\nans = 0\nfor i in range(2 ** N):\n add_pos = []\n for j in range(N):\n if (i >> j) & 1:\n add_pos.append(j + 1)\n\n to_be_sumed = []\n\n if not add_pos:\n to_be_sumed.append(int(S))\n\n for i in range(len(add_pos)):\n if i == 0:\n to_be_sumed.append(int(S[:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n else:\n to_be_sumed.append(int(S[add_pos[i - 1]:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n # print(to_be_sumed)\n ans += sum(to_be_sumed)\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 add_pos = []\n for j in range(N):\n if (i >> j) & 1:\n add_pos.append(j + 1)\n\n to_be_sumed = []\n\n if not add_pos:\n to_be_sumed.append(int(S))\n\n for i in range(len(add_pos)):\n if i == 0:\n to_be_sumed.append(int(S[:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n else:\n to_be_sumed.append(int(S[add_pos[i - 1]:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n # print(to_be_sumed)\n ans += sum(to_be_sumed)",
"i",
"range(2 ** N)",
"range",
"2 ** N",
"2",
"N",
"add_pos = []",
"add_pos",
"[]",
"for j in range(N):\n if (i >> j) & 1:\n add_pos.append(j + 1)\n\n ",
"j",
"range(N)",
"range",
"N",
"if (i >> j) & 1:\n add_pos.append(j + 1)\n\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"add_pos.append(j + 1)",
"add_pos.append",
"add_pos",
"append",
"j + 1",
"j",
"1",
"to_be_sumed = []",
"to_be_sumed",
"[]",
"if not add_pos:\n to_be_sumed.append(int(S))\n\n ",
"not add_pos",
"add_pos",
"to_be_sumed.append(int(S))",
"to_be_sumed.append",
"to_be_sumed",
"append",
"int(S)",
"int",
"S",
"for i in range(len(add_pos)):\n if i == 0:\n to_be_sumed.append(int(S[:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n else:\n to_be_sumed.append(int(S[add_pos[i - 1]:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n # print(to_be_sumed)\n ",
"i",
"range(len(add_pos))",
"range",
"len(add_pos)",
"len",
"add_pos",
"if i == 0:\n to_be_sumed.append(int(S[:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n else:\n to_be_sumed.append(int(S[add_pos[i - 1]:add_pos[i]]))\n if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n # print(to_be_sumed)\n ",
"i == 0",
"i",
"0",
"to_be_sumed.append(int(S[:add_pos[i]]))",
"to_be_sumed.append",
"to_be_sumed",
"append",
"int(S[:add_pos[i]])",
"int",
"S[:add_pos[i]]",
"S",
":add_pos[i]",
"add_pos[i]",
"add_pos",
"i",
"if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n ",
"i == len(add_pos) - 1",
"i",
"len(add_pos) - 1",
"len(add_pos)",
"len",
"add_pos",
"1",
"to_be_sumed.append(int(S[add_pos[i]:]))",
"to_be_sumed.append",
"to_be_sumed",
"append",
"int(S[add_pos[i]:])",
"int",
"S[add_pos[i]:]",
"S",
"add_pos[i]:",
"add_pos[i]",
"add_pos",
"i",
"to_be_sumed.append(int(S[add_pos[i - 1]:add_pos[i]]))",
"to_be_sumed.append",
"to_be_sumed",
"append",
"int(S[add_pos[i - 1]:add_pos[i]])",
"int",
"S[add_pos[i - 1]:add_pos[i]]",
"S",
"add_pos[i - 1]:add_pos[i]",
"add_pos[i - 1]",
"add_pos",
"i - 1",
"i",
"1",
"add_pos[i]",
"add_pos",
"i",
"if i == len(add_pos) - 1:\n to_be_sumed.append(int(S[add_pos[i]:]))\n # print(to_be_sumed)\n ",
"i == len(add_pos) - 1",
"i",
"len(add_pos) - 1",
"len(add_pos)",
"len",
"add_pos",
"1",
"to_be_sumed.append(int(S[add_pos[i]:]))",
"to_be_sumed.append",
"to_be_sumed",
"append",
"int(S[add_pos[i]:])",
"int",
"S[add_pos[i]:]",
"S",
"add_pos[i]:",
"add_pos[i]",
"add_pos",
"i",
"ans += sum(to_be_sumed)",
"ans",
"sum(to_be_sumed)",
"sum",
"to_be_sumed",
"print(ans)",
"print",
"ans",
"ans += sum(to_be_sumed)",
"sum(to_be_sumed)",
"ans",
"S = input()",
"input()",
"S",
"to_be_sumed = []",
"[]",
"to_be_sumed",
"N = len(S) - 1",
"len(S) - 1",
"N",
"ans = 0",
"0",
"ans",
"add_pos = []",
"[]",
"add_pos"
] | S = input()
N = len(S) - 1
ans = 0
for i in range(2 ** N):
add_pos = []
for j in range(N):
if (i >> j) & 1:
add_pos.append(j + 1)
to_be_sumed = []
if not add_pos:
to_be_sumed.append(int(S))
for i in range(len(add_pos)):
if i == 0:
to_be_sumed.append(int(S[:add_pos[i]]))
if i == len(add_pos) - 1:
to_be_sumed.append(int(S[add_pos[i]:]))
else:
to_be_sumed.append(int(S[add_pos[i - 1]:add_pos[i]]))
if i == len(add_pos) - 1:
to_be_sumed.append(int(S[add_pos[i]:]))
# print(to_be_sumed)
ans += sum(to_be_sumed)
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,
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,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
64,
2
],
[
82,
6
],
[
65,
10
],
[
79,
13
],
[
17,
16
],
[
83,
21
],
[
67,
23
],
[
27,
26
],
[
83,
29
],
[
16,
33
],
[
26,
34
],
[
70,
37
],
[
65,
41
],
[
26,
45
],
[
73,
48
],
[
26,
50
],
[
76,
53
],
[
65,
57
],
[
77,
62
],
[
71,
62
],
[
80,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
]
] | [
"s = input()\nn = len(s)-1\nans = 0\nfor i in range(2**n):\n k = 0\n for j in range(n):\n if (i >> j) & 1:\n ans += int(s[k:j+1])\n k = j+1\n ans += int(s[k:])\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 k = 0\n for j in range(n):\n if (i >> j) & 1:\n ans += int(s[k:j+1])\n k = j+1\n ans += int(s[k:])",
"i",
"range(2**n)",
"range",
"2**n",
"2",
"n",
"k = 0",
"k",
"0",
"for j in range(n):\n if (i >> j) & 1:\n ans += int(s[k:j+1])\n k = j+1\n ",
"j",
"range(n)",
"range",
"n",
"if (i >> j) & 1:\n ans += int(s[k:j+1])\n k = j+1\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"ans += int(s[k:j+1])",
"ans",
"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",
"ans += int(s[k:])",
"ans",
"int(s[k:])",
"int",
"s[k:]",
"s",
"k:",
"k",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"k = 0",
"0",
"k",
"ans += int(s[k:j+1])",
"int(s[k:j+1])",
"ans",
"k = j+1",
"j+1",
"k",
"ans += int(s[k:])",
"int(s[k:])",
"ans",
"ans = 0",
"0",
"ans",
"n = len(s)-1",
"len(s)-1",
"n"
] | s = input()
n = len(s)-1
ans = 0
for i in range(2**n):
k = 0
for j in range(n):
if (i >> j) & 1:
ans += int(s[k:j+1])
k = j+1
ans += int(s[k:])
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
39,
28,
13,
4,
13,
2,
17,
2,
4,
13,
13,
17,
0,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
2,
13,
13,
17,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
18,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
90,
2
],
[
102,
8
],
[
12,
11
],
[
91,
19
],
[
93,
22
],
[
84,
25
],
[
91,
27
],
[
31,
30
],
[
91,
36
],
[
11,
42
],
[
30,
43
],
[
81,
47
],
[
91,
49
],
[
30,
51
],
[
99,
54
],
[
85,
57
],
[
88,
57
],
[
82,
57
],
[
87,
59
],
[
91,
61
],
[
30,
63
],
[
96,
66
],
[
88,
69
],
[
82,
69
],
[
85,
69
],
[
103,
72
],
[
97,
74
],
[
100,
74
],
[
94,
74
],
[
103,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
]
] | [
"s=list(input())\nans=[]\nfor i in range(1<<(len(s)-1)):\n tmp=0\n num=s[0]\n for j in range(len(s)-1):\n if (i>>j)%2==0:\n num+=s[j+1]\n else:\n tmp+=int(num)\n num=s[j+1]\n #print(num)\n tmp+=int(num)\n ans.append(tmp)\nprint(sum(ans))",
"s=list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"ans=[]",
"ans",
"[]",
"for i in range(1<<(len(s)-1)):\n tmp=0\n num=s[0]\n for j in range(len(s)-1):\n if (i>>j)%2==0:\n num+=s[j+1]\n else:\n tmp+=int(num)\n num=s[j+1]\n #print(num)\n tmp+=int(num)\n ans.append(tmp)",
"i",
"range(1<<(len(s)-1))",
"range",
"1<<(len(s)-1)",
"1",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"tmp=0",
"tmp",
"0",
"num=s[0]",
"num",
"s[0]",
"s",
"0",
"for j in range(len(s)-1):\n if (i>>j)%2==0:\n num+=s[j+1]\n else:\n tmp+=int(num)\n num=s[j+1]\n #print(num)\n ",
"j",
"range(len(s)-1)",
"range",
"len(s)-1",
"len(s)",
"len",
"s",
"1",
"if (i>>j)%2==0:\n num+=s[j+1]\n else:\n tmp+=int(num)\n num=s[j+1]\n #print(num)\n ",
"(i>>j)%2==0",
"(i>>j)%2",
"i>>j",
"i",
"j",
"2",
"0",
"num+=s[j+1]",
"num",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"tmp+=int(num)",
"tmp",
"int(num)",
"int",
"num",
"num=s[j+1]",
"num",
"s[j+1]",
"s",
"j+1",
"j",
"1",
"tmp+=int(num)",
"tmp",
"int(num)",
"int",
"num",
"ans.append(tmp)",
"ans.append",
"ans",
"append",
"tmp",
"print(sum(ans))",
"print",
"sum(ans)",
"sum",
"ans",
"num+=s[j+1]",
"s[j+1]",
"num",
"num=s[0]",
"s[0]",
"num",
"num=s[j+1]",
"s[j+1]",
"num",
"s=list(input())",
"list(input())",
"s",
"tmp=0",
"0",
"tmp",
"tmp+=int(num)",
"int(num)",
"tmp",
"tmp+=int(num)",
"int(num)",
"tmp",
"ans=[]",
"[]",
"ans"
] | s=list(input())
ans=[]
for i in range(1<<(len(s)-1)):
tmp=0
num=s[0]
for j in range(len(s)-1):
if (i>>j)%2==0:
num+=s[j+1]
else:
tmp+=int(num)
num=s[j+1]
#print(num)
tmp+=int(num)
ans.append(tmp)
print(sum(ans)) |
[
7,
0,
13,
4,
13,
0,
13,
39,
39,
17,
28,
13,
4,
13,
17,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
39,
13,
0,
13,
2,
13,
13,
0,
13,
13,
41,
28,
13,
13,
4,
2,
13,
39,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
18,
13,
13,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
18,
13,
39,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
39,
13
] | [
[
88,
2
],
[
112,
6
],
[
12,
11
],
[
89,
17
],
[
21,
20
],
[
113,
20
],
[
95,
20
],
[
20,
24
],
[
91,
28
],
[
113,
31
],
[
95,
31
],
[
94,
33
],
[
92,
34
],
[
38,
37
],
[
95,
37
],
[
113,
37
],
[
37,
41
],
[
89,
45
],
[
109,
47
],
[
106,
50
],
[
54,
53
],
[
110,
53
],
[
95,
53
],
[
113,
53
],
[
57,
56
],
[
53,
62
],
[
97,
65
],
[
53,
67
],
[
56,
68
],
[
100,
69
],
[
53,
71
],
[
56,
73
],
[
103,
76
],
[
89,
80
],
[
104,
86
],
[
107,
86
],
[
88,
89
],
[
91,
92
],
[
92,
94
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
]
] | [
"# -*- coding: utf-8 -*-\nS = input()\n\nbuf = [[0]]\nfor i in range(1, len(S)):\n buf2 = [b + [i] for b in buf] + buf\n buf = buf2\nbuf = [b + [len(S)] for b in buf]\n\nans = 0\nfor b in buf:\n for i in range(len(b) - 1):\n right, left = b[i], b[i+1]\n ans += int(S[right: left])\nprint(ans)",
"S = input()",
"S",
"input()",
"input",
"buf = [[0]]",
"buf",
"[[0]]",
"[0]",
"0",
"for i in range(1, len(S)):\n buf2 = [b + [i] for b in buf] + buf\n buf = buf2",
"i",
"range(1, len(S))",
"range",
"1",
"len(S)",
"len",
"S",
"b + [i] for b in buf",
"for b in buf",
"b",
"buf",
"for b in buf",
"b + [i]",
"b",
"[i]",
"i",
"buf2 = [b + [i] for b in buf] + buf",
"buf2",
"[b + [i] for b in buf] + buf",
"[b + [i] for b in buf]",
"buf",
"buf = buf2",
"buf",
"buf2",
"b + [len(S)] for b in buf",
"for b in buf",
"b",
"buf",
"for b in buf",
"b + [len(S)]",
"b",
"[len(S)]",
"len(S)",
"len",
"S",
"buf = [b + [len(S)] for b in buf]",
"buf",
"[b + [len(S)] for b in buf]",
"ans = 0",
"ans",
"0",
"for b in buf:\n for i in range(len(b) - 1):\n right, left = b[i], b[i+1]\n ans += int(S[right: left])",
"b",
"buf",
"for i in range(len(b) - 1):\n right, left = b[i], b[i+1]\n ans += int(S[right: left])",
"i",
"range(len(b) - 1)",
"range",
"len(b) - 1",
"len(b)",
"len",
"b",
"1",
"right, left = b[i], b[i+1]",
"right",
"b[i]",
"b",
"i",
"left",
"b[i+1]",
"b",
"i+1",
"i",
"1",
"ans += int(S[right: left])",
"ans",
"int(S[right: left])",
"int",
"S[right: left]",
"S",
"right: left",
"right",
"left",
"print(ans)",
"print",
"ans",
"S = input()",
"input()",
"S",
"buf2 = [b + [i] for b in buf] + buf",
"[b + [i] for b in buf] + buf",
"buf2",
"buf = buf2",
"buf2",
"buf",
"right, left = b[i], b[i+1]",
"b[i]",
"right",
"left = b[i], b[i+1]",
"b[i+1]",
"left",
"ans += int(S[right: left])",
"int(S[right: left])",
"ans",
"ans = 0",
"0",
"ans",
"buf = [b + [len(S)] for b in buf]",
"[b + [len(S)] for b in buf]",
"buf",
"buf = [[0]]",
"[[0]]",
"buf"
] | # -*- coding: utf-8 -*-
S = input()
buf = [[0]]
for i in range(1, len(S)):
buf2 = [b + [i] for b in buf] + buf
buf = buf2
buf = [b + [len(S)] for b in buf]
ans = 0
for b in buf:
for i in range(len(b) - 1):
right, left = b[i], b[i+1]
ans += int(S[right: left])
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,
18,
13,
17,
28,
13,
4,
13,
2,
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,
14,
2,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
13,
14,
2,
13,
17,
4,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] | [
[
89,
2
],
[
110,
6
],
[
90,
9
],
[
107,
11
],
[
15,
14
],
[
111,
20
],
[
95,
23
],
[
101,
26
],
[
90,
28
],
[
32,
31
],
[
111,
35
],
[
14,
40
],
[
31,
41
],
[
113,
44
],
[
102,
47
],
[
117,
47
],
[
93,
47
],
[
92,
49
],
[
90,
51
],
[
31,
53
],
[
116,
56
],
[
90,
58
],
[
31,
60
],
[
31,
64
],
[
111,
66
],
[
98,
69
],
[
117,
72
],
[
93,
72
],
[
102,
72
],
[
104,
74
],
[
99,
75
],
[
114,
75
],
[
96,
75
],
[
111,
78
],
[
90,
84
],
[
105,
87
],
[
108,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
99,
104
],
[
114,
104
],
[
96,
104
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
]
] | [
"S = input()\nn = len(S)\nres = 0\nfor i in range(1 << n-1):\n subres = 0\n subst = S[0]\n for j in range(n-1):\n if i >> j & 1:\n subres += int(subst)\n subst = S[j+1]\n else:\n subst += S[j+1]\n if j == n - 2:\n subres += int(subst)\n res += subres\nif n == 1:\n print(int(S))\nelse:\n print(res)\n\n",
"S = input()",
"S",
"input()",
"input",
"n = len(S)",
"n",
"len(S)",
"len",
"S",
"res = 0",
"res",
"0",
"for i in range(1 << n-1):\n subres = 0\n subst = S[0]\n for j in range(n-1):\n if i >> j & 1:\n subres += int(subst)\n subst = S[j+1]\n else:\n subst += S[j+1]\n if j == n - 2:\n subres += int(subst)\n res += subres",
"i",
"range(1 << n-1)",
"range",
"1 << n-1",
"1",
"n-1",
"n",
"1",
"subres = 0",
"subres",
"0",
"subst = S[0]",
"subst",
"S[0]",
"S",
"0",
"for j in range(n-1):\n if i >> j & 1:\n subres += int(subst)\n subst = S[j+1]\n else:\n subst += S[j+1]\n if j == n - 2:\n subres += int(subst)\n ",
"j",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"if i >> j & 1:\n subres += int(subst)\n subst = S[j+1]\n else:\n subst += S[j+1]\n ",
"i >> j & 1",
"i >> j",
"i",
"j",
"1",
"subres += int(subst)",
"subres",
"int(subst)",
"int",
"subst",
"subst = S[j+1]",
"subst",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"subst += S[j+1]",
"subst",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"if j == n - 2:\n subres += int(subst)\n ",
"j == n - 2",
"j",
"n - 2",
"n",
"2",
"subres += int(subst)",
"subres",
"int(subst)",
"int",
"subst",
"res += subres",
"res",
"subres",
"if n == 1:\n print(int(S))\nelse:\n print(res)",
"n == 1",
"n",
"1",
"print(int(S))",
"print",
"int(S)",
"int",
"S",
"print(res)",
"print",
"res",
"S = input()",
"input()",
"S",
"subst = S[j+1]",
"S[j+1]",
"subst",
"subres = 0",
"0",
"subres",
"subres += int(subst)",
"int(subst)",
"subres",
"subst = S[0]",
"S[0]",
"subst",
"res += subres",
"subres",
"res",
"res = 0",
"0",
"res",
"n = len(S)",
"len(S)",
"n",
"subres += int(subst)",
"int(subst)",
"subres",
"subst += S[j+1]",
"S[j+1]",
"subst"
] | S = input()
n = len(S)
res = 0
for i in range(1 << n-1):
subres = 0
subst = S[0]
for j in range(n-1):
if i >> j & 1:
subres += int(subst)
subst = S[j+1]
else:
subst += S[j+1]
if j == n - 2:
subres += int(subst)
res += subres
if n == 1:
print(int(S))
else:
print(res)
|
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
17,
2,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
13,
2,
17,
13,
0,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
4,
11
],
[
14,
13
],
[
17,
16
],
[
20,
19
],
[
8,
25
],
[
29,
28
],
[
4,
30
],
[
34,
33
],
[
8,
38
],
[
19,
42
],
[
33,
45
],
[
48,
47
],
[
28,
49
],
[
52,
49
],
[
47,
49
],
[
53,
52
],
[
47,
54
],
[
28,
54
],
[
52,
54
],
[
4,
56
],
[
33,
58
],
[
62,
61
],
[
52,
64
],
[
47,
64
],
[
28,
64
],
[
61,
67
],
[
16,
67
],
[
76,
73
]
] | [
"def main():\n s = input()\n p = len(s)\n i = 0\n ans = 0\n for i in range(2 ** (p-1)):\n t = s[0]\n for j in range(0,p-1):\n if (i & (1 << j)):\n t = t + \"+\"\n t = t + s[j+1]\n \n #print(bin(i),t,eval(t))\n ans += eval(t)\n \n print(ans)\n \nif __name__ == '__main__':\n main()",
"def main():\n s = input()\n p = len(s)\n i = 0\n ans = 0\n for i in range(2 ** (p-1)):\n t = s[0]\n for j in range(0,p-1):\n if (i & (1 << j)):\n t = t + \"+\"\n t = t + s[j+1]\n \n #print(bin(i),t,eval(t))\n ans += eval(t)\n \n print(ans)\n ",
"main",
"s = input()",
"s",
"input()",
"input",
"p = len(s)",
"p",
"len(s)",
"len",
"s",
"i = 0",
"i",
"0",
"ans = 0",
"ans",
"0",
"for i in range(2 ** (p-1)):\n t = s[0]\n for j in range(0,p-1):\n if (i & (1 << j)):\n t = t + \"+\"\n t = t + s[j+1]\n \n #print(bin(i),t,eval(t))\n ans += eval(t)\n \n ",
"i",
"range(2 ** (p-1))",
"range",
"2 ** (p-1)",
"2",
"p-1",
"p",
"1",
"t = s[0]",
"t",
"s[0]",
"s",
"0",
"for j in range(0,p-1):\n if (i & (1 << j)):\n t = t + \"+\"\n t = t + s[j+1]\n \n #print(bin(i),t,eval(t))\n ",
"j",
"range(0,p-1)",
"range",
"0",
"p-1",
"p",
"1",
"if (i & (1 << j)):\n t = t + \"+\"\n ",
"i & (1 << j)",
"i",
"1 << j",
"1",
"j",
"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",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n s = input()\n p = len(s)\n i = 0\n ans = 0\n for i in range(2 ** (p-1)):\n t = s[0]\n for j in range(0,p-1):\n if (i & (1 << j)):\n t = t + \"+\"\n t = t + s[j+1]\n \n #print(bin(i),t,eval(t))\n ans += eval(t)\n \n print(ans)\n ",
"def main():\n s = input()\n p = len(s)\n i = 0\n ans = 0\n for i in range(2 ** (p-1)):\n t = s[0]\n for j in range(0,p-1):\n if (i & (1 << j)):\n t = t + \"+\"\n t = t + s[j+1]\n \n #print(bin(i),t,eval(t))\n ans += eval(t)\n \n print(ans)\n ",
"main"
] | def main():
s = input()
p = len(s)
i = 0
ans = 0
for i in range(2 ** (p-1)):
t = s[0]
for j in range(0,p-1):
if (i & (1 << j)):
t = t + "+"
t = t + s[j+1]
#print(bin(i),t,eval(t))
ans += eval(t)
print(ans)
if __name__ == '__main__':
main() |
[
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,
13,
13,
17,
0,
13,
2,
2,
13,
17,
4,
13,
18,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13
] | [
[
71,
2
],
[
89,
8
],
[
72,
12
],
[
83,
15
],
[
19,
18
],
[
90,
23
],
[
77,
25
],
[
72,
27
],
[
31,
30
],
[
90,
33
],
[
18,
37
],
[
30,
38
],
[
86,
41
],
[
78,
44
],
[
75,
44
],
[
87,
44
],
[
72,
49
],
[
30,
51
],
[
74,
54
],
[
78,
56
],
[
75,
56
],
[
87,
56
],
[
72,
58
],
[
30,
60
],
[
80,
63
],
[
75,
66
],
[
87,
66
],
[
78,
66
],
[
81,
69
],
[
84,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] | [
"S = list(input())\nnum_cnt = len(S) - 1\ntotal = 0\n\nfor i in range(2 ** num_cnt):\n temp_sum = S[0]\n for j in range(num_cnt):\n if ((i >> j) & 1):\n temp_sum = temp_sum + '+' + str(S[j+1])\n else:\n temp_sum = temp_sum + S[j+1]\n total += eval(temp_sum)\n\nprint(total)",
"S = list(input())",
"S",
"list(input())",
"list",
"input()",
"input",
"num_cnt = len(S) - 1",
"num_cnt",
"len(S) - 1",
"len(S)",
"len",
"S",
"1",
"total = 0",
"total",
"0",
"for i in range(2 ** num_cnt):\n temp_sum = S[0]\n for j in range(num_cnt):\n if ((i >> j) & 1):\n temp_sum = temp_sum + '+' + str(S[j+1])\n else:\n temp_sum = temp_sum + S[j+1]\n total += eval(temp_sum)",
"i",
"range(2 ** num_cnt)",
"range",
"2 ** num_cnt",
"2",
"num_cnt",
"temp_sum = S[0]",
"temp_sum",
"S[0]",
"S",
"0",
"for j in range(num_cnt):\n if ((i >> j) & 1):\n temp_sum = temp_sum + '+' + str(S[j+1])\n else:\n temp_sum = temp_sum + S[j+1]\n ",
"j",
"range(num_cnt)",
"range",
"num_cnt",
"if ((i >> j) & 1):\n temp_sum = temp_sum + '+' + str(S[j+1])\n else:\n temp_sum = temp_sum + S[j+1]\n ",
"(i >> j) & 1",
"i >> j",
"i",
"j",
"1",
"temp_sum = temp_sum + '+' + str(S[j+1])",
"temp_sum",
"temp_sum + '+' + str(S[j+1])",
"temp_sum + '+'",
"temp_sum",
"'+'",
"str(S[j+1])",
"str",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"temp_sum = temp_sum + S[j+1]",
"temp_sum",
"temp_sum + S[j+1]",
"temp_sum",
"S[j+1]",
"S",
"j+1",
"j",
"1",
"total += eval(temp_sum)",
"total",
"eval(temp_sum)",
"eval",
"temp_sum",
"print(total)",
"print",
"total",
"S = list(input())",
"list(input())",
"S",
"temp_sum = temp_sum + S[j+1]",
"temp_sum + S[j+1]",
"temp_sum",
"temp_sum = S[0]",
"S[0]",
"temp_sum",
"total += eval(temp_sum)",
"eval(temp_sum)",
"total",
"total = 0",
"0",
"total",
"temp_sum = temp_sum + '+' + str(S[j+1])",
"temp_sum + '+' + str(S[j+1])",
"temp_sum",
"num_cnt = len(S) - 1",
"len(S) - 1",
"num_cnt"
] | S = list(input())
num_cnt = len(S) - 1
total = 0
for i in range(2 ** num_cnt):
temp_sum = S[0]
for j in range(num_cnt):
if ((i >> j) & 1):
temp_sum = temp_sum + '+' + str(S[j+1])
else:
temp_sum = temp_sum + S[j+1]
total += eval(temp_sum)
print(total) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.