node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
2,
4,
13,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
2,
39,
17,
2,
2,
17,
2,
17,
13,
17,
0,
13,
13,
0,
18,
18,
13,
17,
2,
17,
13,
17,
28,
13,
4,
13,
17,
13,
28,
13,
4,
13,
17,
2,
2,
2,
17,
17,
13,
17,
14,
40,
18,
18,
13,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
13,
13,
13,
4,
13,
2,
18,
18,
13,
13,
2,
17,
13,
17,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
12
],
[
140,
14
],
[
140,
16
],
[
20,
19
],
[
19,
29
],
[
138,
30
],
[
134,
32
],
[
37,
36
],
[
141,
41
],
[
141,
52
],
[
143,
55
],
[
65,
58
],
[
144,
60
],
[
141,
64
],
[
68,
67
],
[
141,
71
],
[
74,
73
],
[
141,
82
],
[
144,
88
],
[
67,
89
],
[
73,
90
],
[
100,
93
],
[
144,
95
],
[
67,
97
],
[
73,
99
],
[
144,
102
],
[
67,
103
],
[
73,
104
],
[
117,
106
],
[
144,
108
],
[
67,
110
],
[
73,
113
],
[
135,
115
],
[
67,
116
],
[
144,
119
],
[
67,
120
],
[
73,
121
],
[
144,
127
],
[
141,
128
],
[
141,
131
],
[
134,
135
],
[
140,
138
],
[
140,
141
],
[
143,
144
]
] | [
"N,A = (int(T) for T in input().split())\nX = [int(T)-A for T in input().split()]\nDP = [[0]*(2*(50*N)+1) for TI in range(0,N+1)]\nDP[0][50*N] = 1\nfor TI in range(0,N):\n for TS in range(0,2*50*N+1):\n if DP[TI][TS]!=0:\n DP[TI+1][TS] += DP[TI][TS]\n DP[TI+1][TS+X[TI]] += DP[TI][TS]\nprint(DP[N][50*N]-1)",
"int(T) for T in input().split()",
"for T in input().split()",
"T",
"input().split()",
"().split",
"()",
"input",
"split",
"for T in input().split()",
"int(T)",
"int",
"T",
"N,A = (int(T) for T in input().split())",
"N",
"(int(T) for T in input().split())",
"A",
"int(T)-A for T in input().split()",
"for T in input().split()",
"T",
"input().split()",
"().split",
"()",
"input",
"split",
"for T in input().split()",
"int(T)-A",
"int(T)",
"int",
"T",
"A",
"X = [int(T)-A for T in input().split()]",
"X",
"[int(T)-A for T in input().split()]",
"[0]*(2*(50*N)+1) for TI in range(0,N+1)",
"for TI in range(0,N+1)",
"TI",
"range(0,N+1)",
"range",
"0",
"N+1",
"N",
"1",
"for TI in range(0,N+1)",
"[0]*(2*(50*N)+1)",
"[0]",
"0",
"2*(50*N)+1",
"2*(50*N)",
"2",
"50*N",
"50",
"N",
"1",
"DP = [[0]*(2*(50*N)+1) for TI in range(0,N+1)]",
"DP",
"[[0]*(2*(50*N)+1) for TI in range(0,N+1)]",
"DP[0][50*N] = 1",
"DP[0][50*N]",
"[0]",
"DP",
"0",
"50*N",
"50",
"N",
"1",
"for TI in range(0,N):\n for TS in range(0,2*50*N+1):\n if DP[TI][TS]!=0:\n DP[TI+1][TS] += DP[TI][TS]\n DP[TI+1][TS+X[TI]] += DP[TI][TS]",
"TI",
"range(0,N)",
"range",
"0",
"N",
"for TS in range(0,2*50*N+1):\n if DP[TI][TS]!=0:\n DP[TI+1][TS] += DP[TI][TS]\n DP[TI+1][TS+X[TI]] += DP[TI][TS]",
"TS",
"range(0,2*50*N+1)",
"range",
"0",
"2*50*N+1",
"2*50*N",
"2*50",
"2",
"50",
"N",
"1",
"if DP[TI][TS]!=0:\n DP[TI+1][TS] += DP[TI][TS]\n DP[TI+1][TS+X[TI]] += DP[TI][TS]",
"DP[TI][TS]!=0",
"DP[TI][TS]",
"[TI]",
"DP",
"TI",
"TS",
"0",
"DP[TI+1][TS] += DP[TI][TS]",
"DP[TI+1][TS]",
"[TI+1]",
"DP",
"TI+1",
"TI",
"1",
"TS",
"DP[TI][TS]",
"[TI]",
"DP",
"TI",
"TS",
"DP[TI+1][TS+X[TI]] += DP[TI][TS]",
"DP[TI+1][TS+X[TI]]",
"[TI+1]",
"DP",
"TI+1",
"TI",
"1",
"TS+X[TI]",
"TS",
"X[TI]",
"X",
"TI",
"DP[TI][TS]",
"[TI]",
"DP",
"TI",
"TS",
"print(DP[N][50*N]-1)",
"print",
"DP[N][50*N]-1",
"DP[N][50*N]",
"[N]",
"DP",
"N",
"50*N",
"50",
"N",
"1",
"X = [int(T)-A for T in input().split()]",
"[int(T)-A for T in input().split()]",
"X",
"A = (int(T) for T in input().split())",
"(int(T) for T in input().split())",
"A",
"N,A = (int(T) for T in input().split())",
"(int(T) for T in input().split())",
"N",
"DP = [[0]*(2*(50*N)+1) for TI in range(0,N+1)]",
"[[0]*(2*(50*N)+1) for TI in range(0,N+1)]",
"DP"
] | N,A = (int(T) for T in input().split())
X = [int(T)-A for T in input().split()]
DP = [[0]*(2*(50*N)+1) for TI in range(0,N+1)]
DP[0][50*N] = 1
for TI in range(0,N):
for TS in range(0,2*50*N+1):
if DP[TI][TS]!=0:
DP[TI+1][TS] += DP[TI][TS]
DP[TI+1][TS+X[TI]] += DP[TI][TS]
print(DP[N][50*N]-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
18,
13,
13,
0,
13,
17,
42,
2,
2,
13,
13,
2,
18,
13,
13,
13,
0,
13,
17,
0,
13,
13,
42,
2,
2,
13,
13,
2,
18,
13,
13,
13,
0,
13,
17,
0,
13,
2,
13,
13,
41,
28,
13,
18,
13,
39,
13,
4,
2,
13,
13,
0,
13,
39,
13,
13,
0,
13,
4,
13,
4,
13,
18,
13,
17,
4,
13,
18,
13,
17,
41,
28,
13,
4,
13,
17,
4,
2,
39,
17,
2,
13,
17,
0,
13,
13,
28,
13,
4,
13,
17,
0,
18,
18,
13,
13,
17,
17,
28,
13,
4,
13,
4,
13,
18,
13,
13,
28,
13,
4,
13,
2,
4,
13,
18,
13,
13,
17,
17,
17,
14,
40,
2,
13,
18,
18,
13,
13,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
18,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
18,
18,
13,
17,
13,
18,
18,
13,
17,
13,
0,
13,
2,
17,
13,
4,
13,
2,
13,
2,
2,
17,
13,
17,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
241,
2
],
[
241,
11
],
[
223,
13
],
[
224,
26
],
[
226,
29
],
[
227,
34
],
[
233,
34
],
[
230,
35
],
[
224,
38
],
[
227,
39
],
[
233,
39
],
[
242,
40
],
[
232,
42
],
[
217,
45
],
[
233,
46
],
[
227,
46
],
[
218,
50
],
[
248,
50
],
[
230,
51
],
[
224,
54
],
[
218,
55
],
[
248,
55
],
[
242,
56
],
[
247,
58
],
[
220,
61
],
[
248,
63
],
[
218,
63
],
[
233,
64
],
[
227,
64
],
[
68,
67
],
[
224,
69
],
[
242,
74
],
[
67,
75
],
[
238,
77
],
[
250,
82
],
[
239,
88
],
[
239,
93
],
[
98,
97
],
[
251,
106
],
[
235,
109
],
[
113,
112
],
[
122,
117
],
[
236,
119
],
[
112,
120
],
[
125,
124
],
[
239,
130
],
[
112,
131
],
[
134,
133
],
[
236,
140
],
[
112,
141
],
[
133,
148
],
[
239,
151
],
[
112,
152
],
[
124,
153
],
[
161,
156
],
[
236,
158
],
[
112,
159
],
[
133,
160
],
[
236,
163
],
[
112,
164
],
[
133,
166
],
[
239,
169
],
[
112,
170
],
[
124,
171
],
[
211,
173
],
[
177,
176
],
[
251,
181
],
[
244,
184
],
[
236,
188
],
[
176,
190
],
[
236,
193
],
[
176,
195
],
[
214,
197
],
[
221,
200
],
[
215,
204
],
[
245,
204
],
[
212,
204
],
[
221,
208
],
[
211,
212
],
[
214,
215
],
[
233,
217
],
[
227,
217
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
226,
227
],
[
241,
230
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
250,
251
]
] | [
"n, a = map(int,input().split())\nX = list(map(int,input().split()))\n\nX.sort()\nii = 0\nwhile ii < n and X[ii] < a:\n ii += 1\njj = ii\nwhile jj < n and X[jj] == a:\n jj += 1\n\naa = jj-ii\nA = [[a-i for i in X[:ii]], [j-a for j in X[jj:]]]\n\n# print(A)\n\nmm = min(sum(A[0]), sum(A[1]))\n\nAA = [[0] * (mm + 1) for i in range(2)]\nfor k in range(2):\n AA[k][0] = 1\n for i in range(len(A[k])):\n for j in range(len(AA[k])-1, -1, -1):\n if j - A[k][i] >= 0:\n AA[k][j] += AA[k][j-A[k][i]]\n # print(AA)\n # print(k, j, A[k][i])\n\n\n# print(AA,aa)\nans = 0\nfor i in range(1, mm + 1):\n ans += AA[0][i] * AA[1][i]\n# print(ans)\nans *= 2 ** aa\n\nprint(ans + (2 ** aa - 1))\n ",
"n, a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"X = list(map(int,input().split()))",
"X",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"X.sort()",
"X.sort",
"X",
"sort",
"ii = 0",
"ii",
"0",
"while ii < n and X[ii] < a:\n ii += 1",
"ii < n and X[ii] < a",
"ii < n",
"ii",
"n",
"X[ii] < a",
"X[ii]",
"X",
"ii",
"a",
"ii += 1",
"ii",
"1",
"jj = ii",
"jj",
"ii",
"while jj < n and X[jj] == a:\n jj += 1",
"jj < n and X[jj] == a",
"jj < n",
"jj",
"n",
"X[jj] == a",
"X[jj]",
"X",
"jj",
"a",
"jj += 1",
"jj",
"1",
"aa = jj-ii",
"aa",
"jj-ii",
"jj",
"ii",
"a-i for i in X[:ii]",
"for i in X[:ii]",
"i",
"X[:ii]",
"X",
":ii",
"ii",
"for i in X[:ii]",
"a-i",
"a",
"i",
"A = [[a-i for i in X[:ii]], [j-a for j in X[jj:]]]",
"A",
"[[a-i for i in X[:ii]], [j-a for j in X[jj:]]]",
"[a-i for i in X[:ii]]",
"[j-a for j in X[jj:]]",
"mm = min(sum(A[0]), sum(A[1]))",
"mm",
"min(sum(A[0]), sum(A[1]))",
"min",
"sum(A[0])",
"sum",
"A[0]",
"A",
"0",
"sum(A[1])",
"sum",
"A[1]",
"A",
"1",
"[0] * (mm + 1) for i in range(2)",
"for i in range(2)",
"i",
"range(2)",
"range",
"2",
"for i in range(2)",
"[0] * (mm + 1)",
"[0]",
"0",
"mm + 1",
"mm",
"1",
"AA = [[0] * (mm + 1) for i in range(2)]",
"AA",
"[[0] * (mm + 1) for i in range(2)]",
"for k in range(2):\n AA[k][0] = 1\n for i in range(len(A[k])):\n for j in range(len(AA[k])-1, -1, -1):\n if j - A[k][i] >= 0:\n AA[k][j] += AA[k][j-A[k][i]]\n # print(AA)\n # print(k, j, A[k][i])\n\n\n# print(AA,aa)",
"k",
"range(2)",
"range",
"2",
"AA[k][0] = 1",
"AA[k][0]",
"[k]",
"AA",
"k",
"0",
"1",
"for i in range(len(A[k])):\n for j in range(len(AA[k])-1, -1, -1):\n if j - A[k][i] >= 0:\n AA[k][j] += AA[k][j-A[k][i]]\n # print(AA)\n # print(k, j, A[k][i])\n\n\n# print(AA,aa)",
"i",
"range(len(A[k]))",
"range",
"len(A[k])",
"len",
"A[k]",
"A",
"k",
"for j in range(len(AA[k])-1, -1, -1):\n if j - A[k][i] >= 0:\n AA[k][j] += AA[k][j-A[k][i]]\n # print(AA)\n # print(k, j, A[k][i])\n\n\n# print(AA,aa)",
"j",
"range(len(AA[k])-1, -1, -1)",
"range",
"len(AA[k])-1",
"len(AA[k])",
"len",
"AA[k]",
"AA",
"k",
"1",
"-1",
"-1",
"if j - A[k][i] >= 0:\n AA[k][j] += AA[k][j-A[k][i]]\n # print(AA)\n # print(k, j, A[k][i])\n\n\n# print(AA,aa)",
"j - A[k][i] >= 0",
"j - A[k][i]",
"j",
"A[k][i]",
"[k]",
"A",
"k",
"i",
"0",
"AA[k][j] += AA[k][j-A[k][i]]",
"AA[k][j]",
"[k]",
"AA",
"k",
"j",
"AA[k][j-A[k][i]]",
"[k]",
"AA",
"k",
"j-A[k][i]",
"j",
"A[k][i]",
"[k]",
"A",
"k",
"i",
"ans = 0",
"ans",
"0",
"for i in range(1, mm + 1):\n ans += AA[0][i] * AA[1][i]\n# print(ans)",
"i",
"range(1, mm + 1)",
"range",
"1",
"mm + 1",
"mm",
"1",
"ans += AA[0][i] * AA[1][i]",
"ans",
"AA[0][i] * AA[1][i]",
"AA[0][i]",
"[0]",
"AA",
"0",
"i",
"AA[1][i]",
"[1]",
"AA",
"1",
"i",
"ans *= 2 ** aa",
"ans",
"2 ** aa",
"2",
"aa",
"print(ans + (2 ** aa - 1))",
"print",
"ans + (2 ** aa - 1)",
"ans",
"2 ** aa - 1",
"2 ** aa",
"2",
"aa",
"1",
"ans = 0",
"0",
"ans",
"ans *= 2 ** aa",
"2 ** aa",
"ans",
"jj = ii",
"ii",
"jj",
"aa = jj-ii",
"jj-ii",
"aa",
"X = list(map(int,input().split()))",
"list(map(int,input().split()))",
"X",
"ii = 0",
"0",
"ii",
"n, a = map(int,input().split())",
"map(int,input().split())",
"n",
"ii += 1",
"1",
"ii",
"AA = [[0] * (mm + 1) for i in range(2)]",
"[[0] * (mm + 1) for i in range(2)]",
"AA",
"A = [[a-i for i in X[:ii]], [j-a for j in X[jj:]]]",
"[[a-i for i in X[:ii]], [j-a for j in X[jj:]]]",
"A",
"a = map(int,input().split())",
"map(int,input().split())",
"a",
"ans += AA[0][i] * AA[1][i]",
"AA[0][i] * AA[1][i]",
"ans",
"jj += 1",
"1",
"jj",
"mm = min(sum(A[0]), sum(A[1]))",
"min(sum(A[0]), sum(A[1]))",
"mm"
] | n, a = map(int,input().split())
X = list(map(int,input().split()))
X.sort()
ii = 0
while ii < n and X[ii] < a:
ii += 1
jj = ii
while jj < n and X[jj] == a:
jj += 1
aa = jj-ii
A = [[a-i for i in X[:ii]], [j-a for j in X[jj:]]]
# print(A)
mm = min(sum(A[0]), sum(A[1]))
AA = [[0] * (mm + 1) for i in range(2)]
for k in range(2):
AA[k][0] = 1
for i in range(len(A[k])):
for j in range(len(AA[k])-1, -1, -1):
if j - A[k][i] >= 0:
AA[k][j] += AA[k][j-A[k][i]]
# print(AA)
# print(k, j, A[k][i])
# print(AA,aa)
ans = 0
for i in range(1, mm + 1):
ans += AA[0][i] * AA[1][i]
# print(ans)
ans *= 2 ** aa
print(ans + (2 ** aa - 1))
|
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
2,
13,
39,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
12,
13,
14,
2,
18,
18,
18,
13,
13,
13,
13,
17,
14,
2,
2,
2,
13,
13,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
17,
14,
2,
40,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
4,
13,
2,
13,
17,
13,
13,
14,
2,
2,
40,
13,
17,
40,
13,
17,
40,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
4,
13,
2,
13,
17,
13,
13,
4,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
17,
29,
18,
18,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
4,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
4,
3
],
[
3,
12
],
[
215,
14
],
[
215,
16
],
[
20,
19
],
[
19,
28
],
[
203,
30
],
[
218,
33
],
[
204,
37
],
[
43,
42
],
[
216,
46
],
[
212,
51
],
[
213,
60
],
[
174,
61
],
[
176,
62
],
[
178,
63
],
[
178,
69
],
[
174,
70
],
[
176,
71
],
[
81,
74
],
[
213,
77
],
[
174,
78
],
[
176,
79
],
[
178,
80
],
[
174,
85
],
[
178,
88
],
[
204,
90
],
[
174,
92
],
[
102,
95
],
[
213,
98
],
[
174,
99
],
[
176,
100
],
[
178,
101
],
[
174,
105
],
[
176,
107
],
[
178,
108
],
[
174,
113
],
[
176,
116
],
[
178,
119
],
[
204,
121
],
[
174,
123
],
[
133,
126
],
[
213,
129
],
[
174,
130
],
[
176,
131
],
[
178,
132
],
[
174,
137
],
[
176,
139
],
[
178,
140
],
[
174,
144
],
[
176,
147
],
[
178,
150
],
[
204,
152
],
[
174,
154
],
[
164,
157
],
[
213,
160
],
[
174,
161
],
[
176,
162
],
[
178,
163
],
[
157,
166
],
[
126,
166
],
[
95,
166
],
[
74,
166
],
[
213,
169
],
[
174,
170
],
[
176,
171
],
[
178,
172
],
[
174,
174
],
[
176,
176
],
[
178,
178
],
[
206,
180
],
[
184,
183
],
[
216,
188
],
[
224,
191
],
[
222,
193
],
[
216,
194
],
[
183,
195
],
[
183,
197
],
[
210,
198
],
[
225,
201
],
[
207,
201
],
[
203,
204
],
[
206,
207
],
[
215,
210
],
[
212,
213
],
[
215,
216
],
[
218,
219
],
[
224,
225
]
] | [
"N,A = [int(x) for x in input().split()]\nx = [int(x) for x in input().split()]\nX = max(x+[A])\n#%%\ndp = [[[-1]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]\n\ndef rep(j,k,s):\n if(dp[j][k][s]==-1):\n if(s==j==k==0):\n dp[j][k][s] = 1\n elif(j>=1 and s<x[j-1]):\n dp[j][k][s] = rep(j-1,k,s)\n elif(j>=1 and k>=1 and s>=x[j-1]):\n dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])\n else:\n dp[j][k][s] = 0\n return dp[j][k][s]\n\nans = 0\nfor k in range(1,N+1):\n ans += rep(N,k,k*A)\nprint(ans)",
"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",
"N,A = [int(x) for x in input().split()]",
"N",
"[int(x) for x in input().split()]",
"A",
"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",
"x = [int(x) for x in input().split()]",
"x",
"[int(x) for x in input().split()]",
"X = max(x+[A])",
"X",
"max(x+[A])",
"max",
"x+[A]",
"x",
"[A]",
"A",
"[[-1]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[[-1]*(N*X+1) for _ in range(N+1)]",
"dp = [[[-1]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[-1]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]",
"def rep(j,k,s):\n if(dp[j][k][s]==-1):\n if(s==j==k==0):\n dp[j][k][s] = 1\n elif(j>=1 and s<x[j-1]):\n dp[j][k][s] = rep(j-1,k,s)\n elif(j>=1 and k>=1 and s>=x[j-1]):\n dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])\n else:\n dp[j][k][s] = 0\n return dp[j][k][s]",
"rep",
"if(dp[j][k][s]==-1):\n if(s==j==k==0):\n dp[j][k][s] = 1\n elif(j>=1 and s<x[j-1]):\n dp[j][k][s] = rep(j-1,k,s)\n elif(j>=1 and k>=1 and s>=x[j-1]):\n dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])\n else:\n dp[j][k][s] = 0\n ",
"dp[j][k][s]==-1",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"-1",
"if(s==j==k==0):\n dp[j][k][s] = 1\n elif(j>=1 and s<x[j-1]):\n dp[j][k][s] = rep(j-1,k,s)\n elif(j>=1 and k>=1 and s>=x[j-1]):\n dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])\n else:\n dp[j][k][s] = 0\n ",
"s==j==k==0",
"s==j==k",
"s==j",
"s",
"j",
"k",
"0",
"dp[j][k][s] = 1",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"1",
"elif(j>=1 and s<x[j-1]):\n dp[j][k][s] = rep(j-1,k,s)\n ",
"j>=1 and s<x[j-1]",
"j>=1",
"j",
"1",
"s<x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = rep(j-1,k,s)",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"rep(j-1,k,s)",
"rep",
"j-1",
"j",
"1",
"k",
"s",
"elif(j>=1 and k>=1 and s>=x[j-1]):\n dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])\n ",
"j>=1 and k>=1 and s>=x[j-1]",
"j>=1 and k>=1",
"j>=1",
"j",
"1",
"k>=1",
"k",
"1",
"s>=x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])",
"rep(j-1,k,s)",
"rep",
"j-1",
"j",
"1",
"k",
"s",
"rep(j-1,k-1,s-x[j-1])",
"rep",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"s-x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = 0",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"0",
"return dp[j][k][s]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"j",
"j",
"k",
"k",
"s",
"s",
"ans = 0",
"ans",
"0",
"for k in range(1,N+1):\n ans += rep(N,k,k*A)",
"k",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += rep(N,k,k*A)",
"ans",
"rep(N,k,k*A)",
"rep",
"N",
"k",
"k*A",
"k",
"A",
"print(ans)",
"print",
"ans",
"x = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"x",
"ans = 0",
"0",
"ans",
"A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"A",
"dp = [[[-1]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]",
"[[[-1]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"N,A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"N",
"X = max(x+[A])",
"max(x+[A])",
"X",
"def rep(j,k,s):\n if(dp[j][k][s]==-1):\n if(s==j==k==0):\n dp[j][k][s] = 1\n elif(j>=1 and s<x[j-1]):\n dp[j][k][s] = rep(j-1,k,s)\n elif(j>=1 and k>=1 and s>=x[j-1]):\n dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])\n else:\n dp[j][k][s] = 0\n return dp[j][k][s]",
"def rep(j,k,s):\n if(dp[j][k][s]==-1):\n if(s==j==k==0):\n dp[j][k][s] = 1\n elif(j>=1 and s<x[j-1]):\n dp[j][k][s] = rep(j-1,k,s)\n elif(j>=1 and k>=1 and s>=x[j-1]):\n dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])\n else:\n dp[j][k][s] = 0\n return dp[j][k][s]",
"rep",
"ans += rep(N,k,k*A)",
"rep(N,k,k*A)",
"ans"
] | N,A = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
X = max(x+[A])
#%%
dp = [[[-1]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]
def rep(j,k,s):
if(dp[j][k][s]==-1):
if(s==j==k==0):
dp[j][k][s] = 1
elif(j>=1 and s<x[j-1]):
dp[j][k][s] = rep(j-1,k,s)
elif(j>=1 and k>=1 and s>=x[j-1]):
dp[j][k][s] = rep(j-1,k,s) + rep(j-1,k-1,s-x[j-1])
else:
dp[j][k][s] = 0
return dp[j][k][s]
ans = 0
for k in range(1,N+1):
ans += rep(N,k,k*A)
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
18,
18,
18,
13,
17,
13,
2,
13,
13,
4,
13,
2,
13,
17,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
154,
2
],
[
154,
11
],
[
142,
13
],
[
136,
25
],
[
143,
28
],
[
32,
31
],
[
137,
35
],
[
139,
40
],
[
50,
43
],
[
140,
46
],
[
53,
52
],
[
137,
55
],
[
145,
57
],
[
143,
59
],
[
52,
60
],
[
63,
62
],
[
137,
65
],
[
68,
67
],
[
81,
72
],
[
140,
75
],
[
52,
77
],
[
62,
79
],
[
67,
80
],
[
140,
84
],
[
52,
85
],
[
62,
86
],
[
67,
87
],
[
102,
89
],
[
140,
92
],
[
52,
94
],
[
62,
97
],
[
67,
100
],
[
146,
101
],
[
140,
105
],
[
52,
106
],
[
62,
107
],
[
67,
108
],
[
157,
110
],
[
114,
113
],
[
137,
117
],
[
148,
120
],
[
140,
124
],
[
113,
126
],
[
113,
128
],
[
152,
129
],
[
149,
133
],
[
158,
133
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
154,
152
],
[
154,
155
],
[
157,
158
]
] | [
"n,a=map(int,input().split())\nlst=list(map(int,input().split()))\n\nz=len(lst)\ndp=[[[0]*2501 for i in range(51)] for j in range(z+1)]\ndp[0][0][0]=1\n\nfor i in range(z):\n x=lst[i]\n for j in range(z):\n for k in range(2451):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x]+=dp[i][j][k]\n\nans=0\n\nfor i in range(z+1):\n ans+=dp[-1][i][i*a]\n\nprint(ans-1)",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"lst=list(map(int,input().split()))",
"lst",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"z=len(lst)",
"z",
"len(lst)",
"len",
"lst",
"[[0]*2501 for i in range(51)] for j in range(z+1)",
"for j in range(z+1)",
"j",
"range(z+1)",
"range",
"z+1",
"z",
"1",
"for j in range(z+1)",
"[[0]*2501 for i in range(51)]",
"dp=[[[0]*2501 for i in range(51)] for j in range(z+1)]",
"dp",
"[[[0]*2501 for i in range(51)] for j in range(z+1)]",
"dp[0][0][0]=1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(z):\n x=lst[i]\n for j in range(z):\n for k in range(2451):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x]+=dp[i][j][k]",
"i",
"range(z)",
"range",
"z",
"x=lst[i]",
"x",
"lst[i]",
"lst",
"i",
"for j in range(z):\n for k in range(2451):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x]+=dp[i][j][k]",
"j",
"range(z)",
"range",
"z",
"for k in range(2451):\n dp[i+1][j][k]+=dp[i][j][k]\n dp[i+1][j+1][k+x]+=dp[i][j][k]",
"k",
"range(2451)",
"range",
"2451",
"dp[i+1][j][k]+=dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i+1][j+1][k+x]+=dp[i][j][k]",
"dp[i+1][j+1][k+x]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k+x",
"k",
"x",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"ans=0",
"ans",
"0",
"for i in range(z+1):\n ans+=dp[-1][i][i*a]",
"i",
"range(z+1)",
"range",
"z+1",
"z",
"1",
"ans+=dp[-1][i][i*a]",
"ans",
"dp[-1][i][i*a]",
"[i]",
"[-1]",
"dp",
"-1",
"i",
"i*a",
"i",
"a",
"print(ans-1)",
"print",
"ans-1",
"ans",
"1",
"z=len(lst)",
"len(lst)",
"z",
"dp=[[[0]*2501 for i in range(51)] for j in range(z+1)]",
"[[[0]*2501 for i in range(51)] for j in range(z+1)]",
"dp",
"lst=list(map(int,input().split()))",
"list(map(int,input().split()))",
"lst",
"x=lst[i]",
"lst[i]",
"x",
"ans+=dp[-1][i][i*a]",
"dp[-1][i][i*a]",
"ans",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"ans=0",
"0",
"ans"
] | n,a=map(int,input().split())
lst=list(map(int,input().split()))
z=len(lst)
dp=[[[0]*2501 for i in range(51)] for j in range(z+1)]
dp[0][0][0]=1
for i in range(z):
x=lst[i]
for j in range(z):
for k in range(2451):
dp[i+1][j][k]+=dp[i][j][k]
dp[i+1][j+1][k+x]+=dp[i][j][k]
ans=0
for i in range(z+1):
ans+=dp[-1][i][i*a]
print(ans-1) |
[
7,
15,
13,
12,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
13,
0,
18,
18,
18,
13,
13,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
17,
14,
40,
2,
13,
18,
13,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
13,
2,
18,
18,
18,
13,
13,
13,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
2,
13,
17,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
13,
18,
18,
18,
13,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
29,
23,
13,
23,
13,
23,
13,
12,
13,
12,
13,
28,
13,
18,
13,
13,
28,
13,
4,
18,
13,
13,
27,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
8,
7
],
[
136,
11
],
[
17,
16
],
[
20,
19
],
[
136,
22
],
[
31,
24
],
[
16,
27
],
[
19,
28
],
[
34,
33
],
[
136,
36
],
[
39,
38
],
[
136,
41
],
[
44,
43
],
[
43,
50
],
[
140,
52
],
[
33,
53
],
[
67,
56
],
[
16,
59
],
[
33,
61
],
[
38,
64
],
[
43,
66
],
[
16,
71
],
[
33,
72
],
[
38,
73
],
[
43,
75
],
[
140,
77
],
[
33,
78
],
[
16,
82
],
[
33,
83
],
[
38,
85
],
[
43,
87
],
[
100,
89
],
[
16,
92
],
[
33,
94
],
[
38,
97
],
[
43,
99
],
[
16,
103
],
[
33,
104
],
[
38,
106
],
[
43,
108
],
[
111,
110
],
[
114,
113
],
[
136,
118
],
[
122,
121
],
[
16,
125
],
[
136,
126
],
[
113,
127
],
[
138,
129
],
[
113,
130
],
[
121,
133
],
[
110,
133
],
[
136,
136
],
[
138,
138
],
[
140,
140
],
[
147,
146
],
[
152,
151
],
[
146,
154
],
[
151,
157
],
[
160,
159
],
[
144,
161
],
[
164,
163
],
[
159,
168
],
[
171,
170
],
[
159,
175
],
[
179,
178
],
[
163,
181
],
[
159,
187
],
[
190,
189
],
[
207,
192
],
[
163,
193
],
[
170,
194
],
[
189,
195
],
[
204,
201
]
] | [
"#!/usr/bin/env python3\nimport sys\n\ndef solve(N: int, A: int, x: \"List[int]\"):\n ## dp[i][j][k] = i番目までのカードからjマイ選んで合計kにする選び方の総数\n dp = [[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n\n for i in range(N):\n dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(N):\n for k in range(2501):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n answer = 0\n for j in range(1,N+1):\n answer += dp[N][j][A*j]\n print(answer)\n return\n\ndef main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"def solve(N: int, A: int, x: \"List[int]\"):\n ## dp[i][j][k] = i番目までのカードからjマイ選んで合計kにする選び方の総数\n dp = [[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n\n for i in range(N):\n dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(N):\n for k in range(2501):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n answer = 0\n for j in range(1,N+1):\n answer += dp[N][j][A*j]\n print(answer)\n return",
"solve",
"[[0]*2501 for _ in range(N+1)] for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[[0]*2501 for _ in range(N+1)]",
"dp = [[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]",
"for i in range(N):\n dp[i][0][0] = 1\n\n ",
"i",
"range(N)",
"range",
"N",
"dp[i][0][0] = 1",
"dp[i][0][0]",
"[0]",
"[i]",
"dp",
"i",
"0",
"0",
"1",
"for i in range(N):\n for j in range(N):\n for k in range(2501):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n ",
"i",
"range(N)",
"range",
"N",
"for j in range(N):\n for k in range(2501):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n ",
"j",
"range(N)",
"range",
"N",
"for k in range(2501):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n ",
"k",
"range(2501)",
"range",
"2501",
"if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n ",
"k-x[i] >= 0",
"k-x[i]",
"k",
"x[i]",
"x",
"i",
"0",
"dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]",
"dp[i+1][j+1][k]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k",
"dp[i][j][k-x[i]]+dp[i][j+1][k]",
"dp[i][j][k-x[i]]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k-x[i]",
"k",
"x[i]",
"x",
"i",
"dp[i][j+1][k]",
"[j+1]",
"[i]",
"dp",
"i",
"j+1",
"j",
"1",
"k",
"dp[i+1][j+1][k] = dp[i][j+1][k]",
"dp[i+1][j+1][k]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k",
"dp[i][j+1][k]",
"[j+1]",
"[i]",
"dp",
"i",
"j+1",
"j",
"1",
"k",
"answer = 0",
"answer",
"0",
"for j in range(1,N+1):\n answer += dp[N][j][A*j]\n ",
"j",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"answer += dp[N][j][A*j]",
"answer",
"dp[N][j][A*j]",
"[j]",
"[N]",
"dp",
"N",
"j",
"A*j",
"A",
"j",
"print(answer)",
"print",
"answer",
"return",
"N: int",
"N",
"A: int",
"A",
"x: \"List[int]\"",
"x",
"def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"main",
"def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"iterate_tokens",
"for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"line",
"sys.stdin",
"sys",
"stdin",
"for word in line.split():\n yield word\n ",
"word",
"line.split()",
"line.split",
"line",
"split",
"yield word",
"word",
"tokens = iterate_tokens()",
"tokens",
"iterate_tokens()",
"iterate_tokens",
"N = int(next(tokens))",
"N",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"A = int(next(tokens))",
"A",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"int(next(tokens)) for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"x = [int(next(tokens)) for _ in range(N)]",
"x",
"[int(next(tokens)) for _ in range(N)]",
"solve(N, A, x)",
"solve",
"N",
"A",
"x",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"main",
"def solve(N: int, A: int, x: \"List[int]\"):\n ## dp[i][j][k] = i番目までのカードからjマイ選んで合計kにする選び方の総数\n dp = [[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n\n for i in range(N):\n dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(N):\n for k in range(2501):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n answer = 0\n for j in range(1,N+1):\n answer += dp[N][j][A*j]\n print(answer)\n return",
"def solve(N: int, A: int, x: \"List[int]\"):\n ## dp[i][j][k] = i番目までのカードからjマイ選んで合計kにする選び方の総数\n dp = [[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]\n\n for i in range(N):\n dp[i][0][0] = 1\n\n for i in range(N):\n for j in range(N):\n for k in range(2501):\n if k-x[i] >= 0:\n dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\n answer = 0\n for j in range(1,N+1):\n answer += dp[N][j][A*j]\n print(answer)\n return",
"solve"
] | #!/usr/bin/env python3
import sys
def solve(N: int, A: int, x: "List[int]"):
## dp[i][j][k] = i番目までのカードからjマイ選んで合計kにする選び方の総数
dp = [[[0]*2501 for _ in range(N+1)] for _ in range(N+1)]
for i in range(N):
dp[i][0][0] = 1
for i in range(N):
for j in range(N):
for k in range(2501):
if k-x[i] >= 0:
dp[i+1][j+1][k] = dp[i][j][k-x[i]]+dp[i][j+1][k]
else:
dp[i+1][j+1][k] = dp[i][j+1][k]
answer = 0
for j in range(1,N+1):
answer += dp[N][j][A*j]
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
x = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A, x)
if __name__ == '__main__':
main()
|
[
7,
15,
13,
15,
12,
13,
41,
28,
13,
4,
13,
13,
4,
2,
39,
13,
13,
12,
13,
23,
13,
23,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
23,
13,
23,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
17,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
17,
12,
13,
12,
13,
12,
13,
12,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
4,
2,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
4,
13,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
4,
13,
13,
28,
13,
13,
4,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
13,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
13,
4,
13,
2,
18,
18,
13,
13,
17,
17,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
13,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
4,
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,
13,
13
] | [
[
9,
8
],
[
20,
20
],
[
22,
22
],
[
24,
24
],
[
28,
27
],
[
36,
36
],
[
38,
38
],
[
40,
40
],
[
42,
42
],
[
46,
45
],
[
54,
54
],
[
56,
56
],
[
58,
58
],
[
60,
60
],
[
62,
62
],
[
66,
66
],
[
69,
68
],
[
77,
76
],
[
236,
82
],
[
87,
86
],
[
205,
104
],
[
220,
109
],
[
238,
116
],
[
245,
118
],
[
238,
119
],
[
123,
122
],
[
227,
124
],
[
122,
127
],
[
239,
128
],
[
208,
130
],
[
135,
134
],
[
224,
138
],
[
250,
145
],
[
153,
148
],
[
251,
150
],
[
209,
159
],
[
251,
166
],
[
177,
170
],
[
251,
172
],
[
188,
179
],
[
251,
181
],
[
251,
194
],
[
224,
195
],
[
205,
206
],
[
208,
209
],
[
220,
221
],
[
238,
224
],
[
238,
239
],
[
250,
251
]
] | [
"# -*- coding: utf-8 -*-\n\nimport sys\nfrom collections import defaultdict\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 9)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN, K = MAP()\n# 総和0を平均KとするためKを引く\nA = [a-K for a in LIST()]\n\n# dp[i][j] := i番目まで見て、和がjとなる通り数\ndp = [defaultdict(int) for i in range(N+1)]\ndp[0][0] = 1\nfor i, a in enumerate(A):\n for k, v in dp[i].items():\n dp[i+1][k] += v\n dp[i+1][k+a] += v\n# 部分和が0になった通り数から、1つも選ばない分の1を引く\nprint(dp[N][0] - 1)",
"import sys",
"sys",
"from collections import defaultdict",
"def input(): return sys.stdin.readline().strip()",
"input",
"[c] * b for i in range(a)",
"for i in range(a)",
"i",
"range(a)",
"range",
"a",
"for i in range(a)",
"[c] * b",
"[c]",
"c",
"b",
"def list2d(a, b, c): return [[c] * b for i in range(a)]",
"list2d",
"a",
"a",
"b",
"b",
"c",
"c",
"[[d] * c for j in range(b)] for i in range(a)",
"for i in range(a)",
"i",
"range(a)",
"range",
"a",
"for i in range(a)",
"[[d] * c for j in range(b)]",
"def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]",
"list3d",
"a",
"a",
"b",
"b",
"c",
"c",
"d",
"d",
"[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)",
"for i in range(a)",
"i",
"range(a)",
"range",
"a",
"for i in range(a)",
"[[[e] * d for j in range(c)] for j in range(b)]",
"def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"list4d",
"a",
"a",
"b",
"b",
"c",
"c",
"d",
"d",
"e",
"e",
"def ceil(x, y=1): return int(-(-x // y))",
"ceil",
"x",
"x",
"y=1",
"y",
"1",
"def INT(): return int(input())",
"INT",
"def MAP(): return map(int, input().split())",
"MAP",
"INT() for i in range(N)",
"for i in range(N)",
"i",
"range(N)",
"range",
"N",
"for i in range(N)",
"INT()",
"INT",
"def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]",
"LIST",
"N=None",
"N",
"None",
"def Yes(): print('Yes')",
"Yes",
"def No(): print('No')",
"No",
"def YES(): print('YES')",
"YES",
"def NO(): print('NO')",
"NO",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = 10 ** 18",
"INF",
"10 ** 18",
"10",
"18",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N, K = MAP()",
"N",
"MAP()",
"MAP",
"K",
"a-K for a in LIST()",
"for a in LIST()",
"a",
"LIST()",
"LIST",
"for a in LIST()",
"a-K",
"a",
"K",
"A = [a-K for a in LIST()]",
"A",
"[a-K for a in LIST()]",
"defaultdict(int) for i in range(N+1)",
"for i in range(N+1)",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for i in range(N+1)",
"defaultdict(int)",
"defaultdict",
"int",
"dp = [defaultdict(int) for i in range(N+1)]",
"dp",
"[defaultdict(int) for i in range(N+1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i, a in enumerate(A):\n for k, v in dp[i].items():\n dp[i+1][k] += v\n dp[i+1][k+a] += v\n# 部分和が0になった通り数から、1つも選ばない分の1を引く",
"i",
"a",
"enumerate(A)",
"enumerate",
"A",
"for k, v in dp[i].items():\n dp[i+1][k] += v\n dp[i+1][k+a] += v\n# 部分和が0になった通り数から、1つも選ばない分の1を引く",
"k",
"v",
"dp[i].items()",
"[i].items",
"[i]",
"dp",
"i",
"items",
"dp[i+1][k] += v",
"dp[i+1][k]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k",
"v",
"dp[i+1][k+a] += v",
"dp[i+1][k+a]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k+a",
"k",
"a",
"v",
"print(dp[N][0] - 1)",
"print",
"dp[N][0] - 1",
"dp[N][0]",
"[N]",
"dp",
"N",
"0",
"1",
"def list2d(a, b, c): return [[c] * b for i in range(a)]",
"def list2d(a, b, c): return [[c] * b for i in range(a)]",
"list2d",
"def ceil(x, y=1): return int(-(-x // y))",
"def ceil(x, y=1): return int(-(-x // y))",
"ceil",
"INF = 10 ** 18",
"10 ** 18",
"INF",
"A = [a-K for a in LIST()]",
"[a-K for a in LIST()]",
"A",
"def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]",
"def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]",
"list3d",
"def Yes(): print('Yes')",
"def Yes(): print('Yes')",
"Yes",
"def NO(): print('NO')",
"def NO(): print('NO')",
"NO",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"N, K = MAP()",
"MAP()",
"N",
"def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]",
"def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]",
"LIST",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"list4d",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"K = MAP()",
"MAP()",
"K",
"def No(): print('No')",
"def No(): print('No')",
"No",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"def YES(): print('YES')",
"def YES(): print('YES')",
"YES",
"dp = [defaultdict(int) for i in range(N+1)]",
"[defaultdict(int) for i in range(N+1)]",
"dp"
] | # -*- coding: utf-8 -*-
import sys
from collections import defaultdict
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, K = MAP()
# 総和0を平均KとするためKを引く
A = [a-K for a in LIST()]
# dp[i][j] := i番目まで見て、和がjとなる通り数
dp = [defaultdict(int) for i in range(N+1)]
dp[0][0] = 1
for i, a in enumerate(A):
for k, v in dp[i].items():
dp[i+1][k] += v
dp[i+1][k+a] += v
# 部分和が0になった通り数から、1つも選ばない分の1を引く
print(dp[N][0] - 1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
18,
18,
13,
13,
13,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
40,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13
] | [
[
151,
2
],
[
151,
11
],
[
154,
13
],
[
163,
25
],
[
155,
28
],
[
32,
31
],
[
152,
35
],
[
166,
40
],
[
50,
43
],
[
167,
46
],
[
53,
52
],
[
152,
55
],
[
58,
57
],
[
152,
60
],
[
63,
62
],
[
164,
65
],
[
167,
71
],
[
52,
72
],
[
57,
73
],
[
62,
74
],
[
86,
77
],
[
167,
80
],
[
52,
82
],
[
57,
84
],
[
62,
85
],
[
167,
89
],
[
52,
90
],
[
57,
91
],
[
62,
92
],
[
109,
94
],
[
167,
97
],
[
52,
99
],
[
57,
102
],
[
62,
105
],
[
155,
107
],
[
52,
108
],
[
167,
112
],
[
52,
113
],
[
57,
114
],
[
62,
115
],
[
157,
117
],
[
121,
120
],
[
152,
125
],
[
120,
130
],
[
149,
131
],
[
164,
132
],
[
160,
134
],
[
167,
138
],
[
152,
139
],
[
120,
140
],
[
120,
142
],
[
149,
143
],
[
161,
146
],
[
158,
146
],
[
151,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\nsum_X = sum(X)\ndp = [[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0] = 1\nfor i in range(N):\n for j in range(N):\n for k in range(sum_X):\n if dp[i][j][k] == 0: continue\n # not used\n dp[i+1][j][k] += dp[i][j][k]\n # used\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]\nans = 0\nfor k in range(1, N+1):\n if k*A <= sum_X:\n ans += dp[N][k][k*A]\nprint(ans) ",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sum_X = sum(X)",
"sum_X",
"sum(X)",
"sum",
"X",
"[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[[0]*(sum_X+1) for _ in range(N+1)]",
"dp = [[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(N):\n for j in range(N):\n for k in range(sum_X):\n if dp[i][j][k] == 0: continue\n # not used\n dp[i+1][j][k] += dp[i][j][k]\n # used\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"i",
"range(N)",
"range",
"N",
"for j in range(N):\n for k in range(sum_X):\n if dp[i][j][k] == 0: continue\n # not used\n dp[i+1][j][k] += dp[i][j][k]\n # used\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"j",
"range(N)",
"range",
"N",
"for k in range(sum_X):\n if dp[i][j][k] == 0: continue\n # not used\n dp[i+1][j][k] += dp[i][j][k]\n # used\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"k",
"range(sum_X)",
"range",
"sum_X",
"if dp[i][j][k] == 0: continue\n # not used\n ",
"dp[i][j][k] == 0",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"0",
"dp[i+1][j][k] += dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"dp[i+1][j+1][k+X[i]]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k+X[i]",
"k",
"X[i]",
"X",
"i",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"ans = 0",
"ans",
"0",
"for k in range(1, N+1):\n if k*A <= sum_X:\n ans += dp[N][k][k*A]",
"k",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if k*A <= sum_X:\n ans += dp[N][k][k*A]",
"k*A <= sum_X",
"k*A",
"k",
"A",
"sum_X",
"ans += dp[N][k][k*A]",
"ans",
"dp[N][k][k*A]",
"[k]",
"[N]",
"dp",
"N",
"k",
"k*A",
"k",
"A",
"print(ans)",
"print",
"ans",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"ans = 0",
"0",
"ans",
"ans += dp[N][k][k*A]",
"dp[N][k][k*A]",
"ans",
"sum_X = sum(X)",
"sum(X)",
"sum_X",
"dp = [[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)]",
"[[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp"
] | N, A = map(int, input().split())
X = list(map(int, input().split()))
sum_X = sum(X)
dp = [[[0]*(sum_X+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N):
for k in range(sum_X):
if dp[i][j][k] == 0: continue
# not used
dp[i+1][j][k] += dp[i][j][k]
# used
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for k in range(1, N+1):
if k*A <= sum_X:
ans += dp[N][k][k*A]
print(ans) |
[
7,
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,
12,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
2,
4,
18,
13,
13,
4,
13,
13,
0,
13,
4,
18,
4,
18,
13,
13,
39,
2,
13,
17,
2,
2,
17,
13,
17,
13,
13,
0,
18,
18,
13,
17,
2,
13,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
17,
13,
17,
0,
18,
18,
13,
2,
13,
17,
13,
8,
40,
40,
2,
17,
13,
2,
13,
18,
13,
13,
17,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
18,
13,
13,
18,
18,
13,
13,
13,
0,
13,
2,
18,
18,
13,
13,
2,
13,
13,
17,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13
] | [
[
168,
36
],
[
148,
38
],
[
168,
39
],
[
156,
41
],
[
172,
48
],
[
151,
49
],
[
174,
51
],
[
169,
60
],
[
169,
65
],
[
77,
70
],
[
175,
72
],
[
169,
75
],
[
151,
76
],
[
80,
79
],
[
169,
82
],
[
85,
84
],
[
169,
90
],
[
100,
93
],
[
175,
95
],
[
79,
97
],
[
84,
99
],
[
169,
105
],
[
84,
107
],
[
157,
109
],
[
79,
110
],
[
175,
115
],
[
79,
116
],
[
84,
117
],
[
175,
120
],
[
79,
121
],
[
84,
123
],
[
157,
125
],
[
79,
126
],
[
175,
129
],
[
79,
130
],
[
84,
131
],
[
177,
133
],
[
175,
137
],
[
169,
138
],
[
169,
140
],
[
151,
141
],
[
178,
145
],
[
168,
151
],
[
156,
157
],
[
168,
169
],
[
174,
175
],
[
177,
178
]
] | [
"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 copy as cp\nimport sys\ndef sinput(): return sys.stdin.readline()\ndef iinput(): return int(sinput())\ndef imap(): return map(int, sinput().split())\ndef fmap(): return map(float, sinput().split())\ndef iarr(): return list(imap())\ndef farr(): return list(fmap())\ndef sarr(): return sinput().split()\n\nn,a = imap()\nx = np.array(iarr()) - a\n\n# dp[i][和 + NA]\n# 本来のSの範囲は、1N-NAから50N-NA\n# 負の数はdp範囲外なのでNAたすと、1Nから50N\n# 和０のときは dp[n][0+NA]\ndp = np.zeros((n+1, 50*n+1)).astype(int)\ndp[0][n*a] = 1\n\nfor i in range(n):\n for s in range(50*n+1):\n dp[i+1][s] = dp[i][s] + dp[i][s-x[i]] if 50*n>= s-x[i] >=0 else dp[i][s]\n\nans = dp[n][n*a] - 1 #実際は初期条件の０個選ぶパターンを除外\nprint(ans)\n\n",
"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 copy as cp",
"copy",
"import sys",
"sys",
"def sinput(): return sys.stdin.readline()",
"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(): return list(imap())",
"iarr",
"def farr(): return list(fmap())",
"farr",
"def sarr(): return sinput().split()",
"sarr",
"n,a = imap()",
"n",
"imap()",
"imap",
"a",
"x = np.array(iarr()) - a",
"x",
"np.array(iarr()) - a",
"np.array(iarr())",
"np.array",
"np",
"array",
"iarr()",
"iarr",
"a",
"dp = np.zeros((n+1, 50*n+1)).astype(int)",
"dp",
"np.zeros((n+1, 50*n+1)).astype(int)",
"np.zeros((n+1, 50*n+1)).astype",
"np.zeros((n+1, 50*n+1))",
"np.zeros",
"np",
"zeros",
"(n+1, 50*n+1)",
"n+1",
"n",
"1",
"50*n+1",
"50*n",
"50",
"n",
"1",
"astype",
"int",
"dp[0][n*a] = 1",
"dp[0][n*a]",
"[0]",
"dp",
"0",
"n*a",
"n",
"a",
"1",
"for i in range(n):\n for s in range(50*n+1):\n dp[i+1][s] = dp[i][s] + dp[i][s-x[i]] if 50*n>= s-x[i] >=0 else dp[i][s]",
"i",
"range(n)",
"range",
"n",
"for s in range(50*n+1):\n dp[i+1][s] = dp[i][s] + dp[i][s-x[i]] if 50*n>= s-x[i] >=0 else dp[i][s]",
"s",
"range(50*n+1)",
"range",
"50*n+1",
"50*n",
"50",
"n",
"1",
"dp[i+1][s] = dp[i][s] + dp[i][s-x[i]] if 50*n>= s-x[i] >=0 else dp[i][s]",
"dp[i+1][s]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"s",
"dp[i][s] + dp[i][s-x[i]] if 50*n>= s-x[i] >=0 else dp[i][s]",
"50*n>= s-x[i] >=0",
"50*n>= s-x[i]",
"50*n",
"50",
"n",
"s-x[i]",
"s",
"x[i]",
"x",
"i",
"0",
"dp[i][s] + dp[i][s-x[i]]",
"dp[i][s]",
"[i]",
"dp",
"i",
"s",
"dp[i][s-x[i]]",
"[i]",
"dp",
"i",
"s-x[i]",
"s",
"x[i]",
"x",
"i",
"dp[i][s]",
"[i]",
"dp",
"i",
"s",
"ans = dp[n][n*a] - 1",
"ans",
"dp[n][n*a] - 1",
"dp[n][n*a]",
"[n]",
"dp",
"n",
"n*a",
"n",
"a",
"1",
"print(ans)",
"print",
"ans",
"def imap(): return map(int, sinput().split())",
"def imap(): return map(int, sinput().split())",
"imap",
"a = imap()",
"imap()",
"a",
"def iinput(): return int(sinput())",
"def iinput(): return int(sinput())",
"iinput",
"x = np.array(iarr()) - a",
"np.array(iarr()) - a",
"x",
"def sinput(): return sys.stdin.readline()",
"def sinput(): return sys.stdin.readline()",
"sinput",
"def fmap(): return map(float, sinput().split())",
"def fmap(): return map(float, sinput().split())",
"fmap",
"def farr(): return list(fmap())",
"def farr(): return list(fmap())",
"farr",
"n,a = imap()",
"imap()",
"n",
"def iarr(): return list(imap())",
"def iarr(): return list(imap())",
"iarr",
"dp = np.zeros((n+1, 50*n+1)).astype(int)",
"np.zeros((n+1, 50*n+1)).astype(int)",
"dp",
"ans = dp[n][n*a] - 1",
"dp[n][n*a] - 1",
"ans",
"def sarr(): return sinput().split()",
"def sarr(): return sinput().split()",
"sarr"
] | 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 copy as cp
import sys
def sinput(): return sys.stdin.readline()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(): return list(imap())
def farr(): return list(fmap())
def sarr(): return sinput().split()
n,a = imap()
x = np.array(iarr()) - a
# dp[i][和 + NA]
# 本来のSの範囲は、1N-NAから50N-NA
# 負の数はdp範囲外なのでNAたすと、1Nから50N
# 和０のときは dp[n][0+NA]
dp = np.zeros((n+1, 50*n+1)).astype(int)
dp[0][n*a] = 1
for i in range(n):
for s in range(50*n+1):
dp[i+1][s] = dp[i][s] + dp[i][s-x[i]] if 50*n>= s-x[i] >=0 else dp[i][s]
ans = dp[n][n*a] - 1 #実際は初期条件の０個選ぶパターンを除外
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
0,
13,
13,
28,
13,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
0,
13,
39,
28,
13,
4,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
18,
13,
13,
14,
2,
40,
13,
17,
40,
13,
17,
4,
18,
13,
13,
2,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
4,
18,
13,
13,
18,
18,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13,
10,
18,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13
] | [
[
171,
2
],
[
171,
11
],
[
153,
13
],
[
27,
26
],
[
148,
30
],
[
162,
35
],
[
43,
38
],
[
163,
40
],
[
168,
45
],
[
163,
46
],
[
49,
48
],
[
148,
51
],
[
174,
53
],
[
57,
56
],
[
148,
60
],
[
156,
63
],
[
67,
66
],
[
148,
71
],
[
172,
72
],
[
165,
75
],
[
66,
77
],
[
154,
79
],
[
48,
80
],
[
166,
84
],
[
56,
87
],
[
157,
91
],
[
169,
96
],
[
151,
96
],
[
56,
97
],
[
66,
98
],
[
169,
101
],
[
151,
101
],
[
56,
103
],
[
166,
105
],
[
157,
108
],
[
169,
112
],
[
151,
112
],
[
56,
113
],
[
66,
114
],
[
175,
117
],
[
157,
119
],
[
150,
121
],
[
175,
122
],
[
177,
124
],
[
128,
127
],
[
148,
132
],
[
159,
135
],
[
151,
138
],
[
169,
138
],
[
127,
139
],
[
127,
141
],
[
172,
142
],
[
160,
145
],
[
178,
145
],
[
171,
148
],
[
175,
150
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
],
[
163,
168
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
177,
178
]
] | [
"#解説解答\nn,a = map(int,input().split())\nx = list(map(int,input().split()))\ndp0 = [[0 for s in range(n*a+1)] for k in range(n+1)]\ndp0[0][0] = 1\ndp = dp0\nfor j in range(n):\n now = []\n for k in range(n+1):\n add = []\n for s in range(n*a+1):\n t = s-x[j]\n if t >= 0 and k >= 1:\n add.append( dp[k][s] + dp[k-1][t] )\n else:\n add.append( dp[k][s] )\n now.append(add)\n dp = now\nans = 0\nfor k in range(1,n+1):\n ans += dp[k][k*a]\nprint(ans)",
"n,a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[0 for s in range(n*a+1)] for k in range(n+1)",
"for k in range(n+1)",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for k in range(n+1)",
"[0 for s in range(n*a+1)]",
"dp0 = [[0 for s in range(n*a+1)] for k in range(n+1)]",
"dp0",
"[[0 for s in range(n*a+1)] for k in range(n+1)]",
"dp0[0][0] = 1",
"dp0[0][0]",
"[0]",
"dp0",
"0",
"0",
"1",
"dp = dp0",
"dp",
"dp0",
"for j in range(n):\n now = []\n for k in range(n+1):\n add = []\n for s in range(n*a+1):\n t = s-x[j]\n if t >= 0 and k >= 1:\n add.append( dp[k][s] + dp[k-1][t] )\n else:\n add.append( dp[k][s] )\n now.append(add)\n dp = now",
"j",
"range(n)",
"range",
"n",
"now = []",
"now",
"[]",
"for k in range(n+1):\n add = []\n for s in range(n*a+1):\n t = s-x[j]\n if t >= 0 and k >= 1:\n add.append( dp[k][s] + dp[k-1][t] )\n else:\n add.append( dp[k][s] )\n now.append(add)\n ",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"add = []",
"add",
"[]",
"for s in range(n*a+1):\n t = s-x[j]\n if t >= 0 and k >= 1:\n add.append( dp[k][s] + dp[k-1][t] )\n else:\n add.append( dp[k][s] )\n ",
"s",
"range(n*a+1)",
"range",
"n*a+1",
"n*a",
"n",
"a",
"1",
"t = s-x[j]",
"t",
"s-x[j]",
"s",
"x[j]",
"x",
"j",
"if t >= 0 and k >= 1:\n add.append( dp[k][s] + dp[k-1][t] )\n else:\n add.append( dp[k][s] )\n ",
"t >= 0 and k >= 1",
"t >= 0",
"t",
"0",
"k >= 1",
"k",
"1",
"add.append( dp[k][s] + dp[k-1][t] )",
"add.append",
"add",
"append",
"dp[k][s] + dp[k-1][t]",
"dp[k][s]",
"[k]",
"dp",
"k",
"s",
"dp[k-1][t]",
"[k-1]",
"dp",
"k-1",
"k",
"1",
"t",
"add.append( dp[k][s] )",
"add.append",
"add",
"append",
"dp[k][s]",
"[k]",
"dp",
"k",
"s",
"now.append(add)",
"now.append",
"now",
"append",
"add",
"dp = now",
"dp",
"now",
"ans = 0",
"ans",
"0",
"for k in range(1,n+1):\n ans += dp[k][k*a]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[k][k*a]",
"ans",
"dp[k][k*a]",
"[k]",
"dp",
"k",
"k*a",
"k",
"a",
"print(ans)",
"print",
"ans",
"n,a = map(int,input().split())",
"map(int,input().split())",
"n",
"dp = now",
"now",
"dp",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"add = []",
"[]",
"add",
"ans += dp[k][k*a]",
"dp[k][k*a]",
"ans",
"dp0 = [[0 for s in range(n*a+1)] for k in range(n+1)]",
"[[0 for s in range(n*a+1)] for k in range(n+1)]",
"dp0",
"t = s-x[j]",
"s-x[j]",
"t",
"dp = dp0",
"dp0",
"dp",
"a = map(int,input().split())",
"map(int,input().split())",
"a",
"now = []",
"[]",
"now",
"ans = 0",
"0",
"ans"
] | #解説解答
n,a = map(int,input().split())
x = list(map(int,input().split()))
dp0 = [[0 for s in range(n*a+1)] for k in range(n+1)]
dp0[0][0] = 1
dp = dp0
for j in range(n):
now = []
for k in range(n+1):
add = []
for s in range(n*a+1):
t = s-x[j]
if t >= 0 and k >= 1:
add.append( dp[k][s] + dp[k-1][t] )
else:
add.append( dp[k][s] )
now.append(add)
dp = now
ans = 0
for k in range(1,n+1):
ans += dp[k][k*a]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
13,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
0,
18,
18,
18,
13,
17,
17,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
18,
18,
13,
13,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
14,
40,
2,
13,
18,
13,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
18,
18,
13,
17,
13,
2,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
175,
2
],
[
175,
11
],
[
169,
13
],
[
27,
26
],
[
167,
29
],
[
172,
33
],
[
43,
36
],
[
173,
39
],
[
54,
45
],
[
173,
48
],
[
170,
52
],
[
57,
56
],
[
167,
60
],
[
69,
62
],
[
173,
65
],
[
56,
66
],
[
72,
71
],
[
56,
76
],
[
80,
79
],
[
79,
86
],
[
170,
88
],
[
56,
89
],
[
99,
92
],
[
173,
95
],
[
56,
96
],
[
71,
97
],
[
79,
98
],
[
173,
103
],
[
56,
105
],
[
71,
108
],
[
79,
111
],
[
170,
113
],
[
56,
114
],
[
173,
118
],
[
56,
120
],
[
71,
122
],
[
79,
123
],
[
132,
125
],
[
173,
128
],
[
56,
129
],
[
71,
130
],
[
79,
131
],
[
173,
135
],
[
56,
137
],
[
71,
139
],
[
79,
140
],
[
144,
143
],
[
167,
148
],
[
173,
154
],
[
143,
156
],
[
176,
158
],
[
143,
159
],
[
175,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
]
] | [
"N, A=map(int, input().split())\nx=list(map(int, input().split()))\n\ndp=[[[0]*2501 for j in range(N+1)] for i in range(N)]\n\ndp[0][0][0]=1\ndp[0][1][x[0]]=1\nfor i in range(1, N):\n dp[i][0][0]=1\n for j in range(1, i+2):\n for k in range(2501):\n if k-x[i]>=0:\n dp[i][j][k]=dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]\n else:\n dp[i][j][k]=dp[i-1][j][k]\n \nprint(sum([dp[-1][j][A*j] for j in range(1, N+1)]))",
"N, A=map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x=list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0]*2501 for j in range(N+1)] for i in range(N)",
"for i in range(N)",
"i",
"range(N)",
"range",
"N",
"for i in range(N)",
"[[0]*2501 for j in range(N+1)]",
"dp=[[[0]*2501 for j in range(N+1)] for i in range(N)]",
"dp",
"[[[0]*2501 for j in range(N+1)] for i in range(N)]",
"dp[0][0][0]=1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"dp[0][1][x[0]]=1",
"dp[0][1][x[0]]",
"[1]",
"[0]",
"dp",
"0",
"1",
"x[0]",
"x",
"0",
"1",
"for i in range(1, N):\n dp[i][0][0]=1\n for j in range(1, i+2):\n for k in range(2501):\n if k-x[i]>=0:\n dp[i][j][k]=dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]\n else:\n dp[i][j][k]=dp[i-1][j][k]\n ",
"i",
"range(1, N)",
"range",
"1",
"N",
"dp[i][0][0]=1",
"dp[i][0][0]",
"[0]",
"[i]",
"dp",
"i",
"0",
"0",
"1",
"for j in range(1, i+2):\n for k in range(2501):\n if k-x[i]>=0:\n dp[i][j][k]=dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]\n else:\n dp[i][j][k]=dp[i-1][j][k]\n ",
"j",
"range(1, i+2)",
"range",
"1",
"i+2",
"i",
"2",
"for k in range(2501):\n if k-x[i]>=0:\n dp[i][j][k]=dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]\n else:\n dp[i][j][k]=dp[i-1][j][k]\n ",
"k",
"range(2501)",
"range",
"2501",
"if k-x[i]>=0:\n dp[i][j][k]=dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]\n else:\n dp[i][j][k]=dp[i-1][j][k]\n ",
"k-x[i]>=0",
"k-x[i]",
"k",
"x[i]",
"x",
"i",
"0",
"dp[i][j][k]=dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]",
"dp[i-1][j-1][k-x[i]]",
"[j-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"k-x[i]",
"k",
"x[i]",
"x",
"i",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"dp[i][j][k]=dp[i-1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"dp[-1][j][A*j] for j in range(1, N+1)",
"for j in range(1, N+1)",
"j",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for j in range(1, N+1)",
"dp[-1][j][A*j]",
"[j]",
"[-1]",
"dp",
"-1",
"j",
"A*j",
"A",
"j",
"print(sum([dp[-1][j][A*j] for j in range(1, N+1)]))",
"print",
"sum([dp[-1][j][A*j] for j in range(1, N+1)])",
"sum",
"[dp[-1][j][A*j] for j in range(1, N+1)]",
"N, A=map(int, input().split())",
"map(int, input().split())",
"N",
"x=list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp=[[[0]*2501 for j in range(N+1)] for i in range(N)]",
"[[[0]*2501 for j in range(N+1)] for i in range(N)]",
"dp",
"A=map(int, input().split())",
"map(int, input().split())",
"A"
] | N, A=map(int, input().split())
x=list(map(int, input().split()))
dp=[[[0]*2501 for j in range(N+1)] for i in range(N)]
dp[0][0][0]=1
dp[0][1][x[0]]=1
for i in range(1, N):
dp[i][0][0]=1
for j in range(1, i+2):
for k in range(2501):
if k-x[i]>=0:
dp[i][j][k]=dp[i-1][j-1][k-x[i]]+dp[i-1][j][k]
else:
dp[i][j][k]=dp[i-1][j][k]
print(sum([dp[-1][j][A*j] for j in range(1, N+1)])) |
[
7,
12,
13,
12,
13,
14,
40,
2,
18,
18,
18,
13,
13,
13,
13,
17,
29,
18,
18,
18,
13,
13,
13,
13,
14,
40,
2,
13,
13,
14,
2,
2,
13,
17,
2,
13,
2,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
17,
29,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
17,
29,
18,
18,
18,
13,
13,
13,
13,
0,
13,
4,
13,
2,
13,
17,
13,
13,
0,
13,
4,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
2,
13,
13,
29,
18,
18,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
4,
18,
13,
13,
13,
29,
4,
13,
17,
17,
17,
14,
2,
13,
17,
4,
13,
4,
13,
10,
12,
13
] | [
[
117,
12
],
[
119,
13
],
[
121,
14
],
[
117,
21
],
[
119,
22
],
[
121,
23
],
[
117,
27
],
[
119,
32
],
[
121,
35
],
[
119,
38
],
[
47,
40
],
[
117,
44
],
[
119,
45
],
[
121,
46
],
[
40,
49
],
[
117,
53
],
[
119,
54
],
[
121,
55
],
[
64,
57
],
[
117,
61
],
[
119,
62
],
[
121,
63
],
[
57,
66
],
[
40,
66
],
[
117,
70
],
[
119,
71
],
[
121,
72
],
[
75,
74
],
[
117,
78
],
[
119,
80
],
[
121,
81
],
[
84,
83
],
[
117,
87
],
[
119,
90
],
[
121,
93
],
[
117,
96
],
[
105,
98
],
[
117,
102
],
[
119,
103
],
[
121,
104
],
[
74,
106
],
[
83,
107
],
[
98,
109
],
[
57,
109
],
[
40,
109
],
[
117,
113
],
[
119,
114
],
[
121,
115
],
[
117,
117
],
[
119,
119
],
[
121,
121
],
[
124,
123
],
[
124,
134
],
[
137,
136
],
[
149,
148
],
[
152,
151
],
[
123,
155
],
[
160,
159
],
[
123,
163
],
[
169,
168
],
[
148,
172
],
[
168,
174
],
[
4,
177
],
[
191,
188
]
] | [
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n TABLE[i][n][total] = 1\n return TABLE[i][n][total]\n\n TABLE[i][n][total] = 0\n return TABLE[i][n][total]\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)\n\n\nif __name__ == '__main__':\n print(solve())",
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n TABLE[i][n][total] = 1\n return TABLE[i][n][total]\n\n TABLE[i][n][total] = 0\n return TABLE[i][n][total]\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)",
"solve",
"def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n TABLE[i][n][total] = 1\n return TABLE[i][n][total]\n\n TABLE[i][n][total] = 0\n return TABLE[i][n][total]\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n ",
"recur",
"if not TABLE[i][n][total] == -1:\n return TABLE[i][n][total]\n\n ",
"not TABLE[i][n][total] == -1",
"TABLE[i][n][total] == -1",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"-1",
"return TABLE[i][n][total]",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"if not i < N:\n if n > 0 and total == A * n:\n TABLE[i][n][total] = 1\n return TABLE[i][n][total]\n\n TABLE[i][n][total] = 0\n return TABLE[i][n][total]\n\n ",
"not i < N",
"i < N",
"i",
"N",
"if n > 0 and total == A * n:\n TABLE[i][n][total] = 1\n return TABLE[i][n][total]\n\n ",
"n > 0 and total == A * n",
"n > 0",
"n",
"0",
"total == A * n",
"total",
"A * n",
"A",
"n",
"TABLE[i][n][total] = 1",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"1",
"return TABLE[i][n][total]",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"TABLE[i][n][total] = 0",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"0",
"return TABLE[i][n][total]",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"ans1 = recur(i + 1, n, total)",
"ans1",
"recur(i + 1, n, total)",
"recur",
"i + 1",
"i",
"1",
"n",
"total",
"ans2 = recur(i + 1, n + 1, total + XS[i])",
"ans2",
"recur(i + 1, n + 1, total + XS[i])",
"recur",
"i + 1",
"i",
"1",
"n + 1",
"n",
"1",
"total + XS[i]",
"total",
"XS[i]",
"XS",
"i",
"TABLE[i][n][total] = ans1 + ans2",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"ans1 + ans2",
"ans1",
"ans2",
"return TABLE[i][n][total]",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"i",
"i",
"n",
"n",
"total",
"total",
"N, A = tuple(map(int, input().split()))",
"N",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"XS = tuple(map(int, input().split()))",
"XS",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"TABLE = []",
"TABLE",
"[]",
"for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n ",
"_",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"[-1 for x in range(N * 50 + 1)] for y in range(N + 1)",
"for y in range(N + 1)",
"y",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for y in range(N + 1)",
"[-1 for x in range(N * 50 + 1)]",
"lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]",
"lines",
"[[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]",
"TABLE.append(lines)",
"TABLE.append",
"TABLE",
"append",
"lines",
"return recur(0, 0, 0)",
"recur(0, 0, 0)",
"recur",
"0",
"0",
"0",
"if __name__ == '__main__':\n print(solve())",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"print(solve())",
"print",
"solve()",
"solve",
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n TABLE[i][n][total] = 1\n return TABLE[i][n][total]\n\n TABLE[i][n][total] = 0\n return TABLE[i][n][total]\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)",
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n TABLE[i][n][total] = 1\n return TABLE[i][n][total]\n\n TABLE[i][n][total] = 0\n return TABLE[i][n][total]\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)",
"solve"
] | def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
TABLE[i][n][total] = 1
return TABLE[i][n][total]
TABLE[i][n][total] = 0
return TABLE[i][n][total]
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
TABLE[i][n][total] = ans1 + ans2
return TABLE[i][n][total]
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == '__main__':
print(solve())
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
13,
14,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
160,
2
],
[
160,
11
],
[
145,
13
],
[
157,
25
],
[
146,
30
],
[
155,
31
],
[
35,
34
],
[
161,
38
],
[
148,
43
],
[
53,
46
],
[
149,
49
],
[
56,
55
],
[
161,
58
],
[
61,
60
],
[
161,
63
],
[
66,
65
],
[
161,
69
],
[
158,
70
],
[
149,
75
],
[
55,
76
],
[
60,
77
],
[
65,
78
],
[
89,
80
],
[
149,
83
],
[
55,
85
],
[
60,
87
],
[
65,
88
],
[
149,
92
],
[
55,
93
],
[
60,
94
],
[
65,
95
],
[
112,
97
],
[
149,
100
],
[
55,
102
],
[
60,
105
],
[
65,
108
],
[
146,
110
],
[
55,
111
],
[
149,
115
],
[
55,
116
],
[
60,
117
],
[
65,
118
],
[
163,
120
],
[
124,
123
],
[
161,
128
],
[
151,
131
],
[
149,
135
],
[
161,
136
],
[
123,
137
],
[
123,
139
],
[
155,
140
],
[
152,
143
],
[
164,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
160,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
]
] | [
"# 配列を大きめにとって配った方がすっきりかけるのかも\n\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\nX = max(max(x), a)\ndp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]\n\n#if j == 0 and k == 0 and s == 0:\ndp[0][0][0] = 1\nfor j in range(n):\n for k in range(n):\n for s in range(n*X):\n\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]\nans = 0\nfor k in range(1,n+1):\n ans += dp[n][k][k*a]\n\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"X = max(max(x), a)",
"X",
"max(max(x), a)",
"max",
"max(x)",
"max",
"x",
"a",
"[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[[0]*(n*X+1) for _ in range(n+1)]",
"dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"dp",
"[[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for j in range(n):\n for k in range(n):\n for s in range(n*X):\n\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"j",
"range(n)",
"range",
"n",
"for k in range(n):\n for s in range(n*X):\n\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"k",
"range(n)",
"range",
"n",
"for s in range(n*X):\n\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"s",
"range(n*X)",
"range",
"n*X",
"n",
"X",
"if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j+1][k][s] += dp[j][k][s]",
"dp[j+1][k][s]",
"[k]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"k",
"s",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"dp[j+1][k+1][s+x[j]]",
"[k+1]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"k+1",
"k",
"1",
"s+x[j]",
"s",
"x[j]",
"x",
"j",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"ans = 0",
"ans",
"0",
"for k in range(1,n+1):\n ans += dp[n][k][k*a]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[n][k][k*a]",
"ans",
"dp[n][k][k*a]",
"[k]",
"[n]",
"dp",
"n",
"k",
"k*a",
"k",
"a",
"print(ans)",
"print",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"[[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"dp",
"ans += dp[n][k][k*a]",
"dp[n][k][k*a]",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"X = max(max(x), a)",
"max(max(x), a)",
"X",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"ans = 0",
"0",
"ans"
] | # 配列を大きめにとって配った方がすっきりかけるのかも
n, a = map(int, input().split())
x = list(map(int, input().split()))
X = max(max(x), a)
dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]
#if j == 0 and k == 0 and s == 0:
dp[0][0][0] = 1
for j in range(n):
for k in range(n):
for s in range(n*X):
if dp[j][k][s]:
dp[j+1][k][s] += dp[j][k][s]
dp[j+1][k+1][s+x[j]] += dp[j][k][s]
ans = 0
for k in range(1,n+1):
ans += dp[n][k][k*a]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
13,
4,
2,
39,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
2,
18,
13,
17,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
18,
13,
13,
2,
18,
13,
13,
17,
17,
28,
13,
4,
13,
17,
28,
13,
4,
13,
17,
14,
40,
40,
17,
2,
13,
2,
13,
18,
13,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
2,
13,
2,
13,
18,
13,
13,
4,
13,
18,
18,
13,
2,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
136,
2
],
[
136,
11
],
[
127,
13
],
[
26,
25
],
[
137,
28
],
[
33,
30
],
[
128,
31
],
[
25,
32
],
[
131,
33
],
[
37,
36
],
[
137,
39
],
[
133,
46
],
[
58,
49
],
[
134,
51
],
[
128,
55
],
[
61,
60
],
[
137,
64
],
[
75,
66
],
[
134,
68
],
[
60,
69
],
[
30,
71
],
[
128,
72
],
[
60,
73
],
[
78,
77
],
[
83,
82
],
[
77,
91
],
[
82,
93
],
[
30,
94
],
[
128,
95
],
[
60,
96
],
[
104,
99
],
[
134,
101
],
[
60,
102
],
[
77,
103
],
[
134,
106
],
[
60,
108
],
[
77,
111
],
[
82,
113
],
[
30,
114
],
[
128,
115
],
[
60,
116
],
[
134,
121
],
[
137,
123
],
[
127,
128
],
[
136,
131
],
[
133,
134
],
[
136,
137
]
] | [
"n,a=map(int,input().split())\nx=list(map(int,input().split()))\nfor i in range(n):\n x[i]-=a\n# dp[i][j] = i番目までで(j-2500)を何個作れるか\ndp=[[0]*5001 for i in range(n)]\ndp[0][x[0]+2500]=1\nfor i in range(1,n):\n dp[i][x[i]+2500]=1\n for j in range(5000):\n for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i][j]+=dp[i-1][j-k*x[i]]\nprint(dp[n-1][2500])",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x=list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n):\n x[i]-=a\n# dp[i][j] = i番目までで(j-2500)を何個作れるか",
"i",
"range(n)",
"range",
"n",
"x[i]-=a",
"x[i]",
"x",
"i",
"a",
"[0]*5001 for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"[0]*5001",
"[0]",
"0",
"5001",
"dp=[[0]*5001 for i in range(n)]",
"dp",
"[[0]*5001 for i in range(n)]",
"dp[0][x[0]+2500]=1",
"dp[0][x[0]+2500]",
"[0]",
"dp",
"0",
"x[0]+2500",
"x[0]",
"x",
"0",
"2500",
"1",
"for i in range(1,n):\n dp[i][x[i]+2500]=1\n for j in range(5000):\n for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i][j]+=dp[i-1][j-k*x[i]]",
"i",
"range(1,n)",
"range",
"1",
"n",
"dp[i][x[i]+2500]=1",
"dp[i][x[i]+2500]",
"[i]",
"dp",
"i",
"x[i]+2500",
"x[i]",
"x",
"i",
"2500",
"1",
"for j in range(5000):\n for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i][j]+=dp[i-1][j-k*x[i]]",
"j",
"range(5000)",
"range",
"5000",
"for k in range(2):\n if 0<=j-k*x[i]<=5000:\n dp[i][j]+=dp[i-1][j-k*x[i]]",
"k",
"range(2)",
"range",
"2",
"if 0<=j-k*x[i]<=5000:\n dp[i][j]+=dp[i-1][j-k*x[i]]",
"0<=j-k*x[i]<=5000",
"0<=j-k*x[i]",
"0",
"j-k*x[i]",
"j",
"k*x[i]",
"k",
"x[i]",
"x",
"i",
"5000",
"dp[i][j]+=dp[i-1][j-k*x[i]]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j-k*x[i]]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-k*x[i]",
"j",
"k*x[i]",
"k",
"x[i]",
"x",
"i",
"print(dp[n-1][2500])",
"print",
"dp[n-1][2500]",
"[n-1]",
"dp",
"n-1",
"n",
"1",
"2500",
"x=list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"dp=[[0]*5001 for i in range(n)]",
"[[0]*5001 for i in range(n)]",
"dp",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n"
] | n,a=map(int,input().split())
x=list(map(int,input().split()))
for i in range(n):
x[i]-=a
# dp[i][j] = i番目までで(j-2500)を何個作れるか
dp=[[0]*5001 for i in range(n)]
dp[0][x[0]+2500]=1
for i in range(1,n):
dp[i][x[i]+2500]=1
for j in range(5000):
for k in range(2):
if 0<=j-k*x[i]<=5000:
dp[i][j]+=dp[i-1][j-k*x[i]]
print(dp[n-1][2500])
|
[
7,
41,
28,
13,
4,
13,
17,
4,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
13,
0,
39,
13,
13,
13,
31,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
18,
4,
13,
13,
39,
17,
28,
13,
18,
4,
13,
2,
17,
13,
39,
17,
14,
18,
18,
13,
13,
13,
4,
13,
4,
13,
18,
18,
13,
13,
2,
13,
13,
10,
13,
13,
10,
13,
13
] | [
[
4,
3
],
[
77,
17
],
[
23,
20
],
[
23,
24
],
[
80,
27
],
[
35,
30
],
[
81,
32
],
[
38,
37
],
[
78,
39
],
[
43,
42
],
[
78,
45
],
[
51,
50
],
[
78,
53
],
[
81,
62
],
[
42,
63
],
[
50,
64
],
[
81,
71
],
[
77,
78
],
[
80,
81
]
] | [
"R=range;(N,A),(*X,)=(map(int,input().split())for _ in R(2));C=[51*N*[0]for _ in R(N+1)];C[0][0]=1\nfor I in R(N):\n\tfor J in R(N)[::-1]:\n\t\tfor K in R(50*N)[::-1]:\n\t\t\tif C[J][K]:C[J+1][K+X[I]]+=C[J][K]\nprint(sum(C[I][I*A]for I in R(1,N+1)))",
"map(int,input().split())for _ in R(2)",
"for _ in R(2)",
"_",
"R(2)",
"R",
"2",
"for _ in R(2)",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"R=range",
"R",
"range",
"(N,A),(*X,)=(map(int,input().split())for _ in R(2))",
"(N,A)",
"N",
"A",
"(map(int,input().split())for _ in R(2))",
"*X",
"X",
"C=[51*N*[0]for _ in R(N+1)]",
"C",
"[51*N*[0]for _ in R(N+1)]",
"C[0][0]=1",
"C[0][0]",
"[0]",
"C",
"0",
"0",
"1",
"for I in R(N):\n\tfor J in R(N)[::-1]:\n\t\tfor K in R(50*N)[::-1]:\n\t\t\tif C[J][K]:C[J+1][K+X[I]]+=C[J][K]",
"I",
"R(N)",
"R",
"N",
"for J in R(N)[::-1]:\n\t\tfor K in R(50*N)[::-1]:\n\t\t\tif C[J][K]:C[J+1][K+X[I]]+=C[J][K]",
"J",
"R(N)[::-1]",
"(N)",
"R",
"N",
"::-1",
"-1",
"for K in R(50*N)[::-1]:\n\t\t\tif C[J][K]:C[J+1][K+X[I]]+=C[J][K]",
"K",
"R(50*N)[::-1]",
"(50*N)",
"R",
"50*N",
"50",
"N",
"::-1",
"-1",
"if C[J][K]:C[J+1][K+X[I]]+=C[J]",
"C[J][K]",
"[J]",
"C",
"J",
"K",
"print(sum(C[I][I*A]for I in R(1,N+1)))",
"print",
"sum(C[I][I*A]for I in R(1,N+1))",
"sum",
"C[I][I*A]",
"[I]",
"C",
"I",
"I*A",
"I",
"A",
"R=range",
"range",
"R",
"C=[51*N*[0]for _ in R(N+1)]",
"[51*N*[0]for _ in R(N+1)]",
"C"
] | R=range;(N,A),(*X,)=(map(int,input().split())for _ in R(2));C=[51*N*[0]for _ in R(N+1)];C[0][0]=1
for I in R(N):
for J in R(N)[::-1]:
for K in R(50*N)[::-1]:
if C[J][K]:C[J+1][K+X[I]]+=C[J][K]
print(sum(C[I][I*A]for I in R(1,N+1)))
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
2,
17,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
17,
13,
17,
0,
13,
2,
13,
2,
17,
13,
0,
13,
18,
13,
13,
14,
40,
40,
2,
17,
13,
2,
13,
13,
2,
17,
13,
0,
18,
18,
13,
2,
13,
17,
13,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
4,
13,
2,
18,
18,
13,
13,
2,
17,
13,
17,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
152,
2
],
[
152,
11
],
[
146,
13
],
[
26,
25
],
[
150,
28
],
[
33,
30
],
[
147,
31
],
[
25,
32
],
[
153,
33
],
[
37,
36
],
[
150,
40
],
[
140,
45
],
[
55,
48
],
[
141,
50
],
[
150,
54
],
[
58,
57
],
[
150,
60
],
[
63,
62
],
[
150,
68
],
[
155,
71
],
[
62,
73
],
[
150,
76
],
[
143,
78
],
[
30,
79
],
[
147,
80
],
[
57,
81
],
[
150,
87
],
[
156,
89
],
[
144,
90
],
[
150,
93
],
[
102,
95
],
[
141,
97
],
[
57,
99
],
[
62,
101
],
[
141,
105
],
[
57,
106
],
[
62,
107
],
[
141,
110
],
[
57,
111
],
[
62,
113
],
[
144,
114
],
[
123,
116
],
[
141,
118
],
[
57,
120
],
[
62,
122
],
[
141,
125
],
[
57,
126
],
[
62,
127
],
[
141,
133
],
[
150,
134
],
[
150,
137
],
[
140,
141
],
[
30,
143
],
[
143,
144
],
[
146,
147
],
[
152,
150
],
[
152,
153
],
[
155,
156
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\nfor i in range(n):\n x[i] -= a\ndp = [[0 for i in range(100 * n + 1)] for j in range(n + 1)]\ndp[0][50 * n] = 1\nfor i in range(n):\n for j in range(100 * n + 1):\n j2 = j - 50 * n\n num = x[i]\n if -50 * n <= j2 - num <= 50 * n:\n dp[i + 1][j] = dp[i][j] + dp[i][j - num]\n else:\n dp[i + 1][j] = dp[i][j]\nprint(dp[n][50 * n] - 1)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n):\n x[i] -= a",
"i",
"range(n)",
"range",
"n",
"x[i] -= a",
"x[i]",
"x",
"i",
"a",
"[0 for i in range(100 * n + 1)] for j in range(n + 1)",
"for j in range(n + 1)",
"j",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for j in range(n + 1)",
"[0 for i in range(100 * n + 1)]",
"dp = [[0 for i in range(100 * n + 1)] for j in range(n + 1)]",
"dp",
"[[0 for i in range(100 * n + 1)] for j in range(n + 1)]",
"dp[0][50 * n] = 1",
"dp[0][50 * n]",
"[0]",
"dp",
"0",
"50 * n",
"50",
"n",
"1",
"for i in range(n):\n for j in range(100 * n + 1):\n j2 = j - 50 * n\n num = x[i]\n if -50 * n <= j2 - num <= 50 * n:\n dp[i + 1][j] = dp[i][j] + dp[i][j - num]\n else:\n dp[i + 1][j] = dp[i][j]",
"i",
"range(n)",
"range",
"n",
"for j in range(100 * n + 1):\n j2 = j - 50 * n\n num = x[i]\n if -50 * n <= j2 - num <= 50 * n:\n dp[i + 1][j] = dp[i][j] + dp[i][j - num]\n else:\n dp[i + 1][j] = dp[i][j]",
"j",
"range(100 * n + 1)",
"range",
"100 * n + 1",
"100 * n",
"100",
"n",
"1",
"j2 = j - 50 * n",
"j2",
"j - 50 * n",
"j",
"50 * n",
"50",
"n",
"num = x[i]",
"num",
"x[i]",
"x",
"i",
"if -50 * n <= j2 - num <= 50 * n:\n dp[i + 1][j] = dp[i][j] + dp[i][j - num]\n else:\n dp[i + 1][j] = dp[i][j]",
"-50 * n <= j2 - num <= 50 * n",
"-50 * n <= j2 - num",
"-50 * n",
"-50",
"n",
"j2 - num",
"j2",
"num",
"50 * n",
"50",
"n",
"dp[i + 1][j] = dp[i][j] + dp[i][j - num]",
"dp[i + 1][j]",
"[i + 1]",
"dp",
"i + 1",
"i",
"1",
"j",
"dp[i][j] + dp[i][j - num]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i][j - num]",
"[i]",
"dp",
"i",
"j - num",
"j",
"num",
"dp[i + 1][j] = dp[i][j]",
"dp[i + 1][j]",
"[i + 1]",
"dp",
"i + 1",
"i",
"1",
"j",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"print(dp[n][50 * n] - 1)",
"print",
"dp[n][50 * n] - 1",
"dp[n][50 * n]",
"[n]",
"dp",
"n",
"50 * n",
"50",
"n",
"1",
"dp = [[0 for i in range(100 * n + 1)] for j in range(n + 1)]",
"[[0 for i in range(100 * n + 1)] for j in range(n + 1)]",
"dp",
"num = x[i]",
"x[i]",
"num",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"j2 = j - 50 * n",
"j - 50 * n",
"j2"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
for i in range(n):
x[i] -= a
dp = [[0 for i in range(100 * n + 1)] for j in range(n + 1)]
dp[0][50 * n] = 1
for i in range(n):
for j in range(100 * n + 1):
j2 = j - 50 * n
num = x[i]
if -50 * n <= j2 - num <= 50 * n:
dp[i + 1][j] = dp[i][j] + dp[i][j - num]
else:
dp[i + 1][j] = dp[i][j]
print(dp[n][50 * n] - 1) |
[
7,
15,
13,
15,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
2,
4,
18,
13,
13,
4,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
18,
4,
18,
13,
13,
39,
2,
13,
17,
2,
2,
17,
13,
17,
13,
13,
0,
18,
18,
13,
17,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
13,
14,
2,
2,
2,
13,
18,
13,
13,
17,
2,
2,
13,
18,
13,
13,
2,
17,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
18,
13,
13,
4,
13,
2,
18,
18,
13,
13,
13,
17,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13
] | [
[
158,
20
],
[
144,
22
],
[
158,
23
],
[
152,
25
],
[
171,
32
],
[
147,
33
],
[
164,
35
],
[
173,
42
],
[
159,
51
],
[
165,
56
],
[
66,
61
],
[
174,
63
],
[
165,
65
],
[
69,
68
],
[
159,
71
],
[
74,
73
],
[
165,
78
],
[
73,
83
],
[
153,
85
],
[
68,
86
],
[
73,
90
],
[
153,
92
],
[
68,
93
],
[
165,
96
],
[
105,
98
],
[
174,
100
],
[
68,
102
],
[
73,
104
],
[
174,
107
],
[
68,
108
],
[
73,
109
],
[
118,
111
],
[
174,
113
],
[
68,
115
],
[
73,
117
],
[
174,
121
],
[
68,
122
],
[
73,
123
],
[
174,
126
],
[
68,
127
],
[
73,
129
],
[
153,
131
],
[
68,
132
],
[
174,
138
],
[
159,
139
],
[
165,
140
],
[
158,
147
],
[
152,
153
],
[
158,
159
],
[
164,
165
],
[
173,
174
]
] | [
"import sys\nimport numpy as np\ndef sinput(): return sys.stdin.readline()\ndef iinput(): return int(sinput())\ndef imap(): return map(int, sinput().split())\ndef fmap(): return map(float, sinput().split())\ndef iarr(): return list(imap())\ndef farr(): return list(fmap())\ndef sarr(): return sinput().split()\n\nn, a = imap()\nx = np.array(iarr()) - a\nMAX = 50*50+1\n\ndp = np.zeros((n+1, 2*MAX+1)).astype(int)\ndp[0][MAX] = 1\nfor i in range(n):\n for j in range(2*MAX):\n if j-x[i] < 0 or j-x[i] > 2*MAX:\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x[i]]\nprint(dp[n][MAX]-1)",
"import sys",
"sys",
"import numpy as np",
"numpy",
"def sinput(): return sys.stdin.readline()",
"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(): return list(imap())",
"iarr",
"def farr(): return list(fmap())",
"farr",
"def sarr(): return sinput().split()",
"sarr",
"n, a = imap()",
"n",
"imap()",
"imap",
"a",
"x = np.array(iarr()) - a",
"x",
"np.array(iarr()) - a",
"np.array(iarr())",
"np.array",
"np",
"array",
"iarr()",
"iarr",
"a",
"MAX = 50*50+1",
"MAX",
"50*50+1",
"50*50",
"50",
"50",
"1",
"dp = np.zeros((n+1, 2*MAX+1)).astype(int)",
"dp",
"np.zeros((n+1, 2*MAX+1)).astype(int)",
"np.zeros((n+1, 2*MAX+1)).astype",
"np.zeros((n+1, 2*MAX+1))",
"np.zeros",
"np",
"zeros",
"(n+1, 2*MAX+1)",
"n+1",
"n",
"1",
"2*MAX+1",
"2*MAX",
"2",
"MAX",
"1",
"astype",
"int",
"dp[0][MAX] = 1",
"dp[0][MAX]",
"[0]",
"dp",
"0",
"MAX",
"1",
"for i in range(n):\n for j in range(2*MAX):\n if j-x[i] < 0 or j-x[i] > 2*MAX:\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x[i]]",
"i",
"range(n)",
"range",
"n",
"for j in range(2*MAX):\n if j-x[i] < 0 or j-x[i] > 2*MAX:\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x[i]]",
"j",
"range(2*MAX)",
"range",
"2*MAX",
"2",
"MAX",
"if j-x[i] < 0 or j-x[i] > 2*MAX:\n dp[i+1][j] = dp[i][j]\n else:\n dp[i+1][j] = dp[i][j] + dp[i][j-x[i]]",
"j-x[i] < 0 or j-x[i] > 2*MAX",
"j-x[i] < 0",
"j-x[i]",
"j",
"x[i]",
"x",
"i",
"0",
"j-x[i] > 2*MAX",
"j-x[i]",
"j",
"x[i]",
"x",
"i",
"2*MAX",
"2",
"MAX",
"dp[i+1][j] = dp[i][j]",
"dp[i+1][j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i+1][j] = dp[i][j] + dp[i][j-x[i]]",
"dp[i+1][j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"dp[i][j] + dp[i][j-x[i]]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i][j-x[i]]",
"[i]",
"dp",
"i",
"j-x[i]",
"j",
"x[i]",
"x",
"i",
"print(dp[n][MAX]-1)",
"print",
"dp[n][MAX]-1",
"dp[n][MAX]",
"[n]",
"dp",
"n",
"MAX",
"1",
"def imap(): return map(int, sinput().split())",
"def imap(): return map(int, sinput().split())",
"imap",
"a = imap()",
"imap()",
"a",
"def farr(): return list(fmap())",
"def farr(): return list(fmap())",
"farr",
"x = np.array(iarr()) - a",
"np.array(iarr()) - a",
"x",
"def fmap(): return map(float, sinput().split())",
"def fmap(): return map(float, sinput().split())",
"fmap",
"n, a = imap()",
"imap()",
"n",
"def iinput(): return int(sinput())",
"def iinput(): return int(sinput())",
"iinput",
"MAX = 50*50+1",
"50*50+1",
"MAX",
"def sarr(): return sinput().split()",
"def sarr(): return sinput().split()",
"sarr",
"def iarr(): return list(imap())",
"def iarr(): return list(imap())",
"iarr",
"dp = np.zeros((n+1, 2*MAX+1)).astype(int)",
"np.zeros((n+1, 2*MAX+1)).astype(int)",
"dp",
"def sinput(): return sys.stdin.readline()",
"def sinput(): return sys.stdin.readline()",
"sinput"
] | import sys
import numpy as np
def sinput(): return sys.stdin.readline()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(): return list(imap())
def farr(): return list(fmap())
def sarr(): return sinput().split()
n, a = imap()
x = np.array(iarr()) - a
MAX = 50*50+1
dp = np.zeros((n+1, 2*MAX+1)).astype(int)
dp[0][MAX] = 1
for i in range(n):
for j in range(2*MAX):
if j-x[i] < 0 or j-x[i] > 2*MAX:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = dp[i][j] + dp[i][j-x[i]]
print(dp[n][MAX]-1)
|
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
31,
13,
12,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
4,
18,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
2,
39,
17,
17,
13,
0,
13,
13,
0,
18,
18,
13,
17,
2,
17,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
17,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
0,
13,
18,
13,
13,
14,
40,
13,
17,
14,
40,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
2,
13,
13,
14,
40,
2,
13,
13,
2,
2,
17,
13,
17,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
2,
13,
13,
0,
13,
2,
18,
18,
13,
13,
2,
17,
13,
17,
29,
13,
14,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
172,
4
],
[
172,
17
],
[
172,
18
],
[
24,
23
],
[
167,
26
],
[
31,
28
],
[
23,
30
],
[
173,
31
],
[
39,
38
],
[
167,
42
],
[
167,
50
],
[
53,
52
],
[
62,
55
],
[
52,
57
],
[
167,
61
],
[
65,
64
],
[
167,
67
],
[
70,
69
],
[
167,
74
],
[
83,
76
],
[
52,
78
],
[
64,
80
],
[
69,
82
],
[
52,
85
],
[
64,
86
],
[
69,
87
],
[
90,
89
],
[
28,
90
],
[
64,
92
],
[
89,
95
],
[
69,
99
],
[
89,
100
],
[
109,
102
],
[
52,
104
],
[
64,
106
],
[
69,
108
],
[
52,
111
],
[
64,
112
],
[
69,
114
],
[
89,
115
],
[
69,
119
],
[
89,
120
],
[
167,
124
],
[
134,
127
],
[
52,
129
],
[
64,
131
],
[
69,
133
],
[
52,
136
],
[
64,
137
],
[
69,
139
],
[
89,
140
],
[
143,
142
],
[
52,
146
],
[
167,
147
],
[
167,
150
],
[
142,
153
],
[
169,
159
],
[
176,
161
],
[
170,
164
],
[
172,
167
],
[
169,
170
],
[
172,
173
]
] | [
"import sys\n\nn, a, *x = map(int, sys.stdin.read().split())\n\ndef main():\n for i in range(n):\n x[i] -= a\n x.sort()\n\n res = [[0] * 99*n for _ in range(n+1)]\n # res[i][49*n]を中心とする。\n res[0][49*n] = 1\n for i in range(n):\n for j in range(99*n):\n res[i+1][j] += res[i][j]\n cur = x[i]\n if cur >= 0:\n if j >= cur:\n res[i+1][j] += res[i][j-cur]\n else:\n if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ans = res[n][49*n] - 1\n return ans\n \nif __name__ == '__main__':\n ans = main()\n print(ans)",
"import sys",
"sys",
"n, a, *x = map(int, sys.stdin.read().split())",
"n",
"map(int, sys.stdin.read().split())",
"map",
"int",
"sys.stdin.read().split()",
"sys.stdin.read().split",
"sys.stdin.read()",
"sys.stdin.read",
"sys.stdin",
"sys",
"stdin",
"read",
"split",
"a",
"*x",
"x",
"def main():\n for i in range(n):\n x[i] -= a\n x.sort()\n\n res = [[0] * 99*n for _ in range(n+1)]\n # res[i][49*n]を中心とする。\n res[0][49*n] = 1\n for i in range(n):\n for j in range(99*n):\n res[i+1][j] += res[i][j]\n cur = x[i]\n if cur >= 0:\n if j >= cur:\n res[i+1][j] += res[i][j-cur]\n else:\n if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ans = res[n][49*n] - 1\n return ans\n ",
"main",
"for i in range(n):\n x[i] -= a\n ",
"i",
"range(n)",
"range",
"n",
"x[i] -= a",
"x[i]",
"x",
"i",
"a",
"x.sort()",
"x.sort",
"x",
"sort",
"[0] * 99*n for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"[0] * 99*n",
"[0] * 99",
"[0]",
"0",
"99",
"n",
"res = [[0] * 99*n for _ in range(n+1)]",
"res",
"[[0] * 99*n for _ in range(n+1)]",
"res[0][49*n] = 1",
"res[0][49*n]",
"[0]",
"res",
"0",
"49*n",
"49",
"n",
"1",
"for i in range(n):\n for j in range(99*n):\n res[i+1][j] += res[i][j]\n cur = x[i]\n if cur >= 0:\n if j >= cur:\n res[i+1][j] += res[i][j-cur]\n else:\n if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ",
"i",
"range(n)",
"range",
"n",
"for j in range(99*n):\n res[i+1][j] += res[i][j]\n cur = x[i]\n if cur >= 0:\n if j >= cur:\n res[i+1][j] += res[i][j-cur]\n else:\n if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ",
"j",
"range(99*n)",
"range",
"99*n",
"99",
"n",
"res[i+1][j] += res[i][j]",
"res[i+1][j]",
"[i+1]",
"res",
"i+1",
"i",
"1",
"j",
"res[i][j]",
"[i]",
"res",
"i",
"j",
"cur = x[i]",
"cur",
"x[i]",
"x",
"i",
"if cur >= 0:\n if j >= cur:\n res[i+1][j] += res[i][j-cur]\n else:\n if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ",
"cur >= 0",
"cur",
"0",
"if j >= cur:\n res[i+1][j] += res[i][j-cur]\n ",
"j >= cur",
"j",
"cur",
"res[i+1][j] += res[i][j-cur]",
"res[i+1][j]",
"[i+1]",
"res",
"i+1",
"i",
"1",
"j",
"res[i][j-cur]",
"[i]",
"res",
"i",
"j-cur",
"j",
"cur",
"if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ",
"j - cur <= 99 * n - 1",
"j - cur",
"j",
"cur",
"99 * n - 1",
"99 * n",
"99",
"n",
"1",
"res[i+1][j] += res[i][j-cur]",
"res[i+1][j]",
"[i+1]",
"res",
"i+1",
"i",
"1",
"j",
"res[i][j-cur]",
"[i]",
"res",
"i",
"j-cur",
"j",
"cur",
"ans = res[n][49*n] - 1",
"ans",
"res[n][49*n] - 1",
"res[n][49*n]",
"[n]",
"res",
"n",
"49*n",
"49",
"n",
"1",
"return ans",
"ans",
"if __name__ == '__main__':\n ans = main()\n print(ans)",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"ans = main()",
"ans",
"main()",
"main",
"print(ans)",
"print",
"ans",
"n, a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"n",
"ans = main()",
"main()",
"ans",
"a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"a",
"def main():\n for i in range(n):\n x[i] -= a\n x.sort()\n\n res = [[0] * 99*n for _ in range(n+1)]\n # res[i][49*n]を中心とする。\n res[0][49*n] = 1\n for i in range(n):\n for j in range(99*n):\n res[i+1][j] += res[i][j]\n cur = x[i]\n if cur >= 0:\n if j >= cur:\n res[i+1][j] += res[i][j-cur]\n else:\n if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ans = res[n][49*n] - 1\n return ans\n ",
"def main():\n for i in range(n):\n x[i] -= a\n x.sort()\n\n res = [[0] * 99*n for _ in range(n+1)]\n # res[i][49*n]を中心とする。\n res[0][49*n] = 1\n for i in range(n):\n for j in range(99*n):\n res[i+1][j] += res[i][j]\n cur = x[i]\n if cur >= 0:\n if j >= cur:\n res[i+1][j] += res[i][j-cur]\n else:\n if j - cur <= 99 * n - 1:\n res[i+1][j] += res[i][j-cur]\n \n ans = res[n][49*n] - 1\n return ans\n ",
"main"
] | import sys
n, a, *x = map(int, sys.stdin.read().split())
def main():
for i in range(n):
x[i] -= a
x.sort()
res = [[0] * 99*n for _ in range(n+1)]
# res[i][49*n]を中心とする。
res[0][49*n] = 1
for i in range(n):
for j in range(99*n):
res[i+1][j] += res[i][j]
cur = x[i]
if cur >= 0:
if j >= cur:
res[i+1][j] += res[i][j-cur]
else:
if j - cur <= 99 * n - 1:
res[i+1][j] += res[i][j-cur]
ans = res[n][49*n] - 1
return ans
if __name__ == '__main__':
ans = main()
print(ans) |
[
7,
12,
13,
0,
13,
2,
13,
13,
14,
2,
2,
13,
2,
13,
13,
17,
29,
2,
2,
13,
13,
17,
29,
2,
13,
13,
23,
13,
23,
13,
17,
17,
17,
17,
17,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
12,
2,
13,
13,
23,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
4,
13,
2,
18,
13,
17,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
5,
4
],
[
27,
6
],
[
29,
7
],
[
4,
11
],
[
27,
13
],
[
29,
14
],
[
27,
19
],
[
29,
20
],
[
27,
24
],
[
29,
25
],
[
27,
27
],
[
29,
29
],
[
52,
51
],
[
123,
53
],
[
52,
54
],
[
57,
56
],
[
123,
58
],
[
61,
60
],
[
54,
68
],
[
56,
70
],
[
73,
72
],
[
79,
78
],
[
60,
78
],
[
56,
78
],
[
72,
87
],
[
95,
90
],
[
72,
91
],
[
78,
93
],
[
72,
98
],
[
78,
101
],
[
72,
109
],
[
120,
117
]
] | [
"#\n# Written by NoKnowledgeGG @YlePhan\n# ('ω')\n#\n#import math\n#mod = 10**9+7\n#import itertools\n#import fractions\n#import numpy as np\n#mod = 10**4 + 7\ndef kiri(n,m):\n r_ = n / m\n if (r_ - (n // m)) > 0:\n return (n//m) + 1\n else:\n return (n//m)\n\n\"\"\" n! mod m 階乗\nmod = 1e9 + 7\nN = 10000000\nfac = [0] * N\ndef ini():\n fac[0] = 1 % mod\n for i in range(1,N):\n fac[i] = fac[i-1] * i % mod\"\"\"\n\n\"\"\"mod = 1e9+7\nN = 10000000\npw = [0] * N\ndef ini(c):\n pw[0] = 1 % mod\n for i in range(1,N):\n pw[i] = pw[i-1] * c % mod\"\"\"\n\n\"\"\"\ndef YEILD():\n yield 'one'\n yield 'two'\n yield 'three'\ngenerator = YEILD()\nprint(next(generator))\nprint(next(generator))\nprint(next(generator))\n\"\"\"\n\"\"\"def gcd_(a,b):\n if b == 0:#結局はc,0の最大公約数はcなのに\n return a\n return gcd_(a,a % b) # a = p * b + q\"\"\"\n\"\"\"def extgcd(a,b,x,y):\n d = a\n if b!=0:\n d = extgcd(b,a%b,y,x)\n y -= (a//b) * x\n print(x,y)\n else:\n x = 1\n y = 0\n return d\"\"\"\n\n\ndef readInts():\n return list(map(int,input().split()))\n\ndef main():\n n,a = readInts()\n \n X = readInts()\n \n X = list(map(lambda i: i-a, X))# lambda iに、 i - aという演算のもと Xから入れる\n # ここで、平均が8になるもの key = 0の時が答えになる。\n # だからこそ 答えで dp[0] - 1 するのはこのため\n \n dp = {0:1} \n \n for i in X:\n for k,v in list(dp.items()): # key,valueをそれぞれ抽出\n dp[i+k] = dp.get(i+k, 0) + v\n #\n # get(なんか) なんかに入ってる辞書のvalueが返ってくる\n # 無かったら、get(なんか,〇)で、〇に入ってるので辞書が更新される\n # \n # print(dp)\n #{0: 6, 1: 6, 2: 2, -1: 2}\n # 負の数にも対応している\n print(dp[0]-1)\n \nif __name__ == '__main__':\n main()",
"def kiri(n,m):\n r_ = n / m\n if (r_ - (n // m)) > 0:\n return (n//m) + 1\n else:\n return (n//m)",
"kiri",
"r_ = n / m",
"r_",
"n / m",
"n",
"m",
"if (r_ - (n // m)) > 0:\n return (n//m) + 1\n else:\n return (n//m)",
"(r_ - (n // m)) > 0",
"r_ - (n // m)",
"r_",
"n // m",
"n",
"m",
"0",
"return (n//m) + 1",
"(n//m) + 1",
"n//m",
"n",
"m",
"1",
"return (n//m)",
"n//m",
"n",
"m",
"n",
"n",
"m",
"m",
"\"\"\" n! mod m 階乗\nmod = 1e9 + 7\nN = 10000000\nfac = [0] * N\ndef ini():\n fac[0] = 1 % mod\n for i in range(1,N):\n fac[i] = fac[i-1] * i % mod\"\"\"",
"\"\"\"mod = 1e9+7\nN = 10000000\npw = [0] * N\ndef ini(c):\n pw[0] = 1 % mod\n for i in range(1,N):\n pw[i] = pw[i-1] * c % mod\"\"\"",
"\"\"\"\ndef YEILD():\n yield 'one'\n yield 'two'\n yield 'three'\ngenerator = YEILD()\nprint(next(generator))\nprint(next(generator))\nprint(next(generator))\n\"\"\"",
"\"\"\"def gcd_(a,b):\n if b == 0:#結局はc,0の最大公約数はcなのに\n return a\n return gcd_(a,a % b) # a = p * b + q\"\"\"",
"\"\"\"def extgcd(a,b,x,y):\n d = a\n if b!=0:\n d = extgcd(b,a%b,y,x)\n y -= (a//b) * x\n print(x,y)\n else:\n x = 1\n y = 0\n return d\"\"\"",
"def readInts():\n return list(map(int,input().split()))",
"readInts",
"return list(map(int,input().split()))",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def main():\n n,a = readInts()\n \n X = readInts()\n \n X = list(map(lambda i: i-a, X))# lambda iに、 i - aという演算のもと Xから入れる\n # ここで、平均が8になるもの key = 0の時が答えになる。\n # だからこそ 答えで dp[0] - 1 するのはこのため\n \n dp = {0:1} \n \n for i in X:\n for k,v in list(dp.items()): # key,valueをそれぞれ抽出\n dp[i+k] = dp.get(i+k, 0) + v\n #\n # get(なんか) なんかに入ってる辞書のvalueが返ってくる\n # 無かったら、get(なんか,〇)で、〇に入ってるので辞書が更新される\n # \n # print(dp)\n #{0: 6, 1: 6, 2: 2, -1: 2}\n # 負の数にも対応している\n print(dp[0]-1)\n ",
"main",
"n,a = readInts()",
"n",
"readInts()",
"readInts",
"a",
"X = readInts()",
"X",
"readInts()",
"readInts",
"X = list(map(lambda i: i-a, X))",
"X",
"list(map(lambda i: i-a, X))",
"list",
"map(lambda i: i-a, X)",
"map",
"lambda i: i-a",
"i-a",
"i",
"a",
"i",
"X",
"dp = {0:1}",
"dp",
"{0:1}",
"0",
"0",
"1",
"for i in X:\n for k,v in list(dp.items()): # key,valueをそれぞれ抽出\n dp[i+k] = dp.get(i+k, 0) + v\n #\n # get(なんか) なんかに入ってる辞書のvalueが返ってくる\n # 無かったら、get(なんか,〇)で、〇に入ってるので辞書が更新される\n # \n # print(dp)\n #{0: 6, 1: 6, 2: 2, -1: 2}\n # 負の数にも対応している\n ",
"i",
"X",
"for k,v in list(dp.items()): # key,valueをそれぞれ抽出\n dp[i+k] = dp.get(i+k, 0) + v\n #\n # get(なんか) なんかに入ってる辞書のvalueが返ってくる\n # 無かったら、get(なんか,〇)で、〇に入ってるので辞書が更新される\n # \n # print(dp)\n #{0: 6, 1: 6, 2: 2, -1: 2}\n # 負の数にも対応している\n ",
"k",
"v",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"dp[i+k] = dp.get(i+k, 0) + v",
"dp[i+k]",
"dp",
"i+k",
"i",
"k",
"dp.get(i+k, 0) + v",
"dp.get(i+k, 0)",
"dp.get",
"dp",
"get",
"i+k",
"i",
"k",
"0",
"v",
"print(dp[0]-1)",
"print",
"dp[0]-1",
"dp[0]",
"dp",
"0",
"1",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n n,a = readInts()\n \n X = readInts()\n \n X = list(map(lambda i: i-a, X))# lambda iに、 i - aという演算のもと Xから入れる\n # ここで、平均が8になるもの key = 0の時が答えになる。\n # だからこそ 答えで dp[0] - 1 するのはこのため\n \n dp = {0:1} \n \n for i in X:\n for k,v in list(dp.items()): # key,valueをそれぞれ抽出\n dp[i+k] = dp.get(i+k, 0) + v\n #\n # get(なんか) なんかに入ってる辞書のvalueが返ってくる\n # 無かったら、get(なんか,〇)で、〇に入ってるので辞書が更新される\n # \n # print(dp)\n #{0: 6, 1: 6, 2: 2, -1: 2}\n # 負の数にも対応している\n print(dp[0]-1)\n ",
"def main():\n n,a = readInts()\n \n X = readInts()\n \n X = list(map(lambda i: i-a, X))# lambda iに、 i - aという演算のもと Xから入れる\n # ここで、平均が8になるもの key = 0の時が答えになる。\n # だからこそ 答えで dp[0] - 1 するのはこのため\n \n dp = {0:1} \n \n for i in X:\n for k,v in list(dp.items()): # key,valueをそれぞれ抽出\n dp[i+k] = dp.get(i+k, 0) + v\n #\n # get(なんか) なんかに入ってる辞書のvalueが返ってくる\n # 無かったら、get(なんか,〇)で、〇に入ってるので辞書が更新される\n # \n # print(dp)\n #{0: 6, 1: 6, 2: 2, -1: 2}\n # 負の数にも対応している\n print(dp[0]-1)\n ",
"main",
"def readInts():\n return list(map(int,input().split()))",
"def readInts():\n return list(map(int,input().split()))",
"readInts",
"def kiri(n,m):\n r_ = n / m\n if (r_ - (n // m)) > 0:\n return (n//m) + 1\n else:\n return (n//m)",
"def kiri(n,m):\n r_ = n / m\n if (r_ - (n // m)) > 0:\n return (n//m) + 1\n else:\n return (n//m)",
"kiri"
] | #
# Written by NoKnowledgeGG @YlePhan
# ('ω')
#
#import math
#mod = 10**9+7
#import itertools
#import fractions
#import numpy as np
#mod = 10**4 + 7
def kiri(n,m):
r_ = n / m
if (r_ - (n // m)) > 0:
return (n//m) + 1
else:
return (n//m)
""" n! mod m 階乗
mod = 1e9 + 7
N = 10000000
fac = [0] * N
def ini():
fac[0] = 1 % mod
for i in range(1,N):
fac[i] = fac[i-1] * i % mod"""
"""mod = 1e9+7
N = 10000000
pw = [0] * N
def ini(c):
pw[0] = 1 % mod
for i in range(1,N):
pw[i] = pw[i-1] * c % mod"""
"""
def YEILD():
yield 'one'
yield 'two'
yield 'three'
generator = YEILD()
print(next(generator))
print(next(generator))
print(next(generator))
"""
"""def gcd_(a,b):
if b == 0:#結局はc,0の最大公約数はcなのに
return a
return gcd_(a,a % b) # a = p * b + q"""
"""def extgcd(a,b,x,y):
d = a
if b!=0:
d = extgcd(b,a%b,y,x)
y -= (a//b) * x
print(x,y)
else:
x = 1
y = 0
return d"""
def readInts():
return list(map(int,input().split()))
def main():
n,a = readInts()
X = readInts()
X = list(map(lambda i: i-a, X))# lambda iに、 i - aという演算のもと Xから入れる
# ここで、平均が8になるもの key = 0の時が答えになる。
# だからこそ 答えで dp[0] - 1 するのはこのため
dp = {0:1}
for i in X:
for k,v in list(dp.items()): # key,valueをそれぞれ抽出
dp[i+k] = dp.get(i+k, 0) + v
#
# get(なんか) なんかに入ってる辞書のvalueが返ってくる
# 無かったら、get(なんか,〇)で、〇に入ってるので辞書が更新される
#
# print(dp)
#{0: 6, 1: 6, 2: 2, -1: 2}
# 負の数にも対応している
print(dp[0]-1)
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
2,
39,
17,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
40,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
17,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13
] | [
[
163,
2
],
[
163,
11
],
[
178,
13
],
[
175,
28
],
[
33,
32
],
[
164,
36
],
[
166,
41
],
[
51,
44
],
[
167,
47
],
[
54,
53
],
[
164,
58
],
[
62,
61
],
[
164,
65
],
[
69,
68
],
[
176,
72
],
[
179,
77
],
[
53,
78
],
[
68,
79
],
[
88,
81
],
[
167,
84
],
[
53,
85
],
[
61,
86
],
[
68,
87
],
[
167,
91
],
[
53,
93
],
[
61,
95
],
[
68,
96
],
[
61,
99
],
[
109,
102
],
[
167,
105
],
[
53,
106
],
[
61,
107
],
[
68,
108
],
[
167,
113
],
[
53,
115
],
[
61,
117
],
[
68,
118
],
[
167,
122
],
[
53,
124
],
[
61,
127
],
[
68,
130
],
[
179,
132
],
[
53,
133
],
[
172,
135
],
[
139,
138
],
[
164,
143
],
[
169,
146
],
[
167,
150
],
[
138,
152
],
[
161,
154
],
[
138,
155
],
[
170,
158
],
[
173,
158
],
[
163,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
]
] | [
"n, a = map(int, input().split())\nx = [0] + list(map(int, input().split()))\nnx = 2501\n\n# DP: x1からxjまでの間でk枚を選んで合計がsになる組み合わせの数\ndp = [ [ [0 for s in range(nx+1)] for k in range(n+1)] for j in range(n+1)]\ndp[0][0][0] = 1\n\nfor j in range(1, n+1):\n for k in range(n+1):\n for s in range(nx+1):\n if x[j] > s:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n#print(dp)\nans = 0\nfor k in range(1, n+1):\n ans += dp[-1][k][a * k]\n\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = [0] + list(map(int, input().split()))",
"x",
"[0] + list(map(int, input().split()))",
"[0]",
"0",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"nx = 2501",
"nx",
"2501",
"[ [0 for s in range(nx+1)] for k in range(n+1)] for j in range(n+1)",
"for j in range(n+1)",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for j in range(n+1)",
"[ [0 for s in range(nx+1)] for k in range(n+1)]",
"dp = [ [ [0 for s in range(nx+1)] for k in range(n+1)] for j in range(n+1)]",
"dp",
"[ [ [0 for s in range(nx+1)] for k in range(n+1)] for j in range(n+1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for j in range(1, n+1):\n for k in range(n+1):\n for s in range(nx+1):\n if x[j] > s:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n#print(dp)",
"j",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for k in range(n+1):\n for s in range(nx+1):\n if x[j] > s:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n#print(dp)",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for s in range(nx+1):\n if x[j] > s:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n#print(dp)",
"s",
"range(nx+1)",
"range",
"nx+1",
"nx",
"1",
"if x[j] > s:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n#print(dp)",
"x[j] > s",
"x[j]",
"x",
"j",
"s",
"dp[j][k][s] = dp[j-1][k][s]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j-1][k][s]",
"[k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"s",
"elif k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]\n#print(dp)",
"k >= 1",
"k",
"1",
"dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]",
"dp[j-1][k][s]",
"[k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"s",
"dp[j-1][k-1][s-x[j]]",
"[k-1]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"s-x[j]",
"s",
"x[j]",
"x",
"j",
"ans = 0",
"ans",
"0",
"for k in range(1, n+1):\n ans += dp[-1][k][a * k]",
"k",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[-1][k][a * k]",
"ans",
"dp[-1][k][a * k]",
"[k]",
"[-1]",
"dp",
"-1",
"k",
"a * k",
"a",
"k",
"print(ans)",
"print",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"dp = [ [ [0 for s in range(nx+1)] for k in range(n+1)] for j in range(n+1)]",
"[ [ [0 for s in range(nx+1)] for k in range(n+1)] for j in range(n+1)]",
"dp",
"ans += dp[-1][k][a * k]",
"dp[-1][k][a * k]",
"ans",
"ans = 0",
"0",
"ans",
"nx = 2501",
"2501",
"nx",
"x = [0] + list(map(int, input().split()))",
"[0] + list(map(int, input().split()))",
"x"
] | n, a = map(int, input().split())
x = [0] + list(map(int, input().split()))
nx = 2501
# DP: x1からxjまでの間でk枚を選んで合計がsになる組み合わせの数
dp = [ [ [0 for s in range(nx+1)] for k in range(n+1)] for j in range(n+1)]
dp[0][0][0] = 1
for j in range(1, n+1):
for k in range(n+1):
for s in range(nx+1):
if x[j] > s:
dp[j][k][s] = dp[j-1][k][s]
elif k >= 1:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j]]
#print(dp)
ans = 0
for k in range(1, n+1):
ans += dp[-1][k][a * k]
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
40,
13,
17,
40,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
191,
2
],
[
191,
11
],
[
176,
13
],
[
194,
25
],
[
177,
30
],
[
192,
31
],
[
35,
34
],
[
183,
38
],
[
179,
43
],
[
53,
46
],
[
180,
49
],
[
56,
55
],
[
183,
60
],
[
64,
63
],
[
55,
67
],
[
71,
70
],
[
195,
75
],
[
63,
76
],
[
70,
80
],
[
177,
82
],
[
55,
84
],
[
94,
87
],
[
180,
90
],
[
55,
91
],
[
63,
92
],
[
70,
93
],
[
180,
97
],
[
55,
99
],
[
63,
101
],
[
70,
102
],
[
63,
106
],
[
70,
109
],
[
177,
111
],
[
55,
113
],
[
123,
116
],
[
180,
119
],
[
55,
120
],
[
63,
121
],
[
70,
122
],
[
180,
127
],
[
55,
129
],
[
63,
131
],
[
70,
132
],
[
180,
136
],
[
55,
138
],
[
63,
141
],
[
70,
144
],
[
177,
146
],
[
55,
148
],
[
185,
151
],
[
155,
154
],
[
183,
159
],
[
188,
162
],
[
180,
166
],
[
183,
167
],
[
154,
168
],
[
154,
170
],
[
192,
171
],
[
189,
174
],
[
186,
174
],
[
176,
177
],
[
179,
180
],
[
191,
183
],
[
185,
186
],
[
188,
189
],
[
191,
192
],
[
194,
195
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\n# 初期化\nmax_num = max(max(x), a)\ndp = [[[0 for _ in range(max_num * n + 1)]\n for _ in range(n + 1)] for _ in range(n + 1)]\ndp[0][0][0] = 1\n\nfor j in range(1, n+1):\n for k in range(j+1):\n for s in range(max_num * k + 1):\n if s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n\nans = 0\nfor k in range(1, n+1):\n ans += dp[n][k][k*a]\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"max_num = max(max(x), a)",
"max_num",
"max(max(x), a)",
"max",
"max(x)",
"max",
"x",
"a",
"[[0 for _ in range(max_num * n + 1)]\n for _ in range(n + 1)] for _ in range(n + 1)",
"for _ in range(n + 1)",
"_",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for _ in range(n + 1)",
"[[0 for _ in range(max_num * n + 1)]\n for _ in range(n + 1)]",
"dp = [[[0 for _ in range(max_num * n + 1)]\n for _ in range(n + 1)] for _ in range(n + 1)]",
"dp",
"[[[0 for _ in range(max_num * n + 1)]\n for _ in range(n + 1)] for _ in range(n + 1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for j in range(1, n+1):\n for k in range(j+1):\n for s in range(max_num * k + 1):\n if s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"j",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for k in range(j+1):\n for s in range(max_num * k + 1):\n if s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"k",
"range(j+1)",
"range",
"j+1",
"j",
"1",
"for s in range(max_num * k + 1):\n if s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"s",
"range(max_num * k + 1)",
"range",
"max_num * k + 1",
"max_num * k",
"max_num",
"k",
"1",
"if s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"s < x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = dp[j-1][k][s]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j-1][k][s]",
"[k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"s",
"elif k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"k >= 1 and s >= x[j-1]",
"k >= 1",
"k",
"1",
"s >= x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"dp[j-1][k][s]",
"[k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"s",
"dp[j-1][k-1][s-x[j-1]]",
"[k-1]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"s-x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"ans = 0",
"ans",
"0",
"for k in range(1, n+1):\n ans += dp[n][k][k*a]",
"k",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[n][k][k*a]",
"ans",
"dp[n][k][k*a]",
"[k]",
"[n]",
"dp",
"n",
"k",
"k*a",
"k",
"a",
"print(ans)",
"print",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [[[0 for _ in range(max_num * n + 1)]\n for _ in range(n + 1)] for _ in range(n + 1)]",
"[[[0 for _ in range(max_num * n + 1)]\n for _ in range(n + 1)] for _ in range(n + 1)]",
"dp",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"ans = 0",
"0",
"ans",
"ans += dp[n][k][k*a]",
"dp[n][k][k*a]",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"max_num = max(max(x), a)",
"max(max(x), a)",
"max_num"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
# 初期化
max_num = max(max(x), a)
dp = [[[0 for _ in range(max_num * n + 1)]
for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for j in range(1, n+1):
for k in range(j+1):
for s in range(max_num * k + 1):
if s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
ans = 0
for k in range(1, n+1):
ans += dp[n][k][k*a]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
17,
0,
13,
2,
39,
17,
17,
0,
13,
39,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
13,
14,
2,
13,
17,
0,
13,
17,
14,
2,
13,
17,
4,
18,
13,
13,
13,
4,
18,
13,
13,
40,
13,
28,
13,
13,
28,
13,
4,
13,
17,
17,
17,
14,
40,
18,
13,
13,
17,
0,
18,
13,
2,
13,
13,
18,
13,
13,
0,
18,
13,
13,
17,
28,
13,
13,
28,
13,
4,
13,
17,
17,
17,
14,
40,
18,
13,
13,
17,
0,
18,
13,
2,
13,
13,
18,
13,
13,
0,
18,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
17,
13,
0,
13,
2,
4,
13,
17,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13
] | [
[
177,
2
],
[
177,
11
],
[
189,
13
],
[
204,
25
],
[
183,
31
],
[
192,
37
],
[
210,
40
],
[
186,
43
],
[
47,
46
],
[
175,
49
],
[
213,
51
],
[
190,
54
],
[
46,
55
],
[
178,
56
],
[
214,
59
],
[
180,
62
],
[
214,
66
],
[
193,
70
],
[
214,
72
],
[
211,
75
],
[
214,
78
],
[
81,
80
],
[
193,
80
],
[
84,
83
],
[
205,
92
],
[
83,
93
],
[
101,
96
],
[
205,
97
],
[
83,
99
],
[
80,
100
],
[
205,
102
],
[
83,
103
],
[
108,
105
],
[
205,
106
],
[
80,
107
],
[
111,
110
],
[
211,
110
],
[
114,
113
],
[
184,
122
],
[
113,
123
],
[
131,
126
],
[
184,
127
],
[
113,
129
],
[
110,
130
],
[
184,
132
],
[
113,
133
],
[
138,
135
],
[
184,
136
],
[
110,
137
],
[
198,
140
],
[
144,
143
],
[
201,
148
],
[
105,
150
],
[
205,
151
],
[
143,
152
],
[
135,
153
],
[
184,
154
],
[
143,
155
],
[
195,
157
],
[
181,
161
],
[
187,
161
],
[
207,
163
],
[
181,
168
],
[
187,
168
],
[
208,
172
],
[
196,
172
],
[
202,
172
],
[
199,
172
],
[
177,
175
],
[
177,
178
],
[
180,
181
],
[
183,
184
],
[
186,
187
],
[
189,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
]
] | [
"n,a = map(int,input().split())\nx = list(map(int,input().split()))\n\ndpp = [0]*3000\ndpm = [0]*3000\n\np = []\nm = []\nn0 = 0\n\nfor i in range(n):\n x1 = x[i] - a\n if x1 == 0:\n n0 += 1\n elif x1 > 0:\n p.append(x1)\n else:\n m.append(-x1)\n\nfor i in p:\n for j in range(2600,0,-1):\n if dpp[j] >= 1:\n dpp[j+i] += dpp[j]\n dpp[i] += 1\n\nfor i in m:\n for j in range(2600,0,-1):\n if dpm[j] >= 1:\n dpm[j+i] += dpm[j]\n dpm[i] += 1\n\nans = 0\n\nfor i in range(3000):\n ans += dpp[i] * dpm[i]\n\nans *= pow(2,n0)\nans += pow(2,n0) - 1\n\nprint(ans)",
"n,a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"dpp = [0]*3000",
"dpp",
"[0]*3000",
"[0]",
"0",
"3000",
"dpm = [0]*3000",
"dpm",
"[0]*3000",
"[0]",
"0",
"3000",
"p = []",
"p",
"[]",
"m = []",
"m",
"[]",
"n0 = 0",
"n0",
"0",
"for i in range(n):\n x1 = x[i] - a\n if x1 == 0:\n n0 += 1\n elif x1 > 0:\n p.append(x1)\n else:\n m.append(-x1)",
"i",
"range(n)",
"range",
"n",
"x1 = x[i] - a",
"x1",
"x[i] - a",
"x[i]",
"x",
"i",
"a",
"if x1 == 0:\n n0 += 1\n elif x1 > 0:\n p.append(x1)\n else:\n m.append(-x1)",
"x1 == 0",
"x1",
"0",
"n0 += 1",
"n0",
"1",
"elif x1 > 0:\n p.append(x1)\n ",
"x1 > 0",
"x1",
"0",
"p.append(x1)",
"p.append",
"p",
"append",
"x1",
"m.append(-x1)",
"m.append",
"m",
"append",
"-x1",
"x1",
"for i in p:\n for j in range(2600,0,-1):\n if dpp[j] >= 1:\n dpp[j+i] += dpp[j]\n dpp[i] += 1",
"i",
"p",
"for j in range(2600,0,-1):\n if dpp[j] >= 1:\n dpp[j+i] += dpp[j]\n ",
"j",
"range(2600,0,-1)",
"range",
"2600",
"0",
"-1",
"if dpp[j] >= 1:\n dpp[j+i] += dpp[j]\n ",
"dpp[j] >= 1",
"dpp[j]",
"dpp",
"j",
"1",
"dpp[j+i] += dpp[j]",
"dpp[j+i]",
"dpp",
"j+i",
"j",
"i",
"dpp[j]",
"dpp",
"j",
"dpp[i] += 1",
"dpp[i]",
"dpp",
"i",
"1",
"for i in m:\n for j in range(2600,0,-1):\n if dpm[j] >= 1:\n dpm[j+i] += dpm[j]\n dpm[i] += 1",
"i",
"m",
"for j in range(2600,0,-1):\n if dpm[j] >= 1:\n dpm[j+i] += dpm[j]\n ",
"j",
"range(2600,0,-1)",
"range",
"2600",
"0",
"-1",
"if dpm[j] >= 1:\n dpm[j+i] += dpm[j]\n ",
"dpm[j] >= 1",
"dpm[j]",
"dpm",
"j",
"1",
"dpm[j+i] += dpm[j]",
"dpm[j+i]",
"dpm",
"j+i",
"j",
"i",
"dpm[j]",
"dpm",
"j",
"dpm[i] += 1",
"dpm[i]",
"dpm",
"i",
"1",
"ans = 0",
"ans",
"0",
"for i in range(3000):\n ans += dpp[i] * dpm[i]",
"i",
"range(3000)",
"range",
"3000",
"ans += dpp[i] * dpm[i]",
"ans",
"dpp[i] * dpm[i]",
"dpp[i]",
"dpp",
"i",
"dpm[i]",
"dpm",
"i",
"ans *= pow(2,n0)",
"ans",
"pow(2,n0)",
"pow",
"2",
"n0",
"ans += pow(2,n0) - 1",
"ans",
"pow(2,n0) - 1",
"pow(2,n0)",
"pow",
"2",
"n0",
"1",
"print(ans)",
"print",
"ans",
"n,a = map(int,input().split())",
"map(int,input().split())",
"n",
"a = map(int,input().split())",
"map(int,input().split())",
"a",
"n0 += 1",
"1",
"n0",
"dpm = [0]*3000",
"[0]*3000",
"dpm",
"n0 = 0",
"0",
"n0",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"p = []",
"[]",
"p",
"ans *= pow(2,n0)",
"pow(2,n0)",
"ans",
"ans = 0",
"0",
"ans",
"ans += dpp[i] * dpm[i]",
"dpp[i] * dpm[i]",
"ans",
"dpp = [0]*3000",
"[0]*3000",
"dpp",
"ans += pow(2,n0) - 1",
"pow(2,n0) - 1",
"ans",
"m = []",
"[]",
"m",
"x1 = x[i] - a",
"x[i] - a",
"x1"
] | n,a = map(int,input().split())
x = list(map(int,input().split()))
dpp = [0]*3000
dpm = [0]*3000
p = []
m = []
n0 = 0
for i in range(n):
x1 = x[i] - a
if x1 == 0:
n0 += 1
elif x1 > 0:
p.append(x1)
else:
m.append(-x1)
for i in p:
for j in range(2600,0,-1):
if dpp[j] >= 1:
dpp[j+i] += dpp[j]
dpp[i] += 1
for i in m:
for j in range(2600,0,-1):
if dpm[j] >= 1:
dpm[j+i] += dpm[j]
dpm[i] += 1
ans = 0
for i in range(3000):
ans += dpp[i] * dpm[i]
ans *= pow(2,n0)
ans += pow(2,n0) - 1
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
17,
14,
2,
40,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
2,
40,
13,
17,
40,
13,
17,
40,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
17,
13
] | [
[
207,
2
],
[
207,
11
],
[
213,
13
],
[
210,
25
],
[
214,
30
],
[
205,
31
],
[
35,
34
],
[
208,
38
],
[
219,
43
],
[
47,
46
],
[
208,
50
],
[
54,
53
],
[
208,
57
],
[
61,
60
],
[
208,
65
],
[
211,
66
],
[
46,
72
],
[
53,
75
],
[
60,
78
],
[
88,
81
],
[
220,
84
],
[
46,
85
],
[
53,
86
],
[
60,
87
],
[
46,
92
],
[
60,
95
],
[
214,
97
],
[
46,
99
],
[
109,
102
],
[
220,
105
],
[
46,
106
],
[
53,
107
],
[
60,
108
],
[
220,
112
],
[
46,
114
],
[
53,
116
],
[
60,
117
],
[
46,
122
],
[
53,
125
],
[
60,
128
],
[
214,
130
],
[
46,
132
],
[
142,
135
],
[
220,
138
],
[
46,
139
],
[
53,
140
],
[
60,
141
],
[
220,
146
],
[
46,
148
],
[
53,
150
],
[
60,
151
],
[
220,
155
],
[
46,
157
],
[
53,
160
],
[
60,
163
],
[
214,
165
],
[
46,
167
],
[
177,
170
],
[
220,
173
],
[
46,
174
],
[
53,
175
],
[
60,
176
],
[
222,
179
],
[
183,
182
],
[
208,
187
],
[
216,
190
],
[
220,
194
],
[
208,
195
],
[
182,
196
],
[
182,
198
],
[
205,
199
],
[
217,
202
],
[
223,
202
],
[
207,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
219,
220
],
[
222,
223
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\nX = max(max(x), a)\n#dp = [[[0]*(n*X+1) for _ in range(X+1)] for i in range(n+1)]\ndp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]\n\nfor j in range(n+1):\n for k in range(n+1):\n for s in range(n*X+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s] = 0\nans = 0\nfor k in range(1,n+1):\n ans += dp[n][k][k*a]\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"X = max(max(x), a)",
"X",
"max(max(x), a)",
"max",
"max(x)",
"max",
"x",
"a",
"[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[[0]*(n*X+1) for _ in range(n+1)]",
"dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"dp",
"[[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"for j in range(n+1):\n for k in range(n+1):\n for s in range(n*X+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s] = 0",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for k in range(n+1):\n for s in range(n*X+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s] = 0",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for s in range(n*X+1):\n if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s] = 0",
"s",
"range(n*X+1)",
"range",
"n*X+1",
"n*X",
"n",
"X",
"1",
"if j == 0 and k == 0 and s == 0:\n dp[j][k][s] = 1\n elif j >= 1 and s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n elif j >= 1 and k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:\n dp[j][k][s] = 0",
"j == 0 and k == 0 and s == 0",
"j == 0 and k == 0",
"j == 0",
"j",
"0",
"k == 0",
"k",
"0",
"s == 0",
"s",
"0",
"dp[j][k][s] = 1",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"1",
"elif j >= 1 and s < x[j-1]:\n dp[j][k][s] = dp[j-1][k][s]\n ",
"j >= 1 and s < x[j-1]",
"j >= 1",
"j",
"1",
"s < x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = dp[j-1][k][s]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j-1][k][s]",
"[k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"s",
"elif j >= 1 and k >= 1 and s >= x[j-1]:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n ",
"j >= 1 and k >= 1 and s >= x[j-1]",
"j >= 1 and k >= 1",
"j >= 1",
"j",
"1",
"k >= 1",
"k",
"1",
"s >= x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]",
"dp[j-1][k][s]",
"[k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"s",
"dp[j-1][k-1][s-x[j-1]]",
"[k-1]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"s-x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][k][s] = 0",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"0",
"ans = 0",
"ans",
"0",
"for k in range(1,n+1):\n ans += dp[n][k][k*a]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[n][k][k*a]",
"ans",
"dp[n][k][k*a]",
"[k]",
"[n]",
"dp",
"n",
"k",
"k*a",
"k",
"a",
"print(ans)",
"print",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"X = max(max(x), a)",
"max(max(x), a)",
"X",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"ans += dp[n][k][k*a]",
"dp[n][k][k*a]",
"ans",
"dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"[[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]",
"dp",
"ans = 0",
"0",
"ans"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
X = max(max(x), a)
#dp = [[[0]*(n*X+1) for _ in range(X+1)] for i in range(n+1)]
dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]
for j in range(n+1):
for k in range(n+1):
for s in range(n*X+1):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif j >= 1 and k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s] = 0
ans = 0
for k in range(1,n+1):
ans += dp[n][k][k*a]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
39,
28,
13,
4,
13,
17,
4,
18,
13,
13,
2,
39,
17,
17,
0,
18,
18,
13,
17,
17,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
13,
0,
13,
39,
28,
13,
4,
13,
17,
0,
13,
4,
18,
18,
13,
13,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
17,
28,
13,
4,
13,
17,
14,
2,
2,
40,
2,
13,
17,
17,
40,
2,
13,
13,
17,
2,
18,
18,
13,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
28,
13,
4,
13,
17,
14,
2,
2,
40,
13,
17,
2,
2,
13,
13,
17,
2,
2,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
171,
2
],
[
171,
11
],
[
162,
13
],
[
17,
16
],
[
163,
22
],
[
34,
29
],
[
163,
31
],
[
156,
36
],
[
49,
48
],
[
157,
48
],
[
177,
51
],
[
55,
54
],
[
174,
59
],
[
163,
63
],
[
54,
64
],
[
178,
68
],
[
175,
70
],
[
73,
72
],
[
78,
77
],
[
72,
86
],
[
77,
91
],
[
48,
92
],
[
178,
97
],
[
72,
98
],
[
77,
99
],
[
111,
102
],
[
163,
104
],
[
72,
106
],
[
77,
109
],
[
48,
110
],
[
178,
113
],
[
72,
114
],
[
77,
115
],
[
165,
117
],
[
121,
120
],
[
126,
125
],
[
120,
133
],
[
125,
137
],
[
120,
138
],
[
125,
142
],
[
120,
143
],
[
169,
144
],
[
159,
146
],
[
163,
149
],
[
120,
150
],
[
125,
151
],
[
160,
154
],
[
166,
154
],
[
156,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
],
[
171,
169
],
[
171,
172
],
[
174,
175
],
[
177,
178
]
] | [
"\nN,A = map(int,input().split())\n\nlis = []\n\nfor i in range(51):\n lis.append([0] * 2501)\n\nlis[0][0] = 1\n\nX = list(map(int,input().split()))\n\n\nfor x in X:\n\n nlis = []\n for k in range(51):\n new = lis[k].copy()\n nlis.append(new)\n\n for i in range(51):\n\n for j in range(2501):\n\n if i+1 <= 50 and j+x <= 2500 and nlis[i][j] > 0:\n\n lis[i+1][j+x] += nlis[i][j]\n\nans = 0\nfor i in range(51):\n\n for j in range(2501):\n\n if i != 0 and j % i == 0 and j // i == A:\n #print (i,j,lis[i][j])\n ans += lis[i][j]\n\nprint (ans)",
"N,A = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"lis = []",
"lis",
"[]",
"for i in range(51):\n lis.append([0] * 2501)",
"i",
"range(51)",
"range",
"51",
"lis.append([0] * 2501)",
"lis.append",
"lis",
"append",
"[0] * 2501",
"[0]",
"0",
"2501",
"lis[0][0] = 1",
"lis[0][0]",
"[0]",
"lis",
"0",
"0",
"1",
"X = list(map(int,input().split()))",
"X",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in X:\n\n nlis = []\n for k in range(51):\n new = lis[k].copy()\n nlis.append(new)\n\n for i in range(51):\n\n for j in range(2501):\n\n if i+1 <= 50 and j+x <= 2500 and nlis[i][j] > 0:\n\n lis[i+1][j+x] += nlis[i][j]",
"x",
"X",
"nlis = []",
"nlis",
"[]",
"for k in range(51):\n new = lis[k].copy()\n nlis.append(new)\n\n ",
"k",
"range(51)",
"range",
"51",
"new = lis[k].copy()",
"new",
"lis[k].copy()",
"[k].copy",
"[k]",
"lis",
"k",
"copy",
"nlis.append(new)",
"nlis.append",
"nlis",
"append",
"new",
"for i in range(51):\n\n for j in range(2501):\n\n if i+1 <= 50 and j+x <= 2500 and nlis[i][j] > 0:\n\n lis[i+1][j+x] += nlis[i][j]",
"i",
"range(51)",
"range",
"51",
"for j in range(2501):\n\n if i+1 <= 50 and j+x <= 2500 and nlis[i][j] > 0:\n\n lis[i+1][j+x] += nlis[i][j]",
"j",
"range(2501)",
"range",
"2501",
"if i+1 <= 50 and j+x <= 2500 and nlis[i][j] > 0:\n\n lis[i+1][j+x] += nlis[i][j]",
"i+1 <= 50 and j+x <= 2500 and nlis[i][j] > 0",
"i+1 <= 50 and j+x <= 2500",
"i+1 <= 50",
"i+1",
"i",
"1",
"50",
"j+x <= 2500",
"j+x",
"j",
"x",
"2500",
"nlis[i][j] > 0",
"nlis[i][j]",
"[i]",
"nlis",
"i",
"j",
"0",
"lis[i+1][j+x] += nlis[i][j]",
"lis[i+1][j+x]",
"[i+1]",
"lis",
"i+1",
"i",
"1",
"j+x",
"j",
"x",
"nlis[i][j]",
"[i]",
"nlis",
"i",
"j",
"ans = 0",
"ans",
"0",
"for i in range(51):\n\n for j in range(2501):\n\n if i != 0 and j % i == 0 and j // i == A:\n #print (i,j,lis[i][j])\n ans += lis[i][j]",
"i",
"range(51)",
"range",
"51",
"for j in range(2501):\n\n if i != 0 and j % i == 0 and j // i == A:\n #print (i,j,lis[i][j])\n ans += lis[i][j]",
"j",
"range(2501)",
"range",
"2501",
"if i != 0 and j % i == 0 and j // i == A:\n #print (i,j,lis[i][j])\n ans += lis[i][j]",
"i != 0 and j % i == 0 and j // i == A",
"i != 0 and j % i == 0",
"i != 0",
"i",
"0",
"j % i == 0",
"j % i",
"j",
"i",
"0",
"j // i == A",
"j // i",
"j",
"i",
"A",
"ans += lis[i][j]",
"ans",
"lis[i][j]",
"[i]",
"lis",
"i",
"j",
"print (ans)",
"print",
"ans",
"X = list(map(int,input().split()))",
"list(map(int,input().split()))",
"X",
"ans += lis[i][j]",
"lis[i][j]",
"ans",
"lis = []",
"[]",
"lis",
"ans = 0",
"0",
"ans",
"A = map(int,input().split())",
"map(int,input().split())",
"A",
"N,A = map(int,input().split())",
"map(int,input().split())",
"N",
"new = lis[k].copy()",
"lis[k].copy()",
"new",
"nlis = []",
"[]",
"nlis"
] |
N,A = map(int,input().split())
lis = []
for i in range(51):
lis.append([0] * 2501)
lis[0][0] = 1
X = list(map(int,input().split()))
for x in X:
nlis = []
for k in range(51):
new = lis[k].copy()
nlis.append(new)
for i in range(51):
for j in range(2501):
if i+1 <= 50 and j+x <= 2500 and nlis[i][j] > 0:
lis[i+1][j+x] += nlis[i][j]
ans = 0
for i in range(51):
for j in range(2501):
if i != 0 and j % i == 0 and j // i == A:
#print (i,j,lis[i][j])
ans += lis[i][j]
print (ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
2,
13,
13,
17,
28,
13,
4,
13,
17,
13,
28,
13,
4,
13,
2,
2,
2,
17,
13,
13,
17,
14,
2,
4,
13,
2,
13,
18,
13,
13,
2,
2,
17,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
18,
13,
13,
4,
13,
2,
18,
18,
13,
13,
2,
13,
13,
17,
17,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
161,
2
],
[
161,
11
],
[
158,
13
],
[
28,
27
],
[
159,
27
],
[
27,
31
],
[
162,
32
],
[
149,
34
],
[
155,
37
],
[
159,
42
],
[
162,
43
],
[
47,
46
],
[
147,
50
],
[
152,
55
],
[
65,
58
],
[
153,
60
],
[
147,
63
],
[
156,
64
],
[
68,
67
],
[
147,
71
],
[
74,
73
],
[
147,
80
],
[
156,
81
],
[
73,
88
],
[
150,
90
],
[
67,
91
],
[
147,
95
],
[
156,
96
],
[
105,
98
],
[
153,
100
],
[
67,
102
],
[
73,
104
],
[
153,
107
],
[
67,
108
],
[
73,
109
],
[
118,
111
],
[
153,
113
],
[
67,
115
],
[
73,
117
],
[
153,
121
],
[
67,
122
],
[
73,
123
],
[
153,
126
],
[
67,
127
],
[
73,
129
],
[
150,
131
],
[
67,
132
],
[
153,
138
],
[
147,
139
],
[
147,
141
],
[
156,
142
],
[
161,
147
],
[
149,
150
],
[
152,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\n'''\n辞書がめっちゃ書きやすい！ただし、3次元配列でdpやりたい時むずいかも。\nx = [i-a for i in x]\ndp = {0:1}\nprint(dp)\nfor item in x:\n print('--------for item:{}-----------'.format(item))\n for key, value in list(dp.items()):\n print('key:{},value:{}'.format(key,value))\n dp[item + key] = dp.get(item + key, 0) + value\n print(dp)\nprint(dp[0]-1)\n'''\n\ndiff = [i-a for i in x]\nma = max(max(x),a)\n\ndp = [[0 for j in range(2*n*ma+1)] for k in range(n+1)]\n# 0を初期値として1からNまでやりたいので結果の箱は1+n回ループを回す準備をする。\n# print(dp[1][71])\n# この初期化をした時に添字はどっちがどっちみたいのはいい加減覚える。\n# 0~2*n*naまでの列がn+1倍なのでそれがn+1個並んでいるイメージ。最初の添字ではn+1個並んでいるうちの一つを指定する。\n\ndp[0][n*ma] = 1\n# initialize\n\nfor l in range(0,n):\n # diff(入力の全てからaを引いたやつ)は0~n-1までしかないことに注意\n # 同様に後ろのdpの添字も注意\n for m in range(2*n*ma+1):\n if abs(m - diff[l]) > 2*n*ma:\n dp[l+1][m] = dp[l][m]\n #ループ回すまでもなく選んでも無理な時はそのまま \n else:\n dp[l+1][m] = dp[l][m] + dp[l][m - diff[l]]\nprint(dp[n][n*ma]-1)\n\n\n\n'''\ncountzero = len([i for i in diff if i == 0])\n#print(countzero)\nover = sorted([i for i in diff if i > 0])\nunder = sorted([i for i in diff if i < 0])\n#print(over)\n#print(under)\ncountover = [0 for i in range(50)]\ncountunder = [0 for i in range(50)]\nfor item in set(over):\n countover[item-1] = over.count(item)\nfor item in set(under):\n countunder[item] = under.count(item)\ncountunder = sorted(countunder)\n\nvalover = [countover[0]]\nvalunder = [countunder[0]]\n\nfor i in range(1,2500):\n plus = 0\n minus = 0\n if i%2 == 0:\n plus = countover[int(i/2)]*(countover[int(i/2)]-1)/2\n minus = countunder[int(i/2)]*(countunder[int(i/2)]-1)/2\n for j in range(int(i/2)):\n plus += countover[i]*countover[-i]\n minus += countunder[i]*countunder[-i]\n valover.append(plus)\n valunder.append(minus)\n\nplusminus = 0\nfor i in range(2500):\n plusminus += valover[i]*valunder[i]\n\nprint((plusminus+1)*2**(countzero)-1)\n'''",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"'''\n辞書がめっちゃ書きやすい！ただし、3次元配列でdpやりたい時むずいかも。\nx = [i-a for i in x]\ndp = {0:1}\nprint(dp)\nfor item in x:\n print('--------for item:{}-----------'.format(item))\n for key, value in list(dp.items()):\n print('key:{},value:{}'.format(key,value))\n dp[item + key] = dp.get(item + key, 0) + value\n print(dp)\nprint(dp[0]-1)\n'''",
"i-a for i in x",
"for i in x",
"i",
"x",
"for i in x",
"i-a",
"i",
"a",
"diff = [i-a for i in x]",
"diff",
"[i-a for i in x]",
"ma = max(max(x),a)",
"ma",
"max(max(x),a)",
"max",
"max(x)",
"max",
"x",
"a",
"[0 for j in range(2*n*ma+1)] for k in range(n+1)",
"for k in range(n+1)",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for k in range(n+1)",
"[0 for j in range(2*n*ma+1)]",
"dp = [[0 for j in range(2*n*ma+1)] for k in range(n+1)]",
"dp",
"[[0 for j in range(2*n*ma+1)] for k in range(n+1)]",
"dp[0][n*ma] = 1",
"dp[0][n*ma]",
"[0]",
"dp",
"0",
"n*ma",
"n",
"ma",
"1",
"for l in range(0,n):\n # diff(入力の全てからaを引いたやつ)は0~n-1までしかないことに注意\n # 同様に後ろのdpの添字も注意\n for m in range(2*n*ma+1):\n if abs(m - diff[l]) > 2*n*ma:\n dp[l+1][m] = dp[l][m]\n #ループ回すまでもなく選んでも無理な時はそのまま \n else:\n dp[l+1][m] = dp[l][m] + dp[l][m - diff[l]]",
"l",
"range(0,n)",
"range",
"0",
"n",
"for m in range(2*n*ma+1):\n if abs(m - diff[l]) > 2*n*ma:\n dp[l+1][m] = dp[l][m]\n #ループ回すまでもなく選んでも無理な時はそのまま \n else:\n dp[l+1][m] = dp[l][m] + dp[l][m - diff[l]]",
"m",
"range(2*n*ma+1)",
"range",
"2*n*ma+1",
"2*n*ma",
"2*n",
"2",
"n",
"ma",
"1",
"if abs(m - diff[l]) > 2*n*ma:\n dp[l+1][m] = dp[l][m]\n #ループ回すまでもなく選んでも無理な時はそのまま \n else:\n dp[l+1][m] = dp[l][m] + dp[l][m - diff[l]]",
"abs(m - diff[l]) > 2*n*ma",
"abs(m - diff[l])",
"abs",
"m - diff[l]",
"m",
"diff[l]",
"diff",
"l",
"2*n*ma",
"2*n",
"2",
"n",
"ma",
"dp[l+1][m] = dp[l][m]",
"dp[l+1][m]",
"[l+1]",
"dp",
"l+1",
"l",
"1",
"m",
"dp[l][m]",
"[l]",
"dp",
"l",
"m",
"dp[l+1][m] = dp[l][m] + dp[l][m - diff[l]]",
"dp[l+1][m]",
"[l+1]",
"dp",
"l+1",
"l",
"1",
"m",
"dp[l][m] + dp[l][m - diff[l]]",
"dp[l][m]",
"[l]",
"dp",
"l",
"m",
"dp[l][m - diff[l]]",
"[l]",
"dp",
"l",
"m - diff[l]",
"m",
"diff[l]",
"diff",
"l",
"print(dp[n][n*ma]-1)",
"print",
"dp[n][n*ma]-1",
"dp[n][n*ma]",
"[n]",
"dp",
"n",
"n*ma",
"n",
"ma",
"1",
"'''\ncountzero = len([i for i in diff if i == 0])\n#print(countzero)\nover = sorted([i for i in diff if i > 0])\nunder = sorted([i for i in diff if i < 0])\n#print(over)\n#print(under)\ncountover = [0 for i in range(50)]\ncountunder = [0 for i in range(50)]\nfor item in set(over):\n countover[item-1] = over.count(item)\nfor item in set(under):\n countunder[item] = under.count(item)\ncountunder = sorted(countunder)\n\nvalover = [countover[0]]\nvalunder = [countunder[0]]\n\nfor i in range(1,2500):\n plus = 0\n minus = 0\n if i%2 == 0:\n plus = countover[int(i/2)]*(countover[int(i/2)]-1)/2\n minus = countunder[int(i/2)]*(countunder[int(i/2)]-1)/2\n for j in range(int(i/2)):\n plus += countover[i]*countover[-i]\n minus += countunder[i]*countunder[-i]\n valover.append(plus)\n valunder.append(minus)\n\nplusminus = 0\nfor i in range(2500):\n plusminus += valover[i]*valunder[i]\n\nprint((plusminus+1)*2**(countzero)-1)\n'''",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"diff = [i-a for i in x]",
"[i-a for i in x]",
"diff",
"dp = [[0 for j in range(2*n*ma+1)] for k in range(n+1)]",
"[[0 for j in range(2*n*ma+1)] for k in range(n+1)]",
"dp",
"ma = max(max(x),a)",
"max(max(x),a)",
"ma",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"a = map(int, input().split())",
"map(int, input().split())",
"a"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
'''
辞書がめっちゃ書きやすい！ただし、3次元配列でdpやりたい時むずいかも。
x = [i-a for i in x]
dp = {0:1}
print(dp)
for item in x:
print('--------for item:{}-----------'.format(item))
for key, value in list(dp.items()):
print('key:{},value:{}'.format(key,value))
dp[item + key] = dp.get(item + key, 0) + value
print(dp)
print(dp[0]-1)
'''
diff = [i-a for i in x]
ma = max(max(x),a)
dp = [[0 for j in range(2*n*ma+1)] for k in range(n+1)]
# 0を初期値として1からNまでやりたいので結果の箱は1+n回ループを回す準備をする。
# print(dp[1][71])
# この初期化をした時に添字はどっちがどっちみたいのはいい加減覚える。
# 0~2*n*naまでの列がn+1倍なのでそれがn+1個並んでいるイメージ。最初の添字ではn+1個並んでいるうちの一つを指定する。
dp[0][n*ma] = 1
# initialize
for l in range(0,n):
# diff(入力の全てからaを引いたやつ)は0~n-1までしかないことに注意
# 同様に後ろのdpの添字も注意
for m in range(2*n*ma+1):
if abs(m - diff[l]) > 2*n*ma:
dp[l+1][m] = dp[l][m]
#ループ回すまでもなく選んでも無理な時はそのまま
else:
dp[l+1][m] = dp[l][m] + dp[l][m - diff[l]]
print(dp[n][n*ma]-1)
'''
countzero = len([i for i in diff if i == 0])
#print(countzero)
over = sorted([i for i in diff if i > 0])
under = sorted([i for i in diff if i < 0])
#print(over)
#print(under)
countover = [0 for i in range(50)]
countunder = [0 for i in range(50)]
for item in set(over):
countover[item-1] = over.count(item)
for item in set(under):
countunder[item] = under.count(item)
countunder = sorted(countunder)
valover = [countover[0]]
valunder = [countunder[0]]
for i in range(1,2500):
plus = 0
minus = 0
if i%2 == 0:
plus = countover[int(i/2)]*(countover[int(i/2)]-1)/2
minus = countunder[int(i/2)]*(countunder[int(i/2)]-1)/2
for j in range(int(i/2)):
plus += countover[i]*countover[-i]
minus += countunder[i]*countunder[-i]
valover.append(plus)
valunder.append(minus)
plusminus = 0
for i in range(2500):
plusminus += valover[i]*valunder[i]
print((plusminus+1)*2**(countzero)-1)
''' |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
2,
39,
17,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
13,
18,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
40,
13,
18,
13,
13,
40,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
40,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
3,
4,
13,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
192,
4
],
[
204,
11
],
[
193,
18
],
[
204,
20
],
[
189,
22
],
[
193,
34
],
[
210,
37
],
[
190,
40
],
[
213,
42
],
[
190,
45
],
[
49,
48
],
[
201,
55
],
[
65,
58
],
[
202,
61
],
[
68,
67
],
[
205,
72
],
[
76,
75
],
[
67,
79
],
[
83,
82
],
[
214,
87
],
[
75,
88
],
[
82,
92
],
[
190,
94
],
[
67,
95
],
[
104,
97
],
[
202,
100
],
[
67,
101
],
[
75,
102
],
[
82,
103
],
[
202,
107
],
[
67,
109
],
[
75,
111
],
[
82,
112
],
[
82,
116
],
[
190,
118
],
[
67,
119
],
[
75,
121
],
[
131,
124
],
[
202,
127
],
[
67,
128
],
[
75,
129
],
[
82,
130
],
[
202,
135
],
[
67,
137
],
[
75,
139
],
[
82,
140
],
[
202,
144
],
[
67,
146
],
[
75,
149
],
[
82,
152
],
[
190,
154
],
[
67,
155
],
[
207,
157
],
[
161,
160
],
[
205,
165
],
[
196,
170
],
[
160,
171
],
[
211,
172
],
[
198,
174
],
[
202,
178
],
[
205,
179
],
[
160,
180
],
[
196,
182
],
[
160,
183
],
[
199,
187
],
[
208,
187
],
[
189,
190
],
[
192,
193
],
[
204,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
]
] | [
"import sys\ninput=sys.stdin.readline\nn,a=map(int,input().split())\nx=[0]+list(map(int,input().split()))\nsu=sum(x)\nmaxi=max(x)\ndp=[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]\ndp[0][0][0]=1\nfor i in range(1,n+1):\n for j in range(i+1):\n for k in range(maxi*j+1):\n if k<x[i]:\n dp[i][j][k]=dp[i-1][j][k]\n if k>=x[i] and j>=1:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]\nans=0\nfor t in range(1,n+1):\n if a*t<=su:\n ans+=dp[n][t][a*t]\n else:\n break\nprint(ans)",
"import sys",
"sys",
"input=sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x=[0]+list(map(int,input().split()))",
"x",
"[0]+list(map(int,input().split()))",
"[0]",
"0",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"su=sum(x)",
"su",
"sum(x)",
"sum",
"x",
"maxi=max(x)",
"maxi",
"max(x)",
"max",
"x",
"[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)",
"for i in range(51)",
"i",
"range(51)",
"range",
"51",
"for i in range(51)",
"[[0 for k in range(maxi*n+1)] for j in range(51)]",
"dp=[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]",
"dp",
"[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]",
"dp[0][0][0]=1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(1,n+1):\n for j in range(i+1):\n for k in range(maxi*j+1):\n if k<x[i]:\n dp[i][j][k]=dp[i-1][j][k]\n if k>=x[i] and j>=1:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for j in range(i+1):\n for k in range(maxi*j+1):\n if k<x[i]:\n dp[i][j][k]=dp[i-1][j][k]\n if k>=x[i] and j>=1:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]",
"j",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"for k in range(maxi*j+1):\n if k<x[i]:\n dp[i][j][k]=dp[i-1][j][k]\n if k>=x[i] and j>=1:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]",
"k",
"range(maxi*j+1)",
"range",
"maxi*j+1",
"maxi*j",
"maxi",
"j",
"1",
"if k<x[i]:\n dp[i][j][k]=dp[i-1][j][k]\n ",
"k<x[i]",
"k",
"x[i]",
"x",
"i",
"dp[i][j][k]=dp[i-1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"if k>=x[i] and j>=1:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]",
"k>=x[i] and j>=1",
"k>=x[i]",
"k",
"x[i]",
"x",
"i",
"j>=1",
"j",
"1",
"dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"dp[i-1][j-1][k-x[i]]",
"[j-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"k-x[i]",
"k",
"x[i]",
"x",
"i",
"ans=0",
"ans",
"0",
"for t in range(1,n+1):\n if a*t<=su:\n ans+=dp[n][t][a*t]\n else:\n break",
"t",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"if a*t<=su:\n ans+=dp[n][t][a*t]\n else:\n break",
"a*t<=su",
"a*t",
"a",
"t",
"su",
"ans+=dp[n][t][a*t]",
"ans",
"dp[n][t][a*t]",
"[t]",
"[n]",
"dp",
"n",
"t",
"a*t",
"a",
"t",
"break",
"print(ans)",
"print",
"ans",
"x=[0]+list(map(int,input().split()))",
"[0]+list(map(int,input().split()))",
"x",
"input=sys.stdin.readline",
"sys.stdin.readline",
"input",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"ans+=dp[n][t][a*t]",
"dp[n][t][a*t]",
"ans",
"dp=[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]",
"[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]",
"dp",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"ans=0",
"0",
"ans",
"su=sum(x)",
"sum(x)",
"su",
"maxi=max(x)",
"max(x)",
"maxi"
] | import sys
input=sys.stdin.readline
n,a=map(int,input().split())
x=[0]+list(map(int,input().split()))
su=sum(x)
maxi=max(x)
dp=[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]
dp[0][0][0]=1
for i in range(1,n+1):
for j in range(i+1):
for k in range(maxi*j+1):
if k<x[i]:
dp[i][j][k]=dp[i-1][j][k]
if k>=x[i] and j>=1:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]
ans=0
for t in range(1,n+1):
if a*t<=su:
ans+=dp[n][t][a*t]
else:
break
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
2,
4,
13,
13,
13,
0,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
41,
28,
13,
13,
4,
39,
13,
18,
13,
13,
0,
13,
13,
28,
13,
13,
14,
2,
2,
18,
13,
17,
13,
13,
0,
18,
13,
2,
18,
13,
17,
13,
18,
13,
17,
0,
18,
13,
2,
18,
13,
17,
13,
18,
13,
17,
4,
13,
2,
18,
13,
17,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
21,
13,
10,
13,
13
] | [
[
98,
2
],
[
98,
11
],
[
15,
14
],
[
14,
24
],
[
99,
25
],
[
104,
27
],
[
101,
30
],
[
37,
36
],
[
105,
36
],
[
41,
40
],
[
102,
40
],
[
102,
46
],
[
40,
47
],
[
92,
49
],
[
53,
52
],
[
93,
52
],
[
52,
58
],
[
36,
60
],
[
102,
61
],
[
70,
63
],
[
102,
64
],
[
52,
67
],
[
36,
69
],
[
52,
71
],
[
81,
74
],
[
102,
75
],
[
52,
78
],
[
36,
80
],
[
52,
82
],
[
102,
88
],
[
92,
93
],
[
98,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
]
] | [
"n,a=map(int,input().split())\nnums=[int(i)-a for i in input().split()]\nd={0:1}\nfor i in nums:\n s = [[j, d[j]] for j in d]\n for j in s:\n if j[0] + i in d:\n d[j[0]+i] += j[1]\n else:\n d[j[0]+i] = j[1]\nprint(d[0]-1)",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"int(i)-a for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)-a",
"int(i)",
"int",
"i",
"a",
"nums=[int(i)-a for i in input().split()]",
"nums",
"[int(i)-a for i in input().split()]",
"d={0:1}",
"d",
"{0:1}",
"0",
"0",
"1",
"for i in nums:\n s = [[j, d[j]] for j in d]\n for j in s:\n if j[0] + i in d:\n d[j[0]+i] += j[1]\n else:\n d[j[0]+i] = j[1]",
"i",
"nums",
"[j, d[j]] for j in d",
"for j in d",
"j",
"d",
"for j in d",
"[j, d[j]]",
"j",
"d[j]",
"d",
"j",
"s = [[j, d[j]] for j in d]",
"s",
"[[j, d[j]] for j in d]",
"for j in s:\n if j[0] + i in d:\n d[j[0]+i] += j[1]\n else:\n d[j[0]+i] = j[1]",
"j",
"s",
"if j[0] + i in d:\n d[j[0]+i] += j[1]\n else:\n d[j[0]+i] = j[1]",
"j[0] + i in d",
"j[0] + i",
"j[0]",
"j",
"0",
"i",
"d",
"d[j[0]+i] += j[1]",
"d[j[0]+i]",
"d",
"j[0]+i",
"j[0]",
"j",
"0",
"i",
"j[1]",
"j",
"1",
"d[j[0]+i] = j[1]",
"d[j[0]+i]",
"d",
"j[0]+i",
"j[0]",
"j",
"0",
"i",
"j[1]",
"j",
"1",
"print(d[0]-1)",
"print",
"d[0]-1",
"d[0]",
"d",
"0",
"1",
"s = [[j, d[j]] for j in d]",
"[[j, d[j]] for j in d]",
"s",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"d={0:1}",
"{0:1}",
"d",
"nums=[int(i)-a for i in input().split()]",
"[int(i)-a for i in input().split()]",
"nums"
] | n,a=map(int,input().split())
nums=[int(i)-a for i in input().split()]
d={0:1}
for i in nums:
s = [[j, d[j]] for j in d]
for j in s:
if j[0] + i in d:
d[j[0]+i] += j[1]
else:
d[j[0]+i] = j[1]
print(d[0]-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
2,
2,
39,
17,
13,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
2,
13,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
13,
17,
17,
0,
13,
2,
13,
18,
13,
13,
14,
2,
40,
17,
13,
2,
2,
13,
17,
17,
0,
18,
18,
13,
2,
13,
17,
13,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
4,
13,
2,
18,
18,
13,
13,
2,
13,
17,
17,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
148,
2
],
[
148,
11
],
[
151,
13
],
[
27,
26
],
[
152,
26
],
[
26,
30
],
[
143,
31
],
[
139,
33
],
[
38,
37
],
[
149,
41
],
[
149,
49
],
[
145,
53
],
[
63,
56
],
[
146,
58
],
[
149,
61
],
[
66,
65
],
[
149,
68
],
[
71,
70
],
[
149,
75
],
[
154,
79
],
[
70,
81
],
[
140,
83
],
[
152,
83
],
[
65,
84
],
[
155,
89
],
[
149,
92
],
[
103,
96
],
[
146,
98
],
[
65,
100
],
[
70,
102
],
[
146,
106
],
[
65,
107
],
[
70,
108
],
[
146,
111
],
[
65,
112
],
[
155,
113
],
[
122,
115
],
[
146,
117
],
[
65,
119
],
[
70,
121
],
[
146,
124
],
[
65,
125
],
[
70,
126
],
[
146,
132
],
[
149,
133
],
[
149,
135
],
[
139,
140
],
[
148,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
]
] | [
"n , a = map(int, input().split())\nx = list(map(int,input().split()))\n\nx=[i-a for i in x]\ndp=[[0]*n*50*2 for i in range(n+1)]\n\ndp[0][n*50]=1\n\nfor i in range(n):\n for j in range(n*50*2):\n t=j-x[i]\n if 0<=t<n*50*2:\n dp[i+1][j]=dp[i][j]+dp[i][t]\n else:\n dp[i+1][j]=dp[i][j]\nprint(dp[n][n*50]-1)",
"n , a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"i-a for i in x",
"for i in x",
"i",
"x",
"for i in x",
"i-a",
"i",
"a",
"x=[i-a for i in x]",
"x",
"[i-a for i in x]",
"[0]*n*50*2 for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[0]*n*50*2",
"[0]*n*50",
"[0]*n",
"[0]",
"0",
"n",
"50",
"2",
"dp=[[0]*n*50*2 for i in range(n+1)]",
"dp",
"[[0]*n*50*2 for i in range(n+1)]",
"dp[0][n*50]=1",
"dp[0][n*50]",
"[0]",
"dp",
"0",
"n*50",
"n",
"50",
"1",
"for i in range(n):\n for j in range(n*50*2):\n t=j-x[i]\n if 0<=t<n*50*2:\n dp[i+1][j]=dp[i][j]+dp[i][t]\n else:\n dp[i+1][j]=dp[i][j]",
"i",
"range(n)",
"range",
"n",
"for j in range(n*50*2):\n t=j-x[i]\n if 0<=t<n*50*2:\n dp[i+1][j]=dp[i][j]+dp[i][t]\n else:\n dp[i+1][j]=dp[i][j]",
"j",
"range(n*50*2)",
"range",
"n*50*2",
"n*50",
"n",
"50",
"2",
"t=j-x[i]",
"t",
"j-x[i]",
"j",
"x[i]",
"x",
"i",
"if 0<=t<n*50*2:\n dp[i+1][j]=dp[i][j]+dp[i][t]\n else:\n dp[i+1][j]=dp[i][j]",
"0<=t<n*50*2",
"0<=t",
"0",
"t",
"n*50*2",
"n*50",
"n",
"50",
"2",
"dp[i+1][j]=dp[i][j]+dp[i][t]",
"dp[i+1][j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"dp[i][j]+dp[i][t]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i][t]",
"[i]",
"dp",
"i",
"t",
"dp[i+1][j]=dp[i][j]",
"dp[i+1][j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"print(dp[n][n*50]-1)",
"print",
"dp[n][n*50]-1",
"dp[n][n*50]",
"[n]",
"dp",
"n",
"n*50",
"n",
"50",
"1",
"x=[i-a for i in x]",
"[i-a for i in x]",
"x",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"dp=[[0]*n*50*2 for i in range(n+1)]",
"[[0]*n*50*2 for i in range(n+1)]",
"dp",
"n , a = map(int, input().split())",
"map(int, input().split())",
"n",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"t=j-x[i]",
"j-x[i]",
"t"
] | n , a = map(int, input().split())
x = list(map(int,input().split()))
x=[i-a for i in x]
dp=[[0]*n*50*2 for i in range(n+1)]
dp[0][n*50]=1
for i in range(n):
for j in range(n*50*2):
t=j-x[i]
if 0<=t<n*50*2:
dp[i+1][j]=dp[i][j]+dp[i][t]
else:
dp[i+1][j]=dp[i][j]
print(dp[n][n*50]-1)
|
[
7,
12,
13,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
17,
14,
2,
40,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
2,
40,
13,
17,
40,
18,
13,
2,
13,
17,
13,
40,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
18,
18,
18,
13,
2,
13,
17,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
17,
13,
2,
13,
13,
29,
4,
13,
13,
23,
13,
23,
13,
23,
13,
14,
2,
13,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
5,
4
],
[
188,
9
],
[
186,
10
],
[
14,
13
],
[
184,
17
],
[
23,
22
],
[
26,
25
],
[
184,
29
],
[
33,
32
],
[
184,
36
],
[
40,
39
],
[
184,
44
],
[
4,
45
],
[
25,
51
],
[
32,
54
],
[
39,
57
],
[
67,
60
],
[
22,
63
],
[
25,
64
],
[
32,
65
],
[
39,
66
],
[
25,
71
],
[
39,
74
],
[
188,
76
],
[
25,
78
],
[
88,
81
],
[
22,
84
],
[
25,
85
],
[
32,
86
],
[
39,
87
],
[
22,
91
],
[
25,
93
],
[
32,
95
],
[
39,
96
],
[
25,
101
],
[
188,
105
],
[
25,
107
],
[
39,
109
],
[
32,
111
],
[
121,
114
],
[
22,
117
],
[
25,
118
],
[
32,
119
],
[
39,
120
],
[
22,
125
],
[
25,
127
],
[
32,
130
],
[
39,
133
],
[
188,
135
],
[
25,
137
],
[
22,
142
],
[
25,
144
],
[
32,
146
],
[
39,
147
],
[
156,
149
],
[
22,
152
],
[
25,
153
],
[
32,
154
],
[
39,
155
],
[
159,
158
],
[
162,
161
],
[
184,
166
],
[
170,
169
],
[
22,
173
],
[
161,
175
],
[
161,
177
],
[
186,
178
],
[
169,
182
],
[
158,
182
],
[
184,
184
],
[
186,
186
],
[
188,
188
],
[
236,
194
],
[
236,
203
],
[
207,
206
],
[
206,
215
],
[
233,
217
],
[
242,
220
],
[
240,
222
],
[
231,
223
],
[
237,
224
],
[
234,
225
],
[
243,
228
],
[
236,
231
],
[
233,
234
],
[
236,
237
],
[
242,
243
]
] | [
"def solve(n, a, lst):\n m = max(max(lst), a)\n ans = [[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)]\n #ans[i][j][k] : lst[:i]までの中からj枚選んで合計kにする選び方\n for i in range(n+1):\n for j in range(n+1):\n for k in range(n*m+1):\n if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ret = 0\n for i in range(1,n+1):\n ret += ans[-1][i][i*a]\n return int(ret)\n\nif __name__ == \"__main__\":\n n, a = map(int,input().split())\n x_list = [int(i) for i in input().split()]\n ans = solve(n,a,x_list)\n print(ans)",
"def solve(n, a, lst):\n m = max(max(lst), a)\n ans = [[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)]\n #ans[i][j][k] : lst[:i]までの中からj枚選んで合計kにする選び方\n for i in range(n+1):\n for j in range(n+1):\n for k in range(n*m+1):\n if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ret = 0\n for i in range(1,n+1):\n ret += ans[-1][i][i*a]\n return int(ret)",
"solve",
"m = max(max(lst), a)",
"m",
"max(max(lst), a)",
"max",
"max(lst)",
"max",
"lst",
"a",
"[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)",
"for j in range(n+1)",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for j in range(n+1)",
"[[0]*(n*m+1) for i in range(n+1)]",
"ans = [[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)]",
"ans",
"[[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)]",
"for i in range(n+1):\n for j in range(n+1):\n for k in range(n*m+1):\n if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for j in range(n+1):\n for k in range(n*m+1):\n if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for k in range(n*m+1):\n if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ",
"k",
"range(n*m+1)",
"range",
"n*m+1",
"n*m",
"n",
"m",
"1",
"if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ",
"i == 0 and j == 0 and k == 0",
"i == 0 and j == 0",
"i == 0",
"i",
"0",
"j == 0",
"j",
"0",
"k == 0",
"k",
"0",
"ans[i][j][k] = 1",
"ans[i][j][k]",
"[j]",
"[i]",
"ans",
"i",
"j",
"k",
"1",
"elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n ",
"i >= 1 and k < lst[i-1]",
"i >= 1",
"i",
"1",
"k < lst[i-1]",
"k",
"lst[i-1]",
"lst",
"i-1",
"i",
"1",
"ans[i][j][k] = ans[i-1][j][k]",
"ans[i][j][k]",
"[j]",
"[i]",
"ans",
"i",
"j",
"k",
"ans[i-1][j][k]",
"[j]",
"[i-1]",
"ans",
"i-1",
"i",
"1",
"j",
"k",
"elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n ",
"i >= 1 and lst[i-1] <= k and j >= 1",
"i >= 1 and lst[i-1] <= k",
"i >= 1",
"i",
"1",
"lst[i-1] <= k",
"lst[i-1]",
"lst",
"i-1",
"i",
"1",
"k",
"j >= 1",
"j",
"1",
"ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]",
"ans[i][j][k]",
"[j]",
"[i]",
"ans",
"i",
"j",
"k",
"ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]",
"ans[i-1][j-1][k-lst[i-1]]",
"[j-1]",
"[i-1]",
"ans",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"k-lst[i-1]",
"k",
"lst[i-1]",
"lst",
"i-1",
"i",
"1",
"ans[i-1][j][k]",
"[j]",
"[i-1]",
"ans",
"i-1",
"i",
"1",
"j",
"k",
"ans[i][j][k] = 0",
"ans[i][j][k]",
"[j]",
"[i]",
"ans",
"i",
"j",
"k",
"0",
"ret = 0",
"ret",
"0",
"for i in range(1,n+1):\n ret += ans[-1][i][i*a]\n ",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ret += ans[-1][i][i*a]",
"ret",
"ans[-1][i][i*a]",
"[i]",
"[-1]",
"ans",
"-1",
"i",
"i*a",
"i",
"a",
"return int(ret)",
"int(ret)",
"int",
"ret",
"n",
"n",
"a",
"a",
"lst",
"lst",
"if __name__ == \"__main__\":\n n, a = map(int,input().split())\n x_list = [int(i) for i in input().split()]\n ans = solve(n,a,x_list)\n print(ans)",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"n, a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"x_list = [int(i) for i in input().split()]",
"x_list",
"[int(i) for i in input().split()]",
"ans = solve(n,a,x_list)",
"ans",
"solve(n,a,x_list)",
"solve",
"n",
"a",
"x_list",
"print(ans)",
"print",
"ans",
"n, a = map(int,input().split())",
"map(int,input().split())",
"n",
"x_list = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"x_list",
"a = map(int,input().split())",
"map(int,input().split())",
"a",
"def solve(n, a, lst):\n m = max(max(lst), a)\n ans = [[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)]\n #ans[i][j][k] : lst[:i]までの中からj枚選んで合計kにする選び方\n for i in range(n+1):\n for j in range(n+1):\n for k in range(n*m+1):\n if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ret = 0\n for i in range(1,n+1):\n ret += ans[-1][i][i*a]\n return int(ret)",
"def solve(n, a, lst):\n m = max(max(lst), a)\n ans = [[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)]\n #ans[i][j][k] : lst[:i]までの中からj枚選んで合計kにする選び方\n for i in range(n+1):\n for j in range(n+1):\n for k in range(n*m+1):\n if i == 0 and j == 0 and k == 0:\n ans[i][j][k] = 1\n elif i >= 1 and k < lst[i-1]:\n ans[i][j][k] = ans[i-1][j][k]\n elif i >= 1 and lst[i-1] <= k and j >= 1:\n ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]\n else:\n ans[i][j][k] = 0\n ret = 0\n for i in range(1,n+1):\n ret += ans[-1][i][i*a]\n return int(ret)",
"solve",
"ans = solve(n,a,x_list)",
"solve(n,a,x_list)",
"ans"
] | def solve(n, a, lst):
m = max(max(lst), a)
ans = [[[0]*(n*m+1) for i in range(n+1)] for j in range(n+1)]
#ans[i][j][k] : lst[:i]までの中からj枚選んで合計kにする選び方
for i in range(n+1):
for j in range(n+1):
for k in range(n*m+1):
if i == 0 and j == 0 and k == 0:
ans[i][j][k] = 1
elif i >= 1 and k < lst[i-1]:
ans[i][j][k] = ans[i-1][j][k]
elif i >= 1 and lst[i-1] <= k and j >= 1:
ans[i][j][k] = ans[i-1][j-1][k-lst[i-1]] + ans[i-1][j][k]
else:
ans[i][j][k] = 0
ret = 0
for i in range(1,n+1):
ret += ans[-1][i][i*a]
return int(ret)
if __name__ == "__main__":
n, a = map(int,input().split())
x_list = [int(i) for i in input().split()]
ans = solve(n,a,x_list)
print(ans)
|
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
4,
13,
2,
18,
13,
17,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
16,
15
],
[
29,
28
],
[
15,
28
],
[
28,
32
],
[
13,
33
],
[
36,
35
],
[
39,
38
],
[
45,
44
],
[
35,
44
],
[
15,
44
],
[
38,
53
],
[
61,
56
],
[
38,
57
],
[
44,
59
],
[
38,
64
],
[
44,
67
],
[
38,
75
],
[
86,
83
]
] | [
"#!/usr/bin python3\n# -*- coding: utf-8 -*-\n\ndef main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n X = [x-A for x in X]\n\n ret={0: 1}\n for xi in X:\n for y, cnt in list(ret.items()):\n ret[xi+y] = ret.get(xi+y, 0) + cnt\n print(ret[0]-1)\n\nif __name__ == '__main__':\n main()",
"def main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n X = [x-A for x in X]\n\n ret={0: 1}\n for xi in X:\n for y, cnt in list(ret.items()):\n ret[xi+y] = ret.get(xi+y, 0) + cnt\n print(ret[0]-1)",
"main",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x-A for x in X",
"for x in X",
"x",
"X",
"for x in X",
"x-A",
"x",
"A",
"X = [x-A for x in X]",
"X",
"[x-A for x in X]",
"ret={0: 1}",
"ret",
"{0: 1}",
"0",
"0",
"1",
"for xi in X:\n for y, cnt in list(ret.items()):\n ret[xi+y] = ret.get(xi+y, 0) + cnt\n ",
"xi",
"X",
"for y, cnt in list(ret.items()):\n ret[xi+y] = ret.get(xi+y, 0) + cnt\n ",
"y",
"cnt",
"list(ret.items())",
"list",
"ret.items()",
"ret.items",
"ret",
"items",
"ret[xi+y] = ret.get(xi+y, 0) + cnt",
"ret[xi+y]",
"ret",
"xi+y",
"xi",
"y",
"ret.get(xi+y, 0) + cnt",
"ret.get(xi+y, 0)",
"ret.get",
"ret",
"get",
"xi+y",
"xi",
"y",
"0",
"cnt",
"print(ret[0]-1)",
"print",
"ret[0]-1",
"ret[0]",
"ret",
"0",
"1",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n X = [x-A for x in X]\n\n ret={0: 1}\n for xi in X:\n for y, cnt in list(ret.items()):\n ret[xi+y] = ret.get(xi+y, 0) + cnt\n print(ret[0]-1)",
"def main():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n X = [x-A for x in X]\n\n ret={0: 1}\n for xi in X:\n for y, cnt in list(ret.items()):\n ret[xi+y] = ret.get(xi+y, 0) + cnt\n print(ret[0]-1)",
"main"
] | #!/usr/bin python3
# -*- coding: utf-8 -*-
def main():
N, A = map(int, input().split())
X = list(map(int, input().split()))
X = [x-A for x in X]
ret={0: 1}
for xi in X:
for y, cnt in list(ret.items()):
ret[xi+y] = ret.get(xi+y, 0) + cnt
print(ret[0]-1)
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
2,
18,
13,
17,
17,
17,
0,
18,
18,
13,
17,
17,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
17,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
14,
40,
40,
17,
2,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
13,
13,
4,
13,
2,
18,
18,
13,
2,
13,
17,
17,
17,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13
] | [
[
148,
2
],
[
148,
11
],
[
139,
13
],
[
27,
26
],
[
140,
26
],
[
26,
30
],
[
149,
31
],
[
151,
33
],
[
38,
37
],
[
137,
41
],
[
142,
49
],
[
61,
52
],
[
143,
54
],
[
152,
58
],
[
68,
63
],
[
143,
65
],
[
71,
70
],
[
137,
74
],
[
145,
77
],
[
152,
79
],
[
70,
81
],
[
85,
84
],
[
96,
89
],
[
143,
91
],
[
70,
93
],
[
84,
95
],
[
143,
98
],
[
70,
99
],
[
84,
100
],
[
84,
106
],
[
146,
107
],
[
119,
110
],
[
143,
112
],
[
70,
114
],
[
84,
117
],
[
146,
118
],
[
143,
121
],
[
70,
122
],
[
84,
123
],
[
143,
129
],
[
137,
131
],
[
148,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
]
] | [
"N,A=map(int,input().split())\nx = list(map(int,input().split()))\ny = [val-A for val in x]\n\n# dp[i][j] : i枚目まで見て合計がj-2500のもの\ndp = [[0]*5001 for _ in range(N+1)]\ndp[0][y[0]+2500] = 1\ndp[0][2500] += 1\nfor i in range(N-1):\n new = y[i+1]\n for j in range(5001):\n dp[i+1][j] += dp[i][j]\n if 0 <= j+new <= 5000:\n dp[i+1][j+new] += dp[i][j]\nprint(dp[N-1][2500]-1)",
"N,A=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"val-A for val in x",
"for val in x",
"val",
"x",
"for val in x",
"val-A",
"val",
"A",
"y = [val-A for val in x]",
"y",
"[val-A for val in x]",
"[0]*5001 for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[0]*5001",
"[0]",
"0",
"5001",
"dp = [[0]*5001 for _ in range(N+1)]",
"dp",
"[[0]*5001 for _ in range(N+1)]",
"dp[0][y[0]+2500] = 1",
"dp[0][y[0]+2500]",
"[0]",
"dp",
"0",
"y[0]+2500",
"y[0]",
"y",
"0",
"2500",
"1",
"dp[0][2500] += 1",
"dp[0][2500]",
"[0]",
"dp",
"0",
"2500",
"1",
"for i in range(N-1):\n new = y[i+1]\n for j in range(5001):\n dp[i+1][j] += dp[i][j]\n if 0 <= j+new <= 5000:\n dp[i+1][j+new] += dp[i][j]",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"new = y[i+1]",
"new",
"y[i+1]",
"y",
"i+1",
"i",
"1",
"for j in range(5001):\n dp[i+1][j] += dp[i][j]\n if 0 <= j+new <= 5000:\n dp[i+1][j+new] += dp[i][j]",
"j",
"range(5001)",
"range",
"5001",
"dp[i+1][j] += dp[i][j]",
"dp[i+1][j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"if 0 <= j+new <= 5000:\n dp[i+1][j+new] += dp[i][j]",
"0 <= j+new <= 5000",
"0 <= j+new",
"0",
"j+new",
"j",
"new",
"5000",
"dp[i+1][j+new] += dp[i][j]",
"dp[i+1][j+new]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+new",
"j",
"new",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"print(dp[N-1][2500]-1)",
"print",
"dp[N-1][2500]-1",
"dp[N-1][2500]",
"[N-1]",
"dp",
"N-1",
"N",
"1",
"2500",
"1",
"N,A=map(int,input().split())",
"map(int,input().split())",
"N",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"dp = [[0]*5001 for _ in range(N+1)]",
"[[0]*5001 for _ in range(N+1)]",
"dp",
"new = y[i+1]",
"y[i+1]",
"new",
"A=map(int,input().split())",
"map(int,input().split())",
"A",
"y = [val-A for val in x]",
"[val-A for val in x]",
"y"
] | N,A=map(int,input().split())
x = list(map(int,input().split()))
y = [val-A for val in x]
# dp[i][j] : i枚目まで見て合計がj-2500のもの
dp = [[0]*5001 for _ in range(N+1)]
dp[0][y[0]+2500] = 1
dp[0][2500] += 1
for i in range(N-1):
new = y[i+1]
for j in range(5001):
dp[i+1][j] += dp[i][j]
if 0 <= j+new <= 5000:
dp[i+1][j+new] += dp[i][j]
print(dp[N-1][2500]-1)
|
[
7,
15,
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,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
2,
17,
17,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
2,
13,
13,
13,
0,
18,
18,
18,
13,
13,
2,
13,
17,
2,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
17,
13,
2,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13
] | [
[
180,
11
],
[
183,
16
],
[
26,
25
],
[
26,
34
],
[
37,
36
],
[
49,
48
],
[
57,
56
],
[
25,
60
],
[
66,
65
],
[
75,
68
],
[
65,
71
],
[
78,
77
],
[
25,
82
],
[
86,
85
],
[
36,
87
],
[
77,
89
],
[
93,
92
],
[
25,
95
],
[
98,
97
],
[
48,
100
],
[
109,
102
],
[
65,
105
],
[
77,
106
],
[
92,
107
],
[
97,
108
],
[
65,
112
],
[
77,
114
],
[
92,
116
],
[
97,
117
],
[
97,
121
],
[
85,
122
],
[
48,
123
],
[
136,
125
],
[
65,
128
],
[
77,
129
],
[
92,
131
],
[
97,
134
],
[
85,
135
],
[
65,
139
],
[
77,
141
],
[
92,
143
],
[
97,
144
],
[
147,
146
],
[
150,
149
],
[
25,
154
],
[
158,
157
],
[
65,
161
],
[
149,
163
],
[
34,
165
],
[
149,
166
],
[
157,
169
],
[
146,
169
],
[
178,
175
],
[
180,
181
],
[
183,
184
]
] | [
"import sys\n\nsys.setrecursionlimit(10 ** 7)\nf_inf = float('inf')\nmod = 10 ** 9 + 7\n\n\ndef resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = 50 * 50 + 1\n\n dp = [[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for j in range(n):\n for k in range(MAX):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n res += dp[-1][j][a * j]\n print(res)\n\n\nif __name__ == '__main__':\n resolve()",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 7",
"10",
"7",
"f_inf = float('inf')",
"f_inf",
"float('inf')",
"float",
"'inf'",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = 50 * 50 + 1\n\n dp = [[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for j in range(n):\n for k in range(MAX):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n res += dp[-1][j][a * j]\n print(res)",
"resolve",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"MAX = 50 * 50 + 1",
"MAX",
"50 * 50 + 1",
"50 * 50",
"50",
"50",
"1",
"[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)",
"for _ in range(n + 1)",
"_",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for _ in range(n + 1)",
"[[0] * MAX for _ in range(n + 1)]",
"dp = [[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]",
"dp",
"[[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(1, n + 1):\n x = X[i - 1]\n for j in range(n):\n for k in range(MAX):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n ",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"x = X[i - 1]",
"x",
"X[i - 1]",
"X",
"i - 1",
"i",
"1",
"for j in range(n):\n for k in range(MAX):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n ",
"j",
"range(n)",
"range",
"n",
"for k in range(MAX):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n ",
"k",
"range(MAX)",
"range",
"MAX",
"dp[i][j][k] += dp[i - 1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i - 1][j][k]",
"[j]",
"[i - 1]",
"dp",
"i - 1",
"i",
"1",
"j",
"k",
"if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n ",
"k + x < MAX",
"k + x",
"k",
"x",
"MAX",
"dp[i][j + 1][k + x] += dp[i - 1][j][k]",
"dp[i][j + 1][k + x]",
"[j + 1]",
"[i]",
"dp",
"i",
"j + 1",
"j",
"1",
"k + x",
"k",
"x",
"dp[i - 1][j][k]",
"[j]",
"[i - 1]",
"dp",
"i - 1",
"i",
"1",
"j",
"k",
"res = 0",
"res",
"0",
"for j in range(1, n + 1):\n res += dp[-1][j][a * j]\n ",
"j",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"res += dp[-1][j][a * j]",
"res",
"dp[-1][j][a * j]",
"[j]",
"[-1]",
"dp",
"-1",
"j",
"a * j",
"a",
"j",
"print(res)",
"print",
"res",
"if __name__ == '__main__':\n resolve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"resolve()",
"resolve",
"def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = 50 * 50 + 1\n\n dp = [[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for j in range(n):\n for k in range(MAX):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n res += dp[-1][j][a * j]\n print(res)",
"def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = 50 * 50 + 1\n\n dp = [[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 1\n for i in range(1, n + 1):\n x = X[i - 1]\n for j in range(n):\n for k in range(MAX):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n res += dp[-1][j][a * j]\n print(res)",
"resolve",
"f_inf = float('inf')",
"float('inf')",
"f_inf",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod"
] | import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, a = map(int, input().split())
X = list(map(int, input().split()))
MAX = 50 * 50 + 1
dp = [[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for i in range(1, n + 1):
x = X[i - 1]
for j in range(n):
for k in range(MAX):
dp[i][j][k] += dp[i - 1][j][k]
if k + x < MAX:
dp[i][j + 1][k + x] += dp[i - 1][j][k]
res = 0
for j in range(1, n + 1):
res += dp[-1][j][a * j]
print(res)
if __name__ == '__main__':
resolve()
|
[
7,
15,
13,
15,
15,
15,
13,
4,
18,
13,
13,
2,
17,
17,
12,
13,
41,
28,
13,
4,
18,
4,
13,
13,
17,
4,
4,
13,
13,
29,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
29,
13,
23,
13,
12,
13,
29,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
12,
13,
4,
13,
17,
31,
13,
0,
13,
18,
13,
13,
23,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
8,
2,
13,
2,
13,
13,
17,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
0,
13,
8,
2,
2,
13,
18,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
13,
13,
4,
13,
2,
18,
18,
18,
13,
17,
17,
17,
17,
10,
18,
13,
10,
12,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
8,
13,
10,
4,
13,
10,
12,
13
] | [
[
19,
18
],
[
18,
28
],
[
36,
35
],
[
47,
38
],
[
47,
47
],
[
72,
71
],
[
237,
77
],
[
214,
79
],
[
237,
80
],
[
225,
82
],
[
214,
84
],
[
216,
86
],
[
91,
90
],
[
223,
94
],
[
219,
99
],
[
103,
102
],
[
223,
106
],
[
110,
109
],
[
217,
112
],
[
121,
114
],
[
220,
117
],
[
223,
118
],
[
102,
119
],
[
109,
120
],
[
109,
123
],
[
102,
125
],
[
238,
126
],
[
131,
130
],
[
223,
134
],
[
140,
139
],
[
130,
143
],
[
147,
146
],
[
217,
149
],
[
210,
151
],
[
220,
155
],
[
130,
157
],
[
139,
159
],
[
146,
160
],
[
234,
162
],
[
146,
166
],
[
226,
168
],
[
130,
169
],
[
217,
170
],
[
220,
174
],
[
130,
176
],
[
139,
179
],
[
146,
182
],
[
226,
184
],
[
130,
185
],
[
195,
188
],
[
220,
191
],
[
130,
192
],
[
139,
193
],
[
146,
194
],
[
211,
196
],
[
235,
197
],
[
220,
204
],
[
210,
211
],
[
216,
217
],
[
219,
220
],
[
237,
223
],
[
225,
226
],
[
234,
235
],
[
237,
238
]
] | [
"import math\nfrom functools import reduce\nfrom collections import deque\nimport sys\nsys.setrecursionlimit(10**7)\n\n# スペース区切りの入力を読み込んで数値リストにして返します。\ndef get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。\ndef get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。\ndef get_all_int():\n return map(int, open(0).read().split())\n\ndef log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)\n\nn,a = get_nums_l()\nxxx = get_nums_l()\n\nvalMax = 2505\n\n# dp[i][j][k] = i番目まで処理して、選択した個数がjで、合計がkのとき、平均aにできるパターン数\ndp = [ [ [0]*valMax for __ in range(n+1) ] for _ in range(n+1) ]\n\nfor j in range(n+1):\n for k in range(valMax):\n dp[n][j][k] = 1 if k == j*a else 0\n\nfor i in range(n-1, -1, -1):\n for j in range(i+1):\n for k in range(valMax):\n no_pic = dp[i+1][j][k]\n pic = dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0\n dp[i][j][k] = no_pic + pic\n # if no_pic+pic > 0:\n # log((i,j,k), no_pic, pic, no_pic+pic)\n\nprint(dp[0][0][0] - 1)",
"import math",
"math",
"from functools import reduce",
"from collections import deque",
"import sys",
"sys",
"sys.setrecursionlimit(10**7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**7",
"10",
"7",
"def get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。",
"get_nums_l",
"int(s) for s in input().split(\" \")",
"for s in input().split(\" \")",
"s",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"for s in input().split(\" \")",
"int(s)",
"int",
"s",
"return [ int(s) for s in input().split(\" \")]",
"[ int(s) for s in input().split(\" \")]",
"def get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。",
"get_nums_n",
"int(input()) for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"int(input())",
"int",
"input()",
"input",
"return [ int(input()) for _ in range(n)]",
"[ int(input()) for _ in range(n)]",
"n",
"n",
"def get_all_int():\n return map(int, open(0).read().split())",
"get_all_int",
"return map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"def log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)",
"log",
"print(\"DEBUG:\", *args, file=sys.stderr)",
"print",
"\"DEBUG:\"",
"*args",
"args",
"file=sys.stderr",
"file",
"sys.stderr",
"sys",
"stderr",
"*args",
"n,a = get_nums_l()",
"n",
"get_nums_l()",
"get_nums_l",
"a",
"xxx = get_nums_l()",
"xxx",
"get_nums_l()",
"get_nums_l",
"valMax = 2505",
"valMax",
"2505",
"[ [0]*valMax for __ in range(n+1) ] for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"[ [0]*valMax for __ in range(n+1) ]",
"dp = [ [ [0]*valMax for __ in range(n+1) ] for _ in range(n+1) ]",
"dp",
"[ [ [0]*valMax for __ in range(n+1) ] for _ in range(n+1) ]",
"for j in range(n+1):\n for k in range(valMax):\n dp[n][j][k] = 1 if k == j*a else 0",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for k in range(valMax):\n dp[n][j][k] = 1 if k == j*a else 0",
"k",
"range(valMax)",
"range",
"valMax",
"dp[n][j][k] = 1 if k == j*a else 0",
"dp[n][j][k]",
"[j]",
"[n]",
"dp",
"n",
"j",
"k",
"1 if k == j*a else 0",
"k == j*a",
"k",
"j*a",
"j",
"a",
"1",
"0",
"for i in range(n-1, -1, -1):\n for j in range(i+1):\n for k in range(valMax):\n no_pic = dp[i+1][j][k]\n pic = dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0\n dp[i][j][k] = no_pic + pic\n # if no_pic+pic > 0:\n # log((i,j,k), no_pic, pic, no_pic+pic)",
"i",
"range(n-1, -1, -1)",
"range",
"n-1",
"n",
"1",
"-1",
"-1",
"for j in range(i+1):\n for k in range(valMax):\n no_pic = dp[i+1][j][k]\n pic = dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0\n dp[i][j][k] = no_pic + pic\n # if no_pic+pic > 0:\n # log((i,j,k), no_pic, pic, no_pic+pic)",
"j",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"for k in range(valMax):\n no_pic = dp[i+1][j][k]\n pic = dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0\n dp[i][j][k] = no_pic + pic\n # if no_pic+pic > 0:\n # log((i,j,k), no_pic, pic, no_pic+pic)",
"k",
"range(valMax)",
"range",
"valMax",
"no_pic = dp[i+1][j][k]",
"no_pic",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"pic = dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0",
"pic",
"dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0",
"k+xxx[i] < valMax",
"k+xxx[i]",
"k",
"xxx[i]",
"xxx",
"i",
"valMax",
"dp[i+1][j+1][k + xxx[i]]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k + xxx[i]",
"k",
"xxx[i]",
"xxx",
"i",
"0",
"dp[i][j][k] = no_pic + pic",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"no_pic + pic",
"no_pic",
"pic",
"print(dp[0][0][0] - 1)",
"print",
"dp[0][0][0] - 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"no_pic = dp[i+1][j][k]",
"dp[i+1][j][k]",
"no_pic",
"def get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。",
"def get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。",
"get_nums_l",
"valMax = 2505",
"2505",
"valMax",
"dp = [ [ [0]*valMax for __ in range(n+1) ] for _ in range(n+1) ]",
"[ [ [0]*valMax for __ in range(n+1) ] for _ in range(n+1) ]",
"dp",
"n,a = get_nums_l()",
"get_nums_l()",
"n",
"xxx = get_nums_l()",
"get_nums_l()",
"xxx",
"def log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)",
"def log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)",
"log",
"def get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。",
"def get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。",
"get_nums_n",
"pic = dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0",
"dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0",
"pic",
"a = get_nums_l()",
"get_nums_l()",
"a",
"def get_all_int():\n return map(int, open(0).read().split())",
"def get_all_int():\n return map(int, open(0).read().split())",
"get_all_int"
] | import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
n,a = get_nums_l()
xxx = get_nums_l()
valMax = 2505
# dp[i][j][k] = i番目まで処理して、選択した個数がjで、合計がkのとき、平均aにできるパターン数
dp = [ [ [0]*valMax for __ in range(n+1) ] for _ in range(n+1) ]
for j in range(n+1):
for k in range(valMax):
dp[n][j][k] = 1 if k == j*a else 0
for i in range(n-1, -1, -1):
for j in range(i+1):
for k in range(valMax):
no_pic = dp[i+1][j][k]
pic = dp[i+1][j+1][k + xxx[i]] if k+xxx[i] < valMax else 0
dp[i][j][k] = no_pic + pic
# if no_pic+pic > 0:
# log((i,j,k), no_pic, pic, no_pic+pic)
print(dp[0][0][0] - 1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
17,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
135,
2
],
[
135,
11
],
[
141,
13
],
[
27,
26
],
[
132,
33
],
[
43,
36
],
[
133,
39
],
[
46,
45
],
[
130,
48
],
[
51,
50
],
[
130,
53
],
[
56,
55
],
[
70,
61
],
[
133,
64
],
[
45,
66
],
[
50,
68
],
[
55,
69
],
[
133,
73
],
[
45,
74
],
[
50,
75
],
[
55,
76
],
[
93,
78
],
[
133,
81
],
[
45,
83
],
[
50,
86
],
[
55,
89
],
[
142,
91
],
[
45,
92
],
[
133,
96
],
[
45,
97
],
[
50,
98
],
[
55,
99
],
[
138,
101
],
[
105,
104
],
[
130,
109
],
[
126,
112
],
[
133,
116
],
[
130,
117
],
[
104,
118
],
[
104,
120
],
[
136,
121
],
[
127,
124
],
[
139,
124
],
[
126,
127
],
[
135,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\ndp = [[[0] * 3001 for i in range(51)] for j in range(51)]\n\ndp[0][0][0] = 1\n\nfor i in range(N):\n for j in range(N):\n for k in range(0, 2501):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]\n\nans = 0\nfor n in range(1, N+1):\n ans += dp[N][n][n*A]\n\nprint(ans)",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0] * 3001 for i in range(51)] for j in range(51)",
"for j in range(51)",
"j",
"range(51)",
"range",
"51",
"for j in range(51)",
"[[0] * 3001 for i in range(51)]",
"dp = [[[0] * 3001 for i in range(51)] for j in range(51)]",
"dp",
"[[[0] * 3001 for i in range(51)] for j in range(51)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(N):\n for j in range(N):\n for k in range(0, 2501):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"i",
"range(N)",
"range",
"N",
"for j in range(N):\n for k in range(0, 2501):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"j",
"range(N)",
"range",
"N",
"for k in range(0, 2501):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"k",
"range(0, 2501)",
"range",
"0",
"2501",
"dp[i+1][j][k] += dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i+1][j+1][k+X[i]] += dp[i][j][k]",
"dp[i+1][j+1][k+X[i]]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k+X[i]",
"k",
"X[i]",
"X",
"i",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"ans = 0",
"ans",
"0",
"for n in range(1, N+1):\n ans += dp[N][n][n*A]",
"n",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[N][n][n*A]",
"ans",
"dp[N][n][n*A]",
"[n]",
"[N]",
"dp",
"N",
"n",
"n*A",
"n",
"A",
"print(ans)",
"print",
"ans",
"ans += dp[N][n][n*A]",
"dp[N][n][n*A]",
"ans",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"dp = [[[0] * 3001 for i in range(51)] for j in range(51)]",
"[[[0] * 3001 for i in range(51)] for j in range(51)]",
"dp",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"ans = 0",
"0",
"ans",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X"
] | N, A = map(int, input().split())
X = list(map(int, input().split()))
dp = [[[0] * 3001 for i in range(51)] for j in range(51)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N):
for k in range(0, 2501):
dp[i+1][j][k] += dp[i][j][k]
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for n in range(1, N+1):
ans += dp[N][n][n*A]
print(ans) |
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
13,
28,
13,
4,
13,
17,
2,
2,
17,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
40,
18,
18,
18,
13,
13,
13,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
2,
13,
17,
18,
18,
18,
13,
13,
13,
13,
4,
13,
4,
13,
18,
18,
18,
13,
13,
2,
13,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
12
],
[
149,
14
],
[
149,
16
],
[
20,
19
],
[
19,
28
],
[
143,
30
],
[
35,
34
],
[
147,
39
],
[
152,
44
],
[
54,
47
],
[
153,
50
],
[
57,
56
],
[
147,
60
],
[
63,
62
],
[
147,
69
],
[
73,
72
],
[
147,
77
],
[
153,
84
],
[
56,
85
],
[
62,
86
],
[
72,
87
],
[
99,
90
],
[
153,
93
],
[
56,
95
],
[
62,
97
],
[
72,
98
],
[
153,
102
],
[
56,
103
],
[
62,
104
],
[
72,
105
],
[
122,
107
],
[
153,
110
],
[
56,
112
],
[
62,
115
],
[
144,
117
],
[
56,
118
],
[
72,
120
],
[
153,
125
],
[
56,
126
],
[
62,
127
],
[
72,
128
],
[
153,
136
],
[
147,
137
],
[
150,
139
],
[
143,
144
],
[
149,
147
],
[
149,
150
],
[
152,
153
]
] | [
"N,A = (int(T) for T in input().split())\nX = [int(T) for T in input().split()]\nDP = [[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)]\nDP[0][0][0] = 1\nfor TI in range(0,N):\n for TS in range(0,50*N+1):\n for TK in range(0,N+1):\n if DP[TI][TS][TK]!=0:\n DP[TI+1][TS][TK] += DP[TI][TS][TK]\n DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]\nprint(sum(DP[N][A*TA][TA] for TA in range(1,N+1)))",
"int(T) for T in input().split()",
"for T in input().split()",
"T",
"input().split()",
"().split",
"()",
"input",
"split",
"for T in input().split()",
"int(T)",
"int",
"T",
"N,A = (int(T) for T in input().split())",
"N",
"(int(T) for T in input().split())",
"A",
"int(T) for T in input().split()",
"for T in input().split()",
"T",
"input().split()",
"().split",
"()",
"input",
"split",
"for T in input().split()",
"int(T)",
"int",
"T",
"X = [int(T) for T in input().split()]",
"X",
"[int(T) for T in input().split()]",
"[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)",
"for TI in range(0,N+1)",
"TI",
"range(0,N+1)",
"range",
"0",
"N+1",
"N",
"1",
"for TI in range(0,N+1)",
"[[0]*(N+1) for TS in range(0,50*N+1)]",
"DP = [[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)]",
"DP",
"[[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)]",
"DP[0][0][0] = 1",
"DP[0][0][0]",
"[0]",
"[0]",
"DP",
"0",
"0",
"0",
"1",
"for TI in range(0,N):\n for TS in range(0,50*N+1):\n for TK in range(0,N+1):\n if DP[TI][TS][TK]!=0:\n DP[TI+1][TS][TK] += DP[TI][TS][TK]\n DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]",
"TI",
"range(0,N)",
"range",
"0",
"N",
"for TS in range(0,50*N+1):\n for TK in range(0,N+1):\n if DP[TI][TS][TK]!=0:\n DP[TI+1][TS][TK] += DP[TI][TS][TK]\n DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]",
"TS",
"range(0,50*N+1)",
"range",
"0",
"50*N+1",
"50*N",
"50",
"N",
"1",
"for TK in range(0,N+1):\n if DP[TI][TS][TK]!=0:\n DP[TI+1][TS][TK] += DP[TI][TS][TK]\n DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]",
"TK",
"range(0,N+1)",
"range",
"0",
"N+1",
"N",
"1",
"if DP[TI][TS][TK]!=0:\n DP[TI+1][TS][TK] += DP[TI][TS][TK]\n DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]",
"DP[TI][TS][TK]!=0",
"DP[TI][TS][TK]",
"[TS]",
"[TI]",
"DP",
"TI",
"TS",
"TK",
"0",
"DP[TI+1][TS][TK] += DP[TI][TS][TK]",
"DP[TI+1][TS][TK]",
"[TS]",
"[TI+1]",
"DP",
"TI+1",
"TI",
"1",
"TS",
"TK",
"DP[TI][TS][TK]",
"[TS]",
"[TI]",
"DP",
"TI",
"TS",
"TK",
"DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]",
"DP[TI+1][TS+X[TI]][TK+1]",
"[TS+X[TI]]",
"[TI+1]",
"DP",
"TI+1",
"TI",
"1",
"TS+X[TI]",
"TS",
"X[TI]",
"X",
"TI",
"TK+1",
"TK",
"1",
"DP[TI][TS][TK]",
"[TS]",
"[TI]",
"DP",
"TI",
"TS",
"TK",
"print(sum(DP[N][A*TA][TA] for TA in range(1,N+1)))",
"print",
"sum(DP[N][A*TA][TA] for TA in range(1,N+1))",
"sum",
"DP[N][A*TA][TA]",
"[A*TA]",
"[N]",
"DP",
"N",
"A*TA",
"A",
"TA",
"TA",
"X = [int(T) for T in input().split()]",
"[int(T) for T in input().split()]",
"X",
"N,A = (int(T) for T in input().split())",
"(int(T) for T in input().split())",
"N",
"A = (int(T) for T in input().split())",
"(int(T) for T in input().split())",
"A",
"DP = [[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)]",
"[[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)]",
"DP"
] | N,A = (int(T) for T in input().split())
X = [int(T) for T in input().split()]
DP = [[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)]
DP[0][0][0] = 1
for TI in range(0,N):
for TS in range(0,50*N+1):
for TK in range(0,N+1):
if DP[TI][TS][TK]!=0:
DP[TI+1][TS][TK] += DP[TI][TS][TK]
DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]
print(sum(DP[N][A*TA][TA] for TA in range(1,N+1))) |
[
7,
12,
13,
29,
4,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
13,
17,
12,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
41,
28,
13,
4,
13,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
18,
18,
18,
13,
17,
17,
13,
17,
28,
13,
4,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
40,
2,
13,
18,
13,
2,
13,
17,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
13,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
2,
13,
13,
13,
13,
29,
13,
14,
2,
13,
17,
4,
13,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
33,
32
],
[
176,
34
],
[
33,
35
],
[
38,
37
],
[
176,
39
],
[
43,
42
],
[
50,
49
],
[
53,
52
],
[
32,
56
],
[
66,
59
],
[
49,
62
],
[
52,
65
],
[
69,
68
],
[
49,
73
],
[
76,
75
],
[
32,
80
],
[
84,
83
],
[
32,
88
],
[
68,
93
],
[
37,
95
],
[
83,
97
],
[
108,
101
],
[
49,
104
],
[
68,
105
],
[
75,
106
],
[
83,
107
],
[
49,
111
],
[
68,
113
],
[
37,
115
],
[
83,
117
],
[
75,
120
],
[
83,
123
],
[
133,
126
],
[
49,
129
],
[
68,
130
],
[
75,
131
],
[
83,
132
],
[
49,
136
],
[
68,
137
],
[
75,
138
],
[
83,
140
],
[
144,
143
],
[
147,
146
],
[
32,
151
],
[
155,
154
],
[
49,
158
],
[
35,
160
],
[
146,
161
],
[
146,
162
],
[
32,
163
],
[
154,
165
],
[
143,
165
],
[
182,
173
]
] | [
"\n\ndef read_int():\n return int(input().strip())\n\n\ndef read_ints():\n return list(map(int, input().strip().split(' ')))\n\n\ndef solve():\n \"\"\"\n OPT[i][j][k] - sum is i, j number of elements, first k elements\n OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken\n OPT[i][j][k-1]\n\n OPT[A*j][j][k] for all k\n \"\"\"\n N, A = read_ints()\n x = read_ints()\n OPT = [[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]\n for k in range(N+1):\n OPT[0][0][k] = 1\n for i in range(len(OPT)):\n for j in range(1, N+1):\n for k in range(1, N+1):\n if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n OPT[i][j][k] += OPT[i][j][k-1]\n T = 0\n for j in range(1, N+1):\n T += OPT[A*j][j][N]\n return T\n\n\nif __name__ == '__main__':\n print(solve())",
"def read_int():\n return int(input().strip())",
"read_int",
"return int(input().strip())",
"int(input().strip())",
"int",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"def read_ints():\n return list(map(int, input().strip().split(' ')))",
"read_ints",
"return list(map(int, input().strip().split(' ')))",
"list(map(int, input().strip().split(' ')))",
"list",
"map(int, input().strip().split(' '))",
"map",
"int",
"input().strip().split(' ')",
"().strip().split",
"().strip()",
"().strip",
"()",
"input",
"strip",
"split",
"' '",
"def solve():\n \"\"\"\n OPT[i][j][k] - sum is i, j number of elements, first k elements\n OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken\n OPT[i][j][k-1]\n\n OPT[A*j][j][k] for all k\n \"\"\"\n N, A = read_ints()\n x = read_ints()\n OPT = [[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]\n for k in range(N+1):\n OPT[0][0][k] = 1\n for i in range(len(OPT)):\n for j in range(1, N+1):\n for k in range(1, N+1):\n if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n OPT[i][j][k] += OPT[i][j][k-1]\n T = 0\n for j in range(1, N+1):\n T += OPT[A*j][j][N]\n return T",
"solve",
"\"\"\"\n OPT[i][j][k] - sum is i, j number of elements, first k elements\n OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken\n OPT[i][j][k-1]\n\n OPT[A*j][j][k] for all k\n \"\"\"",
"N, A = read_ints()",
"N",
"read_ints()",
"read_ints",
"A",
"x = read_ints()",
"x",
"read_ints()",
"read_ints",
"[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)",
"for _ in range(2501)",
"_",
"range(2501)",
"range",
"2501",
"for _ in range(2501)",
"[[0 for _ in range(51)] for _ in range(51)]",
"OPT = [[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]",
"OPT",
"[[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]",
"for k in range(N+1):\n OPT[0][0][k] = 1\n ",
"k",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"OPT[0][0][k] = 1",
"OPT[0][0][k]",
"[0]",
"[0]",
"OPT",
"0",
"0",
"k",
"1",
"for i in range(len(OPT)):\n for j in range(1, N+1):\n for k in range(1, N+1):\n if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n OPT[i][j][k] += OPT[i][j][k-1]\n ",
"i",
"range(len(OPT))",
"range",
"len(OPT)",
"len",
"OPT",
"for j in range(1, N+1):\n for k in range(1, N+1):\n if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n OPT[i][j][k] += OPT[i][j][k-1]\n ",
"j",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for k in range(1, N+1):\n if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n OPT[i][j][k] += OPT[i][j][k-1]\n ",
"k",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n ",
"i-x[k-1] >= 0",
"i-x[k-1]",
"i",
"x[k-1]",
"x",
"k-1",
"k",
"1",
"0",
"OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]",
"OPT[i][j][k]",
"[j]",
"[i]",
"OPT",
"i",
"j",
"k",
"OPT[i-x[k-1]][j-1][k-1]",
"[j-1]",
"[i-x[k-1]]",
"OPT",
"i-x[k-1]",
"i",
"x[k-1]",
"x",
"k-1",
"k",
"1",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"OPT[i][j][k] += OPT[i][j][k-1]",
"OPT[i][j][k]",
"[j]",
"[i]",
"OPT",
"i",
"j",
"k",
"OPT[i][j][k-1]",
"[j]",
"[i]",
"OPT",
"i",
"j",
"k-1",
"k",
"1",
"T = 0",
"T",
"0",
"for j in range(1, N+1):\n T += OPT[A*j][j][N]\n ",
"j",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"T += OPT[A*j][j][N]",
"T",
"OPT[A*j][j][N]",
"[j]",
"[A*j]",
"OPT",
"A*j",
"A",
"j",
"j",
"N",
"return T",
"T",
"if __name__ == '__main__':\n print(solve())",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"print(solve())",
"print",
"solve()",
"solve",
"def read_ints():\n return list(map(int, input().strip().split(' ')))",
"def read_ints():\n return list(map(int, input().strip().split(' ')))",
"read_ints",
"def read_int():\n return int(input().strip())",
"def read_int():\n return int(input().strip())",
"read_int",
"def solve():\n \"\"\"\n OPT[i][j][k] - sum is i, j number of elements, first k elements\n OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken\n OPT[i][j][k-1]\n\n OPT[A*j][j][k] for all k\n \"\"\"\n N, A = read_ints()\n x = read_ints()\n OPT = [[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]\n for k in range(N+1):\n OPT[0][0][k] = 1\n for i in range(len(OPT)):\n for j in range(1, N+1):\n for k in range(1, N+1):\n if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n OPT[i][j][k] += OPT[i][j][k-1]\n T = 0\n for j in range(1, N+1):\n T += OPT[A*j][j][N]\n return T",
"def solve():\n \"\"\"\n OPT[i][j][k] - sum is i, j number of elements, first k elements\n OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken\n OPT[i][j][k-1]\n\n OPT[A*j][j][k] for all k\n \"\"\"\n N, A = read_ints()\n x = read_ints()\n OPT = [[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]\n for k in range(N+1):\n OPT[0][0][k] = 1\n for i in range(len(OPT)):\n for j in range(1, N+1):\n for k in range(1, N+1):\n if i-x[k-1] >= 0:\n OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]\n OPT[i][j][k] += OPT[i][j][k-1]\n T = 0\n for j in range(1, N+1):\n T += OPT[A*j][j][N]\n return T",
"solve"
] |
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
OPT[i][j][k] - sum is i, j number of elements, first k elements
OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken
OPT[i][j][k-1]
OPT[A*j][j][k] for all k
"""
N, A = read_ints()
x = read_ints()
OPT = [[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]
for k in range(N+1):
OPT[0][0][k] = 1
for i in range(len(OPT)):
for j in range(1, N+1):
for k in range(1, N+1):
if i-x[k-1] >= 0:
OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]
OPT[i][j][k] += OPT[i][j][k-1]
T = 0
for j in range(1, N+1):
T += OPT[A*j][j][N]
return T
if __name__ == '__main__':
print(solve())
|
[
7,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
18,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
14,
2,
40,
13,
17,
40,
13,
18,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
2,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
13,
2,
13,
17,
2,
13,
18,
13,
13,
14,
2,
2,
40,
13,
2,
13,
17,
2,
13,
2,
13,
13,
40,
13,
17,
14,
40,
18,
18,
18,
13,
2,
13,
17,
13,
13,
17,
0,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
4,
13,
4,
13,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
210,
2
],
[
210,
13
],
[
204,
15
],
[
30,
29
],
[
205,
32
],
[
36,
35
],
[
191,
39
],
[
45,
44
],
[
54,
47
],
[
44,
50
],
[
57,
56
],
[
60,
59
],
[
191,
62
],
[
65,
64
],
[
193,
68
],
[
72,
71
],
[
29,
75
],
[
71,
79
],
[
205,
81
],
[
59,
82
],
[
93,
84
],
[
44,
87
],
[
59,
89
],
[
64,
91
],
[
71,
92
],
[
44,
96
],
[
59,
97
],
[
64,
98
],
[
71,
99
],
[
64,
103
],
[
71,
106
],
[
205,
108
],
[
59,
109
],
[
120,
111
],
[
44,
114
],
[
59,
116
],
[
64,
118
],
[
71,
119
],
[
44,
124
],
[
59,
125
],
[
64,
126
],
[
71,
127
],
[
44,
131
],
[
59,
132
],
[
64,
134
],
[
71,
137
],
[
205,
139
],
[
59,
140
],
[
64,
145
],
[
59,
147
],
[
71,
150
],
[
64,
152
],
[
195,
153
],
[
64,
155
],
[
111,
159
],
[
84,
159
],
[
44,
162
],
[
59,
164
],
[
64,
166
],
[
71,
167
],
[
171,
170
],
[
111,
172
],
[
84,
172
],
[
44,
175
],
[
59,
177
],
[
64,
179
],
[
71,
180
],
[
44,
184
],
[
59,
185
],
[
64,
186
],
[
71,
187
],
[
170,
189
],
[
56,
189
],
[
191,
191
],
[
193,
193
],
[
195,
195
],
[
214,
199
],
[
211,
200
],
[
211,
201
],
[
208,
202
],
[
204,
205
],
[
210,
208
],
[
210,
211
]
] | [
"n,a = list(map(int,input().split()))\nx = list(map(int,input().split()))\n\ndef Count(n,k,a):\n\ts = sum(x)\n\tdp=[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]\n\tdp[0][0][0]=1\n\tSum=0\n\tfor i in range(n):\n\t\tfor j in range(k+1):\n\t\t\tfor l in range(s+1):\n\t\t\t\tif l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\tif j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\tif j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\treturn Sum\n\nprint(Count(n,n,a))\n",
"n,a = list(map(int,input().split()))",
"n",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def Count(n,k,a):\n\ts = sum(x)\n\tdp=[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]\n\tdp[0][0][0]=1\n\tSum=0\n\tfor i in range(n):\n\t\tfor j in range(k+1):\n\t\t\tfor l in range(s+1):\n\t\t\t\tif l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\tif j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\tif j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\treturn Sum",
"Count",
"s = sum(x)",
"s",
"sum(x)",
"sum",
"x",
"[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[[0 for l in range(s+1)] for j in range(k+1)]",
"dp=[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]",
"dp",
"[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]",
"dp[0][0][0]=1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"Sum=0",
"Sum",
"0",
"for i in range(n):\n\t\tfor j in range(k+1):\n\t\t\tfor l in range(s+1):\n\t\t\t\tif l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\tif j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\tif j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\t",
"i",
"range(n)",
"range",
"n",
"for j in range(k+1):\n\t\t\tfor l in range(s+1):\n\t\t\t\tif l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\tif j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\tif j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\t",
"j",
"range(k+1)",
"range",
"k+1",
"k",
"1",
"for l in range(s+1):\n\t\t\t\tif l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\tif j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\tif j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\t",
"l",
"range(s+1)",
"range",
"s+1",
"s",
"1",
"if l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\t",
"l < x[i]",
"l",
"x[i]",
"x",
"i",
"dp[i+1][j][l] = dp[i][j][l]",
"dp[i+1][j][l]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"l",
"dp[i][j][l]",
"[j]",
"[i]",
"dp",
"i",
"j",
"l",
"if j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\t",
"j >=1 and l >= x[i]",
"j >=1",
"j",
"1",
"l >= x[i]",
"l",
"x[i]",
"x",
"i",
"dp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]",
"dp[i+1][j][l]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"l",
"dp[i][j][l] + dp[i][j-1][l-x[i]]",
"dp[i][j][l]",
"[j]",
"[i]",
"dp",
"i",
"j",
"l",
"dp[i][j-1][l-x[i]]",
"[j-1]",
"[i]",
"dp",
"i",
"j-1",
"j",
"1",
"l-x[i]",
"l",
"x[i]",
"x",
"i",
"if j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\t",
"j <= i+1 and l ==j*a and j >= 1",
"j <= i+1 and l ==j*a",
"j <= i+1",
"j",
"i+1",
"i",
"1",
"l ==j*a",
"l",
"j*a",
"j",
"a",
"j >= 1",
"j",
"1",
"if dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\t",
"dp[i+1][j][l]>=1",
"dp[i+1][j][l]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"l",
"1",
"Sum += dp[i+1][j][l]-dp[i][j][l]",
"Sum",
"dp[i+1][j][l]-dp[i][j][l]",
"dp[i+1][j][l]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"l",
"dp[i][j][l]",
"[j]",
"[i]",
"dp",
"i",
"j",
"l",
"return Sum",
"Sum",
"n",
"n",
"k",
"k",
"a",
"a",
"print(Count(n,n,a))",
"print",
"Count(n,n,a)",
"Count",
"n",
"n",
"a",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"n,a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"n",
"def Count(n,k,a):\n\ts = sum(x)\n\tdp=[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]\n\tdp[0][0][0]=1\n\tSum=0\n\tfor i in range(n):\n\t\tfor j in range(k+1):\n\t\t\tfor l in range(s+1):\n\t\t\t\tif l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\tif j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\tif j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\treturn Sum",
"def Count(n,k,a):\n\ts = sum(x)\n\tdp=[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]\n\tdp[0][0][0]=1\n\tSum=0\n\tfor i in range(n):\n\t\tfor j in range(k+1):\n\t\t\tfor l in range(s+1):\n\t\t\t\tif l < x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l]\n\t\t\t\tif j >=1 and l >= x[i]:\n\t\t\t\t\tdp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]\n\t\t\t\tif j <= i+1 and l ==j*a and j >= 1:\n\t\t\t\t\tif dp[i+1][j][l]>=1:\t\n\t\t\t\t\t\tSum += dp[i+1][j][l]-dp[i][j][l]\n\treturn Sum",
"Count"
] | n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
def Count(n,k,a):
s = sum(x)
dp=[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]
dp[0][0][0]=1
Sum=0
for i in range(n):
for j in range(k+1):
for l in range(s+1):
if l < x[i]:
dp[i+1][j][l] = dp[i][j][l]
if j >=1 and l >= x[i]:
dp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]
if j <= i+1 and l ==j*a and j >= 1:
if dp[i+1][j][l]>=1:
Sum += dp[i+1][j][l]-dp[i][j][l]
return Sum
print(Count(n,n,a))
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
17,
14,
40,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
14,
2,
40,
13,
17,
40,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
2,
13,
17,
2,
13,
13,
0,
13,
4,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13
] | [
[
142,
2
],
[
142,
11
],
[
133,
13
],
[
27,
26
],
[
145,
33
],
[
43,
36
],
[
146,
39
],
[
46,
45
],
[
137,
48
],
[
148,
50
],
[
134,
52
],
[
45,
53
],
[
56,
55
],
[
45,
59
],
[
63,
62
],
[
45,
68
],
[
55,
69
],
[
80,
71
],
[
146,
74
],
[
45,
76
],
[
55,
78
],
[
62,
79
],
[
146,
83
],
[
45,
84
],
[
55,
85
],
[
62,
86
],
[
55,
90
],
[
62,
93
],
[
149,
94
],
[
105,
96
],
[
146,
99
],
[
45,
101
],
[
55,
103
],
[
62,
104
],
[
146,
108
],
[
45,
109
],
[
55,
111
],
[
62,
114
],
[
149,
115
],
[
139,
117
],
[
146,
123
],
[
137,
124
],
[
143,
127
],
[
140,
131
],
[
133,
134
],
[
142,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\n\ndp = [[[0]*(2501) for i in range(51)] for j in range(51)]\ndp[0][0][0] = 1\nfor i in range(N):\n value = X[i]\n for j in range(i+2):\n for k in range(2501):\n if i >= j:\n dp[i+1][j][k] += dp[i][j][k]\n if j >= 1 and k >= value:\n dp[i+1][j][k] += dp[i][j-1][k-value]\n\nans = sum(dp[N][x][A*x] for x in range(1,N+1))\n\nprint(ans)\n",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0]*(2501) for i in range(51)] for j in range(51)",
"for j in range(51)",
"j",
"range(51)",
"range",
"51",
"for j in range(51)",
"[[0]*(2501) for i in range(51)]",
"dp = [[[0]*(2501) for i in range(51)] for j in range(51)]",
"dp",
"[[[0]*(2501) for i in range(51)] for j in range(51)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(N):\n value = X[i]\n for j in range(i+2):\n for k in range(2501):\n if i >= j:\n dp[i+1][j][k] += dp[i][j][k]\n if j >= 1 and k >= value:\n dp[i+1][j][k] += dp[i][j-1][k-value]",
"i",
"range(N)",
"range",
"N",
"value = X[i]",
"value",
"X[i]",
"X",
"i",
"for j in range(i+2):\n for k in range(2501):\n if i >= j:\n dp[i+1][j][k] += dp[i][j][k]\n if j >= 1 and k >= value:\n dp[i+1][j][k] += dp[i][j-1][k-value]",
"j",
"range(i+2)",
"range",
"i+2",
"i",
"2",
"for k in range(2501):\n if i >= j:\n dp[i+1][j][k] += dp[i][j][k]\n if j >= 1 and k >= value:\n dp[i+1][j][k] += dp[i][j-1][k-value]",
"k",
"range(2501)",
"range",
"2501",
"if i >= j:\n dp[i+1][j][k] += dp[i][j][k]\n ",
"i >= j",
"i",
"j",
"dp[i+1][j][k] += dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"if j >= 1 and k >= value:\n dp[i+1][j][k] += dp[i][j-1][k-value]",
"j >= 1 and k >= value",
"j >= 1",
"j",
"1",
"k >= value",
"k",
"value",
"dp[i+1][j][k] += dp[i][j-1][k-value]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j-1][k-value]",
"[j-1]",
"[i]",
"dp",
"i",
"j-1",
"j",
"1",
"k-value",
"k",
"value",
"ans = sum(dp[N][x][A*x] for x in range(1,N+1))",
"ans",
"sum(dp[N][x][A*x] for x in range(1,N+1))",
"sum",
"dp[N][x][A*x]",
"[x]",
"[N]",
"dp",
"N",
"x",
"A*x",
"A",
"x",
"print(ans)",
"print",
"ans",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans = sum(dp[N][x][A*x] for x in range(1,N+1))",
"sum(dp[N][x][A*x] for x in range(1,N+1))",
"ans",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"dp = [[[0]*(2501) for i in range(51)] for j in range(51)]",
"[[[0]*(2501) for i in range(51)] for j in range(51)]",
"dp",
"value = X[i]",
"X[i]",
"value"
] | N, A = map(int, input().split())
X = list(map(int, input().split()))
dp = [[[0]*(2501) for i in range(51)] for j in range(51)]
dp[0][0][0] = 1
for i in range(N):
value = X[i]
for j in range(i+2):
for k in range(2501):
if i >= j:
dp[i+1][j][k] += dp[i][j][k]
if j >= 1 and k >= value:
dp[i+1][j][k] += dp[i][j-1][k-value]
ans = sum(dp[N][x][A*x] for x in range(1,N+1))
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
17,
14,
2,
40,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
2,
40,
13,
17,
40,
13,
17,
40,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
217,
2
],
[
217,
11
],
[
214,
13
],
[
223,
25
],
[
215,
28
],
[
32,
31
],
[
218,
35
],
[
220,
40
],
[
44,
43
],
[
218,
47
],
[
51,
50
],
[
218,
54
],
[
58,
57
],
[
224,
61
],
[
43,
67
],
[
50,
70
],
[
57,
73
],
[
83,
76
],
[
221,
79
],
[
43,
80
],
[
50,
81
],
[
57,
82
],
[
43,
87
],
[
57,
90
],
[
215,
92
],
[
43,
94
],
[
104,
97
],
[
221,
100
],
[
43,
101
],
[
50,
102
],
[
57,
103
],
[
221,
107
],
[
43,
109
],
[
50,
111
],
[
57,
112
],
[
43,
117
],
[
50,
120
],
[
57,
123
],
[
215,
125
],
[
43,
127
],
[
137,
130
],
[
221,
133
],
[
43,
134
],
[
50,
135
],
[
57,
136
],
[
221,
141
],
[
43,
143
],
[
50,
145
],
[
57,
146
],
[
221,
150
],
[
43,
152
],
[
50,
155
],
[
57,
158
],
[
215,
160
],
[
43,
162
],
[
172,
165
],
[
221,
168
],
[
43,
169
],
[
50,
170
],
[
57,
171
],
[
208,
174
],
[
178,
177
],
[
218,
182
],
[
206,
187
],
[
177,
188
],
[
224,
189
],
[
211,
191
],
[
221,
195
],
[
218,
196
],
[
177,
197
],
[
206,
199
],
[
177,
200
],
[
212,
203
],
[
209,
203
],
[
217,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
]
] | [
"n, a = map(int, input().split())\nX = list(map(int, input().split()))\n\n# editorial 参照 -> 3 dimentional DP\n# 制約1: x1-xjのカード, 制約2: k枚選択, 制約3: 点数合計A*k\nsum_X = sum(X)\nDP = [[[0 for _ in range(sum_X+1)] for _ in range(n+1)] for _ in range(n+1)]\n\n\nfor j in range(n+1):\n for k in range(n+1):\n for s in range(sum_X+1):\n if (j==0) and (k==0) and (s==0):\n DP[j][k][s] = 1\n elif (j >= 1) and (s < X[j-1]):\n DP[j][k][s] = DP[j-1][k][s]\n elif (j >= 1) and (k >= 1) and (s >= X[j-1]):\n DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]\n else:\n DP[j][k][s] = 0\n\nans = 0\nfor k in range(1, n+1):\n if a*k > sum_X:\n pass\n else:\n ans += DP[n][k][a*k]\n\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sum_X = sum(X)",
"sum_X",
"sum(X)",
"sum",
"X",
"[[0 for _ in range(sum_X+1)] for _ in range(n+1)] for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"[[0 for _ in range(sum_X+1)] for _ in range(n+1)]",
"DP = [[[0 for _ in range(sum_X+1)] for _ in range(n+1)] for _ in range(n+1)]",
"DP",
"[[[0 for _ in range(sum_X+1)] for _ in range(n+1)] for _ in range(n+1)]",
"for j in range(n+1):\n for k in range(n+1):\n for s in range(sum_X+1):\n if (j==0) and (k==0) and (s==0):\n DP[j][k][s] = 1\n elif (j >= 1) and (s < X[j-1]):\n DP[j][k][s] = DP[j-1][k][s]\n elif (j >= 1) and (k >= 1) and (s >= X[j-1]):\n DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]\n else:\n DP[j][k][s] = 0",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for k in range(n+1):\n for s in range(sum_X+1):\n if (j==0) and (k==0) and (s==0):\n DP[j][k][s] = 1\n elif (j >= 1) and (s < X[j-1]):\n DP[j][k][s] = DP[j-1][k][s]\n elif (j >= 1) and (k >= 1) and (s >= X[j-1]):\n DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]\n else:\n DP[j][k][s] = 0",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for s in range(sum_X+1):\n if (j==0) and (k==0) and (s==0):\n DP[j][k][s] = 1\n elif (j >= 1) and (s < X[j-1]):\n DP[j][k][s] = DP[j-1][k][s]\n elif (j >= 1) and (k >= 1) and (s >= X[j-1]):\n DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]\n else:\n DP[j][k][s] = 0",
"s",
"range(sum_X+1)",
"range",
"sum_X+1",
"sum_X",
"1",
"if (j==0) and (k==0) and (s==0):\n DP[j][k][s] = 1\n elif (j >= 1) and (s < X[j-1]):\n DP[j][k][s] = DP[j-1][k][s]\n elif (j >= 1) and (k >= 1) and (s >= X[j-1]):\n DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]\n else:\n DP[j][k][s] = 0",
"(j==0) and (k==0) and (s==0)",
"(j==0) and (k==0)",
"j==0",
"j",
"0",
"k==0",
"k",
"0",
"s==0",
"s",
"0",
"DP[j][k][s] = 1",
"DP[j][k][s]",
"[k]",
"[j]",
"DP",
"j",
"k",
"s",
"1",
"elif (j >= 1) and (s < X[j-1]):\n DP[j][k][s] = DP[j-1][k][s]\n ",
"(j >= 1) and (s < X[j-1])",
"j >= 1",
"j",
"1",
"s < X[j-1]",
"s",
"X[j-1]",
"X",
"j-1",
"j",
"1",
"DP[j][k][s] = DP[j-1][k][s]",
"DP[j][k][s]",
"[k]",
"[j]",
"DP",
"j",
"k",
"s",
"DP[j-1][k][s]",
"[k]",
"[j-1]",
"DP",
"j-1",
"j",
"1",
"k",
"s",
"elif (j >= 1) and (k >= 1) and (s >= X[j-1]):\n DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]\n ",
"(j >= 1) and (k >= 1) and (s >= X[j-1])",
"(j >= 1) and (k >= 1)",
"j >= 1",
"j",
"1",
"k >= 1",
"k",
"1",
"s >= X[j-1]",
"s",
"X[j-1]",
"X",
"j-1",
"j",
"1",
"DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]",
"DP[j][k][s]",
"[k]",
"[j]",
"DP",
"j",
"k",
"s",
"DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]",
"DP[j-1][k][s]",
"[k]",
"[j-1]",
"DP",
"j-1",
"j",
"1",
"k",
"s",
"DP[j-1][k-1][s-X[j-1]]",
"[k-1]",
"[j-1]",
"DP",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"s-X[j-1]",
"s",
"X[j-1]",
"X",
"j-1",
"j",
"1",
"DP[j][k][s] = 0",
"DP[j][k][s]",
"[k]",
"[j]",
"DP",
"j",
"k",
"s",
"0",
"ans = 0",
"ans",
"0",
"for k in range(1, n+1):\n if a*k > sum_X:\n pass\n else:\n ans += DP[n][k][a*k]",
"k",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"if a*k > sum_X:\n pass\n else:\n ans += DP[n][k][a*k]",
"a*k > sum_X",
"a*k",
"a",
"k",
"sum_X",
"ans += DP[n][k][a*k]",
"ans",
"DP[n][k][a*k]",
"[k]",
"[n]",
"DP",
"n",
"k",
"a*k",
"a",
"k",
"print(ans)",
"print",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"ans = 0",
"0",
"ans",
"ans += DP[n][k][a*k]",
"DP[n][k][a*k]",
"ans",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"DP = [[[0 for _ in range(sum_X+1)] for _ in range(n+1)] for _ in range(n+1)]",
"[[[0 for _ in range(sum_X+1)] for _ in range(n+1)] for _ in range(n+1)]",
"DP",
"sum_X = sum(X)",
"sum(X)",
"sum_X"
] | n, a = map(int, input().split())
X = list(map(int, input().split()))
# editorial 参照 -> 3 dimentional DP
# 制約1: x1-xjのカード, 制約2: k枚選択, 制約3: 点数合計A*k
sum_X = sum(X)
DP = [[[0 for _ in range(sum_X+1)] for _ in range(n+1)] for _ in range(n+1)]
for j in range(n+1):
for k in range(n+1):
for s in range(sum_X+1):
if (j==0) and (k==0) and (s==0):
DP[j][k][s] = 1
elif (j >= 1) and (s < X[j-1]):
DP[j][k][s] = DP[j-1][k][s]
elif (j >= 1) and (k >= 1) and (s >= X[j-1]):
DP[j][k][s] = DP[j-1][k][s] + DP[j-1][k-1][s-X[j-1]]
else:
DP[j][k][s] = 0
ans = 0
for k in range(1, n+1):
if a*k > sum_X:
pass
else:
ans += DP[n][k][a*k]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
2,
13,
17,
0,
18,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
17,
28,
13,
4,
13,
17,
17,
17,
14,
2,
18,
18,
13,
13,
13,
40,
2,
13,
18,
13,
2,
13,
17,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
18,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
13,
13,
2,
13,
13,
4,
13,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13
] | [
[
151,
2
],
[
151,
11
],
[
15,
14
],
[
14,
23
],
[
157,
25
],
[
30,
29
],
[
149,
33
],
[
145,
41
],
[
45,
44
],
[
149,
48
],
[
52,
51
],
[
44,
55
],
[
51,
61
],
[
75,
64
],
[
146,
66
],
[
51,
68
],
[
158,
71
],
[
44,
73
],
[
78,
77
],
[
146,
87
],
[
51,
88
],
[
77,
89
],
[
77,
92
],
[
158,
94
],
[
44,
96
],
[
113,
100
],
[
146,
102
],
[
51,
104
],
[
77,
107
],
[
158,
109
],
[
44,
111
],
[
146,
115
],
[
51,
116
],
[
77,
117
],
[
142,
119
],
[
123,
122
],
[
149,
127
],
[
154,
130
],
[
146,
133
],
[
122,
134
],
[
122,
136
],
[
152,
137
],
[
155,
140
],
[
143,
140
],
[
142,
143
],
[
145,
146
],
[
151,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
]
] | [
"n, a = map(int, input().split())\nx = [int(x) for x in input().split()]\n\ndp = [[0]*2501 for _ in range(n+1)]\nfor i in range(n+1):\n for j in range(i-1, -1, -1):\n if j == 0:\n dp[j+1][x[i-1]] += 1\n for k in range(2500, -1, -1):\n if dp[j][k] and k+x[i-1] <= 2500:\n dp[j+1][k+x[i-1]] += dp[j][k]\n\nans = 0\nfor i in range(1, n+1):\n ans += dp[i][i*a]\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"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",
"x = [int(x) for x in input().split()]",
"x",
"[int(x) for x in input().split()]",
"[0]*2501 for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"[0]*2501",
"[0]",
"0",
"2501",
"dp = [[0]*2501 for _ in range(n+1)]",
"dp",
"[[0]*2501 for _ in range(n+1)]",
"for i in range(n+1):\n for j in range(i-1, -1, -1):\n if j == 0:\n dp[j+1][x[i-1]] += 1\n for k in range(2500, -1, -1):\n if dp[j][k] and k+x[i-1] <= 2500:\n dp[j+1][k+x[i-1]] += dp[j][k]",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for j in range(i-1, -1, -1):\n if j == 0:\n dp[j+1][x[i-1]] += 1\n for k in range(2500, -1, -1):\n if dp[j][k] and k+x[i-1] <= 2500:\n dp[j+1][k+x[i-1]] += dp[j][k]",
"j",
"range(i-1, -1, -1)",
"range",
"i-1",
"i",
"1",
"-1",
"-1",
"if j == 0:\n dp[j+1][x[i-1]] += 1\n ",
"j == 0",
"j",
"0",
"dp[j+1][x[i-1]] += 1",
"dp[j+1][x[i-1]]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"1",
"for k in range(2500, -1, -1):\n if dp[j][k] and k+x[i-1] <= 2500:\n dp[j+1][k+x[i-1]] += dp[j][k]",
"k",
"range(2500, -1, -1)",
"range",
"2500",
"-1",
"-1",
"if dp[j][k] and k+x[i-1] <= 2500:\n dp[j+1][k+x[i-1]] += dp[j][k]",
"dp[j][k] and k+x[i-1] <= 2500",
"dp[j][k]",
"[j]",
"dp",
"j",
"k",
"k+x[i-1] <= 2500",
"k+x[i-1]",
"k",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"2500",
"dp[j+1][k+x[i-1]] += dp[j][k]",
"dp[j+1][k+x[i-1]]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"k+x[i-1]",
"k",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"dp[j][k]",
"[j]",
"dp",
"j",
"k",
"ans = 0",
"ans",
"0",
"for i in range(1, n+1):\n ans += dp[i][i*a]",
"i",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[i][i*a]",
"ans",
"dp[i][i*a]",
"[i]",
"dp",
"i",
"i*a",
"i",
"a",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"dp = [[0]*2501 for _ in range(n+1)]",
"[[0]*2501 for _ in range(n+1)]",
"dp",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"ans += dp[i][i*a]",
"dp[i][i*a]",
"ans",
"x = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"x"
] | n, a = map(int, input().split())
x = [int(x) for x in input().split()]
dp = [[0]*2501 for _ in range(n+1)]
for i in range(n+1):
for j in range(i-1, -1, -1):
if j == 0:
dp[j+1][x[i-1]] += 1
for k in range(2500, -1, -1):
if dp[j][k] and k+x[i-1] <= 2500:
dp[j+1][k+x[i-1]] += dp[j][k]
ans = 0
for i in range(1, n+1):
ans += dp[i][i*a]
print(ans) |
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
12,
13,
0,
13,
2,
17,
4,
13,
13,
0,
13,
17,
28,
13,
18,
13,
39,
17,
0,
13,
2,
2,
17,
4,
13,
13,
17,
0,
13,
2,
2,
13,
4,
13,
13,
13,
29,
4,
13,
13,
23,
13,
17,
23,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
2,
13,
17,
2,
13,
17,
2,
13,
17,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
40,
2,
13,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
17,
13,
13,
4,
13,
13,
29,
23,
13,
23,
13,
23,
13,
12,
13,
12,
13,
28,
13,
18,
13,
13,
28,
13,
4,
18,
13,
13,
27,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13
] | [
[
269,
11
],
[
19,
18
],
[
26,
25
],
[
29,
28
],
[
35,
34
],
[
28,
40
],
[
44,
43
],
[
18,
46
],
[
56,
49
],
[
34,
50
],
[
25,
50
],
[
43,
54
],
[
57,
56
],
[
63,
62
],
[
197,
65
],
[
68,
67
],
[
261,
69
],
[
193,
71
],
[
193,
74
],
[
62,
77
],
[
87,
80
],
[
67,
83
],
[
197,
93
],
[
96,
95
],
[
99,
98
],
[
193,
102
],
[
106,
105
],
[
62,
109
],
[
119,
112
],
[
67,
115
],
[
98,
117
],
[
105,
118
],
[
67,
122
],
[
98,
126
],
[
105,
127
],
[
105,
131
],
[
142,
135
],
[
67,
138
],
[
98,
140
],
[
105,
141
],
[
67,
145
],
[
98,
150
],
[
105,
153
],
[
157,
156
],
[
160,
159
],
[
193,
164
],
[
168,
167
],
[
62,
171
],
[
167,
176
],
[
159,
177
],
[
195,
178
],
[
181,
180
],
[
67,
184
],
[
159,
186
],
[
167,
187
],
[
180,
190
],
[
156,
190
],
[
193,
193
],
[
195,
195
],
[
197,
197
],
[
204,
203
],
[
209,
208
],
[
203,
211
],
[
208,
214
],
[
217,
216
],
[
201,
218
],
[
221,
220
],
[
216,
225
],
[
228,
227
],
[
216,
232
],
[
236,
235
],
[
220,
238
],
[
216,
244
],
[
247,
246
],
[
264,
249
],
[
220,
250
],
[
227,
251
],
[
246,
252
],
[
267,
258
],
[
269,
270
]
] | [
"#!/usr/bin/env python3\nimport sys\nsys.setrecursionlimit(10**8)\nINF = float(\"inf\")\n\n\ndef array(*args, initial=0):\n pre = \"[\"*len(args)\n post = \"\"\n for a in args[::-1]:\n post += \" for _ in range(\"+str(a)+\")]\"\n S = pre + str(initial) + post\n return eval(S)\n\n\ndef solve(N: int, A: int, x: \"List[int]\"):\n M = sum(x)\n # Nまで考慮, 使用した個数（Nまで）, 合計値\n DP = array(N+1, N+1, M+1)\n DP[0][0][0] = 1\n\n for i, a in enumerate(x, start=1):\n for j in range(N+1):\n for tot in range(M+1):\n DP[i][j][tot] = DP[i-1][j][tot] # 使わない時\n if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ans = 0\n for j in range(1, N+1):\n for tot in range(M+1):\n if tot / j == A:\n # if abs(tot / j-A) < 0.1:\n ans += DP[-1][j][tot]\n print(ans)\n # print(*DP[-1], sep=\"\\n\")\n return\n\n\ndef main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"sys.setrecursionlimit(10**8)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**8",
"10",
"8",
"INF = float(\"inf\")",
"INF",
"float(\"inf\")",
"float",
"\"inf\"",
"def array(*args, initial=0):\n pre = \"[\"*len(args)\n post = \"\"\n for a in args[::-1]:\n post += \" for _ in range(\"+str(a)+\")]\"\n S = pre + str(initial) + post\n return eval(S)",
"array",
"pre = \"[\"*len(args)",
"pre",
"\"[\"*len(args)",
"\"[\"",
"len(args)",
"len",
"args",
"post = \"\"",
"post",
"\"\"",
"for a in args[::-1]:\n post += \" for _ in range(\"+str(a)+\")]\"\n ",
"a",
"args[::-1]",
"args",
"::-1",
"-1",
"post += \" for _ in range(\"+str(a)+\")]\"",
"post",
"\" for _ in range(\"+str(a)+\")]\"",
"\" for _ in range(\"+str(a)",
"\" for _ in range(\"",
"str(a)",
"str",
"a",
"\")]\"",
"S = pre + str(initial) + post",
"S",
"pre + str(initial) + post",
"pre + str(initial)",
"pre",
"str(initial)",
"str",
"initial",
"post",
"return eval(S)",
"eval(S)",
"eval",
"S",
"initial=0",
"initial",
"0",
"*args",
"def solve(N: int, A: int, x: \"List[int]\"):\n M = sum(x)\n # Nまで考慮, 使用した個数（Nまで）, 合計値\n DP = array(N+1, N+1, M+1)\n DP[0][0][0] = 1\n\n for i, a in enumerate(x, start=1):\n for j in range(N+1):\n for tot in range(M+1):\n DP[i][j][tot] = DP[i-1][j][tot] # 使わない時\n if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ans = 0\n for j in range(1, N+1):\n for tot in range(M+1):\n if tot / j == A:\n # if abs(tot / j-A) < 0.1:\n ans += DP[-1][j][tot]\n print(ans)\n # print(*DP[-1], sep=\"\\n\")\n return",
"solve",
"M = sum(x)",
"M",
"sum(x)",
"sum",
"x",
"DP = array(N+1, N+1, M+1)",
"DP",
"array(N+1, N+1, M+1)",
"array",
"N+1",
"N",
"1",
"N+1",
"N",
"1",
"M+1",
"M",
"1",
"DP[0][0][0] = 1",
"DP[0][0][0]",
"[0]",
"[0]",
"DP",
"0",
"0",
"0",
"1",
"for i, a in enumerate(x, start=1):\n for j in range(N+1):\n for tot in range(M+1):\n DP[i][j][tot] = DP[i-1][j][tot] # 使わない時\n if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ",
"i",
"a",
"enumerate(x, start=1)",
"enumerate",
"x",
"start=1",
"start",
"1",
"for j in range(N+1):\n for tot in range(M+1):\n DP[i][j][tot] = DP[i-1][j][tot] # 使わない時\n if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for tot in range(M+1):\n DP[i][j][tot] = DP[i-1][j][tot] # 使わない時\n if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ",
"tot",
"range(M+1)",
"range",
"M+1",
"M",
"1",
"DP[i][j][tot] = DP[i-1][j][tot]",
"DP[i][j][tot]",
"[j]",
"[i]",
"DP",
"i",
"j",
"tot",
"DP[i-1][j][tot]",
"[j]",
"[i-1]",
"DP",
"i-1",
"i",
"1",
"j",
"tot",
"if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ",
"tot - a >= 0",
"tot - a",
"tot",
"a",
"0",
"DP[i][j][tot] += DP[i-1][j-1][tot-a]",
"DP[i][j][tot]",
"[j]",
"[i]",
"DP",
"i",
"j",
"tot",
"DP[i-1][j-1][tot-a]",
"[j-1]",
"[i-1]",
"DP",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"tot-a",
"tot",
"a",
"ans = 0",
"ans",
"0",
"for j in range(1, N+1):\n for tot in range(M+1):\n if tot / j == A:\n # if abs(tot / j-A) < 0.1:\n ans += DP[-1][j][tot]\n ",
"j",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for tot in range(M+1):\n if tot / j == A:\n # if abs(tot / j-A) < 0.1:\n ans += DP[-1][j][tot]\n ",
"tot",
"range(M+1)",
"range",
"M+1",
"M",
"1",
"if tot / j == A:\n # if abs(tot / j-A) < 0.1:\n ans += DP[-1][j][tot]\n ",
"tot / j == A",
"tot / j",
"tot",
"j",
"A",
"ans += DP[-1][j][tot]",
"ans",
"DP[-1][j][tot]",
"[j]",
"[-1]",
"DP",
"-1",
"j",
"tot",
"print(ans)",
"print",
"ans",
"return",
"N: int",
"N",
"A: int",
"A",
"x: \"List[int]\"",
"x",
"def main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"main",
"def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"iterate_tokens",
"for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"line",
"sys.stdin",
"sys",
"stdin",
"for word in line.split():\n yield word\n ",
"word",
"line.split()",
"line.split",
"line",
"split",
"yield word",
"word",
"tokens = iterate_tokens()",
"tokens",
"iterate_tokens()",
"iterate_tokens",
"N = int(next(tokens))",
"N",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"A = int(next(tokens))",
"A",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"int(next(tokens)) for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"x = [int(next(tokens)) for _ in range(N)]",
"x",
"[int(next(tokens)) for _ in range(N)]",
"solve(N, A, x)",
"solve",
"N",
"A",
"x",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def array(*args, initial=0):\n pre = \"[\"*len(args)\n post = \"\"\n for a in args[::-1]:\n post += \" for _ in range(\"+str(a)+\")]\"\n S = pre + str(initial) + post\n return eval(S)",
"def array(*args, initial=0):\n pre = \"[\"*len(args)\n post = \"\"\n for a in args[::-1]:\n post += \" for _ in range(\"+str(a)+\")]\"\n S = pre + str(initial) + post\n return eval(S)",
"array",
"def solve(N: int, A: int, x: \"List[int]\"):\n M = sum(x)\n # Nまで考慮, 使用した個数（Nまで）, 合計値\n DP = array(N+1, N+1, M+1)\n DP[0][0][0] = 1\n\n for i, a in enumerate(x, start=1):\n for j in range(N+1):\n for tot in range(M+1):\n DP[i][j][tot] = DP[i-1][j][tot] # 使わない時\n if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ans = 0\n for j in range(1, N+1):\n for tot in range(M+1):\n if tot / j == A:\n # if abs(tot / j-A) < 0.1:\n ans += DP[-1][j][tot]\n print(ans)\n # print(*DP[-1], sep=\"\\n\")\n return",
"def solve(N: int, A: int, x: \"List[int]\"):\n M = sum(x)\n # Nまで考慮, 使用した個数（Nまで）, 合計値\n DP = array(N+1, N+1, M+1)\n DP[0][0][0] = 1\n\n for i, a in enumerate(x, start=1):\n for j in range(N+1):\n for tot in range(M+1):\n DP[i][j][tot] = DP[i-1][j][tot] # 使わない時\n if tot - a >= 0: # 使う時\n DP[i][j][tot] += DP[i-1][j-1][tot-a]\n\n ans = 0\n for j in range(1, N+1):\n for tot in range(M+1):\n if tot / j == A:\n # if abs(tot / j-A) < 0.1:\n ans += DP[-1][j][tot]\n print(ans)\n # print(*DP[-1], sep=\"\\n\")\n return",
"solve",
"def main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"def main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"main",
"INF = float(\"inf\")",
"float(\"inf\")",
"INF"
] | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def array(*args, initial=0):
pre = "["*len(args)
post = ""
for a in args[::-1]:
post += " for _ in range("+str(a)+")]"
S = pre + str(initial) + post
return eval(S)
def solve(N: int, A: int, x: "List[int]"):
M = sum(x)
# Nまで考慮, 使用した個数（Nまで）, 合計値
DP = array(N+1, N+1, M+1)
DP[0][0][0] = 1
for i, a in enumerate(x, start=1):
for j in range(N+1):
for tot in range(M+1):
DP[i][j][tot] = DP[i-1][j][tot] # 使わない時
if tot - a >= 0: # 使う時
DP[i][j][tot] += DP[i-1][j-1][tot-a]
ans = 0
for j in range(1, N+1):
for tot in range(M+1):
if tot / j == A:
# if abs(tot / j-A) < 0.1:
ans += DP[-1][j][tot]
print(ans)
# print(*DP[-1], sep="\n")
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
x = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A, x)
if __name__ == '__main__':
main()
|
[
7,
15,
13,
38,
5,
15,
12,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
2,
2,
13,
13,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
28,
13,
4,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
2,
2,
13,
13,
17,
14,
40,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
2,
13,
13,
4,
13,
4,
13,
18,
18,
13,
13,
2,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
12,
13,
28,
13,
18,
13,
13,
28,
13,
4,
18,
13,
13,
27,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
13,
0,
13,
13,
4,
13,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
11,
10
],
[
89,
14
],
[
91,
22
],
[
89,
23
],
[
27,
26
],
[
34,
29
],
[
26,
31
],
[
37,
36
],
[
93,
36
],
[
40,
39
],
[
89,
46
],
[
50,
49
],
[
36,
52
],
[
91,
55
],
[
89,
56
],
[
49,
60
],
[
36,
61
],
[
68,
63
],
[
26,
65
],
[
39,
66
],
[
49,
67
],
[
26,
70
],
[
39,
72
],
[
49,
75
],
[
36,
76
],
[
26,
83
],
[
91,
86
],
[
89,
89
],
[
91,
91
],
[
93,
93
],
[
100,
99
],
[
105,
104
],
[
99,
107
],
[
104,
110
],
[
113,
112
],
[
97,
114
],
[
117,
116
],
[
112,
121
],
[
124,
123
],
[
112,
128
],
[
132,
131
],
[
116,
134
],
[
112,
140
],
[
143,
142
],
[
157,
145
],
[
116,
146
],
[
123,
147
],
[
142,
148
],
[
160,
154
]
] | [
"#!/usr/bin/env python3\nimport sys\ntry:\n from typing import List\nexcept ImportError:\n pass\n\n\ndef solve(N: int, A: int, x: \"List[int]\"):\n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for xi in x:\n for k in reversed(range(1, N + 1)):\n for j in range(xi, A * N + 1):\n if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))\n\n\ndef main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"try:\n from typing import List\nexcept ImportError:\n pass",
"except ImportError:\n pass",
"from typing import List",
"def solve(N: int, A: int, x: \"List[int]\"):\n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for xi in x:\n for k in reversed(range(1, N + 1)):\n for j in range(xi, A * N + 1):\n if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))",
"solve",
"[0] * (A * N + 1) for _ in range(N + 1)",
"for _ in range(N + 1)",
"_",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for _ in range(N + 1)",
"[0] * (A * N + 1)",
"[0]",
"0",
"A * N + 1",
"A * N",
"A",
"N",
"1",
"dp = [[0] * (A * N + 1) for _ in range(N + 1)]",
"dp",
"[[0] * (A * N + 1) for _ in range(N + 1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for xi in x:\n for k in reversed(range(1, N + 1)):\n for j in range(xi, A * N + 1):\n if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n ",
"xi",
"x",
"for k in reversed(range(1, N + 1)):\n for j in range(xi, A * N + 1):\n if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n ",
"k",
"reversed(range(1, N + 1))",
"reversed",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"for j in range(xi, A * N + 1):\n if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n ",
"j",
"range(xi, A * N + 1)",
"range",
"xi",
"A * N + 1",
"A * N",
"A",
"N",
"1",
"if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n ",
"j >= xi",
"j",
"xi",
"dp[k][j] += dp[k - 1][j - xi]",
"dp[k][j]",
"[k]",
"dp",
"k",
"j",
"dp[k - 1][j - xi]",
"[k - 1]",
"dp",
"k - 1",
"k",
"1",
"j - xi",
"j",
"xi",
"print(sum(dp[i][A * i] for i in range(1, N + 1)))",
"print",
"sum(dp[i][A * i] for i in range(1, N + 1))",
"sum",
"dp[i][A * i]",
"[i]",
"dp",
"i",
"A * i",
"A",
"i",
"N: int",
"N",
"A: int",
"A",
"x: \"List[int]\"",
"x",
"def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"main",
"def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"iterate_tokens",
"for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"line",
"sys.stdin",
"sys",
"stdin",
"for word in line.split():\n yield word\n ",
"word",
"line.split()",
"line.split",
"line",
"split",
"yield word",
"word",
"tokens = iterate_tokens()",
"tokens",
"iterate_tokens()",
"iterate_tokens",
"N = int(next(tokens))",
"N",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"A = int(next(tokens))",
"A",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"int(next(tokens)) for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"x = [int(next(tokens)) for _ in range(N)]",
"x",
"[int(next(tokens)) for _ in range(N)]",
"solve(N, A, x)",
"solve",
"N",
"A",
"x",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def solve(N: int, A: int, x: \"List[int]\"):\n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for xi in x:\n for k in reversed(range(1, N + 1)):\n for j in range(xi, A * N + 1):\n if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))",
"def solve(N: int, A: int, x: \"List[int]\"):\n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for xi in x:\n for k in reversed(range(1, N + 1)):\n for j in range(xi, A * N + 1):\n if j >= xi:\n dp[k][j] += dp[k - 1][j - xi]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))",
"solve",
"def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n x = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"\n solve(N, A, x)",
"main"
] | #!/usr/bin/env python3
import sys
try:
from typing import List
except ImportError:
pass
def solve(N: int, A: int, x: "List[int]"):
dp = [[0] * (A * N + 1) for _ in range(N + 1)]
dp[0][0] = 1
for xi in x:
for k in reversed(range(1, N + 1)):
for j in range(xi, A * N + 1):
if j >= xi:
dp[k][j] += dp[k - 1][j - xi]
print(sum(dp[i][A * i] for i in range(1, N + 1)))
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
x = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A, x)
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
31,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
2,
13,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
17,
13,
0,
18,
18,
18,
13,
13,
2,
13,
17,
13,
18,
18,
18,
13,
13,
13,
13,
14,
40,
13,
18,
13,
13,
0,
18,
18,
18,
13,
13,
2,
13,
17,
13,
18,
18,
18,
13,
2,
13,
17,
13,
2,
13,
18,
13,
13,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
151,
2
],
[
151,
11
],
[
15,
13
],
[
148,
24
],
[
146,
27
],
[
152,
28
],
[
33,
32
],
[
146,
36
],
[
142,
41
],
[
51,
44
],
[
143,
47
],
[
54,
53
],
[
146,
58
],
[
62,
61
],
[
146,
64
],
[
67,
66
],
[
149,
70
],
[
81,
72
],
[
143,
75
],
[
53,
76
],
[
61,
78
],
[
66,
80
],
[
143,
84
],
[
53,
85
],
[
61,
86
],
[
66,
87
],
[
66,
90
],
[
61,
93
],
[
104,
95
],
[
143,
98
],
[
53,
99
],
[
61,
101
],
[
66,
103
],
[
143,
107
],
[
53,
109
],
[
61,
111
],
[
66,
113
],
[
61,
116
],
[
120,
119
],
[
146,
124
],
[
143,
130
],
[
119,
131
],
[
146,
132
],
[
119,
134
],
[
152,
135
],
[
142,
143
],
[
151,
146
],
[
148,
149
],
[
151,
152
]
] | [
"N, A = map(int, input().split())\n*x, = map(int, input().split())\nl = N * A + 1\n\n# dp[n枚選ぶ][m枚目まで][総和]\ndp = [[[0] * l for _ in range(N + 1)] for _ in range(N + 1)]\ndp[0][0][0] = 1\nfor n in range(0, N + 1):\n for m in range(N):\n for s in range(0, l):\n dp[n][m + 1][s] += dp[n][m][s]\n if s >= x[m]:\n dp[n][m + 1][s] += dp[n - 1][m][s - x[m]]\n\nprint(sum([dp[n][N][n * A] for n in range(1, N + 1)]))",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"*x, = map(int, input().split())",
"*x",
"x",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"l = N * A + 1",
"l",
"N * A + 1",
"N * A",
"N",
"A",
"1",
"[[0] * l for _ in range(N + 1)] for _ in range(N + 1)",
"for _ in range(N + 1)",
"_",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for _ in range(N + 1)",
"[[0] * l for _ in range(N + 1)]",
"dp = [[[0] * l for _ in range(N + 1)] for _ in range(N + 1)]",
"dp",
"[[[0] * l for _ in range(N + 1)] for _ in range(N + 1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for n in range(0, N + 1):\n for m in range(N):\n for s in range(0, l):\n dp[n][m + 1][s] += dp[n][m][s]\n if s >= x[m]:\n dp[n][m + 1][s] += dp[n - 1][m][s - x[m]]",
"n",
"range(0, N + 1)",
"range",
"0",
"N + 1",
"N",
"1",
"for m in range(N):\n for s in range(0, l):\n dp[n][m + 1][s] += dp[n][m][s]\n if s >= x[m]:\n dp[n][m + 1][s] += dp[n - 1][m][s - x[m]]",
"m",
"range(N)",
"range",
"N",
"for s in range(0, l):\n dp[n][m + 1][s] += dp[n][m][s]\n if s >= x[m]:\n dp[n][m + 1][s] += dp[n - 1][m][s - x[m]]",
"s",
"range(0, l)",
"range",
"0",
"l",
"dp[n][m + 1][s] += dp[n][m][s]",
"dp[n][m + 1][s]",
"[m + 1]",
"[n]",
"dp",
"n",
"m + 1",
"m",
"1",
"s",
"dp[n][m][s]",
"[m]",
"[n]",
"dp",
"n",
"m",
"s",
"if s >= x[m]:\n dp[n][m + 1][s] += dp[n - 1][m][s - x[m]]",
"s >= x[m]",
"s",
"x[m]",
"x",
"m",
"dp[n][m + 1][s] += dp[n - 1][m][s - x[m]]",
"dp[n][m + 1][s]",
"[m + 1]",
"[n]",
"dp",
"n",
"m + 1",
"m",
"1",
"s",
"dp[n - 1][m][s - x[m]]",
"[m]",
"[n - 1]",
"dp",
"n - 1",
"n",
"1",
"m",
"s - x[m]",
"s",
"x[m]",
"x",
"m",
"dp[n][N][n * A] for n in range(1, N + 1)",
"for n in range(1, N + 1)",
"n",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"for n in range(1, N + 1)",
"dp[n][N][n * A]",
"[N]",
"[n]",
"dp",
"n",
"N",
"n * A",
"n",
"A",
"print(sum([dp[n][N][n * A] for n in range(1, N + 1)]))",
"print",
"sum([dp[n][N][n * A] for n in range(1, N + 1)])",
"sum",
"[dp[n][N][n * A] for n in range(1, N + 1)]",
"dp = [[[0] * l for _ in range(N + 1)] for _ in range(N + 1)]",
"[[[0] * l for _ in range(N + 1)] for _ in range(N + 1)]",
"dp",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"l = N * A + 1",
"N * A + 1",
"l",
"A = map(int, input().split())",
"map(int, input().split())",
"A"
] | N, A = map(int, input().split())
*x, = map(int, input().split())
l = N * A + 1
# dp[n枚選ぶ][m枚目まで][総和]
dp = [[[0] * l for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
for n in range(0, N + 1):
for m in range(N):
for s in range(0, l):
dp[n][m + 1][s] += dp[n][m][s]
if s >= x[m]:
dp[n][m + 1][s] += dp[n - 1][m][s - x[m]]
print(sum([dp[n][N][n * A] for n in range(1, N + 1)])) |
[
7,
0,
13,
17,
0,
13,
17,
41,
28,
13,
4,
13,
13,
4,
13,
0,
13,
13,
12,
13,
14,
2,
13,
17,
29,
17,
14,
2,
13,
17,
14,
2,
13,
17,
29,
17,
0,
13,
2,
13,
13,
14,
40,
13,
17,
29,
17,
0,
13,
2,
13,
13,
14,
2,
13,
13,
29,
17,
14,
40,
18,
18,
18,
13,
13,
13,
13,
17,
29,
18,
18,
18,
13,
13,
13,
13,
0,
13,
4,
13,
2,
13,
17,
13,
13,
13,
13,
0,
13,
4,
13,
2,
13,
17,
2,
13,
18,
13,
13,
2,
13,
17,
13,
13,
0,
13,
2,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
4,
18,
13,
13,
17,
28,
13,
4,
13,
13,
4,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
17,
17,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
2,
17,
4,
13,
13,
13,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13
] | [
[
207,
2
],
[
231,
5
],
[
10,
9
],
[
208,
12
],
[
222,
16
],
[
121,
22
],
[
121,
28
],
[
125,
32
],
[
38,
37
],
[
123,
39
],
[
125,
40
],
[
37,
43
],
[
49,
48
],
[
123,
50
],
[
125,
51
],
[
48,
54
],
[
129,
55
],
[
223,
63
],
[
121,
64
],
[
123,
65
],
[
125,
66
],
[
223,
72
],
[
121,
73
],
[
123,
74
],
[
125,
75
],
[
78,
77
],
[
121,
81
],
[
123,
83
],
[
125,
84
],
[
127,
85
],
[
129,
86
],
[
89,
88
],
[
121,
92
],
[
123,
95
],
[
127,
97
],
[
121,
98
],
[
125,
100
],
[
127,
102
],
[
129,
103
],
[
106,
105
],
[
88,
107
],
[
77,
108
],
[
117,
110
],
[
223,
113
],
[
121,
114
],
[
123,
115
],
[
125,
116
],
[
105,
117
],
[
105,
119
],
[
121,
121
],
[
123,
123
],
[
125,
125
],
[
127,
127
],
[
129,
129
],
[
134,
133
],
[
133,
137
],
[
142,
141
],
[
164,
144
],
[
133,
147
],
[
168,
150
],
[
141,
151
],
[
154,
153
],
[
226,
155
],
[
164,
156
],
[
133,
159
],
[
166,
160
],
[
153,
162
],
[
164,
164
],
[
166,
166
],
[
168,
168
],
[
219,
170
],
[
219,
179
],
[
228,
181
],
[
216,
193
],
[
229,
196
],
[
211,
202
],
[
217,
203
],
[
220,
204
],
[
229,
205
],
[
207,
208
],
[
219,
214
],
[
216,
217
],
[
219,
220
],
[
222,
223
],
[
228,
229
],
[
231,
232
]
] | [
"MAX_INDEX = 51\nMAX_SUM = 2505\n\ndp = [[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)] for _ in range(MAX_INDEX)]\n\ndef waysutil(index, sum, count, arr, K) : \n\n\tif (index < 0) : \n\t\treturn 0; \n\n\tif (index == 0) : \n\n\t\tif (count == 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\tremainder = sum % count; \n\n\t\tif (remainder != 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\taverage = sum // count; \n\n\t\tif (average == K) : \n\t\t\treturn 1; \n\n\tif (dp[index][sum][count] != -1) : \n\t\treturn dp[index][sum][count]; \n\n\tdontpick = waysutil(index - 1, sum, count, arr, K); \n\n\n\tpick = waysutil(index - 1, sum + arr[index], count + 1, arr, K); \n\t\t\t\t\t\t\n\ttotal = pick + dontpick; \n\n\tdp[index][sum][count] = total; \n\t\n\treturn total; \n\n\ndef ways(N, K, arr) : \n\n\tArr = []; \n\n\tArr.append(-1); \n\tfor i in range(N) : \n\t\tArr.append(arr[i]); \n\n\tanswer = waysutil(N, 0, 0, Arr, K); \n\treturn answer; \n\n\nn, k = map(int, input().split())\narr = list(map(int, input().split()))\nN = len(arr)\n\nprint(\"%d\" % (ways(N, k, arr)))",
"MAX_INDEX = 51",
"MAX_INDEX",
"51",
"MAX_SUM = 2505",
"MAX_SUM",
"2505",
"[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)] for _ in range(MAX_INDEX)",
"for _ in range(MAX_INDEX)",
"_",
"range(MAX_INDEX)",
"range",
"MAX_INDEX",
"for _ in range(MAX_INDEX)",
"[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)]",
"dp = [[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)] for _ in range(MAX_INDEX)]",
"dp",
"[[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)] for _ in range(MAX_INDEX)]",
"def waysutil(index, sum, count, arr, K) : \n\n\tif (index < 0) : \n\t\treturn 0; \n\n\tif (index == 0) : \n\n\t\tif (count == 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\tremainder = sum % count; \n\n\t\tif (remainder != 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\taverage = sum // count; \n\n\t\tif (average == K) : \n\t\t\treturn 1; \n\n\tif (dp[index][sum][count] != -1) : \n\t\treturn dp[index][sum][count]; \n\n\tdontpick = waysutil(index - 1, sum, count, arr, K); \n\n\n\tpick = waysutil(index - 1, sum + arr[index], count + 1, arr, K); \n\t\t\t\t\t\t\n\ttotal = pick + dontpick; \n\n\tdp[index][sum][count] = total; \n\t\n\treturn total; ",
"waysutil",
"if (index < 0) : \n\t\treturn 0; \n\n\t",
"index < 0",
"index",
"0",
"return 0",
"0",
"if (index == 0) : \n\n\t\tif (count == 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\tremainder = sum % count; \n\n\t\tif (remainder != 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\taverage = sum // count; \n\n\t\tif (average == K) : \n\t\t\treturn 1; \n\n\t",
"index == 0",
"index",
"0",
"if (count == 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\t",
"count == 0",
"count",
"0",
"return 0",
"0",
"remainder = sum % count",
"remainder",
"sum % count",
"sum",
"count",
"if (remainder != 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\t",
"remainder != 0",
"remainder",
"0",
"return 0",
"0",
"average = sum // count",
"average",
"sum // count",
"sum",
"count",
"if (average == K) : \n\t\t\treturn 1; \n\n\t",
"average == K",
"average",
"K",
"return 1",
"1",
"if (dp[index][sum][count] != -1) : \n\t\treturn dp[index][sum][count]; \n\n\t",
"dp[index][sum][count] != -1",
"dp[index][sum][count]",
"[sum]",
"[index]",
"dp",
"index",
"sum",
"count",
"-1",
"return dp[index][sum][count]",
"dp[index][sum][count]",
"[sum]",
"[index]",
"dp",
"index",
"sum",
"count",
"dontpick = waysutil(index - 1, sum, count, arr, K)",
"dontpick",
"waysutil(index - 1, sum, count, arr, K)",
"waysutil",
"index - 1",
"index",
"1",
"sum",
"count",
"arr",
"K",
"pick = waysutil(index - 1, sum + arr[index], count + 1, arr, K)",
"pick",
"waysutil(index - 1, sum + arr[index], count + 1, arr, K)",
"waysutil",
"index - 1",
"index",
"1",
"sum + arr[index]",
"sum",
"arr[index]",
"arr",
"index",
"count + 1",
"count",
"1",
"arr",
"K",
"total = pick + dontpick",
"total",
"pick + dontpick",
"pick",
"dontpick",
"dp[index][sum][count] = total",
"dp[index][sum][count]",
"[sum]",
"[index]",
"dp",
"index",
"sum",
"count",
"total",
"return total",
"total",
"index",
"index",
"sum",
"sum",
"count",
"count",
"arr",
"arr",
"K",
"K",
"def ways(N, K, arr) : \n\n\tArr = []; \n\n\tArr.append(-1); \n\tfor i in range(N) : \n\t\tArr.append(arr[i]); \n\n\tanswer = waysutil(N, 0, 0, Arr, K); \n\treturn answer; ",
"ways",
"Arr = []",
"Arr",
"[]",
"Arr.append(-1)",
"Arr.append",
"Arr",
"append",
"-1",
"for i in range(N) : \n\t\tArr.append(arr[i]); \n\n\t",
"i",
"range(N)",
"range",
"N",
"Arr.append(arr[i])",
"Arr.append",
"Arr",
"append",
"arr[i]",
"arr",
"i",
"answer = waysutil(N, 0, 0, Arr, K)",
"answer",
"waysutil(N, 0, 0, Arr, K)",
"waysutil",
"N",
"0",
"0",
"Arr",
"K",
"return answer",
"answer",
"N",
"N",
"K",
"K",
"arr",
"arr",
"n, k = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"k",
"arr = list(map(int, input().split()))",
"arr",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"N = len(arr)",
"N",
"len(arr)",
"len",
"arr",
"print(\"%d\" % (ways(N, k, arr)))",
"print",
"\"%d\" % (ways(N, k, arr))",
"\"%d\"",
"ways(N, k, arr)",
"ways",
"N",
"k",
"arr",
"MAX_INDEX = 51",
"51",
"MAX_INDEX",
"def ways(N, K, arr) : \n\n\tArr = []; \n\n\tArr.append(-1); \n\tfor i in range(N) : \n\t\tArr.append(arr[i]); \n\n\tanswer = waysutil(N, 0, 0, Arr, K); \n\treturn answer; ",
"def ways(N, K, arr) : \n\n\tArr = []; \n\n\tArr.append(-1); \n\tfor i in range(N) : \n\t\tArr.append(arr[i]); \n\n\tanswer = waysutil(N, 0, 0, Arr, K); \n\treturn answer; ",
"ways",
"n, k = map(int, input().split())",
"map(int, input().split())",
"n",
"N = len(arr)",
"len(arr)",
"N",
"k = map(int, input().split())",
"map(int, input().split())",
"k",
"dp = [[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)] for _ in range(MAX_INDEX)]",
"[[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)] for _ in range(MAX_INDEX)]",
"dp",
"def waysutil(index, sum, count, arr, K) : \n\n\tif (index < 0) : \n\t\treturn 0; \n\n\tif (index == 0) : \n\n\t\tif (count == 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\tremainder = sum % count; \n\n\t\tif (remainder != 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\taverage = sum // count; \n\n\t\tif (average == K) : \n\t\t\treturn 1; \n\n\tif (dp[index][sum][count] != -1) : \n\t\treturn dp[index][sum][count]; \n\n\tdontpick = waysutil(index - 1, sum, count, arr, K); \n\n\n\tpick = waysutil(index - 1, sum + arr[index], count + 1, arr, K); \n\t\t\t\t\t\t\n\ttotal = pick + dontpick; \n\n\tdp[index][sum][count] = total; \n\t\n\treturn total; ",
"def waysutil(index, sum, count, arr, K) : \n\n\tif (index < 0) : \n\t\treturn 0; \n\n\tif (index == 0) : \n\n\t\tif (count == 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\tremainder = sum % count; \n\n\t\tif (remainder != 0) : \n\t\t\treturn 0; \n\t\t\t\n\t\taverage = sum // count; \n\n\t\tif (average == K) : \n\t\t\treturn 1; \n\n\tif (dp[index][sum][count] != -1) : \n\t\treturn dp[index][sum][count]; \n\n\tdontpick = waysutil(index - 1, sum, count, arr, K); \n\n\n\tpick = waysutil(index - 1, sum + arr[index], count + 1, arr, K); \n\t\t\t\t\t\t\n\ttotal = pick + dontpick; \n\n\tdp[index][sum][count] = total; \n\t\n\treturn total; ",
"waysutil",
"arr = list(map(int, input().split()))",
"list(map(int, input().split()))",
"arr",
"MAX_SUM = 2505",
"2505",
"MAX_SUM"
] | MAX_INDEX = 51
MAX_SUM = 2505
dp = [[[-1 for _ in range(MAX_INDEX)] for _ in range(MAX_SUM)] for _ in range(MAX_INDEX)]
def waysutil(index, sum, count, arr, K) :
if (index < 0) :
return 0;
if (index == 0) :
if (count == 0) :
return 0;
remainder = sum % count;
if (remainder != 0) :
return 0;
average = sum // count;
if (average == K) :
return 1;
if (dp[index][sum][count] != -1) :
return dp[index][sum][count];
dontpick = waysutil(index - 1, sum, count, arr, K);
pick = waysutil(index - 1, sum + arr[index], count + 1, arr, K);
total = pick + dontpick;
dp[index][sum][count] = total;
return total;
def ways(N, K, arr) :
Arr = [];
Arr.append(-1);
for i in range(N) :
Arr.append(arr[i]);
answer = waysutil(N, 0, 0, Arr, K);
return answer;
n, k = map(int, input().split())
arr = list(map(int, input().split()))
N = len(arr)
print("%d" % (ways(N, k, arr)))
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
18,
13,
13,
0,
13,
4,
13,
4,
13,
12,
2,
13,
13,
23,
13,
0,
13,
4,
13,
13,
0,
18,
13,
17,
17,
28,
13,
13,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
99,
3
],
[
99,
12
],
[
93,
14
],
[
94,
27
],
[
96,
30
],
[
88,
38
],
[
94,
40
],
[
90,
42
],
[
50,
47
],
[
91,
48
],
[
53,
52
],
[
97,
52
],
[
94,
52
],
[
91,
61
],
[
69,
64
],
[
91,
65
],
[
52,
68
],
[
91,
72
],
[
52,
76
],
[
91,
83
],
[
99,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
]
] | [
"from collections import defaultdict\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\nx.sort()\nx = list(map(lambda x:x - a, x))\ndic = defaultdict(int)\ndic[0] = 1\nfor i in x:\n for j, k in list(dic.items()):\n dic[j + i] = dic.get(j + i, 0) + k\nprint(dic[0] - 1)",
"from collections import defaultdict",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x.sort()",
"x.sort",
"x",
"sort",
"x = list(map(lambda x:x - a, x))",
"x",
"list(map(lambda x:x - a, x))",
"list",
"map(lambda x:x - a, x)",
"map",
"lambda x:x - a",
"x - a",
"x",
"a",
"x",
"x",
"dic = defaultdict(int)",
"dic",
"defaultdict(int)",
"defaultdict",
"int",
"dic[0] = 1",
"dic[0]",
"dic",
"0",
"1",
"for i in x:\n for j, k in list(dic.items()):\n dic[j + i] = dic.get(j + i, 0) + k",
"i",
"x",
"for j, k in list(dic.items()):\n dic[j + i] = dic.get(j + i, 0) + k",
"j",
"k",
"list(dic.items())",
"list",
"dic.items()",
"dic.items",
"dic",
"items",
"dic[j + i] = dic.get(j + i, 0) + k",
"dic[j + i]",
"dic",
"j + i",
"j",
"i",
"dic.get(j + i, 0) + k",
"dic.get(j + i, 0)",
"dic.get",
"dic",
"get",
"j + i",
"j",
"i",
"0",
"k",
"print(dic[0] - 1)",
"print",
"dic[0] - 1",
"dic[0]",
"dic",
"0",
"1",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"dic = defaultdict(int)",
"defaultdict(int)",
"dic",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"x = list(map(lambda x:x - a, x))",
"list(map(lambda x:x - a, x))",
"x",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n"
] | from collections import defaultdict
n, a = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
x = list(map(lambda x:x - a, x))
dic = defaultdict(int)
dic[0] = 1
for i in x:
for j, k in list(dic.items()):
dic[j + i] = dic.get(j + i, 0) + k
print(dic[0] - 1) |
[
7,
12,
13,
12,
13,
14,
40,
2,
18,
18,
18,
13,
13,
13,
13,
17,
29,
18,
18,
18,
13,
13,
13,
13,
14,
40,
2,
13,
13,
14,
2,
2,
13,
17,
2,
13,
2,
13,
13,
29,
17,
29,
17,
0,
13,
4,
13,
2,
13,
17,
13,
13,
0,
13,
4,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
2,
13,
13,
29,
18,
18,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
4,
18,
13,
13,
13,
29,
4,
13,
17,
17,
17,
14,
2,
13,
17,
4,
13,
4,
13,
10,
12,
13
] | [
[
87,
12
],
[
89,
13
],
[
91,
14
],
[
87,
21
],
[
89,
22
],
[
91,
23
],
[
87,
27
],
[
89,
32
],
[
91,
35
],
[
89,
38
],
[
45,
44
],
[
87,
48
],
[
89,
50
],
[
91,
51
],
[
54,
53
],
[
87,
57
],
[
89,
60
],
[
91,
63
],
[
87,
66
],
[
75,
68
],
[
87,
72
],
[
89,
73
],
[
91,
74
],
[
44,
76
],
[
53,
77
],
[
68,
79
],
[
87,
83
],
[
89,
84
],
[
91,
85
],
[
87,
87
],
[
89,
89
],
[
91,
91
],
[
94,
93
],
[
94,
104
],
[
107,
106
],
[
119,
118
],
[
122,
121
],
[
93,
125
],
[
130,
129
],
[
93,
133
],
[
139,
138
],
[
118,
142
],
[
138,
144
],
[
4,
147
],
[
161,
158
]
] | [
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n # print('cache!')\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n return 1\n return 0\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)\n\n\nif __name__ == '__main__':\n print(solve())",
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n # print('cache!')\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n return 1\n return 0\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)",
"solve",
"def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n # print('cache!')\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n return 1\n return 0\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n ",
"recur",
"if not TABLE[i][n][total] == -1:\n # print('cache!')\n return TABLE[i][n][total]\n\n ",
"not TABLE[i][n][total] == -1",
"TABLE[i][n][total] == -1",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"-1",
"return TABLE[i][n][total]",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"if not i < N:\n if n > 0 and total == A * n:\n return 1\n return 0\n\n ",
"not i < N",
"i < N",
"i",
"N",
"if n > 0 and total == A * n:\n return 1\n ",
"n > 0 and total == A * n",
"n > 0",
"n",
"0",
"total == A * n",
"total",
"A * n",
"A",
"n",
"return 1",
"1",
"return 0",
"0",
"ans1 = recur(i + 1, n, total)",
"ans1",
"recur(i + 1, n, total)",
"recur",
"i + 1",
"i",
"1",
"n",
"total",
"ans2 = recur(i + 1, n + 1, total + XS[i])",
"ans2",
"recur(i + 1, n + 1, total + XS[i])",
"recur",
"i + 1",
"i",
"1",
"n + 1",
"n",
"1",
"total + XS[i]",
"total",
"XS[i]",
"XS",
"i",
"TABLE[i][n][total] = ans1 + ans2",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"ans1 + ans2",
"ans1",
"ans2",
"return TABLE[i][n][total]",
"TABLE[i][n][total]",
"[n]",
"[i]",
"TABLE",
"i",
"n",
"total",
"i",
"i",
"n",
"n",
"total",
"total",
"N, A = tuple(map(int, input().split()))",
"N",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"XS = tuple(map(int, input().split()))",
"XS",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"TABLE = []",
"TABLE",
"[]",
"for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n ",
"_",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"[-1 for x in range(N * 50 + 1)] for y in range(N + 1)",
"for y in range(N + 1)",
"y",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for y in range(N + 1)",
"[-1 for x in range(N * 50 + 1)]",
"lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]",
"lines",
"[[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]",
"TABLE.append(lines)",
"TABLE.append",
"TABLE",
"append",
"lines",
"return recur(0, 0, 0)",
"recur(0, 0, 0)",
"recur",
"0",
"0",
"0",
"if __name__ == '__main__':\n print(solve())",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"print(solve())",
"print",
"solve()",
"solve",
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n # print('cache!')\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n return 1\n return 0\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)",
"def solve():\n def recur(i, n, total):\n # print(\"i, n, total\", i, n, total)\n\n if not TABLE[i][n][total] == -1:\n # print('cache!')\n return TABLE[i][n][total]\n\n if not i < N:\n if n > 0 and total == A * n:\n return 1\n return 0\n\n ans1 = recur(i + 1, n, total)\n ans2 = recur(i + 1, n + 1, total + XS[i])\n\n # print(ans1, ans2)\n\n TABLE[i][n][total] = ans1 + ans2\n return TABLE[i][n][total]\n\n N, A = tuple(map(int, input().split()))\n XS = tuple(map(int, input().split()))\n\n TABLE = []\n for _ in range(N + 1):\n lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]\n TABLE.append(lines)\n\n return recur(0, 0, 0)",
"solve"
] | def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
# print('cache!')
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
return 1
return 0
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
TABLE[i][n][total] = ans1 + ans2
return TABLE[i][n][total]
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == '__main__':
print(solve())
|
[
7,
15,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
13,
4,
13,
13,
0,
18,
13,
17,
17,
28,
13,
13,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
13,
0,
13,
2,
18,
13,
17,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
6,
5
],
[
6,
18
],
[
6,
19
],
[
24,
23
],
[
23,
27
],
[
18,
28
],
[
31,
30
],
[
33,
32
],
[
40,
37
],
[
32,
38
],
[
43,
42
],
[
30,
42
],
[
32,
51
],
[
59,
54
],
[
32,
55
],
[
42,
57
],
[
62,
61
],
[
32,
64
],
[
61,
69
],
[
78,
75
]
] | [
"# ABC044C - 高橋君とカード / Tak and Cards (ARC060C)\nfrom collections import defaultdict\n\n\ndef main():\n N, A, *X = map(int, open(0).read().split())\n X, D = [i - A for i in X], defaultdict(int)\n D[0] = 1\n for i in X:\n for j, k in list(D.items()):\n D[i + j] += k\n ans = D[0] - 1\n print(ans)\n \n\n\nif __name__ == \"__main__\":\n main()",
"from collections import defaultdict",
"def main():\n N, A, *X = map(int, open(0).read().split())\n X, D = [i - A for i in X], defaultdict(int)\n D[0] = 1\n for i in X:\n for j, k in list(D.items()):\n D[i + j] += k\n ans = D[0] - 1\n print(ans)\n ",
"main",
"N, A, *X = map(int, open(0).read().split())",
"N",
"map(int, open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"A",
"*X",
"X",
"i - A for i in X",
"for i in X",
"i",
"X",
"for i in X",
"i - A",
"i",
"A",
"X, D = [i - A for i in X], defaultdict(int)",
"X",
"[i - A for i in X]",
"D",
"defaultdict(int)",
"defaultdict",
"int",
"D[0] = 1",
"D[0]",
"D",
"0",
"1",
"for i in X:\n for j, k in list(D.items()):\n D[i + j] += k\n ",
"i",
"X",
"for j, k in list(D.items()):\n D[i + j] += k\n ",
"j",
"k",
"list(D.items())",
"list",
"D.items()",
"D.items",
"D",
"items",
"D[i + j] += k",
"D[i + j]",
"D",
"i + j",
"i",
"j",
"k",
"ans = D[0] - 1",
"ans",
"D[0] - 1",
"D[0]",
"D",
"0",
"1",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n N, A, *X = map(int, open(0).read().split())\n X, D = [i - A for i in X], defaultdict(int)\n D[0] = 1\n for i in X:\n for j, k in list(D.items()):\n D[i + j] += k\n ans = D[0] - 1\n print(ans)\n ",
"def main():\n N, A, *X = map(int, open(0).read().split())\n X, D = [i - A for i in X], defaultdict(int)\n D[0] = 1\n for i in X:\n for j, k in list(D.items()):\n D[i + j] += k\n ans = D[0] - 1\n print(ans)\n ",
"main"
] | # ABC044C - 高橋君とカード / Tak and Cards (ARC060C)
from collections import defaultdict
def main():
N, A, *X = map(int, open(0).read().split())
X, D = [i - A for i in X], defaultdict(int)
D[0] = 1
for i in X:
for j, k in list(D.items()):
D[i + j] += k
ans = D[0] - 1
print(ans)
if __name__ == "__main__":
main() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
17,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
40,
13,
17,
40,
2,
13,
18,
13,
2,
13,
17,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13
] | [
[
158,
2
],
[
158,
11
],
[
167,
13
],
[
27,
26
],
[
156,
30
],
[
152,
35
],
[
45,
38
],
[
153,
41
],
[
48,
47
],
[
156,
52
],
[
56,
55
],
[
47,
59
],
[
63,
62
],
[
156,
68
],
[
78,
71
],
[
153,
74
],
[
47,
75
],
[
55,
76
],
[
62,
77
],
[
153,
81
],
[
47,
83
],
[
55,
85
],
[
62,
86
],
[
55,
90
],
[
62,
94
],
[
168,
96
],
[
47,
98
],
[
109,
102
],
[
153,
105
],
[
47,
106
],
[
55,
107
],
[
62,
108
],
[
153,
112
],
[
47,
114
],
[
55,
117
],
[
62,
120
],
[
168,
122
],
[
47,
124
],
[
161,
127
],
[
131,
130
],
[
156,
135
],
[
164,
138
],
[
153,
142
],
[
156,
143
],
[
130,
144
],
[
159,
146
],
[
130,
147
],
[
165,
150
],
[
162,
150
],
[
152,
153
],
[
158,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
]
] | [
"N, A = map(int,input().split())\nX = list(map(int,input().split()))\ndp = [[[0 for k in range(50 * N + 1)] for j in range(N + 1)] for i in range(N + 1)]\ndp[0][0][0] = 1\nfor i in range(1,N+1):\n for j in range(i+1):\n for k in range(50 * N + 1):\n dp[i][j][k] += dp[i-1][j][k]\n if j != 0 and k - X[i-1] >= 0:\n dp[i][j][k] += dp[i-1][j-1][k - X[i-1]]\nans = 0\nfor i in range(1, N+1):\n ans += dp[N][i][A * i]\nprint(ans)",
"N, A = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int,input().split()))",
"X",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0 for k in range(50 * N + 1)] for j in range(N + 1)] for i in range(N + 1)",
"for i in range(N + 1)",
"i",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for i in range(N + 1)",
"[[0 for k in range(50 * N + 1)] for j in range(N + 1)]",
"dp = [[[0 for k in range(50 * N + 1)] for j in range(N + 1)] for i in range(N + 1)]",
"dp",
"[[[0 for k in range(50 * N + 1)] for j in range(N + 1)] for i in range(N + 1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(1,N+1):\n for j in range(i+1):\n for k in range(50 * N + 1):\n dp[i][j][k] += dp[i-1][j][k]\n if j != 0 and k - X[i-1] >= 0:\n dp[i][j][k] += dp[i-1][j-1][k - X[i-1]]",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for j in range(i+1):\n for k in range(50 * N + 1):\n dp[i][j][k] += dp[i-1][j][k]\n if j != 0 and k - X[i-1] >= 0:\n dp[i][j][k] += dp[i-1][j-1][k - X[i-1]]",
"j",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"for k in range(50 * N + 1):\n dp[i][j][k] += dp[i-1][j][k]\n if j != 0 and k - X[i-1] >= 0:\n dp[i][j][k] += dp[i-1][j-1][k - X[i-1]]",
"k",
"range(50 * N + 1)",
"range",
"50 * N + 1",
"50 * N",
"50",
"N",
"1",
"dp[i][j][k] += dp[i-1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"if j != 0 and k - X[i-1] >= 0:\n dp[i][j][k] += dp[i-1][j-1][k - X[i-1]]",
"j != 0 and k - X[i-1] >= 0",
"j != 0",
"j",
"0",
"k - X[i-1] >= 0",
"k - X[i-1]",
"k",
"X[i-1]",
"X",
"i-1",
"i",
"1",
"0",
"dp[i][j][k] += dp[i-1][j-1][k - X[i-1]]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j-1][k - X[i-1]]",
"[j-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"k - X[i-1]",
"k",
"X[i-1]",
"X",
"i-1",
"i",
"1",
"ans = 0",
"ans",
"0",
"for i in range(1, N+1):\n ans += dp[N][i][A * i]",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[N][i][A * i]",
"ans",
"dp[N][i][A * i]",
"[i]",
"[N]",
"dp",
"N",
"i",
"A * i",
"A",
"i",
"print(ans)",
"print",
"ans",
"dp = [[[0 for k in range(50 * N + 1)] for j in range(N + 1)] for i in range(N + 1)]",
"[[[0 for k in range(50 * N + 1)] for j in range(N + 1)] for i in range(N + 1)]",
"dp",
"N, A = map(int,input().split())",
"map(int,input().split())",
"N",
"A = map(int,input().split())",
"map(int,input().split())",
"A",
"ans = 0",
"0",
"ans",
"ans += dp[N][i][A * i]",
"dp[N][i][A * i]",
"ans",
"X = list(map(int,input().split()))",
"list(map(int,input().split()))",
"X"
] | N, A = map(int,input().split())
X = list(map(int,input().split()))
dp = [[[0 for k in range(50 * N + 1)] for j in range(N + 1)] for i in range(N + 1)]
dp[0][0][0] = 1
for i in range(1,N+1):
for j in range(i+1):
for k in range(50 * N + 1):
dp[i][j][k] += dp[i-1][j][k]
if j != 0 and k - X[i-1] >= 0:
dp[i][j][k] += dp[i-1][j-1][k - X[i-1]]
ans = 0
for i in range(1, N+1):
ans += dp[N][i][A * i]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
17,
0,
13,
13,
28,
13,
4,
13,
17,
13,
0,
18,
13,
2,
13,
17,
18,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
14,
2,
13,
18,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] | [
[
204,
2
],
[
204,
11
],
[
186,
13
],
[
27,
26
],
[
205,
31
],
[
198,
36
],
[
46,
39
],
[
199,
42
],
[
50,
49
],
[
205,
54
],
[
195,
59
],
[
63,
62
],
[
205,
66
],
[
73,
68
],
[
196,
69
],
[
62,
71
],
[
187,
74
],
[
62,
75
],
[
78,
77
],
[
205,
82
],
[
86,
85
],
[
77,
90
],
[
94,
93
],
[
190,
99
],
[
205,
100
],
[
93,
104
],
[
196,
106
],
[
77,
107
],
[
116,
109
],
[
199,
112
],
[
77,
113
],
[
85,
114
],
[
93,
115
],
[
199,
119
],
[
77,
121
],
[
85,
123
],
[
93,
124
],
[
133,
126
],
[
199,
129
],
[
77,
130
],
[
85,
131
],
[
93,
132
],
[
199,
137
],
[
77,
139
],
[
85,
141
],
[
93,
142
],
[
199,
146
],
[
77,
148
],
[
85,
151
],
[
93,
154
],
[
196,
156
],
[
77,
157
],
[
201,
159
],
[
163,
162
],
[
205,
167
],
[
192,
170
],
[
202,
172
],
[
193,
172
],
[
199,
176
],
[
205,
177
],
[
162,
178
],
[
162,
180
],
[
190,
181
],
[
193,
184
],
[
202,
184
],
[
186,
187
],
[
204,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
]
] | [
"n , a= map(int , input().split())\narr = list(map(int , input().split()))\ndp = [ [[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)] for i in range(0,n+2)]\ndp[0][0][0]=1\nb=[0 for i in range(0 , n+1)]\nfor i in range(0 , n):\n\tb[i+1]=arr[i]\nfor i in range(1 , n+1):\t# choosing only first i elements\n\tfor j in range(0 , i+1):# choosing only j elements from first i elements\n\t\tfor k in range(0 , a*(n)+2):# no of ways of forming a sum k taking j elements out of i elements\n\t\t\tif k<b[i]:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]\n\t\t\telse:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]\ntot = 0\nfor i in range(1 , n+1):\n\ttot = tot + dp[n][i][(i)*a]\nprint(tot)",
"n , a= map(int , input().split())",
"n",
"map(int , input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"arr = list(map(int , input().split()))",
"arr",
"list(map(int , input().split()))",
"list",
"map(int , input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)] for i in range(0,n+2)",
"for i in range(0,n+2)",
"i",
"range(0,n+2)",
"range",
"0",
"n+2",
"n",
"2",
"for i in range(0,n+2)",
"[[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)]",
"dp = [ [[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)] for i in range(0,n+2)]",
"dp",
"[ [[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)] for i in range(0,n+2)]",
"dp[0][0][0]=1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"0 for i in range(0 , n+1)",
"for i in range(0 , n+1)",
"i",
"range(0 , n+1)",
"range",
"0",
"n+1",
"n",
"1",
"for i in range(0 , n+1)",
"0",
"b=[0 for i in range(0 , n+1)]",
"b",
"[0 for i in range(0 , n+1)]",
"for i in range(0 , n):\n\tb[i+1]=arr[i]",
"i",
"range(0 , n)",
"range",
"0",
"n",
"b[i+1]=arr[i]",
"b[i+1]",
"b",
"i+1",
"i",
"1",
"arr[i]",
"arr",
"i",
"for i in range(1 , n+1):\t# choosing only first i elements\n\tfor j in range(0 , i+1):# choosing only j elements from first i elements\n\t\tfor k in range(0 , a*(n)+2):# no of ways of forming a sum k taking j elements out of i elements\n\t\t\tif k<b[i]:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]\n\t\t\telse:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]",
"i",
"range(1 , n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for j in range(0 , i+1):# choosing only j elements from first i elements\n\t\tfor k in range(0 , a*(n)+2):# no of ways of forming a sum k taking j elements out of i elements\n\t\t\tif k<b[i]:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]\n\t\t\telse:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]",
"j",
"range(0 , i+1)",
"range",
"0",
"i+1",
"i",
"1",
"for k in range(0 , a*(n)+2):# no of ways of forming a sum k taking j elements out of i elements\n\t\t\tif k<b[i]:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]\n\t\t\telse:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]",
"k",
"range(0 , a*(n)+2)",
"range",
"0",
"a*(n)+2",
"a*(n)",
"a",
"n",
"2",
"if k<b[i]:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]\n\t\t\telse:\n\t\t\t\tdp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]",
"k<b[i]",
"k",
"b[i]",
"b",
"i",
"dp[i][j][k]=dp[i-1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"dp[i-1][j-1][k-b[i]]",
"[j-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"k-b[i]",
"k",
"b[i]",
"b",
"i",
"tot = 0",
"tot",
"0",
"for i in range(1 , n+1):\n\ttot = tot + dp[n][i][(i)*a]",
"i",
"range(1 , n+1)",
"range",
"1",
"n+1",
"n",
"1",
"tot = tot + dp[n][i][(i)*a]",
"tot",
"tot + dp[n][i][(i)*a]",
"tot",
"dp[n][i][(i)*a]",
"[i]",
"[n]",
"dp",
"n",
"i",
"(i)*a",
"i",
"a",
"print(tot)",
"print",
"tot",
"arr = list(map(int , input().split()))",
"list(map(int , input().split()))",
"arr",
"a= map(int , input().split())",
"map(int , input().split())",
"a",
"tot = tot + dp[n][i][(i)*a]",
"tot + dp[n][i][(i)*a]",
"tot",
"b=[0 for i in range(0 , n+1)]",
"[0 for i in range(0 , n+1)]",
"b",
"dp = [ [[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)] for i in range(0,n+2)]",
"[ [[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)] for i in range(0,n+2)]",
"dp",
"tot = 0",
"0",
"tot",
"n , a= map(int , input().split())",
"map(int , input().split())",
"n"
] | n , a= map(int , input().split())
arr = list(map(int , input().split()))
dp = [ [[ 0 for j in range(0 , a*(n+2))] for k in range(0 , n+2)] for i in range(0,n+2)]
dp[0][0][0]=1
b=[0 for i in range(0 , n+1)]
for i in range(0 , n):
b[i+1]=arr[i]
for i in range(1 , n+1): # choosing only first i elements
for j in range(0 , i+1):# choosing only j elements from first i elements
for k in range(0 , a*(n)+2):# no of ways of forming a sum k taking j elements out of i elements
if k<b[i]:
dp[i][j][k]=dp[i-1][j][k]
else:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-b[i]]
tot = 0
for i in range(1 , n+1):
tot = tot + dp[n][i][(i)*a]
print(tot) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
4,
13,
13,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
28,
13,
4,
13,
13,
0,
18,
18,
13,
2,
13,
17,
2,
17,
18,
13,
13,
17,
28,
13,
4,
13,
17,
14,
40,
18,
18,
13,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
4,
13,
18,
18,
13,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
124,
2
],
[
124,
11
],
[
127,
13
],
[
26,
25
],
[
128,
30
],
[
35,
32
],
[
128,
33
],
[
25,
34
],
[
122,
35
],
[
39,
38
],
[
125,
42
],
[
130,
50
],
[
54,
53
],
[
125,
56
],
[
69,
58
],
[
131,
60
],
[
53,
62
],
[
32,
66
],
[
128,
67
],
[
53,
68
],
[
72,
71
],
[
131,
79
],
[
53,
80
],
[
71,
81
],
[
95,
84
],
[
131,
86
],
[
53,
88
],
[
71,
91
],
[
32,
92
],
[
128,
93
],
[
53,
94
],
[
131,
97
],
[
53,
98
],
[
71,
99
],
[
108,
101
],
[
131,
103
],
[
53,
105
],
[
71,
107
],
[
131,
110
],
[
53,
111
],
[
71,
112
],
[
131,
117
],
[
125,
118
],
[
124,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
]
] | [
"n,a=map(int,input().split())\nx=list(map(int,input().split()))\nfor i in range(len(x)):\n x[i]-=a\nli=[[0]*5001 for i in range(n+1)]\nfor i in range(n):\n li[i+1][2500+x[i]]+=1\n for j in range(5001):\n if li[i][j]>=1:\n li[i+1][j+x[i]]+=li[i][j]\n li[i+1][j]+=li[i][j]\n # print(li[i+1][2490:2510])\nprint(li[n][2500])",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x=list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(len(x)):\n x[i]-=a",
"i",
"range(len(x))",
"range",
"len(x)",
"len",
"x",
"x[i]-=a",
"x[i]",
"x",
"i",
"a",
"[0]*5001 for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[0]*5001",
"[0]",
"0",
"5001",
"li=[[0]*5001 for i in range(n+1)]",
"li",
"[[0]*5001 for i in range(n+1)]",
"for i in range(n):\n li[i+1][2500+x[i]]+=1\n for j in range(5001):\n if li[i][j]>=1:\n li[i+1][j+x[i]]+=li[i][j]\n li[i+1][j]+=li[i][j]\n # print(li[i+1][2490:2510])",
"i",
"range(n)",
"range",
"n",
"li[i+1][2500+x[i]]+=1",
"li[i+1][2500+x[i]]",
"[i+1]",
"li",
"i+1",
"i",
"1",
"2500+x[i]",
"2500",
"x[i]",
"x",
"i",
"1",
"for j in range(5001):\n if li[i][j]>=1:\n li[i+1][j+x[i]]+=li[i][j]\n li[i+1][j]+=li[i][j]\n # print(li[i+1][2490:2510])",
"j",
"range(5001)",
"range",
"5001",
"if li[i][j]>=1:\n li[i+1][j+x[i]]+=li[i][j]\n li[i+1][j]+=li[i][j]\n # print(li[i+1][2490:2510])",
"li[i][j]>=1",
"li[i][j]",
"[i]",
"li",
"i",
"j",
"1",
"li[i+1][j+x[i]]+=li[i][j]",
"li[i+1][j+x[i]]",
"[i+1]",
"li",
"i+1",
"i",
"1",
"j+x[i]",
"j",
"x[i]",
"x",
"i",
"li[i][j]",
"[i]",
"li",
"i",
"j",
"li[i+1][j]+=li[i][j]",
"li[i+1][j]",
"[i+1]",
"li",
"i+1",
"i",
"1",
"j",
"li[i][j]",
"[i]",
"li",
"i",
"j",
"print(li[n][2500])",
"print",
"li[n][2500]",
"[n]",
"li",
"n",
"2500",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"x=list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"li=[[0]*5001 for i in range(n+1)]",
"[[0]*5001 for i in range(n+1)]",
"li"
] | n,a=map(int,input().split())
x=list(map(int,input().split()))
for i in range(len(x)):
x[i]-=a
li=[[0]*5001 for i in range(n+1)]
for i in range(n):
li[i+1][2500+x[i]]+=1
for j in range(5001):
if li[i][j]>=1:
li[i+1][j+x[i]]+=li[i][j]
li[i+1][j]+=li[i][j]
# print(li[i+1][2490:2510])
print(li[n][2500]) |
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
0,
18,
18,
18,
13,
17,
17,
17,
17,
14,
2,
40,
13,
17,
2,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
2,
40,
13,
17,
40,
13,
17,
40,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
17,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
18,
18,
13,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
39,
13,
10,
4,
13
] | [
[
238,
4
],
[
238,
15
],
[
229,
17
],
[
217,
29
],
[
230,
34
],
[
227,
35
],
[
39,
38
],
[
239,
42
],
[
232,
47
],
[
57,
50
],
[
233,
53
],
[
235,
59
],
[
63,
62
],
[
239,
66
],
[
220,
69
],
[
230,
71
],
[
62,
73
],
[
77,
76
],
[
239,
80
],
[
84,
83
],
[
239,
88
],
[
218,
89
],
[
62,
95
],
[
76,
98
],
[
83,
101
],
[
111,
104
],
[
233,
107
],
[
62,
115
],
[
83,
118
],
[
221,
119
],
[
128,
121
],
[
233,
124
],
[
62,
125
],
[
76,
126
],
[
83,
127
],
[
233,
131
],
[
62,
133
],
[
76,
135
],
[
83,
136
],
[
62,
141
],
[
76,
144
],
[
83,
147
],
[
221,
148
],
[
157,
150
],
[
233,
153
],
[
62,
154
],
[
76,
155
],
[
83,
156
],
[
233,
161
],
[
62,
163
],
[
76,
165
],
[
83,
166
],
[
233,
170
],
[
62,
172
],
[
76,
175
],
[
83,
178
],
[
221,
179
],
[
188,
181
],
[
233,
184
],
[
62,
185
],
[
76,
186
],
[
83,
187
],
[
192,
191
],
[
239,
196
],
[
233,
202
],
[
239,
203
],
[
191,
204
],
[
191,
206
],
[
227,
207
],
[
223,
209
],
[
224,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
238,
227
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
238,
239
]
] | [
"#!/usr/bin/env python3\n\nimport itertools\n\nN, A = list(map(int, input().split()))\nx_list = list(map(int, input().split()))\n\nmax_x = max(max(x_list), A)\ndp = [[[0 for s in range(N * max_x + 1)] for k in range(N + 1)] for j in range(N + 1)]\ndp[0][0][0] = 1\nka_list = []\n\nfor j in range(N + 1): # 何番目の数か\n x = x_list[j - 1]\n for k in range(N + 1): # k枚選ぶとき\n for s in range(N * max_x + 1):\n if j == 0 and k == 0 and s == 0:\n dp[0][0][0] = 1\n elif j >= 1 and s < x:\n # オーバーするので選べない\n # ひとつ前と同じになる\n dp[j][k][s] = dp[j - 1][k][s]\n elif j >= 1 and k >= 1 and s >= x:\n dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]\n else:\n dp[j][k][s] = 0\n\nans = sum([dp[N][k][k * A] for k in range(1, N + 1)])\nprint(ans)",
"import itertools",
"itertools",
"N, A = list(map(int, input().split()))",
"N",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x_list = list(map(int, input().split()))",
"x_list",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"max_x = max(max(x_list), A)",
"max_x",
"max(max(x_list), A)",
"max",
"max(x_list)",
"max",
"x_list",
"A",
"[[0 for s in range(N * max_x + 1)] for k in range(N + 1)] for j in range(N + 1)",
"for j in range(N + 1)",
"j",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for j in range(N + 1)",
"[[0 for s in range(N * max_x + 1)] for k in range(N + 1)]",
"dp = [[[0 for s in range(N * max_x + 1)] for k in range(N + 1)] for j in range(N + 1)]",
"dp",
"[[[0 for s in range(N * max_x + 1)] for k in range(N + 1)] for j in range(N + 1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"ka_list = []",
"ka_list",
"[]",
"for j in range(N + 1): # 何番目の数か\n x = x_list[j - 1]\n for k in range(N + 1): # k枚選ぶとき\n for s in range(N * max_x + 1):\n if j == 0 and k == 0 and s == 0:\n dp[0][0][0] = 1\n elif j >= 1 and s < x:\n # オーバーするので選べない\n # ひとつ前と同じになる\n dp[j][k][s] = dp[j - 1][k][s]\n elif j >= 1 and k >= 1 and s >= x:\n dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]\n else:\n dp[j][k][s] = 0",
"j",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"x = x_list[j - 1]",
"x",
"x_list[j - 1]",
"x_list",
"j - 1",
"j",
"1",
"for k in range(N + 1): # k枚選ぶとき\n for s in range(N * max_x + 1):\n if j == 0 and k == 0 and s == 0:\n dp[0][0][0] = 1\n elif j >= 1 and s < x:\n # オーバーするので選べない\n # ひとつ前と同じになる\n dp[j][k][s] = dp[j - 1][k][s]\n elif j >= 1 and k >= 1 and s >= x:\n dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]\n else:\n dp[j][k][s] = 0",
"k",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for s in range(N * max_x + 1):\n if j == 0 and k == 0 and s == 0:\n dp[0][0][0] = 1\n elif j >= 1 and s < x:\n # オーバーするので選べない\n # ひとつ前と同じになる\n dp[j][k][s] = dp[j - 1][k][s]\n elif j >= 1 and k >= 1 and s >= x:\n dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]\n else:\n dp[j][k][s] = 0",
"s",
"range(N * max_x + 1)",
"range",
"N * max_x + 1",
"N * max_x",
"N",
"max_x",
"1",
"if j == 0 and k == 0 and s == 0:\n dp[0][0][0] = 1\n elif j >= 1 and s < x:\n # オーバーするので選べない\n # ひとつ前と同じになる\n dp[j][k][s] = dp[j - 1][k][s]\n elif j >= 1 and k >= 1 and s >= x:\n dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]\n else:\n dp[j][k][s] = 0",
"j == 0 and k == 0 and s == 0",
"j == 0 and k == 0",
"j == 0",
"j",
"0",
"k == 0",
"k",
"0",
"s == 0",
"s",
"0",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"elif j >= 1 and s < x:\n # オーバーするので選べない\n # ひとつ前と同じになる\n dp[j][k][s] = dp[j - 1][k][s]\n ",
"j >= 1 and s < x",
"j >= 1",
"j",
"1",
"s < x",
"s",
"x",
"dp[j][k][s] = dp[j - 1][k][s]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j - 1][k][s]",
"[k]",
"[j - 1]",
"dp",
"j - 1",
"j",
"1",
"k",
"s",
"elif j >= 1 and k >= 1 and s >= x:\n dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]\n ",
"j >= 1 and k >= 1 and s >= x",
"j >= 1 and k >= 1",
"j >= 1",
"j",
"1",
"k >= 1",
"k",
"1",
"s >= x",
"s",
"x",
"dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]",
"dp[j - 1][k][s]",
"[k]",
"[j - 1]",
"dp",
"j - 1",
"j",
"1",
"k",
"s",
"dp[j - 1][k - 1][s - x]",
"[k - 1]",
"[j - 1]",
"dp",
"j - 1",
"j",
"1",
"k - 1",
"k",
"1",
"s - x",
"s",
"x",
"dp[j][k][s] = 0",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"0",
"dp[N][k][k * A] for k in range(1, N + 1)",
"for k in range(1, N + 1)",
"k",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"for k in range(1, N + 1)",
"dp[N][k][k * A]",
"[k]",
"[N]",
"dp",
"N",
"k",
"k * A",
"k",
"A",
"ans = sum([dp[N][k][k * A] for k in range(1, N + 1)])",
"ans",
"sum([dp[N][k][k * A] for k in range(1, N + 1)])",
"sum",
"[dp[N][k][k * A] for k in range(1, N + 1)]",
"print(ans)",
"print",
"ans",
"max_x = max(max(x_list), A)",
"max(max(x_list), A)",
"max_x",
"x = x_list[j - 1]",
"x_list[j - 1]",
"x",
"ans = sum([dp[N][k][k * A] for k in range(1, N + 1)])",
"sum([dp[N][k][k * A] for k in range(1, N + 1)])",
"ans",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"x_list = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x_list",
"dp = [[[0 for s in range(N * max_x + 1)] for k in range(N + 1)] for j in range(N + 1)]",
"[[[0 for s in range(N * max_x + 1)] for k in range(N + 1)] for j in range(N + 1)]",
"dp",
"ka_list = []",
"[]",
"ka_list",
"N, A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"N"
] | #!/usr/bin/env python3
import itertools
N, A = list(map(int, input().split()))
x_list = list(map(int, input().split()))
max_x = max(max(x_list), A)
dp = [[[0 for s in range(N * max_x + 1)] for k in range(N + 1)] for j in range(N + 1)]
dp[0][0][0] = 1
ka_list = []
for j in range(N + 1): # 何番目の数か
x = x_list[j - 1]
for k in range(N + 1): # k枚選ぶとき
for s in range(N * max_x + 1):
if j == 0 and k == 0 and s == 0:
dp[0][0][0] = 1
elif j >= 1 and s < x:
# オーバーするので選べない
# ひとつ前と同じになる
dp[j][k][s] = dp[j - 1][k][s]
elif j >= 1 and k >= 1 and s >= x:
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x]
else:
dp[j][k][s] = 0
ans = sum([dp[N][k][k * A] for k in range(1, N + 1)])
print(ans)
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
17,
4,
18,
13,
13,
2,
17,
17,
12,
13,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
4,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
18,
13,
13,
0,
13,
4,
13,
28,
13,
13,
4,
18,
13,
13,
0,
18,
13,
13,
13,
0,
18,
13,
2,
13,
13,
13,
0,
13,
13,
4,
13,
2,
18,
13,
17,
17,
14,
2,
13,
17,
4,
13,
10,
2,
13,
10,
12,
13,
10,
18,
13,
10,
4,
13
] | [
[
125,
4
],
[
119,
11
],
[
128,
18
],
[
34,
33
],
[
126,
40
],
[
34,
42
],
[
45,
44
],
[
126,
53
],
[
57,
56
],
[
60,
59
],
[
66,
63
],
[
59,
64
],
[
69,
68
],
[
33,
71
],
[
74,
73
],
[
42,
75
],
[
44,
77
],
[
68,
78
],
[
81,
80
],
[
59,
88
],
[
103,
88
],
[
94,
91
],
[
80,
92
],
[
101,
96
],
[
80,
97
],
[
73,
99
],
[
104,
103
],
[
80,
104
],
[
103,
109
],
[
59,
109
],
[
123,
117
],
[
119,
120
],
[
125,
126
],
[
128,
129
]
] | [
"import sys\n\nreadline = sys.stdin.readline\nMOD = 10 ** 9 + 7\nINF = float('INF')\nsys.setrecursionlimit(10 ** 5)\n\n\ndef main():\n from collections import Counter\n\n n, a = map(int, readline().split())\n x = list(map(int, readline().split()))\n\n ans = 0\n counter = Counter()\n\n counter[0] += 1\n for i in range(n):\n cur = a - x[i]\n counter_next = Counter()\n for key, val in counter.items():\n counter_next[key] += val\n counter_next[cur + key] += val\n counter = counter_next\n\n print(counter[0] - 1)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"readline = sys.stdin.readline",
"readline",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"INF = float('INF')",
"INF",
"float('INF')",
"float",
"'INF'",
"sys.setrecursionlimit(10 ** 5)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 5",
"10",
"5",
"def main():\n from collections import Counter\n\n n, a = map(int, readline().split())\n x = list(map(int, readline().split()))\n\n ans = 0\n counter = Counter()\n\n counter[0] += 1\n for i in range(n):\n cur = a - x[i]\n counter_next = Counter()\n for key, val in counter.items():\n counter_next[key] += val\n counter_next[cur + key] += val\n counter = counter_next\n\n print(counter[0] - 1)",
"main",
"from collections import Counter",
"n, a = map(int, readline().split())",
"n",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"a",
"x = list(map(int, readline().split()))",
"x",
"list(map(int, readline().split()))",
"list",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"ans = 0",
"ans",
"0",
"counter = Counter()",
"counter",
"Counter()",
"Counter",
"counter[0] += 1",
"counter[0]",
"counter",
"0",
"1",
"for i in range(n):\n cur = a - x[i]\n counter_next = Counter()\n for key, val in counter.items():\n counter_next[key] += val\n counter_next[cur + key] += val\n counter = counter_next\n\n ",
"i",
"range(n)",
"range",
"n",
"cur = a - x[i]",
"cur",
"a - x[i]",
"a",
"x[i]",
"x",
"i",
"counter_next = Counter()",
"counter_next",
"Counter()",
"Counter",
"for key, val in counter.items():\n counter_next[key] += val\n counter_next[cur + key] += val\n ",
"key",
"val",
"counter.items()",
"counter.items",
"counter",
"items",
"counter_next[key] += val",
"counter_next[key]",
"counter_next",
"key",
"val",
"counter_next[cur + key] += val",
"counter_next[cur + key]",
"counter_next",
"cur + key",
"cur",
"key",
"val",
"counter = counter_next",
"counter",
"counter_next",
"print(counter[0] - 1)",
"print",
"counter[0] - 1",
"counter[0]",
"counter",
"0",
"1",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def main():\n from collections import Counter\n\n n, a = map(int, readline().split())\n x = list(map(int, readline().split()))\n\n ans = 0\n counter = Counter()\n\n counter[0] += 1\n for i in range(n):\n cur = a - x[i]\n counter_next = Counter()\n for key, val in counter.items():\n counter_next[key] += val\n counter_next[cur + key] += val\n counter = counter_next\n\n print(counter[0] - 1)",
"def main():\n from collections import Counter\n\n n, a = map(int, readline().split())\n x = list(map(int, readline().split()))\n\n ans = 0\n counter = Counter()\n\n counter[0] += 1\n for i in range(n):\n cur = a - x[i]\n counter_next = Counter()\n for key, val in counter.items():\n counter_next[key] += val\n counter_next[cur + key] += val\n counter = counter_next\n\n print(counter[0] - 1)",
"main",
"readline = sys.stdin.readline",
"sys.stdin.readline",
"readline",
"INF = float('INF')",
"float('INF')",
"INF"
] | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
from collections import Counter
n, a = map(int, readline().split())
x = list(map(int, readline().split()))
ans = 0
counter = Counter()
counter[0] += 1
for i in range(n):
cur = a - x[i]
counter_next = Counter()
for key, val in counter.items():
counter_next[key] += val
counter_next[cur + key] += val
counter = counter_next
print(counter[0] - 1)
if __name__ == '__main__':
main()
|
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
13,
0,
13,
4,
18,
13,
13,
39,
2,
13,
17,
2,
13,
17,
18,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
0,
18,
13,
39,
17,
18,
13,
39,
17,
0,
13,
4,
18,
13,
13,
17,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
4,
18,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
108,
4
],
[
108,
13
],
[
93,
15
],
[
105,
27
],
[
109,
30
],
[
102,
32
],
[
109,
39
],
[
106,
42
],
[
53,
48
],
[
103,
50
],
[
56,
55
],
[
94,
55
],
[
62,
58
],
[
103,
59
],
[
103,
63
],
[
111,
67
],
[
109,
74
],
[
99,
77
],
[
112,
79
],
[
97,
80
],
[
114,
82
],
[
103,
86
],
[
112,
87
],
[
115,
91
],
[
93,
94
],
[
108,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
]
] | [
"import numpy as np\n\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\nMAX = 50 * n\n\ndp = np.zeros((n + 1, MAX + 1), np.int64)\ndp[0][0] = 1\n\nfor e in x:\n dp[1:, e:] += dp[:-1, :-e]\n\ncnt = np.arange(1, n + 1)\nsm = cnt * a\nans = dp[cnt, sm].sum()\n\nprint(ans)",
"import numpy as np",
"numpy",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"MAX = 50 * n",
"MAX",
"50 * n",
"50",
"n",
"dp = np.zeros((n + 1, MAX + 1), np.int64)",
"dp",
"np.zeros((n + 1, MAX + 1), np.int64)",
"np.zeros",
"np",
"zeros",
"(n + 1, MAX + 1)",
"n + 1",
"n",
"1",
"MAX + 1",
"MAX",
"1",
"np.int64",
"np",
"int64",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for e in x:\n dp[1:, e:] += dp[:-1, :-e]",
"e",
"x",
"dp[1:, e:] += dp[:-1, :-e]",
"dp[1:, e:]",
"dp",
"1:",
"1",
"dp[:-1, :-e]",
"dp",
":-1",
"-1",
"cnt = np.arange(1, n + 1)",
"cnt",
"np.arange(1, n + 1)",
"np.arange",
"np",
"arange",
"1",
"n + 1",
"n",
"1",
"sm = cnt * a",
"sm",
"cnt * a",
"cnt",
"a",
"ans = dp[cnt, sm].sum()",
"ans",
"dp[cnt, sm].sum()",
"[cnt, sm].sum",
"[cnt, sm]",
"dp",
"cnt",
"sum",
"print(ans)",
"print",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"sm = cnt * a",
"cnt * a",
"sm",
"dp = np.zeros((n + 1, MAX + 1), np.int64)",
"np.zeros((n + 1, MAX + 1), np.int64)",
"dp",
"MAX = 50 * n",
"50 * n",
"MAX",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"cnt = np.arange(1, n + 1)",
"np.arange(1, n + 1)",
"cnt",
"ans = dp[cnt, sm].sum()",
"dp[cnt, sm].sum()",
"ans"
] | import numpy as np
n, a = map(int, input().split())
x = list(map(int, input().split()))
MAX = 50 * n
dp = np.zeros((n + 1, MAX + 1), np.int64)
dp[0][0] = 1
for e in x:
dp[1:, e:] += dp[:-1, :-e]
cnt = np.arange(1, n + 1)
sm = cnt * a
ans = dp[cnt, sm].sum()
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
28,
13,
4,
13,
17,
17,
17,
28,
13,
4,
13,
17,
17,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13
] | [
[
113,
2
],
[
113,
11
],
[
101,
13
],
[
27,
26
],
[
110,
36
],
[
44,
39
],
[
111,
41
],
[
47,
46
],
[
102,
46
],
[
50,
49
],
[
57,
56
],
[
72,
63
],
[
111,
65
],
[
49,
67
],
[
56,
70
],
[
46,
71
],
[
111,
74
],
[
49,
75
],
[
56,
76
],
[
116,
78
],
[
82,
81
],
[
114,
86
],
[
107,
89
],
[
111,
92
],
[
81,
93
],
[
81,
95
],
[
105,
96
],
[
108,
99
],
[
117,
99
],
[
101,
102
],
[
113,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
]
] | [
"\nN, M = map(int, input().split())\nD = list(map(int, input().split()))\ndp = [[0] * 2551 for i in range(51)]\ndp[0][0] = 1\nfor k in D:\n for i in range(49, -1, -1):\n for j in range(2500, -1, -1):\n dp[i+1][j + k] += dp[i][j]\n\nans = 0\nfor i in range(1, N+1):\n ans += dp[i][i*M]\nprint(ans)\n\n\n",
"N, M = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"M",
"D = list(map(int, input().split()))",
"D",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[0] * 2551 for i in range(51)",
"for i in range(51)",
"i",
"range(51)",
"range",
"51",
"for i in range(51)",
"[0] * 2551",
"[0]",
"0",
"2551",
"dp = [[0] * 2551 for i in range(51)]",
"dp",
"[[0] * 2551 for i in range(51)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for k in D:\n for i in range(49, -1, -1):\n for j in range(2500, -1, -1):\n dp[i+1][j + k] += dp[i][j]",
"k",
"D",
"for i in range(49, -1, -1):\n for j in range(2500, -1, -1):\n dp[i+1][j + k] += dp[i][j]",
"i",
"range(49, -1, -1)",
"range",
"49",
"-1",
"-1",
"for j in range(2500, -1, -1):\n dp[i+1][j + k] += dp[i][j]",
"j",
"range(2500, -1, -1)",
"range",
"2500",
"-1",
"-1",
"dp[i+1][j + k] += dp[i][j]",
"dp[i+1][j + k]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j + k",
"j",
"k",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"ans = 0",
"ans",
"0",
"for i in range(1, N+1):\n ans += dp[i][i*M]",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[i][i*M]",
"ans",
"dp[i][i*M]",
"[i]",
"dp",
"i",
"i*M",
"i",
"M",
"print(ans)",
"print",
"ans",
"D = list(map(int, input().split()))",
"list(map(int, input().split()))",
"D",
"M = map(int, input().split())",
"map(int, input().split())",
"M",
"ans += dp[i][i*M]",
"dp[i][i*M]",
"ans",
"dp = [[0] * 2551 for i in range(51)]",
"[[0] * 2551 for i in range(51)]",
"dp",
"N, M = map(int, input().split())",
"map(int, input().split())",
"N",
"ans = 0",
"0",
"ans"
] |
N, M = map(int, input().split())
D = list(map(int, input().split()))
dp = [[0] * 2551 for i in range(51)]
dp[0][0] = 1
for k in D:
for i in range(49, -1, -1):
for j in range(2500, -1, -1):
dp[i+1][j + k] += dp[i][j]
ans = 0
for i in range(1, N+1):
ans += dp[i][i*M]
print(ans)
|
[
7,
15,
13,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
2,
2,
17,
13,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
2,
17,
13,
17,
18,
13,
13,
0,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
13,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
13,
13,
2,
13,
13,
29,
13,
4,
13,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
7,
15
],
[
18,
17
],
[
31,
30
],
[
6,
34
],
[
6,
43
],
[
47,
46
],
[
54,
49
],
[
46,
51
],
[
57,
56
],
[
6,
59
],
[
62,
61
],
[
46,
66
],
[
105,
66
],
[
69,
68
],
[
56,
72
],
[
76,
75
],
[
6,
82
],
[
17,
85
],
[
56,
86
],
[
99,
88
],
[
61,
90
],
[
68,
92
],
[
75,
95
],
[
17,
97
],
[
56,
98
],
[
46,
101
],
[
105,
101
],
[
68,
102
],
[
75,
103
],
[
106,
105
],
[
61,
106
],
[
109,
108
],
[
112,
111
],
[
6,
116
],
[
120,
119
],
[
105,
122
],
[
46,
122
],
[
111,
123
],
[
111,
125
],
[
15,
126
],
[
119,
128
],
[
108,
128
],
[
135,
132
]
] | [
"import copy\ndef main():\n N, A = map(int, input().split())\n x = list(map(int, input().split()))\n dp = [[0] * (50*N + 1) for _ in range(N+1)]\n dp[0][0] = 1\n for k in range(N):\n dpn = copy.deepcopy(dp)\n for i in range(k+1):\n for j in range(50 * N + 1 -x[k]):\n dpn[i+1][j+x[k]] += dp[i][j]\n dp = dpn\n r = 0\n for i in range(1, N+1):\n r += dp[i][i*A]\n return r\nprint(main())",
"import copy",
"copy",
"def main():\n N, A = map(int, input().split())\n x = list(map(int, input().split()))\n dp = [[0] * (50*N + 1) for _ in range(N+1)]\n dp[0][0] = 1\n for k in range(N):\n dpn = copy.deepcopy(dp)\n for i in range(k+1):\n for j in range(50 * N + 1 -x[k]):\n dpn[i+1][j+x[k]] += dp[i][j]\n dp = dpn\n r = 0\n for i in range(1, N+1):\n r += dp[i][i*A]\n return r",
"main",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[0] * (50*N + 1) for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[0] * (50*N + 1)",
"[0]",
"0",
"50*N + 1",
"50*N",
"50",
"N",
"1",
"dp = [[0] * (50*N + 1) for _ in range(N+1)]",
"dp",
"[[0] * (50*N + 1) for _ in range(N+1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for k in range(N):\n dpn = copy.deepcopy(dp)\n for i in range(k+1):\n for j in range(50 * N + 1 -x[k]):\n dpn[i+1][j+x[k]] += dp[i][j]\n dp = dpn\n ",
"k",
"range(N)",
"range",
"N",
"dpn = copy.deepcopy(dp)",
"dpn",
"copy.deepcopy(dp)",
"copy.deepcopy",
"copy",
"deepcopy",
"dp",
"for i in range(k+1):\n for j in range(50 * N + 1 -x[k]):\n dpn[i+1][j+x[k]] += dp[i][j]\n ",
"i",
"range(k+1)",
"range",
"k+1",
"k",
"1",
"for j in range(50 * N + 1 -x[k]):\n dpn[i+1][j+x[k]] += dp[i][j]\n ",
"j",
"range(50 * N + 1 -x[k])",
"range",
"50 * N + 1 -x[k]",
"50 * N + 1",
"50 * N",
"50",
"N",
"1",
"x[k]",
"x",
"k",
"dpn[i+1][j+x[k]] += dp[i][j]",
"dpn[i+1][j+x[k]]",
"[i+1]",
"dpn",
"i+1",
"i",
"1",
"j+x[k]",
"j",
"x[k]",
"x",
"k",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp = dpn",
"dp",
"dpn",
"r = 0",
"r",
"0",
"for i in range(1, N+1):\n r += dp[i][i*A]\n ",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"r += dp[i][i*A]",
"r",
"dp[i][i*A]",
"[i]",
"dp",
"i",
"i*A",
"i",
"A",
"return r",
"r",
"print(main())",
"print",
"main()",
"main",
"def main():\n N, A = map(int, input().split())\n x = list(map(int, input().split()))\n dp = [[0] * (50*N + 1) for _ in range(N+1)]\n dp[0][0] = 1\n for k in range(N):\n dpn = copy.deepcopy(dp)\n for i in range(k+1):\n for j in range(50 * N + 1 -x[k]):\n dpn[i+1][j+x[k]] += dp[i][j]\n dp = dpn\n r = 0\n for i in range(1, N+1):\n r += dp[i][i*A]\n return r",
"def main():\n N, A = map(int, input().split())\n x = list(map(int, input().split()))\n dp = [[0] * (50*N + 1) for _ in range(N+1)]\n dp[0][0] = 1\n for k in range(N):\n dpn = copy.deepcopy(dp)\n for i in range(k+1):\n for j in range(50 * N + 1 -x[k]):\n dpn[i+1][j+x[k]] += dp[i][j]\n dp = dpn\n r = 0\n for i in range(1, N+1):\n r += dp[i][i*A]\n return r",
"main"
] | import copy
def main():
N, A = map(int, input().split())
x = list(map(int, input().split()))
dp = [[0] * (50*N + 1) for _ in range(N+1)]
dp[0][0] = 1
for k in range(N):
dpn = copy.deepcopy(dp)
for i in range(k+1):
for j in range(50 * N + 1 -x[k]):
dpn[i+1][j+x[k]] += dp[i][j]
dp = dpn
r = 0
for i in range(1, N+1):
r += dp[i][i*A]
return r
print(main())
|
[
7,
12,
13,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
12,
2,
4,
13,
13,
13,
23,
4,
18,
4,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
28,
13,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
0,
13,
2,
18,
13,
17,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
6,
5
],
[
6,
14
],
[
17,
16
],
[
14,
26
],
[
35,
34
],
[
41,
40
],
[
16,
40
],
[
44,
43
],
[
34,
48
],
[
60,
55
],
[
34,
56
],
[
40,
59
],
[
34,
63
],
[
40,
67
],
[
72,
71
],
[
34,
74
],
[
71,
79
],
[
88,
85
]
] | [
"def abc044_c():\n ''' 過去提出を参考に '''\n _, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split()))\n d = {0: 1} # 負の値を取り得るため、配列でなく辞書で持つ\n for x in X:\n prev = list(d.items()) # 前のターンのぶんを保持しておく\n for val, cnt in prev:\n d[val + x] = d.get(val + x, 0) + cnt\n ans = d[0] - 1\n print(ans)\n\nif __name__ == '__main__':\n abc044_c()",
"def abc044_c():\n ''' 過去提出を参考に '''\n _, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split()))\n d = {0: 1} # 負の値を取り得るため、配列でなく辞書で持つ\n for x in X:\n prev = list(d.items()) # 前のターンのぶんを保持しておく\n for val, cnt in prev:\n d[val + x] = d.get(val + x, 0) + cnt\n ans = d[0] - 1\n print(ans)",
"abc044_c",
"''' 過去提出を参考に '''",
"_, A = map(int, input().split())",
"_",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(lambda x: int(x) - A, input().split()))",
"X",
"list(map(lambda x: int(x) - A, input().split()))",
"list",
"map(lambda x: int(x) - A, input().split())",
"map",
"lambda x: int(x) - A",
"int(x) - A",
"int(x)",
"int",
"x",
"A",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"d = {0: 1}",
"d",
"{0: 1}",
"0",
"0",
"1",
"for x in X:\n prev = list(d.items()) # 前のターンのぶんを保持しておく\n for val, cnt in prev:\n d[val + x] = d.get(val + x, 0) + cnt\n ",
"x",
"X",
"prev = list(d.items())",
"prev",
"list(d.items())",
"list",
"d.items()",
"d.items",
"d",
"items",
"for val, cnt in prev:\n d[val + x] = d.get(val + x, 0) + cnt\n ",
"val",
"cnt",
"prev",
"d[val + x] = d.get(val + x, 0) + cnt",
"d[val + x]",
"d",
"val + x",
"val",
"x",
"d.get(val + x, 0) + cnt",
"d.get(val + x, 0)",
"d.get",
"d",
"get",
"val + x",
"val",
"x",
"0",
"cnt",
"ans = d[0] - 1",
"ans",
"d[0] - 1",
"d[0]",
"d",
"0",
"1",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n abc044_c()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"abc044_c()",
"abc044_c",
"def abc044_c():\n ''' 過去提出を参考に '''\n _, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split()))\n d = {0: 1} # 負の値を取り得るため、配列でなく辞書で持つ\n for x in X:\n prev = list(d.items()) # 前のターンのぶんを保持しておく\n for val, cnt in prev:\n d[val + x] = d.get(val + x, 0) + cnt\n ans = d[0] - 1\n print(ans)",
"def abc044_c():\n ''' 過去提出を参考に '''\n _, A = map(int, input().split())\n X = list(map(lambda x: int(x) - A, input().split()))\n d = {0: 1} # 負の値を取り得るため、配列でなく辞書で持つ\n for x in X:\n prev = list(d.items()) # 前のターンのぶんを保持しておく\n for val, cnt in prev:\n d[val + x] = d.get(val + x, 0) + cnt\n ans = d[0] - 1\n print(ans)",
"abc044_c"
] | def abc044_c():
''' 過去提出を参考に '''
_, A = map(int, input().split())
X = list(map(lambda x: int(x) - A, input().split()))
d = {0: 1} # 負の値を取り得るため、配列でなく辞書で持つ
for x in X:
prev = list(d.items()) # 前のターンのぶんを保持しておく
for val, cnt in prev:
d[val + x] = d.get(val + x, 0) + cnt
ans = d[0] - 1
print(ans)
if __name__ == '__main__':
abc044_c() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
2,
4,
13,
13,
13,
0,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
28,
13,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
21,
13,
10,
4,
13
] | [
[
86,
2
],
[
86,
11
],
[
15,
14
],
[
14,
24
],
[
78,
25
],
[
80,
27
],
[
83,
30
],
[
37,
36
],
[
81,
36
],
[
74,
39
],
[
84,
44
],
[
56,
51
],
[
84,
52
],
[
36,
55
],
[
84,
59
],
[
36,
63
],
[
84,
70
],
[
74,
75
],
[
86,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] | [
"n, a = map(int, input().split())\nx = [int(i)-a for i in input().split()]\n\ndp = {0: 1}\n\nfor i in x:\n tmp = list(dp.items())\n for key, value in tmp:\n dp[key+i] = dp.get(key+i, 0) + value\nprint(dp[0] - 1)\n\n",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"int(i)-a for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)-a",
"int(i)",
"int",
"i",
"a",
"x = [int(i)-a for i in input().split()]",
"x",
"[int(i)-a for i in input().split()]",
"dp = {0: 1}",
"dp",
"{0: 1}",
"0",
"0",
"1",
"for i in x:\n tmp = list(dp.items())\n for key, value in tmp:\n dp[key+i] = dp.get(key+i, 0) + value",
"i",
"x",
"tmp = list(dp.items())",
"tmp",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"for key, value in tmp:\n dp[key+i] = dp.get(key+i, 0) + value",
"key",
"value",
"tmp",
"dp[key+i] = dp.get(key+i, 0) + value",
"dp[key+i]",
"dp",
"key+i",
"key",
"i",
"dp.get(key+i, 0) + value",
"dp.get(key+i, 0)",
"dp.get",
"dp",
"get",
"key+i",
"key",
"i",
"0",
"value",
"print(dp[0] - 1)",
"print",
"dp[0] - 1",
"dp[0]",
"dp",
"0",
"1",
"tmp = list(dp.items())",
"list(dp.items())",
"tmp",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"x = [int(i)-a for i in input().split()]",
"[int(i)-a for i in input().split()]",
"x",
"dp = {0: 1}",
"{0: 1}",
"dp",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n"
] | n, a = map(int, input().split())
x = [int(i)-a for i in input().split()]
dp = {0: 1}
for i in x:
tmp = list(dp.items())
for key, value in tmp:
dp[key+i] = dp.get(key+i, 0) + value
print(dp[0] - 1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
2,
2,
13,
13,
17,
0,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
18,
13,
13,
18,
13,
2,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
28,
13,
4,
13,
2,
13,
17,
2,
2,
13,
13,
17,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
2,
13,
17,
4,
13,
17,
2,
2,
13,
13,
18,
13,
2,
13,
17,
18,
18,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
2,
13,
13,
13,
4,
13,
13,
4,
13,
0,
13,
18,
18,
13,
13,
2,
2,
13,
13,
2,
2,
13,
17,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
189,
2
],
[
189,
11
],
[
174,
13
],
[
192,
25
],
[
175,
28
],
[
32,
31
],
[
184,
35
],
[
193,
43
],
[
184,
44
],
[
177,
47
],
[
51,
50
],
[
184,
55
],
[
67,
58
],
[
178,
60
],
[
50,
61
],
[
175,
63
],
[
50,
65
],
[
70,
69
],
[
193,
74
],
[
82,
77
],
[
178,
79
],
[
50,
80
],
[
69,
81
],
[
178,
84
],
[
50,
86
],
[
69,
88
],
[
91,
90
],
[
193,
94
],
[
193,
98
],
[
184,
99
],
[
107,
102
],
[
178,
104
],
[
50,
105
],
[
90,
106
],
[
178,
110
],
[
50,
112
],
[
90,
119
],
[
193,
120
],
[
175,
122
],
[
50,
124
],
[
178,
128
],
[
50,
130
],
[
90,
132
],
[
180,
134
],
[
138,
137
],
[
184,
142
],
[
137,
147
],
[
190,
148
],
[
193,
149
],
[
181,
152
],
[
187,
152
],
[
186,
156
],
[
178,
159
],
[
184,
160
],
[
137,
163
],
[
190,
164
],
[
137,
167
],
[
193,
169
],
[
187,
172
],
[
181,
172
],
[
174,
175
],
[
177,
178
],
[
180,
181
],
[
189,
184
],
[
186,
187
],
[
189,
190
],
[
192,
193
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\ns = sum(x)\ndp = [[0] * (s * n + 1) for _ in range(n + 1)]\nfor i in range(1, n + 1):\n dp[i][x[i - 1]] = 1\n for j in range(1, s + 1):\n dp[i][j] += dp[i - 1][j]\n for j in range(s + 1, s * n + 1):\n dp[i][j] = dp[i - 1][max(0, j - s - x[i - 1])] + dp[i - 1][j]\nans = 0\nfor i in range(1, n + 1):\n if i * a > s:\n print(ans)\n exit()\n ans += dp[n][i * a + (i - 1) * s]\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"s = sum(x)",
"s",
"sum(x)",
"sum",
"x",
"[0] * (s * n + 1) for _ in range(n + 1)",
"for _ in range(n + 1)",
"_",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for _ in range(n + 1)",
"[0] * (s * n + 1)",
"[0]",
"0",
"s * n + 1",
"s * n",
"s",
"n",
"1",
"dp = [[0] * (s * n + 1) for _ in range(n + 1)]",
"dp",
"[[0] * (s * n + 1) for _ in range(n + 1)]",
"for i in range(1, n + 1):\n dp[i][x[i - 1]] = 1\n for j in range(1, s + 1):\n dp[i][j] += dp[i - 1][j]\n for j in range(s + 1, s * n + 1):\n dp[i][j] = dp[i - 1][max(0, j - s - x[i - 1])] + dp[i - 1][j]",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"dp[i][x[i - 1]] = 1",
"dp[i][x[i - 1]]",
"[i]",
"dp",
"i",
"x[i - 1]",
"x",
"i - 1",
"i",
"1",
"1",
"for j in range(1, s + 1):\n dp[i][j] += dp[i - 1][j]\n ",
"j",
"range(1, s + 1)",
"range",
"1",
"s + 1",
"s",
"1",
"dp[i][j] += dp[i - 1][j]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i - 1][j]",
"[i - 1]",
"dp",
"i - 1",
"i",
"1",
"j",
"for j in range(s + 1, s * n + 1):\n dp[i][j] = dp[i - 1][max(0, j - s - x[i - 1])] + dp[i - 1][j]",
"j",
"range(s + 1, s * n + 1)",
"range",
"s + 1",
"s",
"1",
"s * n + 1",
"s * n",
"s",
"n",
"1",
"dp[i][j] = dp[i - 1][max(0, j - s - x[i - 1])] + dp[i - 1][j]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i - 1][max(0, j - s - x[i - 1])] + dp[i - 1][j]",
"dp[i - 1][max(0, j - s - x[i - 1])]",
"[i - 1]",
"dp",
"i - 1",
"i",
"1",
"max(0, j - s - x[i - 1])",
"max",
"0",
"j - s - x[i - 1]",
"j - s",
"j",
"s",
"x[i - 1]",
"x",
"i - 1",
"i",
"1",
"dp[i - 1][j]",
"[i - 1]",
"dp",
"i - 1",
"i",
"1",
"j",
"ans = 0",
"ans",
"0",
"for i in range(1, n + 1):\n if i * a > s:\n print(ans)\n exit()\n ans += dp[n][i * a + (i - 1) * s]",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"if i * a > s:\n print(ans)\n exit()\n ",
"i * a > s",
"i * a",
"i",
"a",
"s",
"print(ans)",
"print",
"ans",
"exit()",
"exit",
"ans += dp[n][i * a + (i - 1) * s]",
"ans",
"dp[n][i * a + (i - 1) * s]",
"[n]",
"dp",
"n",
"i * a + (i - 1) * s",
"i * a",
"i",
"a",
"(i - 1) * s",
"i - 1",
"i",
"1",
"s",
"print(ans)",
"print",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [[0] * (s * n + 1) for _ in range(n + 1)]",
"[[0] * (s * n + 1) for _ in range(n + 1)]",
"dp",
"ans = 0",
"0",
"ans",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"ans += dp[n][i * a + (i - 1) * s]",
"dp[n][i * a + (i - 1) * s]",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"s = sum(x)",
"sum(x)",
"s"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
s = sum(x)
dp = [[0] * (s * n + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
dp[i][x[i - 1]] = 1
for j in range(1, s + 1):
dp[i][j] += dp[i - 1][j]
for j in range(s + 1, s * n + 1):
dp[i][j] = dp[i - 1][max(0, j - s - x[i - 1])] + dp[i - 1][j]
ans = 0
for i in range(1, n + 1):
if i * a > s:
print(ans)
exit()
ans += dp[n][i * a + (i - 1) * s]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
17,
14,
40,
18,
18,
18,
13,
13,
13,
13,
9,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
14,
2,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13
] | [
[
155,
2
],
[
155,
11
],
[
146,
13
],
[
27,
26
],
[
156,
30
],
[
149,
35
],
[
45,
38
],
[
150,
41
],
[
48,
47
],
[
156,
50
],
[
53,
52
],
[
156,
56
],
[
60,
59
],
[
150,
68
],
[
47,
69
],
[
52,
70
],
[
59,
71
],
[
83,
74
],
[
150,
77
],
[
47,
79
],
[
52,
81
],
[
59,
82
],
[
150,
86
],
[
47,
87
],
[
52,
88
],
[
59,
89
],
[
52,
92
],
[
156,
93
],
[
110,
95
],
[
150,
98
],
[
47,
100
],
[
52,
103
],
[
59,
106
],
[
147,
108
],
[
47,
109
],
[
150,
113
],
[
47,
114
],
[
52,
115
],
[
59,
116
],
[
152,
118
],
[
122,
121
],
[
156,
126
],
[
158,
129
],
[
150,
133
],
[
156,
134
],
[
121,
135
],
[
121,
137
],
[
144,
138
],
[
159,
141
],
[
153,
141
],
[
155,
144
],
[
146,
147
],
[
149,
150
],
[
152,
153
],
[
155,
156
],
[
158,
159
]
] | [
"N,A=map(int, input().split())\nX=list(map(int, input().split()))\ndp=[[[0]*(2501) for _ in range(N+1)]for _ in range(N+1)]\ndp[0][0][0]=1\n#dp[i][j][k]i枚目を検討中、j枚選び、合計kとなるのは何通りか\nfor i in range(N):\n for j in range(N+1):\n for k in range(2501):\n if not dp[i][j][k]:\n continue\n dp[i+1][j][k]+=dp[i][j][k]\n if j<N:\n dp[i+1][j+1][k+X[i]]+=dp[i][j][k]\nans=0\nfor i in range(1,N+1):\n ans+=dp[N][i][i*A]\nprint(ans)",
"N,A=map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X=list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0]*(2501) for _ in range(N+1)]for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[[0]*(2501) for _ in range(N+1)]",
"dp=[[[0]*(2501) for _ in range(N+1)]for _ in range(N+1)]",
"dp",
"[[[0]*(2501) for _ in range(N+1)]for _ in range(N+1)]",
"dp[0][0][0]=1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(N):\n for j in range(N+1):\n for k in range(2501):\n if not dp[i][j][k]:\n continue\n dp[i+1][j][k]+=dp[i][j][k]\n if j<N:\n dp[i+1][j+1][k+X[i]]+=dp[i][j][k]",
"i",
"range(N)",
"range",
"N",
"for j in range(N+1):\n for k in range(2501):\n if not dp[i][j][k]:\n continue\n dp[i+1][j][k]+=dp[i][j][k]\n if j<N:\n dp[i+1][j+1][k+X[i]]+=dp[i][j][k]",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for k in range(2501):\n if not dp[i][j][k]:\n continue\n dp[i+1][j][k]+=dp[i][j][k]\n if j<N:\n dp[i+1][j+1][k+X[i]]+=dp[i][j][k]",
"k",
"range(2501)",
"range",
"2501",
"if not dp[i][j][k]:\n continue\n ",
"not dp[i][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"continue",
"dp[i+1][j][k]+=dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"if j<N:\n dp[i+1][j+1][k+X[i]]+=dp[i][j][k]",
"j<N",
"j",
"N",
"dp[i+1][j+1][k+X[i]]+=dp[i][j][k]",
"dp[i+1][j+1][k+X[i]]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k+X[i]",
"k",
"X[i]",
"X",
"i",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"ans=0",
"ans",
"0",
"for i in range(1,N+1):\n ans+=dp[N][i][i*A]",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans+=dp[N][i][i*A]",
"ans",
"dp[N][i][i*A]",
"[i]",
"[N]",
"dp",
"N",
"i",
"i*A",
"i",
"A",
"print(ans)",
"print",
"ans",
"A=map(int, input().split())",
"map(int, input().split())",
"A",
"X=list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"dp=[[[0]*(2501) for _ in range(N+1)]for _ in range(N+1)]",
"[[[0]*(2501) for _ in range(N+1)]for _ in range(N+1)]",
"dp",
"ans=0",
"0",
"ans",
"N,A=map(int, input().split())",
"map(int, input().split())",
"N",
"ans+=dp[N][i][i*A]",
"dp[N][i][i*A]",
"ans"
] | N,A=map(int, input().split())
X=list(map(int, input().split()))
dp=[[[0]*(2501) for _ in range(N+1)]for _ in range(N+1)]
dp[0][0][0]=1
#dp[i][j][k]i枚目を検討中、j枚選び、合計kとなるのは何通りか
for i in range(N):
for j in range(N+1):
for k in range(2501):
if not dp[i][j][k]:
continue
dp[i+1][j][k]+=dp[i][j][k]
if j<N:
dp[i+1][j+1][k+X[i]]+=dp[i][j][k]
ans=0
for i in range(1,N+1):
ans+=dp[N][i][i*A]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
28,
13,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
21,
13,
10,
4,
13
] | [
[
86,
2
],
[
86,
11
],
[
95,
13
],
[
27,
26
],
[
96,
26
],
[
26,
30
],
[
81,
31
],
[
89,
33
],
[
92,
36
],
[
43,
42
],
[
90,
42
],
[
83,
45
],
[
93,
50
],
[
62,
57
],
[
93,
58
],
[
42,
61
],
[
93,
65
],
[
42,
69
],
[
93,
76
],
[
86,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
]
] | [
"N,A = map(int,input().split())\nX = list(map(int,input().split()))\nY = [x-A for x in X]\ndp = {0:1}\n\nfor y in Y:\n tmp = list(dp.items())\n for k,v in tmp:\n dp[k+y]=dp.get(k+y,0)+v\n\nprint(dp[0]-1)",
"N,A = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int,input().split()))",
"X",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x-A for x in X",
"for x in X",
"x",
"X",
"for x in X",
"x-A",
"x",
"A",
"Y = [x-A for x in X]",
"Y",
"[x-A for x in X]",
"dp = {0:1}",
"dp",
"{0:1}",
"0",
"0",
"1",
"for y in Y:\n tmp = list(dp.items())\n for k,v in tmp:\n dp[k+y]=dp.get(k+y,0)+v",
"y",
"Y",
"tmp = list(dp.items())",
"tmp",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"for k,v in tmp:\n dp[k+y]=dp.get(k+y,0)+v",
"k",
"v",
"tmp",
"dp[k+y]=dp.get(k+y,0)+v",
"dp[k+y]",
"dp",
"k+y",
"k",
"y",
"dp.get(k+y,0)+v",
"dp.get(k+y,0)",
"dp.get",
"dp",
"get",
"k+y",
"k",
"y",
"0",
"v",
"print(dp[0]-1)",
"print",
"dp[0]-1",
"dp[0]",
"dp",
"0",
"1",
"A = map(int,input().split())",
"map(int,input().split())",
"A",
"tmp = list(dp.items())",
"list(dp.items())",
"tmp",
"N,A = map(int,input().split())",
"map(int,input().split())",
"N",
"Y = [x-A for x in X]",
"[x-A for x in X]",
"Y",
"dp = {0:1}",
"{0:1}",
"dp",
"X = list(map(int,input().split()))",
"list(map(int,input().split()))",
"X"
] | N,A = map(int,input().split())
X = list(map(int,input().split()))
Y = [x-A for x in X]
dp = {0:1}
for y in Y:
tmp = list(dp.items())
for k,v in tmp:
dp[k+y]=dp.get(k+y,0)+v
print(dp[0]-1) |
[
7,
15,
13,
15,
0,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
31,
13,
12,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
0,
13,
4,
13,
13,
0,
18,
13,
17,
17,
28,
13,
13,
0,
13,
4,
18,
13,
13,
28,
13,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
13,
0,
13,
13,
0,
13,
2,
18,
13,
17,
17,
29,
13,
14,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
93,
5
],
[
93,
18
],
[
93,
19
],
[
25,
24
],
[
94,
27
],
[
32,
29
],
[
24,
31
],
[
91,
32
],
[
35,
34
],
[
42,
39
],
[
34,
40
],
[
45,
44
],
[
48,
47
],
[
34,
50
],
[
67,
50
],
[
34,
57
],
[
67,
57
],
[
65,
60
],
[
47,
61
],
[
44,
64
],
[
68,
67
],
[
47,
68
],
[
71,
70
],
[
67,
73
],
[
34,
73
],
[
70,
77
],
[
99,
83
],
[
97,
85
],
[
100,
88
],
[
93,
91
],
[
93,
94
],
[
99,
100
]
] | [
"import sys\nfrom collections import defaultdict\n\nn, a, *x = map(int, sys.stdin.read().split())\n\ndef main():\n for i in range(n):\n x[i] -= a\n \n c = defaultdict(int)\n c[0] = 1\n for i in x:\n nex = c.copy()\n for val, cnt in c.items():\n nex[val+i] += cnt\n c = nex\n ans = c[0] - 1\n return ans\n\nif __name__ == '__main__':\n ans = main()\n print(ans)",
"import sys",
"sys",
"from collections import defaultdict",
"n, a, *x = map(int, sys.stdin.read().split())",
"n",
"map(int, sys.stdin.read().split())",
"map",
"int",
"sys.stdin.read().split()",
"sys.stdin.read().split",
"sys.stdin.read()",
"sys.stdin.read",
"sys.stdin",
"sys",
"stdin",
"read",
"split",
"a",
"*x",
"x",
"def main():\n for i in range(n):\n x[i] -= a\n \n c = defaultdict(int)\n c[0] = 1\n for i in x:\n nex = c.copy()\n for val, cnt in c.items():\n nex[val+i] += cnt\n c = nex\n ans = c[0] - 1\n return ans",
"main",
"for i in range(n):\n x[i] -= a\n \n ",
"i",
"range(n)",
"range",
"n",
"x[i] -= a",
"x[i]",
"x",
"i",
"a",
"c = defaultdict(int)",
"c",
"defaultdict(int)",
"defaultdict",
"int",
"c[0] = 1",
"c[0]",
"c",
"0",
"1",
"for i in x:\n nex = c.copy()\n for val, cnt in c.items():\n nex[val+i] += cnt\n c = nex\n ",
"i",
"x",
"nex = c.copy()",
"nex",
"c.copy()",
"c.copy",
"c",
"copy",
"for val, cnt in c.items():\n nex[val+i] += cnt\n ",
"val",
"cnt",
"c.items()",
"c.items",
"c",
"items",
"nex[val+i] += cnt",
"nex[val+i]",
"nex",
"val+i",
"val",
"i",
"cnt",
"c = nex",
"c",
"nex",
"ans = c[0] - 1",
"ans",
"c[0] - 1",
"c[0]",
"c",
"0",
"1",
"return ans",
"ans",
"if __name__ == '__main__':\n ans = main()\n print(ans)",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"ans = main()",
"ans",
"main()",
"main",
"print(ans)",
"print",
"ans",
"a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"a",
"n, a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"n",
"def main():\n for i in range(n):\n x[i] -= a\n \n c = defaultdict(int)\n c[0] = 1\n for i in x:\n nex = c.copy()\n for val, cnt in c.items():\n nex[val+i] += cnt\n c = nex\n ans = c[0] - 1\n return ans",
"def main():\n for i in range(n):\n x[i] -= a\n \n c = defaultdict(int)\n c[0] = 1\n for i in x:\n nex = c.copy()\n for val, cnt in c.items():\n nex[val+i] += cnt\n c = nex\n ans = c[0] - 1\n return ans",
"main",
"ans = main()",
"main()",
"ans"
] | import sys
from collections import defaultdict
n, a, *x = map(int, sys.stdin.read().split())
def main():
for i in range(n):
x[i] -= a
c = defaultdict(int)
c[0] = 1
for i in x:
nex = c.copy()
for val, cnt in c.items():
nex[val+i] += cnt
c = nex
ans = c[0] - 1
return ans
if __name__ == '__main__':
ans = main()
print(ans) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
17,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
31,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
2,
39,
17,
17,
0,
18,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
13,
13,
28,
13,
4,
13,
17,
14,
40,
40,
17,
2,
13,
18,
13,
13,
17,
0,
18,
13,
13,
18,
13,
2,
13,
18,
13,
13,
4,
13,
2,
18,
13,
13,
17,
29,
14,
2,
13,
17,
4,
13,
10,
2,
13,
10,
18,
13,
10,
12,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13
] | [
[
141,
4
],
[
144,
11
],
[
135,
18
],
[
132,
32
],
[
147,
37
],
[
43,
42
],
[
142,
49
],
[
43,
51
],
[
43,
52
],
[
57,
56
],
[
56,
60
],
[
51,
61
],
[
64,
63
],
[
67,
66
],
[
70,
69
],
[
78,
75
],
[
69,
76
],
[
66,
77
],
[
81,
80
],
[
42,
83
],
[
86,
85
],
[
69,
87
],
[
85,
87
],
[
90,
89
],
[
85,
90
],
[
69,
90
],
[
93,
92
],
[
92,
101
],
[
63,
103
],
[
80,
104
],
[
110,
107
],
[
85,
108
],
[
69,
108
],
[
92,
109
],
[
89,
111
],
[
92,
113
],
[
63,
115
],
[
80,
116
],
[
75,
120
],
[
85,
121
],
[
69,
121
],
[
66,
122
],
[
139,
130
],
[
132,
133
],
[
135,
136
],
[
141,
142
],
[
144,
145
],
[
147,
148
]
] | [
"import sys\n\nread = sys.stdin.read\nreadline = sys.stdin.readline\nreadlines = sys.stdin.readlines\nsys.setrecursionlimit(10 ** 9)\nINF = 1 << 60\nMOD = 1000000007\n\n\ndef main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [0] * 5001\n dp[base] = 1\n for i in range(N):\n dp, dp_prev = dp[:], dp\n for j in range(5001):\n if 0 <= j - X[i] <= 5000:\n dp[j] += dp_prev[j - X[i]]\n\n print(dp[base] - 1)\n\n return\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"read = sys.stdin.read",
"read",
"sys.stdin.read",
"sys.stdin",
"sys",
"stdin",
"read",
"readline = sys.stdin.readline",
"readline",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"readlines = sys.stdin.readlines",
"readlines",
"sys.stdin.readlines",
"sys.stdin",
"sys",
"stdin",
"readlines",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = 1 << 60",
"INF",
"1 << 60",
"1",
"60",
"MOD = 1000000007",
"MOD",
"1000000007",
"def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [0] * 5001\n dp[base] = 1\n for i in range(N):\n dp, dp_prev = dp[:], dp\n for j in range(5001):\n if 0 <= j - X[i] <= 5000:\n dp[j] += dp_prev[j - X[i]]\n\n print(dp[base] - 1)\n\n return",
"main",
"N, A, *X = map(int, read().split())",
"N",
"map(int, read().split())",
"map",
"int",
"read().split()",
"().split",
"()",
"read",
"split",
"A",
"*X",
"X",
"x - A for x in X",
"for x in X",
"x",
"X",
"for x in X",
"x - A",
"x",
"A",
"X = [x - A for x in X]",
"X",
"[x - A for x in X]",
"base = 2500",
"base",
"2500",
"dp = [0] * 5001",
"dp",
"[0] * 5001",
"[0]",
"0",
"5001",
"dp[base] = 1",
"dp[base]",
"dp",
"base",
"1",
"for i in range(N):\n dp, dp_prev = dp[:], dp\n for j in range(5001):\n if 0 <= j - X[i] <= 5000:\n dp[j] += dp_prev[j - X[i]]\n\n ",
"i",
"range(N)",
"range",
"N",
"dp, dp_prev = dp[:], dp",
"dp",
"dp[:]",
"dp",
":",
"dp_prev",
"dp",
"for j in range(5001):\n if 0 <= j - X[i] <= 5000:\n dp[j] += dp_prev[j - X[i]]\n\n ",
"j",
"range(5001)",
"range",
"5001",
"if 0 <= j - X[i] <= 5000:\n dp[j] += dp_prev[j - X[i]]\n\n ",
"0 <= j - X[i] <= 5000",
"0 <= j - X[i]",
"0",
"j - X[i]",
"j",
"X[i]",
"X",
"i",
"5000",
"dp[j] += dp_prev[j - X[i]]",
"dp[j]",
"dp",
"j",
"dp_prev[j - X[i]]",
"dp_prev",
"j - X[i]",
"j",
"X[i]",
"X",
"i",
"print(dp[base] - 1)",
"print",
"dp[base] - 1",
"dp[base]",
"dp",
"base",
"1",
"return",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"INF = 1 << 60",
"1 << 60",
"INF",
"readlines = sys.stdin.readlines",
"sys.stdin.readlines",
"readlines",
"def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [0] * 5001\n dp[base] = 1\n for i in range(N):\n dp, dp_prev = dp[:], dp\n for j in range(5001):\n if 0 <= j - X[i] <= 5000:\n dp[j] += dp_prev[j - X[i]]\n\n print(dp[base] - 1)\n\n return",
"def main():\n N, A, *X = map(int, read().split())\n\n X = [x - A for x in X]\n\n base = 2500\n dp = [0] * 5001\n dp[base] = 1\n for i in range(N):\n dp, dp_prev = dp[:], dp\n for j in range(5001):\n if 0 <= j - X[i] <= 5000:\n dp[j] += dp_prev[j - X[i]]\n\n print(dp[base] - 1)\n\n return",
"main",
"read = sys.stdin.read",
"sys.stdin.read",
"read",
"readline = sys.stdin.readline",
"sys.stdin.readline",
"readline",
"MOD = 1000000007",
"1000000007",
"MOD"
] | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, A, *X = map(int, read().split())
X = [x - A for x in X]
base = 2500
dp = [0] * 5001
dp[base] = 1
for i in range(N):
dp, dp_prev = dp[:], dp
for j in range(5001):
if 0 <= j - X[i] <= 5000:
dp[j] += dp_prev[j - X[i]]
print(dp[base] - 1)
return
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
13,
17,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
40,
13,
18,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
2,
18,
18,
18,
13,
13,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13
] | [
[
180,
2
],
[
180,
11
],
[
171,
13
],
[
165,
25
],
[
172,
28
],
[
32,
31
],
[
181,
35
],
[
183,
40
],
[
168,
43
],
[
53,
46
],
[
184,
49
],
[
56,
55
],
[
181,
58
],
[
61,
60
],
[
55,
64
],
[
68,
67
],
[
166,
72
],
[
181,
73
],
[
67,
77
],
[
172,
79
],
[
55,
80
],
[
91,
82
],
[
184,
85
],
[
55,
87
],
[
60,
89
],
[
67,
90
],
[
184,
95
],
[
55,
96
],
[
60,
98
],
[
67,
101
],
[
172,
103
],
[
55,
104
],
[
184,
108
],
[
55,
109
],
[
60,
110
],
[
67,
111
],
[
122,
113
],
[
184,
116
],
[
55,
118
],
[
60,
120
],
[
67,
121
],
[
184,
125
],
[
55,
126
],
[
60,
127
],
[
67,
128
],
[
131,
130
],
[
166,
135
],
[
181,
136
],
[
140,
139
],
[
181,
144
],
[
175,
149
],
[
139,
150
],
[
130,
151
],
[
177,
153
],
[
184,
157
],
[
181,
158
],
[
139,
159
],
[
130,
160
],
[
178,
163
],
[
169,
163
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
180,
175
],
[
177,
178
],
[
180,
181
],
[
183,
184
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\nx_max = max(x)\ndp = [[[0]*(x_max*n+1) for k in range(n+1)] for i in range(n+1)]\nans = 0\ndp[0][0][0] = 1\nfor i in range(n):\n for j in range(i+2):\n for k in range(x_max*n+1):\n if k>= x[i]:\n dp[i+1][j][k] = dp[i][j-1][k-x[i]] + dp[i][j][k]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n \nfor k in range(x_max*n+1):\n for j in range(1,n+1):\n if a*j == k:\n ans += dp[n][j][k]\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x_max = max(x)",
"x_max",
"max(x)",
"max",
"x",
"[[0]*(x_max*n+1) for k in range(n+1)] for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[[0]*(x_max*n+1) for k in range(n+1)]",
"dp = [[[0]*(x_max*n+1) for k in range(n+1)] for i in range(n+1)]",
"dp",
"[[[0]*(x_max*n+1) for k in range(n+1)] for i in range(n+1)]",
"ans = 0",
"ans",
"0",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(n):\n for j in range(i+2):\n for k in range(x_max*n+1):\n if k>= x[i]:\n dp[i+1][j][k] = dp[i][j-1][k-x[i]] + dp[i][j][k]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"i",
"range(n)",
"range",
"n",
"for j in range(i+2):\n for k in range(x_max*n+1):\n if k>= x[i]:\n dp[i+1][j][k] = dp[i][j-1][k-x[i]] + dp[i][j][k]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"j",
"range(i+2)",
"range",
"i+2",
"i",
"2",
"for k in range(x_max*n+1):\n if k>= x[i]:\n dp[i+1][j][k] = dp[i][j-1][k-x[i]] + dp[i][j][k]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"k",
"range(x_max*n+1)",
"range",
"x_max*n+1",
"x_max*n",
"x_max",
"n",
"1",
"if k>= x[i]:\n dp[i+1][j][k] = dp[i][j-1][k-x[i]] + dp[i][j][k]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"k>= x[i]",
"k",
"x[i]",
"x",
"i",
"dp[i+1][j][k] = dp[i][j-1][k-x[i]] + dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j-1][k-x[i]] + dp[i][j][k]",
"dp[i][j-1][k-x[i]]",
"[j-1]",
"[i]",
"dp",
"i",
"j-1",
"j",
"1",
"k-x[i]",
"k",
"x[i]",
"x",
"i",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i+1][j][k] = dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"for k in range(x_max*n+1):\n for j in range(1,n+1):\n if a*j == k:\n ans += dp[n][j][k]",
"k",
"range(x_max*n+1)",
"range",
"x_max*n+1",
"x_max*n",
"x_max",
"n",
"1",
"for j in range(1,n+1):\n if a*j == k:\n ans += dp[n][j][k]",
"j",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"if a*j == k:\n ans += dp[n][j][k]",
"a*j == k",
"a*j",
"a",
"j",
"k",
"ans += dp[n][j][k]",
"ans",
"dp[n][j][k]",
"[j]",
"[n]",
"dp",
"n",
"j",
"k",
"print(ans)",
"print",
"ans",
"x_max = max(x)",
"max(x)",
"x_max",
"ans = 0",
"0",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"ans += dp[n][j][k]",
"dp[n][j][k]",
"ans",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"dp = [[[0]*(x_max*n+1) for k in range(n+1)] for i in range(n+1)]",
"[[[0]*(x_max*n+1) for k in range(n+1)] for i in range(n+1)]",
"dp"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
x_max = max(x)
dp = [[[0]*(x_max*n+1) for k in range(n+1)] for i in range(n+1)]
ans = 0
dp[0][0][0] = 1
for i in range(n):
for j in range(i+2):
for k in range(x_max*n+1):
if k>= x[i]:
dp[i+1][j][k] = dp[i][j-1][k-x[i]] + dp[i][j][k]
else:
dp[i+1][j][k] = dp[i][j][k]
for k in range(x_max*n+1):
for j in range(1,n+1):
if a*j == k:
ans += dp[n][j][k]
print(ans) |
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
4,
2,
4,
13,
13,
13,
12,
13,
14,
2,
13,
17,
29,
17,
14,
2,
2,
2,
13,
13,
17,
13,
29,
17,
14,
2,
13,
17,
14,
2,
13,
17,
29,
17,
29,
17,
14,
2,
13,
13,
29,
17,
0,
13,
4,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
0,
13,
4,
13,
2,
13,
17,
13,
13,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
14,
2,
13,
17,
29,
13,
14,
2,
13,
17,
29,
13,
29,
2,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
17,
12,
13,
0,
13,
39,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
17,
14,
2,
13,
17,
0,
13,
4,
13,
13,
13,
13,
0,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
4,
13,
17,
13,
2,
13,
13,
14,
40,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
12,
13,
10,
12,
13
] | [
[
212,
3
],
[
212,
12
],
[
16,
15
],
[
15,
24
],
[
218,
26
],
[
219,
32
],
[
213,
33
],
[
125,
38
],
[
213,
46
],
[
121,
47
],
[
123,
49
],
[
123,
54
],
[
125,
58
],
[
121,
66
],
[
213,
67
],
[
72,
71
],
[
121,
75
],
[
123,
78
],
[
125,
81
],
[
219,
83
],
[
121,
84
],
[
87,
86
],
[
121,
90
],
[
123,
92
],
[
125,
93
],
[
71,
97
],
[
86,
100
],
[
71,
106
],
[
86,
109
],
[
86,
112
],
[
71,
115
],
[
71,
118
],
[
86,
119
],
[
121,
121
],
[
123,
123
],
[
125,
125
],
[
203,
127
],
[
133,
132
],
[
139,
138
],
[
204,
141
],
[
132,
143
],
[
138,
147
],
[
151,
150
],
[
222,
152
],
[
164,
153
],
[
166,
154
],
[
168,
155
],
[
160,
157
],
[
204,
158
],
[
132,
159
],
[
150,
160
],
[
138,
160
],
[
150,
162
],
[
138,
162
],
[
164,
164
],
[
166,
166
],
[
168,
168
],
[
215,
170
],
[
174,
173
],
[
213,
178
],
[
206,
181
],
[
225,
183
],
[
173,
185
],
[
173,
187
],
[
201,
188
],
[
207,
191
],
[
209,
194
],
[
207,
195
],
[
210,
198
],
[
216,
198
],
[
212,
201
],
[
203,
204
],
[
206,
207
],
[
207,
209
],
[
209,
210
],
[
212,
213
],
[
215,
216
],
[
218,
219
]
] | [
"from functools import lru_cache\nN, A = map(int, input().split())\nX = [int(x) for x in input().split()]\n#with open(\"9\", \"w\") as f:\n# print(50, 1, file=f)\n# print(*([1]*50), file=f)\nassert len(X) == N\ndef solve0(i, n, s):\n if s < 0:\n return -1\n if N-i+1 < n:\n return -1\n if n == 0:\n if s == 0:\n return 1\n else:\n return -1\n if i == N:\n return -1\n s1 = solve(i+1, n-1,s-X[i])\n s2 = solve(i+1, n, s)\n if s1 == -1 and s2 == -1:\n return -1\n if s1 == -1:\n return s2\n if s2 == -1:\n return s1\n return s1 + s2\n\ncache = {}\ndef solve(i, n, s):\n key = (i, n, s)\n a = cache.get(key, None)\n if a is None:\n a = solve0(i, n, s)\n cache[key] = a\n return a\n\nanswer = 0\nfor n in range(1, N+1):\n s = solve(0, n, n*A)\n if s != -1:\n answer += s\nprint(answer)",
"from functools import lru_cache",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"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",
"X = [int(x) for x in input().split()]",
"X",
"[int(x) for x in input().split()]",
"assert len(X) == N",
"len(X) == N",
"len(X)",
"len",
"X",
"N",
"def solve0(i, n, s):\n if s < 0:\n return -1\n if N-i+1 < n:\n return -1\n if n == 0:\n if s == 0:\n return 1\n else:\n return -1\n if i == N:\n return -1\n s1 = solve(i+1, n-1,s-X[i])\n s2 = solve(i+1, n, s)\n if s1 == -1 and s2 == -1:\n return -1\n if s1 == -1:\n return s2\n if s2 == -1:\n return s1\n return s1 + s2",
"solve0",
"if s < 0:\n return -1\n ",
"s < 0",
"s",
"0",
"return -1",
"-1",
"if N-i+1 < n:\n return -1\n ",
"N-i+1 < n",
"N-i+1",
"N-i",
"N",
"i",
"1",
"n",
"return -1",
"-1",
"if n == 0:\n if s == 0:\n return 1\n else:\n return -1\n ",
"n == 0",
"n",
"0",
"if s == 0:\n return 1\n else:\n return -1\n ",
"s == 0",
"s",
"0",
"return 1",
"1",
"return -1",
"-1",
"if i == N:\n return -1\n ",
"i == N",
"i",
"N",
"return -1",
"-1",
"s1 = solve(i+1, n-1,s-X[i])",
"s1",
"solve(i+1, n-1,s-X[i])",
"solve",
"i+1",
"i",
"1",
"n-1",
"n",
"1",
"s-X[i]",
"s",
"X[i]",
"X",
"i",
"s2 = solve(i+1, n, s)",
"s2",
"solve(i+1, n, s)",
"solve",
"i+1",
"i",
"1",
"n",
"s",
"if s1 == -1 and s2 == -1:\n return -1\n ",
"s1 == -1 and s2 == -1",
"s1 == -1",
"s1",
"-1",
"s2 == -1",
"s2",
"-1",
"return -1",
"-1",
"if s1 == -1:\n return s2\n ",
"s1 == -1",
"s1",
"-1",
"return s2",
"s2",
"if s2 == -1:\n return s1\n ",
"s2 == -1",
"s2",
"-1",
"return s1",
"s1",
"return s1 + s2",
"s1 + s2",
"s1",
"s2",
"i",
"i",
"n",
"n",
"s",
"s",
"cache = {}",
"cache",
"{}",
"def solve(i, n, s):\n key = (i, n, s)\n a = cache.get(key, None)\n if a is None:\n a = solve0(i, n, s)\n cache[key] = a\n return a",
"solve",
"key = (i, n, s)",
"key",
"(i, n, s)",
"i",
"n",
"s",
"a = cache.get(key, None)",
"a",
"cache.get(key, None)",
"cache.get",
"cache",
"get",
"key",
"None",
"if a is None:\n a = solve0(i, n, s)\n cache[key] = a\n ",
"a is None",
"a",
"None",
"a = solve0(i, n, s)",
"a",
"solve0(i, n, s)",
"solve0",
"i",
"n",
"s",
"cache[key] = a",
"cache[key]",
"cache",
"key",
"a",
"return a",
"a",
"i",
"i",
"n",
"n",
"s",
"s",
"answer = 0",
"answer",
"0",
"for n in range(1, N+1):\n s = solve(0, n, n*A)\n if s != -1:\n answer += s",
"n",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"s = solve(0, n, n*A)",
"s",
"solve(0, n, n*A)",
"solve",
"0",
"n",
"n*A",
"n",
"A",
"if s != -1:\n answer += s",
"s != -1",
"s",
"-1",
"answer += s",
"answer",
"s",
"print(answer)",
"print",
"answer",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"cache = {}",
"{}",
"cache",
"s = solve(0, n, n*A)",
"solve(0, n, n*A)",
"s",
"answer += s",
"s",
"answer",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"answer = 0",
"0",
"answer",
"X = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"X",
"def solve0(i, n, s):\n if s < 0:\n return -1\n if N-i+1 < n:\n return -1\n if n == 0:\n if s == 0:\n return 1\n else:\n return -1\n if i == N:\n return -1\n s1 = solve(i+1, n-1,s-X[i])\n s2 = solve(i+1, n, s)\n if s1 == -1 and s2 == -1:\n return -1\n if s1 == -1:\n return s2\n if s2 == -1:\n return s1\n return s1 + s2",
"def solve0(i, n, s):\n if s < 0:\n return -1\n if N-i+1 < n:\n return -1\n if n == 0:\n if s == 0:\n return 1\n else:\n return -1\n if i == N:\n return -1\n s1 = solve(i+1, n-1,s-X[i])\n s2 = solve(i+1, n, s)\n if s1 == -1 and s2 == -1:\n return -1\n if s1 == -1:\n return s2\n if s2 == -1:\n return s1\n return s1 + s2",
"solve0",
"def solve(i, n, s):\n key = (i, n, s)\n a = cache.get(key, None)\n if a is None:\n a = solve0(i, n, s)\n cache[key] = a\n return a",
"def solve(i, n, s):\n key = (i, n, s)\n a = cache.get(key, None)\n if a is None:\n a = solve0(i, n, s)\n cache[key] = a\n return a",
"solve"
] | from functools import lru_cache
N, A = map(int, input().split())
X = [int(x) for x in input().split()]
#with open("9", "w") as f:
# print(50, 1, file=f)
# print(*([1]*50), file=f)
assert len(X) == N
def solve0(i, n, s):
if s < 0:
return -1
if N-i+1 < n:
return -1
if n == 0:
if s == 0:
return 1
else:
return -1
if i == N:
return -1
s1 = solve(i+1, n-1,s-X[i])
s2 = solve(i+1, n, s)
if s1 == -1 and s2 == -1:
return -1
if s1 == -1:
return s2
if s2 == -1:
return s1
return s1 + s2
cache = {}
def solve(i, n, s):
key = (i, n, s)
a = cache.get(key, None)
if a is None:
a = solve0(i, n, s)
cache[key] = a
return a
answer = 0
for n in range(1, N+1):
s = solve(0, n, n*A)
if s != -1:
answer += s
print(answer) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
12,
2,
4,
13,
13,
13,
23,
4,
18,
4,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
21,
13,
10,
4,
13,
10,
4,
13
] | [
[
81,
2
],
[
81,
11
],
[
72,
13
],
[
82,
23
],
[
75,
31
],
[
38,
37
],
[
73,
37
],
[
76,
46
],
[
54,
49
],
[
76,
50
],
[
37,
53
],
[
76,
57
],
[
37,
61
],
[
76,
68
],
[
72,
73
],
[
75,
76
],
[
81,
79
],
[
81,
82
]
] | [
"N,A = map(int,input().split())\nY = list(map(lambda x:int(x)-A,input().split()))\ndp = {0:1}\n\nfor y in Y:\n\tfor k,v in list(dp.items()):\n\t\tdp[k+y]=dp.get(k+y,0)+v\n\nprint(dp[0]-1)",
"N,A = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"Y = list(map(lambda x:int(x)-A,input().split()))",
"Y",
"list(map(lambda x:int(x)-A,input().split()))",
"list",
"map(lambda x:int(x)-A,input().split())",
"map",
"lambda x:int(x)-A",
"int(x)-A",
"int(x)",
"int",
"x",
"A",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"dp = {0:1}",
"dp",
"{0:1}",
"0",
"0",
"1",
"for y in Y:\n\tfor k,v in list(dp.items()):\n\t\tdp[k+y]=dp.get(k+y,0)+v",
"y",
"Y",
"for k,v in list(dp.items()):\n\t\tdp[k+y]=dp.get(k+y,0)+v",
"k",
"v",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"dp[k+y]=dp.get(k+y,0)+v",
"dp[k+y]",
"dp",
"k+y",
"k",
"y",
"dp.get(k+y,0)+v",
"dp.get(k+y,0)",
"dp.get",
"dp",
"get",
"k+y",
"k",
"y",
"0",
"v",
"print(dp[0]-1)",
"print",
"dp[0]-1",
"dp[0]",
"dp",
"0",
"1",
"Y = list(map(lambda x:int(x)-A,input().split()))",
"list(map(lambda x:int(x)-A,input().split()))",
"Y",
"dp = {0:1}",
"{0:1}",
"dp",
"N,A = map(int,input().split())",
"map(int,input().split())",
"N",
"A = map(int,input().split())",
"map(int,input().split())",
"A"
] | N,A = map(int,input().split())
Y = list(map(lambda x:int(x)-A,input().split()))
dp = {0:1}
for y in Y:
for k,v in list(dp.items()):
dp[k+y]=dp.get(k+y,0)+v
print(dp[0]-1)
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
0,
18,
13,
17,
17,
28,
13,
13,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
84,
3
],
[
84,
12
],
[
72,
14
],
[
28,
27
],
[
73,
27
],
[
27,
31
],
[
79,
32
],
[
75,
34
],
[
81,
37
],
[
44,
41
],
[
82,
42
],
[
47,
46
],
[
76,
46
],
[
82,
55
],
[
63,
58
],
[
82,
59
],
[
46,
62
],
[
82,
68
],
[
72,
73
],
[
75,
76
],
[
84,
79
],
[
81,
82
],
[
84,
85
]
] | [
"from collections import Counter\n\n\nN, A = map(int, input().split())\nX = list(map(int, input().split()))\nY = [x - A for x in X]\nL = Counter()\nL[0] = 1\n\nfor y in Y:\n for key, value in list(L.items()):\n L[key + y] += value\n\nprint(L[0] - 1)",
"from collections import Counter",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x - A for x in X",
"for x in X",
"x",
"X",
"for x in X",
"x - A",
"x",
"A",
"Y = [x - A for x in X]",
"Y",
"[x - A for x in X]",
"L = Counter()",
"L",
"Counter()",
"Counter",
"L[0] = 1",
"L[0]",
"L",
"0",
"1",
"for y in Y:\n for key, value in list(L.items()):\n L[key + y] += value",
"y",
"Y",
"for key, value in list(L.items()):\n L[key + y] += value",
"key",
"value",
"list(L.items())",
"list",
"L.items()",
"L.items",
"L",
"items",
"L[key + y] += value",
"L[key + y]",
"L",
"key + y",
"key",
"y",
"value",
"print(L[0] - 1)",
"print",
"L[0] - 1",
"L[0]",
"L",
"0",
"1",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"Y = [x - A for x in X]",
"[x - A for x in X]",
"Y",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"L = Counter()",
"Counter()",
"L",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N"
] | from collections import Counter
N, A = map(int, input().split())
X = list(map(int, input().split()))
Y = [x - A for x in X]
L = Counter()
L[0] = 1
for y in Y:
for key, value in list(L.items()):
L[key + y] += value
print(L[0] - 1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
2,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
2,
2,
17,
13,
17,
17,
14,
2,
40,
17,
2,
13,
18,
13,
2,
13,
17,
2,
2,
17,
13,
17,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
4,
13,
2,
18,
18,
13,
13,
2,
13,
17,
17,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
152,
2
],
[
152,
11
],
[
143,
13
],
[
26,
25
],
[
150,
28
],
[
33,
30
],
[
144,
31
],
[
25,
32
],
[
153,
33
],
[
37,
36
],
[
150,
40
],
[
146,
45
],
[
55,
48
],
[
147,
50
],
[
150,
53
],
[
58,
57
],
[
150,
62
],
[
66,
65
],
[
150,
72
],
[
65,
80
],
[
144,
82
],
[
57,
84
],
[
150,
89
],
[
97,
92
],
[
147,
94
],
[
57,
95
],
[
65,
96
],
[
147,
100
],
[
57,
102
],
[
65,
104
],
[
147,
107
],
[
57,
109
],
[
65,
112
],
[
144,
114
],
[
57,
116
],
[
124,
119
],
[
147,
121
],
[
57,
122
],
[
65,
123
],
[
147,
126
],
[
57,
128
],
[
65,
130
],
[
147,
136
],
[
150,
137
],
[
150,
139
],
[
143,
144
],
[
146,
147
],
[
152,
150
],
[
152,
153
]
] | [
"n,a = map(int,input().split())\nx = list(map(int,input().split()))\nfor i in range(n):\n x[i] -= a\ndp = [[0 for i in range(2*n*50+1)] for j in range(n+1)]\ndp [0][n*50] = 1\n\nfor i in range(1,n+1):\n for j in range(2*n*50+1):\n if 0 <= j - x[i-1] < 2*n*50:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i-1]]\n else:\n dp[i][j] = dp[i-1][j]\n #print(dp[i])\nprint(dp[n][n*50] - 1) #全て選ばないを除く\n\n# 4 8\n# 7 9 8 9 のとき\n# i = 1 で -1 0 が 1\n# i = 2 で -1 1 が 1, 0 が2\n# i = 3 で -1 1 が 2, 0 が4\n# i = 4 で -1 2 が 2, 0 1 が 6",
"n,a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n):\n x[i] -= a",
"i",
"range(n)",
"range",
"n",
"x[i] -= a",
"x[i]",
"x",
"i",
"a",
"[0 for i in range(2*n*50+1)] for j in range(n+1)",
"for j in range(n+1)",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for j in range(n+1)",
"[0 for i in range(2*n*50+1)]",
"dp = [[0 for i in range(2*n*50+1)] for j in range(n+1)]",
"dp",
"[[0 for i in range(2*n*50+1)] for j in range(n+1)]",
"dp [0][n*50] = 1",
"dp [0][n*50]",
"[0]",
"dp",
"0",
"n*50",
"n",
"50",
"1",
"for i in range(1,n+1):\n for j in range(2*n*50+1):\n if 0 <= j - x[i-1] < 2*n*50:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i-1]]\n else:\n dp[i][j] = dp[i-1][j]\n #print(dp[i])",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for j in range(2*n*50+1):\n if 0 <= j - x[i-1] < 2*n*50:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i-1]]\n else:\n dp[i][j] = dp[i-1][j]\n #print(dp[i])",
"j",
"range(2*n*50+1)",
"range",
"2*n*50+1",
"2*n*50",
"2*n",
"2",
"n",
"50",
"1",
"if 0 <= j - x[i-1] < 2*n*50:\n dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i-1]]\n else:\n dp[i][j] = dp[i-1][j]\n #print(dp[i])",
"0 <= j - x[i-1] < 2*n*50",
"0 <= j - x[i-1]",
"0",
"j - x[i-1]",
"j",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"2*n*50",
"2*n",
"2",
"n",
"50",
"dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i-1]]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j] + dp[i-1][j-x[i-1]]",
"dp[i-1][j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"dp[i-1][j-x[i-1]]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-x[i-1]",
"j",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"dp[i][j] = dp[i-1][j]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"print(dp[n][n*50] - 1)",
"print",
"dp[n][n*50] - 1",
"dp[n][n*50]",
"[n]",
"dp",
"n",
"n*50",
"n",
"50",
"1",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"dp = [[0 for i in range(2*n*50+1)] for j in range(n+1)]",
"[[0 for i in range(2*n*50+1)] for j in range(n+1)]",
"dp",
"n,a = map(int,input().split())",
"map(int,input().split())",
"n",
"a = map(int,input().split())",
"map(int,input().split())",
"a"
] | n,a = map(int,input().split())
x = list(map(int,input().split()))
for i in range(n):
x[i] -= a
dp = [[0 for i in range(2*n*50+1)] for j in range(n+1)]
dp [0][n*50] = 1
for i in range(1,n+1):
for j in range(2*n*50+1):
if 0 <= j - x[i-1] < 2*n*50:
dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i-1]]
else:
dp[i][j] = dp[i-1][j]
#print(dp[i])
print(dp[n][n*50] - 1) #全て選ばないを除く
# 4 8
# 7 9 8 9 のとき
# i = 1 で -1 0 が 1
# i = 2 で -1 1 が 1, 0 が2
# i = 3 で -1 1 が 2, 0 が4
# i = 4 で -1 2 が 2, 0 1 が 6 |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
13,
39,
13,
0,
13,
4,
13,
13,
0,
13,
2,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
14,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
157,
2
],
[
157,
11
],
[
154,
13
],
[
172,
25
],
[
155,
27
],
[
169,
31
],
[
173,
34
],
[
160,
36
],
[
152,
38
],
[
170,
39
],
[
43,
42
],
[
152,
46
],
[
163,
51
],
[
61,
54
],
[
164,
57
],
[
175,
63
],
[
67,
66
],
[
152,
69
],
[
72,
71
],
[
152,
74
],
[
77,
76
],
[
161,
79
],
[
164,
84
],
[
66,
85
],
[
71,
86
],
[
76,
87
],
[
98,
89
],
[
164,
92
],
[
66,
94
],
[
71,
96
],
[
76,
97
],
[
164,
101
],
[
66,
102
],
[
71,
103
],
[
76,
104
],
[
121,
106
],
[
164,
109
],
[
66,
111
],
[
71,
114
],
[
76,
117
],
[
155,
119
],
[
66,
120
],
[
164,
124
],
[
66,
125
],
[
71,
126
],
[
76,
127
],
[
130,
129
],
[
152,
134
],
[
166,
137
],
[
164,
141
],
[
152,
142
],
[
129,
143
],
[
129,
145
],
[
158,
146
],
[
167,
149
],
[
176,
149
],
[
157,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
]
] | [
"N,A = map(int,input().split())\nx = list(map(int,input().split()))\n\ntemp = x + [A]\n\nX = max(temp)\n\nm = N * X\n\ndp = [[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)]\n\ndp[0][0][0] = 1\n\nres = 0\n\nfor j in range(N):\n for k in range(N):\n for s in range(m):\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]\n\nfor k in range(1,N+1):\n res += dp[N][k][k*A]\n\nprint(res)",
"N,A = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"temp = x + [A]",
"temp",
"x + [A]",
"x",
"[A]",
"A",
"X = max(temp)",
"X",
"max(temp)",
"max",
"temp",
"m = N * X",
"m",
"N * X",
"N",
"X",
"[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)",
"for j in range(N+1)",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for j in range(N+1)",
"[[0 for s in range(m+1)] for k in range(N+1)]",
"dp = [[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)]",
"dp",
"[[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"res = 0",
"res",
"0",
"for j in range(N):\n for k in range(N):\n for s in range(m):\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"j",
"range(N)",
"range",
"N",
"for k in range(N):\n for s in range(m):\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"k",
"range(N)",
"range",
"N",
"for s in range(m):\n if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"s",
"range(m)",
"range",
"m",
"if dp[j][k][s]:\n dp[j+1][k][s] += dp[j][k][s]\n dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j+1][k][s] += dp[j][k][s]",
"dp[j+1][k][s]",
"[k]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"k",
"s",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j+1][k+1][s+x[j]] += dp[j][k][s]",
"dp[j+1][k+1][s+x[j]]",
"[k+1]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"k+1",
"k",
"1",
"s+x[j]",
"s",
"x[j]",
"x",
"j",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"for k in range(1,N+1):\n res += dp[N][k][k*A]",
"k",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"res += dp[N][k][k*A]",
"res",
"dp[N][k][k*A]",
"[k]",
"[N]",
"dp",
"N",
"k",
"k*A",
"k",
"A",
"print(res)",
"print",
"res",
"N,A = map(int,input().split())",
"map(int,input().split())",
"N",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"A = map(int,input().split())",
"map(int,input().split())",
"A",
"m = N * X",
"N * X",
"m",
"dp = [[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)]",
"[[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)]",
"dp",
"res += dp[N][k][k*A]",
"dp[N][k][k*A]",
"res",
"X = max(temp)",
"max(temp)",
"X",
"temp = x + [A]",
"x + [A]",
"temp",
"res = 0",
"0",
"res"
] | N,A = map(int,input().split())
x = list(map(int,input().split()))
temp = x + [A]
X = max(temp)
m = N * X
dp = [[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)]
dp[0][0][0] = 1
res = 0
for j in range(N):
for k in range(N):
for s in range(m):
if dp[j][k][s]:
dp[j+1][k][s] += dp[j][k][s]
dp[j+1][k+1][s+x[j]] += dp[j][k][s]
for k in range(1,N+1):
res += dp[N][k][k*A]
print(res)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
12,
2,
4,
13,
13,
13,
23,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
17,
0,
18,
13,
17,
17,
28,
13,
13,
0,
13,
4,
18,
13,
13,
28,
13,
4,
13,
17,
17,
14,
18,
13,
13,
0,
18,
13,
2,
13,
13,
18,
13,
13,
0,
13,
4,
18,
13,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
86,
2
],
[
86,
11
],
[
95,
13
],
[
87,
23
],
[
92,
31
],
[
40,
37
],
[
93,
38
],
[
43,
42
],
[
96,
42
],
[
98,
45
],
[
93,
48
],
[
90,
48
],
[
52,
51
],
[
93,
58
],
[
90,
58
],
[
51,
59
],
[
66,
61
],
[
99,
62
],
[
42,
64
],
[
51,
65
],
[
93,
67
],
[
90,
67
],
[
51,
68
],
[
89,
70
],
[
99,
73
],
[
90,
79
],
[
93,
79
],
[
86,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
]
] | [
"N,A=map(int, input().split())\nx=tuple(map(lambda i:int(i)-A,input().split()))\nl=[0]*5001\nl[0]=1\nfor i in x:\n f=l.copy()\n for j in range(-2500,2501):\n if l[j]:\n f[i+j]+=l[j]\n l=f.copy()\nprint(l[0]-1)",
"N,A=map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x=tuple(map(lambda i:int(i)-A,input().split()))",
"x",
"tuple(map(lambda i:int(i)-A,input().split()))",
"tuple",
"map(lambda i:int(i)-A,input().split())",
"map",
"lambda i:int(i)-A",
"int(i)-A",
"int(i)",
"int",
"i",
"A",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"l=[0]*5001",
"l",
"[0]*5001",
"[0]",
"0",
"5001",
"l[0]=1",
"l[0]",
"l",
"0",
"1",
"for i in x:\n f=l.copy()\n for j in range(-2500,2501):\n if l[j]:\n f[i+j]+=l[j]\n l=f.copy()",
"i",
"x",
"f=l.copy()",
"f",
"l.copy()",
"l.copy",
"l",
"copy",
"for j in range(-2500,2501):\n if l[j]:\n f[i+j]+=l[j]\n ",
"j",
"range(-2500,2501)",
"range",
"-2500",
"2501",
"if l[j]:\n f[i+j]+=l[j]\n ",
"l[j]",
"l",
"j",
"f[i+j]+=l[j]",
"f[i+j]",
"f",
"i+j",
"i",
"j",
"l[j]",
"l",
"j",
"l=f.copy()",
"l",
"f.copy()",
"f.copy",
"f",
"copy",
"print(l[0]-1)",
"print",
"l[0]-1",
"l[0]",
"l",
"0",
"1",
"N,A=map(int, input().split())",
"map(int, input().split())",
"N",
"A=map(int, input().split())",
"map(int, input().split())",
"A",
"l=f.copy()",
"f.copy()",
"l",
"l=[0]*5001",
"[0]*5001",
"l",
"x=tuple(map(lambda i:int(i)-A,input().split()))",
"tuple(map(lambda i:int(i)-A,input().split()))",
"x",
"f=l.copy()",
"l.copy()",
"f"
] | N,A=map(int, input().split())
x=tuple(map(lambda i:int(i)-A,input().split()))
l=[0]*5001
l[0]=1
for i in x:
f=l.copy()
for j in range(-2500,2501):
if l[j]:
f[i+j]+=l[j]
l=f.copy()
print(l[0]-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
13,
17,
14,
2,
18,
13,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
13,
2,
13,
17,
13,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
13,
2,
13,
17,
13,
18,
18,
18,
13,
2,
13,
18,
13,
13,
2,
13,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
2,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
169,
2
],
[
169,
11
],
[
151,
13
],
[
27,
26
],
[
157,
33
],
[
43,
36
],
[
158,
39
],
[
46,
45
],
[
51,
50
],
[
161,
55
],
[
59,
58
],
[
50,
62
],
[
163,
65
],
[
50,
67
],
[
152,
72
],
[
164,
73
],
[
45,
74
],
[
83,
76
],
[
158,
79
],
[
45,
80
],
[
50,
81
],
[
58,
82
],
[
158,
86
],
[
45,
87
],
[
50,
89
],
[
58,
91
],
[
100,
93
],
[
158,
96
],
[
45,
97
],
[
50,
98
],
[
58,
99
],
[
158,
104
],
[
45,
105
],
[
50,
107
],
[
58,
109
],
[
158,
113
],
[
45,
115
],
[
152,
117
],
[
164,
118
],
[
50,
120
],
[
58,
123
],
[
166,
126
],
[
130,
129
],
[
161,
134
],
[
154,
137
],
[
158,
141
],
[
129,
143
],
[
170,
144
],
[
161,
145
],
[
129,
146
],
[
155,
149
],
[
167,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
169,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\ndp = [[[0 for k in range(n+1)] for j in range(n+1)] for s in range(2501)]\n\n\ndp[0][0][0] = 1\nfor s in range(2501):\n for j in range(1, n+1):\n for k in range(j+1):\n idx = j-1\n if x[idx] > s:\n dp[s][j][k] = dp[s][j-1][k]\n else:\n dp[s][j][k] = dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]\n\nans = 0\nfor k in range(1, n+1):\n ans += dp[k*a][n][k]\n\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0 for k in range(n+1)] for j in range(n+1)] for s in range(2501)",
"for s in range(2501)",
"s",
"range(2501)",
"range",
"2501",
"for s in range(2501)",
"[[0 for k in range(n+1)] for j in range(n+1)]",
"dp = [[[0 for k in range(n+1)] for j in range(n+1)] for s in range(2501)]",
"dp",
"[[[0 for k in range(n+1)] for j in range(n+1)] for s in range(2501)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for s in range(2501):\n for j in range(1, n+1):\n for k in range(j+1):\n idx = j-1\n if x[idx] > s:\n dp[s][j][k] = dp[s][j-1][k]\n else:\n dp[s][j][k] = dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]",
"s",
"range(2501)",
"range",
"2501",
"for j in range(1, n+1):\n for k in range(j+1):\n idx = j-1\n if x[idx] > s:\n dp[s][j][k] = dp[s][j-1][k]\n else:\n dp[s][j][k] = dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]",
"j",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for k in range(j+1):\n idx = j-1\n if x[idx] > s:\n dp[s][j][k] = dp[s][j-1][k]\n else:\n dp[s][j][k] = dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]",
"k",
"range(j+1)",
"range",
"j+1",
"j",
"1",
"idx = j-1",
"idx",
"j-1",
"j",
"1",
"if x[idx] > s:\n dp[s][j][k] = dp[s][j-1][k]\n else:\n dp[s][j][k] = dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]",
"x[idx] > s",
"x[idx]",
"x",
"idx",
"s",
"dp[s][j][k] = dp[s][j-1][k]",
"dp[s][j][k]",
"[j]",
"[s]",
"dp",
"s",
"j",
"k",
"dp[s][j-1][k]",
"[j-1]",
"[s]",
"dp",
"s",
"j-1",
"j",
"1",
"k",
"dp[s][j][k] = dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]",
"dp[s][j][k]",
"[j]",
"[s]",
"dp",
"s",
"j",
"k",
"dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]",
"dp[s][j-1][k]",
"[j-1]",
"[s]",
"dp",
"s",
"j-1",
"j",
"1",
"k",
"dp[s-x[idx]][j-1][k-1]",
"[j-1]",
"[s-x[idx]]",
"dp",
"s-x[idx]",
"s",
"x[idx]",
"x",
"idx",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"ans = 0",
"ans",
"0",
"for k in range(1, n+1):\n ans += dp[k*a][n][k]",
"k",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[k*a][n][k]",
"ans",
"dp[k*a][n][k]",
"[n]",
"[k*a]",
"dp",
"k*a",
"k",
"a",
"n",
"k",
"print(ans)",
"print",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"ans += dp[k*a][n][k]",
"dp[k*a][n][k]",
"ans",
"dp = [[[0 for k in range(n+1)] for j in range(n+1)] for s in range(2501)]",
"[[[0 for k in range(n+1)] for j in range(n+1)] for s in range(2501)]",
"dp",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"idx = j-1",
"j-1",
"idx",
"ans = 0",
"0",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
dp = [[[0 for k in range(n+1)] for j in range(n+1)] for s in range(2501)]
dp[0][0][0] = 1
for s in range(2501):
for j in range(1, n+1):
for k in range(j+1):
idx = j-1
if x[idx] > s:
dp[s][j][k] = dp[s][j-1][k]
else:
dp[s][j][k] = dp[s][j-1][k] + dp[s-x[idx]][j-1][k-1]
ans = 0
for k in range(1, n+1):
ans += dp[k*a][n][k]
print(ans) |
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
2,
4,
13,
13,
13,
0,
13,
13,
0,
13,
4,
13,
2,
13,
39,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
2,
2,
2,
17,
13,
13,
17,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
17,
13,
13,
14,
2,
2,
13,
17,
2,
13,
2,
13,
13,
0,
18,
18,
13,
13,
13,
17,
14,
2,
2,
2,
13,
18,
13,
2,
13,
17,
17,
2,
2,
13,
18,
13,
2,
13,
17,
2,
2,
17,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
14,
2,
2,
17,
2,
13,
18,
13,
2,
13,
17,
2,
2,
13,
18,
13,
2,
13,
17,
2,
2,
17,
13,
13,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
13,
13,
13,
17,
4,
13,
2,
18,
18,
13,
13,
2,
13,
13,
17,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
12
],
[
213,
14
],
[
213,
16
],
[
20,
19
],
[
19,
29
],
[
211,
30
],
[
216,
32
],
[
204,
35
],
[
217,
39
],
[
45,
44
],
[
214,
48
],
[
214,
58
],
[
205,
59
],
[
207,
62
],
[
66,
65
],
[
214,
69
],
[
73,
72
],
[
214,
78
],
[
205,
79
],
[
65,
83
],
[
72,
86
],
[
214,
88
],
[
205,
89
],
[
96,
91
],
[
208,
93
],
[
65,
94
],
[
72,
95
],
[
72,
101
],
[
217,
103
],
[
65,
105
],
[
72,
110
],
[
217,
112
],
[
65,
114
],
[
214,
119
],
[
205,
120
],
[
127,
122
],
[
208,
124
],
[
65,
125
],
[
72,
126
],
[
208,
129
],
[
65,
131
],
[
72,
133
],
[
72,
139
],
[
217,
141
],
[
65,
143
],
[
72,
147
],
[
217,
149
],
[
65,
151
],
[
214,
156
],
[
205,
157
],
[
164,
159
],
[
208,
161
],
[
65,
162
],
[
72,
163
],
[
208,
167
],
[
65,
169
],
[
72,
171
],
[
208,
174
],
[
65,
176
],
[
72,
179
],
[
217,
181
],
[
65,
183
],
[
191,
186
],
[
208,
188
],
[
65,
189
],
[
72,
190
],
[
208,
197
],
[
214,
198
],
[
214,
200
],
[
205,
201
],
[
204,
205
],
[
207,
208
],
[
213,
211
],
[
213,
214
],
[
216,
217
]
] | [
"N, A = [int(x_i) for x_i in input().split()]\nx = [int(x_i) - A for x_i in input().split()]\n\nX = max(x + [A])\n\ndp=[[0] * (2*N*X + 1) for _ in range(N + 1)]\n\nfor j in range(N+1):\n for t in range(2*N*X):\n if j==0 and t==N*X:\n dp[j][t] = 1\n elif t-x[j-1] < 0 or t-x[j-1] > 2*N*X:\n dp[j][t] = dp[j-1][t]\n elif 0 < t-x[j-1] and t-x[j-1] < 2*N*X:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = 0\n\nprint(dp[N][N*X]-1)",
"int(x_i) for x_i in input().split()",
"for x_i in input().split()",
"x_i",
"input().split()",
"().split",
"()",
"input",
"split",
"for x_i in input().split()",
"int(x_i)",
"int",
"x_i",
"N, A = [int(x_i) for x_i in input().split()]",
"N",
"[int(x_i) for x_i in input().split()]",
"A",
"int(x_i) - A for x_i in input().split()",
"for x_i in input().split()",
"x_i",
"input().split()",
"().split",
"()",
"input",
"split",
"for x_i in input().split()",
"int(x_i) - A",
"int(x_i)",
"int",
"x_i",
"A",
"x = [int(x_i) - A for x_i in input().split()]",
"x",
"[int(x_i) - A for x_i in input().split()]",
"X = max(x + [A])",
"X",
"max(x + [A])",
"max",
"x + [A]",
"x",
"[A]",
"A",
"[0] * (2*N*X + 1) for _ in range(N + 1)",
"for _ in range(N + 1)",
"_",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for _ in range(N + 1)",
"[0] * (2*N*X + 1)",
"[0]",
"0",
"2*N*X + 1",
"2*N*X",
"2*N",
"2",
"N",
"X",
"1",
"dp=[[0] * (2*N*X + 1) for _ in range(N + 1)]",
"dp",
"[[0] * (2*N*X + 1) for _ in range(N + 1)]",
"for j in range(N+1):\n for t in range(2*N*X):\n if j==0 and t==N*X:\n dp[j][t] = 1\n elif t-x[j-1] < 0 or t-x[j-1] > 2*N*X:\n dp[j][t] = dp[j-1][t]\n elif 0 < t-x[j-1] and t-x[j-1] < 2*N*X:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = 0",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for t in range(2*N*X):\n if j==0 and t==N*X:\n dp[j][t] = 1\n elif t-x[j-1] < 0 or t-x[j-1] > 2*N*X:\n dp[j][t] = dp[j-1][t]\n elif 0 < t-x[j-1] and t-x[j-1] < 2*N*X:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = 0",
"t",
"range(2*N*X)",
"range",
"2*N*X",
"2*N",
"2",
"N",
"X",
"if j==0 and t==N*X:\n dp[j][t] = 1\n elif t-x[j-1] < 0 or t-x[j-1] > 2*N*X:\n dp[j][t] = dp[j-1][t]\n elif 0 < t-x[j-1] and t-x[j-1] < 2*N*X:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n else:\n dp[j][t] = 0",
"j==0 and t==N*X",
"j==0",
"j",
"0",
"t==N*X",
"t",
"N*X",
"N",
"X",
"dp[j][t] = 1",
"dp[j][t]",
"[j]",
"dp",
"j",
"t",
"1",
"elif t-x[j-1] < 0 or t-x[j-1] > 2*N*X:\n dp[j][t] = dp[j-1][t]\n ",
"t-x[j-1] < 0 or t-x[j-1] > 2*N*X",
"t-x[j-1] < 0",
"t-x[j-1]",
"t",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"0",
"t-x[j-1] > 2*N*X",
"t-x[j-1]",
"t",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"2*N*X",
"2*N",
"2",
"N",
"X",
"dp[j][t] = dp[j-1][t]",
"dp[j][t]",
"[j]",
"dp",
"j",
"t",
"dp[j-1][t]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"t",
"elif 0 < t-x[j-1] and t-x[j-1] < 2*N*X:\n dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]\n ",
"0 < t-x[j-1] and t-x[j-1] < 2*N*X",
"0 < t-x[j-1]",
"0",
"t-x[j-1]",
"t",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"t-x[j-1] < 2*N*X",
"t-x[j-1]",
"t",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"2*N*X",
"2*N",
"2",
"N",
"X",
"dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]",
"dp[j][t]",
"[j]",
"dp",
"j",
"t",
"dp[j-1][t] + dp[j-1][t-x[j-1]]",
"dp[j-1][t]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"t",
"dp[j-1][t-x[j-1]]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"t-x[j-1]",
"t",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"dp[j][t] = 0",
"dp[j][t]",
"[j]",
"dp",
"j",
"t",
"0",
"print(dp[N][N*X]-1)",
"print",
"dp[N][N*X]-1",
"dp[N][N*X]",
"[N]",
"dp",
"N",
"N*X",
"N",
"X",
"1",
"X = max(x + [A])",
"max(x + [A])",
"X",
"dp=[[0] * (2*N*X + 1) for _ in range(N + 1)]",
"[[0] * (2*N*X + 1) for _ in range(N + 1)]",
"dp",
"A = [int(x_i) for x_i in input().split()]",
"[int(x_i) for x_i in input().split()]",
"A",
"N, A = [int(x_i) for x_i in input().split()]",
"[int(x_i) for x_i in input().split()]",
"N",
"x = [int(x_i) - A for x_i in input().split()]",
"[int(x_i) - A for x_i in input().split()]",
"x"
] | N, A = [int(x_i) for x_i in input().split()]
x = [int(x_i) - A for x_i in input().split()]
X = max(x + [A])
dp=[[0] * (2*N*X + 1) for _ in range(N + 1)]
for j in range(N+1):
for t in range(2*N*X):
if j==0 and t==N*X:
dp[j][t] = 1
elif t-x[j-1] < 0 or t-x[j-1] > 2*N*X:
dp[j][t] = dp[j-1][t]
elif 0 < t-x[j-1] and t-x[j-1] < 2*N*X:
dp[j][t] = dp[j-1][t] + dp[j-1][t-x[j-1]]
else:
dp[j][t] = 0
print(dp[N][N*X]-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
40,
13,
17,
2,
18,
13,
2,
13,
17,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
2,
40,
13,
17,
40,
13,
17,
40,
18,
13,
2,
13,
17,
13,
0,
18,
18,
18,
13,
13,
13,
13,
2,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13
] | [
[
184,
2
],
[
184,
11
],
[
190,
13
],
[
187,
25
],
[
185,
27
],
[
179,
28
],
[
32,
31
],
[
185,
35
],
[
196,
40
],
[
50,
43
],
[
197,
46
],
[
53,
52
],
[
185,
56
],
[
60,
59
],
[
185,
63
],
[
67,
66
],
[
188,
70
],
[
52,
75
],
[
191,
79
],
[
52,
81
],
[
66,
83
],
[
92,
85
],
[
197,
88
],
[
52,
89
],
[
59,
90
],
[
66,
91
],
[
197,
95
],
[
52,
97
],
[
59,
99
],
[
66,
100
],
[
52,
105
],
[
59,
108
],
[
191,
112
],
[
52,
114
],
[
66,
116
],
[
125,
118
],
[
197,
121
],
[
52,
122
],
[
59,
123
],
[
66,
124
],
[
197,
129
],
[
52,
131
],
[
59,
133
],
[
66,
134
],
[
197,
138
],
[
52,
140
],
[
59,
143
],
[
66,
146
],
[
191,
148
],
[
52,
150
],
[
193,
153
],
[
157,
156
],
[
185,
161
],
[
181,
164
],
[
197,
168
],
[
185,
169
],
[
156,
170
],
[
156,
172
],
[
179,
173
],
[
182,
176
],
[
194,
176
],
[
184,
179
],
[
181,
182
],
[
184,
185
],
[
187,
188
],
[
190,
191
],
[
193,
194
],
[
196,
197
]
] | [
"N, A = map(int, input().split())\nx = list(map(int, input().split()))\n\nmax_of_a = N * A\n\n# dp[i][j][k] := i枚目までからj枚取って、合計をkにする通り数\ndp = [[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)]\ndp[0][0][0] = 1\n\n\nfor i in range(N+1):\n for j in range(N+1):\n for k in range(max_of_a + 1):\n if i >= 1 and x[i-1] > k:\n dp[i][j][k] = dp[i-1][j][k]\n elif i >= 1 and j >= 1 and x[i-1] <= k:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]\n\nans = 0\nfor j in range(1, N+1):\n # N枚(カード総数)の中から1枚以上取った時の、j枚取って合計がj*Aの所 の合計\n ans += dp[N][j][j*A]\nprint(ans)",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"max_of_a = N * A",
"max_of_a",
"N * A",
"N",
"A",
"[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[[0] * (max_of_a + 1) for _ in range(N+1)]",
"dp = [[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)]",
"dp",
"[[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(N+1):\n for j in range(N+1):\n for k in range(max_of_a + 1):\n if i >= 1 and x[i-1] > k:\n dp[i][j][k] = dp[i-1][j][k]\n elif i >= 1 and j >= 1 and x[i-1] <= k:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for j in range(N+1):\n for k in range(max_of_a + 1):\n if i >= 1 and x[i-1] > k:\n dp[i][j][k] = dp[i-1][j][k]\n elif i >= 1 and j >= 1 and x[i-1] <= k:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for k in range(max_of_a + 1):\n if i >= 1 and x[i-1] > k:\n dp[i][j][k] = dp[i-1][j][k]\n elif i >= 1 and j >= 1 and x[i-1] <= k:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]",
"k",
"range(max_of_a + 1)",
"range",
"max_of_a + 1",
"max_of_a",
"1",
"if i >= 1 and x[i-1] > k:\n dp[i][j][k] = dp[i-1][j][k]\n elif i >= 1 and j >= 1 and x[i-1] <= k:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]",
"i >= 1 and x[i-1] > k",
"i >= 1",
"i",
"1",
"x[i-1] > k",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"k",
"dp[i][j][k] = dp[i-1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"elif i >= 1 and j >= 1 and x[i-1] <= k:\n dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]",
"i >= 1 and j >= 1 and x[i-1] <= k",
"i >= 1 and j >= 1",
"i >= 1",
"i",
"1",
"j >= 1",
"j",
"1",
"x[i-1] <= k",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"k",
"dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"dp[i-1][j-1][k - x[i-1]]",
"[j-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"k - x[i-1]",
"k",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"ans = 0",
"ans",
"0",
"for j in range(1, N+1):\n # N枚(カード総数)の中から1枚以上取った時の、j枚取って合計がj*Aの所 の合計\n ans += dp[N][j][j*A]",
"j",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[N][j][j*A]",
"ans",
"dp[N][j][j*A]",
"[j]",
"[N]",
"dp",
"N",
"j",
"j*A",
"j",
"A",
"print(ans)",
"print",
"ans",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"ans += dp[N][j][j*A]",
"dp[N][j][j*A]",
"ans",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"max_of_a = N * A",
"N * A",
"max_of_a",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"ans = 0",
"0",
"ans",
"dp = [[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)]",
"[[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)]",
"dp"
] | N, A = map(int, input().split())
x = list(map(int, input().split()))
max_of_a = N * A
# dp[i][j][k] := i枚目までからj枚取って、合計をkにする通り数
dp = [[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N+1):
for j in range(N+1):
for k in range(max_of_a + 1):
if i >= 1 and x[i-1] > k:
dp[i][j][k] = dp[i-1][j][k]
elif i >= 1 and j >= 1 and x[i-1] <= k:
dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]
ans = 0
for j in range(1, N+1):
# N枚(カード総数)の中から1枚以上取った時の、j枚取って合計がj*Aの所 の合計
ans += dp[N][j][j*A]
print(ans) |
[
7,
15,
13,
15,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
28,
13,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
13,
4,
13,
2,
18,
13,
17,
17,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
21,
13,
10,
4,
13,
10,
4,
13
] | [
[
111,
6
],
[
114,
15
],
[
123,
24
],
[
135,
33
],
[
115,
40
],
[
135,
42
],
[
126,
44
],
[
115,
53
],
[
58,
57
],
[
127,
57
],
[
57,
61
],
[
118,
62
],
[
120,
64
],
[
129,
67
],
[
74,
73
],
[
121,
73
],
[
132,
76
],
[
130,
81
],
[
93,
88
],
[
130,
89
],
[
73,
92
],
[
130,
96
],
[
73,
100
],
[
130,
107
],
[
111,
112
],
[
114,
115
],
[
135,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
]
] | [
"# -*- coding: utf-8 -*-\nimport sys \nimport numpy as np\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nN, A = map(int, readline().split())\nX = list(map(int,readline().split()))\nY = [x-A for x in X]\ndp = {0:1}\n\nfor y in Y:\n tmp = list(dp.items())\n for k,v in tmp:\n dp[k+y] = dp.get(k+y,0) + v\nprint(dp[0]-1) ",
"import sys",
"sys",
"import numpy as np",
"numpy",
"read = sys.stdin.buffer.read",
"read",
"sys.stdin.buffer.read",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"read",
"readline = sys.stdin.buffer.readline",
"readline",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"readlines = sys.stdin.buffer.readlines",
"readlines",
"sys.stdin.buffer.readlines",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readlines",
"N, A = map(int, readline().split())",
"N",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"A",
"X = list(map(int,readline().split()))",
"X",
"list(map(int,readline().split()))",
"list",
"map(int,readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"x-A for x in X",
"for x in X",
"x",
"X",
"for x in X",
"x-A",
"x",
"A",
"Y = [x-A for x in X]",
"Y",
"[x-A for x in X]",
"dp = {0:1}",
"dp",
"{0:1}",
"0",
"0",
"1",
"for y in Y:\n tmp = list(dp.items())\n for k,v in tmp:\n dp[k+y] = dp.get(k+y,0) + v",
"y",
"Y",
"tmp = list(dp.items())",
"tmp",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"for k,v in tmp:\n dp[k+y] = dp.get(k+y,0) + v",
"k",
"v",
"tmp",
"dp[k+y] = dp.get(k+y,0) + v",
"dp[k+y]",
"dp",
"k+y",
"k",
"y",
"dp.get(k+y,0) + v",
"dp.get(k+y,0)",
"dp.get",
"dp",
"get",
"k+y",
"k",
"y",
"0",
"v",
"print(dp[0]-1)",
"print",
"dp[0]-1",
"dp[0]",
"dp",
"0",
"1",
"read = sys.stdin.buffer.read",
"sys.stdin.buffer.read",
"read",
"readline = sys.stdin.buffer.readline",
"sys.stdin.buffer.readline",
"readline",
"A = map(int, readline().split())",
"map(int, readline().split())",
"A",
"Y = [x-A for x in X]",
"[x-A for x in X]",
"Y",
"readlines = sys.stdin.buffer.readlines",
"sys.stdin.buffer.readlines",
"readlines",
"X = list(map(int,readline().split()))",
"list(map(int,readline().split()))",
"X",
"dp = {0:1}",
"{0:1}",
"dp",
"tmp = list(dp.items())",
"list(dp.items())",
"tmp",
"N, A = map(int, readline().split())",
"map(int, readline().split())",
"N"
] | # -*- coding: utf-8 -*-
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, A = map(int, readline().split())
X = list(map(int,readline().split()))
Y = [x-A for x in X]
dp = {0:1}
for y in Y:
tmp = list(dp.items())
for k,v in tmp:
dp[k+y] = dp.get(k+y,0) + v
print(dp[0]-1) |
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
39,
13,
2,
13,
17,
0,
13,
18,
13,
13,
28,
13,
4,
13,
13,
28,
13,
18,
4,
13,
13,
39,
17,
0,
18,
18,
13,
2,
13,
17,
39,
18,
13,
13,
18,
18,
13,
13,
39,
40,
18,
13,
13,
0,
18,
18,
13,
17,
18,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
40,
2,
2,
13,
17,
13,
13,
0,
13,
18,
18,
13,
13,
2,
2,
13,
17,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
136,
4
],
[
136,
13
],
[
139,
15
],
[
124,
28
],
[
140,
31
],
[
130,
33
],
[
125,
41
],
[
45,
44
],
[
50,
49
],
[
134,
52
],
[
55,
54
],
[
49,
58
],
[
72,
62
],
[
131,
64
],
[
54,
66
],
[
140,
70
],
[
49,
71
],
[
131,
74
],
[
54,
75
],
[
140,
79
],
[
49,
80
],
[
89,
82
],
[
131,
84
],
[
140,
87
],
[
49,
88
],
[
121,
91
],
[
95,
94
],
[
134,
97
],
[
94,
102
],
[
137,
104
],
[
125,
105
],
[
127,
107
],
[
131,
110
],
[
94,
111
],
[
94,
114
],
[
137,
116
],
[
128,
119
],
[
122,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
136,
134
],
[
136,
137
],
[
139,
140
]
] | [
"import numpy as np\nn,a = map(int,input().split())\nx = list(map(int,input().split()))\n\"\"\"\n平均がa <=> 集合をlとして, len(l)a = sum(l)\ndp[i][j][k] := i番目までのカードを選んだとき, 選んだ枚数がkでの総和がちょうどjになる場合の数.\nこれだとメモリが足りないので, iを省略する.\n\"\"\"\nsumx = sum(x)\ndp = np.zeros((n, sumx+1), dtype=np.int64)\nfor i in range(n):\n\tfor j in range(i)[::-1]:\n\t\tdp[j+1][x[i]:] += dp[j][:-x[i]]\n\tdp[0][x[i]] += 1\nans = 0\nfor i in range(n):\n\tif (i+1)*a <= sumx:\n\t\tans += dp[i][(i+1)*a]\nprint(ans)",
"import numpy as np",
"numpy",
"n,a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"\"\"\"\n平均がa <=> 集合をlとして, len(l)a = sum(l)\ndp[i][j][k] := i番目までのカードを選んだとき, 選んだ枚数がkでの総和がちょうどjになる場合の数.\nこれだとメモリが足りないので, iを省略する.\n\"\"\"",
"sumx = sum(x)",
"sumx",
"sum(x)",
"sum",
"x",
"dp = np.zeros((n, sumx+1), dtype=np.int64)",
"dp",
"np.zeros((n, sumx+1), dtype=np.int64)",
"np.zeros",
"np",
"zeros",
"(n, sumx+1)",
"n",
"sumx+1",
"sumx",
"1",
"dtype=np.int64",
"dtype",
"np.int64",
"np",
"int64",
"for i in range(n):\n\tfor j in range(i)[::-1]:\n\t\tdp[j+1][x[i]:] += dp[j][:-x[i]]\n\tdp[0][x[i]] += 1",
"i",
"range(n)",
"range",
"n",
"for j in range(i)[::-1]:\n\t\tdp[j+1][x[i]:] += dp[j][:-x[i]]\n\t",
"j",
"range(i)[::-1]",
"(i)",
"range",
"i",
"::-1",
"-1",
"dp[j+1][x[i]:] += dp[j][:-x[i]]",
"dp[j+1][x[i]:]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"x[i]:",
"x[i]",
"x",
"i",
"dp[j][:-x[i]]",
"[j]",
"dp",
"j",
":-x[i]",
"-x[i]",
"x[i]",
"x",
"i",
"dp[0][x[i]] += 1",
"dp[0][x[i]]",
"[0]",
"dp",
"0",
"x[i]",
"x",
"i",
"1",
"ans = 0",
"ans",
"0",
"for i in range(n):\n\tif (i+1)*a <= sumx:\n\t\tans += dp[i][(i+1)*a]",
"i",
"range(n)",
"range",
"n",
"if (i+1)*a <= sumx:\n\t\tans += dp[i][(i+1)*a]",
"(i+1)*a <= sumx",
"(i+1)*a",
"i+1",
"i",
"1",
"a",
"sumx",
"ans += dp[i][(i+1)*a]",
"ans",
"dp[i][(i+1)*a]",
"[i]",
"dp",
"i",
"(i+1)*a",
"i+1",
"i",
"1",
"a",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"sumx = sum(x)",
"sum(x)",
"sumx",
"ans += dp[i][(i+1)*a]",
"dp[i][(i+1)*a]",
"ans",
"dp = np.zeros((n, sumx+1), dtype=np.int64)",
"np.zeros((n, sumx+1), dtype=np.int64)",
"dp",
"n,a = map(int,input().split())",
"map(int,input().split())",
"n",
"a = map(int,input().split())",
"map(int,input().split())",
"a",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x"
] | import numpy as np
n,a = map(int,input().split())
x = list(map(int,input().split()))
"""
平均がa <=> 集合をlとして, len(l)a = sum(l)
dp[i][j][k] := i番目までのカードを選んだとき, 選んだ枚数がkでの総和がちょうどjになる場合の数.
これだとメモリが足りないので, iを省略する.
"""
sumx = sum(x)
dp = np.zeros((n, sumx+1), dtype=np.int64)
for i in range(n):
for j in range(i)[::-1]:
dp[j+1][x[i]:] += dp[j][:-x[i]]
dp[0][x[i]] += 1
ans = 0
for i in range(n):
if (i+1)*a <= sumx:
ans += dp[i][(i+1)*a]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
14,
2,
40,
2,
13,
17,
13,
2,
2,
13,
18,
13,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] | [
[
155,
2
],
[
155,
11
],
[
143,
13
],
[
27,
26
],
[
156,
30
],
[
146,
35
],
[
45,
38
],
[
147,
41
],
[
48,
47
],
[
156,
50
],
[
53,
52
],
[
156,
56
],
[
60,
59
],
[
73,
64
],
[
147,
67
],
[
47,
69
],
[
52,
71
],
[
59,
72
],
[
147,
76
],
[
47,
77
],
[
52,
78
],
[
59,
79
],
[
52,
84
],
[
156,
86
],
[
59,
89
],
[
144,
91
],
[
47,
92
],
[
110,
95
],
[
147,
98
],
[
47,
100
],
[
52,
103
],
[
59,
106
],
[
144,
108
],
[
47,
109
],
[
147,
113
],
[
47,
114
],
[
52,
115
],
[
59,
116
],
[
149,
118
],
[
122,
121
],
[
156,
126
],
[
158,
129
],
[
147,
133
],
[
156,
134
],
[
121,
135
],
[
121,
137
],
[
153,
138
],
[
159,
141
],
[
150,
141
],
[
143,
144
],
[
146,
147
],
[
149,
150
],
[
155,
153
],
[
155,
156
],
[
158,
159
]
] | [
"N, A = map(int, input().split())\nx = list(map(int, input().split()))\ndp = [[[0]*3000 for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0] = 1\n\nfor i in range(N):\n for j in range(N+1):\n for k in range(3000):\n dp[i+1][j][k] += dp[i][j][k]\n \n if j+1<=N and k+x[i]<3000:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]\n\nans = 0\n\nfor i in range(1, N+1):\n ans += dp[N][i][i*A]\n\nprint(ans)",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0]*3000 for _ in range(N+1)] for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"[[0]*3000 for _ in range(N+1)]",
"dp = [[[0]*3000 for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0]*3000 for _ in range(N+1)] for _ in range(N+1)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(N):\n for j in range(N+1):\n for k in range(3000):\n dp[i+1][j][k] += dp[i][j][k]\n \n if j+1<=N and k+x[i]<3000:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"i",
"range(N)",
"range",
"N",
"for j in range(N+1):\n for k in range(3000):\n dp[i+1][j][k] += dp[i][j][k]\n \n if j+1<=N and k+x[i]<3000:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for k in range(3000):\n dp[i+1][j][k] += dp[i][j][k]\n \n if j+1<=N and k+x[i]<3000:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"k",
"range(3000)",
"range",
"3000",
"dp[i+1][j][k] += dp[i][j][k]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"if j+1<=N and k+x[i]<3000:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"j+1<=N and k+x[i]<3000",
"j+1<=N",
"j+1",
"j",
"1",
"N",
"k+x[i]<3000",
"k+x[i]",
"k",
"x[i]",
"x",
"i",
"3000",
"dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"dp[i+1][j+1][k+x[i]]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k+x[i]",
"k",
"x[i]",
"x",
"i",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"ans = 0",
"ans",
"0",
"for i in range(1, N+1):\n ans += dp[N][i][i*A]",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[N][i][i*A]",
"ans",
"dp[N][i][i*A]",
"[i]",
"[N]",
"dp",
"N",
"i",
"i*A",
"i",
"A",
"print(ans)",
"print",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [[[0]*3000 for _ in range(N+1)] for _ in range(N+1)]",
"[[[0]*3000 for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"ans = 0",
"0",
"ans",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans += dp[N][i][i*A]",
"dp[N][i][i*A]",
"ans"
] | N, A = map(int, input().split())
x = list(map(int, input().split()))
dp = [[[0]*3000 for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N+1):
for k in range(3000):
dp[i+1][j][k] += dp[i][j][k]
if j+1<=N and k+x[i]<3000:
dp[i+1][j+1][k+x[i]] += dp[i][j][k]
ans = 0
for i in range(1, N+1):
ans += dp[N][i][i*A]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
12,
2,
4,
13,
13,
13,
23,
4,
18,
4,
13,
13,
0,
13,
2,
2,
17,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
2,
13,
17,
0,
13,
13,
0,
18,
18,
13,
17,
2,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
2,
13,
17,
13,
8,
40,
40,
17,
2,
13,
18,
13,
2,
13,
17,
13,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
17,
4,
13,
2,
18,
18,
13,
13,
2,
13,
17,
17,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
145,
2
],
[
145,
11
],
[
148,
13
],
[
140,
23
],
[
142,
31
],
[
146,
35
],
[
149,
40
],
[
140,
41
],
[
45,
44
],
[
146,
48
],
[
143,
55
],
[
136,
58
],
[
68,
61
],
[
137,
63
],
[
143,
66
],
[
71,
70
],
[
146,
75
],
[
79,
78
],
[
143,
82
],
[
90,
85
],
[
137,
87
],
[
70,
88
],
[
78,
89
],
[
137,
93
],
[
70,
95
],
[
78,
97
],
[
78,
103
],
[
149,
105
],
[
70,
107
],
[
143,
109
],
[
137,
112
],
[
70,
114
],
[
78,
117
],
[
149,
119
],
[
70,
121
],
[
137,
129
],
[
146,
130
],
[
143,
132
],
[
136,
137
],
[
145,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
]
] | [
"n,a,=map(int,input().split())\nx=list(map(lambda y:int(y)-a,input().split()))\nw=2*n*(max(max(x),a))\ndp=[[0]*(w+1) for _ in range(n+1)]\ndp[0][w//2]=1\nfor i in range(1,n+1):\n for j in range(w+1):\n dp[i][j]=dp[i-1][j]+(dp[i-1][j-x[i-1]] if 0<=j-x[i-1]<=w else 0)\nprint(dp[n][w//2]-1)",
"n,a,=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x=list(map(lambda y:int(y)-a,input().split()))",
"x",
"list(map(lambda y:int(y)-a,input().split()))",
"list",
"map(lambda y:int(y)-a,input().split())",
"map",
"lambda y:int(y)-a",
"int(y)-a",
"int(y)",
"int",
"y",
"a",
"y",
"input().split()",
"().split",
"()",
"input",
"split",
"w=2*n*(max(max(x),a))",
"w",
"2*n*(max(max(x),a))",
"2*n",
"2",
"n",
"max(max(x),a)",
"max",
"max(x)",
"max",
"x",
"a",
"[0]*(w+1) for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"[0]*(w+1)",
"[0]",
"0",
"w+1",
"w",
"1",
"dp=[[0]*(w+1) for _ in range(n+1)]",
"dp",
"[[0]*(w+1) for _ in range(n+1)]",
"dp[0][w//2]=1",
"dp[0][w//2]",
"[0]",
"dp",
"0",
"w//2",
"w",
"2",
"1",
"for i in range(1,n+1):\n for j in range(w+1):\n dp[i][j]=dp[i-1][j]+(dp[i-1][j-x[i-1]] if 0<=j-x[i-1]<=w else 0)",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for j in range(w+1):\n dp[i][j]=dp[i-1][j]+(dp[i-1][j-x[i-1]] if 0<=j-x[i-1]<=w else 0)",
"j",
"range(w+1)",
"range",
"w+1",
"w",
"1",
"dp[i][j]=dp[i-1][j]+(dp[i-1][j-x[i-1]] if 0<=j-x[i-1]<=w else 0)",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j]+(dp[i-1][j-x[i-1]] if 0<=j-x[i-1]<=w else 0)",
"dp[i-1][j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"dp[i-1][j-x[i-1]] if 0<=j-x[i-1]<=w else 0",
"0<=j-x[i-1]<=w",
"0<=j-x[i-1]",
"0",
"j-x[i-1]",
"j",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"w",
"dp[i-1][j-x[i-1]]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-x[i-1]",
"j",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"0",
"print(dp[n][w//2]-1)",
"print",
"dp[n][w//2]-1",
"dp[n][w//2]",
"[n]",
"dp",
"n",
"w//2",
"w",
"2",
"1",
"dp=[[0]*(w+1) for _ in range(n+1)]",
"[[0]*(w+1) for _ in range(n+1)]",
"dp",
"a,=map(int,input().split())",
"map(int,input().split())",
"a",
"w=2*n*(max(max(x),a))",
"2*n*(max(max(x),a))",
"w",
"n,a,=map(int,input().split())",
"map(int,input().split())",
"n",
"x=list(map(lambda y:int(y)-a,input().split()))",
"list(map(lambda y:int(y)-a,input().split()))",
"x"
] | n,a,=map(int,input().split())
x=list(map(lambda y:int(y)-a,input().split()))
w=2*n*(max(max(x),a))
dp=[[0]*(w+1) for _ in range(n+1)]
dp[0][w//2]=1
for i in range(1,n+1):
for j in range(w+1):
dp[i][j]=dp[i-1][j]+(dp[i-1][j-x[i-1]] if 0<=j-x[i-1]<=w else 0)
print(dp[n][w//2]-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
4,
13,
13,
28,
13,
4,
13,
17,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
0,
13,
2,
18,
18,
13,
13,
17,
17,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
123,
2
],
[
123,
11
],
[
111,
13
],
[
27,
26
],
[
112,
26
],
[
26,
30
],
[
124,
31
],
[
117,
33
],
[
38,
37
],
[
121,
41
],
[
126,
49
],
[
57,
52
],
[
127,
54
],
[
118,
63
],
[
66,
65
],
[
80,
71
],
[
127,
73
],
[
65,
78
],
[
127,
82
],
[
65,
84
],
[
93,
86
],
[
127,
88
],
[
65,
92
],
[
127,
95
],
[
65,
97
],
[
114,
99
],
[
127,
103
],
[
121,
104
],
[
115,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
123,
121
],
[
123,
124
],
[
126,
127
]
] | [
"n,a = map(int, input().split())\nX = list(map(int, input().split()))\nx = [i-a for i in X]\ndp = [[0]*5201 for i in range(n+1)]\ndp[0][2600] = 1 \nfor i,xi in enumerate(x):\n for k in range(99,5101):\n dp[i+1][k+xi] += dp[i][k] \n dp[i+1][k] += dp[i][k]\nans = dp[n][2600] - 1\nprint(ans)",
"n,a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"i-a for i in X",
"for i in X",
"i",
"X",
"for i in X",
"i-a",
"i",
"a",
"x = [i-a for i in X]",
"x",
"[i-a for i in X]",
"[0]*5201 for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[0]*5201",
"[0]",
"0",
"5201",
"dp = [[0]*5201 for i in range(n+1)]",
"dp",
"[[0]*5201 for i in range(n+1)]",
"dp[0][2600] = 1",
"dp[0][2600]",
"[0]",
"dp",
"0",
"2600",
"1",
"for i,xi in enumerate(x):\n for k in range(99,5101):\n dp[i+1][k+xi] += dp[i][k] \n dp[i+1][k] += dp[i][k]",
"i",
"xi",
"enumerate(x)",
"enumerate",
"x",
"for k in range(99,5101):\n dp[i+1][k+xi] += dp[i][k] \n dp[i+1][k] += dp[i][k]",
"k",
"range(99,5101)",
"range",
"99",
"5101",
"dp[i+1][k+xi] += dp[i][k]",
"dp[i+1][k+xi]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k+xi",
"k",
"xi",
"dp[i][k]",
"[i]",
"dp",
"i",
"k",
"dp[i+1][k] += dp[i][k]",
"dp[i+1][k]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k",
"dp[i][k]",
"[i]",
"dp",
"i",
"k",
"ans = dp[n][2600] - 1",
"ans",
"dp[n][2600] - 1",
"dp[n][2600]",
"[n]",
"dp",
"n",
"2600",
"1",
"print(ans)",
"print",
"ans",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"ans = dp[n][2600] - 1",
"dp[n][2600] - 1",
"ans",
"x = [i-a for i in X]",
"[i-a for i in X]",
"x",
"n,a = map(int, input().split())",
"map(int, input().split())",
"n",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"dp = [[0]*5201 for i in range(n+1)]",
"[[0]*5201 for i in range(n+1)]",
"dp"
] | n,a = map(int, input().split())
X = list(map(int, input().split()))
x = [i-a for i in X]
dp = [[0]*5201 for i in range(n+1)]
dp[0][2600] = 1
for i,xi in enumerate(x):
for k in range(99,5101):
dp[i+1][k+xi] += dp[i][k]
dp[i+1][k] += dp[i][k]
ans = dp[n][2600] - 1
print(ans) |
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
4,
13,
13,
0,
13,
13,
0,
18,
18,
13,
17,
13,
17,
28,
13,
13,
4,
13,
13,
28,
13,
4,
18,
18,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
4,
13,
2,
18,
18,
13,
13,
13,
17,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13
] | [
[
107,
3
],
[
107,
12
],
[
113,
14
],
[
28,
27
],
[
105,
31
],
[
116,
38
],
[
46,
41
],
[
117,
43
],
[
108,
45
],
[
114,
52
],
[
55,
54
],
[
117,
58
],
[
110,
62
],
[
54,
65
],
[
108,
66
],
[
76,
69
],
[
117,
71
],
[
111,
75
],
[
117,
78
],
[
54,
80
],
[
89,
82
],
[
117,
84
],
[
54,
88
],
[
117,
91
],
[
54,
93
],
[
117,
99
],
[
105,
100
],
[
108,
101
],
[
107,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
]
] | [
"from collections import defaultdict\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\n\ndp = [defaultdict(int) for _ in range(n+1)]\ndp[0][a] += 1\n\nfor i, x_i in enumerate(x):\n for p in dp[i].keys():\n pk = p + a - x_i\n dp[i+1][pk] += dp[i][p]\n dp[i+1][p] += dp[i][p]\n\nprint(dp[n][a] - 1)",
"from collections import defaultdict",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"defaultdict(int) for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"defaultdict(int)",
"defaultdict",
"int",
"dp = [defaultdict(int) for _ in range(n+1)]",
"dp",
"[defaultdict(int) for _ in range(n+1)]",
"dp[0][a] += 1",
"dp[0][a]",
"[0]",
"dp",
"0",
"a",
"1",
"for i, x_i in enumerate(x):\n for p in dp[i].keys():\n pk = p + a - x_i\n dp[i+1][pk] += dp[i][p]\n dp[i+1][p] += dp[i][p]",
"i",
"x_i",
"enumerate(x)",
"enumerate",
"x",
"for p in dp[i].keys():\n pk = p + a - x_i\n dp[i+1][pk] += dp[i][p]\n dp[i+1][p] += dp[i][p]",
"p",
"dp[i].keys()",
"[i].keys",
"[i]",
"dp",
"i",
"keys",
"pk = p + a - x_i",
"pk",
"p + a - x_i",
"p + a",
"p",
"a",
"x_i",
"dp[i+1][pk] += dp[i][p]",
"dp[i+1][pk]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"pk",
"dp[i][p]",
"[i]",
"dp",
"i",
"p",
"dp[i+1][p] += dp[i][p]",
"dp[i+1][p]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"p",
"dp[i][p]",
"[i]",
"dp",
"i",
"p",
"print(dp[n][a] - 1)",
"print",
"dp[n][a] - 1",
"dp[n][a]",
"[n]",
"dp",
"n",
"a",
"1",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"pk = p + a - x_i",
"p + a - x_i",
"pk",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [defaultdict(int) for _ in range(n+1)]",
"[defaultdict(int) for _ in range(n+1)]",
"dp"
] | from collections import defaultdict
n, a = map(int, input().split())
x = list(map(int, input().split()))
dp = [defaultdict(int) for _ in range(n+1)]
dp[0][a] += 1
for i, x_i in enumerate(x):
for p in dp[i].keys():
pk = p + a - x_i
dp[i+1][pk] += dp[i][p]
dp[i+1][p] += dp[i][p]
print(dp[n][a] - 1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
2,
13,
17,
4,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
18,
18,
13,
2,
13,
17,
39,
17,
17,
0,
18,
18,
13,
13,
2,
17,
18,
13,
2,
13,
17,
17,
28,
13,
4,
13,
17,
14,
2,
40,
17,
2,
13,
18,
13,
2,
13,
17,
40,
2,
13,
18,
13,
2,
13,
17,
17,
0,
18,
18,
13,
13,
2,
13,
18,
13,
2,
13,
17,
18,
18,
13,
2,
13,
17,
13,
0,
13,
18,
18,
13,
13,
17,
4,
13,
2,
2,
2,
13,
17,
2,
17,
13,
17,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
206,
2
],
[
206,
11
],
[
191,
13
],
[
26,
25
],
[
204,
28
],
[
33,
30
],
[
192,
31
],
[
25,
32
],
[
30,
34
],
[
192,
35
],
[
25,
36
],
[
207,
37
],
[
197,
39
],
[
200,
42
],
[
46,
45
],
[
204,
48
],
[
30,
51
],
[
192,
52
],
[
45,
53
],
[
194,
56
],
[
201,
58
],
[
195,
58
],
[
198,
62
],
[
30,
64
],
[
192,
65
],
[
45,
66
],
[
209,
68
],
[
198,
71
],
[
75,
74
],
[
210,
78
],
[
204,
78
],
[
185,
86
],
[
90,
89
],
[
210,
94
],
[
204,
94
],
[
100,
97
],
[
186,
98
],
[
89,
99
],
[
186,
102
],
[
89,
104
],
[
121,
110
],
[
97,
111
],
[
186,
112
],
[
89,
113
],
[
198,
117
],
[
89,
119
],
[
124,
123
],
[
123,
132
],
[
198,
134
],
[
89,
136
],
[
123,
140
],
[
198,
142
],
[
89,
144
],
[
159,
148
],
[
97,
149
],
[
186,
150
],
[
89,
151
],
[
123,
153
],
[
198,
155
],
[
89,
157
],
[
186,
161
],
[
89,
163
],
[
123,
165
],
[
188,
167
],
[
186,
170
],
[
210,
171
],
[
204,
171
],
[
189,
178
],
[
195,
182
],
[
201,
182
],
[
185,
186
],
[
188,
189
],
[
191,
192
],
[
194,
195
],
[
197,
198
],
[
200,
201
],
[
206,
204
],
[
206,
207
],
[
209,
210
]
] | [
"n,a=map(int,input().split())\nA=list(map(int,input().split()))\nfor i in range(n):\n A[i]=A[i]-a\nB=[]\nc=0\nfor i in range(n):\n if A[i]==0:\n c=c+1\n else:\n B.append(A[i])\nn=len(B)\ndp=[[0]*5010 for i in range(n+1)]#0と2505を対応\nfor i in range(1,n+1):\n dp[i]=dp[i-1][0:5010]\n dp[i][2505+B[i-1]]+=1\n for j in range(5010):\n if 0<=j+B[i-1] and j+B[i-1]<=5009:\n dp[i][j+B[i-1]]+=dp[i-1][j]\nans=dp[n][2505]\nprint((ans+1)*2**c-1)",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(n):\n A[i]=A[i]-a",
"i",
"range(n)",
"range",
"n",
"A[i]=A[i]-a",
"A[i]",
"A",
"i",
"A[i]-a",
"A[i]",
"A",
"i",
"a",
"B=[]",
"B",
"[]",
"c=0",
"c",
"0",
"for i in range(n):\n if A[i]==0:\n c=c+1\n else:\n B.append(A[i])",
"i",
"range(n)",
"range",
"n",
"if A[i]==0:\n c=c+1\n else:\n B.append(A[i])",
"A[i]==0",
"A[i]",
"A",
"i",
"0",
"c=c+1",
"c",
"c+1",
"c",
"1",
"B.append(A[i])",
"B.append",
"B",
"append",
"A[i]",
"A",
"i",
"n=len(B)",
"n",
"len(B)",
"len",
"B",
"[0]*5010 for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[0]*5010",
"[0]",
"0",
"5010",
"dp=[[0]*5010 for i in range(n+1)]",
"dp",
"[[0]*5010 for i in range(n+1)]",
"for i in range(1,n+1):\n dp[i]=dp[i-1][0:5010]\n dp[i][2505+B[i-1]]+=1\n for j in range(5010):\n if 0<=j+B[i-1] and j+B[i-1]<=5009:\n dp[i][j+B[i-1]]+=dp[i-1][j]",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"dp[i]=dp[i-1][0:5010]",
"dp[i]",
"dp",
"i",
"dp[i-1][0:5010]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"0:5010",
"0",
"5010",
"dp[i][2505+B[i-1]]+=1",
"dp[i][2505+B[i-1]]",
"[i]",
"dp",
"i",
"2505+B[i-1]",
"2505",
"B[i-1]",
"B",
"i-1",
"i",
"1",
"1",
"for j in range(5010):\n if 0<=j+B[i-1] and j+B[i-1]<=5009:\n dp[i][j+B[i-1]]+=dp[i-1][j]",
"j",
"range(5010)",
"range",
"5010",
"if 0<=j+B[i-1] and j+B[i-1]<=5009:\n dp[i][j+B[i-1]]+=dp[i-1][j]",
"0<=j+B[i-1] and j+B[i-1]<=5009",
"0<=j+B[i-1]",
"0",
"j+B[i-1]",
"j",
"B[i-1]",
"B",
"i-1",
"i",
"1",
"j+B[i-1]<=5009",
"j+B[i-1]",
"j",
"B[i-1]",
"B",
"i-1",
"i",
"1",
"5009",
"dp[i][j+B[i-1]]+=dp[i-1][j]",
"dp[i][j+B[i-1]]",
"[i]",
"dp",
"i",
"j+B[i-1]",
"j",
"B[i-1]",
"B",
"i-1",
"i",
"1",
"dp[i-1][j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"ans=dp[n][2505]",
"ans",
"dp[n][2505]",
"[n]",
"dp",
"n",
"2505",
"print((ans+1)*2**c-1)",
"print",
"(ans+1)*2**c-1",
"(ans+1)*2**c",
"ans+1",
"ans",
"1",
"2**c",
"2",
"c",
"1",
"dp=[[0]*5010 for i in range(n+1)]",
"[[0]*5010 for i in range(n+1)]",
"dp",
"ans=dp[n][2505]",
"dp[n][2505]",
"ans",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"c=c+1",
"c+1",
"c",
"B=[]",
"[]",
"B",
"c=0",
"0",
"c",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"n=len(B)",
"len(B)",
"n"
] | n,a=map(int,input().split())
A=list(map(int,input().split()))
for i in range(n):
A[i]=A[i]-a
B=[]
c=0
for i in range(n):
if A[i]==0:
c=c+1
else:
B.append(A[i])
n=len(B)
dp=[[0]*5010 for i in range(n+1)]#0と2505を対応
for i in range(1,n+1):
dp[i]=dp[i-1][0:5010]
dp[i][2505+B[i-1]]+=1
for j in range(5010):
if 0<=j+B[i-1] and j+B[i-1]<=5009:
dp[i][j+B[i-1]]+=dp[i-1][j]
ans=dp[n][2505]
print((ans+1)*2**c-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
2,
2,
2,
17,
13,
13,
17,
0,
13,
13,
0,
18,
18,
13,
17,
2,
13,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
2,
17,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
14,
2,
40,
17,
2,
13,
18,
13,
13,
40,
2,
13,
18,
13,
13,
2,
2,
17,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
2,
13,
18,
13,
13,
4,
13,
2,
18,
18,
13,
13,
2,
13,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
160,
2
],
[
160,
11
],
[
157,
13
],
[
26,
25
],
[
155,
28
],
[
33,
30
],
[
158,
31
],
[
25,
32
],
[
161,
33
],
[
151,
35
],
[
158,
40
],
[
161,
41
],
[
45,
44
],
[
155,
48
],
[
155,
58
],
[
152,
59
],
[
163,
62
],
[
72,
65
],
[
164,
67
],
[
155,
70
],
[
152,
71
],
[
75,
74
],
[
155,
77
],
[
80,
79
],
[
155,
86
],
[
152,
87
],
[
97,
90
],
[
164,
92
],
[
74,
94
],
[
79,
96
],
[
164,
99
],
[
74,
100
],
[
79,
101
],
[
79,
107
],
[
30,
108
],
[
158,
109
],
[
74,
110
],
[
79,
113
],
[
30,
114
],
[
158,
115
],
[
74,
116
],
[
155,
120
],
[
152,
121
],
[
130,
123
],
[
164,
125
],
[
74,
127
],
[
79,
129
],
[
164,
132
],
[
74,
133
],
[
79,
135
],
[
30,
136
],
[
158,
137
],
[
74,
138
],
[
164,
144
],
[
155,
145
],
[
155,
147
],
[
152,
148
],
[
151,
152
],
[
160,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
]
] | [
"N, A = map(int, input().split())\nx = list(map(int, input().split()))\nfor i in range(N):\n x[i] -= A\nmax_x = max(max(x), A)\n\ndp = [[0]*(2*N*max_x + 1) for i in range(N+1)]\ndp[0][N*max_x] = 1\n\nfor i in range(N):\n for k in range(2*N*max_x + 1):\n dp[i+1][k] = dp[i][k]\n if 0 <= k - x[i] and k - x[i] <= 2*N*max_x:\n dp[i+1][k] += dp[i][k - x[i]]\n\nprint(dp[N][N*max_x] - 1)",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x = list(map(int, input().split()))",
"x",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(N):\n x[i] -= A",
"i",
"range(N)",
"range",
"N",
"x[i] -= A",
"x[i]",
"x",
"i",
"A",
"max_x = max(max(x), A)",
"max_x",
"max(max(x), A)",
"max",
"max(x)",
"max",
"x",
"A",
"[0]*(2*N*max_x + 1) for i in range(N+1)",
"for i in range(N+1)",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for i in range(N+1)",
"[0]*(2*N*max_x + 1)",
"[0]",
"0",
"2*N*max_x + 1",
"2*N*max_x",
"2*N",
"2",
"N",
"max_x",
"1",
"dp = [[0]*(2*N*max_x + 1) for i in range(N+1)]",
"dp",
"[[0]*(2*N*max_x + 1) for i in range(N+1)]",
"dp[0][N*max_x] = 1",
"dp[0][N*max_x]",
"[0]",
"dp",
"0",
"N*max_x",
"N",
"max_x",
"1",
"for i in range(N):\n for k in range(2*N*max_x + 1):\n dp[i+1][k] = dp[i][k]\n if 0 <= k - x[i] and k - x[i] <= 2*N*max_x:\n dp[i+1][k] += dp[i][k - x[i]]",
"i",
"range(N)",
"range",
"N",
"for k in range(2*N*max_x + 1):\n dp[i+1][k] = dp[i][k]\n if 0 <= k - x[i] and k - x[i] <= 2*N*max_x:\n dp[i+1][k] += dp[i][k - x[i]]",
"k",
"range(2*N*max_x + 1)",
"range",
"2*N*max_x + 1",
"2*N*max_x",
"2*N",
"2",
"N",
"max_x",
"1",
"dp[i+1][k] = dp[i][k]",
"dp[i+1][k]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k",
"dp[i][k]",
"[i]",
"dp",
"i",
"k",
"if 0 <= k - x[i] and k - x[i] <= 2*N*max_x:\n dp[i+1][k] += dp[i][k - x[i]]",
"0 <= k - x[i] and k - x[i] <= 2*N*max_x",
"0 <= k - x[i]",
"0",
"k - x[i]",
"k",
"x[i]",
"x",
"i",
"k - x[i] <= 2*N*max_x",
"k - x[i]",
"k",
"x[i]",
"x",
"i",
"2*N*max_x",
"2*N",
"2",
"N",
"max_x",
"dp[i+1][k] += dp[i][k - x[i]]",
"dp[i+1][k]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k",
"dp[i][k - x[i]]",
"[i]",
"dp",
"i",
"k - x[i]",
"k",
"x[i]",
"x",
"i",
"print(dp[N][N*max_x] - 1)",
"print",
"dp[N][N*max_x] - 1",
"dp[N][N*max_x]",
"[N]",
"dp",
"N",
"N*max_x",
"N",
"max_x",
"1",
"max_x = max(max(x), A)",
"max(max(x), A)",
"max_x",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"dp = [[0]*(2*N*max_x + 1) for i in range(N+1)]",
"[[0]*(2*N*max_x + 1) for i in range(N+1)]",
"dp"
] | N, A = map(int, input().split())
x = list(map(int, input().split()))
for i in range(N):
x[i] -= A
max_x = max(max(x), A)
dp = [[0]*(2*N*max_x + 1) for i in range(N+1)]
dp[0][N*max_x] = 1
for i in range(N):
for k in range(2*N*max_x + 1):
dp[i+1][k] = dp[i][k]
if 0 <= k - x[i] and k - x[i] <= 2*N*max_x:
dp[i+1][k] += dp[i][k - x[i]]
print(dp[N][N*max_x] - 1) |
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
2,
13,
17,
28,
13,
13,
4,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
14,
40,
13,
17,
0,
13,
18,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
121,
3
],
[
121,
12
],
[
106,
14
],
[
29,
28
],
[
119,
32
],
[
115,
38
],
[
46,
41
],
[
116,
43
],
[
107,
52
],
[
55,
54
],
[
116,
68
],
[
54,
69
],
[
81,
72
],
[
116,
74
],
[
54,
76
],
[
109,
83
],
[
116,
90
],
[
112,
96
],
[
122,
101
],
[
113,
104
],
[
110,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
121,
119
],
[
121,
122
]
] | [
"from collections import Counter\nN,A = map(int, input().split())\nX = list(map(int, input().split()))\n\n\"\"\"\n普通にやると最大で2**50通りなのでTLE\ni枚選んだ時に合計がi*Aになる物を考えるとよい\nprd_xxxさんの解答に自分向けのコメントつけただけ\nhttps://atcoder.jp/contests/abc044/submissions/3018277\n\"\"\"\n\n# 0枚からN枚まで選んで、合計値がkeyでその組み合わせの数がvalue\ndp = [Counter() for _ in range(N+1)]\ndp[0][0] = 1\n\nfor i, a in enumerate(X): # i番目のカードまで選べる\n for j in reversed(range(i+1)): # j枚選ぶとき（０～i枚の範囲）、逆順にしないと１枚目にX_iを選んで３枚目にもX_iを選ぶみたいな重複が発生するのでこれを回避するために逆順にする\n for k,v in dp[j].items(): # j枚選んだ時の合計値とその組み合わせの個数についてみていく\n dp[j+1][k+a] += v # j+1枚目としてi番目のカードを選ぶ時に合計がk+aになる個数は、j枚選んでｋになる個数と同じ（それぞれの場合にaを足してできる）\n\nans = 0\nfor i, C in enumerate(dp):\n if i >= 1:\n ans += C[i*A]\nprint(ans)",
"from collections import Counter",
"N,A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"X = list(map(int, input().split()))",
"X",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"\"\"\"\n普通にやると最大で2**50通りなのでTLE\ni枚選んだ時に合計がi*Aになる物を考えるとよい\nprd_xxxさんの解答に自分向けのコメントつけただけ\nhttps://atcoder.jp/contests/abc044/submissions/3018277\n\"\"\"",
"Counter() for _ in range(N+1)",
"for _ in range(N+1)",
"_",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for _ in range(N+1)",
"Counter()",
"Counter",
"dp = [Counter() for _ in range(N+1)]",
"dp",
"[Counter() for _ in range(N+1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i, a in enumerate(X): # i番目のカードまで選べる\n for j in reversed(range(i+1)): # j枚選ぶとき（０～i枚の範囲）、逆順にしないと１枚目にX_iを選んで３枚目にもX_iを選ぶみたいな重複が発生するのでこれを回避するために逆順にする\n for k,v in dp[j].items(): # j枚選んだ時の合計値とその組み合わせの個数についてみていく\n dp[j+1][k+a] += v # j+1枚目としてi番目のカードを選ぶ時に合計がk+aになる個数は、j枚選んでｋになる個数と同じ（それぞれの場合にaを足してできる）",
"i",
"a",
"enumerate(X)",
"enumerate",
"X",
"for j in reversed(range(i+1)): # j枚選ぶとき（０～i枚の範囲）、逆順にしないと１枚目にX_iを選んで３枚目にもX_iを選ぶみたいな重複が発生するのでこれを回避するために逆順にする\n for k,v in dp[j].items(): # j枚選んだ時の合計値とその組み合わせの個数についてみていく\n dp[j+1][k+a] += v # j+1枚目としてi番目のカードを選ぶ時に合計がk+aになる個数は、j枚選んでｋになる個数と同じ（それぞれの場合にaを足してできる）",
"j",
"reversed(range(i+1))",
"reversed",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"for k,v in dp[j].items(): # j枚選んだ時の合計値とその組み合わせの個数についてみていく\n dp[j+1][k+a] += v # j+1枚目としてi番目のカードを選ぶ時に合計がk+aになる個数は、j枚選んでｋになる個数と同じ（それぞれの場合にaを足してできる）",
"k",
"v",
"dp[j].items()",
"[j].items",
"[j]",
"dp",
"j",
"items",
"dp[j+1][k+a] += v",
"dp[j+1][k+a]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"k+a",
"k",
"a",
"v",
"ans = 0",
"ans",
"0",
"for i, C in enumerate(dp):\n if i >= 1:\n ans += C[i*A]",
"i",
"C",
"enumerate(dp)",
"enumerate",
"dp",
"if i >= 1:\n ans += C[i*A]",
"i >= 1",
"i",
"1",
"ans += C[i*A]",
"ans",
"C[i*A]",
"C",
"i*A",
"i",
"A",
"print(ans)",
"print",
"ans",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"ans = 0",
"0",
"ans",
"ans += C[i*A]",
"C[i*A]",
"ans",
"dp = [Counter() for _ in range(N+1)]",
"[Counter() for _ in range(N+1)]",
"dp",
"N,A = map(int, input().split())",
"map(int, input().split())",
"N",
"A = map(int, input().split())",
"map(int, input().split())",
"A"
] | from collections import Counter
N,A = map(int, input().split())
X = list(map(int, input().split()))
"""
普通にやると最大で2**50通りなのでTLE
i枚選んだ時に合計がi*Aになる物を考えるとよい
prd_xxxさんの解答に自分向けのコメントつけただけ
https://atcoder.jp/contests/abc044/submissions/3018277
"""
# 0枚からN枚まで選んで、合計値がkeyでその組み合わせの数がvalue
dp = [Counter() for _ in range(N+1)]
dp[0][0] = 1
for i, a in enumerate(X): # i番目のカードまで選べる
for j in reversed(range(i+1)): # j枚選ぶとき（０～i枚の範囲）、逆順にしないと１枚目にX_iを選んで３枚目にもX_iを選ぶみたいな重複が発生するのでこれを回避するために逆順にする
for k,v in dp[j].items(): # j枚選んだ時の合計値とその組み合わせの個数についてみていく
dp[j+1][k+a] += v # j+1枚目としてi番目のカードを選ぶ時に合計がk+aになる個数は、j枚選んでｋになる個数と同じ（それぞれの場合にaを足してできる）
ans = 0
for i, C in enumerate(dp):
if i >= 1:
ans += C[i*A]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
28,
13,
18,
4,
13,
17,
2,
13,
17,
39,
17,
28,
13,
18,
4,
13,
13,
2,
13,
17,
39,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
4,
13,
2,
13,
13,
13,
17,
0,
13,
18,
18,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13
] | [
[
127,
2
],
[
127,
11
],
[
133,
13
],
[
121,
25
],
[
134,
28
],
[
32,
31
],
[
119,
35
],
[
130,
40
],
[
48,
43
],
[
131,
45
],
[
51,
50
],
[
134,
50
],
[
54,
53
],
[
119,
59
],
[
65,
64
],
[
50,
68
],
[
122,
70
],
[
80,
75
],
[
131,
77
],
[
53,
78
],
[
64,
79
],
[
131,
82
],
[
53,
84
],
[
64,
87
],
[
50,
88
],
[
124,
90
],
[
94,
93
],
[
122,
101
],
[
128,
102
],
[
119,
103
],
[
136,
106
],
[
131,
109
],
[
93,
110
],
[
93,
112
],
[
128,
113
],
[
137,
116
],
[
125,
116
],
[
127,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
]
] | [
"n,a = map(int,input().split())\nxx = list(map(int,input().split()))\n\nsm = sum(xx)\ndp = [[0 for j in range(sm+1)] for i in range(n+1)]\ndp[0][0] = 1\nfor x in xx:\n for i in range(1,n+1)[::-1]:\n for j in range(x,sm+1)[::-1]:\n # if dp[i-1][j-x]:\n dp[i][j] += dp[i-1][j-x]\n\nans = 0\nfor i in range(1, min(sm // a,n) + 1):\n ans += dp[i][i*a]\nprint(ans)",
"n,a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"xx = list(map(int,input().split()))",
"xx",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sm = sum(xx)",
"sm",
"sum(xx)",
"sum",
"xx",
"[0 for j in range(sm+1)] for i in range(n+1)",
"for i in range(n+1)",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for i in range(n+1)",
"[0 for j in range(sm+1)]",
"dp = [[0 for j in range(sm+1)] for i in range(n+1)]",
"dp",
"[[0 for j in range(sm+1)] for i in range(n+1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for x in xx:\n for i in range(1,n+1)[::-1]:\n for j in range(x,sm+1)[::-1]:\n # if dp[i-1][j-x]:\n dp[i][j] += dp[i-1][j-x]",
"x",
"xx",
"for i in range(1,n+1)[::-1]:\n for j in range(x,sm+1)[::-1]:\n # if dp[i-1][j-x]:\n dp[i][j] += dp[i-1][j-x]",
"i",
"range(1,n+1)[::-1]",
"(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"::-1",
"-1",
"for j in range(x,sm+1)[::-1]:\n # if dp[i-1][j-x]:\n dp[i][j] += dp[i-1][j-x]",
"j",
"range(x,sm+1)[::-1]",
"(x,sm+1)",
"range",
"x",
"sm+1",
"sm",
"1",
"::-1",
"-1",
"dp[i][j] += dp[i-1][j-x]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j-x]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-x",
"j",
"x",
"ans = 0",
"ans",
"0",
"for i in range(1, min(sm // a,n) + 1):\n ans += dp[i][i*a]",
"i",
"range(1, min(sm // a,n) + 1)",
"range",
"1",
"min(sm // a,n) + 1",
"min(sm // a,n)",
"min",
"sm // a",
"sm",
"a",
"n",
"1",
"ans += dp[i][i*a]",
"ans",
"dp[i][i*a]",
"[i]",
"dp",
"i",
"i*a",
"i",
"a",
"print(ans)",
"print",
"ans",
"n,a = map(int,input().split())",
"map(int,input().split())",
"n",
"sm = sum(xx)",
"sum(xx)",
"sm",
"ans = 0",
"0",
"ans",
"a = map(int,input().split())",
"map(int,input().split())",
"a",
"dp = [[0 for j in range(sm+1)] for i in range(n+1)]",
"[[0 for j in range(sm+1)] for i in range(n+1)]",
"dp",
"xx = list(map(int,input().split()))",
"list(map(int,input().split()))",
"xx",
"ans += dp[i][i*a]",
"dp[i][i*a]",
"ans"
] | n,a = map(int,input().split())
xx = list(map(int,input().split()))
sm = sum(xx)
dp = [[0 for j in range(sm+1)] for i in range(n+1)]
dp[0][0] = 1
for x in xx:
for i in range(1,n+1)[::-1]:
for j in range(x,sm+1)[::-1]:
# if dp[i-1][j-x]:
dp[i][j] += dp[i-1][j-x]
ans = 0
for i in range(1, min(sm // a,n) + 1):
ans += dp[i][i*a]
print(ans)
|
[
7,
15,
0,
13,
4,
13,
4,
13,
0,
13,
17,
13,
17,
14,
2,
2,
18,
13,
17,
18,
13,
17,
2,
40,
18,
13,
17,
40,
18,
13,
17,
0,
13,
17,
14,
2,
2,
18,
13,
17,
18,
13,
17,
2,
40,
18,
13,
17,
40,
18,
13,
17,
0,
13,
17,
8,
2,
13,
13,
4,
13,
17,
4,
13,
17,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
78,
3
],
[
72,
9
],
[
75,
11
],
[
79,
17
],
[
79,
20
],
[
79,
25
],
[
79,
29
],
[
69,
32
],
[
79,
38
],
[
79,
41
],
[
79,
46
],
[
79,
50
],
[
66,
53
],
[
70,
57
],
[
73,
57
],
[
67,
58
],
[
76,
58
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
]
] | [
"from collections import Counter\n\n\ncntr = Counter(input())\nx_ok, y_ok = False, False\nif (cntr[\"E\"] and cntr[\"W\"]) or (not cntr[\"E\"] and not cntr[\"W\"]):\n x_ok = True\nif (cntr[\"N\"] and cntr[\"S\"]) or (not cntr[\"N\"] and not cntr[\"S\"]):\n y_ok = True\nprint(\"Yes\") if x_ok and y_ok else print(\"No\")",
"from collections import Counter",
"cntr = Counter(input())",
"cntr",
"Counter(input())",
"Counter",
"input()",
"input",
"x_ok, y_ok = False, False",
"x_ok",
"False",
"y_ok",
"False",
"if (cntr[\"E\"] and cntr[\"W\"]) or (not cntr[\"E\"] and not cntr[\"W\"]):\n x_ok = True",
"(cntr[\"E\"] and cntr[\"W\"]) or (not cntr[\"E\"] and not cntr[\"W\"])",
"cntr[\"E\"] and cntr[\"W\"]",
"cntr[\"E\"]",
"cntr",
"\"E\"",
"cntr[\"W\"]",
"cntr",
"\"W\"",
"not cntr[\"E\"] and not cntr[\"W\"]",
"not cntr[\"E\"]",
"cntr[\"E\"]",
"cntr",
"\"E\"",
"not cntr[\"W\"]",
"cntr[\"W\"]",
"cntr",
"\"W\"",
"x_ok = True",
"x_ok",
"True",
"if (cntr[\"N\"] and cntr[\"S\"]) or (not cntr[\"N\"] and not cntr[\"S\"]):\n y_ok = True",
"(cntr[\"N\"] and cntr[\"S\"]) or (not cntr[\"N\"] and not cntr[\"S\"])",
"cntr[\"N\"] and cntr[\"S\"]",
"cntr[\"N\"]",
"cntr",
"\"N\"",
"cntr[\"S\"]",
"cntr",
"\"S\"",
"not cntr[\"N\"] and not cntr[\"S\"]",
"not cntr[\"N\"]",
"cntr[\"N\"]",
"cntr",
"\"N\"",
"not cntr[\"S\"]",
"cntr[\"S\"]",
"cntr",
"\"S\"",
"y_ok = True",
"y_ok",
"True",
"print(\"Yes\") if x_ok and y_ok else print(\"No\")",
"x_ok and y_ok",
"x_ok",
"y_ok",
"print(\"Yes\")",
"print",
"\"Yes\"",
"print(\"No\")",
"print",
"\"No\"",
"y_ok = True",
"True",
"y_ok",
"x_ok = True",
"True",
"x_ok",
"x_ok, y_ok = False, False",
"False",
"x_ok",
"y_ok = False, False",
"False",
"y_ok",
"cntr = Counter(input())",
"Counter(input())",
"cntr"
] | from collections import Counter
cntr = Counter(input())
x_ok, y_ok = False, False
if (cntr["E"] and cntr["W"]) or (not cntr["E"] and not cntr["W"]):
x_ok = True
if (cntr["N"] and cntr["S"]) or (not cntr["N"] and not cntr["S"]):
y_ok = True
print("Yes") if x_ok and y_ok else print("No")
|
[
7,
0,
13,
4,
13,
4,
13,
4,
13,
14,
2,
2,
2,
4,
13,
13,
17,
2,
4,
13,
13,
4,
13,
39,
17,
17,
2,
4,
13,
13,
4,
13,
39,
17,
17,
4,
13,
17,
4,
13,
17,
10,
4,
13
] | [
[
42,
2
],
[
43,
15
],
[
43,
20
],
[
43,
29
],
[
42,
43
]
] | [
"S=list(set(input()))\nif len(S)==4 or set(S)==set(['N','S']) or set(S)==set(['W','E']):\n print('Yes')\nelse:\n print('No')",
"S=list(set(input()))",
"S",
"list(set(input()))",
"list",
"set(input())",
"set",
"input()",
"input",
"if len(S)==4 or set(S)==set(['N','S']) or set(S)==set(['W','E']):\n print('Yes')\nelse:\n print('No')",
"len(S)==4 or set(S)==set(['N','S']) or set(S)==set(['W','E'])",
"len(S)==4 or set(S)==set(['N','S'])",
"len(S)==4",
"len(S)",
"len",
"S",
"4",
"set(S)==set(['N','S'])",
"set(S)",
"set",
"S",
"set(['N','S'])",
"set",
"['N','S']",
"'N'",
"'S'",
"set(S)==set(['W','E'])",
"set(S)",
"set",
"S",
"set(['W','E'])",
"set",
"['W','E']",
"'W'",
"'E'",
"print('Yes')",
"print",
"'Yes'",
"print('No')",
"print",
"'No'",
"S=list(set(input()))",
"list(set(input()))",
"S"
] | S=list(set(input()))
if len(S)==4 or set(S)==set(['N','S']) or set(S)==set(['W','E']):
print('Yes')
else:
print('No') |
[
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,
18,
13,
13,
13,
0,
13,
18,
13,
17,
0,
13,
18,
13,
17,
0,
13,
18,
13,
17,
0,
13,
18,
13,
17,
14,
2,
2,
2,
2,
13,
17,
2,
13,
17,
2,
2,
13,
13,
17,
2,
2,
2,
13,
17,
2,
13,
17,
2,
2,
13,
13,
17,
4,
13,
17,
4,
13,
17,
14,
2,
13,
17,
4,
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
] | [
[
166,
11
],
[
178,
30
],
[
43,
42
],
[
167,
46
],
[
42,
51
],
[
57,
56
],
[
167,
60
],
[
56,
66
],
[
73,
72
],
[
167,
76
],
[
72,
81
],
[
90,
89
],
[
188,
91
],
[
94,
93
],
[
89,
98
],
[
101,
100
],
[
93,
102
],
[
106,
105
],
[
93,
107
],
[
111,
110
],
[
93,
112
],
[
116,
115
],
[
93,
117
],
[
100,
124
],
[
110,
127
],
[
100,
131
],
[
110,
132
],
[
105,
137
],
[
115,
140
],
[
105,
144
],
[
115,
145
],
[
164,
158
],
[
166,
167
],
[
178,
179
]
] | [
"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\n cnt = collections.Counter(S)\n n = cnt['N']\n w = cnt['W']\n s = cnt['S']\n e = cnt['E']\n if (n > 0 and s > 0 or n == s == 0) and (w > 0 and e > 0 or w == e == 0):\n print('Yes')\n else:\n print('No')\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\n cnt = collections.Counter(S)\n n = cnt['N']\n w = cnt['W']\n s = cnt['S']\n e = cnt['E']\n if (n > 0 and s > 0 or n == s == 0) and (w > 0 and e > 0 or w == e == 0):\n print('Yes')\n else:\n print('No')",
"resolve",
"S = SS()",
"S",
"SS()",
"SS",
"cnt = collections.Counter(S)",
"cnt",
"collections.Counter(S)",
"collections.Counter",
"collections",
"Counter",
"S",
"n = cnt['N']",
"n",
"cnt['N']",
"cnt",
"'N'",
"w = cnt['W']",
"w",
"cnt['W']",
"cnt",
"'W'",
"s = cnt['S']",
"s",
"cnt['S']",
"cnt",
"'S'",
"e = cnt['E']",
"e",
"cnt['E']",
"cnt",
"'E'",
"if (n > 0 and s > 0 or n == s == 0) and (w > 0 and e > 0 or w == e == 0):\n print('Yes')\n else:\n print('No')",
"(n > 0 and s > 0 or n == s == 0) and (w > 0 and e > 0 or w == e == 0)",
"n > 0 and s > 0 or n == s == 0",
"n > 0 and s > 0",
"n > 0",
"n",
"0",
"s > 0",
"s",
"0",
"n == s == 0",
"n == s",
"n",
"s",
"0",
"w > 0 and e > 0 or w == e == 0",
"w > 0 and e > 0",
"w > 0",
"w",
"0",
"e > 0",
"e",
"0",
"w == e == 0",
"w == e",
"w",
"e",
"0",
"print('Yes')",
"print",
"'Yes'",
"print('No')",
"print",
"'No'",
"if __name__ == '__main__':\n resolve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"resolve()",
"resolve",
"def F(): return float(input())",
"def F(): return float(input())",
"F",
"def resolve():\n S = SS()\n\n cnt = collections.Counter(S)\n n = cnt['N']\n w = cnt['W']\n s = cnt['S']\n e = cnt['E']\n if (n > 0 and s > 0 or n == s == 0) and (w > 0 and e > 0 or w == e == 0):\n print('Yes')\n else:\n print('No')",
"def resolve():\n S = SS()\n\n cnt = collections.Counter(S)\n n = cnt['N']\n w = cnt['W']\n s = cnt['S']\n e = cnt['E']\n if (n > 0 and s > 0 or n == s == 0) and (w > 0 and e > 0 or w == e == 0):\n print('Yes')\n else:\n print('No')",
"resolve",
"input = lambda: sys.stdin.readline().rstrip()",
"lambda: sys.stdin.readline().rstrip()",
"input",
"def LI_(): return [int(x)-1 for x in input().split()]",
"def LI_(): return [int(x)-1 for x in input().split()]",
"LI_",
"def LI(): return [int(x) for x in input().split()]",
"def LI(): return [int(x) for x in input().split()]",
"LI",
"def LSS(): return input().split()",
"def LSS(): return input().split()",
"LSS",
"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 I(): return int(input())",
"def I(): return int(input())",
"I",
"def SS(): return input()",
"def SS(): return input()",
"SS"
] | 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()
cnt = collections.Counter(S)
n = cnt['N']
w = cnt['W']
s = cnt['S']
e = cnt['E']
if (n > 0 and s > 0 or n == s == 0) and (w > 0 and e > 0 or w == e == 0):
print('Yes')
else:
print('No')
if __name__ == '__main__':
resolve()
|
[
7,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
14,
40,
4,
13,
13,
17,
14,
2,
2,
2,
2,
2,
17,
13,
40,
17,
13,
2,
2,
17,
13,
40,
17,
13,
2,
2,
17,
13,
40,
17,
13,
2,
2,
17,
13,
40,
17,
13,
4,
13,
17,
29,
4,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
9,
8
],
[
4,
11
],
[
8,
16
],
[
8,
25
],
[
8,
28
],
[
8,
32
],
[
8,
35
],
[
8,
39
],
[
8,
42
],
[
8,
46
],
[
8,
49
],
[
61,
58
]
] | [
"def resolve():\n S = input()\n chk = set(S)\n if len(chk) != 4:\n if (\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk) or (\"W\" in chk and \"E\" not in chk):\n print(\"No\")\n return\n print(\"Yes\")\n\n\nresolve()",
"def resolve():\n S = input()\n chk = set(S)\n if len(chk) != 4:\n if (\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk) or (\"W\" in chk and \"E\" not in chk):\n print(\"No\")\n return\n print(\"Yes\")",
"resolve",
"S = input()",
"S",
"input()",
"input",
"chk = set(S)",
"chk",
"set(S)",
"set",
"S",
"if len(chk) != 4:\n if (\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk) or (\"W\" in chk and \"E\" not in chk):\n print(\"No\")\n return\n ",
"len(chk) != 4",
"len(chk)",
"len",
"chk",
"4",
"if (\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk) or (\"W\" in chk and \"E\" not in chk):\n print(\"No\")\n return\n ",
"(\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk) or (\"W\" in chk and \"E\" not in chk)",
"(\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk)",
"(\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk)",
"\"N\" in chk and \"S\" not in chk",
"\"N\" in chk",
"\"N\"",
"chk",
"\"S\" not in chk",
"\"S\"",
"chk",
"\"E\" in chk and \"W\" not in chk",
"\"E\" in chk",
"\"E\"",
"chk",
"\"W\" not in chk",
"\"W\"",
"chk",
"\"S\" in chk and \"N\" not in chk",
"\"S\" in chk",
"\"S\"",
"chk",
"\"N\" not in chk",
"\"N\"",
"chk",
"\"W\" in chk and \"E\" not in chk",
"\"W\" in chk",
"\"W\"",
"chk",
"\"E\" not in chk",
"\"E\"",
"chk",
"print(\"No\")",
"print",
"\"No\"",
"return",
"print(\"Yes\")",
"print",
"\"Yes\"",
"resolve()",
"resolve",
"def resolve():\n S = input()\n chk = set(S)\n if len(chk) != 4:\n if (\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk) or (\"W\" in chk and \"E\" not in chk):\n print(\"No\")\n return\n print(\"Yes\")",
"def resolve():\n S = input()\n chk = set(S)\n if len(chk) != 4:\n if (\"N\" in chk and \"S\" not in chk) or (\"E\" in chk and \"W\" not in chk) or (\n \"S\" in chk and \"N\" not in chk) or (\"W\" in chk and \"E\" not in chk):\n print(\"No\")\n return\n print(\"Yes\")",
"resolve"
] | def resolve():
S = input()
chk = set(S)
if len(chk) != 4:
if ("N" in chk and "S" not in chk) or ("E" in chk and "W" not in chk) or (
"S" in chk and "N" not in chk) or ("W" in chk and "E" not in chk):
print("No")
return
print("Yes")
resolve()
|
[
7,
0,
13,
4,
13,
14,
2,
40,
4,
18,
13,
13,
17,
17,
2,
4,
18,
13,
13,
17,
17,
4,
13,
17,
14,
2,
40,
4,
18,
13,
13,
17,
17,
2,
4,
18,
13,
13,
17,
17,
4,
13,
17,
14,
2,
40,
4,
18,
13,
13,
17,
17,
2,
4,
18,
13,
13,
17,
17,
4,
13,
17,
14,
2,
40,
4,
18,
13,
13,
17,
17,
2,
4,
18,
13,
13,
17,
17,
4,
13,
17,
4,
13,
17,
10,
4,
13
] | [
[
85,
2
],
[
86,
10
],
[
86,
17
],
[
86,
29
],
[
86,
36
],
[
86,
48
],
[
86,
55
],
[
86,
67
],
[
86,
74
],
[
85,
86
]
] | [
"S=input()\nif S.count(\"N\")>=1 and S.count(\"S\")==0:\n print(\"No\")\nelif S.count(\"S\")>=1 and S.count(\"N\")==0:\n print(\"No\")\nelif S.count(\"W\")>=1 and S.count(\"E\")==0:\n print(\"No\")\nelif S.count(\"E\")>=1 and S.count(\"W\")==0:\n print(\"No\")\nelse:\n print(\"Yes\")",
"S=input()",
"S",
"input()",
"input",
"if S.count(\"N\")>=1 and S.count(\"S\")==0:\n print(\"No\")\nelif S.count(\"S\")>=1 and S.count(\"N\")==0:\n print(\"No\")\nelif S.count(\"W\")>=1 and S.count(\"E\")==0:\n print(\"No\")\nelif S.count(\"E\")>=1 and S.count(\"W\")==0:\n print(\"No\")\nelse:\n print(\"Yes\")",
"S.count(\"N\")>=1 and S.count(\"S\")==0",
"S.count(\"N\")>=1",
"S.count(\"N\")",
"S.count",
"S",
"count",
"\"N\"",
"1",
"S.count(\"S\")==0",
"S.count(\"S\")",
"S.count",
"S",
"count",
"\"S\"",
"0",
"print(\"No\")",
"print",
"\"No\"",
"elif S.count(\"S\")>=1 and S.count(\"N\")==0:\n print(\"No\")",
"S.count(\"S\")>=1 and S.count(\"N\")==0",
"S.count(\"S\")>=1",
"S.count(\"S\")",
"S.count",
"S",
"count",
"\"S\"",
"1",
"S.count(\"N\")==0",
"S.count(\"N\")",
"S.count",
"S",
"count",
"\"N\"",
"0",
"print(\"No\")",
"print",
"\"No\"",
"elif S.count(\"W\")>=1 and S.count(\"E\")==0:\n print(\"No\")",
"S.count(\"W\")>=1 and S.count(\"E\")==0",
"S.count(\"W\")>=1",
"S.count(\"W\")",
"S.count",
"S",
"count",
"\"W\"",
"1",
"S.count(\"E\")==0",
"S.count(\"E\")",
"S.count",
"S",
"count",
"\"E\"",
"0",
"print(\"No\")",
"print",
"\"No\"",
"elif S.count(\"E\")>=1 and S.count(\"W\")==0:\n print(\"No\")",
"S.count(\"E\")>=1 and S.count(\"W\")==0",
"S.count(\"E\")>=1",
"S.count(\"E\")",
"S.count",
"S",
"count",
"\"E\"",
"1",
"S.count(\"W\")==0",
"S.count(\"W\")",
"S.count",
"S",
"count",
"\"W\"",
"0",
"print(\"No\")",
"print",
"\"No\"",
"print(\"Yes\")",
"print",
"\"Yes\"",
"S=input()",
"input()",
"S"
] | S=input()
if S.count("N")>=1 and S.count("S")==0:
print("No")
elif S.count("S")>=1 and S.count("N")==0:
print("No")
elif S.count("W")>=1 and S.count("E")==0:
print("No")
elif S.count("E")>=1 and S.count("W")==0:
print("No")
else:
print("Yes") |
[
7,
0,
13,
4,
13,
4,
13,
14,
2,
4,
13,
13,
17,
4,
13,
17,
14,
2,
4,
13,
13,
17,
4,
13,
17,
14,
2,
2,
2,
17,
13,
2,
17,
13,
2,
2,
17,
13,
2,
17,
13,
4,
13,
17,
4,
13,
17,
10,
4,
13
] | [
[
48,
2
],
[
49,
11
],
[
49,
20
],
[
49,
30
],
[
49,
33
],
[
49,
37
],
[
49,
40
],
[
48,
49
]
] | [
"s=set(input())\nif len(s)==4:\n print(\"Yes\")\nelif len(s)%2:\n print(\"No\")\nelse:\n if (\"N\" in s and \"S\" in s) or (\"W\"in s and \"E\" in s):\n print(\"Yes\")\n else:\n print(\"No\")",
"s=set(input())",
"s",
"set(input())",
"set",
"input()",
"input",
"if len(s)==4:\n print(\"Yes\")\nelif len(s)%2:\n print(\"No\")\nelse:\n if (\"N\" in s and \"S\" in s) or (\"W\"in s and \"E\" in s):\n print(\"Yes\")\n else:\n print(\"No\")",
"len(s)==4",
"len(s)",
"len",
"s",
"4",
"print(\"Yes\")",
"print",
"\"Yes\"",
"elif len(s)%2:\n print(\"No\")",
"len(s)%2",
"len(s)",
"len",
"s",
"2",
"print(\"No\")",
"print",
"\"No\"",
"if (\"N\" in s and \"S\" in s) or (\"W\"in s and \"E\" in s):\n print(\"Yes\")\n else:\n print(\"No\")",
"(\"N\" in s and \"S\" in s) or (\"W\"in s and \"E\" in s)",
"\"N\" in s and \"S\" in s",
"\"N\" in s",
"\"N\"",
"s",
"\"S\" in s",
"\"S\"",
"s",
"\"W\"in s and \"E\" in s",
"\"W\"in s",
"\"W\"",
"s",
"\"E\" in s",
"\"E\"",
"s",
"print(\"Yes\")",
"print",
"\"Yes\"",
"print(\"No\")",
"print",
"\"No\"",
"s=set(input())",
"set(input())",
"s"
] | s=set(input())
if len(s)==4:
print("Yes")
elif len(s)%2:
print("No")
else:
if ("N" in s and "S" in s) or ("W"in s and "E" in s):
print("Yes")
else:
print("No")
|
[
7,
0,
13,
4,
13,
0,
13,
4,
18,
13,
13,
17,
13,
4,
18,
13,
13,
17,
0,
13,
4,
18,
13,
13,
17,
13,
4,
18,
13,
13,
17,
0,
13,
17,
14,
2,
2,
13,
17,
2,
13,
17,
14,
40,
13,
13,
0,
13,
17,
14,
2,
2,
13,
17,
2,
13,
17,
14,
40,
13,
13,
0,
13,
17,
4,
13,
8,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
71,
2
],
[
74,
6
],
[
72,
9
],
[
92,
12
],
[
72,
15
],
[
83,
19
],
[
72,
22
],
[
77,
25
],
[
72,
28
],
[
80,
32
],
[
75,
37
],
[
84,
40
],
[
75,
44
],
[
84,
45
],
[
89,
47
],
[
93,
52
],
[
78,
55
],
[
93,
59
],
[
78,
60
],
[
86,
62
],
[
87,
67
],
[
90,
67
],
[
81,
67
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
]
] | [
"S = input()\nn, w = S.count('N'), S.count('W')\ns, e = S.count('S'), S.count('E')\nflag = True\nif n == 0 or s == 0:\n if n != s:\n flag = False\nif w == 0 or e == 0:\n if w != e:\n flag = False\nprint('Yes' if flag else 'No')",
"S = input()",
"S",
"input()",
"input",
"n, w = S.count('N'), S.count('W')",
"n",
"S.count('N')",
"S.count",
"S",
"count",
"'N'",
"w",
"S.count('W')",
"S.count",
"S",
"count",
"'W'",
"s, e = S.count('S'), S.count('E')",
"s",
"S.count('S')",
"S.count",
"S",
"count",
"'S'",
"e",
"S.count('E')",
"S.count",
"S",
"count",
"'E'",
"flag = True",
"flag",
"True",
"if n == 0 or s == 0:\n if n != s:\n flag = False",
"n == 0 or s == 0",
"n == 0",
"n",
"0",
"s == 0",
"s",
"0",
"if n != s:\n flag = False",
"n != s",
"n",
"s",
"flag = False",
"flag",
"False",
"if w == 0 or e == 0:\n if w != e:\n flag = False",
"w == 0 or e == 0",
"w == 0",
"w",
"0",
"e == 0",
"e",
"0",
"if w != e:\n flag = False",
"w != e",
"w",
"e",
"flag = False",
"flag",
"False",
"print('Yes' if flag else 'No')",
"print",
"'Yes' if flag else 'No'",
"flag",
"'Yes'",
"'No'",
"S = input()",
"input()",
"S",
"n, w = S.count('N'), S.count('W')",
"S.count('N')",
"n",
"e = S.count('S'), S.count('E')",
"S.count('E')",
"e",
"flag = True",
"True",
"flag",
"s, e = S.count('S'), S.count('E')",
"S.count('S')",
"s",
"flag = False",
"False",
"flag",
"flag = False",
"False",
"flag",
"w = S.count('N'), S.count('W')",
"S.count('W')",
"w"
] | S = input()
n, w = S.count('N'), S.count('W')
s, e = S.count('S'), S.count('E')
flag = True
if n == 0 or s == 0:
if n != s:
flag = False
if w == 0 or e == 0:
if w != e:
flag = False
print('Yes' if flag else 'No')
|
[
7,
12,
13,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
17,
23,
13,
23,
13,
0,
13,
17,
13,
17,
13,
17,
13,
17,
28,
13,
4,
13,
14,
2,
13,
17,
0,
13,
17,
14,
2,
13,
17,
0,
13,
17,
14,
2,
13,
17,
0,
13,
17,
0,
13,
17,
14,
2,
4,
13,
13,
13,
4,
13,
13,
13,
4,
13,
17,
4,
13,
17,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
12,
13,
10,
17,
13,
10,
17,
13
] | [
[
26,
6
],
[
28,
9
],
[
26,
16
],
[
28,
19
],
[
26,
26
],
[
28,
28
],
[
83,
30
],
[
107,
32
],
[
86,
34
],
[
95,
36
],
[
40,
39
],
[
39,
44
],
[
104,
47
],
[
39,
51
],
[
89,
54
],
[
39,
58
],
[
92,
61
],
[
98,
64
],
[
102,
69
],
[
105,
70
],
[
84,
70
],
[
93,
71
],
[
87,
71
],
[
102,
73
],
[
99,
74
],
[
96,
74
],
[
90,
75
],
[
108,
75
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
104,
105
],
[
107,
108
]
] | [
"# A - Wanna go back home\ndef can_go_home(dir1, dir2):\n\tif dir1 > 0 and dir2 > 0:\n\t\treturn True\n\telif dir1 == 0 and dir2 == 0:\n\t\treturn True\n\telse:\n\t\treturn False\n\n\nn, w, s, e = 0, 0, 0, 0\n\nfor dir in input():\n\tif dir == 'N':\n\t\tn += 1\n\telif dir == 'W':\n\t\tw += 1\n\telif dir == 'S':\n\t\ts += 1\n\telse:\n\t\te += 1\n\nif can_go_home(n, s) and can_go_home(e, w):\n\tprint('Yes')\nelse:\n\tprint('No')",
"def can_go_home(dir1, dir2):\n\tif dir1 > 0 and dir2 > 0:\n\t\treturn True\n\telif dir1 == 0 and dir2 == 0:\n\t\treturn True\n\telse:\n\t\treturn False",
"can_go_home",
"if dir1 > 0 and dir2 > 0:\n\t\treturn True\n\telif dir1 == 0 and dir2 == 0:\n\t\treturn True\n\telse:\n\t\treturn False",
"dir1 > 0 and dir2 > 0",
"dir1 > 0",
"dir1",
"0",
"dir2 > 0",
"dir2",
"0",
"return True",
"True",
"elif dir1 == 0 and dir2 == 0:\n\t\treturn True\n\t",
"dir1 == 0 and dir2 == 0",
"dir1 == 0",
"dir1",
"0",
"dir2 == 0",
"dir2",
"0",
"return True",
"True",
"return False",
"False",
"dir1",
"dir1",
"dir2",
"dir2",
"n, w, s, e = 0, 0, 0, 0",
"n",
"0",
"w",
"0",
"s",
"0",
"e",
"0",
"for dir in input():\n\tif dir == 'N':\n\t\tn += 1\n\telif dir == 'W':\n\t\tw += 1\n\telif dir == 'S':\n\t\ts += 1\n\telse:\n\t\te += 1",
"dir",
"input()",
"input",
"if dir == 'N':\n\t\tn += 1\n\telif dir == 'W':\n\t\tw += 1\n\telif dir == 'S':\n\t\ts += 1\n\telse:\n\t\te += 1",
"dir == 'N'",
"dir",
"'N'",
"n += 1",
"n",
"1",
"elif dir == 'W':\n\t\tw += 1\n\t",
"dir == 'W'",
"dir",
"'W'",
"w += 1",
"w",
"1",
"elif dir == 'S':\n\t\ts += 1\n\t",
"dir == 'S'",
"dir",
"'S'",
"s += 1",
"s",
"1",
"e += 1",
"e",
"1",
"if can_go_home(n, s) and can_go_home(e, w):\n\tprint('Yes')\nelse:\n\tprint('No')",
"can_go_home(n, s) and can_go_home(e, w)",
"can_go_home(n, s)",
"can_go_home",
"n",
"s",
"can_go_home(e, w)",
"can_go_home",
"e",
"w",
"print('Yes')",
"print",
"'Yes'",
"print('No')",
"print",
"'No'",
"n, w, s, e = 0, 0, 0, 0",
"0",
"n",
"s, e = 0, 0, 0, 0",
"0",
"s",
"w += 1",
"1",
"w",
"s += 1",
"1",
"s",
"e = 0, 0, 0, 0",
"0",
"e",
"e += 1",
"1",
"e",
"def can_go_home(dir1, dir2):\n\tif dir1 > 0 and dir2 > 0:\n\t\treturn True\n\telif dir1 == 0 and dir2 == 0:\n\t\treturn True\n\telse:\n\t\treturn False",
"def can_go_home(dir1, dir2):\n\tif dir1 > 0 and dir2 > 0:\n\t\treturn True\n\telif dir1 == 0 and dir2 == 0:\n\t\treturn True\n\telse:\n\t\treturn False",
"can_go_home",
"n += 1",
"1",
"n",
"w, s, e = 0, 0, 0, 0",
"0",
"w"
] | # A - Wanna go back home
def can_go_home(dir1, dir2):
if dir1 > 0 and dir2 > 0:
return True
elif dir1 == 0 and dir2 == 0:
return True
else:
return False
n, w, s, e = 0, 0, 0, 0
for dir in input():
if dir == 'N':
n += 1
elif dir == 'W':
w += 1
elif dir == 'S':
s += 1
else:
e += 1
if can_go_home(n, s) and can_go_home(e, w):
print('Yes')
else:
print('No') |
[
7,
0,
13,
4,
13,
0,
13,
17,
14,
40,
4,
18,
13,
13,
17,
17,
14,
2,
4,
18,
13,
13,
17,
17,
0,
13,
17,
14,
40,
4,
18,
13,
13,
17,
17,
14,
2,
4,
18,
13,
13,
17,
17,
0,
13,
17,
14,
40,
4,
18,
13,
13,
17,
17,
14,
2,
4,
18,
13,
13,
17,
17,
0,
13,
17,
14,
40,
4,
18,
13,
13,
17,
17,
14,
2,
4,
18,
13,
13,
17,
17,
0,
13,
17,
14,
13,
4,
13,
17,
4,
13,
17,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13
] | [
[
93,
2
],
[
99,
6
],
[
94,
12
],
[
94,
20
],
[
108,
25
],
[
94,
31
],
[
94,
39
],
[
96,
44
],
[
94,
50
],
[
94,
58
],
[
102,
63
],
[
94,
69
],
[
94,
77
],
[
105,
82
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
]
] | [
"s = input()\nok = True\nif s.count(\"N\") >= 1:\n if s.count(\"S\") == 0:\n ok = False\nif s.count(\"S\") >= 1:\n if s.count(\"N\") == 0:\n ok = False\n\nif s.count(\"E\") >= 1:\n if s.count(\"W\") == 0:\n ok = False\n\nif s.count(\"W\") >= 1:\n if s.count(\"E\") == 0:\n ok = False\nif ok:\n print(\"Yes\")\nelse:\n print(\"No\")",
"s = input()",
"s",
"input()",
"input",
"ok = True",
"ok",
"True",
"if s.count(\"N\") >= 1:\n if s.count(\"S\") == 0:\n ok = False",
"s.count(\"N\") >= 1",
"s.count(\"N\")",
"s.count",
"s",
"count",
"\"N\"",
"1",
"if s.count(\"S\") == 0:\n ok = False",
"s.count(\"S\") == 0",
"s.count(\"S\")",
"s.count",
"s",
"count",
"\"S\"",
"0",
"ok = False",
"ok",
"False",
"if s.count(\"S\") >= 1:\n if s.count(\"N\") == 0:\n ok = False",
"s.count(\"S\") >= 1",
"s.count(\"S\")",
"s.count",
"s",
"count",
"\"S\"",
"1",
"if s.count(\"N\") == 0:\n ok = False",
"s.count(\"N\") == 0",
"s.count(\"N\")",
"s.count",
"s",
"count",
"\"N\"",
"0",
"ok = False",
"ok",
"False",
"if s.count(\"E\") >= 1:\n if s.count(\"W\") == 0:\n ok = False",
"s.count(\"E\") >= 1",
"s.count(\"E\")",
"s.count",
"s",
"count",
"\"E\"",
"1",
"if s.count(\"W\") == 0:\n ok = False",
"s.count(\"W\") == 0",
"s.count(\"W\")",
"s.count",
"s",
"count",
"\"W\"",
"0",
"ok = False",
"ok",
"False",
"if s.count(\"W\") >= 1:\n if s.count(\"E\") == 0:\n ok = False",
"s.count(\"W\") >= 1",
"s.count(\"W\")",
"s.count",
"s",
"count",
"\"W\"",
"1",
"if s.count(\"E\") == 0:\n ok = False",
"s.count(\"E\") == 0",
"s.count(\"E\")",
"s.count",
"s",
"count",
"\"E\"",
"0",
"ok = False",
"ok",
"False",
"if ok:\n print(\"Yes\")\nelse:\n print(\"No\")",
"ok",
"print(\"Yes\")",
"print",
"\"Yes\"",
"print(\"No\")",
"print",
"\"No\"",
"s = input()",
"input()",
"s",
"ok = False",
"False",
"ok",
"ok = True",
"True",
"ok",
"ok = False",
"False",
"ok",
"ok = False",
"False",
"ok",
"ok = False",
"False",
"ok"
] | s = input()
ok = True
if s.count("N") >= 1:
if s.count("S") == 0:
ok = False
if s.count("S") >= 1:
if s.count("N") == 0:
ok = False
if s.count("E") >= 1:
if s.count("W") == 0:
ok = False
if s.count("W") >= 1:
if s.count("E") == 0:
ok = False
if ok:
print("Yes")
else:
print("No") |
[
7,
17,
12,
13,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
18,
4,
13,
39,
17,
0,
13,
4,
13,
4,
13,
13,
14,
2,
4,
13,
13,
17,
4,
13,
17,
14,
2,
2,
4,
13,
13,
17,
2,
4,
13,
13,
17,
4,
13,
17,
14,
2,
2,
2,
17,
13,
2,
17,
13,
2,
2,
17,
13,
2,
17,
13,
4,
13,
17,
4,
13,
17,
29,
4,
13,
10,
12,
13
] | [
[
8,
7
],
[
15,
14
],
[
22,
21
],
[
29,
28
],
[
7,
31
],
[
36,
35
],
[
28,
40
],
[
35,
45
],
[
35,
55
],
[
35,
60
],
[
28,
70
],
[
28,
73
],
[
28,
77
],
[
28,
80
],
[
92,
89
]
] | [
"'''\nCreated on 2020/08/19\n\n@author: harurun\n'''\ndef main():\n import sys\n pin=sys.stdin.readline\n pout=sys.stdout.write\n perr=sys.stderr.write\n \n S=pin()[:-1]\n T=list(set(S))\n if len(T)==4:\n print(\"Yes\")\n elif len(T)==3 or len(T)==1:\n print(\"No\")\n else:\n if ((\"N\" in S )and (\"S\" in S)) or ((\"W\" in S) and (\"E\" in S)):\n print(\"Yes\")\n else:\n print(\"No\")\n return \n\nmain()",
"'''\nCreated on 2020/08/19\n\n@author: harurun\n'''",
"def main():\n import sys\n pin=sys.stdin.readline\n pout=sys.stdout.write\n perr=sys.stderr.write\n \n S=pin()[:-1]\n T=list(set(S))\n if len(T)==4:\n print(\"Yes\")\n elif len(T)==3 or len(T)==1:\n print(\"No\")\n else:\n if ((\"N\" in S )and (\"S\" in S)) or ((\"W\" in S) and (\"E\" in S)):\n print(\"Yes\")\n else:\n print(\"No\")\n return ",
"main",
"import sys",
"sys",
"pin=sys.stdin.readline",
"pin",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"pout=sys.stdout.write",
"pout",
"sys.stdout.write",
"sys.stdout",
"sys",
"stdout",
"write",
"perr=sys.stderr.write",
"perr",
"sys.stderr.write",
"sys.stderr",
"sys",
"stderr",
"write",
"S=pin()[:-1]",
"S",
"pin()[:-1]",
"()",
"pin",
":-1",
"-1",
"T=list(set(S))",
"T",
"list(set(S))",
"list",
"set(S)",
"set",
"S",
"if len(T)==4:\n print(\"Yes\")\n elif len(T)==3 or len(T)==1:\n print(\"No\")\n else:\n if ((\"N\" in S )and (\"S\" in S)) or ((\"W\" in S) and (\"E\" in S)):\n print(\"Yes\")\n else:\n print(\"No\")\n ",
"len(T)==4",
"len(T)",
"len",
"T",
"4",
"print(\"Yes\")",
"print",
"\"Yes\"",
"elif len(T)==3 or len(T)==1:\n print(\"No\")\n ",
"len(T)==3 or len(T)==1",
"len(T)==3",
"len(T)",
"len",
"T",
"3",
"len(T)==1",
"len(T)",
"len",
"T",
"1",
"print(\"No\")",
"print",
"\"No\"",
"if ((\"N\" in S )and (\"S\" in S)) or ((\"W\" in S) and (\"E\" in S)):\n print(\"Yes\")\n else:\n print(\"No\")\n ",
"((\"N\" in S )and (\"S\" in S)) or ((\"W\" in S) and (\"E\" in S))",
"(\"N\" in S )and (\"S\" in S)",
"\"N\" in S",
"\"N\"",
"S",
"\"S\" in S",
"\"S\"",
"S",
"(\"W\" in S) and (\"E\" in S)",
"\"W\" in S",
"\"W\"",
"S",
"\"E\" in S",
"\"E\"",
"S",
"print(\"Yes\")",
"print",
"\"Yes\"",
"print(\"No\")",
"print",
"\"No\"",
"return",
"main()",
"main",
"def main():\n import sys\n pin=sys.stdin.readline\n pout=sys.stdout.write\n perr=sys.stderr.write\n \n S=pin()[:-1]\n T=list(set(S))\n if len(T)==4:\n print(\"Yes\")\n elif len(T)==3 or len(T)==1:\n print(\"No\")\n else:\n if ((\"N\" in S )and (\"S\" in S)) or ((\"W\" in S) and (\"E\" in S)):\n print(\"Yes\")\n else:\n print(\"No\")\n return ",
"def main():\n import sys\n pin=sys.stdin.readline\n pout=sys.stdout.write\n perr=sys.stderr.write\n \n S=pin()[:-1]\n T=list(set(S))\n if len(T)==4:\n print(\"Yes\")\n elif len(T)==3 or len(T)==1:\n print(\"No\")\n else:\n if ((\"N\" in S )and (\"S\" in S)) or ((\"W\" in S) and (\"E\" in S)):\n print(\"Yes\")\n else:\n print(\"No\")\n return ",
"main"
] | '''
Created on 2020/08/19
@author: harurun
'''
def main():
import sys
pin=sys.stdin.readline
pout=sys.stdout.write
perr=sys.stderr.write
S=pin()[:-1]
T=list(set(S))
if len(T)==4:
print("Yes")
elif len(T)==3 or len(T)==1:
print("No")
else:
if (("N" in S )and ("S" in S)) or (("W" in S) and ("E" in S)):
print("Yes")
else:
print("No")
return
main() |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
0,
13,
8,
13,
17,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
12,
13
] | [
[
82,
4
],
[
14,
13
],
[
83,
17
],
[
21,
20
],
[
13,
25
],
[
13,
29
],
[
32,
31
],
[
13,
36
],
[
13,
40
],
[
43,
42
],
[
13,
47
],
[
13,
51
],
[
54,
53
],
[
13,
58
],
[
13,
62
],
[
65,
64
],
[
68,
67
],
[
64,
69
],
[
53,
69
],
[
42,
69
],
[
31,
69
],
[
20,
69
],
[
67,
74
],
[
86,
80
],
[
82,
83
]
] | [
"import sys\n\ninput = sys.stdin.readline\n\n\ndef main():\n S = input().rstrip()\n\n go_back_home = True\n if \"N\" in S:\n if \"S\" not in S:\n go_back_home = False\n if \"S\" in S:\n if \"N\" not in S:\n go_back_home = False\n if \"W\" in S:\n if \"E\" not in S:\n go_back_home = False\n if \"E\" in S:\n if \"W\" not in S:\n go_back_home = False\n\n ans = \"Yes\" if go_back_home else \"No\"\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def main():\n S = input().rstrip()\n\n go_back_home = True\n if \"N\" in S:\n if \"S\" not in S:\n go_back_home = False\n if \"S\" in S:\n if \"N\" not in S:\n go_back_home = False\n if \"W\" in S:\n if \"E\" not in S:\n go_back_home = False\n if \"E\" in S:\n if \"W\" not in S:\n go_back_home = False\n\n ans = \"Yes\" if go_back_home else \"No\"\n print(ans)",
"main",
"S = input().rstrip()",
"S",
"input().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"go_back_home = True",
"go_back_home",
"True",
"if \"N\" in S:\n if \"S\" not in S:\n go_back_home = False\n ",
"\"N\" in S",
"\"N\"",
"S",
"if \"S\" not in S:\n go_back_home = False\n ",
"\"S\" not in S",
"\"S\"",
"S",
"go_back_home = False",
"go_back_home",
"False",
"if \"S\" in S:\n if \"N\" not in S:\n go_back_home = False\n ",
"\"S\" in S",
"\"S\"",
"S",
"if \"N\" not in S:\n go_back_home = False\n ",
"\"N\" not in S",
"\"N\"",
"S",
"go_back_home = False",
"go_back_home",
"False",
"if \"W\" in S:\n if \"E\" not in S:\n go_back_home = False\n ",
"\"W\" in S",
"\"W\"",
"S",
"if \"E\" not in S:\n go_back_home = False\n ",
"\"E\" not in S",
"\"E\"",
"S",
"go_back_home = False",
"go_back_home",
"False",
"if \"E\" in S:\n if \"W\" not in S:\n go_back_home = False\n\n ",
"\"E\" in S",
"\"E\"",
"S",
"if \"W\" not in S:\n go_back_home = False\n\n ",
"\"W\" not in S",
"\"W\"",
"S",
"go_back_home = False",
"go_back_home",
"False",
"ans = \"Yes\" if go_back_home else \"No\"",
"ans",
"\"Yes\" if go_back_home else \"No\"",
"go_back_home",
"\"Yes\"",
"\"No\"",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"def main():\n S = input().rstrip()\n\n go_back_home = True\n if \"N\" in S:\n if \"S\" not in S:\n go_back_home = False\n if \"S\" in S:\n if \"N\" not in S:\n go_back_home = False\n if \"W\" in S:\n if \"E\" not in S:\n go_back_home = False\n if \"E\" in S:\n if \"W\" not in S:\n go_back_home = False\n\n ans = \"Yes\" if go_back_home else \"No\"\n print(ans)",
"def main():\n S = input().rstrip()\n\n go_back_home = True\n if \"N\" in S:\n if \"S\" not in S:\n go_back_home = False\n if \"S\" in S:\n if \"N\" not in S:\n go_back_home = False\n if \"W\" in S:\n if \"E\" not in S:\n go_back_home = False\n if \"E\" in S:\n if \"W\" not in S:\n go_back_home = False\n\n ans = \"Yes\" if go_back_home else \"No\"\n print(ans)",
"main"
] | import sys
input = sys.stdin.readline
def main():
S = input().rstrip()
go_back_home = True
if "N" in S:
if "S" not in S:
go_back_home = False
if "S" in S:
if "N" not in S:
go_back_home = False
if "W" in S:
if "E" not in S:
go_back_home = False
if "E" in S:
if "W" not in S:
go_back_home = False
ans = "Yes" if go_back_home else "No"
print(ans)
if __name__ == "__main__":
main()
|
[
7,
15,
13,
0,
13,
4,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
17,
14,
2,
18,
13,
17,
17,
14,
2,
18,
13,
17,
17,
0,
13,
17,
14,
2,
18,
13,
17,
17,
14,
2,
18,
13,
17,
17,
0,
13,
17,
14,
2,
18,
13,
17,
17,
14,
2,
18,
13,
17,
17,
0,
13,
17,
14,
2,
18,
13,
17,
17,
14,
2,
18,
13,
17,
17,
0,
13,
17,
14,
13,
4,
13,
17,
4,
13,
17,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] | [
[
98,
4
],
[
92,
8
],
[
99,
13
],
[
104,
15
],
[
93,
20
],
[
93,
26
],
[
101,
30
],
[
93,
35
],
[
93,
41
],
[
95,
45
],
[
93,
50
],
[
93,
56
],
[
89,
60
],
[
93,
65
],
[
93,
71
],
[
86,
75
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
]
] | [
"import collections\n\ns=input()\na=collections.Counter(s)\nf=True\n\nif a['N']>0:\n\tif a['S']==0:\n\t\tf=False\n\t\t\nif a['S']>0:\n\tif a['N']==0:\n\t\tf=False\n\t\t\nif a['W']>0:\n\tif a['E']==0:\n\t\tf=False\n\t\t\nif a['E']>0:\n\tif a['W']==0:\n\t\tf=False\n\t\t\nif f:\n\tprint('Yes')\nelse:\n\tprint('No')",
"import collections",
"collections",
"s=input()",
"s",
"input()",
"input",
"a=collections.Counter(s)",
"a",
"collections.Counter(s)",
"collections.Counter",
"collections",
"Counter",
"s",
"f=True",
"f",
"True",
"if a['N']>0:\n\tif a['S']==0:\n\t\tf=False\n\t\t",
"a['N']>0",
"a['N']",
"a",
"'N'",
"0",
"if a['S']==0:\n\t\tf=False\n\t\t",
"a['S']==0",
"a['S']",
"a",
"'S'",
"0",
"f=False",
"f",
"False",
"if a['S']>0:\n\tif a['N']==0:\n\t\tf=False\n\t\t",
"a['S']>0",
"a['S']",
"a",
"'S'",
"0",
"if a['N']==0:\n\t\tf=False\n\t\t",
"a['N']==0",
"a['N']",
"a",
"'N'",
"0",
"f=False",
"f",
"False",
"if a['W']>0:\n\tif a['E']==0:\n\t\tf=False\n\t\t",
"a['W']>0",
"a['W']",
"a",
"'W'",
"0",
"if a['E']==0:\n\t\tf=False\n\t\t",
"a['E']==0",
"a['E']",
"a",
"'E'",
"0",
"f=False",
"f",
"False",
"if a['E']>0:\n\tif a['W']==0:\n\t\tf=False\n\t\t",
"a['E']>0",
"a['E']",
"a",
"'E'",
"0",
"if a['W']==0:\n\t\tf=False\n\t\t",
"a['W']==0",
"a['W']",
"a",
"'W'",
"0",
"f=False",
"f",
"False",
"if f:\n\tprint('Yes')\nelse:\n\tprint('No')",
"f",
"print('Yes')",
"print",
"'Yes'",
"print('No')",
"print",
"'No'",
"f=False",
"False",
"f",
"f=False",
"False",
"f",
"a=collections.Counter(s)",
"collections.Counter(s)",
"a",
"f=False",
"False",
"f",
"s=input()",
"input()",
"s",
"f=False",
"False",
"f",
"f=True",
"True",
"f"
] | import collections
s=input()
a=collections.Counter(s)
f=True
if a['N']>0:
if a['S']==0:
f=False
if a['S']>0:
if a['N']==0:
f=False
if a['W']>0:
if a['E']==0:
f=False
if a['E']>0:
if a['W']==0:
f=False
if f:
print('Yes')
else:
print('No') |
[
7,
0,
13,
4,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
14,
2,
17,
13,
14,
40,
17,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] | [
[
68,
2
],
[
62,
6
],
[
69,
11
],
[
69,
15
],
[
65,
17
],
[
69,
22
],
[
69,
26
],
[
56,
28
],
[
69,
33
],
[
69,
37
],
[
71,
39
],
[
69,
44
],
[
69,
48
],
[
59,
50
],
[
60,
54
],
[
72,
54
],
[
57,
54
],
[
66,
54
],
[
63,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
]
] | [
"S = input()\nres = \"Yes\"\nif \"N\" in S:\n if \"S\" not in S:\n res = \"No\"\nif \"W\" in S:\n if \"E\" not in S:\n res = \"No\"\nif \"S\" in S:\n if \"N\" not in S:\n res = \"No\"\nif \"E\" in S:\n if \"W\" not in S:\n res = \"No\"\nprint(res)",
"S = input()",
"S",
"input()",
"input",
"res = \"Yes\"",
"res",
"\"Yes\"",
"if \"N\" in S:\n if \"S\" not in S:\n res = \"No\"",
"\"N\" in S",
"\"N\"",
"S",
"if \"S\" not in S:\n res = \"No\"",
"\"S\" not in S",
"\"S\"",
"S",
"res = \"No\"",
"res",
"\"No\"",
"if \"W\" in S:\n if \"E\" not in S:\n res = \"No\"",
"\"W\" in S",
"\"W\"",
"S",
"if \"E\" not in S:\n res = \"No\"",
"\"E\" not in S",
"\"E\"",
"S",
"res = \"No\"",
"res",
"\"No\"",
"if \"S\" in S:\n if \"N\" not in S:\n res = \"No\"",
"\"S\" in S",
"\"S\"",
"S",
"if \"N\" not in S:\n res = \"No\"",
"\"N\" not in S",
"\"N\"",
"S",
"res = \"No\"",
"res",
"\"No\"",
"if \"E\" in S:\n if \"W\" not in S:\n res = \"No\"",
"\"E\" in S",
"\"E\"",
"S",
"if \"W\" not in S:\n res = \"No\"",
"\"W\" not in S",
"\"W\"",
"S",
"res = \"No\"",
"res",
"\"No\"",
"print(res)",
"print",
"res",
"res = \"No\"",
"\"No\"",
"res",
"res = \"No\"",
"\"No\"",
"res",
"res = \"Yes\"",
"\"Yes\"",
"res",
"res = \"No\"",
"\"No\"",
"res",
"S = input()",
"input()",
"S",
"res = \"No\"",
"\"No\"",
"res"
] | S = input()
res = "Yes"
if "N" in S:
if "S" not in S:
res = "No"
if "W" in S:
if "E" not in S:
res = "No"
if "S" in S:
if "N" not in S:
res = "No"
if "E" in S:
if "W" not in S:
res = "No"
print(res) |
[
7,
0,
13,
4,
13,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
13,
14,
2,
13,
17,
14,
2,
13,
17,
14,
2,
13,
17,
14,
2,
13,
17,
14,
2,
2,
2,
2,
17,
13,
2,
17,
13,
2,
2,
13,
17,
2,
13,
17,
2,
2,
2,
17,
13,
2,
17,
13,
2,
2,
13,
17,
2,
13,
17,
4,
13,
17,
4,
13,
17,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] | [
[
81,
2
],
[
75,
6
],
[
78,
9
],
[
84,
12
],
[
87,
15
],
[
19,
18
],
[
82,
18
],
[
18,
22
],
[
18,
26
],
[
18,
30
],
[
18,
34
],
[
76,
42
],
[
88,
45
],
[
76,
48
],
[
88,
51
],
[
79,
57
],
[
85,
60
],
[
79,
63
],
[
85,
66
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
]
] | [
"S = input()\n\nn = 0\ne = 0\nw = 0\ns = 0\n\nfor v in S:\n if v == 'N': n+=1\n if v == 'E': e+=1\n if v == 'W': w+=1\n if v == 'S': s+=1\nif ((0<n and 0<s) or (n==0 and s==0)) and ((0<e and 0<w) or (e==0 and w==0)):\n print('Yes')\nelse:\n print('No')",
"S = input()",
"S",
"input()",
"input",
"n = 0",
"n",
"0",
"e = 0",
"e",
"0",
"w = 0",
"w",
"0",
"s = 0",
"s",
"0",
"for v in S:\n if v == 'N': n+=1\n if v == 'E': e+=1\n if v == 'W': w+=1\n if v == 'S': s+=1",
"v",
"S",
"if v == 'N': n+=1\n ",
"v == 'N'",
"v",
"'N'",
"if v == 'E': e+=1\n ",
"v == 'E'",
"v",
"'E'",
"if v == 'W': w+=1\n ",
"v == 'W'",
"v",
"'W'",
"if v == 'S': ",
"v == 'S'",
"v",
"'S'",
"if ((0<n and 0<s) or (n==0 and s==0)) and ((0<e and 0<w) or (e==0 and w==0)):\n print('Yes')\nelse:\n print('No')",
"((0<n and 0<s) or (n==0 and s==0)) and ((0<e and 0<w) or (e==0 and w==0))",
"(0<n and 0<s) or (n==0 and s==0)",
"0<n and 0<s",
"0<n",
"0",
"n",
"0<s",
"0",
"s",
"n==0 and s==0",
"n==0",
"n",
"0",
"s==0",
"s",
"0",
"(0<e and 0<w) or (e==0 and w==0)",
"0<e and 0<w",
"0<e",
"0",
"e",
"0<w",
"0",
"w",
"e==0 and w==0",
"e==0",
"e",
"0",
"w==0",
"w",
"0",
"print('Yes')",
"print",
"'Yes'",
"print('No')",
"print",
"'No'",
"n = 0",
"0",
"n",
"e = 0",
"0",
"e",
"S = input()",
"input()",
"S",
"w = 0",
"0",
"w",
"s = 0",
"0",
"s"
] | S = input()
n = 0
e = 0
w = 0
s = 0
for v in S:
if v == 'N': n+=1
if v == 'E': e+=1
if v == 'W': w+=1
if v == 'S': s+=1
if ((0<n and 0<s) or (n==0 and s==0)) and ((0<e and 0<w) or (e==0 and w==0)):
print('Yes')
else:
print('No') |
[
7,
0,
13,
4,
13,
0,
13,
2,
2,
2,
17,
13,
2,
17,
13,
2,
40,
17,
13,
40,
17,
13,
0,
13,
2,
2,
2,
17,
13,
2,
17,
13,
2,
40,
17,
13,
40,
17,
13,
4,
13,
8,
2,
13,
13,
17,
17,
10,
2,
13,
10,
2,
13,
10,
4,
13
] | [
[
54,
2
],
[
48,
6
],
[
55,
11
],
[
55,
14
],
[
55,
18
],
[
55,
21
],
[
51,
23
],
[
55,
28
],
[
55,
31
],
[
55,
35
],
[
55,
38
],
[
49,
43
],
[
52,
44
],
[
48,
49
],
[
51,
52
],
[
54,
55
]
] | [
"s = input()\n\nans1 = ((\"S\" in s) and (\"N\" in s)) or ((\"S\" not in s) and (\"N\" not in s))\nans2 = ((\"E\" in s) and (\"W\" in s)) or ((\"E\" not in s) and (\"W\" not in s))\n\nprint(\"Yes\" if ans1 and ans2 else \"No\")",
"s = input()",
"s",
"input()",
"input",
"ans1 = ((\"S\" in s) and (\"N\" in s)) or ((\"S\" not in s) and (\"N\" not in s))",
"ans1",
"((\"S\" in s) and (\"N\" in s)) or ((\"S\" not in s) and (\"N\" not in s))",
"(\"S\" in s) and (\"N\" in s)",
"\"S\" in s",
"\"S\"",
"s",
"\"N\" in s",
"\"N\"",
"s",
"(\"S\" not in s) and (\"N\" not in s)",
"\"S\" not in s",
"\"S\"",
"s",
"\"N\" not in s",
"\"N\"",
"s",
"ans2 = ((\"E\" in s) and (\"W\" in s)) or ((\"E\" not in s) and (\"W\" not in s))",
"ans2",
"((\"E\" in s) and (\"W\" in s)) or ((\"E\" not in s) and (\"W\" not in s))",
"(\"E\" in s) and (\"W\" in s)",
"\"E\" in s",
"\"E\"",
"s",
"\"W\" in s",
"\"W\"",
"s",
"(\"E\" not in s) and (\"W\" not in s)",
"\"E\" not in s",
"\"E\"",
"s",
"\"W\" not in s",
"\"W\"",
"s",
"print(\"Yes\" if ans1 and ans2 else \"No\")",
"print",
"\"Yes\" if ans1 and ans2 else \"No\"",
"ans1 and ans2",
"ans1",
"ans2",
"\"Yes\"",
"\"No\"",
"ans1 = ((\"S\" in s) and (\"N\" in s)) or ((\"S\" not in s) and (\"N\" not in s))",
"((\"S\" in s) and (\"N\" in s)) or ((\"S\" not in s) and (\"N\" not in s))",
"ans1",
"ans2 = ((\"E\" in s) and (\"W\" in s)) or ((\"E\" not in s) and (\"W\" not in s))",
"((\"E\" in s) and (\"W\" in s)) or ((\"E\" not in s) and (\"W\" not in s))",
"ans2",
"s = input()",
"input()",
"s"
] | s = input()
ans1 = (("S" in s) and ("N" in s)) or (("S" not in s) and ("N" not in s))
ans2 = (("E" in s) and ("W" in s)) or (("E" not in s) and ("W" not in s))
print("Yes" if ans1 and ans2 else "No") |
[
7,
0,
13,
4,
13,
0,
13,
2,
17,
13,
0,
13,
2,
17,
13,
0,
13,
2,
17,
13,
0,
13,
2,
17,
13,
0,
13,
2,
2,
13,
13,
2,
40,
13,
40,
13,
0,
13,
2,
2,
13,
13,
2,
40,
13,
40,
13,
14,
2,
13,
13,
4,
13,
17,
4,
13,
17,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
70,
2
],
[
73,
6
],
[
71,
9
],
[
58,
11
],
[
71,
14
],
[
61,
16
],
[
71,
19
],
[
76,
21
],
[
71,
24
],
[
64,
26
],
[
74,
29
],
[
59,
30
],
[
74,
33
],
[
59,
35
],
[
67,
37
],
[
62,
40
],
[
77,
41
],
[
62,
44
],
[
77,
46
],
[
65,
49
],
[
68,
50
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
]
] | [
"S = input()\nhas_N = \"N\" in S\nhas_S = \"S\" in S\nhas_E = \"E\" in S\nhas_W = \"W\" in S\nreachable_NS = has_N and has_S or not has_N and not has_S\nreachable_SW = has_E and has_W or not has_E and not has_W\nif reachable_NS and reachable_SW:\n print(\"Yes\")\nelse:\n print(\"No\")",
"S = input()",
"S",
"input()",
"input",
"has_N = \"N\" in S",
"has_N",
"\"N\" in S",
"\"N\"",
"S",
"has_S = \"S\" in S",
"has_S",
"\"S\" in S",
"\"S\"",
"S",
"has_E = \"E\" in S",
"has_E",
"\"E\" in S",
"\"E\"",
"S",
"has_W = \"W\" in S",
"has_W",
"\"W\" in S",
"\"W\"",
"S",
"reachable_NS = has_N and has_S or not has_N and not has_S",
"reachable_NS",
"has_N and has_S or not has_N and not has_S",
"has_N and has_S",
"has_N",
"has_S",
"not has_N and not has_S",
"not has_N",
"has_N",
"not has_S",
"has_S",
"reachable_SW = has_E and has_W or not has_E and not has_W",
"reachable_SW",
"has_E and has_W or not has_E and not has_W",
"has_E and has_W",
"has_E",
"has_W",
"not has_E and not has_W",
"not has_E",
"has_E",
"not has_W",
"has_W",
"if reachable_NS and reachable_SW:\n print(\"Yes\")\nelse:\n print(\"No\")",
"reachable_NS and reachable_SW",
"reachable_NS",
"reachable_SW",
"print(\"Yes\")",
"print",
"\"Yes\"",
"print(\"No\")",
"print",
"\"No\"",
"has_S = \"S\" in S",
"\"S\" in S",
"has_S",
"has_E = \"E\" in S",
"\"E\" in S",
"has_E",
"reachable_NS = has_N and has_S or not has_N and not has_S",
"has_N and has_S or not has_N and not has_S",
"reachable_NS",
"reachable_SW = has_E and has_W or not has_E and not has_W",
"has_E and has_W or not has_E and not has_W",
"reachable_SW",
"S = input()",
"input()",
"S",
"has_N = \"N\" in S",
"\"N\" in S",
"has_N",
"has_W = \"W\" in S",
"\"W\" in S",
"has_W"
] | S = input()
has_N = "N" in S
has_S = "S" in S
has_E = "E" in S
has_W = "W" in S
reachable_NS = has_N and has_S or not has_N and not has_S
reachable_SW = has_E and has_W or not has_E and not has_W
if reachable_NS and reachable_SW:
print("Yes")
else:
print("No")
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
39,
17,
17,
39,
17,
17,
39,
17,
17,
17,
17,
4,
13,
8,
2,
13,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
38,
2
],
[
44,
6
],
[
39,
9
],
[
41,
11
],
[
45,
14
],
[
39,
14
],
[
47,
16
],
[
42,
33
],
[
45,
33
],
[
39,
33
],
[
48,
34
],
[
38,
39
],
[
41,
42
],
[
44,
45
],
[
47,
48
]
] | [
"s=input()\ns=set(s)\ns=sorted(s)\nans=[['E','W'],['N','S'],['E','N','S','W']]\nprint(\"Yes\" if s in ans else \"No\")",
"s=input()",
"s",
"input()",
"input",
"s=set(s)",
"s",
"set(s)",
"set",
"s",
"s=sorted(s)",
"s",
"sorted(s)",
"sorted",
"s",
"ans=[['E','W'],['N','S'],['E','N','S','W']]",
"ans",
"[['E','W'],['N','S'],['E','N','S','W']]",
"['E','W']",
"'E'",
"'W'",
"['N','S']",
"'N'",
"'S'",
"['E','N','S','W']",
"'E'",
"'N'",
"'S'",
"'W'",
"print(\"Yes\" if s in ans else \"No\")",
"print",
"\"Yes\" if s in ans else \"No\"",
"s in ans",
"s",
"ans",
"\"Yes\"",
"\"No\"",
"s=input()",
"input()",
"s",
"s=sorted(s)",
"sorted(s)",
"s",
"s=set(s)",
"set(s)",
"s",
"ans=[['E','W'],['N','S'],['E','N','S','W']]",
"[['E','W'],['N','S'],['E','N','S','W']]",
"ans"
] | s=input()
s=set(s)
s=sorted(s)
ans=[['E','W'],['N','S'],['E','N','S','W']]
print("Yes" if s in ans else "No") |
[
7,
15,
15,
15,
15,
15,
15,
13,
15,
13,
4,
18,
13,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
0,
13,
4,
13,
0,
13,
4,
18,
13,
13,
17,
0,
13,
4,
18,
13,
13,
17,
0,
13,
4,
18,
13,
13,
17,
0,
13,
4,
18,
13,
13,
17,
14,
13,
14,
13,
4,
13,
17,
4,
13,
14,
13,
14,
13,
4,
13,
17,
4,
13,
14,
13,
14,
13,
4,
13,
17,
4,
13,
14,
13,
14,
13,
4,
13,
17,
4,
13,
4,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13
] | [
[
121,
16
],
[
39,
38
],
[
43,
42
],
[
38,
45
],
[
50,
49
],
[
38,
52
],
[
57,
56
],
[
38,
59
],
[
64,
63
],
[
38,
66
],
[
116,
113
],
[
121,
122
]
] | [
"from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]\nfrom fractions import gcd\nfrom itertools import combinations # (string,3) 3回\nfrom collections import deque\nfrom collections import defaultdict\nimport bisect\n#\n# d = m - k[i] - k[j]\n# if kk[bisect.bisect_right(kk,d) - 1] == d:\n#\n#\n#\n# pythonで無理なときは、pypyでやると正解するかも！！\n#\n#\n\nimport sys\nsys.setrecursionlimit(10000000)\nmod = 10**9 + 7\n\ndef readInts():\n return list(map(int,input().split()))\ndef main():\n s = input()\n N = s.count('N')\n W = s.count('W')\n S = s.count('S')\n E = s.count('E')\n if N:\n if S:\n pass\n else:\n print('No')\n exit()\n if S:\n if N:\n pass\n else:\n print('No')\n exit()\n if W:\n if E:\n pass\n else:\n print('No')\n exit()\n if E:\n if W:\n pass\n else:\n print('No')\n exit()\n print('Yes')\nif __name__ == '__main__':\n main()",
"from statistics import median",
"from fractions import gcd",
"from itertools import combinations",
"from collections import deque",
"from collections import defaultdict",
"import bisect",
"bisect",
"import sys",
"sys",
"sys.setrecursionlimit(10000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10000000",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def readInts():\n return list(map(int,input().split()))",
"readInts",
"return list(map(int,input().split()))",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def main():\n s = input()\n N = s.count('N')\n W = s.count('W')\n S = s.count('S')\n E = s.count('E')\n if N:\n if S:\n pass\n else:\n print('No')\n exit()\n if S:\n if N:\n pass\n else:\n print('No')\n exit()\n if W:\n if E:\n pass\n else:\n print('No')\n exit()\n if E:\n if W:\n pass\n else:\n print('No')\n exit()\n print('Yes')",
"main",
"s = input()",
"s",
"input()",
"input",
"N = s.count('N')",
"N",
"s.count('N')",
"s.count",
"s",
"count",
"'N'",
"W = s.count('W')",
"W",
"s.count('W')",
"s.count",
"s",
"count",
"'W'",
"S = s.count('S')",
"S",
"s.count('S')",
"s.count",
"s",
"count",
"'S'",
"E = s.count('E')",
"E",
"s.count('E')",
"s.count",
"s",
"count",
"'E'",
"if N:\n if S:\n pass\n else:\n print('No')\n exit()\n ",
"N",
"if S:\n pass\n else:\n print('No')\n exit()\n ",
"S",
"print('No')",
"print",
"'No'",
"exit()",
"exit",
"if S:\n if N:\n pass\n else:\n print('No')\n exit()\n ",
"S",
"if N:\n pass\n else:\n print('No')\n exit()\n ",
"N",
"print('No')",
"print",
"'No'",
"exit()",
"exit",
"if W:\n if E:\n pass\n else:\n print('No')\n exit()\n ",
"W",
"if E:\n pass\n else:\n print('No')\n exit()\n ",
"E",
"print('No')",
"print",
"'No'",
"exit()",
"exit",
"if E:\n if W:\n pass\n else:\n print('No')\n exit()\n ",
"E",
"if W:\n pass\n else:\n print('No')\n exit()\n ",
"W",
"print('No')",
"print",
"'No'",
"exit()",
"exit",
"print('Yes')",
"print",
"'Yes'",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n s = input()\n N = s.count('N')\n W = s.count('W')\n S = s.count('S')\n E = s.count('E')\n if N:\n if S:\n pass\n else:\n print('No')\n exit()\n if S:\n if N:\n pass\n else:\n print('No')\n exit()\n if W:\n if E:\n pass\n else:\n print('No')\n exit()\n if E:\n if W:\n pass\n else:\n print('No')\n exit()\n print('Yes')",
"def main():\n s = input()\n N = s.count('N')\n W = s.count('W')\n S = s.count('S')\n E = s.count('E')\n if N:\n if S:\n pass\n else:\n print('No')\n exit()\n if S:\n if N:\n pass\n else:\n print('No')\n exit()\n if W:\n if E:\n pass\n else:\n print('No')\n exit()\n if E:\n if W:\n pass\n else:\n print('No')\n exit()\n print('Yes')",
"main",
"def readInts():\n return list(map(int,input().split()))",
"def readInts():\n return list(map(int,input().split()))",
"readInts",
"mod = 10**9 + 7",
"10**9 + 7",
"mod"
] | from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
s = input()
N = s.count('N')
W = s.count('W')
S = s.count('S')
E = s.count('E')
if N:
if S:
pass
else:
print('No')
exit()
if S:
if N:
pass
else:
print('No')
exit()
if W:
if E:
pass
else:
print('No')
exit()
if E:
if W:
pass
else:
print('No')
exit()
print('Yes')
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
13,
4,
13,
8,
2,
2,
2,
13,
4,
13,
17,
2,
13,
4,
13,
17,
2,
13,
4,
13,
17,
17,
17,
10,
4,
13,
10,
4,
13
] | [
[
36,
2
],
[
33,
6
],
[
37,
9
],
[
34,
16
],
[
34,
21
],
[
34,
26
],
[
33,
34
],
[
36,
37
]
] | [
"s = input();\n\nst = set(s)\nprint(\"Yes\" if st == set(\"WE\") or st == set(\"NS\") or st == set(\"SENW\") else \"No\")",
"s = input()",
"s",
"input()",
"input",
"st = set(s)",
"st",
"set(s)",
"set",
"s",
"print(\"Yes\" if st == set(\"WE\") or st == set(\"NS\") or st == set(\"SENW\") else \"No\")",
"print",
"\"Yes\" if st == set(\"WE\") or st == set(\"NS\") or st == set(\"SENW\") else \"No\"",
"st == set(\"WE\") or st == set(\"NS\") or st == set(\"SENW\")",
"st == set(\"WE\") or st == set(\"NS\")",
"st == set(\"WE\")",
"st",
"set(\"WE\")",
"set",
"\"WE\"",
"st == set(\"NS\")",
"st",
"set(\"NS\")",
"set",
"\"NS\"",
"st == set(\"SENW\")",
"st",
"set(\"SENW\")",
"set",
"\"SENW\"",
"\"Yes\"",
"\"No\"",
"st = set(s)",
"set(s)",
"st",
"s = input()",
"input()",
"s"
] | s = input();
st = set(s)
print("Yes" if st == set("WE") or st == set("NS") or st == set("SENW") else "No") |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.