node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
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,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
4,
13,
13,
28,
13,
18,
13,
13,
0,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
4,
13,
13,
0,
13,
18,
18,
13,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13
] | [
[
111,
3
],
[
111,
12
],
[
117,
14
],
[
28,
27
],
[
112,
31
],
[
120,
38
],
[
46,
41
],
[
121,
43
],
[
49,
48
],
[
112,
51
],
[
54,
53
],
[
112,
58
],
[
61,
60
],
[
121,
62
],
[
53,
63
],
[
76,
65
],
[
121,
67
],
[
53,
69
],
[
60,
72
],
[
118,
74
],
[
48,
75
],
[
121,
78
],
[
53,
79
],
[
60,
80
],
[
114,
82
],
[
86,
85
],
[
121,
91
],
[
108,
93
],
[
121,
96
],
[
85,
97
],
[
106,
99
],
[
85,
100
],
[
109,
103
],
[
115,
103
],
[
111,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
]
] | [
"from collections import defaultdict\nn, a = map(int, input().split())\nx = list(map(int, input().split()))\n\ndp = [defaultdict(int) for i in range(n+1)]\ndp[0][0] = 1\n\nfor i in range(n):\n for j in reversed(range(n)):\n for s in dp[j]:\n dp[j+1][s+x[i]] += dp[j][s]\n\n# for dp_i in dp:\n# print(dp_i)\n\nans = 0\nfor i in range(1, len(dp)):\n ans += dp[i][a*i]\nprint(ans)",
"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 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 in range(n):\n for j in reversed(range(n)):\n for s in dp[j]:\n dp[j+1][s+x[i]] += dp[j][s]\n\n# for dp_i in dp:\n# print(dp_i)",
"i",
"range(n)",
"range",
"n",
"for j in reversed(range(n)):\n for s in dp[j]:\n dp[j+1][s+x[i]] += dp[j][s]\n\n# for dp_i in dp:\n# print(dp_i)",
"j",
"reversed(range(n))",
"reversed",
"range(n)",
"range",
"n",
"for s in dp[j]:\n dp[j+1][s+x[i]] += dp[j][s]\n\n# for dp_i in dp:\n# print(dp_i)",
"s",
"dp[j]",
"dp",
"j",
"dp[j+1][s+x[i]] += dp[j][s]",
"dp[j+1][s+x[i]]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"s+x[i]",
"s",
"x[i]",
"x",
"i",
"dp[j][s]",
"[j]",
"dp",
"j",
"s",
"ans = 0",
"ans",
"0",
"for i in range(1, len(dp)):\n ans += dp[i][a*i]",
"i",
"range(1, len(dp))",
"range",
"1",
"len(dp)",
"len",
"dp",
"ans += dp[i][a*i]",
"ans",
"dp[i][a*i]",
"[i]",
"dp",
"i",
"a*i",
"a",
"i",
"print(ans)",
"print",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"ans += dp[i][a*i]",
"dp[i][a*i]",
"ans",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"ans = 0",
"0",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [defaultdict(int) for i in range(n+1)]",
"[defaultdict(int) for i 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 i in range(n+1)]
dp[0][0] = 1
for i in range(n):
for j in reversed(range(n)):
for s in dp[j]:
dp[j+1][s+x[i]] += dp[j][s]
# for dp_i in dp:
# print(dp_i)
ans = 0
for i in range(1, len(dp)):
ans += dp[i][a*i]
print(ans)
|
[
7,
15,
13,
13,
15,
15,
15,
15,
15,
15,
15,
15,
15,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
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,
0,
13,
4,
13,
0,
13,
39,
0,
13,
39,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
0,
13,
17,
14,
2,
13,
13,
4,
18,
13,
13,
2,
13,
13,
4,
18,
13,
13,
2,
13,
13,
0,
13,
2,
39,
17,
17,
0,
13,
2,
39,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
13,
28,
13,
4,
13,
2,
17,
13,
17,
17,
14,
18,
13,
13,
0,
18,
13,
2,
13,
13,
18,
13,
13,
28,
13,
13,
28,
13,
4,
13,
2,
17,
13,
17,
17,
14,
18,
13,
13,
0,
18,
13,
2,
13,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
2,
17,
13,
4,
13,
2,
13,
17,
10,
17,
13,
10,
17,
13,
10,
12,
13,
10,
39,
13,
10,
17,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
39,
13,
10,
2,
13
] | [
[
26,
25
],
[
254,
31
],
[
35,
35
],
[
259,
44
],
[
232,
49
],
[
244,
56
],
[
254,
58
],
[
244,
59
],
[
229,
61
],
[
218,
63
],
[
211,
65
],
[
256,
68
],
[
214,
71
],
[
75,
74
],
[
230,
74
],
[
74,
78
],
[
245,
79
],
[
202,
81
],
[
74,
85
],
[
245,
86
],
[
257,
89
],
[
245,
92
],
[
74,
93
],
[
212,
96
],
[
74,
99
],
[
245,
100
],
[
250,
102
],
[
220,
108
],
[
117,
114
],
[
251,
115
],
[
122,
119
],
[
221,
120
],
[
125,
124
],
[
212,
124
],
[
128,
127
],
[
124,
132
],
[
251,
137
],
[
127,
138
],
[
145,
140
],
[
251,
141
],
[
127,
143
],
[
124,
144
],
[
251,
146
],
[
127,
147
],
[
150,
149
],
[
257,
149
],
[
153,
152
],
[
149,
157
],
[
221,
162
],
[
152,
163
],
[
170,
165
],
[
221,
166
],
[
152,
168
],
[
149,
169
],
[
221,
171
],
[
152,
172
],
[
205,
174
],
[
178,
177
],
[
235,
183
],
[
221,
186
],
[
177,
187
],
[
251,
189
],
[
177,
190
],
[
223,
192
],
[
203,
195
],
[
215,
195
],
[
224,
199
],
[
236,
199
],
[
206,
199
],
[
202,
203
],
[
205,
206
],
[
211,
212
],
[
214,
215
],
[
220,
221
],
[
223,
224
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
244,
242
],
[
244,
245
],
[
250,
251
],
[
256,
257
],
[
259,
260
]
] | [
"import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd\nfrom itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left, insort, insort_left\nfrom heapq import heappush, heappop\nfrom functools import reduce, lru_cache\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef TUPLE(): return tuple(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = 10**6#float('inf')\nmod = 10 ** 9 + 7 \n#mod = 998244353\n#from decimal import *\n#import numpy as np\n#decimal.getcontext().prec = 10\n\nN, A = MAP()\nx = LIST()\n\nbig = []\nsmall = []\ncnt = 0\n\nfor y in x:\n\tif y == A:\n\t\tcnt += 1\n\telif y < A:\n\t\tsmall.append(A-y)\n\telse:\n\t\tbig.append(y-A)\n\nbig_possible = [0]*2501\nsmall_possible = [0]*2501\nbig_possible[0] = 1\nsmall_possible[0] = 1\n\nfor a in big:\n\tfor i in range(2500-a, -1, -1):\n\t\tif big_possible[i]:\n\t\t\tbig_possible[i+a] += big_possible[i]\n\nfor b in small:\n\tfor i in range(2500-b, -1, -1):\n\t\tif small_possible[i]:\n\t\t\tsmall_possible[i+b] += small_possible[i]\n\nans = 1\nfor i in range(1, 2501):\n\tans += small_possible[i]*big_possible[i]\n\n\nans *= 2**cnt\nprint(ans-1)",
"import sys, re",
"sys",
"re",
"from collections import deque, defaultdict, Counter",
"from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd",
"from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby",
"from operator import itemgetter, mul",
"from copy import deepcopy",
"from string import ascii_lowercase, ascii_uppercase, digits",
"from bisect import bisect, bisect_left, insort, insort_left",
"from heapq import heappush, heappop",
"from functools import reduce, lru_cache",
"def input(): return sys.stdin.readline().strip()",
"input",
"def INT(): return int(input())",
"INT",
"def MAP(): return map(int, input().split())",
"MAP",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"def TUPLE(): return tuple(map(int, input().split()))",
"TUPLE",
"MAP() for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"MAP()",
"MAP",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"n",
"n",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = 10**6",
"INF",
"10**6",
"10",
"6",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N, A = MAP()",
"N",
"MAP()",
"MAP",
"A",
"x = LIST()",
"x",
"LIST()",
"LIST",
"big = []",
"big",
"[]",
"small = []",
"small",
"[]",
"cnt = 0",
"cnt",
"0",
"for y in x:\n\tif y == A:\n\t\tcnt += 1\n\telif y < A:\n\t\tsmall.append(A-y)\n\telse:\n\t\tbig.append(y-A)",
"y",
"x",
"if y == A:\n\t\tcnt += 1\n\telif y < A:\n\t\tsmall.append(A-y)\n\telse:\n\t\tbig.append(y-A)",
"y == A",
"y",
"A",
"cnt += 1",
"cnt",
"1",
"elif y < A:\n\t\tsmall.append(A-y)\n\t",
"y < A",
"y",
"A",
"small.append(A-y)",
"small.append",
"small",
"append",
"A-y",
"A",
"y",
"big.append(y-A)",
"big.append",
"big",
"append",
"y-A",
"y",
"A",
"big_possible = [0]*2501",
"big_possible",
"[0]*2501",
"[0]",
"0",
"2501",
"small_possible = [0]*2501",
"small_possible",
"[0]*2501",
"[0]",
"0",
"2501",
"big_possible[0] = 1",
"big_possible[0]",
"big_possible",
"0",
"1",
"small_possible[0] = 1",
"small_possible[0]",
"small_possible",
"0",
"1",
"for a in big:\n\tfor i in range(2500-a, -1, -1):\n\t\tif big_possible[i]:\n\t\t\tbig_possible[i+a] += big_possible[i]",
"a",
"big",
"for i in range(2500-a, -1, -1):\n\t\tif big_possible[i]:\n\t\t\tbig_possible[i+a] += big_possible[i]",
"i",
"range(2500-a, -1, -1)",
"range",
"2500-a",
"2500",
"a",
"-1",
"-1",
"if big_possible[i]:\n\t\t\tbig_possible[i+a] += big_possible[i]",
"big_possible[i]",
"big_possible",
"i",
"big_possible[i+a] += big_possible[i]",
"big_possible[i+a]",
"big_possible",
"i+a",
"i",
"a",
"big_possible[i]",
"big_possible",
"i",
"for b in small:\n\tfor i in range(2500-b, -1, -1):\n\t\tif small_possible[i]:\n\t\t\tsmall_possible[i+b] += small_possible[i]",
"b",
"small",
"for i in range(2500-b, -1, -1):\n\t\tif small_possible[i]:\n\t\t\tsmall_possible[i+b] += small_possible[i]",
"i",
"range(2500-b, -1, -1)",
"range",
"2500-b",
"2500",
"b",
"-1",
"-1",
"if small_possible[i]:\n\t\t\tsmall_possible[i+b] += small_possible[i]",
"small_possible[i]",
"small_possible",
"i",
"small_possible[i+b] += small_possible[i]",
"small_possible[i+b]",
"small_possible",
"i+b",
"i",
"b",
"small_possible[i]",
"small_possible",
"i",
"ans = 1",
"ans",
"1",
"for i in range(1, 2501):\n\tans += small_possible[i]*big_possible[i]",
"i",
"range(1, 2501)",
"range",
"1",
"2501",
"ans += small_possible[i]*big_possible[i]",
"ans",
"small_possible[i]*big_possible[i]",
"small_possible[i]",
"small_possible",
"i",
"big_possible[i]",
"big_possible",
"i",
"ans *= 2**cnt",
"ans",
"2**cnt",
"2",
"cnt",
"print(ans-1)",
"print",
"ans-1",
"ans",
"1",
"cnt += 1",
"1",
"cnt",
"ans = 1",
"1",
"ans",
"def TUPLE(): return tuple(map(int, input().split()))",
"def TUPLE(): return tuple(map(int, input().split()))",
"TUPLE",
"big = []",
"[]",
"big",
"cnt = 0",
"0",
"cnt",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"small_possible = [0]*2501",
"[0]*2501",
"small_possible",
"ans *= 2**cnt",
"2**cnt",
"ans",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"x = LIST()",
"LIST()",
"x",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"ans += small_possible[i]*big_possible[i]",
"small_possible[i]*big_possible[i]",
"ans",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"N, A = MAP()",
"MAP()",
"N",
"A = MAP()",
"MAP()",
"A",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"big_possible = [0]*2501",
"[0]*2501",
"big_possible",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"small = []",
"[]",
"small",
"INF = 10**6",
"10**6",
"INF"
] | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**6#float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
#from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, A = MAP()
x = LIST()
big = []
small = []
cnt = 0
for y in x:
if y == A:
cnt += 1
elif y < A:
small.append(A-y)
else:
big.append(y-A)
big_possible = [0]*2501
small_possible = [0]*2501
big_possible[0] = 1
small_possible[0] = 1
for a in big:
for i in range(2500-a, -1, -1):
if big_possible[i]:
big_possible[i+a] += big_possible[i]
for b in small:
for i in range(2500-b, -1, -1):
if small_possible[i]:
small_possible[i+b] += small_possible[i]
ans = 1
for i in range(1, 2501):
ans += small_possible[i]*big_possible[i]
ans *= 2**cnt
print(ans-1)
|
[
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,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
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,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
85,
3
],
[
85,
12
],
[
16,
15
],
[
15,
24
],
[
82,
26
],
[
31,
30
],
[
83,
30
],
[
30,
34
],
[
86,
35
],
[
79,
37
],
[
88,
40
],
[
48,
45
],
[
89,
46
],
[
51,
50
],
[
80,
50
],
[
83,
50
],
[
89,
59
],
[
67,
62
],
[
89,
63
],
[
86,
65
],
[
50,
66
],
[
89,
72
],
[
85,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] | [
"from collections import defaultdict\n \nn, k = map(int, input().split())\nx = [int(i) for i in input().split()]\nx = [i-k for i in x]\ndic = defaultdict(int)\n\ndic[0]=1\nfor i in x:\n for k,v in list(dic.items()):\n dic[k+i]+=v\nprint(dic[0]-1)\n",
"from collections import defaultdict",
"n, k = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"k",
"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 = [int(i) for i in input().split()]",
"x",
"[int(i) for i in input().split()]",
"i-k for i in x",
"for i in x",
"i",
"x",
"for i in x",
"i-k",
"i",
"k",
"x = [i-k for i in x]",
"x",
"[i-k for i in x]",
"dic = defaultdict(int)",
"dic",
"defaultdict(int)",
"defaultdict",
"int",
"dic[0]=1",
"dic[0]",
"dic",
"0",
"1",
"for i in x:\n for k,v in list(dic.items()):\n dic[k+i]+=v",
"i",
"x",
"for k,v in list(dic.items()):\n dic[k+i]+=v",
"k",
"v",
"list(dic.items())",
"list",
"dic.items()",
"dic.items",
"dic",
"items",
"dic[k+i]+=v",
"dic[k+i]",
"dic",
"k+i",
"k",
"i",
"v",
"print(dic[0]-1)",
"print",
"dic[0]-1",
"dic[0]",
"dic",
"0",
"1",
"n, k = map(int, input().split())",
"map(int, input().split())",
"n",
"x = [i-k for i in x]",
"[i-k for i in x]",
"x",
"x = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"x",
"k = map(int, input().split())",
"map(int, input().split())",
"k",
"dic = defaultdict(int)",
"defaultdict(int)",
"dic"
] | from collections import defaultdict
n, k = map(int, input().split())
x = [int(i) for i in input().split()]
x = [i-k for i in x]
dic = defaultdict(int)
dic[0]=1
for i in x:
for k,v in list(dic.items()):
dic[k+i]+=v
print(dic[0]-1)
|
[
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,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
17,
17,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
14,
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,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
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,
13,
2,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13
] | [
[
179,
2
],
[
179,
11
],
[
15,
14
],
[
14,
23
],
[
173,
25
],
[
30,
29
],
[
182,
36
],
[
40,
39
],
[
177,
43
],
[
53,
46
],
[
183,
49
],
[
39,
50
],
[
185,
55
],
[
174,
58
],
[
61,
60
],
[
177,
65
],
[
69,
68
],
[
186,
72
],
[
76,
75
],
[
177,
80
],
[
188,
83
],
[
174,
85
],
[
60,
87
],
[
189,
91
],
[
68,
92
],
[
101,
94
],
[
183,
97
],
[
60,
98
],
[
68,
99
],
[
75,
100
],
[
183,
105
],
[
60,
107
],
[
68,
109
],
[
75,
110
],
[
183,
114
],
[
60,
116
],
[
68,
119
],
[
189,
120
],
[
75,
122
],
[
132,
125
],
[
183,
128
],
[
60,
129
],
[
68,
130
],
[
75,
131
],
[
183,
135
],
[
60,
137
],
[
68,
139
],
[
75,
140
],
[
167,
142
],
[
146,
145
],
[
177,
150
],
[
170,
153
],
[
183,
157
],
[
177,
158
],
[
145,
160
],
[
180,
161
],
[
145,
162
],
[
171,
165
],
[
168,
165
],
[
167,
168
],
[
170,
171
],
[
173,
174
],
[
179,
177
],
[
179,
180
],
[
182,
183
],
[
185,
186
],
[
188,
189
]
] | [
"n,x=map(int,input().split())\nl=[int(i) for i in input().split()]\ndp = [[[0 for k in range(55)] for j in range(3000)] for i in range(55)]\n\nfor i in range(n+1):\n dp[i][0][0]=1 \nsm=sum(l)\nfor i in range(1,n+1):\n for j in range(sm+5):\n for k in range(1,n+1):\n curr=l[i-1]\n if curr<=j:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-curr][k-1]\n else:\n dp[i][j][k]=dp[i-1][j][k]\n\nans=0 \nfor k in range(1,n+1):\n ans+=dp[n][k*x][k]\nprint(ans)",
"n,x=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x",
"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",
"l=[int(i) for i in input().split()]",
"l",
"[int(i) for i in input().split()]",
"[[0 for k in range(55)] for j in range(3000)] for i in range(55)",
"for i in range(55)",
"i",
"range(55)",
"range",
"55",
"for i in range(55)",
"[[0 for k in range(55)] for j in range(3000)]",
"dp = [[[0 for k in range(55)] for j in range(3000)] for i in range(55)]",
"dp",
"[[[0 for k in range(55)] for j in range(3000)] for i in range(55)]",
"for i in range(n+1):\n dp[i][0][0]=1 ",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"dp[i][0][0]=1",
"dp[i][0][0]",
"[0]",
"[i]",
"dp",
"i",
"0",
"0",
"1",
"sm=sum(l)",
"sm",
"sum(l)",
"sum",
"l",
"for i in range(1,n+1):\n for j in range(sm+5):\n for k in range(1,n+1):\n curr=l[i-1]\n if curr<=j:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-curr][k-1]\n else:\n dp[i][j][k]=dp[i-1][j][k]",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for j in range(sm+5):\n for k in range(1,n+1):\n curr=l[i-1]\n if curr<=j:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-curr][k-1]\n else:\n dp[i][j][k]=dp[i-1][j][k]",
"j",
"range(sm+5)",
"range",
"sm+5",
"sm",
"5",
"for k in range(1,n+1):\n curr=l[i-1]\n if curr<=j:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-curr][k-1]\n else:\n dp[i][j][k]=dp[i-1][j][k]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"curr=l[i-1]",
"curr",
"l[i-1]",
"l",
"i-1",
"i",
"1",
"if curr<=j:\n dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-curr][k-1]\n else:\n dp[i][j][k]=dp[i-1][j][k]",
"curr<=j",
"curr",
"j",
"dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-curr][k-1]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k]+dp[i-1][j-curr][k-1]",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"dp[i-1][j-curr][k-1]",
"[j-curr]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-curr",
"j",
"curr",
"k-1",
"k",
"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",
"ans=0",
"ans",
"0",
"for k in range(1,n+1):\n ans+=dp[n][k*x][k]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans+=dp[n][k*x][k]",
"ans",
"dp[n][k*x][k]",
"[k*x]",
"[n]",
"dp",
"n",
"k*x",
"k",
"x",
"k",
"print(ans)",
"print",
"ans",
"ans=0",
"0",
"ans",
"ans+=dp[n][k*x][k]",
"dp[n][k*x][k]",
"ans",
"l=[int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"l",
"n,x=map(int,input().split())",
"map(int,input().split())",
"n",
"x=map(int,input().split())",
"map(int,input().split())",
"x",
"dp = [[[0 for k in range(55)] for j in range(3000)] for i in range(55)]",
"[[[0 for k in range(55)] for j in range(3000)] for i in range(55)]",
"dp",
"sm=sum(l)",
"sum(l)",
"sm",
"curr=l[i-1]",
"l[i-1]",
"curr"
] | n,x=map(int,input().split())
l=[int(i) for i in input().split()]
dp = [[[0 for k in range(55)] for j in range(3000)] for i in range(55)]
for i in range(n+1):
dp[i][0][0]=1
sm=sum(l)
for i in range(1,n+1):
for j in range(sm+5):
for k in range(1,n+1):
curr=l[i-1]
if curr<=j:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-curr][k-1]
else:
dp[i][j][k]=dp[i-1][j][k]
ans=0
for k in range(1,n+1):
ans+=dp[n][k*x][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,
13,
41,
28,
13,
4,
13,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
17,
18,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
40,
17,
2,
13,
18,
13,
2,
13,
17,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
13,
2,
18,
18,
18,
13,
13,
2,
13,
17,
13,
18,
18,
18,
13,
13,
13,
2,
13,
18,
13,
2,
13,
17,
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,
14,
40,
40,
17,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
2,
13,
17,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
201,
2
],
[
201,
11
],
[
189,
13
],
[
204,
25
],
[
190,
28
],
[
32,
31
],
[
196,
34
],
[
192,
38
],
[
42,
41
],
[
196,
44
],
[
47,
46
],
[
41,
50
],
[
62,
53
],
[
193,
56
],
[
41,
57
],
[
190,
60
],
[
46,
61
],
[
65,
64
],
[
196,
68
],
[
72,
71
],
[
64,
76
],
[
80,
79
],
[
205,
83
],
[
79,
90
],
[
190,
92
],
[
64,
94
],
[
205,
96
],
[
109,
98
],
[
193,
101
],
[
64,
103
],
[
71,
106
],
[
79,
108
],
[
193,
113
],
[
64,
114
],
[
71,
116
],
[
79,
118
],
[
193,
122
],
[
64,
123
],
[
71,
124
],
[
79,
126
],
[
190,
128
],
[
64,
130
],
[
144,
133
],
[
193,
136
],
[
64,
138
],
[
71,
141
],
[
79,
143
],
[
193,
147
],
[
64,
148
],
[
71,
150
],
[
79,
152
],
[
207,
154
],
[
158,
157
],
[
196,
162
],
[
202,
169
],
[
157,
170
],
[
205,
171
],
[
198,
173
],
[
193,
177
],
[
196,
179
],
[
157,
181
],
[
202,
183
],
[
157,
184
],
[
199,
187
],
[
208,
187
],
[
189,
190
],
[
192,
193
],
[
201,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
]
] | [
"N,A = map(int,input().split())\nx = list(map(int,input().split()))\nX = sum(x)\n\ndp = [[[0 for k in range(X+1)] for j in range(N+1)] for i in range(N)]\n\nfor i in range(N):\n for j in range(i+1):\n dp[i][1][x[j]] += 1\n\nfor i in range(N-1):\n for j in range(1,i+2):\n for k in range(X+1):\n if 1 <= k-x[i+1] <= X:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-x[i+1]]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]\n\nans = 0\nfor j in range(1,N+1):\n if 1 <= A*j <= X:\n ans += dp[N-1][j][A*j]\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 = sum(x)",
"X",
"sum(x)",
"sum",
"x",
"[[0 for k in range(X+1)] 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 for k in range(X+1)] for j in range(N+1)]",
"dp = [[[0 for k in range(X+1)] for j in range(N+1)] for i in range(N)]",
"dp",
"[[[0 for k in range(X+1)] for j in range(N+1)] for i in range(N)]",
"for i in range(N):\n for j in range(i+1):\n dp[i][1][x[j]] += 1",
"i",
"range(N)",
"range",
"N",
"for j in range(i+1):\n dp[i][1][x[j]] += 1",
"j",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"dp[i][1][x[j]] += 1",
"dp[i][1][x[j]]",
"[1]",
"[i]",
"dp",
"i",
"1",
"x[j]",
"x",
"j",
"1",
"for i in range(N-1):\n for j in range(1,i+2):\n for k in range(X+1):\n if 1 <= k-x[i+1] <= X:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-x[i+1]]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"for j in range(1,i+2):\n for k in range(X+1):\n if 1 <= k-x[i+1] <= X:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-x[i+1]]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]",
"j",
"range(1,i+2)",
"range",
"1",
"i+2",
"i",
"2",
"for k in range(X+1):\n if 1 <= k-x[i+1] <= X:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-x[i+1]]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]",
"k",
"range(X+1)",
"range",
"X+1",
"X",
"1",
"if 1 <= k-x[i+1] <= X:\n dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-x[i+1]]\n else:\n dp[i+1][j+1][k] = dp[i][j+1][k]",
"1 <= k-x[i+1] <= X",
"1 <= k-x[i+1]",
"1",
"k-x[i+1]",
"k",
"x[i+1]",
"x",
"i+1",
"i",
"1",
"X",
"dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-x[i+1]]",
"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] + dp[i][j][k-x[i+1]]",
"dp[i][j+1][k]",
"[j+1]",
"[i]",
"dp",
"i",
"j+1",
"j",
"1",
"k",
"dp[i][j][k-x[i+1]]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k-x[i+1]",
"k",
"x[i+1]",
"x",
"i+1",
"i",
"1",
"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",
"ans = 0",
"ans",
"0",
"for j in range(1,N+1):\n if 1 <= A*j <= X:\n ans += dp[N-1][j][A*j]",
"j",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if 1 <= A*j <= X:\n ans += dp[N-1][j][A*j]",
"1 <= A*j <= X",
"1 <= A*j",
"1",
"A*j",
"A",
"j",
"X",
"ans += dp[N-1][j][A*j]",
"ans",
"dp[N-1][j][A*j]",
"[j]",
"[N-1]",
"dp",
"N-1",
"N",
"1",
"j",
"A*j",
"A",
"j",
"print(ans)",
"print",
"ans",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"dp = [[[0 for k in range(X+1)] for j in range(N+1)] for i in range(N)]",
"[[[0 for k in range(X+1)] for j in range(N+1)] for i in range(N)]",
"dp",
"N,A = map(int,input().split())",
"map(int,input().split())",
"N",
"ans += dp[N-1][j][A*j]",
"dp[N-1][j][A*j]",
"ans",
"A = map(int,input().split())",
"map(int,input().split())",
"A",
"X = sum(x)",
"sum(x)",
"X",
"ans = 0",
"0",
"ans"
] | N,A = map(int,input().split())
x = list(map(int,input().split()))
X = sum(x)
dp = [[[0 for k in range(X+1)] for j in range(N+1)] for i in range(N)]
for i in range(N):
for j in range(i+1):
dp[i][1][x[j]] += 1
for i in range(N-1):
for j in range(1,i+2):
for k in range(X+1):
if 1 <= k-x[i+1] <= X:
dp[i+1][j+1][k] = dp[i][j+1][k] + dp[i][j][k-x[i+1]]
else:
dp[i+1][j+1][k] = dp[i][j+1][k]
ans = 0
for j in range(1,N+1):
if 1 <= A*j <= X:
ans += dp[N-1][j][A*j]
print(ans) |
[
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,
0,
13,
4,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
13,
17,
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,
14,
2,
2,
13,
13,
2,
13,
2,
13,
13,
0,
13,
2,
13,
18,
18,
18,
13,
13,
13,
13,
4,
13,
2,
13,
17,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13
] | [
[
222,
2
],
[
222,
13
],
[
213,
15
],
[
216,
27
],
[
214,
32
],
[
220,
33
],
[
37,
36
],
[
223,
40
],
[
228,
45
],
[
210,
48
],
[
52,
51
],
[
223,
55
],
[
59,
58
],
[
223,
62
],
[
66,
65
],
[
223,
70
],
[
217,
71
],
[
51,
77
],
[
58,
80
],
[
65,
83
],
[
93,
86
],
[
229,
89
],
[
51,
90
],
[
58,
91
],
[
65,
92
],
[
51,
97
],
[
65,
100
],
[
214,
102
],
[
51,
104
],
[
114,
107
],
[
229,
110
],
[
51,
111
],
[
58,
112
],
[
65,
113
],
[
229,
117
],
[
51,
119
],
[
58,
121
],
[
65,
122
],
[
51,
127
],
[
58,
130
],
[
65,
133
],
[
214,
135
],
[
51,
137
],
[
147,
140
],
[
229,
143
],
[
51,
144
],
[
58,
145
],
[
65,
146
],
[
229,
151
],
[
51,
153
],
[
58,
155
],
[
65,
156
],
[
229,
160
],
[
51,
162
],
[
58,
165
],
[
65,
168
],
[
214,
170
],
[
51,
172
],
[
182,
175
],
[
229,
178
],
[
51,
179
],
[
58,
180
],
[
65,
181
],
[
51,
186
],
[
223,
187
],
[
65,
189
],
[
58,
191
],
[
220,
192
],
[
225,
194
],
[
211,
196
],
[
226,
196
],
[
175,
197
],
[
140,
197
],
[
107,
197
],
[
86,
197
],
[
229,
200
],
[
51,
201
],
[
58,
202
],
[
65,
203
],
[
226,
207
],
[
211,
207
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
222,
220
],
[
222,
223
],
[
225,
226
],
[
228,
229
]
] | [
"N, A = list(map(int, input().split()))\nx = list(map(int, input().split()))\nX = max(max(x), A)\n\ndp=[[[0 for k in range(N*X+1)] for j in range(N+1)] for i in range(N+1)]\n\nans = 0\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\n if j==N and s==k*A:\n ans = ans + dp[j][k][s]\nprint(ans-1)",
"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",
"X = max(max(x), A)",
"X",
"max(max(x), A)",
"max",
"max(x)",
"max",
"x",
"A",
"[[0 for k in range(N*X+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(N*X+1)] for j in range(N+1)]",
"dp=[[[0 for k in range(N*X+1)] for j in range(N+1)] for i in range(N+1)]",
"dp",
"[[[0 for k in range(N*X+1)] for j in range(N+1)] for i in range(N+1)]",
"ans = 0",
"ans",
"0",
"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\n if j==N and s==k*A:\n ans = ans + dp[j][k][s]",
"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\n if j==N and s==k*A:\n ans = ans + dp[j][k][s]",
"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\n if j==N and s==k*A:\n ans = ans + dp[j][k][s]",
"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\n ",
"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",
"if j==N and s==k*A:\n ans = ans + dp[j][k][s]",
"j==N and s==k*A",
"j==N",
"j",
"N",
"s==k*A",
"s",
"k*A",
"k",
"A",
"ans = ans + dp[j][k][s]",
"ans",
"ans + dp[j][k][s]",
"ans",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"print(ans-1)",
"print",
"ans-1",
"ans",
"1",
"ans = 0",
"0",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"X = max(max(x), A)",
"max(max(x), A)",
"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",
"ans = ans + dp[j][k][s]",
"ans + dp[j][k][s]",
"ans",
"dp=[[[0 for k in range(N*X+1)] for j in range(N+1)] for i in range(N+1)]",
"[[[0 for k in range(N*X+1)] for j in range(N+1)] for i in range(N+1)]",
"dp"
] | N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
X = max(max(x), A)
dp=[[[0 for k in range(N*X+1)] for j in range(N+1)] for i in range(N+1)]
ans = 0
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
if j==N and s==k*A:
ans = ans + dp[j][k][s]
print(ans-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,
2,
13,
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,
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,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] | [
[
151,
2
],
[
151,
11
],
[
154,
13
],
[
157,
25
],
[
149,
29
],
[
152,
30
],
[
155,
33
],
[
37,
36
],
[
149,
40
],
[
160,
45
],
[
55,
48
],
[
161,
51
],
[
58,
57
],
[
149,
60
],
[
63,
62
],
[
149,
65
],
[
68,
67
],
[
158,
70
],
[
161,
75
],
[
57,
76
],
[
62,
77
],
[
67,
78
],
[
89,
80
],
[
161,
83
],
[
57,
85
],
[
62,
87
],
[
67,
88
],
[
161,
92
],
[
57,
93
],
[
62,
94
],
[
67,
95
],
[
112,
97
],
[
161,
100
],
[
57,
102
],
[
62,
105
],
[
67,
108
],
[
155,
110
],
[
57,
111
],
[
161,
115
],
[
57,
116
],
[
62,
117
],
[
67,
118
],
[
163,
120
],
[
124,
123
],
[
149,
128
],
[
145,
131
],
[
161,
135
],
[
149,
136
],
[
123,
137
],
[
123,
139
],
[
152,
140
],
[
146,
143
],
[
164,
143
],
[
145,
146
],
[
151,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
]
] | [
"# C - 高橋君とカード\nn,a=map(int,input().split())\nx=list(map(int,input().split()))\n\nmax_num=max(n*a,sum(x))\ndp=[[[0]*(max_num+1) for j in range(n+1)] for i 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(max_num):\n if dp[i][j][k]:\n # not use\n dp[i+1][j][k] += dp[i][j][k]\n # use\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]\n\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",
"max_num=max(n*a,sum(x))",
"max_num",
"max(n*a,sum(x))",
"max",
"n*a",
"n",
"a",
"sum(x)",
"sum",
"x",
"[[0]*(max_num+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]*(max_num+1) for j in range(n+1)]",
"dp=[[[0]*(max_num+1) for j in range(n+1)] for i in range(n+1)]",
"dp",
"[[[0]*(max_num+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(n):\n for j in range(n):\n for k in range(max_num):\n if dp[i][j][k]:\n # not use\n dp[i+1][j][k] += dp[i][j][k]\n # use\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(max_num):\n if dp[i][j][k]:\n # not use\n dp[i+1][j][k] += dp[i][j][k]\n # use\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"j",
"range(n)",
"range",
"n",
"for k in range(max_num):\n if dp[i][j][k]:\n # not use\n dp[i+1][j][k] += dp[i][j][k]\n # use\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"k",
"range(max_num)",
"range",
"max_num",
"if dp[i][j][k]:\n # not use\n dp[i+1][j][k] += dp[i][j][k]\n # use\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]",
"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",
"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",
"ans+=dp[n][i][i*a]",
"dp[n][i][i*a]",
"ans",
"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",
"max_num=max(n*a,sum(x))",
"max(n*a,sum(x))",
"max_num",
"dp=[[[0]*(max_num+1) for j in range(n+1)] for i in range(n+1)]",
"[[[0]*(max_num+1) for j in range(n+1)] for i in range(n+1)]",
"dp",
"ans=0",
"0",
"ans"
] | # C - 高橋君とカード
n,a=map(int,input().split())
x=list(map(int,input().split()))
max_num=max(n*a,sum(x))
dp=[[[0]*(max_num+1) for j in range(n+1)] for i in range(n+1)]
dp[0][0][0]=1
for i in range(n):
for j in range(n):
for k in range(max_num):
if dp[i][j][k]:
# not use
dp[i+1][j][k] += dp[i][j][k]
# use
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,
0,
13,
2,
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,
17,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
13,
9,
28,
13,
4,
13,
13,
17,
17,
28,
13,
4,
13,
2,
13,
13,
17,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
13,
13,
4,
13,
4,
13,
18,
18,
13,
13,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13
] | [
[
111,
2
],
[
111,
11
],
[
114,
13
],
[
120,
25
],
[
112,
27
],
[
109,
28
],
[
32,
31
],
[
109,
35
],
[
121,
42
],
[
117,
45
],
[
53,
48
],
[
118,
50
],
[
115,
59
],
[
121,
63
],
[
67,
66
],
[
74,
73
],
[
121,
77
],
[
91,
82
],
[
118,
84
],
[
66,
86
],
[
73,
89
],
[
118,
93
],
[
66,
94
],
[
73,
95
],
[
118,
102
],
[
112,
106
],
[
111,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
]
] | [
"n, a = map(int, input().split())\nxxx = list(map(int, input().split()))\nlimit = a * n\ndp = [[0] * (limit + 1) for i in range(n + 1)]\ndp[0][0] = 1\nfor i, x in enumerate(xxx):\n if x > limit:\n continue\n for j in range(i, -1, -1):\n for k in range(limit - x, -1, -1):\n dp[j + 1][k + x] += dp[j][k]\n\nprint(sum(dp[i][i * a] for i in range(1, n + 1)))",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"xxx = list(map(int, input().split()))",
"xxx",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"limit = a * n",
"limit",
"a * n",
"a",
"n",
"[0] * (limit + 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] * (limit + 1)",
"[0]",
"0",
"limit + 1",
"limit",
"1",
"dp = [[0] * (limit + 1) for i in range(n + 1)]",
"dp",
"[[0] * (limit + 1) for i in range(n + 1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i, x in enumerate(xxx):\n if x > limit:\n continue\n for j in range(i, -1, -1):\n for k in range(limit - x, -1, -1):\n dp[j + 1][k + x] += dp[j][k]",
"i",
"x",
"enumerate(xxx)",
"enumerate",
"xxx",
"if x > limit:\n continue\n ",
"x > limit",
"x",
"limit",
"continue",
"for j in range(i, -1, -1):\n for k in range(limit - x, -1, -1):\n dp[j + 1][k + x] += dp[j][k]",
"j",
"range(i, -1, -1)",
"range",
"i",
"-1",
"-1",
"for k in range(limit - x, -1, -1):\n dp[j + 1][k + x] += dp[j][k]",
"k",
"range(limit - x, -1, -1)",
"range",
"limit - x",
"limit",
"x",
"-1",
"-1",
"dp[j + 1][k + x] += dp[j][k]",
"dp[j + 1][k + x]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"k + x",
"k",
"x",
"dp[j][k]",
"[j]",
"dp",
"j",
"k",
"print(sum(dp[i][i * a] for i in range(1, n + 1)))",
"print",
"sum(dp[i][i * a] for i in range(1, n + 1))",
"sum",
"dp[i][i * a]",
"[i]",
"dp",
"i",
"i * a",
"i",
"a",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"xxx = list(map(int, input().split()))",
"list(map(int, input().split()))",
"xxx",
"dp = [[0] * (limit + 1) for i in range(n + 1)]",
"[[0] * (limit + 1) for i in range(n + 1)]",
"dp",
"limit = a * n",
"a * n",
"limit"
] | n, a = map(int, input().split())
xxx = list(map(int, input().split()))
limit = a * n
dp = [[0] * (limit + 1) for i in range(n + 1)]
dp[0][0] = 1
for i, x in enumerate(xxx):
if x > limit:
continue
for j in range(i, -1, -1):
for k in range(limit - x, -1, -1):
dp[j + 1][k + x] += dp[j][k]
print(sum(dp[i][i * a] for i in range(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,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
18,
13,
13,
0,
13,
17,
41,
28,
13,
4,
13,
13,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
0,
18,
18,
13,
17,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
28,
13,
4,
13,
40,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
4,
13,
2,
18,
18,
13,
2,
13,
17,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] | [
[
140,
2
],
[
140,
11
],
[
152,
13
],
[
26,
25
],
[
141,
28
],
[
33,
30
],
[
153,
31
],
[
25,
32
],
[
135,
33
],
[
143,
35
],
[
39,
38
],
[
141,
41
],
[
137,
43
],
[
30,
46
],
[
153,
47
],
[
38,
48
],
[
149,
50
],
[
55,
54
],
[
141,
57
],
[
146,
61
],
[
69,
64
],
[
147,
66
],
[
78,
71
],
[
147,
73
],
[
153,
76
],
[
81,
80
],
[
141,
84
],
[
87,
86
],
[
150,
90
],
[
138,
90
],
[
144,
90
],
[
150,
91
],
[
138,
91
],
[
144,
91
],
[
98,
93
],
[
147,
95
],
[
80,
96
],
[
86,
97
],
[
147,
100
],
[
80,
102
],
[
86,
105
],
[
30,
106
],
[
153,
107
],
[
80,
108
],
[
115,
110
],
[
147,
112
],
[
80,
113
],
[
86,
114
],
[
147,
117
],
[
80,
119
],
[
86,
121
],
[
147,
127
],
[
141,
129
],
[
140,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
],
[
149,
150
],
[
152,
153
]
] | [
"n, a = map(int,input().split( ))\n\nx = list(map(int,input().split( )))\n\nfor i in range(n):\n x[i] -= a\n\nmx = 0\nfor i in range(n):\n mx += abs(x[i])\nmx +=1\n\ndp = [[0 for i in range(3*mx)] for j in range(n)]\ndp[0][0] += 1\ndp[0][x[0]] += 1\n\nfor i in range(1,n) :\n for j in range(-mx,mx):\n dp[i][j] += dp[i-1][j-x[i]]\n dp[i][j] += dp[i-1][j]\n #print(*dp[i])\nprint(dp[n-1][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",
"for i in range(n):\n x[i] -= a",
"i",
"range(n)",
"range",
"n",
"x[i] -= a",
"x[i]",
"x",
"i",
"a",
"mx = 0",
"mx",
"0",
"for i in range(n):\n mx += abs(x[i])",
"i",
"range(n)",
"range",
"n",
"mx += abs(x[i])",
"mx",
"abs(x[i])",
"abs",
"x[i]",
"x",
"i",
"mx +=1",
"mx",
"1",
"[0 for i in range(3*mx)] for j in range(n)",
"for j in range(n)",
"j",
"range(n)",
"range",
"n",
"for j in range(n)",
"[0 for i in range(3*mx)]",
"dp = [[0 for i in range(3*mx)] for j in range(n)]",
"dp",
"[[0 for i in range(3*mx)] for j in range(n)]",
"dp[0][0] += 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"dp[0][x[0]] += 1",
"dp[0][x[0]]",
"[0]",
"dp",
"0",
"x[0]",
"x",
"0",
"1",
"for i in range(1,n) :\n for j in range(-mx,mx):\n dp[i][j] += dp[i-1][j-x[i]]\n dp[i][j] += dp[i-1][j]\n #print(*dp[i])",
"i",
"range(1,n)",
"range",
"1",
"n",
"for j in range(-mx,mx):\n dp[i][j] += dp[i-1][j-x[i]]\n dp[i][j] += dp[i-1][j]\n #print(*dp[i])",
"j",
"range(-mx,mx)",
"range",
"-mx",
"mx",
"mx",
"dp[i][j] += dp[i-1][j-x[i]]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j-x[i]]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-x[i]",
"j",
"x[i]",
"x",
"i",
"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-1][0]-1)",
"print",
"dp[n-1][0]-1",
"dp[n-1][0]",
"[n-1]",
"dp",
"n-1",
"n",
"1",
"0",
"1",
"a = map(int,input().split( ))",
"map(int,input().split( ))",
"a",
"mx += abs(x[i])",
"abs(x[i])",
"mx",
"n, a = map(int,input().split( ))",
"map(int,input().split( ))",
"n",
"mx = 0",
"0",
"mx",
"dp = [[0 for i in range(3*mx)] for j in range(n)]",
"[[0 for i in range(3*mx)] for j in range(n)]",
"dp",
"mx +=1",
"1",
"mx",
"x = list(map(int,input().split( )))",
"list(map(int,input().split( )))",
"x"
] | n, a = map(int,input().split( ))
x = list(map(int,input().split( )))
for i in range(n):
x[i] -= a
mx = 0
for i in range(n):
mx += abs(x[i])
mx +=1
dp = [[0 for i in range(3*mx)] for j in range(n)]
dp[0][0] += 1
dp[0][x[0]] += 1
for i in range(1,n) :
for j in range(-mx,mx):
dp[i][j] += dp[i-1][j-x[i]]
dp[i][j] += dp[i-1][j]
#print(*dp[i])
print(dp[n-1][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,
12,
13,
0,
13,
4,
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,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
40,
13,
18,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
2,
18,
18,
13,
13,
2,
13,
18,
13,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
29,
18,
18,
13,
13,
13,
23,
13,
23,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
41,
28,
13,
13,
2,
13,
17,
4,
40,
13,
0,
13,
13,
41,
28,
13,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
4,
13,
4,
13,
13,
4,
13,
13,
17,
0,
13,
2,
4,
13,
13,
13,
4,
13,
13,
13,
0,
13,
17,
0,
13,
4,
18,
13,
13,
17,
14,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
4,
18,
13,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
4,
18,
13,
13,
13,
0,
13,
2,
2,
13,
17,
13,
4,
13,
13,
10,
13,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13
] | [
[
277,
4
],
[
277,
13
],
[
250,
15
],
[
30,
29
],
[
119,
32
],
[
36,
35
],
[
29,
39
],
[
121,
46
],
[
50,
49
],
[
57,
52
],
[
49,
54
],
[
60,
59
],
[
29,
62
],
[
65,
64
],
[
121,
68
],
[
64,
72
],
[
119,
74
],
[
59,
75
],
[
84,
77
],
[
49,
79
],
[
59,
81
],
[
64,
83
],
[
49,
87
],
[
59,
88
],
[
64,
90
],
[
119,
92
],
[
59,
93
],
[
49,
96
],
[
59,
97
],
[
64,
98
],
[
107,
100
],
[
49,
102
],
[
59,
104
],
[
64,
106
],
[
49,
109
],
[
59,
110
],
[
64,
111
],
[
49,
115
],
[
29,
116
],
[
121,
117
],
[
119,
119
],
[
121,
121
],
[
125,
124
],
[
251,
124
],
[
124,
128
],
[
278,
129
],
[
262,
131
],
[
136,
135
],
[
263,
135
],
[
135,
138
],
[
135,
142
],
[
265,
144
],
[
149,
148
],
[
263,
148
],
[
148,
151
],
[
148,
154
],
[
241,
156
],
[
259,
159
],
[
163,
162
],
[
266,
171
],
[
242,
174
],
[
256,
177
],
[
245,
180
],
[
266,
181
],
[
162,
182
],
[
245,
184
],
[
242,
185
],
[
162,
186
],
[
247,
188
],
[
268,
191
],
[
263,
194
],
[
269,
199
],
[
203,
202
],
[
269,
207
],
[
274,
210
],
[
269,
216
],
[
269,
223
],
[
202,
224
],
[
202,
229
],
[
271,
231
],
[
257,
234
],
[
260,
234
],
[
275,
236
],
[
248,
236
],
[
272,
239
],
[
257,
239
],
[
260,
239
],
[
241,
242
],
[
247,
248
],
[
250,
251
],
[
277,
254
],
[
256,
257
],
[
259,
260
],
[
262,
263
],
[
265,
266
],
[
268,
269
],
[
271,
272
],
[
274,
275
],
[
277,
278
]
] | [
"# C - 高橋君とカード / Tak and Cards\n\n#import numpy as np\nimport math\n\nN, A = map(int, input().split())\nx = list(map(int, input().split()))\n\n# 数列aと整数Aを与えると、aからいくつか取って合計Aにするパターンが何通りあるかを返す関数\ndef partial_sum(a,A):\n n = len(a)\n dp = [[0]*(A+2) for _ in range(n+2)] # dp[i+1][j] a[i]までの数からいくつか選んで総和をjにするパターンの数\n dp[0][0] = 1\n \n for i in range(n):\n for j in range(A+1):\n if j >= a[i]:\n dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]\n else:\n dp[i+1][j] = dp[i][j]\n \n return dp[n][A]\n\nx_diff = [a - A for a in x] # ここから合計0になるように取る。負の数列についてpartial_sumが動かないことに注意\nx_diff_negative = [-a for a in x_diff if a < 0]\nx_diff_positive = [a for a in x_diff if a > 0]\n\nans = 0\nfor i in range(1, min(sum(x_diff_negative), sum(x_diff_positive)) + 1):\n ans += partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i) \n\n# 0の選び方\nn_pattern_0 = 0\nn_0 = x_diff.count(0)\nif n_0 > 0:\n for i in range(1, n_0+1):\n n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))\n\n# ここまで数えた全てのパターンそれぞれについて、x_diff中の0をいくつか含めた別パターンがある\n# 0単体で選ぶ方法もある\nans += (ans+1) * n_pattern_0\n \nprint(ans)",
"import math",
"math",
"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",
"def partial_sum(a,A):\n n = len(a)\n dp = [[0]*(A+2) for _ in range(n+2)] # dp[i+1][j] a[i]までの数からいくつか選んで総和をjにするパターンの数\n dp[0][0] = 1\n \n for i in range(n):\n for j in range(A+1):\n if j >= a[i]:\n dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]\n else:\n dp[i+1][j] = dp[i][j]\n \n return dp[n][A]",
"partial_sum",
"n = len(a)",
"n",
"len(a)",
"len",
"a",
"[0]*(A+2) for _ in range(n+2)",
"for _ in range(n+2)",
"_",
"range(n+2)",
"range",
"n+2",
"n",
"2",
"for _ in range(n+2)",
"[0]*(A+2)",
"[0]",
"0",
"A+2",
"A",
"2",
"dp = [[0]*(A+2) for _ in range(n+2)]",
"dp",
"[[0]*(A+2) for _ in range(n+2)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i in range(n):\n for j in range(A+1):\n if j >= a[i]:\n dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]\n else:\n dp[i+1][j] = dp[i][j]\n \n ",
"i",
"range(n)",
"range",
"n",
"for j in range(A+1):\n if j >= a[i]:\n dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]\n else:\n dp[i+1][j] = dp[i][j]\n \n ",
"j",
"range(A+1)",
"range",
"A+1",
"A",
"1",
"if j >= a[i]:\n dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]\n else:\n dp[i+1][j] = dp[i][j]\n \n ",
"j >= a[i]",
"j",
"a[i]",
"a",
"i",
"dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]",
"dp[i+1][j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"dp[i][j-a[i]] + dp[i][j]",
"dp[i][j-a[i]]",
"[i]",
"dp",
"i",
"j-a[i]",
"j",
"a[i]",
"a",
"i",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"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",
"return dp[n][A]",
"dp[n][A]",
"[n]",
"dp",
"n",
"A",
"a",
"a",
"A",
"A",
"a - A for a in x",
"for a in x",
"a",
"x",
"for a in x",
"a - A",
"a",
"A",
"x_diff = [a - A for a in x]",
"x_diff",
"[a - A for a in x]",
"-a for a in x_diff if a < 0",
"for a in x_diff if a < 0",
"a",
"x_diff",
"a < 0",
"a",
"0",
"if a < 0",
"-a",
"a",
"x_diff_negative = [-a for a in x_diff if a < 0]",
"x_diff_negative",
"[-a for a in x_diff if a < 0]",
"a for a in x_diff if a > 0",
"for a in x_diff if a > 0",
"a",
"x_diff",
"a > 0",
"a",
"0",
"if a > 0",
"a",
"x_diff_positive = [a for a in x_diff if a > 0]",
"x_diff_positive",
"[a for a in x_diff if a > 0]",
"ans = 0",
"ans",
"0",
"for i in range(1, min(sum(x_diff_negative), sum(x_diff_positive)) + 1):\n ans += partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i) \n\n# 0の選び方",
"i",
"range(1, min(sum(x_diff_negative), sum(x_diff_positive)) + 1)",
"range",
"1",
"min(sum(x_diff_negative), sum(x_diff_positive)) + 1",
"min(sum(x_diff_negative), sum(x_diff_positive))",
"min",
"sum(x_diff_negative)",
"sum",
"x_diff_negative",
"sum(x_diff_positive)",
"sum",
"x_diff_positive",
"1",
"ans += partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i)",
"ans",
"partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i)",
"partial_sum(x_diff_negative,i)",
"partial_sum",
"x_diff_negative",
"i",
"partial_sum(x_diff_positive,i)",
"partial_sum",
"x_diff_positive",
"i",
"n_pattern_0 = 0",
"n_pattern_0",
"0",
"n_0 = x_diff.count(0)",
"n_0",
"x_diff.count(0)",
"x_diff.count",
"x_diff",
"count",
"0",
"if n_0 > 0:\n for i in range(1, n_0+1):\n n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))\n\n# ここまで数えた全てのパターンそれぞれについて、x_diff中の0をいくつか含めた別パターンがある\n# 0単体で選ぶ方法もある",
"n_0 > 0",
"n_0",
"0",
"for i in range(1, n_0+1):\n n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))\n\n# ここまで数えた全てのパターンそれぞれについて、x_diff中の0をいくつか含めた別パターンがある\n# 0単体で選ぶ方法もある",
"i",
"range(1, n_0+1)",
"range",
"1",
"n_0+1",
"n_0",
"1",
"n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))",
"n_pattern_0",
"math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))",
"math.factorial(n_0)",
"math.factorial",
"math",
"factorial",
"n_0",
"math.factorial(n_0-i) * math.factorial(i)",
"math.factorial(n_0-i)",
"math.factorial",
"math",
"factorial",
"n_0-i",
"n_0",
"i",
"math.factorial(i)",
"math.factorial",
"math",
"factorial",
"i",
"ans += (ans+1) * n_pattern_0",
"ans",
"(ans+1) * n_pattern_0",
"ans+1",
"ans",
"1",
"n_pattern_0",
"print(ans)",
"print",
"ans",
"x_diff_positive = [a for a in x_diff if a > 0]",
"[a for a in x_diff if a > 0]",
"x_diff_positive",
"def partial_sum(a,A):\n n = len(a)\n dp = [[0]*(A+2) for _ in range(n+2)] # dp[i+1][j] a[i]までの数からいくつか選んで総和をjにするパターンの数\n dp[0][0] = 1\n \n for i in range(n):\n for j in range(A+1):\n if j >= a[i]:\n dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]\n else:\n dp[i+1][j] = dp[i][j]\n \n return dp[n][A]",
"def partial_sum(a,A):\n n = len(a)\n dp = [[0]*(A+2) for _ in range(n+2)] # dp[i+1][j] a[i]までの数からいくつか選んで総和をjにするパターンの数\n dp[0][0] = 1\n \n for i in range(n):\n for j in range(A+1):\n if j >= a[i]:\n dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]\n else:\n dp[i+1][j] = dp[i][j]\n \n return dp[n][A]",
"partial_sum",
"n_pattern_0 = 0",
"0",
"n_pattern_0",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans += partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i)",
"partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i)",
"ans",
"ans = 0",
"0",
"ans",
"x_diff = [a - A for a in x]",
"[a - A for a in x]",
"x_diff",
"x_diff_negative = [-a for a in x_diff if a < 0]",
"[-a for a in x_diff if a < 0]",
"x_diff_negative",
"n_0 = x_diff.count(0)",
"x_diff.count(0)",
"n_0",
"ans += (ans+1) * n_pattern_0",
"(ans+1) * n_pattern_0",
"ans",
"n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))",
"math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))",
"n_pattern_0",
"A = map(int, input().split())",
"map(int, input().split())",
"A"
] | # C - 高橋君とカード / Tak and Cards
#import numpy as np
import math
N, A = map(int, input().split())
x = list(map(int, input().split()))
# 数列aと整数Aを与えると、aからいくつか取って合計Aにするパターンが何通りあるかを返す関数
def partial_sum(a,A):
n = len(a)
dp = [[0]*(A+2) for _ in range(n+2)] # dp[i+1][j] a[i]までの数からいくつか選んで総和をjにするパターンの数
dp[0][0] = 1
for i in range(n):
for j in range(A+1):
if j >= a[i]:
dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]
else:
dp[i+1][j] = dp[i][j]
return dp[n][A]
x_diff = [a - A for a in x] # ここから合計0になるように取る。負の数列についてpartial_sumが動かないことに注意
x_diff_negative = [-a for a in x_diff if a < 0]
x_diff_positive = [a for a in x_diff if a > 0]
ans = 0
for i in range(1, min(sum(x_diff_negative), sum(x_diff_positive)) + 1):
ans += partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i)
# 0の選び方
n_pattern_0 = 0
n_0 = x_diff.count(0)
if n_0 > 0:
for i in range(1, n_0+1):
n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))
# ここまで数えた全てのパターンそれぞれについて、x_diff中の0をいくつか含めた別パターンがある
# 0単体で選ぶ方法もある
ans += (ans+1) * n_pattern_0
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,
28,
13,
4,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
17,
17,
14,
2,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
13,
13,
0,
18,
18,
18,
13,
13,
13,
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,
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,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] | [
[
182,
2
],
[
182,
11
],
[
188,
13
],
[
27,
26
],
[
180,
30
],
[
176,
35
],
[
39,
38
],
[
180,
42
],
[
52,
45
],
[
177,
48
],
[
38,
49
],
[
55,
54
],
[
180,
59
],
[
191,
62
],
[
189,
64
],
[
54,
66
],
[
70,
69
],
[
180,
74
],
[
78,
77
],
[
180,
82
],
[
77,
87
],
[
192,
88
],
[
97,
90
],
[
177,
93
],
[
54,
94
],
[
69,
95
],
[
77,
96
],
[
177,
100
],
[
54,
102
],
[
69,
104
],
[
77,
105
],
[
69,
108
],
[
54,
109
],
[
118,
111
],
[
177,
114
],
[
54,
115
],
[
69,
116
],
[
77,
117
],
[
127,
120
],
[
177,
123
],
[
54,
124
],
[
69,
125
],
[
77,
126
],
[
177,
131
],
[
54,
133
],
[
69,
135
],
[
77,
136
],
[
177,
140
],
[
54,
142
],
[
69,
145
],
[
77,
148
],
[
192,
149
],
[
194,
151
],
[
155,
154
],
[
180,
159
],
[
185,
162
],
[
177,
166
],
[
180,
167
],
[
154,
168
],
[
183,
170
],
[
154,
171
],
[
186,
174
],
[
195,
174
],
[
176,
177
],
[
182,
180
],
[
182,
183
],
[
185,
186
],
[
188,
189
],
[
191,
192
],
[
194,
195
]
] | [
"N, A = map(int,input().split())\nX = list(map(int,input().split()))\ndp = [[[0 for i in range(N*50+1)] for j in range(N+1)] for k in range(N+1)]\nfor i in range(N+1):\n dp[i][0][0] = 1\nfor i in range(1,N+1):\n x = X[i-1]\n for j in range(1,N+1):\n for k in range(N*50+1):\n if k < x:\n dp[i][j][k] = dp[i-1][j][k]\n \n elif j > i:\n dp[i][j][k] = 0\n \n else: \n dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]\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 i in range(N*50+1)] for j in range(N+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 i in range(N*50+1)] for j in range(N+1)]",
"dp = [[[0 for i in range(N*50+1)] for j in range(N+1)] for k in range(N+1)]",
"dp",
"[[[0 for i in range(N*50+1)] for j in range(N+1)] for k in range(N+1)]",
"for i in range(N+1):\n dp[i][0][0] = 1",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"dp[i][0][0] = 1",
"dp[i][0][0]",
"[0]",
"[i]",
"dp",
"i",
"0",
"0",
"1",
"for i in range(1,N+1):\n x = X[i-1]\n for j in range(1,N+1):\n for k in range(N*50+1):\n if k < x:\n dp[i][j][k] = dp[i-1][j][k]\n \n elif j > i:\n dp[i][j][k] = 0\n \n else: \n dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]",
"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(1,N+1):\n for k in range(N*50+1):\n if k < x:\n dp[i][j][k] = dp[i-1][j][k]\n \n elif j > i:\n dp[i][j][k] = 0\n \n else: \n dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]",
"j",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for k in range(N*50+1):\n if k < x:\n dp[i][j][k] = dp[i-1][j][k]\n \n elif j > i:\n dp[i][j][k] = 0\n \n else: \n dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]",
"k",
"range(N*50+1)",
"range",
"N*50+1",
"N*50",
"N",
"50",
"1",
"if k < x:\n dp[i][j][k] = dp[i-1][j][k]\n \n elif j > i:\n dp[i][j][k] = 0\n \n else: \n dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]",
"k < x",
"k",
"x",
"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 j > i:\n dp[i][j][k] = 0\n \n ",
"j > i",
"j",
"i",
"dp[i][j][k] = 0",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"0",
"dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j][k] + dp[i-1][j-1][k-x]",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"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",
"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 i in range(N*50+1)] for j in range(N+1)] for k in range(N+1)]",
"[[[0 for i in range(N*50+1)] for j in range(N+1)] for k 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[N][i][A*i]",
"dp[N][i][A*i]",
"ans",
"X = list(map(int,input().split()))",
"list(map(int,input().split()))",
"X",
"x = X[i-1]",
"X[i-1]",
"x",
"ans = 0",
"0",
"ans"
] | N, A = map(int,input().split())
X = list(map(int,input().split()))
dp = [[[0 for i in range(N*50+1)] for j in range(N+1)] for k in range(N+1)]
for i in range(N+1):
dp[i][0][0] = 1
for i in range(1,N+1):
x = X[i-1]
for j in range(1,N+1):
for k in range(N*50+1):
if k < x:
dp[i][j][k] = dp[i-1][j][k]
elif j > i:
dp[i][j][k] = 0
else:
dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]
ans = 0
for i in range(1,N+1):
ans += dp[N][i][A*i]
print(ans)
|
[
7,
15,
13,
15,
0,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
31,
13,
28,
13,
4,
13,
13,
12,
13,
0,
13,
4,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
28,
13,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
18,
13,
13,
13,
0,
13,
13,
4,
13,
2,
18,
13,
17,
17,
14,
2,
13,
17,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
88,
5
],
[
88,
18
],
[
88,
19
],
[
23,
22
],
[
89,
25
],
[
30,
29
],
[
37,
34
],
[
29,
35
],
[
40,
39
],
[
89,
42
],
[
45,
44
],
[
29,
47
],
[
66,
47
],
[
29,
54
],
[
66,
54
],
[
64,
57
],
[
44,
58
],
[
39,
63
],
[
67,
66
],
[
44,
67
],
[
66,
72
],
[
29,
72
],
[
86,
80
],
[
88,
83
],
[
88,
89
]
] | [
"import sys\nfrom collections import defaultdict\n\nn, a, *x = map(int, sys.stdin.read().split())\nfor i in range(n): x[i] -= a\n\ndef main():\n dp = defaultdict(int); dp[0] = 1\n for i in range(n):\n ndp = dp.copy()\n for k, v in dp.items():\n ndp[k+x[i]] += v\n dp = ndp\n print(dp[0] - 1)\n \nif __name__ == '__main__':\n main()",
"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",
"for i in range(n): x[i] -= a",
"i",
"range(n)",
"range",
"n",
"def main():\n dp = defaultdict(int); dp[0] = 1\n for i in range(n):\n ndp = dp.copy()\n for k, v in dp.items():\n ndp[k+x[i]] += v\n dp = ndp\n print(dp[0] - 1)\n ",
"main",
"dp = defaultdict(int)",
"dp",
"defaultdict(int)",
"defaultdict",
"int",
"dp[0] = 1",
"dp[0]",
"dp",
"0",
"1",
"for i in range(n):\n ndp = dp.copy()\n for k, v in dp.items():\n ndp[k+x[i]] += v\n dp = ndp\n ",
"i",
"range(n)",
"range",
"n",
"ndp = dp.copy()",
"ndp",
"dp.copy()",
"dp.copy",
"dp",
"copy",
"for k, v in dp.items():\n ndp[k+x[i]] += v\n ",
"k",
"v",
"dp.items()",
"dp.items",
"dp",
"items",
"ndp[k+x[i]] += v",
"ndp[k+x[i]]",
"ndp",
"k+x[i]",
"k",
"x[i]",
"x",
"i",
"v",
"dp = ndp",
"dp",
"ndp",
"print(dp[0] - 1)",
"print",
"dp[0] - 1",
"dp[0]",
"dp",
"0",
"1",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"a",
"def main():\n dp = defaultdict(int); dp[0] = 1\n for i in range(n):\n ndp = dp.copy()\n for k, v in dp.items():\n ndp[k+x[i]] += v\n dp = ndp\n print(dp[0] - 1)\n ",
"def main():\n dp = defaultdict(int); dp[0] = 1\n for i in range(n):\n ndp = dp.copy()\n for k, v in dp.items():\n ndp[k+x[i]] += v\n dp = ndp\n print(dp[0] - 1)\n ",
"main",
"n, a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"n"
] | import sys
from collections import defaultdict
n, a, *x = map(int, sys.stdin.read().split())
for i in range(n): x[i] -= a
def main():
dp = defaultdict(int); dp[0] = 1
for i in range(n):
ndp = dp.copy()
for k, v in dp.items():
ndp[k+x[i]] += v
dp = ndp
print(dp[0] - 1)
if __name__ == '__main__':
main() |
[
7,
17,
15,
13,
0,
13,
18,
18,
13,
13,
13,
15,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
17,
0,
13,
4,
13,
13,
0,
13,
39,
28,
13,
13,
4,
18,
13,
13,
2,
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,
13,
17,
28,
13,
13,
4,
13,
4,
13,
13,
4,
13,
40,
13,
2,
13,
17,
0,
13,
2,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
8,
40,
40,
17,
2,
13,
18,
13,
13,
2,
17,
13,
18,
18,
13,
13,
2,
13,
18,
13,
13,
17,
4,
13,
2,
18,
18,
13,
13,
13,
17,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13
] | [
[
156,
5
],
[
157,
23
],
[
171,
26
],
[
178,
28
],
[
171,
29
],
[
153,
31
],
[
178,
33
],
[
165,
36
],
[
154,
39
],
[
168,
41
],
[
45,
44
],
[
154,
44
],
[
169,
48
],
[
44,
51
],
[
172,
52
],
[
56,
55
],
[
160,
59
],
[
166,
68
],
[
162,
71
],
[
79,
74
],
[
163,
76
],
[
166,
78
],
[
160,
87
],
[
166,
91
],
[
166,
93
],
[
174,
96
],
[
166,
99
],
[
108,
101
],
[
163,
103
],
[
175,
107
],
[
163,
110
],
[
175,
112
],
[
121,
114
],
[
163,
116
],
[
175,
120
],
[
175,
126
],
[
169,
128
],
[
166,
132
],
[
163,
135
],
[
175,
138
],
[
169,
140
],
[
163,
148
],
[
160,
149
],
[
166,
150
],
[
153,
154
],
[
156,
157
],
[
171,
160
],
[
162,
163
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
]
] | [
"# https://atcoder.jp/contests/abc044/tasks/arc060_a\n# ソートしてからごちゃごちゃやればどうにかなりそう(無理でした)\n\n'''\n解説満点解法1\nもしもk枚選んだとき、合計がsになる通りの数がわかったら？→s=k*Aとなる場合の数の合計をすれば良い\n\nk枚選んだとき、合計がsになる通りの数は典型的なDP！\ndp(j,k,s)... X[0:j]からk枚選んで、その合計をsにするような選び方の総数\nと定義すると、\n\n更新則\ndp(j+1,k,s) = X[j]を選んだ結果sになったときの通りの数 + X[j]を選ばずにsになっている通りの数 なので\nすなわち\ndp(j+1,k,s) = dp(j,k-1,s-X[j]) + dp(j,k,s)\n\nあとは初期条件と境界条件と伝播条件を付け加える。\n境界条件 dp(j,k,0)=0 (数枚選んで合計が0になるのはありえない)\n初期条件 dp(j,0,0)=1 (ただし、0枚選んだときは1通りとなる)(s-X[j]=0のときに1通りとなってほしいという気持ちもある)\n伝播条件 s-X[j]<0に関しては dp(j,k-1,s-X[j])が必ず0通りとなる(ありえないので)\n'''\n\nimport sys\nread = sys.stdin.readline\nfrom itertools import product\n\n\ndef read_ints():\n return list(map(int, read().split()))\n\n\nN, A = read_ints()\nX = read_ints()\n# S = sum(X)\n\n# # 満点解法1\n# dp = [[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]\n# for j in range(N + 1): # 初期条件\n# dp[j][0][0] = 1 # 1枚も選ばずに0になるのは1通り\n# # 0,0,0は1でいい∵ j,1,xで1通りになりたいときに1だと都合がいい\n\n# for j, k, s in product(range(N), range(1, N + 1), range(S + 1)):\n# dp[j + 1][k][s] = dp[j][k][s] + \\\n# (0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]])\n\n# # s=k*Aとなるような通りの数の総数\n# ans = 0\n# for k in range(1, N + 1): # 0個はとる通りの数はいらない\n# s = k * A\n# if s <= S:\n# ans += dp[N][k][s]\n\n# # print(dp)\n# print(ans)\n\n\n'''\n満点解法2\n平均値の特性からXから差っ引けば、選んだカードの合計が0になれば良くなる。Y=X-Aと定義する。\n→そしたらYからいくつか選んで合計tをつくる総数をdpで求めれば良い。(ナップザックDPとコインDPの中間！)\n\n0枚以上選んだときに合計がtに成るかどうか考える\n\ndp(j,t)...Y[:j]の中から0枚以上選んで、その合計を(t-NX)(負になる可能性もあるだけ)にするような選び方の総数\ndp(j,t+NX)...Y[:j]の中から0枚以上選んで、その合計をtにするような選び方の総数 この定義のほうがいいかな\n\n更新則\ndp(j+1,t+NX) = Y[j]を選んで合計がtになる総和 + Y[j]を選ばずに合計がtになっている総和\nつまり\ndp(j+1,t+NX) = dp(j,t+NX - Y[j]) + dp(j,t+NX)\n\n境界条件\ndp(0,t+NX)=0 一つも考慮しない状態では必ずスコアは作れない\n初期条件\ndp(0,0+NX)=1 ∵ただし一つも考慮しないならば合計が0になるのは当然1通り\n伝播条件\n0<=t+NX-Y[j]<=2NXとなる範囲外の場合はdp(j,t+NX - Y[j])を無視 \n'''\n\n# 満点解法2\n# NXは十分幅を取れていればなんでもいい\n# NX = N * max(X) #今回は最低限の幅Sで代用\nS = sum(X)\n\nY = []\nfor x in X:\n Y.append(x - A)\ndp = [[0] * (2 * S + 1) for _ in range(N + 1)]\n\n# 初期条件\ndp[0][S] = 1\n\nfor j, t in product(range(N), range(-S, S + 1)):\n ts = t + S\n dp[j + 1][ts] = dp[j][ts]\n dp[j + 1][ts] += dp[j][ts - Y[j]] if 0 <= ts - Y[j] <= 2 * S else 0\n\nprint(dp[N][S] - 1)",
"'''\n解説満点解法1\nもしもk枚選んだとき、合計がsになる通りの数がわかったら？→s=k*Aとなる場合の数の合計をすれば良い\n\nk枚選んだとき、合計がsになる通りの数は典型的なDP！\ndp(j,k,s)... X[0:j]からk枚選んで、その合計をsにするような選び方の総数\nと定義すると、\n\n更新則\ndp(j+1,k,s) = X[j]を選んだ結果sになったときの通りの数 + X[j]を選ばずにsになっている通りの数 なので\nすなわち\ndp(j+1,k,s) = dp(j,k-1,s-X[j]) + dp(j,k,s)\n\nあとは初期条件と境界条件と伝播条件を付け加える。\n境界条件 dp(j,k,0)=0 (数枚選んで合計が0になるのはありえない)\n初期条件 dp(j,0,0)=1 (ただし、0枚選んだときは1通りとなる)(s-X[j]=0のときに1通りとなってほしいという気持ちもある)\n伝播条件 s-X[j]<0に関しては dp(j,k-1,s-X[j])が必ず0通りとなる(ありえないので)\n'''",
"import sys",
"sys",
"read = sys.stdin.readline",
"read",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"from itertools import product",
"def read_ints():\n return list(map(int, read().split()))",
"read_ints",
"return list(map(int, read().split()))",
"list(map(int, read().split()))",
"list",
"map(int, read().split())",
"map",
"int",
"read().split()",
"().split",
"()",
"read",
"split",
"N, A = read_ints()",
"N",
"read_ints()",
"read_ints",
"A",
"X = read_ints()",
"X",
"read_ints()",
"read_ints",
"'''\n満点解法2\n平均値の特性からXから差っ引けば、選んだカードの合計が0になれば良くなる。Y=X-Aと定義する。\n→そしたらYからいくつか選んで合計tをつくる総数をdpで求めれば良い。(ナップザックDPとコインDPの中間！)\n\n0枚以上選んだときに合計がtに成るかどうか考える\n\ndp(j,t)...Y[:j]の中から0枚以上選んで、その合計を(t-NX)(負になる可能性もあるだけ)にするような選び方の総数\ndp(j,t+NX)...Y[:j]の中から0枚以上選んで、その合計をtにするような選び方の総数 この定義のほうがいいかな\n\n更新則\ndp(j+1,t+NX) = Y[j]を選んで合計がtになる総和 + Y[j]を選ばずに合計がtになっている総和\nつまり\ndp(j+1,t+NX) = dp(j,t+NX - Y[j]) + dp(j,t+NX)\n\n境界条件\ndp(0,t+NX)=0 一つも考慮しない状態では必ずスコアは作れない\n初期条件\ndp(0,0+NX)=1 ∵ただし一つも考慮しないならば合計が0になるのは当然1通り\n伝播条件\n0<=t+NX-Y[j]<=2NXとなる範囲外の場合はdp(j,t+NX - Y[j])を無視 \n'''",
"S = sum(X)",
"S",
"sum(X)",
"sum",
"X",
"Y = []",
"Y",
"[]",
"for x in X:\n Y.append(x - A)",
"x",
"X",
"Y.append(x - A)",
"Y.append",
"Y",
"append",
"x - A",
"x",
"A",
"[0] * (2 * S + 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 * S + 1)",
"[0]",
"0",
"2 * S + 1",
"2 * S",
"2",
"S",
"1",
"dp = [[0] * (2 * S + 1) for _ in range(N + 1)]",
"dp",
"[[0] * (2 * S + 1) for _ in range(N + 1)]",
"dp[0][S] = 1",
"dp[0][S]",
"[0]",
"dp",
"0",
"S",
"1",
"for j, t in product(range(N), range(-S, S + 1)):\n ts = t + S\n dp[j + 1][ts] = dp[j][ts]\n dp[j + 1][ts] += dp[j][ts - Y[j]] if 0 <= ts - Y[j] <= 2 * S else 0",
"j",
"t",
"product(range(N), range(-S, S + 1))",
"product",
"range(N)",
"range",
"N",
"range(-S, S + 1)",
"range",
"-S",
"S",
"S + 1",
"S",
"1",
"ts = t + S",
"ts",
"t + S",
"t",
"S",
"dp[j + 1][ts] = dp[j][ts]",
"dp[j + 1][ts]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"ts",
"dp[j][ts]",
"[j]",
"dp",
"j",
"ts",
"dp[j + 1][ts] += dp[j][ts - Y[j]] if 0 <= ts - Y[j] <= 2 * S else 0",
"dp[j + 1][ts]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"ts",
"dp[j][ts - Y[j]] if 0 <= ts - Y[j] <= 2 * S else 0",
"0 <= ts - Y[j] <= 2 * S",
"0 <= ts - Y[j]",
"0",
"ts - Y[j]",
"ts",
"Y[j]",
"Y",
"j",
"2 * S",
"2",
"S",
"dp[j][ts - Y[j]]",
"[j]",
"dp",
"j",
"ts - Y[j]",
"ts",
"Y[j]",
"Y",
"j",
"0",
"print(dp[N][S] - 1)",
"print",
"dp[N][S] - 1",
"dp[N][S]",
"[N]",
"dp",
"N",
"S",
"1",
"X = read_ints()",
"read_ints()",
"X",
"read = sys.stdin.readline",
"sys.stdin.readline",
"read",
"N, A = read_ints()",
"read_ints()",
"N",
"dp = [[0] * (2 * S + 1) for _ in range(N + 1)]",
"[[0] * (2 * S + 1) for _ in range(N + 1)]",
"dp",
"S = sum(X)",
"sum(X)",
"S",
"Y = []",
"[]",
"Y",
"A = read_ints()",
"read_ints()",
"A",
"ts = t + S",
"t + S",
"ts",
"def read_ints():\n return list(map(int, read().split()))",
"def read_ints():\n return list(map(int, read().split()))",
"read_ints"
] | # https://atcoder.jp/contests/abc044/tasks/arc060_a
# ソートしてからごちゃごちゃやればどうにかなりそう(無理でした)
'''
解説満点解法1
もしもk枚選んだとき、合計がsになる通りの数がわかったら？→s=k*Aとなる場合の数の合計をすれば良い
k枚選んだとき、合計がsになる通りの数は典型的なDP！
dp(j,k,s)... X[0:j]からk枚選んで、その合計をsにするような選び方の総数
と定義すると、
更新則
dp(j+1,k,s) = X[j]を選んだ結果sになったときの通りの数 + X[j]を選ばずにsになっている通りの数 なので
すなわち
dp(j+1,k,s) = dp(j,k-1,s-X[j]) + dp(j,k,s)
あとは初期条件と境界条件と伝播条件を付け加える。
境界条件 dp(j,k,0)=0 (数枚選んで合計が0になるのはありえない)
初期条件 dp(j,0,0)=1 (ただし、0枚選んだときは1通りとなる)(s-X[j]=0のときに1通りとなってほしいという気持ちもある)
伝播条件 s-X[j]<0に関しては dp(j,k-1,s-X[j])が必ず0通りとなる(ありえないので)
'''
import sys
read = sys.stdin.readline
from itertools import product
def read_ints():
return list(map(int, read().split()))
N, A = read_ints()
X = read_ints()
# S = sum(X)
# # 満点解法1
# dp = [[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]
# for j in range(N + 1): # 初期条件
# dp[j][0][0] = 1 # 1枚も選ばずに0になるのは1通り
# # 0,0,0は1でいい∵ j,1,xで1通りになりたいときに1だと都合がいい
# for j, k, s in product(range(N), range(1, N + 1), range(S + 1)):
# dp[j + 1][k][s] = dp[j][k][s] + \
# (0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]])
# # s=k*Aとなるような通りの数の総数
# ans = 0
# for k in range(1, N + 1): # 0個はとる通りの数はいらない
# s = k * A
# if s <= S:
# ans += dp[N][k][s]
# # print(dp)
# print(ans)
'''
満点解法2
平均値の特性からXから差っ引けば、選んだカードの合計が0になれば良くなる。Y=X-Aと定義する。
→そしたらYからいくつか選んで合計tをつくる総数をdpで求めれば良い。(ナップザックDPとコインDPの中間！)
0枚以上選んだときに合計がtに成るかどうか考える
dp(j,t)...Y[:j]の中から0枚以上選んで、その合計を(t-NX)(負になる可能性もあるだけ)にするような選び方の総数
dp(j,t+NX)...Y[:j]の中から0枚以上選んで、その合計をtにするような選び方の総数 この定義のほうがいいかな
更新則
dp(j+1,t+NX) = Y[j]を選んで合計がtになる総和 + Y[j]を選ばずに合計がtになっている総和
つまり
dp(j+1,t+NX) = dp(j,t+NX - Y[j]) + dp(j,t+NX)
境界条件
dp(0,t+NX)=0 一つも考慮しない状態では必ずスコアは作れない
初期条件
dp(0,0+NX)=1 ∵ただし一つも考慮しないならば合計が0になるのは当然1通り
伝播条件
0<=t+NX-Y[j]<=2NXとなる範囲外の場合はdp(j,t+NX - Y[j])を無視
'''
# 満点解法2
# NXは十分幅を取れていればなんでもいい
# NX = N * max(X) #今回は最低限の幅Sで代用
S = sum(X)
Y = []
for x in X:
Y.append(x - A)
dp = [[0] * (2 * S + 1) for _ in range(N + 1)]
# 初期条件
dp[0][S] = 1
for j, t in product(range(N), range(-S, S + 1)):
ts = t + S
dp[j + 1][ts] = dp[j][ts]
dp[j + 1][ts] += dp[j][ts - Y[j]] if 0 <= ts - Y[j] <= 2 * S else 0
print(dp[N][S] - 1)
|
[
7,
0,
13,
17,
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,
28,
13,
4,
13,
13,
28,
13,
4,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
18,
18,
13,
13,
13,
13,
17,
9,
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,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
2,
13,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13
] | [
[
156,
2
],
[
150,
5
],
[
150,
14
],
[
144,
16
],
[
30,
29
],
[
157,
32
],
[
141,
36
],
[
46,
39
],
[
142,
42
],
[
49,
48
],
[
148,
51
],
[
54,
53
],
[
59,
58
],
[
148,
62
],
[
142,
69
],
[
48,
70
],
[
53,
71
],
[
58,
72
],
[
85,
76
],
[
142,
79
],
[
48,
81
],
[
53,
83
],
[
58,
84
],
[
142,
88
],
[
48,
89
],
[
53,
90
],
[
58,
91
],
[
108,
93
],
[
142,
96
],
[
48,
98
],
[
53,
101
],
[
145,
103
],
[
48,
104
],
[
58,
106
],
[
142,
111
],
[
48,
112
],
[
53,
113
],
[
58,
114
],
[
153,
116
],
[
120,
119
],
[
148,
124
],
[
159,
127
],
[
142,
131
],
[
148,
132
],
[
151,
134
],
[
119,
135
],
[
119,
136
],
[
160,
139
],
[
154,
139
],
[
141,
142
],
[
144,
145
],
[
150,
148
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
]
] | [
"\nNMAX = 55\n\nN, A = map(int, input().split())\nX = list(map(int, input().split()))\n\ndp = [[[0] * NMAX for s in range(3000)] for i in range(NMAX)]\n\ndp[0][0][0] = 1 # dp[i][s][k]: i個からk個選ぶとき、総和がsのものの個数\nfor i in range(N): # N-1時点でNが更新されるのでここまでで十分\n for s in range(3000):\n for k in range(N+1):\n if dp[i][s][k] == 0:\n continue\n dp[i+1][s][k] += dp[i][s][k]\n dp[i+1][s+X[i]][k+1] += dp[i][s][k]\n\nans = 0\nfor k in range(1, N+1):\n ans += dp[N][A*k][k]\n\nprint(ans)",
"NMAX = 55",
"NMAX",
"55",
"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] * NMAX for s in range(3000)] for i in range(NMAX)",
"for i in range(NMAX)",
"i",
"range(NMAX)",
"range",
"NMAX",
"for i in range(NMAX)",
"[[0] * NMAX for s in range(3000)]",
"dp = [[[0] * NMAX for s in range(3000)] for i in range(NMAX)]",
"dp",
"[[[0] * NMAX for s in range(3000)] for i in range(NMAX)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for i in range(N): # N-1時点でNが更新されるのでここまでで十分\n for s in range(3000):\n for k in range(N+1):\n if dp[i][s][k] == 0:\n continue\n dp[i+1][s][k] += dp[i][s][k]\n dp[i+1][s+X[i]][k+1] += dp[i][s][k]",
"i",
"range(N)",
"range",
"N",
"for s in range(3000):\n for k in range(N+1):\n if dp[i][s][k] == 0:\n continue\n dp[i+1][s][k] += dp[i][s][k]\n dp[i+1][s+X[i]][k+1] += dp[i][s][k]",
"s",
"range(3000)",
"range",
"3000",
"for k in range(N+1):\n if dp[i][s][k] == 0:\n continue\n dp[i+1][s][k] += dp[i][s][k]\n dp[i+1][s+X[i]][k+1] += dp[i][s][k]",
"k",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"if dp[i][s][k] == 0:\n continue\n ",
"dp[i][s][k] == 0",
"dp[i][s][k]",
"[s]",
"[i]",
"dp",
"i",
"s",
"k",
"0",
"continue",
"dp[i+1][s][k] += dp[i][s][k]",
"dp[i+1][s][k]",
"[s]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"s",
"k",
"dp[i][s][k]",
"[s]",
"[i]",
"dp",
"i",
"s",
"k",
"dp[i+1][s+X[i]][k+1] += dp[i][s][k]",
"dp[i+1][s+X[i]][k+1]",
"[s+X[i]]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"s+X[i]",
"s",
"X[i]",
"X",
"i",
"k+1",
"k",
"1",
"dp[i][s][k]",
"[s]",
"[i]",
"dp",
"i",
"s",
"k",
"ans = 0",
"ans",
"0",
"for k in range(1, N+1):\n ans += dp[N][A*k][k]",
"k",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[N][A*k][k]",
"ans",
"dp[N][A*k][k]",
"[A*k]",
"[N]",
"dp",
"N",
"A*k",
"A",
"k",
"k",
"print(ans)",
"print",
"ans",
"dp = [[[0] * NMAX for s in range(3000)] for i in range(NMAX)]",
"[[[0] * NMAX for s in range(3000)] for i in range(NMAX)]",
"dp",
"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",
"ans = 0",
"0",
"ans",
"NMAX = 55",
"55",
"NMAX",
"ans += dp[N][A*k][k]",
"dp[N][A*k][k]",
"ans"
] |
NMAX = 55
N, A = map(int, input().split())
X = list(map(int, input().split()))
dp = [[[0] * NMAX for s in range(3000)] for i in range(NMAX)]
dp[0][0][0] = 1 # dp[i][s][k]: i個からk個選ぶとき、総和がsのものの個数
for i in range(N): # N-1時点でNが更新されるのでここまでで十分
for s in range(3000):
for k in range(N+1):
if dp[i][s][k] == 0:
continue
dp[i+1][s][k] += dp[i][s][k]
dp[i+1][s+X[i]][k+1] += dp[i][s][k]
ans = 0
for k in range(1, N+1):
ans += dp[N][A*k][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,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
13,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
18,
13,
13,
13,
17,
0,
18,
18,
13,
2,
13,
18,
13,
13,
2,
13,
17,
18,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
2,
13,
13,
0,
13,
18,
18,
13,
13,
13,
4,
13,
2,
13,
17,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] | [
[
141,
2
],
[
141,
11
],
[
129,
13
],
[
144,
25
],
[
130,
28
],
[
32,
31
],
[
145,
35
],
[
135,
40
],
[
48,
43
],
[
136,
45
],
[
145,
46
],
[
142,
47
],
[
51,
50
],
[
142,
53
],
[
56,
55
],
[
145,
59
],
[
63,
62
],
[
142,
66
],
[
136,
72
],
[
55,
73
],
[
62,
74
],
[
88,
77
],
[
136,
79
],
[
55,
81
],
[
130,
83
],
[
50,
84
],
[
62,
86
],
[
136,
90
],
[
55,
91
],
[
62,
92
],
[
138,
94
],
[
98,
97
],
[
145,
101
],
[
105,
104
],
[
142,
108
],
[
97,
112
],
[
104,
114
],
[
133,
115
],
[
147,
117
],
[
136,
120
],
[
97,
121
],
[
104,
122
],
[
148,
126
],
[
139,
126
],
[
129,
130
],
[
141,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
],
[
147,
148
]
] | [
"n,a=map(int,input().split())\nli=list(map(int,input().split()))\n\nmax_a=sum(li)\n\ndp=[[ 0 for _ in range(n+1)]for _ in range(max_a+1)]\ndp[max_a][n]=1\n\nfor j in range(n):\n for i in range(max_a+1):\n for k in range(n+1):\n if dp[i][k]>0:\n dp[i-li[j]][k-1]+=dp[i][k]\n \n \nans=0\nfor f in range(max_a+1):\n for g in range(n+1):\n if f==g*a:\n ans+=dp[f][g]\n \n \nprint(ans-1)",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"li=list(map(int,input().split()))",
"li",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"max_a=sum(li)",
"max_a",
"sum(li)",
"sum",
"li",
"[ 0 for _ in range(n+1)]for _ in range(max_a+1)",
"for _ in range(max_a+1)",
"_",
"range(max_a+1)",
"range",
"max_a+1",
"max_a",
"1",
"for _ in range(max_a+1)",
"[ 0 for _ in range(n+1)]",
"dp=[[ 0 for _ in range(n+1)]for _ in range(max_a+1)]",
"dp",
"[[ 0 for _ in range(n+1)]for _ in range(max_a+1)]",
"dp[max_a][n]=1",
"dp[max_a][n]",
"[max_a]",
"dp",
"max_a",
"n",
"1",
"for j in range(n):\n for i in range(max_a+1):\n for k in range(n+1):\n if dp[i][k]>0:\n dp[i-li[j]][k-1]+=dp[i][k]\n \n ",
"j",
"range(n)",
"range",
"n",
"for i in range(max_a+1):\n for k in range(n+1):\n if dp[i][k]>0:\n dp[i-li[j]][k-1]+=dp[i][k]\n \n ",
"i",
"range(max_a+1)",
"range",
"max_a+1",
"max_a",
"1",
"for k in range(n+1):\n if dp[i][k]>0:\n dp[i-li[j]][k-1]+=dp[i][k]\n \n ",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if dp[i][k]>0:\n dp[i-li[j]][k-1]+=dp[i][k]\n \n ",
"dp[i][k]>0",
"dp[i][k]",
"[i]",
"dp",
"i",
"k",
"0",
"dp[i-li[j]][k-1]+=dp[i][k]",
"dp[i-li[j]][k-1]",
"[i-li[j]]",
"dp",
"i-li[j]",
"i",
"li[j]",
"li",
"j",
"k-1",
"k",
"1",
"dp[i][k]",
"[i]",
"dp",
"i",
"k",
"ans=0",
"ans",
"0",
"for f in range(max_a+1):\n for g in range(n+1):\n if f==g*a:\n ans+=dp[f][g]\n \n ",
"f",
"range(max_a+1)",
"range",
"max_a+1",
"max_a",
"1",
"for g in range(n+1):\n if f==g*a:\n ans+=dp[f][g]\n \n ",
"g",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if f==g*a:\n ans+=dp[f][g]\n \n ",
"f==g*a",
"f",
"g*a",
"g",
"a",
"ans+=dp[f][g]",
"ans",
"dp[f][g]",
"[f]",
"dp",
"f",
"g",
"print(ans-1)",
"print",
"ans-1",
"ans",
"1",
"li=list(map(int,input().split()))",
"list(map(int,input().split()))",
"li",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"dp=[[ 0 for _ in range(n+1)]for _ in range(max_a+1)]",
"[[ 0 for _ in range(n+1)]for _ in range(max_a+1)]",
"dp",
"ans=0",
"0",
"ans",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"max_a=sum(li)",
"sum(li)",
"max_a",
"ans+=dp[f][g]",
"dp[f][g]",
"ans"
] | n,a=map(int,input().split())
li=list(map(int,input().split()))
max_a=sum(li)
dp=[[ 0 for _ in range(n+1)]for _ in range(max_a+1)]
dp[max_a][n]=1
for j in range(n):
for i in range(max_a+1):
for k in range(n+1):
if dp[i][k]>0:
dp[i-li[j]][k-1]+=dp[i][k]
ans=0
for f in range(max_a+1):
for g in range(n+1):
if f==g*a:
ans+=dp[f][g]
print(ans-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,
14,
40,
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,
18,
18,
18,
13,
2,
13,
17,
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,
18,
13,
10,
17,
13,
10,
4,
13
] | [
[
136,
2
],
[
136,
11
],
[
148,
13
],
[
27,
26
],
[
139,
33
],
[
43,
36
],
[
140,
39
],
[
46,
45
],
[
134,
48
],
[
51,
50
],
[
134,
53
],
[
56,
55
],
[
55,
62
],
[
149,
64
],
[
45,
65
],
[
83,
68
],
[
140,
71
],
[
45,
73
],
[
50,
76
],
[
55,
79
],
[
149,
81
],
[
45,
82
],
[
140,
86
],
[
45,
87
],
[
50,
88
],
[
55,
89
],
[
100,
91
],
[
140,
94
],
[
45,
96
],
[
50,
98
],
[
55,
99
],
[
140,
103
],
[
45,
104
],
[
50,
105
],
[
55,
106
],
[
145,
108
],
[
112,
111
],
[
134,
116
],
[
142,
119
],
[
140,
123
],
[
134,
124
],
[
111,
125
],
[
111,
127
],
[
137,
128
],
[
143,
131
],
[
146,
131
],
[
136,
134
],
[
136,
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 _ in range(51)] for _ in range(51)]\ndp[0][0][0] = 1\n\nfor i in range(n):\n for j in range(n):\n for k in range(2501):\n if k + x[i] <= 2500:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]\n dp[i+1][j][k] += dp[i][j][k]\n\n\nans = 0\nfor j in range(1, n+1):\n ans += dp[n][j][j * 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] * 2501 for _ in range(51)] for _ in range(51)",
"for _ in range(51)",
"_",
"range(51)",
"range",
"51",
"for _ in range(51)",
"[[0] * 2501 for _ in range(51)]",
"dp = [[[0] * 2501 for _ in range(51)] for _ in range(51)]",
"dp",
"[[[0] * 2501 for _ in range(51)] for _ 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(2501):\n if k + x[i] <= 2500:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]\n dp[i+1][j][k] += dp[i][j][k]",
"i",
"range(n)",
"range",
"n",
"for j in range(n):\n for k in range(2501):\n if k + x[i] <= 2500:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]\n dp[i+1][j][k] += dp[i][j][k]",
"j",
"range(n)",
"range",
"n",
"for k in range(2501):\n if k + x[i] <= 2500:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]\n dp[i+1][j][k] += dp[i][j][k]",
"k",
"range(2501)",
"range",
"2501",
"if k + x[i] <= 2500:\n dp[i+1][j+1][k+x[i]] += dp[i][j][k]\n ",
"k + x[i] <= 2500",
"k + x[i]",
"k",
"x[i]",
"x",
"i",
"2500",
"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",
"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",
"ans = 0",
"ans",
"0",
"for j in range(1, n+1):\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",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"dp = [[[0] * 2501 for _ in range(51)] for _ in range(51)]",
"[[[0] * 2501 for _ in range(51)] for _ in range(51)]",
"dp",
"ans += dp[n][j][j * a]",
"dp[n][j][j * a]",
"ans",
"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] * 2501 for _ in range(51)] for _ in range(51)]
dp[0][0][0] = 1
for i in range(n):
for j in range(n):
for k in range(2501):
if k + x[i] <= 2500:
dp[i+1][j+1][k+x[i]] += dp[i][j][k]
dp[i+1][j][k] += dp[i][j][k]
ans = 0
for j in range(1, n+1):
ans += dp[n][j][j * 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,
17,
12,
13,
14,
2,
4,
13,
13,
17,
29,
2,
39,
13,
18,
13,
17,
0,
13,
39,
0,
13,
18,
13,
39,
17,
28,
13,
4,
13,
18,
13,
17,
4,
18,
13,
13,
4,
13,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
39,
2,
13,
17,
2,
13,
17,
13,
17,
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,
18,
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,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13
] | [
[
204,
2
],
[
204,
11
],
[
210,
13
],
[
207,
25
],
[
69,
33
],
[
69,
40
],
[
44,
43
],
[
47,
46
],
[
69,
48
],
[
53,
52
],
[
69,
56
],
[
43,
60
],
[
46,
64
],
[
71,
65
],
[
43,
67
],
[
69,
69
],
[
71,
71
],
[
219,
73
],
[
211,
77
],
[
201,
80
],
[
214,
82
],
[
199,
85
],
[
199,
88
],
[
100,
93
],
[
202,
96
],
[
103,
102
],
[
199,
105
],
[
108,
107
],
[
199,
110
],
[
113,
112
],
[
220,
116
],
[
211,
118
],
[
102,
119
],
[
136,
121
],
[
202,
124
],
[
102,
126
],
[
107,
129
],
[
112,
132
],
[
211,
134
],
[
102,
135
],
[
202,
139
],
[
102,
140
],
[
107,
141
],
[
112,
142
],
[
153,
144
],
[
202,
147
],
[
102,
149
],
[
107,
151
],
[
112,
152
],
[
202,
156
],
[
102,
157
],
[
107,
158
],
[
112,
159
],
[
216,
161
],
[
165,
164
],
[
199,
169
],
[
173,
172
],
[
220,
177
],
[
164,
182
],
[
205,
183
],
[
172,
184
],
[
222,
186
],
[
144,
187
],
[
202,
190
],
[
164,
192
],
[
172,
193
],
[
223,
196
],
[
217,
196
],
[
208,
196
],
[
204,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
],
[
216,
217
],
[
219,
220
],
[
144,
222
],
[
222,
223
]
] | [
"N,A = map(int,input().split())\nX = list(map(int,input().split()))\nans = 0\n\ndef make_array(dims,fill):\n if len(dims) == 1:\n return [fill]*dims[0]\n ret = []\n nxt = dims[1:]\n for i in range(dims[0]):\n ret.append(make_array(nxt,fill))\n return ret\nS = sum(X)+1\ndp = make_array([N+2,N+2,S],0)\ndp[0][0][0] = 1\nfor i in range(N):\n for j in range(N):\n for s in range(S-X[i]):\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]\n dp[i+1][j][s] += dp[i][j][s]\nans = 0\nfor j in range(1,N+1):\n for s in range(1,S+1):\n if j*A == s:\n ans += dp[-2][j][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",
"ans = 0",
"ans",
"0",
"def make_array(dims,fill):\n if len(dims) == 1:\n return [fill]*dims[0]\n ret = []\n nxt = dims[1:]\n for i in range(dims[0]):\n ret.append(make_array(nxt,fill))\n return ret",
"make_array",
"if len(dims) == 1:\n return [fill]*dims[0]\n ",
"len(dims) == 1",
"len(dims)",
"len",
"dims",
"1",
"return [fill]*dims[0]",
"[fill]*dims[0]",
"[fill]",
"fill",
"dims[0]",
"dims",
"0",
"ret = []",
"ret",
"[]",
"nxt = dims[1:]",
"nxt",
"dims[1:]",
"dims",
"1:",
"1",
"for i in range(dims[0]):\n ret.append(make_array(nxt,fill))\n ",
"i",
"range(dims[0])",
"range",
"dims[0]",
"dims",
"0",
"ret.append(make_array(nxt,fill))",
"ret.append",
"ret",
"append",
"make_array(nxt,fill)",
"make_array",
"nxt",
"fill",
"return ret",
"ret",
"dims",
"dims",
"fill",
"fill",
"S = sum(X)+1",
"S",
"sum(X)+1",
"sum(X)",
"sum",
"X",
"1",
"dp = make_array([N+2,N+2,S],0)",
"dp",
"make_array([N+2,N+2,S],0)",
"make_array",
"[N+2,N+2,S]",
"N+2",
"N",
"2",
"N+2",
"N",
"2",
"S",
"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(N):\n for s in range(S-X[i]):\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]\n dp[i+1][j][s] += dp[i][j][s]",
"i",
"range(N)",
"range",
"N",
"for j in range(N):\n for s in range(S-X[i]):\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]\n dp[i+1][j][s] += dp[i][j][s]",
"j",
"range(N)",
"range",
"N",
"for s in range(S-X[i]):\n dp[i+1][j+1][s+X[i]] += dp[i][j][s]\n dp[i+1][j][s] += dp[i][j][s]",
"s",
"range(S-X[i])",
"range",
"S-X[i]",
"S",
"X[i]",
"X",
"i",
"dp[i+1][j+1][s+X[i]] += dp[i][j][s]",
"dp[i+1][j+1][s+X[i]]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"s+X[i]",
"s",
"X[i]",
"X",
"i",
"dp[i][j][s]",
"[j]",
"[i]",
"dp",
"i",
"j",
"s",
"dp[i+1][j][s] += dp[i][j][s]",
"dp[i+1][j][s]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"s",
"dp[i][j][s]",
"[j]",
"[i]",
"dp",
"i",
"j",
"s",
"ans = 0",
"ans",
"0",
"for j in range(1,N+1):\n for s in range(1,S+1):\n if j*A == s:\n ans += dp[-2][j][s]",
"j",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for s in range(1,S+1):\n if j*A == s:\n ans += dp[-2][j][s]",
"s",
"range(1,S+1)",
"range",
"1",
"S+1",
"S",
"1",
"if j*A == s:\n ans += dp[-2][j][s]",
"j*A == s",
"j*A",
"j",
"A",
"s",
"ans += dp[-2][j][s]",
"ans",
"dp[-2][j][s]",
"[j]",
"[-2]",
"dp",
"-2",
"j",
"s",
"print(ans)",
"print",
"ans",
"N,A = map(int,input().split())",
"map(int,input().split())",
"N",
"dp = make_array([N+2,N+2,S],0)",
"make_array([N+2,N+2,S],0)",
"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",
"def make_array(dims,fill):\n if len(dims) == 1:\n return [fill]*dims[0]\n ret = []\n nxt = dims[1:]\n for i in range(dims[0]):\n ret.append(make_array(nxt,fill))\n return ret",
"def make_array(dims,fill):\n if len(dims) == 1:\n return [fill]*dims[0]\n ret = []\n nxt = dims[1:]\n for i in range(dims[0]):\n ret.append(make_array(nxt,fill))\n return ret",
"make_array",
"ans = 0",
"0",
"ans",
"S = sum(X)+1",
"sum(X)+1",
"S",
"ans += dp[-2][j][s]",
"dp[-2][j][s]",
"ans"
] | N,A = map(int,input().split())
X = list(map(int,input().split()))
ans = 0
def make_array(dims,fill):
if len(dims) == 1:
return [fill]*dims[0]
ret = []
nxt = dims[1:]
for i in range(dims[0]):
ret.append(make_array(nxt,fill))
return ret
S = sum(X)+1
dp = make_array([N+2,N+2,S],0)
dp[0][0][0] = 1
for i in range(N):
for j in range(N):
for s in range(S-X[i]):
dp[i+1][j+1][s+X[i]] += dp[i][j][s]
dp[i+1][j][s] += dp[i][j][s]
ans = 0
for j in range(1,N+1):
for s in range(1,S+1):
if j*A == s:
ans += dp[-2][j][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,
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,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
18,
13
] | [
[
135,
2
],
[
135,
11
],
[
132,
13
],
[
27,
26
],
[
130,
30
],
[
138,
35
],
[
45,
38
],
[
139,
41
],
[
48,
47
],
[
130,
50
],
[
53,
52
],
[
47,
56
],
[
60,
59
],
[
73,
64
],
[
139,
67
],
[
47,
69
],
[
52,
71
],
[
59,
72
],
[
139,
76
],
[
47,
77
],
[
52,
78
],
[
59,
79
],
[
96,
81
],
[
139,
84
],
[
47,
86
],
[
52,
89
],
[
59,
92
],
[
133,
94
],
[
47,
95
],
[
139,
99
],
[
47,
100
],
[
52,
101
],
[
59,
102
],
[
141,
104
],
[
108,
107
],
[
130,
112
],
[
144,
115
],
[
139,
119
],
[
130,
120
],
[
107,
121
],
[
107,
123
],
[
136,
124
],
[
145,
127
],
[
142,
127
],
[
135,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
]
] | [
"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\nfor i in range(n):\n for j in range(i + 1):\n for k in range(2451):\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 j in range(1, n + 1):\n ans += dp[n][j][j * 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] * 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(i + 1):\n for k in range(2451):\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(i + 1):\n for k in range(2451):\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(i + 1)",
"range",
"i + 1",
"i",
"1",
"for k in range(2451):\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(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[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 j in range(1, n + 1):\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",
"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] * 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",
"ans += dp[n][j][j * a]",
"dp[n][j][j * 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
for i in range(n):
for j in range(i + 1):
for k in range(2451):
dp[i + 1][j][k] += dp[i][j][k]
dp[i + 1][j + 1][k + x[i]] += dp[i][j][k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * 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,
17,
0,
13,
2,
39,
17,
4,
13,
13,
28,
13,
4,
13,
4,
13,
13,
0,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
13,
0,
13,
2,
2,
13,
13,
17,
41,
28,
13,
4,
13,
13,
4,
13,
0,
13,
13,
0,
18,
18,
13,
2,
18,
13,
17,
13,
17,
17,
0,
18,
18,
13,
13,
17,
2,
18,
18,
13,
13,
17,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
13,
14,
2,
40,
17,
2,
13,
18,
13,
2,
13,
17,
13,
0,
18,
18,
13,
13,
2,
13,
17,
2,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
18,
13,
2,
13,
17,
13,
0,
18,
18,
13,
13,
2,
13,
17,
18,
18,
13,
13,
13,
4,
13,
2,
18,
18,
13,
13,
2,
13,
17,
17,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13
] | [
[
215,
2
],
[
215,
11
],
[
221,
13
],
[
218,
25
],
[
203,
28
],
[
222,
34
],
[
37,
36
],
[
222,
41
],
[
46,
43
],
[
204,
44
],
[
36,
45
],
[
222,
48
],
[
36,
49
],
[
216,
50
],
[
206,
52
],
[
224,
55
],
[
59,
58
],
[
201,
61
],
[
43,
64
],
[
204,
65
],
[
58,
66
],
[
209,
69
],
[
43,
70
],
[
204,
71
],
[
58,
72
],
[
43,
75
],
[
204,
76
],
[
58,
77
],
[
230,
80
],
[
43,
81
],
[
204,
82
],
[
58,
83
],
[
227,
85
],
[
210,
88
],
[
207,
88
],
[
231,
89
],
[
225,
89
],
[
94,
93
],
[
228,
96
],
[
212,
100
],
[
112,
103
],
[
213,
105
],
[
219,
105
],
[
204,
108
],
[
210,
110
],
[
207,
110
],
[
119,
114
],
[
213,
116
],
[
219,
116
],
[
210,
117
],
[
207,
117
],
[
213,
122
],
[
219,
122
],
[
210,
123
],
[
207,
123
],
[
128,
127
],
[
201,
131
],
[
135,
134
],
[
228,
137
],
[
134,
143
],
[
204,
145
],
[
127,
147
],
[
228,
149
],
[
158,
151
],
[
213,
153
],
[
219,
153
],
[
134,
154
],
[
127,
156
],
[
213,
161
],
[
219,
161
],
[
134,
162
],
[
127,
163
],
[
213,
166
],
[
219,
166
],
[
134,
168
],
[
204,
170
],
[
127,
172
],
[
127,
174
],
[
183,
176
],
[
213,
178
],
[
219,
178
],
[
134,
179
],
[
127,
181
],
[
213,
185
],
[
219,
185
],
[
134,
186
],
[
127,
187
],
[
213,
193
],
[
219,
193
],
[
210,
194
],
[
207,
194
],
[
201,
196
],
[
215,
201
],
[
203,
204
],
[
206,
207
],
[
43,
209
],
[
209,
210
],
[
212,
213
],
[
215,
216
],
[
218,
219
],
[
221,
222
],
[
224,
225
],
[
227,
228
],
[
43,
230
],
[
230,
231
]
] | [
"N,A=map(int,input().split())\nx=list(map(int,input().split()))\nans=0\ny=[0]*(len(x))\nfor k in range(len(x)):\n y[k]=x[k]-A\nminus=0\nplus=0\nfor k in range(N):\n if y[k]<0:\n minus-=y[k]\n if y[k]>0:\n plus+=y[k]\ntotal=minus+plus+1\nans=[[0 for i in range(N)]for j in range(total)]\nans[y[0]+minus][0]=1\nans[minus][0]=ans[minus][0]+1\nfor j in range(N-1):\n for t in range(total):\n if 0<=t-y[j+1]<total:\n ans[t][j+1] =ans[t][j]+ans[t-y[j+1]][j]\n else:\n ans[t][j+1] =ans[t][j]\nprint(ans[minus][N-1]-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",
"ans=0",
"ans",
"0",
"y=[0]*(len(x))",
"y",
"[0]*(len(x))",
"[0]",
"0",
"len(x)",
"len",
"x",
"for k in range(len(x)):\n y[k]=x[k]-A",
"k",
"range(len(x))",
"range",
"len(x)",
"len",
"x",
"y[k]=x[k]-A",
"y[k]",
"y",
"k",
"x[k]-A",
"x[k]",
"x",
"k",
"A",
"minus=0",
"minus",
"0",
"plus=0",
"plus",
"0",
"for k in range(N):\n if y[k]<0:\n minus-=y[k]\n if y[k]>0:\n plus+=y[k]",
"k",
"range(N)",
"range",
"N",
"if y[k]<0:\n minus-=y[k]\n ",
"y[k]<0",
"y[k]",
"y",
"k",
"0",
"minus-=y[k]",
"minus",
"y[k]",
"y",
"k",
"if y[k]>0:\n plus+=y[k]",
"y[k]>0",
"y[k]",
"y",
"k",
"0",
"plus+=y[k]",
"plus",
"y[k]",
"y",
"k",
"total=minus+plus+1",
"total",
"minus+plus+1",
"minus+plus",
"minus",
"plus",
"1",
"[0 for i in range(N)]for j in range(total)",
"for j in range(total)",
"j",
"range(total)",
"range",
"total",
"for j in range(total)",
"[0 for i in range(N)]",
"ans=[[0 for i in range(N)]for j in range(total)]",
"ans",
"[[0 for i in range(N)]for j in range(total)]",
"ans[y[0]+minus][0]=1",
"ans[y[0]+minus][0]",
"[y[0]+minus]",
"ans",
"y[0]+minus",
"y[0]",
"y",
"0",
"minus",
"0",
"1",
"ans[minus][0]=ans[minus][0]+1",
"ans[minus][0]",
"[minus]",
"ans",
"minus",
"0",
"ans[minus][0]+1",
"ans[minus][0]",
"[minus]",
"ans",
"minus",
"0",
"1",
"for j in range(N-1):\n for t in range(total):\n if 0<=t-y[j+1]<total:\n ans[t][j+1] =ans[t][j]+ans[t-y[j+1]][j]\n else:\n ans[t][j+1] =ans[t][j]",
"j",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"for t in range(total):\n if 0<=t-y[j+1]<total:\n ans[t][j+1] =ans[t][j]+ans[t-y[j+1]][j]\n else:\n ans[t][j+1] =ans[t][j]",
"t",
"range(total)",
"range",
"total",
"if 0<=t-y[j+1]<total:\n ans[t][j+1] =ans[t][j]+ans[t-y[j+1]][j]\n else:\n ans[t][j+1] =ans[t][j]",
"0<=t-y[j+1]<total",
"0<=t-y[j+1]",
"0",
"t-y[j+1]",
"t",
"y[j+1]",
"y",
"j+1",
"j",
"1",
"total",
"ans[t][j+1] =ans[t][j]+ans[t-y[j+1]][j]",
"ans[t][j+1]",
"[t]",
"ans",
"t",
"j+1",
"j",
"1",
"ans[t][j]+ans[t-y[j+1]][j]",
"ans[t][j]",
"[t]",
"ans",
"t",
"j",
"ans[t-y[j+1]][j]",
"[t-y[j+1]]",
"ans",
"t-y[j+1]",
"t",
"y[j+1]",
"y",
"j+1",
"j",
"1",
"j",
"ans[t][j+1] =ans[t][j]",
"ans[t][j+1]",
"[t]",
"ans",
"t",
"j+1",
"j",
"1",
"ans[t][j]",
"[t]",
"ans",
"t",
"j",
"print(ans[minus][N-1]-1)",
"print",
"ans[minus][N-1]-1",
"ans[minus][N-1]",
"[minus]",
"ans",
"minus",
"N-1",
"N",
"1",
"1",
"N,A=map(int,input().split())",
"map(int,input().split())",
"N",
"y=[0]*(len(x))",
"[0]*(len(x))",
"y",
"minus=0",
"0",
"minus",
"minus-=y[k]",
"y[k]",
"minus",
"ans=[[0 for i in range(N)]for j in range(total)]",
"[[0 for i in range(N)]for j in range(total)]",
"ans",
"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",
"plus=0",
"0",
"plus",
"total=minus+plus+1",
"minus+plus+1",
"total",
"plus+=y[k]",
"y[k]",
"plus"
] | N,A=map(int,input().split())
x=list(map(int,input().split()))
ans=0
y=[0]*(len(x))
for k in range(len(x)):
y[k]=x[k]-A
minus=0
plus=0
for k in range(N):
if y[k]<0:
minus-=y[k]
if y[k]>0:
plus+=y[k]
total=minus+plus+1
ans=[[0 for i in range(N)]for j in range(total)]
ans[y[0]+minus][0]=1
ans[minus][0]=ans[minus][0]+1
for j in range(N-1):
for t in range(total):
if 0<=t-y[j+1]<total:
ans[t][j+1] =ans[t][j]+ans[t-y[j+1]][j]
else:
ans[t][j+1] =ans[t][j]
print(ans[minus][N-1]-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,
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,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
76,
3
],
[
76,
12
],
[
82,
14
],
[
28,
27
],
[
83,
27
],
[
27,
31
],
[
74,
32
],
[
85,
34
],
[
79,
37
],
[
45,
42
],
[
80,
43
],
[
48,
47
],
[
86,
47
],
[
83,
47
],
[
80,
56
],
[
64,
59
],
[
80,
60
],
[
47,
63
],
[
80,
69
],
[
76,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
]
] | [
"from collections import defaultdict\n\nN, A = map(int, input().split())\nX = list(map(int, input().split()))\nX =[x - A for x in X]\n\nd = defaultdict(int)\nd[0] = 1\n\nfor x in X:\n for k, v in list(d.items()):\n d[k+x] += v\n\nprint(d[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 - 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]",
"d = defaultdict(int)",
"d",
"defaultdict(int)",
"defaultdict",
"int",
"d[0] = 1",
"d[0]",
"d",
"0",
"1",
"for x in X:\n for k, v in list(d.items()):\n d[k+x] += v",
"x",
"X",
"for k, v in list(d.items()):\n d[k+x] += v",
"k",
"v",
"list(d.items())",
"list",
"d.items()",
"d.items",
"d",
"items",
"d[k+x] += v",
"d[k+x]",
"d",
"k+x",
"k",
"x",
"v",
"print(d[0]-1)",
"print",
"d[0]-1",
"d[0]",
"d",
"0",
"1",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"d = defaultdict(int)",
"defaultdict(int)",
"d",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"X =[x - A for x in X]",
"[x - A for x in X]",
"X"
] | from collections import defaultdict
N, A = map(int, input().split())
X = list(map(int, input().split()))
X =[x - A for x in X]
d = defaultdict(int)
d[0] = 1
for x in X:
for k, v in list(d.items()):
d[k+x] += v
print(d[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,
0,
13,
4,
13,
4,
13,
12,
2,
13,
13,
23,
13,
0,
13,
4,
13,
4,
13,
13,
13,
12,
13,
41,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
14,
2,
40,
13,
17,
2,
2,
13,
2,
18,
13,
2,
13,
17,
2,
13,
13,
2,
13,
2,
18,
13,
2,
13,
17,
2,
13,
13,
29,
4,
13,
2,
13,
17,
13,
14,
2,
2,
40,
13,
17,
40,
13,
2,
18,
13,
2,
13,
17,
2,
13,
13,
40,
13,
2,
18,
13,
2,
13,
17,
2,
13,
13,
29,
2,
4,
13,
2,
13,
17,
13,
4,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
29,
17,
23,
13,
23,
13,
0,
13,
4,
4,
13,
0,
13,
17,
13,
4,
13,
2,
4,
13,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
177,
3
],
[
177,
12
],
[
171,
14
],
[
180,
26
],
[
178,
34
],
[
172,
36
],
[
165,
38
],
[
172,
43
],
[
178,
44
],
[
175,
46
],
[
149,
46
],
[
144,
51
],
[
146,
54
],
[
144,
61
],
[
146,
65
],
[
144,
70
],
[
169,
73
],
[
166,
74
],
[
146,
76
],
[
144,
81
],
[
169,
84
],
[
166,
85
],
[
144,
90
],
[
146,
92
],
[
144,
97
],
[
146,
100
],
[
144,
105
],
[
169,
108
],
[
166,
109
],
[
146,
111
],
[
144,
116
],
[
169,
119
],
[
166,
120
],
[
144,
126
],
[
146,
128
],
[
144,
132
],
[
146,
135
],
[
144,
139
],
[
144,
144
],
[
146,
146
],
[
175,
148
],
[
149,
148
],
[
154,
153
],
[
175,
155
],
[
149,
155
],
[
175,
160
],
[
169,
161
],
[
165,
166
],
[
177,
169
],
[
171,
172
],
[
175,
175
],
[
149,
175
],
[
177,
178
],
[
180,
181
]
] | [
"from functools import lru_cache\n\nN, A = map(int, input().split())\nx = list(map(int, input().split()))\ny = list(map(lambda i: i - A, x))\nX = max(max(x), A)\n\n@lru_cache(maxsize=None)\ndef solve(j, t):\n global y\n if j == 0 and t == 0:\n return 1\n elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):\n return solve(j - 1, t)\n elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:\n return solve(j - 1, t) + solve(j - 1, t - y[j - 1])\n else:\n return 0\n\nprint(solve(N, 0) - 1)",
"from functools import lru_cache",
"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",
"y = list(map(lambda i: i - A, x))",
"y",
"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",
"X = max(max(x), A)",
"X",
"max(max(x), A)",
"max",
"max(x)",
"max",
"x",
"A",
"def solve(j, t):\n global y\n if j == 0 and t == 0:\n return 1\n elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):\n return solve(j - 1, t)\n elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:\n return solve(j - 1, t) + solve(j - 1, t - y[j - 1])\n else:\n return 0",
"solve",
"global y",
"if j == 0 and t == 0:\n return 1\n elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):\n return solve(j - 1, t)\n elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:\n return solve(j - 1, t) + solve(j - 1, t - y[j - 1])\n else:\n return 0",
"j == 0 and t == 0",
"j == 0",
"j",
"0",
"t == 0",
"t",
"0",
"return 1",
"1",
"elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):\n return solve(j - 1, t)\n ",
"j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X)",
"j >= 1",
"j",
"1",
"t < y[j - 1] - N * X or t > y[j - 1] + N * X",
"t < y[j - 1] - N * X",
"t",
"y[j - 1] - N * X",
"y[j - 1]",
"y",
"j - 1",
"j",
"1",
"N * X",
"N",
"X",
"t > y[j - 1] + N * X",
"t",
"y[j - 1] + N * X",
"y[j - 1]",
"y",
"j - 1",
"j",
"1",
"N * X",
"N",
"X",
"return solve(j - 1, t)",
"solve(j - 1, t)",
"solve",
"j - 1",
"j",
"1",
"t",
"elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:\n return solve(j - 1, t) + solve(j - 1, t - y[j - 1])\n ",
"j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X",
"j >= 1 and t >= y[j - 1] - N * X",
"j >= 1",
"j",
"1",
"t >= y[j - 1] - N * X",
"t",
"y[j - 1] - N * X",
"y[j - 1]",
"y",
"j - 1",
"j",
"1",
"N * X",
"N",
"X",
"t <= y[j - 1] + N * X",
"t",
"y[j - 1] + N * X",
"y[j - 1]",
"y",
"j - 1",
"j",
"1",
"N * X",
"N",
"X",
"return solve(j - 1, t) + solve(j - 1, t - y[j - 1])",
"solve(j - 1, t) + solve(j - 1, t - y[j - 1])",
"solve(j - 1, t)",
"solve",
"j - 1",
"j",
"1",
"t",
"solve(j - 1, t - y[j - 1])",
"solve",
"j - 1",
"j",
"1",
"t - y[j - 1]",
"t",
"y[j - 1]",
"y",
"j - 1",
"j",
"1",
"return 0",
"0",
"j",
"j",
"t",
"t",
"@lru_cache(maxsize=None)",
"solve",
"maxsize=None",
"@lru_cache(maxsize=None)",
"lru_cache",
"maxsize=None",
"maxsize",
"None",
"solve",
"print(solve(N, 0) - 1)",
"print",
"solve(N, 0) - 1",
"solve(N, 0)",
"solve",
"N",
"0",
"1",
"X = max(max(x), A)",
"max(max(x), A)",
"X",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"def solve(j, t):\n global y\n if j == 0 and t == 0:\n return 1\n elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):\n return solve(j - 1, t)\n elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:\n return solve(j - 1, t) + solve(j - 1, t - y[j - 1])\n else:\n return 0",
"def solve(j, t):\n global y\n if j == 0 and t == 0:\n return 1\n elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):\n return solve(j - 1, t)\n elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:\n return solve(j - 1, t) + solve(j - 1, t - y[j - 1])\n else:\n return 0",
"solve",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"y = list(map(lambda i: i - A, x))",
"list(map(lambda i: i - A, x))",
"y"
] | from functools import lru_cache
N, A = map(int, input().split())
x = list(map(int, input().split()))
y = list(map(lambda i: i - A, x))
X = max(max(x), A)
@lru_cache(maxsize=None)
def solve(j, t):
global y
if j == 0 and t == 0:
return 1
elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):
return solve(j - 1, t)
elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:
return solve(j - 1, t) + solve(j - 1, t - y[j - 1])
else:
return 0
print(solve(N, 0) - 1)
|
[
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,
0,
13,
2,
18,
13,
17,
17,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
21,
13
] | [
[
84,
2
],
[
84,
11
],
[
81,
13
],
[
76,
23
],
[
87,
31
],
[
38,
37
],
[
82,
37
],
[
88,
46
],
[
54,
49
],
[
88,
50
],
[
37,
52
],
[
88,
57
],
[
37,
60
],
[
78,
65
],
[
88,
68
],
[
79,
73
],
[
84,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
]
] | [
"n, a = map(int, input().split())\nx = list(map(lambda x: int(x) - a, input().split()))\nd = {0: 1}\nfor i in x:\n for j, k in list(d.items()):\n d[i + j] = d.get(i + j, 0) + k\nans = d[0] - 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(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 i in x:\n for j, k in list(d.items()):\n d[i + j] = d.get(i + j, 0) + k",
"i",
"x",
"for j, k in list(d.items()):\n d[i + j] = d.get(i + j, 0) + k",
"j",
"k",
"list(d.items())",
"list",
"d.items()",
"d.items",
"d",
"items",
"d[i + j] = d.get(i + j, 0) + k",
"d[i + j]",
"d",
"i + j",
"i",
"j",
"d.get(i + j, 0) + k",
"d.get(i + j, 0)",
"d.get",
"d",
"get",
"i + j",
"i",
"j",
"0",
"k",
"ans = d[0] - 1",
"ans",
"d[0] - 1",
"d[0]",
"d",
"0",
"1",
"print(ans)",
"print",
"ans",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"ans = d[0] - 1",
"d[0] - 1",
"ans",
"x = list(map(lambda x: int(x) - a, input().split()))",
"list(map(lambda x: int(x) - a, input().split()))",
"x",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"d = {0: 1}",
"{0: 1}",
"d"
] | n, a = map(int, input().split())
x = list(map(lambda x: int(x) - a, input().split()))
d = {0: 1}
for i in x:
for j, k in list(d.items()):
d[i + j] = d.get(i + j, 0) + k
ans = d[0] - 1
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,
0,
13,
2,
4,
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,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
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,
14,
2,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
13,
13,
10,
18,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
17,
13
] | [
[
4,
3
],
[
3,
12
],
[
162,
14
],
[
162,
16
],
[
20,
19
],
[
19,
28
],
[
165,
30
],
[
159,
33
],
[
166,
37
],
[
42,
41
],
[
163,
45
],
[
150,
50
],
[
60,
53
],
[
151,
56
],
[
63,
62
],
[
163,
65
],
[
68,
67
],
[
163,
71
],
[
75,
74
],
[
160,
77
],
[
88,
79
],
[
151,
82
],
[
62,
84
],
[
67,
86
],
[
74,
87
],
[
151,
91
],
[
62,
92
],
[
67,
93
],
[
74,
94
],
[
111,
96
],
[
151,
99
],
[
62,
101
],
[
67,
104
],
[
74,
107
],
[
166,
109
],
[
62,
110
],
[
151,
114
],
[
62,
115
],
[
67,
116
],
[
74,
117
],
[
168,
119
],
[
123,
122
],
[
163,
127
],
[
122,
132
],
[
157,
133
],
[
160,
134
],
[
153,
136
],
[
151,
140
],
[
163,
141
],
[
122,
142
],
[
122,
144
],
[
157,
145
],
[
154,
148
],
[
169,
148
],
[
150,
151
],
[
153,
154
],
[
162,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
],
[
168,
169
]
] | [
"N, A = [int(x) for x in input().split()]\nX = [int(x) for x in input().split()]\n\nXX = sum(X) + 1\n\ndp = [[[0 for i in range(XX * 2)] for i in range(N + 3)] for i in range(N + 3)]\n\ndp[0][0][0] = 1\n\nfor i in range(N):\n for j in range(N + 1):\n for n in range(XX):\n dp[i + 1][j][n] += dp[i][j][n]\n dp[i + 1][j + 1][n + X[i]] += dp[i][j][n]\n\nans = 0\nfor i in range(1, N + 1):\n if i * A < XX:\n ans += dp[N][i][i * A]\n\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()]",
"XX = sum(X) + 1",
"XX",
"sum(X) + 1",
"sum(X)",
"sum",
"X",
"1",
"[[0 for i in range(XX * 2)] for i in range(N + 3)] for i in range(N + 3)",
"for i in range(N + 3)",
"i",
"range(N + 3)",
"range",
"N + 3",
"N",
"3",
"for i in range(N + 3)",
"[[0 for i in range(XX * 2)] for i in range(N + 3)]",
"dp = [[[0 for i in range(XX * 2)] for i in range(N + 3)] for i in range(N + 3)]",
"dp",
"[[[0 for i in range(XX * 2)] for i in range(N + 3)] for i in range(N + 3)]",
"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 n in range(XX):\n dp[i + 1][j][n] += dp[i][j][n]\n dp[i + 1][j + 1][n + X[i]] += dp[i][j][n]",
"i",
"range(N)",
"range",
"N",
"for j in range(N + 1):\n for n in range(XX):\n dp[i + 1][j][n] += dp[i][j][n]\n dp[i + 1][j + 1][n + X[i]] += dp[i][j][n]",
"j",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for n in range(XX):\n dp[i + 1][j][n] += dp[i][j][n]\n dp[i + 1][j + 1][n + X[i]] += dp[i][j][n]",
"n",
"range(XX)",
"range",
"XX",
"dp[i + 1][j][n] += dp[i][j][n]",
"dp[i + 1][j][n]",
"[j]",
"[i + 1]",
"dp",
"i + 1",
"i",
"1",
"j",
"n",
"dp[i][j][n]",
"[j]",
"[i]",
"dp",
"i",
"j",
"n",
"dp[i + 1][j + 1][n + X[i]] += dp[i][j][n]",
"dp[i + 1][j + 1][n + X[i]]",
"[j + 1]",
"[i + 1]",
"dp",
"i + 1",
"i",
"1",
"j + 1",
"j",
"1",
"n + X[i]",
"n",
"X[i]",
"X",
"i",
"dp[i][j][n]",
"[j]",
"[i]",
"dp",
"i",
"j",
"n",
"ans = 0",
"ans",
"0",
"for i in range(1, N + 1):\n if i * A < XX:\n ans += dp[N][i][i * A]",
"i",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"if i * A < XX:\n ans += dp[N][i][i * A]",
"i * A < XX",
"i * A",
"i",
"A",
"XX",
"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",
"dp = [[[0 for i in range(XX * 2)] for i in range(N + 3)] for i in range(N + 3)]",
"[[[0 for i in range(XX * 2)] for i in range(N + 3)] for i in range(N + 3)]",
"dp",
"ans += dp[N][i][i * A]",
"dp[N][i][i * A]",
"ans",
"A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"A",
"XX = sum(X) + 1",
"sum(X) + 1",
"XX",
"N, A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"N",
"X = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"X",
"ans = 0",
"0",
"ans"
] | N, A = [int(x) for x in input().split()]
X = [int(x) for x in input().split()]
XX = sum(X) + 1
dp = [[[0 for i in range(XX * 2)] for i in range(N + 3)] for i in range(N + 3)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N + 1):
for n in range(XX):
dp[i + 1][j][n] += dp[i][j][n]
dp[i + 1][j + 1][n + X[i]] += dp[i][j][n]
ans = 0
for i in range(1, N + 1):
if i * A < XX:
ans += dp[N][i][i * A]
print(ans) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
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,
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,
2,
13,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
14,
40,
2,
13,
18,
13,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
13,
18,
18,
18,
13,
13,
13,
2,
13,
18,
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,
29,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
12,
13
] | [
[
165,
4
],
[
15,
14
],
[
166,
18
],
[
14,
23
],
[
26,
25
],
[
26,
27
],
[
31,
30
],
[
166,
34
],
[
30,
39
],
[
42,
41
],
[
46,
45
],
[
25,
49
],
[
55,
54
],
[
64,
57
],
[
54,
60
],
[
67,
66
],
[
25,
69
],
[
72,
71
],
[
25,
74
],
[
77,
76
],
[
25,
81
],
[
27,
82
],
[
94,
85
],
[
54,
88
],
[
66,
90
],
[
71,
92
],
[
76,
93
],
[
54,
97
],
[
66,
98
],
[
71,
99
],
[
76,
100
],
[
76,
104
],
[
41,
106
],
[
66,
107
],
[
121,
110
],
[
54,
113
],
[
66,
115
],
[
71,
118
],
[
76,
120
],
[
54,
124
],
[
66,
125
],
[
71,
126
],
[
76,
128
],
[
41,
130
],
[
66,
131
],
[
134,
133
],
[
137,
136
],
[
25,
141
],
[
145,
144
],
[
54,
148
],
[
25,
149
],
[
136,
150
],
[
136,
152
],
[
27,
153
],
[
144,
156
],
[
133,
156
],
[
169,
163
],
[
165,
166
]
] | [
"import sys\ninput = sys.stdin.readline\n\ndef main():\n N, A = (int(_) for _ in input().split())\n X = [int(_) for _ in input().split()]\n\n dp = [[[0] * (N*A+1) for _ in range(N+1)] for __ in range(N+1)]\n\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(N*A+1):\n dp[i+1][j][k] += dp[i][j][k]\n if k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\n ret = 0\n for i in range(1, N+1):\n ret += dp[N][i][i*A]\n print(ret)\n return\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 N, A = (int(_) for _ in input().split())\n X = [int(_) for _ in input().split()]\n\n dp = [[[0] * (N*A+1) for _ in range(N+1)] for __ in range(N+1)]\n\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(N*A+1):\n dp[i+1][j][k] += dp[i][j][k]\n if k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\n ret = 0\n for i in range(1, N+1):\n ret += dp[N][i][i*A]\n print(ret)\n return",
"main",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"N, A = (int(_) for _ in input().split())",
"N",
"(int(_) for _ in input().split())",
"A",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"X = [int(_) for _ in input().split()]",
"X",
"[int(_) for _ in input().split()]",
"[[0] * (N*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] * (N*A+1) for _ in range(N+1)]",
"dp = [[[0] * (N*A+1) for _ in range(N+1)] for __ in range(N+1)]",
"dp",
"[[[0] * (N*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):\n for j in range(N):\n for k in range(N*A+1):\n dp[i+1][j][k] += dp[i][j][k]\n if k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\n ",
"i",
"range(N)",
"range",
"N",
"for j in range(N):\n for k in range(N*A+1):\n dp[i+1][j][k] += dp[i][j][k]\n if k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\n ",
"j",
"range(N)",
"range",
"N",
"for k in range(N*A+1):\n dp[i+1][j][k] += dp[i][j][k]\n if k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\n ",
"k",
"range(N*A+1)",
"range",
"N*A+1",
"N*A",
"N",
"A",
"1",
"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 k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\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+1][j+1][k]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"k",
"dp[i][j][k-X[i]]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k-X[i]",
"k",
"X[i]",
"X",
"i",
"ret = 0",
"ret",
"0",
"for i in range(1, N+1):\n ret += dp[N][i][i*A]\n ",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ret += dp[N][i][i*A]",
"ret",
"dp[N][i][i*A]",
"[i]",
"[N]",
"dp",
"N",
"i",
"i*A",
"i",
"A",
"print(ret)",
"print",
"ret",
"return",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"def main():\n N, A = (int(_) for _ in input().split())\n X = [int(_) for _ in input().split()]\n\n dp = [[[0] * (N*A+1) for _ in range(N+1)] for __ in range(N+1)]\n\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(N*A+1):\n dp[i+1][j][k] += dp[i][j][k]\n if k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\n ret = 0\n for i in range(1, N+1):\n ret += dp[N][i][i*A]\n print(ret)\n return",
"def main():\n N, A = (int(_) for _ in input().split())\n X = [int(_) for _ in input().split()]\n\n dp = [[[0] * (N*A+1) for _ in range(N+1)] for __ in range(N+1)]\n\n dp[0][0][0] = 1\n for i in range(N):\n for j in range(N):\n for k in range(N*A+1):\n dp[i+1][j][k] += dp[i][j][k]\n if k - X[i] >= 0:\n dp[i+1][j+1][k] += dp[i][j][k-X[i]]\n ret = 0\n for i in range(1, N+1):\n ret += dp[N][i][i*A]\n print(ret)\n return",
"main"
] | import sys
input = sys.stdin.readline
def main():
N, A = (int(_) for _ in input().split())
X = [int(_) for _ in input().split()]
dp = [[[0] * (N*A+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(N*A+1):
dp[i+1][j][k] += dp[i][j][k]
if k - X[i] >= 0:
dp[i+1][j+1][k] += dp[i][j][k-X[i]]
ret = 0
for i in range(1, N+1):
ret += dp[N][i][i*A]
print(ret)
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,
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,
2,
17,
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,
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,
13,
13,
10,
4,
13
] | [
[
140,
2
],
[
140,
11
],
[
146,
13
],
[
27,
26
],
[
132,
30
],
[
143,
35
],
[
45,
38
],
[
144,
41
],
[
48,
47
],
[
132,
50
],
[
53,
52
],
[
132,
55
],
[
58,
57
],
[
132,
63
],
[
75,
66
],
[
144,
69
],
[
47,
71
],
[
52,
73
],
[
57,
74
],
[
144,
78
],
[
47,
79
],
[
52,
80
],
[
57,
81
],
[
98,
83
],
[
144,
86
],
[
47,
88
],
[
52,
91
],
[
57,
94
],
[
147,
96
],
[
47,
97
],
[
144,
101
],
[
47,
102
],
[
52,
103
],
[
57,
104
],
[
134,
106
],
[
110,
109
],
[
132,
114
],
[
137,
117
],
[
144,
121
],
[
132,
122
],
[
109,
123
],
[
141,
125
],
[
109,
126
],
[
138,
129
],
[
135,
129
],
[
140,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\n\ndp = [[[0]*(50*(N+1)+1) for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0] = 1\n\nfor i in range(N):\n for k in range(N):\n for s in range(50*N+1):\n dp[i+1][k][s] += dp[i][k][s]\n dp[i+1][k+1][s+X[i]] += dp[i][k][s]\n\nans = 0\nfor k in range(1, N+1):\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",
"[[0]*(50*(N+1)+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]*(50*(N+1)+1) for _ in range(N+1)]",
"dp = [[[0]*(50*(N+1)+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0]*(50*(N+1)+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 k in range(N):\n for s in range(50*N+1):\n dp[i+1][k][s] += dp[i][k][s]\n dp[i+1][k+1][s+X[i]] += dp[i][k][s]",
"i",
"range(N)",
"range",
"N",
"for k in range(N):\n for s in range(50*N+1):\n dp[i+1][k][s] += dp[i][k][s]\n dp[i+1][k+1][s+X[i]] += dp[i][k][s]",
"k",
"range(N)",
"range",
"N",
"for s in range(50*N+1):\n dp[i+1][k][s] += dp[i][k][s]\n dp[i+1][k+1][s+X[i]] += dp[i][k][s]",
"s",
"range(50*N+1)",
"range",
"50*N+1",
"50*N",
"50",
"N",
"1",
"dp[i+1][k][s] += dp[i][k][s]",
"dp[i+1][k][s]",
"[k]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k",
"s",
"dp[i][k][s]",
"[k]",
"[i]",
"dp",
"i",
"k",
"s",
"dp[i+1][k+1][s+X[i]] += dp[i][k][s]",
"dp[i+1][k+1][s+X[i]]",
"[k+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"k+1",
"k",
"1",
"s+X[i]",
"s",
"X[i]",
"X",
"i",
"dp[i][k][s]",
"[k]",
"[i]",
"dp",
"i",
"k",
"s",
"ans = 0",
"ans",
"0",
"for k in range(1, N+1):\n ans += dp[N][k][A*k]",
"k",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"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",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans = 0",
"0",
"ans",
"ans += dp[N][k][A*k]",
"dp[N][k][A*k]",
"ans",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"dp = [[[0]*(50*(N+1)+1) for _ in range(N+1)] for _ in range(N+1)]",
"[[[0]*(50*(N+1)+1) for _ in range(N+1)] for _ in range(N+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()))
dp = [[[0]*(50*(N+1)+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for k in range(N):
for s in range(50*N+1):
dp[i+1][k][s] += dp[i][k][s]
dp[i+1][k+1][s+X[i]] += dp[i][k][s]
ans = 0
for k in range(1, N+1):
ans += dp[N][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,
41,
28,
13,
4,
13,
2,
13,
17,
4,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
13,
17,
17,
28,
13,
13,
4,
18,
18,
13,
2,
13,
17,
13,
0,
18,
18,
13,
13,
2,
13,
13,
2,
4,
18,
18,
13,
13,
13,
2,
13,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
4,
18,
18,
13,
13,
13,
2,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13
] | [
[
137,
2
],
[
137,
11
],
[
122,
13
],
[
27,
26
],
[
138,
30
],
[
125,
35
],
[
43,
38
],
[
126,
40
],
[
46,
45
],
[
138,
48
],
[
134,
50
],
[
123,
52
],
[
45,
53
],
[
56,
55
],
[
138,
58
],
[
126,
67
],
[
55,
69
],
[
80,
73
],
[
126,
75
],
[
55,
76
],
[
135,
78
],
[
126,
84
],
[
55,
85
],
[
135,
88
],
[
119,
93
],
[
97,
96
],
[
138,
101
],
[
131,
104
],
[
126,
108
],
[
96,
109
],
[
96,
112
],
[
129,
113
],
[
132,
117
],
[
120,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
137,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\ns = [{} for i in range(N+1)]\ns[0][0] = 1\n\nfor i in range(N):\n cur = X[i]\n for j in range(N, 0, -1):\n for k, v in s[j-1].items():\n s[j][cur + k] = s[j].get(cur + k, 0) + v\n\nans = 0\nfor i in range(1, N+1):\n ans += s[i].get(i*A, 0)\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",
"{} 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)",
"{}",
"s = [{} for i in range(N+1)]",
"s",
"[{} for i in range(N+1)]",
"s[0][0] = 1",
"s[0][0]",
"[0]",
"s",
"0",
"0",
"1",
"for i in range(N):\n cur = X[i]\n for j in range(N, 0, -1):\n for k, v in s[j-1].items():\n s[j][cur + k] = s[j].get(cur + k, 0) + v",
"i",
"range(N)",
"range",
"N",
"cur = X[i]",
"cur",
"X[i]",
"X",
"i",
"for j in range(N, 0, -1):\n for k, v in s[j-1].items():\n s[j][cur + k] = s[j].get(cur + k, 0) + v",
"j",
"range(N, 0, -1)",
"range",
"N",
"0",
"-1",
"for k, v in s[j-1].items():\n s[j][cur + k] = s[j].get(cur + k, 0) + v",
"k",
"v",
"s[j-1].items()",
"[j-1].items",
"[j-1]",
"s",
"j-1",
"j",
"1",
"items",
"s[j][cur + k] = s[j].get(cur + k, 0) + v",
"s[j][cur + k]",
"[j]",
"s",
"j",
"cur + k",
"cur",
"k",
"s[j].get(cur + k, 0) + v",
"s[j].get(cur + k, 0)",
"[j].get",
"[j]",
"s",
"j",
"get",
"cur + k",
"cur",
"k",
"0",
"v",
"ans = 0",
"ans",
"0",
"for i in range(1, N+1):\n ans += s[i].get(i*A, 0)",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += s[i].get(i*A, 0)",
"ans",
"s[i].get(i*A, 0)",
"[i].get",
"[i]",
"s",
"i",
"get",
"i*A",
"i",
"A",
"0",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"s = [{} for i in range(N+1)]",
"[{} for i in range(N+1)]",
"s",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"ans += s[i].get(i*A, 0)",
"s[i].get(i*A, 0)",
"ans",
"cur = X[i]",
"X[i]",
"cur",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N"
] | N, A = map(int, input().split())
X = list(map(int, input().split()))
s = [{} for i in range(N+1)]
s[0][0] = 1
for i in range(N):
cur = X[i]
for j in range(N, 0, -1):
for k, v in s[j-1].items():
s[j][cur + k] = s[j].get(cur + k, 0) + v
ans = 0
for i in range(1, N+1):
ans += s[i].get(i*A, 0)
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,
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,
2,
13,
13,
17,
14,
2,
40,
13,
18,
13,
2,
13,
17,
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,
2,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
18,
18,
13,
13,
2,
13,
17,
2,
2,
13,
17,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
16,
15
],
[
28,
27
],
[
32,
31
],
[
4,
35
],
[
41,
40
],
[
50,
43
],
[
40,
46
],
[
53,
52
],
[
4,
57
],
[
61,
60
],
[
4,
64
],
[
68,
67
],
[
4,
72
],
[
27,
73
],
[
67,
78
],
[
15,
80
],
[
52,
82
],
[
60,
85
],
[
95,
88
],
[
40,
91
],
[
52,
92
],
[
60,
93
],
[
67,
94
],
[
40,
99
],
[
52,
101
],
[
60,
103
],
[
67,
104
],
[
40,
108
],
[
52,
110
],
[
60,
113
],
[
67,
116
],
[
15,
118
],
[
52,
120
],
[
130,
123
],
[
40,
126
],
[
52,
127
],
[
60,
128
],
[
67,
129
],
[
40,
133
],
[
52,
135
],
[
60,
137
],
[
67,
138
],
[
141,
140
],
[
144,
143
],
[
4,
146
],
[
149,
148
],
[
40,
152
],
[
4,
153
],
[
143,
155
],
[
143,
159
],
[
13,
161
],
[
148,
164
],
[
140,
164
],
[
173,
170
]
] | [
"#!/usr/bin/env python3\n\n\ndef main():\n N, A = map(int, input().split())\n x = list(map(int, input().split()))\n X = 50\n dp = [[[0]*(N*X +1) for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for j in range(1,N+1):\n for k in range(N+1):\n for s in range(N*X+1):\n if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ans = 0\n for i in range(N):\n ans += dp[N][i+1][(i+1)*A]\n print(ans)\n\nif __name__ == \"__main__\":\n main()",
"def main():\n N, A = map(int, input().split())\n x = list(map(int, input().split()))\n X = 50\n dp = [[[0]*(N*X +1) for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for j in range(1,N+1):\n for k in range(N+1):\n for s in range(N*X+1):\n if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ans = 0\n for i in range(N):\n ans += dp[N][i+1][(i+1)*A]\n print(ans)",
"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 = 50",
"X",
"50",
"[[0]*(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)",
"[[0]*(N*X +1) for _ in range(N+1)]",
"dp = [[[0]*(N*X +1) for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0]*(N*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 j in range(1,N+1):\n for k in range(N+1):\n for s in range(N*X+1):\n if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ",
"j",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for k in range(N+1):\n for s in range(N*X+1):\n if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ",
"k",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for s in range(N*X+1):\n if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ",
"s",
"range(N*X+1)",
"range",
"N*X+1",
"N*X",
"N",
"X",
"1",
"if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ",
"s >= x[j-1] and k >= 1",
"s >= x[j-1]",
"s",
"x[j-1]",
"x",
"j-1",
"j",
"1",
"k >= 1",
"k",
"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] = 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",
"ans = 0",
"ans",
"0",
"for i in range(N):\n ans += dp[N][i+1][(i+1)*A]\n ",
"i",
"range(N)",
"range",
"N",
"ans += dp[N][i+1][(i+1)*A]",
"ans",
"dp[N][i+1][(i+1)*A]",
"[i+1]",
"[N]",
"dp",
"N",
"i+1",
"i",
"1",
"(i+1)*A",
"i+1",
"i",
"1",
"A",
"print(ans)",
"print",
"ans",
"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 = 50\n dp = [[[0]*(N*X +1) for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for j in range(1,N+1):\n for k in range(N+1):\n for s in range(N*X+1):\n if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ans = 0\n for i in range(N):\n ans += dp[N][i+1][(i+1)*A]\n print(ans)",
"def main():\n N, A = map(int, input().split())\n x = list(map(int, input().split()))\n X = 50\n dp = [[[0]*(N*X +1) for _ in range(N+1)] for _ in range(N+1)]\n dp[0][0][0] = 1\n for j in range(1,N+1):\n for k in range(N+1):\n for s in range(N*X+1):\n if s >= x[j-1] and k >= 1:\n dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]\n else:# x[j]を選ぶと合計sにできない\n dp[j][k][s] = dp[j-1][k][s]\n ans = 0\n for i in range(N):\n ans += dp[N][i+1][(i+1)*A]\n print(ans)",
"main"
] | #!/usr/bin/env python3
def main():
N, A = map(int, input().split())
x = list(map(int, input().split()))
X = 50
dp = [[[0]*(N*X +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(N+1):
for s in range(N*X+1):
if s >= x[j-1] and k >= 1:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
else:# x[j]を選ぶと合計sにできない
dp[j][k][s] = dp[j-1][k][s]
ans = 0
for i in range(N):
ans += dp[N][i+1][(i+1)*A]
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,
28,
13,
4,
13,
13,
0,
18,
13,
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,
4,
13,
10,
4,
13,
10,
13,
13,
10,
21,
13,
10,
4,
13
] | [
[
109,
2
],
[
109,
11
],
[
100,
13
],
[
26,
25
],
[
98,
28
],
[
33,
30
],
[
101,
31
],
[
25,
32
],
[
110,
33
],
[
106,
35
],
[
42,
41
],
[
101,
41
],
[
46,
45
],
[
107,
45
],
[
107,
51
],
[
45,
52
],
[
103,
54
],
[
58,
57
],
[
104,
57
],
[
57,
63
],
[
41,
65
],
[
107,
66
],
[
75,
68
],
[
107,
69
],
[
57,
72
],
[
41,
74
],
[
57,
76
],
[
86,
79
],
[
107,
80
],
[
57,
83
],
[
41,
85
],
[
57,
87
],
[
107,
93
],
[
109,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\nfor i in range(N):\n X[i] -= A\nD = {0: 1}\nfor i in X:\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",
"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",
"D = {0: 1}",
"D",
"{0: 1}",
"0",
"0",
"1",
"for i in X:\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",
"X",
"[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",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"S = [[j, D[j]] for j in D]",
"[[j, D[j]] for j in D]",
"S",
"D = {0: 1}",
"{0: 1}",
"D",
"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
D = {0: 1}
for i in X:
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,
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,
28,
13,
4,
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,
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
] | [
[
5,
4
],
[
5,
13
],
[
16,
15
],
[
29,
28
],
[
4,
32
],
[
4,
41
],
[
45,
44
],
[
52,
47
],
[
44,
49
],
[
55,
54
],
[
4,
57
],
[
60,
59
],
[
54,
65
],
[
69,
68
],
[
4,
75
],
[
15,
78
],
[
54,
79
],
[
92,
81
],
[
44,
83
],
[
59,
85
],
[
68,
88
],
[
15,
90
],
[
54,
91
],
[
44,
94
],
[
59,
95
],
[
68,
96
],
[
99,
98
],
[
102,
101
],
[
4,
106
],
[
110,
109
],
[
44,
112
],
[
101,
113
],
[
101,
115
],
[
13,
116
],
[
109,
118
],
[
98,
118
],
[
125,
122
]
] | [
"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 for i in reversed(range(k+1)):\n for j in range(50 * N + 1 -x[k]):\n dp[i+1][j+x[k]] += dp[i][j]\n r = 0\n for i in range(1, N+1):\n r += dp[i][i*A]\n return r\nprint(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 for i in reversed(range(k+1)):\n for j in range(50 * N + 1 -x[k]):\n dp[i+1][j+x[k]] += dp[i][j]\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 for i in reversed(range(k+1)):\n for j in range(50 * N + 1 -x[k]):\n dp[i+1][j+x[k]] += dp[i][j]\n ",
"k",
"range(N)",
"range",
"N",
"for i in reversed(range(k+1)):\n for j in range(50 * N + 1 -x[k]):\n dp[i+1][j+x[k]] += dp[i][j]\n ",
"i",
"reversed(range(k+1))",
"reversed",
"range(k+1)",
"range",
"k+1",
"k",
"1",
"for j in range(50 * N + 1 -x[k]):\n dp[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",
"dp[i+1][j+x[k]] += dp[i][j]",
"dp[i+1][j+x[k]]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+x[k]",
"j",
"x[k]",
"x",
"k",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"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 for i in reversed(range(k+1)):\n for j in range(50 * N + 1 -x[k]):\n dp[i+1][j+x[k]] += dp[i][j]\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 for i in reversed(range(k+1)):\n for j in range(50 * N + 1 -x[k]):\n dp[i+1][j+x[k]] += dp[i][j]\n r = 0\n for i in range(1, N+1):\n r += dp[i][i*A]\n return r",
"main"
] | 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):
for i in reversed(range(k+1)):
for j in range(50 * N + 1 -x[k]):
dp[i+1][j+x[k]] += dp[i][j]
r = 0
for i in range(1, N+1):
r += dp[i][i*A]
return r
print(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,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
4,
13,
13,
41,
28,
13,
13,
4,
39,
13,
18,
13,
13,
0,
13,
13,
28,
13,
13,
14,
2,
2,
18,
13,
17,
18,
13,
13,
13,
0,
18,
13,
2,
18,
13,
17,
18,
13,
13,
18,
13,
17,
0,
18,
13,
2,
18,
13,
17,
18,
13,
13,
18,
13,
17,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
21,
13,
10,
13,
13,
10,
4,
13
] | [
[
117,
2
],
[
117,
11
],
[
105,
13
],
[
26,
25
],
[
109,
28
],
[
33,
30
],
[
106,
31
],
[
25,
32
],
[
118,
33
],
[
111,
35
],
[
42,
41
],
[
109,
44
],
[
48,
47
],
[
112,
47
],
[
112,
53
],
[
47,
54
],
[
114,
56
],
[
60,
59
],
[
115,
59
],
[
59,
65
],
[
30,
67
],
[
106,
68
],
[
41,
69
],
[
112,
70
],
[
81,
72
],
[
112,
73
],
[
59,
76
],
[
30,
78
],
[
106,
79
],
[
41,
80
],
[
59,
82
],
[
94,
85
],
[
112,
86
],
[
59,
89
],
[
30,
91
],
[
106,
92
],
[
41,
93
],
[
59,
95
],
[
112,
101
],
[
105,
106
],
[
117,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\nfor i in range(N):\n X[i] -= A\nD = {0: 1}\nfor i in range(N):\n F = [[j, D[j]] for j in D]\n for j in F:\n if j[0] + X[i] in D:\n D[j[0] + X[i]] += j[1]\n else:\n D[j[0] + X[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",
"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",
"D = {0: 1}",
"D",
"{0: 1}",
"0",
"0",
"1",
"for i in range(N):\n F = [[j, D[j]] for j in D]\n for j in F:\n if j[0] + X[i] in D:\n D[j[0] + X[i]] += j[1]\n else:\n D[j[0] + X[i]] = j[1]",
"i",
"range(N)",
"range",
"N",
"[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",
"F = [[j, D[j]] for j in D]",
"F",
"[[j, D[j]] for j in D]",
"for j in F:\n if j[0] + X[i] in D:\n D[j[0] + X[i]] += j[1]\n else:\n D[j[0] + X[i]] = j[1]",
"j",
"F",
"if j[0] + X[i] in D:\n D[j[0] + X[i]] += j[1]\n else:\n D[j[0] + X[i]] = j[1]",
"j[0] + X[i] in D",
"j[0] + X[i]",
"j[0]",
"j",
"0",
"X[i]",
"X",
"i",
"D",
"D[j[0] + X[i]] += j[1]",
"D[j[0] + X[i]]",
"D",
"j[0] + X[i]",
"j[0]",
"j",
"0",
"X[i]",
"X",
"i",
"j[1]",
"j",
"1",
"D[j[0] + X[i]] = j[1]",
"D[j[0] + X[i]]",
"D",
"j[0] + X[i]",
"j[0]",
"j",
"0",
"X[i]",
"X",
"i",
"j[1]",
"j",
"1",
"print(D[0]-1)",
"print",
"D[0]-1",
"D[0]",
"D",
"0",
"1",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"D = {0: 1}",
"{0: 1}",
"D",
"F = [[j, D[j]] for j in D]",
"[[j, D[j]] for j in D]",
"F",
"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
D = {0: 1}
for i in range(N):
F = [[j, D[j]] for j in D]
for j in F:
if j[0] + X[i] in D:
D[j[0] + X[i]] += j[1]
else:
D[j[0] + X[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,
4,
18,
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,
10,
13,
13,
10,
21,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
93,
2
],
[
93,
11
],
[
90,
13
],
[
91,
26
],
[
31,
30
],
[
91,
30
],
[
30,
34
],
[
88,
35
],
[
81,
37
],
[
84,
40
],
[
47,
46
],
[
82,
46
],
[
91,
46
],
[
85,
55
],
[
63,
58
],
[
85,
59
],
[
46,
61
],
[
85,
66
],
[
46,
69
],
[
85,
77
],
[
81,
82
],
[
84,
85
],
[
93,
88
],
[
90,
91
],
[
93,
94
]
] | [
"n, a = map(int, input().split())\nx = list(map(int, input().split()))\n\nx.sort()\nx = [i - a for i in x]\n# print(x)\nD = {0 : 1}\nfor i in x:\n for j, k in list(D.items()):\n D[i+j] = D.get(i+j, 0) + k\n\n # print(D)\nprint(D[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.sort()",
"x.sort",
"x",
"sort",
"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]",
"D = {0 : 1}",
"D",
"{0 : 1}",
"0",
"0",
"1",
"for i in x:\n for j, k in list(D.items()):\n D[i+j] = D.get(i+j, 0) + k\n\n # print(D)",
"i",
"x",
"for j, k in list(D.items()):\n D[i+j] = D.get(i+j, 0) + k\n\n # print(D)",
"j",
"k",
"list(D.items())",
"list",
"D.items()",
"D.items",
"D",
"items",
"D[i+j] = D.get(i+j, 0) + k",
"D[i+j]",
"D",
"i+j",
"i",
"j",
"D.get(i+j, 0) + k",
"D.get(i+j, 0)",
"D.get",
"D",
"get",
"i+j",
"i",
"j",
"0",
"k",
"print(D[0] - 1)",
"print",
"D[0] - 1",
"D[0]",
"D",
"0",
"1",
"x = [i - a for i in x]",
"[i - a for i in x]",
"x",
"D = {0 : 1}",
"{0 : 1}",
"D",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n"
] | n, a = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
x = [i - a for i in x]
# print(x)
D = {0 : 1}
for i in x:
for j, k in list(D.items()):
D[i+j] = D.get(i+j, 0) + k
# print(D)
print(D[0] - 1)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
15,
13,
0,
13,
4,
18,
13,
13,
4,
18,
4,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
39,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
17,
14,
2,
18,
13,
13,
17,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
2,
18,
13,
13,
17,
0,
13,
4,
18,
13,
13,
2,
4,
13,
13,
17,
17,
0,
13,
13,
0,
13,
4,
18,
13,
13,
2,
4,
13,
13,
17,
17,
0,
13,
13,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
17,
17,
14,
40,
18,
13,
13,
17,
0,
18,
13,
2,
13,
13,
18,
13,
13,
28,
13,
13,
28,
13,
4,
13,
2,
4,
13,
13,
17,
17,
17,
14,
40,
18,
13,
13,
17,
0,
18,
13,
2,
13,
13,
18,
13,
13,
0,
13,
2,
2,
17,
13,
17,
28,
13,
4,
13,
17,
4,
13,
4,
13,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
18,
13,
13,
2,
17,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
13,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
246,
2
],
[
246,
11
],
[
228,
15
],
[
27,
26
],
[
234,
29
],
[
247,
30
],
[
237,
32
],
[
231,
35
],
[
216,
38
],
[
42,
41
],
[
235,
46
],
[
229,
46
],
[
235,
50
],
[
229,
50
],
[
41,
51
],
[
219,
54
],
[
235,
59
],
[
229,
59
],
[
41,
60
],
[
238,
64
],
[
235,
67
],
[
229,
67
],
[
41,
68
],
[
232,
71
],
[
235,
75
],
[
229,
75
],
[
41,
76
],
[
213,
79
],
[
238,
87
],
[
92,
91
],
[
243,
94
],
[
232,
102
],
[
107,
106
],
[
112,
109
],
[
214,
110
],
[
117,
114
],
[
244,
115
],
[
120,
119
],
[
238,
119
],
[
123,
122
],
[
214,
128
],
[
214,
135
],
[
122,
136
],
[
144,
139
],
[
214,
140
],
[
122,
142
],
[
119,
143
],
[
214,
145
],
[
122,
146
],
[
149,
148
],
[
232,
148
],
[
152,
151
],
[
244,
157
],
[
244,
164
],
[
151,
165
],
[
173,
168
],
[
244,
169
],
[
151,
171
],
[
148,
172
],
[
244,
174
],
[
151,
175
],
[
240,
177
],
[
220,
181
],
[
217,
181
],
[
185,
184
],
[
214,
192
],
[
244,
195
],
[
225,
197
],
[
214,
201
],
[
184,
202
],
[
244,
204
],
[
184,
205
],
[
220,
208
],
[
217,
208
],
[
226,
211
],
[
241,
211
],
[
213,
214
],
[
216,
217
],
[
219,
220
],
[
246,
223
],
[
225,
226
],
[
228,
229
],
[
231,
232
],
[
247,
234
],
[
234,
235
],
[
237,
238
],
[
240,
241
],
[
243,
244
],
[
246,
247
]
] | [
"n,a=map(int,input().split())\nimport numpy as np\nx=np.array(input().split(),dtype=int)\nx-=a\npluslist=[]\nminuslist=[]\nzerocnt=0\nfor i in range(len(x)):\n if x[i]==0:\n zerocnt+=1\n elif x[i]>0:\n pluslist.append(x[i])\n else:\n minuslist.append(x[i]*(-1))\n\ndpplus=np.full((sum(pluslist)+1),0,dtype=int)\ndpminus=np.full((sum(minuslist)+1),0,dtype=int)\ndpplus[0]=1\ndpminus[0]=1\nfor v in pluslist:\n for i in range(len(dpplus)-1,-1,-1):\n if dpplus[i]!=0:\n dpplus[i+v]+=dpplus[i]\nfor v in minuslist:\n for i in range(len(dpminus)-1,-1,-1):\n if dpminus[i]!=0:\n dpminus[i+v]+=dpminus[i]\n\nans=2**zerocnt-1\nfor i in range(1,min(len(dpplus),len(dpminus))):\n ans+=dpplus[i]*dpminus[i]*(2**zerocnt)\n \nprint(ans)",
"n,a=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"import numpy as np",
"numpy",
"x=np.array(input().split(),dtype=int)",
"x",
"np.array(input().split(),dtype=int)",
"np.array",
"np",
"array",
"input().split()",
"().split",
"()",
"input",
"split",
"dtype=int",
"dtype",
"int",
"x-=a",
"x",
"a",
"pluslist=[]",
"pluslist",
"[]",
"minuslist=[]",
"minuslist",
"[]",
"zerocnt=0",
"zerocnt",
"0",
"for i in range(len(x)):\n if x[i]==0:\n zerocnt+=1\n elif x[i]>0:\n pluslist.append(x[i])\n else:\n minuslist.append(x[i]*(-1))",
"i",
"range(len(x))",
"range",
"len(x)",
"len",
"x",
"if x[i]==0:\n zerocnt+=1\n elif x[i]>0:\n pluslist.append(x[i])\n else:\n minuslist.append(x[i]*(-1))",
"x[i]==0",
"x[i]",
"x",
"i",
"0",
"zerocnt+=1",
"zerocnt",
"1",
"elif x[i]>0:\n pluslist.append(x[i])\n ",
"x[i]>0",
"x[i]",
"x",
"i",
"0",
"pluslist.append(x[i])",
"pluslist.append",
"pluslist",
"append",
"x[i]",
"x",
"i",
"minuslist.append(x[i]*(-1))",
"minuslist.append",
"minuslist",
"append",
"x[i]*(-1)",
"x[i]",
"x",
"i",
"-1",
"dpplus=np.full((sum(pluslist)+1),0,dtype=int)",
"dpplus",
"np.full((sum(pluslist)+1),0,dtype=int)",
"np.full",
"np",
"full",
"sum(pluslist)+1",
"sum(pluslist)",
"sum",
"pluslist",
"1",
"0",
"dtype=int",
"dtype",
"int",
"dpminus=np.full((sum(minuslist)+1),0,dtype=int)",
"dpminus",
"np.full((sum(minuslist)+1),0,dtype=int)",
"np.full",
"np",
"full",
"sum(minuslist)+1",
"sum(minuslist)",
"sum",
"minuslist",
"1",
"0",
"dtype=int",
"dtype",
"int",
"dpplus[0]=1",
"dpplus[0]",
"dpplus",
"0",
"1",
"dpminus[0]=1",
"dpminus[0]",
"dpminus",
"0",
"1",
"for v in pluslist:\n for i in range(len(dpplus)-1,-1,-1):\n if dpplus[i]!=0:\n dpplus[i+v]+=dpplus[i]",
"v",
"pluslist",
"for i in range(len(dpplus)-1,-1,-1):\n if dpplus[i]!=0:\n dpplus[i+v]+=dpplus[i]",
"i",
"range(len(dpplus)-1,-1,-1)",
"range",
"len(dpplus)-1",
"len(dpplus)",
"len",
"dpplus",
"1",
"-1",
"-1",
"if dpplus[i]!=0:\n dpplus[i+v]+=dpplus[i]",
"dpplus[i]!=0",
"dpplus[i]",
"dpplus",
"i",
"0",
"dpplus[i+v]+=dpplus[i]",
"dpplus[i+v]",
"dpplus",
"i+v",
"i",
"v",
"dpplus[i]",
"dpplus",
"i",
"for v in minuslist:\n for i in range(len(dpminus)-1,-1,-1):\n if dpminus[i]!=0:\n dpminus[i+v]+=dpminus[i]",
"v",
"minuslist",
"for i in range(len(dpminus)-1,-1,-1):\n if dpminus[i]!=0:\n dpminus[i+v]+=dpminus[i]",
"i",
"range(len(dpminus)-1,-1,-1)",
"range",
"len(dpminus)-1",
"len(dpminus)",
"len",
"dpminus",
"1",
"-1",
"-1",
"if dpminus[i]!=0:\n dpminus[i+v]+=dpminus[i]",
"dpminus[i]!=0",
"dpminus[i]",
"dpminus",
"i",
"0",
"dpminus[i+v]+=dpminus[i]",
"dpminus[i+v]",
"dpminus",
"i+v",
"i",
"v",
"dpminus[i]",
"dpminus",
"i",
"ans=2**zerocnt-1",
"ans",
"2**zerocnt-1",
"2**zerocnt",
"2",
"zerocnt",
"1",
"for i in range(1,min(len(dpplus),len(dpminus))):\n ans+=dpplus[i]*dpminus[i]*(2**zerocnt)\n ",
"i",
"range(1,min(len(dpplus),len(dpminus)))",
"range",
"1",
"min(len(dpplus),len(dpminus))",
"min",
"len(dpplus)",
"len",
"dpplus",
"len(dpminus)",
"len",
"dpminus",
"ans+=dpplus[i]*dpminus[i]*(2**zerocnt)",
"ans",
"dpplus[i]*dpminus[i]*(2**zerocnt)",
"dpplus[i]*dpminus[i]",
"dpplus[i]",
"dpplus",
"i",
"dpminus[i]",
"dpminus",
"i",
"2**zerocnt",
"2",
"zerocnt",
"print(ans)",
"print",
"ans",
"dpplus=np.full((sum(pluslist)+1),0,dtype=int)",
"np.full((sum(pluslist)+1),0,dtype=int)",
"dpplus",
"zerocnt=0",
"0",
"zerocnt",
"zerocnt+=1",
"1",
"zerocnt",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"ans+=dpplus[i]*dpminus[i]*(2**zerocnt)",
"dpplus[i]*dpminus[i]*(2**zerocnt)",
"ans",
"x=np.array(input().split(),dtype=int)",
"np.array(input().split(),dtype=int)",
"x",
"minuslist=[]",
"[]",
"minuslist",
"x-=a",
"a",
"x",
"pluslist=[]",
"[]",
"pluslist",
"ans=2**zerocnt-1",
"2**zerocnt-1",
"ans",
"dpminus=np.full((sum(minuslist)+1),0,dtype=int)",
"np.full((sum(minuslist)+1),0,dtype=int)",
"dpminus",
"a=map(int,input().split())",
"map(int,input().split())",
"a"
] | n,a=map(int,input().split())
import numpy as np
x=np.array(input().split(),dtype=int)
x-=a
pluslist=[]
minuslist=[]
zerocnt=0
for i in range(len(x)):
if x[i]==0:
zerocnt+=1
elif x[i]>0:
pluslist.append(x[i])
else:
minuslist.append(x[i]*(-1))
dpplus=np.full((sum(pluslist)+1),0,dtype=int)
dpminus=np.full((sum(minuslist)+1),0,dtype=int)
dpplus[0]=1
dpminus[0]=1
for v in pluslist:
for i in range(len(dpplus)-1,-1,-1):
if dpplus[i]!=0:
dpplus[i+v]+=dpplus[i]
for v in minuslist:
for i in range(len(dpminus)-1,-1,-1):
if dpminus[i]!=0:
dpminus[i+v]+=dpminus[i]
ans=2**zerocnt-1
for i in range(1,min(len(dpplus),len(dpminus))):
ans+=dpplus[i]*dpminus[i]*(2**zerocnt)
print(ans) |
[
7,
15,
15,
13,
13,
13,
13,
13,
13,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
12,
13,
12,
13,
12,
13,
23,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
2,
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,
2,
13,
17,
28,
13,
4,
13,
13,
14,
40,
13,
18,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
13,
2,
13,
17,
2,
18,
18,
18,
13,
13,
2,
13,
18,
13,
13,
13,
18,
18,
18,
13,
13,
13,
2,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
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,
18,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
13,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13
] | [
[
204,
18
],
[
33,
33
],
[
195,
35
],
[
217,
37
],
[
195,
38
],
[
219,
40
],
[
217,
42
],
[
213,
44
],
[
196,
46
],
[
220,
51
],
[
193,
52
],
[
56,
55
],
[
196,
59
],
[
201,
64
],
[
74,
67
],
[
202,
70
],
[
77,
76
],
[
196,
79
],
[
82,
81
],
[
214,
85
],
[
89,
88
],
[
196,
91
],
[
81,
94
],
[
220,
96
],
[
76,
97
],
[
110,
99
],
[
202,
102
],
[
76,
104
],
[
81,
106
],
[
88,
108
],
[
202,
114
],
[
76,
115
],
[
81,
117
],
[
220,
119
],
[
76,
120
],
[
88,
121
],
[
202,
125
],
[
76,
126
],
[
81,
127
],
[
88,
129
],
[
141,
132
],
[
202,
135
],
[
76,
137
],
[
81,
139
],
[
88,
140
],
[
202,
144
],
[
76,
145
],
[
81,
146
],
[
88,
147
],
[
210,
149
],
[
153,
152
],
[
214,
157
],
[
161,
160
],
[
196,
165
],
[
152,
170
],
[
160,
171
],
[
193,
172
],
[
186,
174
],
[
202,
178
],
[
196,
179
],
[
152,
180
],
[
160,
181
],
[
187,
184
],
[
211,
184
],
[
186,
187
],
[
195,
193
],
[
195,
196
],
[
201,
202
],
[
204,
205
],
[
210,
211
],
[
213,
214
],
[
219,
220
]
] | [
"from collections import Counter,defaultdict,deque\nimport sys,heapq,bisect,math,itertools,string,queue\nsys.setrecursionlimit(10**8)\nmod = 10**9+7\ndef inp(): return int(sys.stdin.readline())\ndef inpl(): return list(map(int, sys.stdin.readline().split()))\ndef inpl_str(): return list(sys.stdin.readline().split())\ndef inpln(n): return list(int(sys.stdin.readline()) for i in range(n))\n\nn,A = inpl()\nx = inpl()\nnx = n * max(max(x),A)\ndp = [[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)]\ndp[0][0][0] = 1\nfor i in range(n):\n for j in range(nx+1):\n for k in range(n):\n if j >= x[i]:\n dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n\nans = 0\nfor j in range(1,nx+1):\n for k in range(1,n+1):\n if j/k == A:\n ans += dp[n][j][k]\nprint(ans)",
"from collections import Counter,defaultdict,deque",
"import sys,heapq,bisect,math,itertools,string,queue",
"sys",
"heapq",
"bisect",
"math",
"itertools",
"string",
"queue",
"sys.setrecursionlimit(10**8)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**8",
"10",
"8",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def inp(): return int(sys.stdin.readline())",
"inp",
"def inpl(): return list(map(int, sys.stdin.readline().split()))",
"inpl",
"def inpl_str(): return list(sys.stdin.readline().split())",
"inpl_str",
"def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))",
"inpln",
"n",
"n",
"n,A = inpl()",
"n",
"inpl()",
"inpl",
"A",
"x = inpl()",
"x",
"inpl()",
"inpl",
"nx = n * max(max(x),A)",
"nx",
"n * max(max(x),A)",
"n",
"max(max(x),A)",
"max",
"max(x)",
"max",
"x",
"A",
"[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)",
"for j in range(n+5)",
"j",
"range(n+5)",
"range",
"n+5",
"n",
"5",
"for j in range(n+5)",
"[[0 for _ in range(n+5)] for i in range(nx+1)]",
"dp = [[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)]",
"dp",
"[[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)]",
"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(nx+1):\n for k in range(n):\n if j >= x[i]:\n dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]\n else:\n dp[i+1][j][k] = dp[i][j][k]",
"i",
"range(n)",
"range",
"n",
"for j in range(nx+1):\n for k in range(n):\n if j >= x[i]:\n dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]\n else:\n dp[i+1][j][k] = dp[i][j][k]",
"j",
"range(nx+1)",
"range",
"nx+1",
"nx",
"1",
"for k in range(n):\n if j >= x[i]:\n dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]\n else:\n dp[i+1][j][k] = dp[i][j][k]",
"k",
"range(n)",
"range",
"n",
"if j >= x[i]:\n dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]\n else:\n dp[i+1][j][k] = dp[i][j][k]",
"j >= x[i]",
"j",
"x[i]",
"x",
"i",
"dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]",
"dp[i+1][j][k+1]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k+1",
"k",
"1",
"dp[i][j-x[i]][k] + dp[i][j][k+1]",
"dp[i][j-x[i]][k]",
"[j-x[i]]",
"[i]",
"dp",
"i",
"j-x[i]",
"j",
"x[i]",
"x",
"i",
"k",
"dp[i][j][k+1]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k+1",
"k",
"1",
"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",
"ans = 0",
"ans",
"0",
"for j in range(1,nx+1):\n for k in range(1,n+1):\n if j/k == A:\n ans += dp[n][j][k]",
"j",
"range(1,nx+1)",
"range",
"1",
"nx+1",
"nx",
"1",
"for k in range(1,n+1):\n if j/k == A:\n ans += dp[n][j][k]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"if j/k == A:\n ans += dp[n][j][k]",
"j/k == A",
"j/k",
"j",
"k",
"A",
"ans += dp[n][j][k]",
"ans",
"dp[n][j][k]",
"[j]",
"[n]",
"dp",
"n",
"j",
"k",
"print(ans)",
"print",
"ans",
"ans += dp[n][j][k]",
"dp[n][j][k]",
"ans",
"def inpl_str(): return list(sys.stdin.readline().split())",
"def inpl_str(): return list(sys.stdin.readline().split())",
"inpl_str",
"A = inpl()",
"inpl()",
"A",
"n,A = inpl()",
"inpl()",
"n",
"def inp(): return int(sys.stdin.readline())",
"def inp(): return int(sys.stdin.readline())",
"inp",
"dp = [[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)]",
"[[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)]",
"dp",
"mod = 10**9+7",
"10**9+7",
"mod",
"def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))",
"def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))",
"inpln",
"ans = 0",
"0",
"ans",
"nx = n * max(max(x),A)",
"n * max(max(x),A)",
"nx",
"def inpl(): return list(map(int, sys.stdin.readline().split()))",
"def inpl(): return list(map(int, sys.stdin.readline().split()))",
"inpl",
"x = inpl()",
"inpl()",
"x"
] | from collections import Counter,defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,A = inpl()
x = inpl()
nx = n * max(max(x),A)
dp = [[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)]
dp[0][0][0] = 1
for i in range(n):
for j in range(nx+1):
for k in range(n):
if j >= x[i]:
dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]
else:
dp[i+1][j][k] = dp[i][j][k]
ans = 0
for j in range(1,nx+1):
for k in range(1,n+1):
if j/k == A:
ans += dp[n][j][k]
print(ans) |
[
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,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
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
] | [
[
92,
5
],
[
92,
18
],
[
92,
19
],
[
25,
24
],
[
93,
27
],
[
32,
29
],
[
24,
31
],
[
84,
32
],
[
35,
34
],
[
42,
39
],
[
34,
40
],
[
45,
44
],
[
34,
53
],
[
61,
56
],
[
34,
57
],
[
44,
60
],
[
64,
63
],
[
34,
66
],
[
63,
70
],
[
86,
76
],
[
90,
78
],
[
87,
81
],
[
92,
84
],
[
86,
87
],
[
92,
93
]
] | [
"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 for val, cnt in tuple(c.items()):\n c[val+i] += cnt\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 for val, cnt in tuple(c.items()):\n c[val+i] += cnt\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 for val, cnt in tuple(c.items()):\n c[val+i] += cnt\n ",
"i",
"x",
"for val, cnt in tuple(c.items()):\n c[val+i] += cnt\n ",
"val",
"cnt",
"tuple(c.items())",
"tuple",
"c.items()",
"c.items",
"c",
"items",
"c[val+i] += cnt",
"c[val+i]",
"c",
"val+i",
"val",
"i",
"cnt",
"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",
"ans = main()",
"main()",
"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 for val, cnt in tuple(c.items()):\n c[val+i] += cnt\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 for val, cnt in tuple(c.items()):\n c[val+i] += cnt\n ans = c[0] - 1\n return ans",
"main",
"n, a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"n"
] | 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:
for val, cnt in tuple(c.items()):
c[val+i] += cnt
ans = c[0] - 1
return ans
if __name__ == '__main__':
ans = main()
print(ans) |
[
7,
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,
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,
0,
13,
2,
18,
13,
17,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
17
],
[
5,
18
],
[
23,
22
],
[
22,
26
],
[
17,
27
],
[
30,
29
],
[
32,
31
],
[
38,
37
],
[
29,
37
],
[
31,
46
],
[
54,
49
],
[
31,
50
],
[
37,
52
],
[
31,
57
],
[
37,
60
],
[
66,
65
],
[
31,
68
],
[
65,
73
],
[
82,
79
]
] | [
"# ABC044C - 高橋君とカード / Tak and Cards (ARC060C)\ndef main():\n N, A, *X = map(int, open(0).read().split())\n X, D = [i - A for i in X], {0: 1}\n for i in X:\n for j, k in list(D.items()):\n D[i + j] = D.get(i + j, 0) + k\n ans = D[0] - 1\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"def main():\n N, A, *X = map(int, open(0).read().split())\n X, D = [i - A for i in X], {0: 1}\n for i in X:\n for j, k in list(D.items()):\n D[i + j] = D.get(i + j, 0) + k\n ans = D[0] - 1\n print(ans)",
"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], {0: 1}",
"X",
"[i - A for i in X]",
"D",
"{0: 1}",
"0",
"0",
"1",
"for i in X:\n for j, k in list(D.items()):\n D[i + j] = D.get(i + j, 0) + k\n ",
"i",
"X",
"for j, k in list(D.items()):\n D[i + j] = D.get(i + j, 0) + k\n ",
"j",
"k",
"list(D.items())",
"list",
"D.items()",
"D.items",
"D",
"items",
"D[i + j] = D.get(i + j, 0) + k",
"D[i + j]",
"D",
"i + j",
"i",
"j",
"D.get(i + j, 0) + k",
"D.get(i + j, 0)",
"D.get",
"D",
"get",
"i + j",
"i",
"j",
"0",
"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], {0: 1}\n for i in X:\n for j, k in list(D.items()):\n D[i + j] = D.get(i + j, 0) + k\n ans = D[0] - 1\n print(ans)",
"def main():\n N, A, *X = map(int, open(0).read().split())\n X, D = [i - A for i in X], {0: 1}\n for i in X:\n for j, k in list(D.items()):\n D[i + j] = D.get(i + j, 0) + k\n ans = D[0] - 1\n print(ans)",
"main"
] | # ABC044C - 高橋君とカード / Tak and Cards (ARC060C)
def main():
N, A, *X = map(int, open(0).read().split())
X, D = [i - A for i in X], {0: 1}
for i in X:
for j, k in list(D.items()):
D[i + j] = D.get(i + j, 0) + 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,
28,
13,
4,
13,
13,
0,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
2,
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,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
17,
13,
17,
14,
2,
2,
2,
13,
18,
13,
13,
17,
2,
2,
17,
13,
2,
13,
18,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
14,
2,
2,
17,
2,
13,
18,
13,
13,
2,
2,
13,
18,
13,
13,
2,
17,
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,
13,
0,
18,
18,
13,
13,
13,
17,
4,
13,
2,
18,
18,
13,
13,
13,
17,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13
] | [
[
189,
2
],
[
189,
11
],
[
192,
13
],
[
26,
25
],
[
184,
28
],
[
33,
30
],
[
193,
31
],
[
25,
32
],
[
30,
34
],
[
193,
35
],
[
25,
36
],
[
190,
37
],
[
186,
39
],
[
184,
41
],
[
184,
42
],
[
46,
45
],
[
184,
49
],
[
187,
58
],
[
195,
61
],
[
69,
64
],
[
196,
66
],
[
187,
68
],
[
72,
71
],
[
184,
76
],
[
198,
79
],
[
71,
81
],
[
85,
84
],
[
187,
90
],
[
84,
96
],
[
193,
98
],
[
199,
99
],
[
187,
104
],
[
84,
106
],
[
193,
108
],
[
199,
109
],
[
116,
111
],
[
196,
113
],
[
71,
114
],
[
84,
115
],
[
196,
118
],
[
71,
120
],
[
84,
122
],
[
84,
128
],
[
193,
130
],
[
199,
131
],
[
84,
134
],
[
193,
136
],
[
199,
137
],
[
187,
140
],
[
147,
142
],
[
196,
144
],
[
71,
145
],
[
84,
146
],
[
196,
150
],
[
71,
152
],
[
84,
154
],
[
196,
157
],
[
71,
159
],
[
84,
162
],
[
193,
164
],
[
199,
165
],
[
172,
167
],
[
196,
169
],
[
71,
170
],
[
84,
171
],
[
196,
178
],
[
184,
179
],
[
187,
180
],
[
189,
184
],
[
186,
187
],
[
189,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
]
] | [
"n,a=map(int,input().split())\nx=list(map(int,input().split()))\n\nfor i in range(n):\n x[i]=x[i]-a\n \nnx=n*n\ndp=[[0]*(2*nx+1) for i in range(n+1)]\n\n#print(dp)\n\ndp[0][nx]=1\n\nfor j in range(1,n+1):\n jj=j-1\n for t in range(2*nx+1):\n if t-x[jj]<0 or 2*nx<t-x[jj]:\n dp[j][t]=dp[j-1][t]\n elif 0<t-x[jj] and t-x[jj]<2*nx:\n dp[j][t]=dp[j-1][t]+dp[j-1][t-x[jj]]\n else:\n dp[j][t]=0\n\nprint(dp[n][nx]-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",
"for i in range(n):\n x[i]=x[i]-a\n ",
"i",
"range(n)",
"range",
"n",
"x[i]=x[i]-a",
"x[i]",
"x",
"i",
"x[i]-a",
"x[i]",
"x",
"i",
"a",
"nx=n*n",
"nx",
"n*n",
"n",
"n",
"[0]*(2*nx+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*nx+1)",
"[0]",
"0",
"2*nx+1",
"2*nx",
"2",
"nx",
"1",
"dp=[[0]*(2*nx+1) for i in range(n+1)]",
"dp",
"[[0]*(2*nx+1) for i in range(n+1)]",
"dp[0][nx]=1",
"dp[0][nx]",
"[0]",
"dp",
"0",
"nx",
"1",
"for j in range(1,n+1):\n jj=j-1\n for t in range(2*nx+1):\n if t-x[jj]<0 or 2*nx<t-x[jj]:\n dp[j][t]=dp[j-1][t]\n elif 0<t-x[jj] and t-x[jj]<2*nx:\n dp[j][t]=dp[j-1][t]+dp[j-1][t-x[jj]]\n else:\n dp[j][t]=0",
"j",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"jj=j-1",
"jj",
"j-1",
"j",
"1",
"for t in range(2*nx+1):\n if t-x[jj]<0 or 2*nx<t-x[jj]:\n dp[j][t]=dp[j-1][t]\n elif 0<t-x[jj] and t-x[jj]<2*nx:\n dp[j][t]=dp[j-1][t]+dp[j-1][t-x[jj]]\n else:\n dp[j][t]=0",
"t",
"range(2*nx+1)",
"range",
"2*nx+1",
"2*nx",
"2",
"nx",
"1",
"if t-x[jj]<0 or 2*nx<t-x[jj]:\n dp[j][t]=dp[j-1][t]\n elif 0<t-x[jj] and t-x[jj]<2*nx:\n dp[j][t]=dp[j-1][t]+dp[j-1][t-x[jj]]\n else:\n dp[j][t]=0",
"t-x[jj]<0 or 2*nx<t-x[jj]",
"t-x[jj]<0",
"t-x[jj]",
"t",
"x[jj]",
"x",
"jj",
"0",
"2*nx<t-x[jj]",
"2*nx",
"2",
"nx",
"t-x[jj]",
"t",
"x[jj]",
"x",
"jj",
"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[jj] and t-x[jj]<2*nx:\n dp[j][t]=dp[j-1][t]+dp[j-1][t-x[jj]]\n ",
"0<t-x[jj] and t-x[jj]<2*nx",
"0<t-x[jj]",
"0",
"t-x[jj]",
"t",
"x[jj]",
"x",
"jj",
"t-x[jj]<2*nx",
"t-x[jj]",
"t",
"x[jj]",
"x",
"jj",
"2*nx",
"2",
"nx",
"dp[j][t]=dp[j-1][t]+dp[j-1][t-x[jj]]",
"dp[j][t]",
"[j]",
"dp",
"j",
"t",
"dp[j-1][t]+dp[j-1][t-x[jj]]",
"dp[j-1][t]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"t",
"dp[j-1][t-x[jj]]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"t-x[jj]",
"t",
"x[jj]",
"x",
"jj",
"dp[j][t]=0",
"dp[j][t]",
"[j]",
"dp",
"j",
"t",
"0",
"print(dp[n][nx]-1)",
"print",
"dp[n][nx]-1",
"dp[n][nx]",
"[n]",
"dp",
"n",
"nx",
"1",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"nx=n*n",
"n*n",
"nx",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"x=list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"dp=[[0]*(2*nx+1) for i in range(n+1)]",
"[[0]*(2*nx+1) for i in range(n+1)]",
"dp",
"jj=j-1",
"j-1",
"jj"
] | n,a=map(int,input().split())
x=list(map(int,input().split()))
for i in range(n):
x[i]=x[i]-a
nx=n*n
dp=[[0]*(2*nx+1) for i in range(n+1)]
#print(dp)
dp[0][nx]=1
for j in range(1,n+1):
jj=j-1
for t in range(2*nx+1):
if t-x[jj]<0 or 2*nx<t-x[jj]:
dp[j][t]=dp[j-1][t]
elif 0<t-x[jj] and t-x[jj]<2*nx:
dp[j][t]=dp[j-1][t]+dp[j-1][t-x[jj]]
else:
dp[j][t]=0
print(dp[n][nx]-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,
17,
12,
13,
14,
2,
13,
17,
29,
14,
2,
39,
13,
13,
13,
13,
29,
14,
2,
13,
17,
14,
2,
13,
17,
0,
18,
13,
39,
13,
13,
13,
17,
0,
18,
13,
39,
13,
13,
13,
17,
29,
14,
40,
13,
13,
14,
2,
2,
13,
17,
2,
13,
17,
0,
18,
13,
39,
13,
13,
13,
17,
0,
18,
13,
39,
13,
13,
13,
17,
29,
4,
13,
2,
13,
17,
2,
13,
18,
13,
13,
2,
13,
17,
4,
13,
13,
13,
2,
13,
17,
0,
18,
13,
39,
13,
13,
13,
2,
18,
13,
39,
2,
13,
17,
2,
13,
18,
13,
13,
2,
13,
17,
18,
13,
39,
13,
13,
2,
13,
17,
23,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
13,
2,
13,
13,
17,
0,
13,
18,
13,
39,
13,
2,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13
] | [
[
196,
2
],
[
196,
11
],
[
184,
13
],
[
193,
25
],
[
147,
31
],
[
194,
40
],
[
147,
44
],
[
149,
48
],
[
57,
51
],
[
194,
52
],
[
65,
59
],
[
194,
60
],
[
151,
69
],
[
197,
70
],
[
149,
74
],
[
147,
77
],
[
86,
80
],
[
194,
81
],
[
94,
88
],
[
194,
89
],
[
147,
99
],
[
149,
102
],
[
185,
104
],
[
151,
105
],
[
151,
107
],
[
147,
111
],
[
149,
112
],
[
151,
114
],
[
123,
117
],
[
194,
118
],
[
194,
125
],
[
147,
128
],
[
149,
131
],
[
185,
133
],
[
151,
134
],
[
151,
136
],
[
194,
139
],
[
151,
144
],
[
147,
147
],
[
149,
149
],
[
151,
151
],
[
199,
153
],
[
157,
156
],
[
197,
161
],
[
203,
164
],
[
156,
165
],
[
156,
167
],
[
191,
168
],
[
187,
171
],
[
194,
173
],
[
156,
177
],
[
191,
178
],
[
188,
182
],
[
200,
182
],
[
184,
185
],
[
187,
188
],
[
196,
191
],
[
193,
194
],
[
196,
197
],
[
199,
200
]
] | [
"N,A=map(int,input().split())\nl=list(map(int,input().split()))\nd={}\ndef func(n,s,i):\n\tif n<0:\n\t\treturn\n\tif (n,s,i) in d:\n\t\treturn\n\tif n==0:\n\t\tif s==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\t\treturn\n\tif i>=N:\n\t\tif s==0 and n==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\n\t\treturn\n\telse:\n\t\tfunc(n-1,s-l[i],i+1)\n\t\tfunc(n,s,i+1)\n\t\td[(n,s,i)]=d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]\nans=0\nfor j in range(1,N+1):\n\tfunc(j,j*A,0)\n\tans+=d[(j,j*A,0)]\nprint(ans)",
"N,A=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"l=list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"d={}",
"d",
"{}",
"def func(n,s,i):\n\tif n<0:\n\t\treturn\n\tif (n,s,i) in d:\n\t\treturn\n\tif n==0:\n\t\tif s==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\t\treturn\n\tif i>=N:\n\t\tif s==0 and n==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\n\t\treturn\n\telse:\n\t\tfunc(n-1,s-l[i],i+1)\n\t\tfunc(n,s,i+1)\n\t\td[(n,s,i)]=d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]",
"func",
"if n<0:\n\t\treturn\n\t",
"n<0",
"n",
"0",
"return",
"if (n,s,i) in d:\n\t\treturn\n\t",
"(n,s,i) in d",
"(n,s,i)",
"n",
"s",
"i",
"d",
"return",
"if n==0:\n\t\tif s==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\t\treturn\n\t",
"n==0",
"n",
"0",
"if s==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\t\t",
"s==0",
"s",
"0",
"d[(n,s,i)]=1",
"d[(n,s,i)]",
"d",
"(n,s,i)",
"n",
"s",
"i",
"1",
"d[(n,s,i)]=0",
"d[(n,s,i)]",
"d",
"(n,s,i)",
"n",
"s",
"i",
"0",
"return",
"if i>=N:\n\t\tif s==0 and n==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\n\t\treturn\n\telse:\n\t\tfunc(n-1,s-l[i],i+1)\n\t\tfunc(n,s,i+1)\n\t\td[(n,s,i)]=d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]",
"i>=N",
"i",
"N",
"if s==0 and n==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\n\t\t",
"s==0 and n==0",
"s==0",
"s",
"0",
"n==0",
"n",
"0",
"d[(n,s,i)]=1",
"d[(n,s,i)]",
"d",
"(n,s,i)",
"n",
"s",
"i",
"1",
"d[(n,s,i)]=0",
"d[(n,s,i)]",
"d",
"(n,s,i)",
"n",
"s",
"i",
"0",
"return",
"func(n-1,s-l[i],i+1)",
"func",
"n-1",
"n",
"1",
"s-l[i]",
"s",
"l[i]",
"l",
"i",
"i+1",
"i",
"1",
"func(n,s,i+1)",
"func",
"n",
"s",
"i+1",
"i",
"1",
"d[(n,s,i)]=d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]",
"d[(n,s,i)]",
"d",
"(n,s,i)",
"n",
"s",
"i",
"d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]",
"d[(n-1,s-l[i],i+1)]",
"d",
"(n-1,s-l[i],i+1)",
"n-1",
"n",
"1",
"s-l[i]",
"s",
"l[i]",
"l",
"i",
"i+1",
"i",
"1",
"d[(n,s,i+1)]",
"d",
"(n,s,i+1)",
"n",
"s",
"i+1",
"i",
"1",
"n",
"n",
"s",
"s",
"i",
"i",
"ans=0",
"ans",
"0",
"for j in range(1,N+1):\n\tfunc(j,j*A,0)\n\tans+=d[(j,j*A,0)]",
"j",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"func(j,j*A,0)",
"func",
"j",
"j*A",
"j",
"A",
"0",
"ans+=d[(j,j*A,0)]",
"ans",
"d[(j,j*A,0)]",
"d",
"(j,j*A,0)",
"j",
"j*A",
"j",
"A",
"0",
"print(ans)",
"print",
"ans",
"l=list(map(int,input().split()))",
"list(map(int,input().split()))",
"l",
"ans+=d[(j,j*A,0)]",
"d[(j,j*A,0)]",
"ans",
"A=map(int,input().split())",
"map(int,input().split())",
"A",
"d={}",
"{}",
"d",
"N,A=map(int,input().split())",
"map(int,input().split())",
"N",
"ans=0",
"0",
"ans",
"def func(n,s,i):\n\tif n<0:\n\t\treturn\n\tif (n,s,i) in d:\n\t\treturn\n\tif n==0:\n\t\tif s==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\t\treturn\n\tif i>=N:\n\t\tif s==0 and n==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\n\t\treturn\n\telse:\n\t\tfunc(n-1,s-l[i],i+1)\n\t\tfunc(n,s,i+1)\n\t\td[(n,s,i)]=d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]",
"def func(n,s,i):\n\tif n<0:\n\t\treturn\n\tif (n,s,i) in d:\n\t\treturn\n\tif n==0:\n\t\tif s==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\t\treturn\n\tif i>=N:\n\t\tif s==0 and n==0:\n\t\t\td[(n,s,i)]=1\n\t\telse:\n\t\t\td[(n,s,i)]=0\n\n\t\treturn\n\telse:\n\t\tfunc(n-1,s-l[i],i+1)\n\t\tfunc(n,s,i+1)\n\t\td[(n,s,i)]=d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]",
"func"
] | N,A=map(int,input().split())
l=list(map(int,input().split()))
d={}
def func(n,s,i):
if n<0:
return
if (n,s,i) in d:
return
if n==0:
if s==0:
d[(n,s,i)]=1
else:
d[(n,s,i)]=0
return
if i>=N:
if s==0 and n==0:
d[(n,s,i)]=1
else:
d[(n,s,i)]=0
return
else:
func(n-1,s-l[i],i+1)
func(n,s,i+1)
d[(n,s,i)]=d[(n-1,s-l[i],i+1)]+d[(n,s,i+1)]
ans=0
for j in range(1,N+1):
func(j,j*A,0)
ans+=d[(j,j*A,0)]
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,
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,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
18,
18,
13,
13,
13,
13,
17,
9,
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,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
2,
13,
17,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] | [
[
148,
2
],
[
148,
11
],
[
154,
13
],
[
151,
25
],
[
30,
29
],
[
143,
33
],
[
157,
38
],
[
48,
41
],
[
158,
44
],
[
51,
50
],
[
143,
53
],
[
56,
55
],
[
143,
58
],
[
61,
60
],
[
152,
63
],
[
158,
69
],
[
50,
70
],
[
55,
71
],
[
60,
72
],
[
85,
76
],
[
158,
79
],
[
50,
81
],
[
55,
83
],
[
60,
84
],
[
158,
88
],
[
50,
89
],
[
55,
90
],
[
60,
91
],
[
108,
93
],
[
158,
96
],
[
50,
98
],
[
55,
101
],
[
60,
104
],
[
155,
106
],
[
50,
107
],
[
158,
111
],
[
50,
112
],
[
55,
113
],
[
60,
114
],
[
160,
116
],
[
120,
119
],
[
143,
123
],
[
145,
126
],
[
158,
130
],
[
143,
131
],
[
119,
132
],
[
119,
134
],
[
149,
135
],
[
146,
139
],
[
161,
139
],
[
148,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\nsumX = 2501\n\ndp = [[[0 for _ in range(sumX)] for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0] = 1\n\nfor j in range(N):\n for k in range(N):\n for s in range(sumX):\n if dp[j][k][s]==0:\n continue\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\n\nfor i in range(N+1):\n ans += dp[N][i][i*A]\nprint(ans-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",
"sumX = 2501",
"sumX",
"2501",
"[[0 for _ in range(sumX)] 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(sumX)] for _ in range(N+1)]",
"dp = [[[0 for _ in range(sumX)] for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0 for _ in range(sumX)] 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(N):\n for k in range(N):\n for s in range(sumX):\n if dp[j][k][s]==0:\n continue\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(sumX):\n if dp[j][k][s]==0:\n continue\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(sumX):\n if dp[j][k][s]==0:\n continue\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(sumX)",
"range",
"sumX",
"if dp[j][k][s]==0:\n continue\n ",
"dp[j][k][s]==0",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"0",
"continue",
"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 i in range(N+1):\n ans += dp[N][i][i*A]",
"i",
"range(N+1)",
"range",
"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-1)",
"print",
"ans-1",
"ans",
"1",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans += dp[N][i][i*A]",
"dp[N][i][i*A]",
"ans",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"sumX = 2501",
"2501",
"sumX",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"dp = [[[0 for _ in range(sumX)] for _ in range(N+1)] for _ in range(N+1)]",
"[[[0 for _ in range(sumX)] for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"ans = 0",
"0",
"ans"
] | N, A = map(int, input().split())
X = list(map(int, input().split()))
sumX = 2501
dp = [[[0 for _ in range(sumX)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for j in range(N):
for k in range(N):
for s in range(sumX):
if dp[j][k][s]==0:
continue
dp[j+1][k][s] += dp[j][k][s]
dp[j+1][k+1][s+X[j]] += dp[j][k][s]
ans = 0
for i in range(N+1):
ans += dp[N][i][i*A]
print(ans-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,
2,
39,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
28,
13,
4,
13,
4,
13,
17,
40,
18,
13,
13,
4,
13,
17,
2,
17,
18,
13,
13,
0,
18,
13,
2,
13,
18,
13,
13,
18,
13,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13
] | [
[
105,
2
],
[
105,
11
],
[
96,
13
],
[
26,
25
],
[
106,
28
],
[
33,
30
],
[
97,
31
],
[
25,
32
],
[
94,
33
],
[
102,
35
],
[
44,
41
],
[
103,
42
],
[
47,
46
],
[
106,
49
],
[
99,
51
],
[
103,
53
],
[
57,
56
],
[
30,
63
],
[
97,
64
],
[
46,
65
],
[
30,
71
],
[
97,
72
],
[
46,
73
],
[
82,
75
],
[
103,
76
],
[
56,
78
],
[
30,
79
],
[
97,
80
],
[
46,
81
],
[
100,
83
],
[
56,
84
],
[
103,
89
],
[
105,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
]
] | [
"N,A = map(int,input().split())\nx = list(map(int,input().split()))\n\nfor i in range(N):\n x[i] -= A\n\ndp = [0]*5000###-2500~2499,idx=2500が0に対応\ndp[2500] = 1\n\nfor i in range(N):\n pre = dp[:]\n for j in range(max(0,-x[i]),min(4999,4999-x[i])):\n dp[j+x[i]] += pre[j]\n #print(pre[2490:2510])\n #print(dp[2490:2510])\n\n#print(x)\nprint(dp[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",
"for i in range(N):\n x[i] -= A",
"i",
"range(N)",
"range",
"N",
"x[i] -= A",
"x[i]",
"x",
"i",
"A",
"dp = [0]*5000",
"dp",
"[0]*5000",
"[0]",
"0",
"5000",
"dp[2500] = 1",
"dp[2500]",
"dp",
"2500",
"1",
"for i in range(N):\n pre = dp[:]\n for j in range(max(0,-x[i]),min(4999,4999-x[i])):\n dp[j+x[i]] += pre[j]\n #print(pre[2490:2510])\n #print(dp[2490:2510])\n\n#print(x)",
"i",
"range(N)",
"range",
"N",
"pre = dp[:]",
"pre",
"dp[:]",
"dp",
":",
"for j in range(max(0,-x[i]),min(4999,4999-x[i])):\n dp[j+x[i]] += pre[j]\n #print(pre[2490:2510])\n #print(dp[2490:2510])\n\n#print(x)",
"j",
"range(max(0,-x[i]),min(4999,4999-x[i]))",
"range",
"max(0,-x[i])",
"max",
"0",
"-x[i]",
"x[i]",
"x",
"i",
"min(4999,4999-x[i])",
"min",
"4999",
"4999-x[i]",
"4999",
"x[i]",
"x",
"i",
"dp[j+x[i]] += pre[j]",
"dp[j+x[i]]",
"dp",
"j+x[i]",
"j",
"x[i]",
"x",
"i",
"pre[j]",
"pre",
"j",
"print(dp[2500]-1)",
"print",
"dp[2500]-1",
"dp[2500]",
"dp",
"2500",
"1",
"A = map(int,input().split())",
"map(int,input().split())",
"A",
"x = list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"pre = dp[:]",
"dp[:]",
"pre",
"dp = [0]*5000",
"[0]*5000",
"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 = [0]*5000###-2500~2499,idx=2500が0に対応
dp[2500] = 1
for i in range(N):
pre = dp[:]
for j in range(max(0,-x[i]),min(4999,4999-x[i])):
dp[j+x[i]] += pre[j]
#print(pre[2490:2510])
#print(dp[2490:2510])
#print(x)
print(dp[2500]-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,
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,
2,
17,
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,
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,
13,
13,
2,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
176,
4
],
[
185,
11
],
[
177,
18
],
[
185,
20
],
[
167,
22
],
[
177,
34
],
[
39,
38
],
[
183,
42
],
[
179,
47
],
[
57,
50
],
[
180,
53
],
[
60,
59
],
[
183,
63
],
[
67,
66
],
[
59,
70
],
[
74,
73
],
[
66,
79
],
[
73,
83
],
[
168,
85
],
[
59,
86
],
[
95,
88
],
[
180,
91
],
[
59,
92
],
[
66,
93
],
[
73,
94
],
[
180,
98
],
[
59,
100
],
[
66,
102
],
[
73,
103
],
[
66,
106
],
[
116,
109
],
[
180,
112
],
[
59,
113
],
[
66,
114
],
[
73,
115
],
[
180,
120
],
[
59,
122
],
[
66,
124
],
[
73,
125
],
[
180,
129
],
[
59,
131
],
[
66,
134
],
[
73,
137
],
[
168,
139
],
[
59,
140
],
[
170,
142
],
[
146,
145
],
[
183,
150
],
[
173,
153
],
[
180,
157
],
[
183,
158
],
[
145,
159
],
[
186,
161
],
[
145,
162
],
[
174,
165
],
[
171,
165
],
[
167,
168
],
[
170,
171
],
[
173,
174
],
[
176,
177
],
[
179,
180
],
[
185,
183
],
[
185,
186
]
] | [
"# python 3.4.3\nimport sys\ninput = sys.stdin.readline\n\n# -------------------------------------------------------------\n# function\n# -------------------------------------------------------------\n\n\n# -------------------------------------------------------------\n# main\n# -------------------------------------------------------------\nN,A = map(int,input().split())\nX = [0] + list(map(int,input().split())) # 1枚も選ばない場合として 0 を足しておく\n\n# dp[n][k][d] : n枚からk枚選んで合計dにする選び方\ndp = [[[0 for _ in range(50*N+1)] for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0] = 1\n\nfor n in range(N+1):\n for k in range(n+1):\n for d in range(50*k+1):\n # 目指す \"合計の数 : d\" がn枚目のカードより小さい場合, そのカードは使えない\n if d < X[n]:\n dp[n][k][d] = dp[n-1][k][d]\n # そうでない場合\n else:\n # k==0のときはカードを選べないことに注意\n if k >= 1:\n dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]\n # dp[n-1][k][d] : k枚目のカードを選ばない場合\n # dp[n-1][k-1][d-X[n]] : k枚目のカードを選ぶ場合。n-1枚目までで合計 d-X[n] であれば良い。\n\nans = 0\nfor i in range(1,N+1): # 0を除く、0のときは「0枚から0枚選んで0にする」で1通りになるが、これは答えには含まれない\n # N枚からi枚選んで平均がA,つまり合計がA*i\n ans += dp[N][i][A*i]\n\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",
"[[0 for _ in range(50*N+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(50*N+1)] for _ in range(N+1)]",
"dp = [[[0 for _ in range(50*N+1)] for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0 for _ in range(50*N+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 n in range(N+1):\n for k in range(n+1):\n for d in range(50*k+1):\n # 目指す \"合計の数 : d\" がn枚目のカードより小さい場合, そのカードは使えない\n if d < X[n]:\n dp[n][k][d] = dp[n-1][k][d]\n # そうでない場合\n else:\n # k==0のときはカードを選べないことに注意\n if k >= 1:\n dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]\n # dp[n-1][k][d] : k枚目のカードを選ばない場合\n # dp[n-1][k-1][d-X[n]] : k枚目のカードを選ぶ場合。n-1枚目までで合計 d-X[n] であれば良い。",
"n",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for k in range(n+1):\n for d in range(50*k+1):\n # 目指す \"合計の数 : d\" がn枚目のカードより小さい場合, そのカードは使えない\n if d < X[n]:\n dp[n][k][d] = dp[n-1][k][d]\n # そうでない場合\n else:\n # k==0のときはカードを選べないことに注意\n if k >= 1:\n dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]\n # dp[n-1][k][d] : k枚目のカードを選ばない場合\n # dp[n-1][k-1][d-X[n]] : k枚目のカードを選ぶ場合。n-1枚目までで合計 d-X[n] であれば良い。",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for d in range(50*k+1):\n # 目指す \"合計の数 : d\" がn枚目のカードより小さい場合, そのカードは使えない\n if d < X[n]:\n dp[n][k][d] = dp[n-1][k][d]\n # そうでない場合\n else:\n # k==0のときはカードを選べないことに注意\n if k >= 1:\n dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]\n # dp[n-1][k][d] : k枚目のカードを選ばない場合\n # dp[n-1][k-1][d-X[n]] : k枚目のカードを選ぶ場合。n-1枚目までで合計 d-X[n] であれば良い。",
"d",
"range(50*k+1)",
"range",
"50*k+1",
"50*k",
"50",
"k",
"1",
"if d < X[n]:\n dp[n][k][d] = dp[n-1][k][d]\n # そうでない場合\n else:\n # k==0のときはカードを選べないことに注意\n if k >= 1:\n dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]\n # dp[n-1][k][d] : k枚目のカードを選ばない場合\n # dp[n-1][k-1][d-X[n]] : k枚目のカードを選ぶ場合。n-1枚目までで合計 d-X[n] であれば良い。",
"d < X[n]",
"d",
"X[n]",
"X",
"n",
"dp[n][k][d] = dp[n-1][k][d]",
"dp[n][k][d]",
"[k]",
"[n]",
"dp",
"n",
"k",
"d",
"dp[n-1][k][d]",
"[k]",
"[n-1]",
"dp",
"n-1",
"n",
"1",
"k",
"d",
"if k >= 1:\n dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]\n # dp[n-1][k][d] : k枚目のカードを選ばない場合\n # dp[n-1][k-1][d-X[n]] : k枚目のカードを選ぶ場合。n-1枚目までで合計 d-X[n] であれば良い。",
"k >= 1",
"k",
"1",
"dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]",
"dp[n][k][d]",
"[k]",
"[n]",
"dp",
"n",
"k",
"d",
"dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]",
"dp[n-1][k][d]",
"[k]",
"[n-1]",
"dp",
"n-1",
"n",
"1",
"k",
"d",
"dp[n-1][k-1][d-X[n]]",
"[k-1]",
"[n-1]",
"dp",
"n-1",
"n",
"1",
"k-1",
"k",
"1",
"d-X[n]",
"d",
"X[n]",
"X",
"n",
"ans = 0",
"ans",
"0",
"for i in range(1,N+1): # 0を除く、0のときは「0枚から0枚選んで0にする」で1通りになるが、これは答えには含まれない\n # N枚からi枚選んで平均がA,つまり合計がA*i\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",
"X = [0] + list(map(int,input().split()))",
"[0] + list(map(int,input().split()))",
"X",
"ans = 0",
"0",
"ans",
"ans += dp[N][i][A*i]",
"dp[N][i][A*i]",
"ans",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"dp = [[[0 for _ in range(50*N+1)] for _ in range(N+1)] for _ in range(N+1)]",
"[[[0 for _ in range(50*N+1)] for _ in range(N+1)] 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"
] | # python 3.4.3
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N,A = map(int,input().split())
X = [0] + list(map(int,input().split())) # 1枚も選ばない場合として 0 を足しておく
# dp[n][k][d] : n枚からk枚選んで合計dにする選び方
dp = [[[0 for _ in range(50*N+1)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for n in range(N+1):
for k in range(n+1):
for d in range(50*k+1):
# 目指す "合計の数 : d" がn枚目のカードより小さい場合, そのカードは使えない
if d < X[n]:
dp[n][k][d] = dp[n-1][k][d]
# そうでない場合
else:
# k==0のときはカードを選べないことに注意
if k >= 1:
dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]
# dp[n-1][k][d] : k枚目のカードを選ばない場合
# dp[n-1][k-1][d-X[n]] : k枚目のカードを選ぶ場合。n-1枚目までで合計 d-X[n] であれば良い。
ans = 0
for i in range(1,N+1): # 0を除く、0のときは「0枚から0枚選んで0にする」で1通りになるが、これは答えには含まれない
# N枚からi枚選んで平均がA,つまり合計がA*i
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,
2,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
13,
17,
17,
28,
13,
4,
13,
2,
17,
13,
0,
18,
18,
13,
13,
2,
13,
13,
18,
18,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
18,
13,
2,
13,
17,
2,
2,
13,
17,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13
] | [
[
126,
2
],
[
126,
11
],
[
111,
13
],
[
27,
26
],
[
127,
30
],
[
129,
38
],
[
46,
41
],
[
130,
43
],
[
49,
48
],
[
127,
51
],
[
117,
53
],
[
112,
55
],
[
48,
56
],
[
59,
58
],
[
127,
61
],
[
66,
65
],
[
118,
70
],
[
79,
72
],
[
130,
74
],
[
58,
75
],
[
65,
77
],
[
118,
78
],
[
130,
81
],
[
58,
83
],
[
65,
85
],
[
114,
87
],
[
91,
90
],
[
127,
93
],
[
123,
95
],
[
130,
98
],
[
90,
100
],
[
90,
104
],
[
121,
106
],
[
124,
109
],
[
115,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
126,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
]
] | [
"n,a=map(int,input().split())\nX=list(map(int,input().split()))\ndp=[[0]*2501 for _ in range(n+1)]\ndp[0][0]=1\nfor i in range(n):\n x=X[i]\n for j in range(n,0,-1):\n \tfor k in range(2501-x):\n \tdp[j][k+x]+=dp[j-1][k]\nans=0\nfor i in range(n):\n ans+=dp[i+1][(i+1)*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)",
"_",
"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)]",
"dp[0][0]=1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i in range(n):\n x=X[i]\n for j in range(n,0,-1):\n \tfor k in range(2501-x):\n \tdp[j][k+x]+=dp[j-1][k]",
"i",
"range(n)",
"range",
"n",
"x=X[i]",
"x",
"X[i]",
"X",
"i",
"for j in range(n,0,-1):\n \tfor k in range(2501-x):\n \tdp[j][k+x]+=dp[j-1][k]",
"j",
"range(n,0,-1)",
"range",
"n",
"0",
"-1",
"for k in range(2501-x):\n \tdp[j][k+x]+=dp[j-1][k]",
"k",
"range(2501-x)",
"range",
"2501-x",
"2501",
"x",
"dp[j][k+x]+=dp[j-1][k]",
"dp[j][k+x]",
"[j]",
"dp",
"j",
"k+x",
"k",
"x",
"dp[j-1][k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"ans=0",
"ans",
"0",
"for i in range(n):\n ans+=dp[i+1][(i+1)*a]",
"i",
"range(n)",
"range",
"n",
"ans+=dp[i+1][(i+1)*a]",
"ans",
"dp[i+1][(i+1)*a]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"(i+1)*a",
"i+1",
"i",
"1",
"a",
"print(ans)",
"print",
"ans",
"X=list(map(int,input().split()))",
"list(map(int,input().split()))",
"X",
"ans=0",
"0",
"ans",
"x=X[i]",
"X[i]",
"x",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"ans+=dp[i+1][(i+1)*a]",
"dp[i+1][(i+1)*a]",
"ans",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"dp=[[0]*2501 for _ in range(n+1)]",
"[[0]*2501 for _ in range(n+1)]",
"dp"
] | n,a=map(int,input().split())
X=list(map(int,input().split()))
dp=[[0]*2501 for _ in range(n+1)]
dp[0][0]=1
for i in range(n):
x=X[i]
for j in range(n,0,-1):
for k in range(2501-x):
dp[j][k+x]+=dp[j-1][k]
ans=0
for i in range(n):
ans+=dp[i+1][(i+1)*a]
print(ans) |
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
0,
13,
4,
13,
13,
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,
2,
2,
2,
17,
13,
13,
17,
0,
13,
13,
0,
18,
18,
13,
17,
2,
13,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
2,
2,
17,
13,
13,
17,
14,
2,
2,
2,
13,
18,
13,
2,
13,
17,
17,
2,
2,
2,
17,
13,
13,
2,
13,
18,
13,
2,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
14,
40,
40,
17,
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,
29,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
17
],
[
5,
18
],
[
22,
21
],
[
17,
24
],
[
31,
30
],
[
30,
34
],
[
17,
35
],
[
38,
37
],
[
42,
41
],
[
4,
45
],
[
4,
55
],
[
21,
56
],
[
60,
59
],
[
69,
62
],
[
59,
64
],
[
4,
67
],
[
21,
68
],
[
72,
71
],
[
4,
76
],
[
80,
79
],
[
4,
86
],
[
21,
87
],
[
79,
93
],
[
37,
95
],
[
71,
97
],
[
4,
104
],
[
21,
105
],
[
79,
107
],
[
37,
109
],
[
71,
111
],
[
119,
114
],
[
59,
116
],
[
71,
117
],
[
79,
118
],
[
59,
121
],
[
71,
123
],
[
79,
125
],
[
79,
131
],
[
37,
133
],
[
71,
135
],
[
4,
140
],
[
21,
141
],
[
148,
143
],
[
59,
145
],
[
71,
146
],
[
79,
147
],
[
59,
151
],
[
71,
153
],
[
79,
155
],
[
59,
158
],
[
71,
160
],
[
79,
163
],
[
37,
165
],
[
71,
167
],
[
175,
170
],
[
59,
172
],
[
71,
173
],
[
79,
174
],
[
59,
181
],
[
4,
182
],
[
4,
184
],
[
21,
185
],
[
192,
189
]
] | [
"def main():\n N, A, *x = map(int, open(0).read().split())\n MAX_A_x = max(A, max(x))\n x = [xi - A for xi in x]\n # dp[i][j]\n # i 選んだ枚数 0 <= i <= N\n # j 合計 0 <= j <= 2 * N * MAX_A_x\n dp = [[0] * (2 * N * MAX_A_x + 1) for i in range(N + 1)]\n dp[0][N * MAX_A_x] = 1\n for i in range(1, N + 1):\n for j in range(2 * N * MAX_A_x + 1):\n if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:\n dp[i][j] = dp[i - 1][j]\n elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n else:\n dp[i][j] = 0\n print(dp[N][N * MAX_A_x] - 1)\n return\n\n\nmain()",
"def main():\n N, A, *x = map(int, open(0).read().split())\n MAX_A_x = max(A, max(x))\n x = [xi - A for xi in x]\n # dp[i][j]\n # i 選んだ枚数 0 <= i <= N\n # j 合計 0 <= j <= 2 * N * MAX_A_x\n dp = [[0] * (2 * N * MAX_A_x + 1) for i in range(N + 1)]\n dp[0][N * MAX_A_x] = 1\n for i in range(1, N + 1):\n for j in range(2 * N * MAX_A_x + 1):\n if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:\n dp[i][j] = dp[i - 1][j]\n elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n else:\n dp[i][j] = 0\n print(dp[N][N * MAX_A_x] - 1)\n return",
"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",
"MAX_A_x = max(A, max(x))",
"MAX_A_x",
"max(A, max(x))",
"max",
"A",
"max(x)",
"max",
"x",
"xi - A for xi in x",
"for xi in x",
"xi",
"x",
"for xi in x",
"xi - A",
"xi",
"A",
"x = [xi - A for xi in x]",
"x",
"[xi - A for xi in x]",
"[0] * (2 * N * MAX_A_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_A_x + 1)",
"[0]",
"0",
"2 * N * MAX_A_x + 1",
"2 * N * MAX_A_x",
"2 * N",
"2",
"N",
"MAX_A_x",
"1",
"dp = [[0] * (2 * N * MAX_A_x + 1) for i in range(N + 1)]",
"dp",
"[[0] * (2 * N * MAX_A_x + 1) for i in range(N + 1)]",
"dp[0][N * MAX_A_x] = 1",
"dp[0][N * MAX_A_x]",
"[0]",
"dp",
"0",
"N * MAX_A_x",
"N",
"MAX_A_x",
"1",
"for i in range(1, N + 1):\n for j in range(2 * N * MAX_A_x + 1):\n if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:\n dp[i][j] = dp[i - 1][j]\n elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n else:\n dp[i][j] = 0\n ",
"i",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"for j in range(2 * N * MAX_A_x + 1):\n if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:\n dp[i][j] = dp[i - 1][j]\n elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n else:\n dp[i][j] = 0\n ",
"j",
"range(2 * N * MAX_A_x + 1)",
"range",
"2 * N * MAX_A_x + 1",
"2 * N * MAX_A_x",
"2 * N",
"2",
"N",
"MAX_A_x",
"1",
"if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:\n dp[i][j] = dp[i - 1][j]\n elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n else:\n dp[i][j] = 0\n ",
"j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]",
"j - x[i - 1] < 0",
"j - x[i - 1]",
"j",
"x[i - 1]",
"x",
"i - 1",
"i",
"1",
"0",
"2 * N * MAX_A_x < j - x[i - 1]",
"2 * N * MAX_A_x",
"2 * N",
"2",
"N",
"MAX_A_x",
"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",
"elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n ",
"0 <= j - x[i - 1] <= 2 * N * MAX_A_x",
"0 <= j - x[i - 1]",
"0",
"j - x[i - 1]",
"j",
"x[i - 1]",
"x",
"i - 1",
"i",
"1",
"2 * N * MAX_A_x",
"2 * N",
"2",
"N",
"MAX_A_x",
"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] = 0",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"0",
"print(dp[N][N * MAX_A_x] - 1)",
"print",
"dp[N][N * MAX_A_x] - 1",
"dp[N][N * MAX_A_x]",
"[N]",
"dp",
"N",
"N * MAX_A_x",
"N",
"MAX_A_x",
"1",
"return",
"main()",
"main",
"def main():\n N, A, *x = map(int, open(0).read().split())\n MAX_A_x = max(A, max(x))\n x = [xi - A for xi in x]\n # dp[i][j]\n # i 選んだ枚数 0 <= i <= N\n # j 合計 0 <= j <= 2 * N * MAX_A_x\n dp = [[0] * (2 * N * MAX_A_x + 1) for i in range(N + 1)]\n dp[0][N * MAX_A_x] = 1\n for i in range(1, N + 1):\n for j in range(2 * N * MAX_A_x + 1):\n if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:\n dp[i][j] = dp[i - 1][j]\n elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n else:\n dp[i][j] = 0\n print(dp[N][N * MAX_A_x] - 1)\n return",
"def main():\n N, A, *x = map(int, open(0).read().split())\n MAX_A_x = max(A, max(x))\n x = [xi - A for xi in x]\n # dp[i][j]\n # i 選んだ枚数 0 <= i <= N\n # j 合計 0 <= j <= 2 * N * MAX_A_x\n dp = [[0] * (2 * N * MAX_A_x + 1) for i in range(N + 1)]\n dp[0][N * MAX_A_x] = 1\n for i in range(1, N + 1):\n for j in range(2 * N * MAX_A_x + 1):\n if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:\n dp[i][j] = dp[i - 1][j]\n elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:\n dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]\n else:\n dp[i][j] = 0\n print(dp[N][N * MAX_A_x] - 1)\n return",
"main"
] | def main():
N, A, *x = map(int, open(0).read().split())
MAX_A_x = max(A, max(x))
x = [xi - A for xi in x]
# dp[i][j]
# i 選んだ枚数 0 <= i <= N
# j 合計 0 <= j <= 2 * N * MAX_A_x
dp = [[0] * (2 * N * MAX_A_x + 1) for i in range(N + 1)]
dp[0][N * MAX_A_x] = 1
for i in range(1, N + 1):
for j in range(2 * N * MAX_A_x + 1):
if j - x[i - 1] < 0 or 2 * N * MAX_A_x < j - x[i - 1]:
dp[i][j] = dp[i - 1][j]
elif 0 <= j - x[i - 1] <= 2 * N * MAX_A_x:
dp[i][j] = dp[i - 1][j] + dp[i - 1][j - x[i - 1]]
else:
dp[i][j] = 0
print(dp[N][N * MAX_A_x] - 1)
return
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,
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,
2,
2,
13,
13,
17,
14,
2,
18,
18,
18,
13,
13,
13,
13,
17,
9,
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,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] | [
[
154,
2
],
[
154,
11
],
[
151,
13
],
[
27,
26
],
[
148,
33
],
[
43,
36
],
[
149,
39
],
[
46,
45
],
[
155,
48
],
[
51,
50
],
[
155,
54
],
[
58,
57
],
[
155,
62
],
[
143,
63
],
[
149,
70
],
[
45,
71
],
[
50,
72
],
[
57,
73
],
[
86,
77
],
[
149,
80
],
[
45,
82
],
[
50,
84
],
[
57,
85
],
[
149,
89
],
[
45,
90
],
[
50,
91
],
[
57,
92
],
[
109,
94
],
[
149,
97
],
[
45,
99
],
[
50,
102
],
[
57,
105
],
[
152,
107
],
[
45,
108
],
[
149,
112
],
[
45,
113
],
[
50,
114
],
[
57,
115
],
[
145,
117
],
[
121,
120
],
[
155,
125
],
[
157,
128
],
[
149,
132
],
[
155,
133
],
[
120,
134
],
[
143,
136
],
[
120,
137
],
[
158,
140
],
[
146,
140
],
[
154,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
]
] | [
"n,a=map(int, input().split())\nx=list(map(int, input().split()))\n\ndp=[[[0]*(2550) for _ in range(55)] for _ in range(55)]\ndp[0][0][0]=1\nfor i in range(n):\n for j in range(n+1):\n for sm in range(n*a+1):\n if dp[i][j][sm]==0:\n continue\n dp[i+1][j][sm]+=dp[i][j][sm]\n dp[i+1][j+1][sm+x[i]]+=dp[i][j][sm]\n\nans=0\nfor k in range(1,n+1):\n ans+=dp[n][k][a*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",
"[[0]*(2550) for _ in range(55)] for _ in range(55)",
"for _ in range(55)",
"_",
"range(55)",
"range",
"55",
"for _ in range(55)",
"[[0]*(2550) for _ in range(55)]",
"dp=[[[0]*(2550) for _ in range(55)] for _ in range(55)]",
"dp",
"[[[0]*(2550) for _ in range(55)] for _ in range(55)]",
"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 sm in range(n*a+1):\n if dp[i][j][sm]==0:\n continue\n dp[i+1][j][sm]+=dp[i][j][sm]\n dp[i+1][j+1][sm+x[i]]+=dp[i][j][sm]",
"i",
"range(n)",
"range",
"n",
"for j in range(n+1):\n for sm in range(n*a+1):\n if dp[i][j][sm]==0:\n continue\n dp[i+1][j][sm]+=dp[i][j][sm]\n dp[i+1][j+1][sm+x[i]]+=dp[i][j][sm]",
"j",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for sm in range(n*a+1):\n if dp[i][j][sm]==0:\n continue\n dp[i+1][j][sm]+=dp[i][j][sm]\n dp[i+1][j+1][sm+x[i]]+=dp[i][j][sm]",
"sm",
"range(n*a+1)",
"range",
"n*a+1",
"n*a",
"n",
"a",
"1",
"if dp[i][j][sm]==0:\n continue\n ",
"dp[i][j][sm]==0",
"dp[i][j][sm]",
"[j]",
"[i]",
"dp",
"i",
"j",
"sm",
"0",
"continue",
"dp[i+1][j][sm]+=dp[i][j][sm]",
"dp[i+1][j][sm]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"sm",
"dp[i][j][sm]",
"[j]",
"[i]",
"dp",
"i",
"j",
"sm",
"dp[i+1][j+1][sm+x[i]]+=dp[i][j][sm]",
"dp[i+1][j+1][sm+x[i]]",
"[j+1]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+1",
"j",
"1",
"sm+x[i]",
"sm",
"x[i]",
"x",
"i",
"dp[i][j][sm]",
"[j]",
"[i]",
"dp",
"i",
"j",
"sm",
"ans=0",
"ans",
"0",
"for k in range(1,n+1):\n ans+=dp[n][k][a*k]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"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",
"dp=[[[0]*(2550) for _ in range(55)] for _ in range(55)]",
"[[[0]*(2550) for _ in range(55)] for _ in range(55)]",
"dp",
"x=list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"n,a=map(int, input().split())",
"map(int, input().split())",
"n",
"ans+=dp[n][k][a*k]",
"dp[n][k][a*k]",
"ans"
] | n,a=map(int, input().split())
x=list(map(int, input().split()))
dp=[[[0]*(2550) for _ in range(55)] for _ in range(55)]
dp[0][0][0]=1
for i in range(n):
for j in range(n+1):
for sm in range(n*a+1):
if dp[i][j][sm]==0:
continue
dp[i+1][j][sm]+=dp[i][j][sm]
dp[i+1][j+1][sm+x[i]]+=dp[i][j][sm]
ans=0
for k in range(1,n+1):
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,
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,
0,
18,
18,
18,
13,
13,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
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,
18,
13,
13,
2,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
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,
2,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13
] | [
[
179,
2
],
[
179,
11
],
[
15,
14
],
[
14,
23
],
[
185,
25
],
[
167,
28
],
[
186,
31
],
[
35,
34
],
[
180,
38
],
[
170,
43
],
[
47,
46
],
[
180,
50
],
[
60,
53
],
[
171,
56
],
[
46,
57
],
[
63,
62
],
[
180,
65
],
[
68,
67
],
[
168,
71
],
[
75,
74
],
[
180,
79
],
[
67,
83
],
[
186,
85
],
[
62,
86
],
[
97,
88
],
[
171,
91
],
[
62,
93
],
[
67,
95
],
[
74,
96
],
[
171,
101
],
[
62,
102
],
[
67,
103
],
[
74,
104
],
[
171,
108
],
[
62,
109
],
[
67,
111
],
[
186,
113
],
[
62,
114
],
[
74,
116
],
[
128,
119
],
[
171,
122
],
[
62,
124
],
[
67,
126
],
[
74,
127
],
[
171,
131
],
[
62,
132
],
[
67,
133
],
[
74,
134
],
[
176,
136
],
[
140,
139
],
[
180,
144
],
[
139,
149
],
[
174,
150
],
[
168,
151
],
[
182,
153
],
[
171,
157
],
[
180,
158
],
[
139,
160
],
[
174,
161
],
[
139,
162
],
[
183,
165
],
[
177,
165
],
[
167,
168
],
[
170,
171
],
[
179,
174
],
[
176,
177
],
[
179,
180
],
[
182,
183
],
[
185,
186
]
] | [
"N,A = map(int, input().split())\nX = [int(x) for x in input().split()]\n\nM = sum(X)\ndp = [[[0]*(N+1) for _ in range(M+1)] for _ in range(N+1)]\n \nfor i in range(N+1):\n dp[i][0][0] = 1\n \nfor i in range(N):\n for j in range(M+1):\n for k in range(1, N+1):\n if j >= X[i]:\n dp[i+1][j][k] = dp[i][j][k] + dp[i][j-X[i]][k-1]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n \nans = 0\nfor k in range(1, N+1):\n if k*A <= M:\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",
"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()]",
"M = sum(X)",
"M",
"sum(X)",
"sum",
"X",
"[[0]*(N+1) for _ in range(M+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]*(N+1) for _ in range(M+1)]",
"dp = [[[0]*(N+1) for _ in range(M+1)] for _ in range(N+1)]",
"dp",
"[[[0]*(N+1) for _ in range(M+1)] for _ in range(N+1)]",
"for i in range(N+1):\n dp[i][0][0] = 1\n ",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"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(M+1):\n for k in range(1, N+1):\n if j >= X[i]:\n dp[i+1][j][k] = dp[i][j][k] + dp[i][j-X[i]][k-1]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"i",
"range(N)",
"range",
"N",
"for j in range(M+1):\n for k in range(1, N+1):\n if j >= X[i]:\n dp[i+1][j][k] = dp[i][j][k] + dp[i][j-X[i]][k-1]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"j",
"range(M+1)",
"range",
"M+1",
"M",
"1",
"for k in range(1, N+1):\n if j >= X[i]:\n dp[i+1][j][k] = dp[i][j][k] + dp[i][j-X[i]][k-1]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"k",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if j >= X[i]:\n dp[i+1][j][k] = dp[i][j][k] + dp[i][j-X[i]][k-1]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"j >= X[i]",
"j",
"X[i]",
"X",
"i",
"dp[i+1][j][k] = dp[i][j][k] + dp[i][j-X[i]][k-1]",
"dp[i+1][j][k]",
"[j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"k",
"dp[i][j][k] + dp[i][j-X[i]][k-1]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i][j-X[i]][k-1]",
"[j-X[i]]",
"[i]",
"dp",
"i",
"j-X[i]",
"j",
"X[i]",
"X",
"i",
"k-1",
"k",
"1",
"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",
"ans = 0",
"ans",
"0",
"for k in range(1, N+1):\n if k*A <= M:\n ans += dp[N][k*A][k]\n ",
"k",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if k*A <= M:\n ans += dp[N][k*A][k]\n ",
"k*A <= M",
"k*A",
"k",
"A",
"M",
"ans += dp[N][k*A][k]",
"ans",
"dp[N][k*A][k]",
"[k*A]",
"[N]",
"dp",
"N",
"k*A",
"k",
"A",
"k",
"print(ans)",
"print",
"ans",
"M = sum(X)",
"sum(X)",
"M",
"dp = [[[0]*(N+1) for _ in range(M+1)] for _ in range(N+1)]",
"[[[0]*(N+1) for _ in range(M+1)] for _ in range(N+1)]",
"dp",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"ans = 0",
"0",
"ans",
"N,A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans += dp[N][k*A][k]",
"dp[N][k*A][k]",
"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()]
M = sum(X)
dp = [[[0]*(N+1) for _ in range(M+1)] for _ in range(N+1)]
for i in range(N+1):
dp[i][0][0] = 1
for i in range(N):
for j in range(M+1):
for k in range(1, N+1):
if j >= X[i]:
dp[i+1][j][k] = dp[i][j][k] + dp[i][j-X[i]][k-1]
else:
dp[i+1][j][k] = dp[i][j][k]
ans = 0
for k in range(1, N+1):
if k*A <= M:
ans += dp[N][k*A][k]
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,
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,
21,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
78,
2
],
[
78,
11
],
[
81,
13
],
[
76,
23
],
[
72,
31
],
[
38,
37
],
[
82,
37
],
[
73,
46
],
[
54,
49
],
[
73,
50
],
[
37,
53
],
[
73,
57
],
[
37,
61
],
[
73,
68
],
[
72,
73
],
[
78,
76
],
[
78,
79
],
[
81,
82
]
] | [
"n, a = map(int, input().split())\nnums = list(map(lambda x: int(x) - a, input().split()))\n\ndp = {0 : 1}\n\nfor n in nums:\n\tfor k, v in list(dp.items()):\n\t\tdp[k+n] =dp.get(k+n, 0) + v\nprint(dp[0] - 1)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"nums = list(map(lambda x: int(x) - a, input().split()))",
"nums",
"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 n in nums:\n\tfor k, v in list(dp.items()):\n\t\tdp[k+n] =dp.get(k+n, 0) + v",
"n",
"nums",
"for k, v in list(dp.items()):\n\t\tdp[k+n] =dp.get(k+n, 0) + v",
"k",
"v",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"dp[k+n] =dp.get(k+n, 0) + v",
"dp[k+n]",
"dp",
"k+n",
"k",
"n",
"dp.get(k+n, 0) + v",
"dp.get(k+n, 0)",
"dp.get",
"dp",
"get",
"k+n",
"k",
"n",
"0",
"v",
"print(dp[0] - 1)",
"print",
"dp[0] - 1",
"dp[0]",
"dp",
"0",
"1",
"dp = {0 : 1}",
"{0 : 1}",
"dp",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"nums = list(map(lambda x: int(x) - a, input().split()))",
"list(map(lambda x: int(x) - a, input().split()))",
"nums"
] | n, a = map(int, input().split())
nums = list(map(lambda x: int(x) - a, input().split()))
dp = {0 : 1}
for n in nums:
for k, v in list(dp.items()):
dp[k+n] =dp.get(k+n, 0) + v
print(dp[0] - 1)
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
17,
0,
13,
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,
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,
0,
13,
18,
13,
2,
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,
2,
2,
2,
13,
13,
2,
13,
17,
40,
2,
13,
17,
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,
2,
13,
13,
14,
40,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
4,
13,
10,
12,
13,
10,
18,
13,
10,
17,
13
] | [
[
203,
11
],
[
197,
18
],
[
206,
23
],
[
29,
28
],
[
204,
35
],
[
29,
37
],
[
40,
39
],
[
204,
48
],
[
52,
51
],
[
39,
54
],
[
58,
57
],
[
28,
61
],
[
67,
66
],
[
76,
69
],
[
66,
72
],
[
79,
78
],
[
28,
83
],
[
87,
86
],
[
39,
88
],
[
78,
90
],
[
94,
93
],
[
28,
97
],
[
101,
100
],
[
51,
104
],
[
114,
107
],
[
66,
110
],
[
78,
111
],
[
93,
112
],
[
100,
113
],
[
66,
117
],
[
78,
119
],
[
93,
121
],
[
100,
122
],
[
100,
127
],
[
86,
128
],
[
51,
130
],
[
93,
134
],
[
28,
136
],
[
149,
138
],
[
66,
141
],
[
78,
142
],
[
93,
144
],
[
100,
147
],
[
86,
148
],
[
66,
152
],
[
78,
154
],
[
93,
156
],
[
100,
157
],
[
160,
159
],
[
163,
162
],
[
28,
167
],
[
171,
170
],
[
37,
172
],
[
162,
173
],
[
170,
176
],
[
51,
177
],
[
180,
179
],
[
66,
183
],
[
28,
184
],
[
162,
185
],
[
170,
186
],
[
179,
189
],
[
159,
189
],
[
201,
195
],
[
197,
198
],
[
203,
204
],
[
206,
207
]
] | [
"import sys\n\nsys.setrecursionlimit(10 ** 7)\ninput = sys.stdin.readline\nf_inf = float('inf')\nmod = 998244353\n\n\ndef resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = sum(X)\n dp = [[[0] * (MAX + 1) 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 + 1):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX + 1 and j + 1 <= n:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n total = a * j\n if total <= MAX:\n res += dp[n][j][total]\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",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"f_inf = float('inf')",
"f_inf",
"float('inf')",
"float",
"'inf'",
"mod = 998244353",
"mod",
"998244353",
"def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = sum(X)\n dp = [[[0] * (MAX + 1) 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 + 1):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX + 1 and j + 1 <= n:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n total = a * j\n if total <= MAX:\n res += dp[n][j][total]\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 = sum(X)",
"MAX",
"sum(X)",
"sum",
"X",
"[[0] * (MAX + 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 + 1) for _ in range(n + 1)]",
"dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]",
"dp",
"[[[0] * (MAX + 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(1, n + 1):\n x = X[i - 1]\n for j in range(n + 1):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX + 1 and j + 1 <= n:\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 + 1):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX + 1 and j + 1 <= n:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n ",
"j",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for k in range(MAX + 1):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX + 1 and j + 1 <= n:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n ",
"k",
"range(MAX + 1)",
"range",
"MAX + 1",
"MAX",
"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 k + x < MAX + 1 and j + 1 <= n:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n ",
"k + x < MAX + 1 and j + 1 <= n",
"k + x < MAX + 1",
"k + x",
"k",
"x",
"MAX + 1",
"MAX",
"1",
"j + 1 <= n",
"j + 1",
"j",
"1",
"n",
"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 total = a * j\n if total <= MAX:\n res += dp[n][j][total]\n ",
"j",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"total = a * j",
"total",
"a * j",
"a",
"j",
"if total <= MAX:\n res += dp[n][j][total]\n ",
"total <= MAX",
"total",
"MAX",
"res += dp[n][j][total]",
"res",
"dp[n][j][total]",
"[j]",
"[n]",
"dp",
"n",
"j",
"total",
"print(res)",
"print",
"res",
"if __name__ == '__main__':\n resolve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"resolve()",
"resolve",
"f_inf = float('inf')",
"float('inf')",
"f_inf",
"def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = sum(X)\n dp = [[[0] * (MAX + 1) 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 + 1):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX + 1 and j + 1 <= n:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n total = a * j\n if total <= MAX:\n res += dp[n][j][total]\n print(res)",
"def resolve():\n n, a = map(int, input().split())\n X = list(map(int, input().split()))\n MAX = sum(X)\n dp = [[[0] * (MAX + 1) 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 + 1):\n for k in range(MAX + 1):\n dp[i][j][k] += dp[i - 1][j][k]\n if k + x < MAX + 1 and j + 1 <= n:\n dp[i][j + 1][k + x] += dp[i - 1][j][k]\n res = 0\n for j in range(1, n + 1):\n total = a * j\n if total <= MAX:\n res += dp[n][j][total]\n print(res)",
"resolve",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"mod = 998244353",
"998244353",
"mod"
] | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 998244353
def resolve():
n, a = map(int, input().split())
X = list(map(int, input().split()))
MAX = sum(X)
dp = [[[0] * (MAX + 1) 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 + 1):
for k in range(MAX + 1):
dp[i][j][k] += dp[i - 1][j][k]
if k + x < MAX + 1 and j + 1 <= n:
dp[i][j + 1][k + x] += dp[i - 1][j][k]
res = 0
for j in range(1, n + 1):
total = a * j
if total <= MAX:
res += dp[n][j][total]
print(res)
if __name__ == '__main__':
resolve()
|
[
7,
15,
15,
13,
15,
12,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
13,
17,
17,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
2,
13,
17,
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,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
18,
18,
13,
13,
2,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
4,
13,
17,
0,
13,
17,
13,
12,
13,
0,
13,
18,
13,
13,
0,
13,
17,
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,
18,
13,
13,
13,
0,
13,
18,
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,
4,
18,
13,
13,
13,
0,
13,
18,
13,
13,
4,
13,
4,
13,
13,
13,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
206,
6
],
[
102,
6
],
[
9,
8
],
[
97,
11
],
[
14,
13
],
[
97,
16
],
[
19,
18
],
[
95,
23
],
[
42,
27
],
[
91,
30
],
[
8,
32
],
[
18,
35
],
[
93,
37
],
[
8,
38
],
[
13,
40
],
[
91,
45
],
[
8,
46
],
[
18,
47
],
[
13,
48
],
[
59,
50
],
[
91,
53
],
[
8,
55
],
[
18,
57
],
[
13,
58
],
[
91,
62
],
[
8,
63
],
[
18,
64
],
[
13,
65
],
[
68,
67
],
[
71,
70
],
[
97,
75
],
[
79,
78
],
[
91,
82
],
[
97,
83
],
[
70,
85
],
[
99,
86
],
[
70,
87
],
[
78,
89
],
[
67,
89
],
[
91,
91
],
[
93,
93
],
[
95,
95
],
[
97,
97
],
[
99,
99
],
[
206,
101
],
[
102,
101
],
[
108,
107
],
[
206,
109
],
[
102,
109
],
[
114,
113
],
[
119,
118
],
[
122,
121
],
[
113,
128
],
[
122,
130
],
[
133,
132
],
[
113,
141
],
[
145,
144
],
[
132,
149
],
[
152,
151
],
[
158,
157
],
[
121,
161
],
[
167,
166
],
[
176,
169
],
[
166,
172
],
[
179,
178
],
[
166,
183
],
[
186,
185
],
[
206,
192
],
[
178,
193
],
[
166,
193
],
[
144,
194
],
[
132,
194
],
[
118,
195
],
[
121,
196
],
[
130,
197
],
[
209,
203
],
[
206,
206
],
[
102,
206
]
] | [
"from sys import stdin\nimport numpy as np\nfrom numba import njit\n\n@njit(\"i8(i8[:,:,:],i8[:],i8,i8,i8)\",cache=True)\ndef f(dp,x,con,n,a):\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n\n return ans\n\ndef main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n x=np.array(x,dtype=np.int64)\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n dp=np.array(dp,dtype=np.int64)\n\n print(f(dp,x,con,n,a))\n\nif __name__==\"__main__\":\n main()",
"from sys import stdin",
"import numpy as np",
"numpy",
"from numba import njit",
"def f(dp,x,con,n,a):\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n\n return ans",
"f",
"for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n ",
"i",
"range(n)",
"range",
"n",
"for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n ",
"k",
"range(n)",
"range",
"n",
"for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n ",
"j",
"range(con+1-50)",
"range",
"con+1-50",
"con+1",
"con",
"1",
"50",
"dp[i+1][j+x[i]][k+1]+=dp[i][j][k]",
"dp[i+1][j+x[i]][k+1]",
"[j+x[i]]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+x[i]",
"j",
"x[i]",
"x",
"i",
"k+1",
"k",
"1",
"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",
"ans=0",
"ans",
"0",
"for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n\n ",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans+=dp[n][k*a][k]",
"ans",
"dp[n][k*a][k]",
"[k*a]",
"[n]",
"dp",
"n",
"k*a",
"k",
"a",
"k",
"return ans",
"ans",
"dp",
"dp",
"x",
"x",
"con",
"con",
"n",
"n",
"a",
"a",
"@njit(\"i8(i8[:,:,:],i8[:],i8,i8,i8)\",cache=True)",
"f",
"\"i8(i8[:,:,:],i8[:],i8,i8,i8)\",cache=True",
"@njit(\"i8(i8[:,:,:],i8[:],i8,i8,i8)\",cache=True)",
"njit",
"\"i8(i8[:,:,:],i8[:],i8,i8,i8)\"",
"cache=True",
"cache",
"True",
"f",
"def main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n x=np.array(x,dtype=np.int64)\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n dp=np.array(dp,dtype=np.int64)\n\n print(f(dp,x,con,n,a))",
"main",
"readline=stdin.readline",
"readline",
"stdin.readline",
"stdin",
"readline",
"con=2500",
"con",
"2500",
"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=np.array(x,dtype=np.int64)",
"x",
"np.array(x,dtype=np.int64)",
"np.array",
"np",
"array",
"x",
"dtype=np.int64",
"dtype",
"np.int64",
"np",
"int64",
"[[0]*(n+1) for _ in range(con+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]*(n+1) for _ in range(con+1)]",
"dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]",
"dp",
"[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]",
"dp[0][0][0]=1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"dp=np.array(dp,dtype=np.int64)",
"dp",
"np.array(dp,dtype=np.int64)",
"np.array",
"np",
"array",
"dp",
"dtype=np.int64",
"dtype",
"np.int64",
"np",
"int64",
"print(f(dp,x,con,n,a))",
"print",
"f(dp,x,con,n,a)",
"f",
"dp",
"x",
"con",
"n",
"a",
"if __name__==\"__main__\":\n main()",
"__name__==\"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def f(dp,x,con,n,a):\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n\n return ans",
"def f(dp,x,con,n,a):\n for i in range(n):\n for k in range(n):\n for j in range(con+1-50):\n #i枚目を選ぶ\n dp[i+1][j+x[i]][k+1]+=dp[i][j][k]\n\n #i枚目を選ばない\n dp[i+1][j][k]+=dp[i][j][k]\n ans=0\n for k in range(1,n+1):\n ans+=dp[n][k*a][k]\n\n return ans",
"f",
"def main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n x=np.array(x,dtype=np.int64)\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n dp=np.array(dp,dtype=np.int64)\n\n print(f(dp,x,con,n,a))",
"def main():\n #入力\n readline=stdin.readline\n con=2500\n n,a=map(int,readline().split())\n x=list(map(int,readline().split()))\n x=np.array(x,dtype=np.int64)\n\n dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]\n dp[0][0][0]=1\n dp=np.array(dp,dtype=np.int64)\n\n print(f(dp,x,con,n,a))",
"main"
] | from sys import stdin
import numpy as np
from numba import njit
@njit("i8(i8[:,:,:],i8[:],i8,i8,i8)",cache=True)
def f(dp,x,con,n,a):
for i in range(n):
for k in range(n):
for j in range(con+1-50):
#i枚目を選ぶ
dp[i+1][j+x[i]][k+1]+=dp[i][j][k]
#i枚目を選ばない
dp[i+1][j][k]+=dp[i][j][k]
ans=0
for k in range(1,n+1):
ans+=dp[n][k*a][k]
return ans
def main():
#入力
readline=stdin.readline
con=2500
n,a=map(int,readline().split())
x=list(map(int,readline().split()))
x=np.array(x,dtype=np.int64)
dp=[[[0]*(n+1) for _ in range(con+1)] for _ in range(n+1)]
dp[0][0][0]=1
dp=np.array(dp,dtype=np.int64)
print(f(dp,x,con,n,a))
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,
2,
39,
17,
2,
13,
17,
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,
2,
13,
18,
13,
13,
17,
39,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
40,
2,
13,
13,
13,
0,
13,
18,
18,
13,
13,
2,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
143,
2
],
[
143,
11
],
[
131,
13
],
[
137,
25
],
[
132,
28
],
[
32,
31
],
[
144,
35
],
[
138,
42
],
[
146,
45
],
[
53,
48
],
[
147,
50
],
[
56,
55
],
[
144,
58
],
[
61,
60
],
[
144,
64
],
[
69,
68
],
[
138,
74
],
[
132,
76
],
[
55,
77
],
[
93,
82
],
[
147,
84
],
[
60,
86
],
[
68,
89
],
[
132,
91
],
[
55,
92
],
[
147,
95
],
[
60,
96
],
[
68,
97
],
[
128,
99
],
[
103,
102
],
[
144,
107
],
[
141,
112
],
[
102,
113
],
[
138,
114
],
[
134,
116
],
[
147,
119
],
[
102,
120
],
[
141,
122
],
[
102,
123
],
[
135,
126
],
[
129,
126
],
[
128,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
143,
141
],
[
143,
144
],
[
146,
147
]
] | [
"N, A = map(int, input().split())\nx = list(map(int, input().split()))\nMAX_J = sum(x)\ndp = [[0] * (MAX_J+1) for i in range(N+1)]\ndp[0][0] = 1\nfor n in range(N):\n for i in range(N)[::-1]:\n for j in range(MAX_J-x[n]+1)[::-1]:\n dp[i+1][j+x[n]] += dp[i][j]\nans = 0\nfor i in range(1, N+1):\n if A * i <= MAX_J:\n ans += dp[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",
"MAX_J = sum(x)",
"MAX_J",
"sum(x)",
"sum",
"x",
"[0] * (MAX_J+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] * (MAX_J+1)",
"[0]",
"0",
"MAX_J+1",
"MAX_J",
"1",
"dp = [[0] * (MAX_J+1) for i in range(N+1)]",
"dp",
"[[0] * (MAX_J+1) for i in range(N+1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for n in range(N):\n for i in range(N)[::-1]:\n for j in range(MAX_J-x[n]+1)[::-1]:\n dp[i+1][j+x[n]] += dp[i][j]",
"n",
"range(N)",
"range",
"N",
"for i in range(N)[::-1]:\n for j in range(MAX_J-x[n]+1)[::-1]:\n dp[i+1][j+x[n]] += dp[i][j]",
"i",
"range(N)[::-1]",
"(N)",
"range",
"N",
"::-1",
"-1",
"for j in range(MAX_J-x[n]+1)[::-1]:\n dp[i+1][j+x[n]] += dp[i][j]",
"j",
"range(MAX_J-x[n]+1)[::-1]",
"(MAX_J-x[n]+1)",
"range",
"MAX_J-x[n]+1",
"MAX_J-x[n]",
"MAX_J",
"x[n]",
"x",
"n",
"1",
"::-1",
"-1",
"dp[i+1][j+x[n]] += dp[i][j]",
"dp[i+1][j+x[n]]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+x[n]",
"j",
"x[n]",
"x",
"n",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"ans = 0",
"ans",
"0",
"for i in range(1, N+1):\n if A * i <= MAX_J:\n ans += dp[i][A * i]",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if A * i <= MAX_J:\n ans += dp[i][A * i]",
"A * i <= MAX_J",
"A * i",
"A",
"i",
"MAX_J",
"ans += dp[i][A * i]",
"ans",
"dp[i][A * i]",
"[i]",
"dp",
"i",
"A * i",
"A",
"i",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"ans += dp[i][A * i]",
"dp[i][A * i]",
"ans",
"MAX_J = sum(x)",
"sum(x)",
"MAX_J",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"dp = [[0] * (MAX_J+1) for i in range(N+1)]",
"[[0] * (MAX_J+1) for i in range(N+1)]",
"dp"
] | N, A = map(int, input().split())
x = list(map(int, input().split()))
MAX_J = sum(x)
dp = [[0] * (MAX_J+1) for i in range(N+1)]
dp[0][0] = 1
for n in range(N):
for i in range(N)[::-1]:
for j in range(MAX_J-x[n]+1)[::-1]:
dp[i+1][j+x[n]] += dp[i][j]
ans = 0
for i in range(1, N+1):
if A * i <= MAX_J:
ans += dp[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,
0,
13,
4,
13,
13,
4,
18,
13,
13,
17,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
18,
13,
17,
17,
17,
0,
18,
18,
18,
13,
17,
17,
17,
17,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
2,
13,
13,
2,
13,
13,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
13,
2,
13,
17,
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,
13,
17,
0,
13,
17,
42,
2,
40,
13,
13,
40,
2,
13,
13,
2,
13,
13,
0,
13,
18,
18,
18,
13,
13,
2,
13,
13,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
17,
13,
10,
18,
13
] | [
[
194,
2
],
[
194,
11
],
[
188,
13
],
[
179,
25
],
[
189,
28
],
[
189,
31
],
[
38,
37
],
[
186,
41
],
[
200,
46
],
[
58,
49
],
[
201,
52
],
[
189,
55
],
[
67,
60
],
[
201,
63
],
[
70,
69
],
[
186,
73
],
[
206,
75
],
[
189,
77
],
[
69,
79
],
[
83,
82
],
[
186,
87
],
[
180,
88
],
[
92,
91
],
[
69,
95
],
[
82,
100
],
[
207,
101
],
[
186,
103
],
[
180,
104
],
[
119,
106
],
[
201,
109
],
[
69,
111
],
[
82,
114
],
[
207,
115
],
[
91,
117
],
[
201,
122
],
[
69,
123
],
[
82,
124
],
[
91,
125
],
[
136,
127
],
[
201,
130
],
[
69,
132
],
[
82,
134
],
[
91,
135
],
[
201,
139
],
[
69,
140
],
[
82,
141
],
[
91,
142
],
[
203,
144
],
[
191,
147
],
[
192,
152
],
[
183,
152
],
[
186,
153
],
[
195,
156
],
[
192,
157
],
[
183,
157
],
[
186,
159
],
[
180,
160
],
[
197,
162
],
[
201,
166
],
[
186,
167
],
[
195,
169
],
[
192,
170
],
[
183,
170
],
[
192,
171
],
[
183,
171
],
[
182,
173
],
[
198,
177
],
[
204,
177
],
[
179,
180
],
[
182,
183
],
[
194,
186
],
[
188,
189
],
[
191,
192
],
[
194,
195
],
[
197,
198
],
[
200,
201
],
[
203,
204
],
[
206,
207
]
] | [
"n,a=map(int,input().split())\n\nx=list(map(int,input().split()))\nA=max(x)\nx.insert(0,-1)\ndp=[[[0]*(n+1) for _ in range(n*A+1)] for i in range(n+1)]\ndp[1][x[1]][1]=1\ndp[1][0][0]=1\nfor i in range(1,n):\n q=x[i+1]\n for s in range(n*A+1):\n for k in range(i+1):\n if s+q<=n*A:\n dp[i+1][s+q][k+1]+=dp[i][s][k]\n dp[i+1][s][k]+=dp[i][s][k]\n\nans=0\ni=1\n\nwhile i<=n and a*i<=n*A:\n ans+=dp[n][a*(i)][i]\n i+=1\nprint(ans)\n\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",
"A=max(x)",
"A",
"max(x)",
"max",
"x",
"x.insert(0,-1)",
"x.insert",
"x",
"insert",
"0",
"-1",
"[[0]*(n+1) for _ in range(n*A+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+1) for _ in range(n*A+1)]",
"dp=[[[0]*(n+1) for _ in range(n*A+1)] for i in range(n+1)]",
"dp",
"[[[0]*(n+1) for _ in range(n*A+1)] for i in range(n+1)]",
"dp[1][x[1]][1]=1",
"dp[1][x[1]][1]",
"[x[1]]",
"[1]",
"dp",
"1",
"x[1]",
"x",
"1",
"1",
"1",
"dp[1][0][0]=1",
"dp[1][0][0]",
"[0]",
"[1]",
"dp",
"1",
"0",
"0",
"1",
"for i in range(1,n):\n q=x[i+1]\n for s in range(n*A+1):\n for k in range(i+1):\n if s+q<=n*A:\n dp[i+1][s+q][k+1]+=dp[i][s][k]\n dp[i+1][s][k]+=dp[i][s][k]",
"i",
"range(1,n)",
"range",
"1",
"n",
"q=x[i+1]",
"q",
"x[i+1]",
"x",
"i+1",
"i",
"1",
"for s in range(n*A+1):\n for k in range(i+1):\n if s+q<=n*A:\n dp[i+1][s+q][k+1]+=dp[i][s][k]\n dp[i+1][s][k]+=dp[i][s][k]",
"s",
"range(n*A+1)",
"range",
"n*A+1",
"n*A",
"n",
"A",
"1",
"for k in range(i+1):\n if s+q<=n*A:\n dp[i+1][s+q][k+1]+=dp[i][s][k]\n dp[i+1][s][k]+=dp[i][s][k]",
"k",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"if s+q<=n*A:\n dp[i+1][s+q][k+1]+=dp[i][s][k]\n ",
"s+q<=n*A",
"s+q",
"s",
"q",
"n*A",
"n",
"A",
"dp[i+1][s+q][k+1]+=dp[i][s][k]",
"dp[i+1][s+q][k+1]",
"[s+q]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"s+q",
"s",
"q",
"k+1",
"k",
"1",
"dp[i][s][k]",
"[s]",
"[i]",
"dp",
"i",
"s",
"k",
"dp[i+1][s][k]+=dp[i][s][k]",
"dp[i+1][s][k]",
"[s]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"s",
"k",
"dp[i][s][k]",
"[s]",
"[i]",
"dp",
"i",
"s",
"k",
"ans=0",
"ans",
"0",
"i=1",
"i",
"1",
"while i<=n and a*i<=n*A:\n ans+=dp[n][a*(i)][i]\n i+=1",
"i<=n and a*i<=n*A",
"i<=n",
"i",
"n",
"a*i<=n*A",
"a*i",
"a",
"i",
"n*A",
"n",
"A",
"ans+=dp[n][a*(i)][i]",
"ans",
"dp[n][a*(i)][i]",
"[a*(i)]",
"[n]",
"dp",
"n",
"a*(i)",
"a",
"i",
"i",
"i+=1",
"i",
"1",
"print(ans)",
"print",
"ans",
"A=max(x)",
"max(x)",
"A",
"i+=1",
"1",
"i",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"x=list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"i=1",
"1",
"i",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"ans+=dp[n][a*(i)][i]",
"dp[n][a*(i)][i]",
"ans",
"dp=[[[0]*(n+1) for _ in range(n*A+1)] for i in range(n+1)]",
"[[[0]*(n+1) for _ in range(n*A+1)] for i in range(n+1)]",
"dp",
"ans=0",
"0",
"ans",
"q=x[i+1]",
"x[i+1]",
"q"
] | n,a=map(int,input().split())
x=list(map(int,input().split()))
A=max(x)
x.insert(0,-1)
dp=[[[0]*(n+1) for _ in range(n*A+1)] for i in range(n+1)]
dp[1][x[1]][1]=1
dp[1][0][0]=1
for i in range(1,n):
q=x[i+1]
for s in range(n*A+1):
for k in range(i+1):
if s+q<=n*A:
dp[i+1][s+q][k+1]+=dp[i][s][k]
dp[i+1][s][k]+=dp[i][s][k]
ans=0
i=1
while i<=n and a*i<=n*A:
ans+=dp[n][a*(i)][i]
i+=1
print(ans)
|
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
4,
18,
4,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
4,
13,
4,
18,
13,
13,
13,
13,
0,
13,
4,
18,
13,
13,
2,
2,
17,
13,
17,
0,
13,
18,
13,
13,
0,
18,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
14,
40,
13,
17,
0,
18,
13,
39,
13,
2,
18,
13,
39,
13,
18,
13,
39,
2,
2,
2,
17,
13,
17,
13,
0,
18,
13,
39,
13,
2,
18,
13,
39,
13,
18,
13,
39,
40,
13,
4,
13,
2,
18,
13,
13,
17,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
139,
4
],
[
139,
13
],
[
127,
15
],
[
27,
26
],
[
124,
31
],
[
128,
33
],
[
140,
34
],
[
136,
36
],
[
128,
42
],
[
140,
44
],
[
131,
45
],
[
142,
47
],
[
137,
55
],
[
59,
58
],
[
66,
63
],
[
143,
64
],
[
137,
65
],
[
69,
68
],
[
131,
71
],
[
133,
73
],
[
125,
75
],
[
68,
76
],
[
134,
79
],
[
86,
82
],
[
143,
83
],
[
143,
88
],
[
143,
92
],
[
137,
98
],
[
134,
100
],
[
106,
102
],
[
143,
103
],
[
143,
108
],
[
143,
112
],
[
134,
115
],
[
63,
119
],
[
143,
120
],
[
137,
121
],
[
124,
125
],
[
127,
128
],
[
139,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
]
] | [
"import numpy as np\n\nn,a = map(int, input().split())\nX = np.array(input().split(), dtype=np.int64)\nY = X-a\nU = max(X.max(), a) * n\ndp = np.zeros(2*U+1, dtype=np.int64)\ndp[U] = 1\nfor i in range(n):\n y = Y[i]\n if y >= 0:\n dp[y:] = dp[y:] + dp[:2*U+1-y]\n else:\n dp[:y] = dp[:y] + dp[-y:]\nprint(dp[U]-1)",
"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 = np.array(input().split(), dtype=np.int64)",
"X",
"np.array(input().split(), dtype=np.int64)",
"np.array",
"np",
"array",
"input().split()",
"().split",
"()",
"input",
"split",
"dtype=np.int64",
"dtype",
"np.int64",
"np",
"int64",
"Y = X-a",
"Y",
"X-a",
"X",
"a",
"U = max(X.max(), a) * n",
"U",
"max(X.max(), a) * n",
"max(X.max(), a)",
"max",
"X.max()",
"X.max",
"X",
"max",
"a",
"n",
"dp = np.zeros(2*U+1, dtype=np.int64)",
"dp",
"np.zeros(2*U+1, dtype=np.int64)",
"np.zeros",
"np",
"zeros",
"2*U+1",
"2*U",
"2",
"U",
"1",
"dtype=np.int64",
"dtype",
"np.int64",
"np",
"int64",
"dp[U] = 1",
"dp[U]",
"dp",
"U",
"1",
"for i in range(n):\n y = Y[i]\n if y >= 0:\n dp[y:] = dp[y:] + dp[:2*U+1-y]\n else:\n dp[:y] = dp[:y] + dp[-y:]",
"i",
"range(n)",
"range",
"n",
"y = Y[i]",
"y",
"Y[i]",
"Y",
"i",
"if y >= 0:\n dp[y:] = dp[y:] + dp[:2*U+1-y]\n else:\n dp[:y] = dp[:y] + dp[-y:]",
"y >= 0",
"y",
"0",
"dp[y:] = dp[y:] + dp[:2*U+1-y]",
"dp[y:]",
"dp",
"y:",
"y",
"dp[y:] + dp[:2*U+1-y]",
"dp[y:]",
"dp",
"y:",
"y",
"dp[:2*U+1-y]",
"dp",
":2*U+1-y",
"2*U+1-y",
"2*U+1",
"2*U",
"2",
"U",
"1",
"y",
"dp[:y] = dp[:y] + dp[-y:]",
"dp[:y]",
"dp",
":y",
"y",
"dp[:y] + dp[-y:]",
"dp[:y]",
"dp",
":y",
"y",
"dp[-y:]",
"dp",
"-y:",
"-y",
"y",
"print(dp[U]-1)",
"print",
"dp[U]-1",
"dp[U]",
"dp",
"U",
"1",
"Y = X-a",
"X-a",
"Y",
"X = np.array(input().split(), dtype=np.int64)",
"np.array(input().split(), dtype=np.int64)",
"X",
"n,a = map(int, input().split())",
"map(int, input().split())",
"n",
"y = Y[i]",
"Y[i]",
"y",
"U = max(X.max(), a) * n",
"max(X.max(), a) * n",
"U",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"dp = np.zeros(2*U+1, dtype=np.int64)",
"np.zeros(2*U+1, dtype=np.int64)",
"dp"
] | import numpy as np
n,a = map(int, input().split())
X = np.array(input().split(), dtype=np.int64)
Y = X-a
U = max(X.max(), a) * n
dp = np.zeros(2*U+1, dtype=np.int64)
dp[U] = 1
for i in range(n):
y = Y[i]
if y >= 0:
dp[y:] = dp[y:] + dp[:2*U+1-y]
else:
dp[:y] = dp[:y] + dp[-y:]
print(dp[U]-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,
15,
13,
0,
13,
4,
18,
13,
13,
39,
2,
13,
17,
17,
13,
0,
18,
13,
17,
17,
28,
13,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
18,
18,
13,
2,
13,
17,
39,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
99,
2
],
[
99,
11
],
[
90,
13
],
[
93,
27
],
[
100,
34
],
[
42,
39
],
[
94,
40
],
[
45,
44
],
[
91,
44
],
[
48,
47
],
[
100,
51
],
[
64,
56
],
[
94,
58
],
[
47,
60
],
[
94,
65
],
[
47,
66
],
[
102,
68
],
[
72,
71
],
[
100,
76
],
[
87,
79
],
[
94,
81
],
[
71,
82
],
[
88,
85
],
[
103,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
99,
97
],
[
99,
100
],
[
102,
103
]
] | [
"n,a=map(int,input().split())\nx=list(map(int,input().split()))\nimport numpy as np\ndp=np.zeros((n+1,2501),int)\ndp[0,0]=1\nfor xi in x:\n for i in range(n-1,-1,-1):\n dp[i+1][xi:]+=dp[i,:-xi]\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",
"x=list(map(int,input().split()))",
"x",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"import numpy as np",
"numpy",
"dp=np.zeros((n+1,2501),int)",
"dp",
"np.zeros((n+1,2501),int)",
"np.zeros",
"np",
"zeros",
"(n+1,2501)",
"n+1",
"n",
"1",
"2501",
"int",
"dp[0,0]=1",
"dp[0,0]",
"dp",
"0",
"1",
"for xi in x:\n for i in range(n-1,-1,-1):\n dp[i+1][xi:]+=dp[i,:-xi]",
"xi",
"x",
"for i in range(n-1,-1,-1):\n dp[i+1][xi:]+=dp[i,:-xi]",
"i",
"range(n-1,-1,-1)",
"range",
"n-1",
"n",
"1",
"-1",
"-1",
"dp[i+1][xi:]+=dp[i,:-xi]",
"dp[i+1][xi:]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"xi:",
"xi",
"dp[i,:-xi]",
"dp",
"i",
"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]",
"dp",
"i",
"print(ans)",
"print",
"ans",
"ans+=dp[i,i*a]",
"dp[i,i*a]",
"ans",
"x=list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"dp=np.zeros((n+1,2501),int)",
"np.zeros((n+1,2501),int)",
"dp",
"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())
x=list(map(int,input().split()))
import numpy as np
dp=np.zeros((n+1,2501),int)
dp[0,0]=1
for xi in x:
for i in range(n-1,-1,-1):
dp[i+1][xi:]+=dp[i,:-xi]
ans=0
for i in range(1,n+1):
ans+=dp[i,i*a]
print(ans)
|
[
7,
12,
13,
15,
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,
13,
4,
2,
13,
13,
0,
13,
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,
13,
29,
2,
18,
13,
17,
17,
4,
13,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
6,
15
],
[
18,
17
],
[
18,
19
],
[
23,
22
],
[
22,
31
],
[
34,
33
],
[
38,
37
],
[
33,
37
],
[
37,
41
],
[
19,
42
],
[
45,
44
],
[
48,
47
],
[
55,
52
],
[
47,
53
],
[
58,
57
],
[
44,
57
],
[
47,
66
],
[
74,
69
],
[
47,
70
],
[
57,
73
],
[
47,
78
],
[
87,
84
]
] | [
"def c_tak_and_cards():\n from collections import defaultdict\n N, A = [int(i) for i in input().split()]\n X = [int(i) for i in input().split()]\n\n average = [x - A for x in X]\n dp = defaultdict(int) # dp[s]: y から 1 枚以上選んで整数の和を s にする方法\n dp[0] = 1 # 「選ばない」 1 通り\n for y in average:\n for k, v in list(dp.items()): # for 文中で要素数が変わってはいけないため\n dp[k + y] += v\n return dp[0] - 1\n\nprint(c_tak_and_cards())",
"def c_tak_and_cards():\n from collections import defaultdict\n N, A = [int(i) for i in input().split()]\n X = [int(i) for i in input().split()]\n\n average = [x - A for x in X]\n dp = defaultdict(int) # dp[s]: y から 1 枚以上選んで整数の和を s にする方法\n dp[0] = 1 # 「選ばない」 1 通り\n for y in average:\n for k, v in list(dp.items()): # for 文中で要素数が変わってはいけないため\n dp[k + y] += v\n return dp[0] - 1",
"c_tak_and_cards",
"from collections import defaultdict",
"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",
"N, A = [int(i) for i in input().split()]",
"N",
"[int(i) for i in 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 = [int(i) for i in input().split()]",
"X",
"[int(i) for i in input().split()]",
"x - A for x in X",
"for x in X",
"x",
"X",
"for x in X",
"x - A",
"x",
"A",
"average = [x - A for x in X]",
"average",
"[x - A for x in X]",
"dp = defaultdict(int)",
"dp",
"defaultdict(int)",
"defaultdict",
"int",
"dp[0] = 1",
"dp[0]",
"dp",
"0",
"1",
"for y in average:\n for k, v in list(dp.items()): # for 文中で要素数が変わってはいけないため\n dp[k + y] += v\n ",
"y",
"average",
"for k, v in list(dp.items()): # for 文中で要素数が変わってはいけないため\n dp[k + y] += v\n ",
"k",
"v",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"dp[k + y] += v",
"dp[k + y]",
"dp",
"k + y",
"k",
"y",
"v",
"return dp[0] - 1",
"dp[0] - 1",
"dp[0]",
"dp",
"0",
"1",
"print(c_tak_and_cards())",
"print",
"c_tak_and_cards()",
"c_tak_and_cards",
"def c_tak_and_cards():\n from collections import defaultdict\n N, A = [int(i) for i in input().split()]\n X = [int(i) for i in input().split()]\n\n average = [x - A for x in X]\n dp = defaultdict(int) # dp[s]: y から 1 枚以上選んで整数の和を s にする方法\n dp[0] = 1 # 「選ばない」 1 通り\n for y in average:\n for k, v in list(dp.items()): # for 文中で要素数が変わってはいけないため\n dp[k + y] += v\n return dp[0] - 1",
"def c_tak_and_cards():\n from collections import defaultdict\n N, A = [int(i) for i in input().split()]\n X = [int(i) for i in input().split()]\n\n average = [x - A for x in X]\n dp = defaultdict(int) # dp[s]: y から 1 枚以上選んで整数の和を s にする方法\n dp[0] = 1 # 「選ばない」 1 通り\n for y in average:\n for k, v in list(dp.items()): # for 文中で要素数が変わってはいけないため\n dp[k + y] += v\n return dp[0] - 1",
"c_tak_and_cards"
] | def c_tak_and_cards():
from collections import defaultdict
N, A = [int(i) for i in input().split()]
X = [int(i) for i in input().split()]
average = [x - A for x in X]
dp = defaultdict(int) # dp[s]: y から 1 枚以上選んで整数の和を s にする方法
dp[0] = 1 # 「選ばない」 1 通り
for y in average:
for k, v in list(dp.items()): # for 文中で要素数が変わってはいけないため
dp[k + y] += v
return dp[0] - 1
print(c_tak_and_cards()) |
[
7,
15,
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,
28,
13,
4,
13,
13,
0,
18,
13,
13,
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,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
83,
5
],
[
83,
14
],
[
80,
16
],
[
29,
28
],
[
84,
31
],
[
36,
33
],
[
81,
34
],
[
28,
35
],
[
78,
36
],
[
74,
38
],
[
46,
43
],
[
75,
44
],
[
49,
48
],
[
81,
48
],
[
75,
57
],
[
65,
60
],
[
75,
61
],
[
48,
64
],
[
75,
70
],
[
74,
75
],
[
83,
78
],
[
80,
81
],
[
83,
84
]
] | [
"from collections import defaultdict\nimport io\n\nnim, mike = map(int, input().split())\nkite = list(map(int, input().split()))\nfor i in range(nim):\n kite[i] -= mike\nqwe = defaultdict(int)\nqwe[0] = 1\nfor o in kite:\n for j, c in list(qwe.items()):\n qwe[j + o] += c\nprint(qwe[0]-1)",
"from collections import defaultdict",
"import io",
"io",
"nim, mike = map(int, input().split())",
"nim",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mike",
"kite = list(map(int, input().split()))",
"kite",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(nim):\n kite[i] -= mike",
"i",
"range(nim)",
"range",
"nim",
"kite[i] -= mike",
"kite[i]",
"kite",
"i",
"mike",
"qwe = defaultdict(int)",
"qwe",
"defaultdict(int)",
"defaultdict",
"int",
"qwe[0] = 1",
"qwe[0]",
"qwe",
"0",
"1",
"for o in kite:\n for j, c in list(qwe.items()):\n qwe[j + o] += c",
"o",
"kite",
"for j, c in list(qwe.items()):\n qwe[j + o] += c",
"j",
"c",
"list(qwe.items())",
"list",
"qwe.items()",
"qwe.items",
"qwe",
"items",
"qwe[j + o] += c",
"qwe[j + o]",
"qwe",
"j + o",
"j",
"o",
"c",
"print(qwe[0]-1)",
"print",
"qwe[0]-1",
"qwe[0]",
"qwe",
"0",
"1",
"qwe = defaultdict(int)",
"defaultdict(int)",
"qwe",
"mike = map(int, input().split())",
"map(int, input().split())",
"mike",
"kite = list(map(int, input().split()))",
"list(map(int, input().split()))",
"kite",
"nim, mike = map(int, input().split())",
"map(int, input().split())",
"nim"
] | from collections import defaultdict
import io
nim, mike = map(int, input().split())
kite = list(map(int, input().split()))
for i in range(nim):
kite[i] -= mike
qwe = defaultdict(int)
qwe[0] = 1
for o in kite:
for j, c in list(qwe.items()):
qwe[j + o] += c
print(qwe[0]-1) |
[
7,
15,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
12,
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,
15,
13,
0,
13,
4,
18,
13,
13,
39,
2,
13,
17,
17,
0,
13,
18,
13,
13,
0,
18,
13,
17,
17,
28,
13,
13,
0,
18,
13,
39,
17,
4,
18,
18,
13,
39,
17,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] | [
[
100,
4
],
[
15,
15
],
[
109,
17
],
[
101,
24
],
[
109,
26
],
[
112,
28
],
[
101,
37
],
[
115,
42
],
[
98,
49
],
[
54,
53
],
[
61,
58
],
[
116,
59
],
[
64,
63
],
[
113,
63
],
[
70,
66
],
[
116,
67
],
[
116,
73
],
[
103,
78
],
[
82,
81
],
[
98,
86
],
[
118,
89
],
[
116,
91
],
[
81,
92
],
[
119,
95
],
[
104,
95
],
[
109,
98
],
[
100,
101
],
[
103,
104
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
]
] | [
"import sys\nreadline = sys.stdin.buffer.readline\ndef even(n): return 1 if n%2==0 else 0\nn,a = map(int,readline().split())\nlst1 = list(map(int,readline().split()))\n\nimport numpy as np\n\ndp = np.zeros((n+1,3000),dtype=np.int64) # 枚数、目標数ごとに場合の数\ndp[0,0] = 1\n\nfor x in lst1:\n dp[1:,x:] += dp[:-1,:-x].copy()\n \nans = 0\nfor i in range(1,n+1):\n ans += dp[i,i*a]\n \nprint(ans)",
"import sys",
"sys",
"readline = sys.stdin.buffer.readline",
"readline",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"def even(n): return 1 if n%2==0 else 0",
"even",
"n",
"n",
"n,a = map(int,readline().split())",
"n",
"map(int,readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"a",
"lst1 = list(map(int,readline().split()))",
"lst1",
"list(map(int,readline().split()))",
"list",
"map(int,readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"import numpy as np",
"numpy",
"dp = np.zeros((n+1,3000),dtype=np.int64)",
"dp",
"np.zeros((n+1,3000),dtype=np.int64)",
"np.zeros",
"np",
"zeros",
"(n+1,3000)",
"n+1",
"n",
"1",
"3000",
"dtype=np.int64",
"dtype",
"np.int64",
"np",
"int64",
"dp[0,0] = 1",
"dp[0,0]",
"dp",
"0",
"1",
"for x in lst1:\n dp[1:,x:] += dp[:-1,:-x].copy()\n ",
"x",
"lst1",
"dp[1:,x:] += dp[:-1,:-x].copy()",
"dp[1:,x:]",
"dp",
"1:",
"1",
"dp[:-1,:-x].copy()",
"[:-1,:-x].copy",
"[:-1,:-x]",
"dp",
":-1",
"-1",
"copy",
"ans = 0",
"ans",
"0",
"for i in range(1,n+1):\n ans += dp[i,i*a]\n ",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[i,i*a]",
"ans",
"dp[i,i*a]",
"dp",
"i",
"print(ans)",
"print",
"ans",
"n,a = map(int,readline().split())",
"map(int,readline().split())",
"n",
"readline = sys.stdin.buffer.readline",
"sys.stdin.buffer.readline",
"readline",
"ans = 0",
"0",
"ans",
"def even(n): return 1 if n%2==0 else 0",
"def even(n): return 1 if n%2==0 else 0",
"even",
"a = map(int,readline().split())",
"map(int,readline().split())",
"a",
"lst1 = list(map(int,readline().split()))",
"list(map(int,readline().split()))",
"lst1",
"dp = np.zeros((n+1,3000),dtype=np.int64)",
"np.zeros((n+1,3000),dtype=np.int64)",
"dp",
"ans += dp[i,i*a]",
"dp[i,i*a]",
"ans"
] | import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n,a = map(int,readline().split())
lst1 = list(map(int,readline().split()))
import numpy as np
dp = np.zeros((n+1,3000),dtype=np.int64) # 枚数、目標数ごとに場合の数
dp[0,0] = 1
for x in lst1:
dp[1:,x:] += dp[:-1,:-x].copy()
ans = 0
for i in range(1,n+1):
ans += dp[i,i*a]
print(ans)
|
[
7,
0,
13,
12,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
8,
13,
4,
13,
17,
4,
13,
17,
23,
15,
13,
15,
13,
15,
13,
15,
13,
12,
13,
0,
13,
17,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
13,
13,
0,
13,
2,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
0,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
2,
17,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
40,
13,
2,
13,
17,
17,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
2,
13,
17,
2,
13,
13,
4,
13,
2,
18,
18,
13,
2,
13,
17,
17,
17,
10,
4,
13,
10,
12,
13,
10,
13,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
247,
2
],
[
223,
13
],
[
256,
26
],
[
259,
39
],
[
241,
46
],
[
69,
68
],
[
108,
72
],
[
110,
73
],
[
108,
79
],
[
110,
80
],
[
110,
81
],
[
84,
83
],
[
108,
85
],
[
110,
86
],
[
89,
88
],
[
83,
93
],
[
110,
93
],
[
97,
96
],
[
108,
99
],
[
83,
100
],
[
110,
100
],
[
88,
101
],
[
104,
103
],
[
88,
104
],
[
103,
106
],
[
96,
106
],
[
68,
106
],
[
108,
108
],
[
110,
110
],
[
235,
112
],
[
248,
114
],
[
235,
115
],
[
238,
117
],
[
224,
119
],
[
122,
121
],
[
221,
124
],
[
129,
126
],
[
239,
127
],
[
121,
128
],
[
236,
129
],
[
244,
131
],
[
239,
136
],
[
229,
138
],
[
250,
141
],
[
221,
144
],
[
148,
147
],
[
221,
151
],
[
226,
156
],
[
164,
159
],
[
227,
161
],
[
167,
166
],
[
221,
169
],
[
232,
171
],
[
126,
172
],
[
239,
173
],
[
166,
174
],
[
177,
176
],
[
251,
180
],
[
251,
182
],
[
191,
186
],
[
227,
188
],
[
166,
189
],
[
176,
190
],
[
227,
194
],
[
166,
196
],
[
176,
198
],
[
227,
201
],
[
166,
203
],
[
176,
206
],
[
233,
207
],
[
227,
213
],
[
221,
215
],
[
235,
221
],
[
223,
224
],
[
226,
227
],
[
229,
230
],
[
126,
232
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
250,
251
],
[
256,
257
],
[
259,
260
]
] | [
"ma = lambda :map(int,input().split())\nlma = lambda :list(map(int,input().split()))\ntma = lambda :tuple(map(int,input().split()))\nni = lambda:int(input())\nyn = lambda fl:print(\"Yes\") if fl else print(\"No\")\nimport collections\nimport math\nimport itertools\nimport heapq as hq\ndef ncr(n,r):\n ret = 1\n if n<r:\n return 0\n if n-r <r:\n r = n-r\n for i in range(1,r+1):\n ret*=(n-r+i)\n ret//=i\n return ret\n\nn,a = ma()\nX = lma()\nfor i in range(n):\n X[i] -= a\nco = collections.Counter(X)\nans = 0\nmx = 49*n #ずれの最大はA=1,x=50 2*mx +1この配列\ndp = [[0 for j in range(-mx,mx+1)] for i in range(n+1)]# dp[i][j] iまで使って値をjにする組み合わせ\ndp[-1][0] = 1 #一個も使わない組み合わせ\nfor i in range(n):\n x = X[i]\n #print(x)\n for j in range(-mx,mx+1,1):\n dp[i][j] += dp[i-1][j] + dp[i-1][j-x] #選ばない/ぶ\n #if j==0:print(i,j,dp[i-1][j] , dp[i-1][j-x])\nprint(dp[n-1][0]-1)",
"ma = lambda :map(int,input().split())",
"ma",
"lambda :map(int,input().split())",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"lma = lambda :list(map(int,input().split()))",
"lma",
"lambda :list(map(int,input().split()))",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"tma = lambda :tuple(map(int,input().split()))",
"tma",
"lambda :tuple(map(int,input().split()))",
"tuple(map(int,input().split()))",
"tuple",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ni = lambda:int(input())",
"ni",
"lambda:int(input())",
"int(input())",
"int",
"input()",
"input",
"yn = lambda fl:print(\"Yes\") if fl else print(\"No\")",
"yn",
"lambda fl:print(\"Yes\") if fl else print(\"No\")",
"print(\"Yes\") if fl else print(\"No\")",
"fl",
"print(\"Yes\")",
"print",
"\"Yes\"",
"print(\"No\")",
"print",
"\"No\"",
"fl",
"import collections",
"collections",
"import math",
"math",
"import itertools",
"itertools",
"import heapq as hq",
"heapq",
"def ncr(n,r):\n ret = 1\n if n<r:\n return 0\n if n-r <r:\n r = n-r\n for i in range(1,r+1):\n ret*=(n-r+i)\n ret//=i\n return ret",
"ncr",
"ret = 1",
"ret",
"1",
"if n<r:\n return 0\n ",
"n<r",
"n",
"r",
"return 0",
"0",
"if n-r <r:\n r = n-r\n ",
"n-r <r",
"n-r",
"n",
"r",
"r",
"r = n-r",
"r",
"n-r",
"n",
"r",
"for i in range(1,r+1):\n ret*=(n-r+i)\n ret//=i\n ",
"i",
"range(1,r+1)",
"range",
"1",
"r+1",
"r",
"1",
"ret*=(n-r+i)",
"ret",
"n-r+i",
"n-r",
"n",
"r",
"i",
"ret//=i",
"ret",
"i",
"return ret",
"ret",
"n",
"n",
"r",
"r",
"n,a = ma()",
"n",
"ma()",
"ma",
"a",
"X = lma()",
"X",
"lma()",
"lma",
"for i in range(n):\n X[i] -= a",
"i",
"range(n)",
"range",
"n",
"X[i] -= a",
"X[i]",
"X",
"i",
"a",
"co = collections.Counter(X)",
"co",
"collections.Counter(X)",
"collections.Counter",
"collections",
"Counter",
"X",
"ans = 0",
"ans",
"0",
"mx = 49*n",
"mx",
"49*n",
"49",
"n",
"[0 for j in range(-mx,mx+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(-mx,mx+1)]",
"dp = [[0 for j in range(-mx,mx+1)] for i in range(n+1)]",
"dp",
"[[0 for j in range(-mx,mx+1)] for i in range(n+1)]",
"dp[-1][0] = 1",
"dp[-1][0]",
"[-1]",
"dp",
"-1",
"0",
"1",
"for i in range(n):\n x = X[i]\n #print(x)\n for j in range(-mx,mx+1,1):\n dp[i][j] += dp[i-1][j] + dp[i-1][j-x] #選ばない/ぶ\n #if j==0:print(i,j,dp[i-1][j] , dp[i-1][j-x])",
"i",
"range(n)",
"range",
"n",
"x = X[i]",
"x",
"X[i]",
"X",
"i",
"for j in range(-mx,mx+1,1):\n dp[i][j] += dp[i-1][j] + dp[i-1][j-x] #選ばない/ぶ\n #if j==0:print(i,j,dp[i-1][j] , dp[i-1][j-x])",
"j",
"range(-mx,mx+1,1)",
"range",
"-mx",
"mx",
"mx+1",
"mx",
"1",
"1",
"dp[i][j] += dp[i-1][j] + dp[i-1][j-x]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j] + dp[i-1][j-x]",
"dp[i-1][j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"dp[i-1][j-x]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-x",
"j",
"x",
"print(dp[n-1][0]-1)",
"print",
"dp[n-1][0]-1",
"dp[n-1][0]",
"[n-1]",
"dp",
"n-1",
"n",
"1",
"0",
"1",
"n,a = ma()",
"ma()",
"n",
"lma = lambda :list(map(int,input().split()))",
"lambda :list(map(int,input().split()))",
"lma",
"dp = [[0 for j in range(-mx,mx+1)] for i in range(n+1)]",
"[[0 for j in range(-mx,mx+1)] for i in range(n+1)]",
"dp",
"ans = 0",
"0",
"ans",
"x = X[i]",
"X[i]",
"x",
"a = ma()",
"ma()",
"a",
"X = lma()",
"lma()",
"X",
"yn = lambda fl:print(\"Yes\") if fl else print(\"No\")",
"lambda fl:print(\"Yes\") if fl else print(\"No\")",
"yn",
"co = collections.Counter(X)",
"collections.Counter(X)",
"co",
"ma = lambda :map(int,input().split())",
"lambda :map(int,input().split())",
"ma",
"mx = 49*n",
"49*n",
"mx",
"def ncr(n,r):\n ret = 1\n if n<r:\n return 0\n if n-r <r:\n r = n-r\n for i in range(1,r+1):\n ret*=(n-r+i)\n ret//=i\n return ret",
"def ncr(n,r):\n ret = 1\n if n<r:\n return 0\n if n-r <r:\n r = n-r\n for i in range(1,r+1):\n ret*=(n-r+i)\n ret//=i\n return ret",
"ncr",
"tma = lambda :tuple(map(int,input().split()))",
"lambda :tuple(map(int,input().split()))",
"tma",
"ni = lambda:int(input())",
"lambda:int(input())",
"ni"
] | ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
def ncr(n,r):
ret = 1
if n<r:
return 0
if n-r <r:
r = n-r
for i in range(1,r+1):
ret*=(n-r+i)
ret//=i
return ret
n,a = ma()
X = lma()
for i in range(n):
X[i] -= a
co = collections.Counter(X)
ans = 0
mx = 49*n #ずれの最大はA=1,x=50 2*mx +1この配列
dp = [[0 for j in range(-mx,mx+1)] for i in range(n+1)]# dp[i][j] iまで使って値をjにする組み合わせ
dp[-1][0] = 1 #一個も使わない組み合わせ
for i in range(n):
x = X[i]
#print(x)
for j in range(-mx,mx+1,1):
dp[i][j] += dp[i-1][j] + dp[i-1][j-x] #選ばない/ぶ
#if j==0:print(i,j,dp[i-1][j] , dp[i-1][j-x])
print(dp[n-1][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,
2,
13,
13,
28,
13,
4,
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,
18,
13,
13,
2,
13,
17,
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,
2,
13,
13,
13,
4,
13,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
136,
2
],
[
136,
11
],
[
139,
13
],
[
27,
26
],
[
127,
33
],
[
43,
36
],
[
128,
39
],
[
46,
45
],
[
134,
48
],
[
51,
50
],
[
134,
54
],
[
137,
55
],
[
58,
57
],
[
134,
60
],
[
71,
62
],
[
128,
65
],
[
45,
67
],
[
50,
69
],
[
57,
70
],
[
128,
74
],
[
45,
75
],
[
50,
76
],
[
57,
77
],
[
94,
79
],
[
128,
82
],
[
45,
84
],
[
50,
87
],
[
140,
89
],
[
45,
90
],
[
57,
92
],
[
128,
97
],
[
45,
98
],
[
50,
99
],
[
57,
100
],
[
142,
102
],
[
106,
105
],
[
134,
110
],
[
130,
113
],
[
128,
117
],
[
134,
118
],
[
105,
120
],
[
137,
121
],
[
105,
122
],
[
131,
125
],
[
143,
125
],
[
127,
128
],
[
130,
131
],
[
136,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
]
] | [
"n,a = map(int,input().split())\nx = list(map(int,input().split()))\n\n\ndp = [[[0]*(55) for i in range(3000)]for i in range(55)]\ndp[0][0][0] = 1\n\nfor i in range(n):\n for j in range(n*a):\n for k in range(n):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+x[i]][k+1] += dp[i][j][k]\n \n \nans = 0\nfor k in range(1,n+1):\n ans += dp[n][k*a][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",
"[[0]*(55) for i in range(3000)]for i in range(55)",
"for i in range(55)",
"i",
"range(55)",
"range",
"55",
"for i in range(55)",
"[[0]*(55) for i in range(3000)]",
"dp = [[[0]*(55) for i in range(3000)]for i in range(55)]",
"dp",
"[[[0]*(55) for i in range(3000)]for i in range(55)]",
"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*a):\n for k in range(n):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+x[i]][k+1] += dp[i][j][k]\n \n ",
"i",
"range(n)",
"range",
"n",
"for j in range(n*a):\n for k in range(n):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+x[i]][k+1] += dp[i][j][k]\n \n ",
"j",
"range(n*a)",
"range",
"n*a",
"n",
"a",
"for k in range(n):\n dp[i+1][j][k] += dp[i][j][k]\n dp[i+1][j+x[i]][k+1] += dp[i][j][k]\n \n ",
"k",
"range(n)",
"range",
"n",
"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+x[i]][k+1] += dp[i][j][k]",
"dp[i+1][j+x[i]][k+1]",
"[j+x[i]]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+x[i]",
"j",
"x[i]",
"x",
"i",
"k+1",
"k",
"1",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"ans = 0",
"ans",
"0",
"for k in range(1,n+1):\n ans += dp[n][k*a][k]",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[n][k*a][k]",
"ans",
"dp[n][k*a][k]",
"[k*a]",
"[n]",
"dp",
"n",
"k*a",
"k",
"a",
"k",
"print(ans)",
"print",
"ans",
"dp = [[[0]*(55) for i in range(3000)]for i in range(55)]",
"[[[0]*(55) for i in range(3000)]for i in range(55)]",
"dp",
"ans += dp[n][k*a][k]",
"dp[n][k*a][k]",
"ans",
"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",
"ans = 0",
"0",
"ans"
] | n,a = map(int,input().split())
x = list(map(int,input().split()))
dp = [[[0]*(55) for i in range(3000)]for i in range(55)]
dp[0][0][0] = 1
for i in range(n):
for j in range(n*a):
for k in range(n):
dp[i+1][j][k] += dp[i][j][k]
dp[i+1][j+x[i]][k+1] += dp[i][j][k]
ans = 0
for k in range(1,n+1):
ans += dp[n][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,
41,
28,
13,
4,
13,
17,
4,
2,
39,
17,
17,
0,
13,
13,
28,
13,
13,
28,
13,
18,
4,
13,
17,
39,
17,
28,
13,
13,
4,
13,
18,
13,
13,
14,
40,
13,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
17,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
0,
13,
18,
18,
13,
13,
2,
13,
2,
13,
17,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
115,
2
],
[
115,
11
],
[
121,
13
],
[
27,
26
],
[
112,
36
],
[
40,
39
],
[
122,
39
],
[
43,
42
],
[
113,
55
],
[
42,
56
],
[
71,
62
],
[
113,
64
],
[
42,
66
],
[
39,
70
],
[
113,
73
],
[
42,
74
],
[
82,
77
],
[
113,
79
],
[
39,
81
],
[
118,
84
],
[
88,
87
],
[
106,
92
],
[
113,
95
],
[
87,
96
],
[
116,
98
],
[
87,
100
],
[
107,
104
],
[
119,
104
],
[
106,
107
],
[
115,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
]
] | [
"# coding: utf-8\n# Your code here!\nN,A=map(int,input().split())\n\nX=list(map(int,input().split()))\n\ndp=[[0]*2501 for i in range(50)]\n\nfor x in X:\n for i in range(49)[::-1]:\n for index,item in enumerate(dp[i]):\n if item!=0:\n dp[i+1][index+x]+=dp[i][index]\n dp[0][x]+=1\n\nans=0\nfor i in range(50):\n ans+=dp[i][A*(i+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",
"[0]*2501 for i in range(50)",
"for i in range(50)",
"i",
"range(50)",
"range",
"50",
"for i in range(50)",
"[0]*2501",
"[0]",
"0",
"2501",
"dp=[[0]*2501 for i in range(50)]",
"dp",
"[[0]*2501 for i in range(50)]",
"for x in X:\n for i in range(49)[::-1]:\n for index,item in enumerate(dp[i]):\n if item!=0:\n dp[i+1][index+x]+=dp[i][index]\n dp[0][x]+=1",
"x",
"X",
"for i in range(49)[::-1]:\n for index,item in enumerate(dp[i]):\n if item!=0:\n dp[i+1][index+x]+=dp[i][index]\n ",
"i",
"range(49)[::-1]",
"(49)",
"range",
"49",
"::-1",
"-1",
"for index,item in enumerate(dp[i]):\n if item!=0:\n dp[i+1][index+x]+=dp[i][index]\n ",
"index",
"item",
"enumerate(dp[i])",
"enumerate",
"dp[i]",
"dp",
"i",
"if item!=0:\n dp[i+1][index+x]+=dp[i][index]\n ",
"item!=0",
"item",
"0",
"dp[i+1][index+x]+=dp[i][index]",
"dp[i+1][index+x]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"index+x",
"index",
"x",
"dp[i][index]",
"[i]",
"dp",
"i",
"index",
"dp[0][x]+=1",
"dp[0][x]",
"[0]",
"dp",
"0",
"x",
"1",
"ans=0",
"ans",
"0",
"for i in range(50):\n ans+=dp[i][A*(i+1)]",
"i",
"range(50)",
"range",
"50",
"ans+=dp[i][A*(i+1)]",
"ans",
"dp[i][A*(i+1)]",
"[i]",
"dp",
"i",
"A*(i+1)",
"A",
"i+1",
"i",
"1",
"print(ans)",
"print",
"ans",
"ans+=dp[i][A*(i+1)]",
"dp[i][A*(i+1)]",
"ans",
"N,A=map(int,input().split())",
"map(int,input().split())",
"N",
"dp=[[0]*2501 for i in range(50)]",
"[[0]*2501 for i in range(50)]",
"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"
] | # coding: utf-8
# Your code here!
N,A=map(int,input().split())
X=list(map(int,input().split()))
dp=[[0]*2501 for i in range(50)]
for x in X:
for i in range(49)[::-1]:
for index,item in enumerate(dp[i]):
if item!=0:
dp[i+1][index+x]+=dp[i][index]
dp[0][x]+=1
ans=0
for i in range(50):
ans+=dp[i][A*(i+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,
2,
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,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
14,
40,
2,
13,
13,
2,
13,
13,
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,
17,
13,
10,
13,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
140,
2
],
[
140,
11
],
[
143,
13
],
[
134,
25
],
[
141,
27
],
[
126,
28
],
[
32,
31
],
[
126,
35
],
[
131,
40
],
[
48,
43
],
[
132,
45
],
[
144,
54
],
[
57,
56
],
[
60,
59
],
[
126,
63
],
[
69,
68
],
[
141,
73
],
[
126,
74
],
[
68,
81
],
[
141,
84
],
[
126,
85
],
[
96,
87
],
[
132,
89
],
[
59,
91
],
[
68,
94
],
[
132,
98
],
[
59,
99
],
[
68,
100
],
[
128,
102
],
[
106,
105
],
[
126,
110
],
[
137,
113
],
[
132,
116
],
[
105,
117
],
[
105,
119
],
[
141,
120
],
[
138,
123
],
[
129,
123
],
[
140,
126
],
[
128,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
]
] | [
"N, A = map(int, input().split())\nnums = list(map(int, input().split()))\nMAX = A*N\ndp = [[0 for _ in range(A*N+1)] for _ in range(N+1)]\ndp[0][0] = 1\nfor k, num in enumerate(nums, start=1):\n for i in range(N-1, -1, -1):\n for j in range(A*N-1, -1, -1):\n if j + num <= A*N:\n dp[i+1][j+num] += dp[i][j]\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",
"nums = list(map(int, input().split()))",
"nums",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"MAX = A*N",
"MAX",
"A*N",
"A",
"N",
"[0 for _ in range(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 for _ in range(A*N+1)]",
"dp = [[0 for _ in range(A*N+1)] for _ in range(N+1)]",
"dp",
"[[0 for _ in range(A*N+1)] for _ in range(N+1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for k, num in enumerate(nums, start=1):\n for i in range(N-1, -1, -1):\n for j in range(A*N-1, -1, -1):\n if j + num <= A*N:\n dp[i+1][j+num] += dp[i][j]",
"k",
"num",
"enumerate(nums, start=1)",
"enumerate",
"nums",
"start=1",
"start",
"1",
"for i in range(N-1, -1, -1):\n for j in range(A*N-1, -1, -1):\n if j + num <= A*N:\n dp[i+1][j+num] += dp[i][j]",
"i",
"range(N-1, -1, -1)",
"range",
"N-1",
"N",
"1",
"-1",
"-1",
"for j in range(A*N-1, -1, -1):\n if j + num <= A*N:\n dp[i+1][j+num] += dp[i][j]",
"j",
"range(A*N-1, -1, -1)",
"range",
"A*N-1",
"A*N",
"A",
"N",
"1",
"-1",
"-1",
"if j + num <= A*N:\n dp[i+1][j+num] += dp[i][j]",
"j + num <= A*N",
"j + num",
"j",
"num",
"A*N",
"A",
"N",
"dp[i+1][j+num] += dp[i][j]",
"dp[i+1][j+num]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j+num",
"j",
"num",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"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",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans = 0",
"0",
"ans",
"dp = [[0 for _ in range(A*N+1)] for _ in range(N+1)]",
"[[0 for _ in range(A*N+1)] for _ in range(N+1)]",
"dp",
"MAX = A*N",
"A*N",
"MAX",
"ans += dp[i][i*A]",
"dp[i][i*A]",
"ans",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"nums = list(map(int, input().split()))",
"list(map(int, input().split()))",
"nums"
] | N, A = map(int, input().split())
nums = list(map(int, input().split()))
MAX = A*N
dp = [[0 for _ in range(A*N+1)] for _ in range(N+1)]
dp[0][0] = 1
for k, num in enumerate(nums, start=1):
for i in range(N-1, -1, -1):
for j in range(A*N-1, -1, -1):
if j + num <= A*N:
dp[i+1][j+num] += dp[i][j]
ans = 0
for i in range(1, N+1):
ans += dp[i][i*A]
print(ans) |
[
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,
2,
2,
13,
4,
13,
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,
13,
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,
14,
2,
2,
13,
13,
4,
13,
13,
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
],
[
196,
34
],
[
33,
35
],
[
38,
37
],
[
196,
39
],
[
43,
42
],
[
32,
47
],
[
37,
50
],
[
56,
55
],
[
59,
58
],
[
32,
62
],
[
72,
65
],
[
55,
68
],
[
58,
71
],
[
75,
74
],
[
55,
79
],
[
82,
81
],
[
32,
86
],
[
90,
89
],
[
81,
92
],
[
32,
94
],
[
74,
99
],
[
37,
101
],
[
89,
103
],
[
114,
107
],
[
55,
110
],
[
74,
111
],
[
81,
112
],
[
89,
113
],
[
55,
117
],
[
74,
119
],
[
37,
121
],
[
89,
123
],
[
81,
126
],
[
89,
129
],
[
139,
132
],
[
55,
135
],
[
74,
136
],
[
81,
137
],
[
89,
138
],
[
55,
142
],
[
74,
143
],
[
81,
144
],
[
89,
146
],
[
150,
149
],
[
153,
152
],
[
32,
157
],
[
35,
162
],
[
152,
163
],
[
55,
166
],
[
169,
168
],
[
55,
172
],
[
35,
174
],
[
152,
175
],
[
152,
176
],
[
32,
177
],
[
168,
179
],
[
149,
179
],
[
193,
187
]
] | [
"\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(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]\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(j, 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 if A*j < len(OPT):\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(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]\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(j, 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 if A*j < len(OPT):\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(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)",
"for _ in range(N*max(x)+1)",
"_",
"range(N*max(x)+1)",
"range",
"N*max(x)+1",
"N*max(x)",
"N",
"max(x)",
"max",
"x",
"1",
"for _ in range(N*max(x)+1)",
"[[0 for _ in range(N+1)] for _ in range(N+1)]",
"OPT = [[[0 for _ in range(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]",
"OPT",
"[[[0 for _ in range(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]",
"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(j, 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(j, 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(j, 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(j, N+1)",
"range",
"j",
"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 if A*j < len(OPT):\n T += OPT[A*j][j][N]\n ",
"j",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if A*j < len(OPT):\n T += OPT[A*j][j][N]\n ",
"A*j < len(OPT)",
"A*j",
"A",
"j",
"len(OPT)",
"len",
"OPT",
"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_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(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]\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(j, 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 if A*j < len(OPT):\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(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]\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(j, 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 if A*j < len(OPT):\n T += OPT[A*j][j][N]\n return T",
"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():
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(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]
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(j, 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):
if A*j < len(OPT):
T += OPT[A*j][j][N]
return T
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,
13,
0,
13,
2,
13,
13,
41,
28,
13,
4,
13,
13,
4,
2,
39,
17,
2,
2,
17,
13,
17,
0,
13,
13,
0,
18,
18,
13,
17,
13,
17,
0,
18,
18,
13,
17,
2,
13,
2,
18,
13,
17,
13,
17,
28,
13,
4,
13,
17,
13,
28,
13,
4,
13,
2,
2,
17,
13,
17,
0,
13,
2,
13,
2,
18,
13,
13,
13,
14,
2,
2,
13,
17,
2,
13,
2,
17,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
2,
13,
17,
13,
18,
18,
13,
2,
13,
17,
13,
4,
13,
2,
18,
18,
13,
2,
13,
17,
13,
17,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
167,
2
],
[
167,
11
],
[
161,
13
],
[
170,
25
],
[
162,
28
],
[
158,
30
],
[
168,
32
],
[
171,
33
],
[
37,
36
],
[
168,
39
],
[
159,
47
],
[
164,
50
],
[
58,
53
],
[
165,
55
],
[
159,
57
],
[
71,
60
],
[
165,
62
],
[
159,
65
],
[
162,
68
],
[
153,
70
],
[
74,
73
],
[
168,
77
],
[
80,
79
],
[
159,
85
],
[
155,
88
],
[
79,
90
],
[
162,
93
],
[
73,
94
],
[
153,
95
],
[
156,
99
],
[
156,
102
],
[
159,
105
],
[
112,
107
],
[
165,
109
],
[
73,
110
],
[
79,
111
],
[
165,
114
],
[
73,
116
],
[
79,
118
],
[
125,
120
],
[
165,
122
],
[
73,
123
],
[
79,
124
],
[
165,
128
],
[
73,
130
],
[
79,
132
],
[
165,
135
],
[
73,
137
],
[
156,
139
],
[
53,
143
],
[
165,
145
],
[
168,
147
],
[
159,
149
],
[
167,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
],
[
170,
171
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\nxmax = max(X)\n\nOFS = N*xmax\ndp = [[0]*(2*OFS+1) for _ in range(N)]\ndp[0][OFS] += 1\ndp[0][OFS+(X[0]-A)] += 1\n\nfor i in range(1, N):\n for s in range(2*OFS+1):\n t = s-(X[i]-A)\n if t < 0 or t > 2*OFS:\n dp[i][s] = dp[i-1][s]\n else:\n dp[i][s] = dp[i-1][s] + dp[i-1][t]\n\n \nprint(dp[N-1][OFS]-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",
"xmax = max(X)",
"xmax",
"max(X)",
"max",
"X",
"OFS = N*xmax",
"OFS",
"N*xmax",
"N",
"xmax",
"[0]*(2*OFS+1) for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"[0]*(2*OFS+1)",
"[0]",
"0",
"2*OFS+1",
"2*OFS",
"2",
"OFS",
"1",
"dp = [[0]*(2*OFS+1) for _ in range(N)]",
"dp",
"[[0]*(2*OFS+1) for _ in range(N)]",
"dp[0][OFS] += 1",
"dp[0][OFS]",
"[0]",
"dp",
"0",
"OFS",
"1",
"dp[0][OFS+(X[0]-A)] += 1",
"dp[0][OFS+(X[0]-A)]",
"[0]",
"dp",
"0",
"OFS+(X[0]-A)",
"OFS",
"X[0]-A",
"X[0]",
"X",
"0",
"A",
"1",
"for i in range(1, N):\n for s in range(2*OFS+1):\n t = s-(X[i]-A)\n if t < 0 or t > 2*OFS:\n dp[i][s] = dp[i-1][s]\n else:\n dp[i][s] = dp[i-1][s] + dp[i-1][t]\n\n ",
"i",
"range(1, N)",
"range",
"1",
"N",
"for s in range(2*OFS+1):\n t = s-(X[i]-A)\n if t < 0 or t > 2*OFS:\n dp[i][s] = dp[i-1][s]\n else:\n dp[i][s] = dp[i-1][s] + dp[i-1][t]\n\n ",
"s",
"range(2*OFS+1)",
"range",
"2*OFS+1",
"2*OFS",
"2",
"OFS",
"1",
"t = s-(X[i]-A)",
"t",
"s-(X[i]-A)",
"s",
"X[i]-A",
"X[i]",
"X",
"i",
"A",
"if t < 0 or t > 2*OFS:\n dp[i][s] = dp[i-1][s]\n else:\n dp[i][s] = dp[i-1][s] + dp[i-1][t]\n\n ",
"t < 0 or t > 2*OFS",
"t < 0",
"t",
"0",
"t > 2*OFS",
"t",
"2*OFS",
"2",
"OFS",
"dp[i][s] = dp[i-1][s]",
"dp[i][s]",
"[i]",
"dp",
"i",
"s",
"dp[i-1][s]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"s",
"dp[i][s] = dp[i-1][s] + dp[i-1][t]",
"dp[i][s]",
"[i]",
"dp",
"i",
"s",
"dp[i-1][s] + dp[i-1][t]",
"dp[i-1][s]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"s",
"dp[i-1][t]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"t",
"print(dp[N-1][OFS]-1)",
"print",
"dp[N-1][OFS]-1",
"dp[N-1][OFS]",
"[N-1]",
"dp",
"N-1",
"N",
"1",
"OFS",
"1",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"t = s-(X[i]-A)",
"s-(X[i]-A)",
"t",
"OFS = N*xmax",
"N*xmax",
"OFS",
"X = list(map(int, input().split()))",
"list(map(int, input().split()))",
"X",
"dp = [[0]*(2*OFS+1) for _ in range(N)]",
"[[0]*(2*OFS+1) for _ in range(N)]",
"dp",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"xmax = max(X)",
"max(X)",
"xmax"
] | N, A = map(int, input().split())
X = list(map(int, input().split()))
xmax = max(X)
OFS = N*xmax
dp = [[0]*(2*OFS+1) for _ in range(N)]
dp[0][OFS] += 1
dp[0][OFS+(X[0]-A)] += 1
for i in range(1, N):
for s in range(2*OFS+1):
t = s-(X[i]-A)
if t < 0 or t > 2*OFS:
dp[i][s] = dp[i-1][s]
else:
dp[i][s] = dp[i-1][s] + dp[i-1][t]
print(dp[N-1][OFS]-1) |
[
7,
15,
13,
15,
13,
15,
15,
4,
18,
13,
13,
17,
15,
15,
15,
15,
15,
15,
15,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
17,
12,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
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,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
2,
17,
17,
28,
13,
4,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
28,
13,
4,
13,
13,
2,
17,
17,
28,
13,
4,
13,
17,
2,
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,
0,
13,
18,
18,
18,
13,
17,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
12,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
187,
20
],
[
199,
27
],
[
202,
36
],
[
179,
38
],
[
202,
39
],
[
181,
41
],
[
179,
43
],
[
47,
46
],
[
173,
50
],
[
184,
55
],
[
65,
58
],
[
185,
61
],
[
68,
67
],
[
173,
71
],
[
196,
74
],
[
182,
76
],
[
67,
78
],
[
82,
81
],
[
89,
88
],
[
67,
91
],
[
100,
93
],
[
185,
96
],
[
67,
97
],
[
88,
98
],
[
81,
99
],
[
185,
103
],
[
67,
105
],
[
88,
107
],
[
81,
108
],
[
111,
110
],
[
197,
113
],
[
119,
118
],
[
67,
123
],
[
133,
126
],
[
185,
129
],
[
67,
130
],
[
118,
131
],
[
110,
132
],
[
185,
136
],
[
67,
138
],
[
118,
141
],
[
110,
144
],
[
197,
145
],
[
175,
147
],
[
151,
150
],
[
173,
155
],
[
193,
158
],
[
185,
162
],
[
150,
164
],
[
150,
166
],
[
203,
167
],
[
194,
170
],
[
176,
170
],
[
202,
173
],
[
175,
176
],
[
181,
182
],
[
184,
185
],
[
187,
188
],
[
193,
194
],
[
196,
197
],
[
199,
200
],
[
202,
203
]
] | [
"#!/usr/bin/env python3\n\nimport sys\nimport math\nfrom bisect import bisect_right as br\nfrom bisect import bisect_left as bl\nsys.setrecursionlimit(2147483647)\nfrom heapq import heappush, heappop,heappushpop\nfrom collections import defaultdict\nfrom itertools import accumulate\nfrom collections import Counter\nfrom collections import deque\nfrom operator import itemgetter\nfrom itertools import permutations\nmod = 10**9 + 7\ninf = float('inf')\ndef I(): return int(sys.stdin.readline())\ndef LI(): return list(map(int,sys.stdin.readline().split()))\n\nn, a = LI()\nx = LI()\n\n# dp[i][j][k] := i番目まで見たときj個使用してkを作る場合の数\ndp = [[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]\ndp[0][0][0] = 1\nfor i in range(n+1):\n xi = x[i-1]\n for j in range(2500+1):\n for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n for j in range(xi, 2500+1):\n for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]\nans = 0\nfor i in range(1, n+1):\n ans += dp[-1][i][i*a]\nprint(ans)",
"import sys",
"sys",
"import math",
"math",
"from bisect import bisect_right as br",
"from bisect import bisect_left as bl",
"sys.setrecursionlimit(2147483647)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"2147483647",
"from heapq import heappush, heappop,heappushpop",
"from collections import defaultdict",
"from itertools import accumulate",
"from collections import Counter",
"from collections import deque",
"from operator import itemgetter",
"from itertools import permutations",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"inf = float('inf')",
"inf",
"float('inf')",
"float",
"'inf'",
"def I(): return int(sys.stdin.readline())",
"I",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"LI",
"n, a = LI()",
"n",
"LI()",
"LI",
"a",
"x = LI()",
"x",
"LI()",
"LI",
"[[0] * (2500+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] * (2500+1) for _ in range(n+1)]",
"dp = [[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]",
"dp",
"[[[0] * (2500+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 xi = x[i-1]\n for j in range(2500+1):\n for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n for j in range(xi, 2500+1):\n for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"xi = x[i-1]",
"xi",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"for j in range(2500+1):\n for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n ",
"j",
"range(2500+1)",
"range",
"2500+1",
"2500",
"1",
"for k in range(i):\n dp[i][k][j] = dp[i-1][k][j]\n ",
"k",
"range(i)",
"range",
"i",
"dp[i][k][j] = dp[i-1][k][j]",
"dp[i][k][j]",
"[k]",
"[i]",
"dp",
"i",
"k",
"j",
"dp[i-1][k][j]",
"[k]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"k",
"j",
"for j in range(xi, 2500+1):\n for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]",
"j",
"range(xi, 2500+1)",
"range",
"xi",
"2500+1",
"2500",
"1",
"for k in range(1, i+1):\n dp[i][k][j] += dp[i-1][k-1][j-xi]",
"k",
"range(1, i+1)",
"range",
"1",
"i+1",
"i",
"1",
"dp[i][k][j] += dp[i-1][k-1][j-xi]",
"dp[i][k][j]",
"[k]",
"[i]",
"dp",
"i",
"k",
"j",
"dp[i-1][k-1][j-xi]",
"[k-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"k-1",
"k",
"1",
"j-xi",
"j",
"xi",
"ans = 0",
"ans",
"0",
"for i in range(1, n+1):\n ans += dp[-1][i][i*a]",
"i",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans += dp[-1][i][i*a]",
"ans",
"dp[-1][i][i*a]",
"[i]",
"[-1]",
"dp",
"-1",
"i",
"i*a",
"i",
"a",
"print(ans)",
"print",
"ans",
"n, a = LI()",
"LI()",
"n",
"ans = 0",
"0",
"ans",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"LI",
"x = LI()",
"LI()",
"x",
"dp = [[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]",
"[[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]",
"dp",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"def I(): return int(sys.stdin.readline())",
"def I(): return int(sys.stdin.readline())",
"I",
"ans += dp[-1][i][i*a]",
"dp[-1][i][i*a]",
"ans",
"xi = x[i-1]",
"x[i-1]",
"xi",
"inf = float('inf')",
"float('inf')",
"inf",
"a = LI()",
"LI()",
"a"
] | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n, a = LI()
x = LI()
# dp[i][j][k] := i番目まで見たときj個使用してkを作る場合の数
dp = [[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n+1):
xi = x[i-1]
for j in range(2500+1):
for k in range(i):
dp[i][k][j] = dp[i-1][k][j]
for j in range(xi, 2500+1):
for k in range(1, i+1):
dp[i][k][j] += dp[i-1][k-1][j-xi]
ans = 0
for i in range(1, n+1):
ans += dp[-1][i][i*a]
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
0,
13,
17,
0,
13,
39,
2,
2,
39,
17,
13,
17,
2,
2,
39,
17,
13,
17,
0,
18,
18,
13,
17,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
40,
13,
13,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
2,
13,
18,
13,
13,
13,
0,
13,
13,
4,
13,
2,
18,
18,
13,
13,
17,
17,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13
] | [
[
114,
2
],
[
114,
15
],
[
114,
16
],
[
102,
19
],
[
117,
22
],
[
103,
28
],
[
103,
34
],
[
42,
37
],
[
118,
39
],
[
105,
44
],
[
48,
47
],
[
115,
50
],
[
108,
52
],
[
106,
55
],
[
112,
55
],
[
58,
57
],
[
103,
61
],
[
103,
62
],
[
69,
64
],
[
118,
66
],
[
109,
67
],
[
57,
68
],
[
118,
72
],
[
106,
73
],
[
112,
73
],
[
57,
74
],
[
118,
77
],
[
106,
78
],
[
112,
78
],
[
57,
81
],
[
47,
84
],
[
100,
85
],
[
111,
87
],
[
109,
88
],
[
118,
94
],
[
112,
95
],
[
106,
95
],
[
114,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
109,
111
],
[
111,
112
],
[
114,
115
],
[
117,
118
]
] | [
"n,a,*l=map(int,open(0).read().split())\nR=2500\ndp=[[0]*R*2,[0]*R*2]\ndp[0][0]=1\nt=0\nfor i in range(n):\n u=1-t\n for s in range(-R,R):\n dp[u][s]=dp[t][s]+dp[t][s-l[i]+a]\n t=u\nprint(dp[t][0]-1)",
"n,a,*l=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",
"*l",
"l",
"R=2500",
"R",
"2500",
"dp=[[0]*R*2,[0]*R*2]",
"dp",
"[[0]*R*2,[0]*R*2]",
"[0]*R*2",
"[0]*R",
"[0]",
"0",
"R",
"2",
"[0]*R*2",
"[0]*R",
"[0]",
"0",
"R",
"2",
"dp[0][0]=1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"t=0",
"t",
"0",
"for i in range(n):\n u=1-t\n for s in range(-R,R):\n dp[u][s]=dp[t][s]+dp[t][s-l[i]+a]\n t=u",
"i",
"range(n)",
"range",
"n",
"u=1-t",
"u",
"1-t",
"1",
"t",
"for s in range(-R,R):\n dp[u][s]=dp[t][s]+dp[t][s-l[i]+a]\n ",
"s",
"range(-R,R)",
"range",
"-R",
"R",
"R",
"dp[u][s]=dp[t][s]+dp[t][s-l[i]+a]",
"dp[u][s]",
"[u]",
"dp",
"u",
"s",
"dp[t][s]+dp[t][s-l[i]+a]",
"dp[t][s]",
"[t]",
"dp",
"t",
"s",
"dp[t][s-l[i]+a]",
"[t]",
"dp",
"t",
"s-l[i]+a",
"s-l[i]",
"s",
"l[i]",
"l",
"i",
"a",
"t=u",
"t",
"u",
"print(dp[t][0]-1)",
"print",
"dp[t][0]-1",
"dp[t][0]",
"[t]",
"dp",
"t",
"0",
"1",
"a,*l=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"a",
"R=2500",
"2500",
"R",
"t=0",
"0",
"t",
"u=1-t",
"1-t",
"u",
"t=u",
"u",
"t",
"n,a,*l=map(int,open(0).read().split())",
"map(int,open(0).read().split())",
"n",
"dp=[[0]*R*2,[0]*R*2]",
"[[0]*R*2,[0]*R*2]",
"dp"
] | n,a,*l=map(int,open(0).read().split())
R=2500
dp=[[0]*R*2,[0]*R*2]
dp[0][0]=1
t=0
for i in range(n):
u=1-t
for s in range(-R,R):
dp[u][s]=dp[t][s]+dp[t][s-l[i]+a]
t=u
print(dp[t][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,
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,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
40,
13,
17,
40,
13,
18,
13,
2,
13,
17,
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,
14,
40,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
14,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
195,
2
],
[
195,
11
],
[
198,
13
],
[
192,
25
],
[
30,
29
],
[
196,
33
],
[
201,
38
],
[
48,
41
],
[
202,
44
],
[
51,
50
],
[
196,
54
],
[
58,
57
],
[
50,
61
],
[
65,
64
],
[
199,
70
],
[
50,
76
],
[
64,
79
],
[
199,
81
],
[
50,
83
],
[
57,
86
],
[
96,
89
],
[
202,
92
],
[
50,
93
],
[
57,
94
],
[
64,
95
],
[
202,
100
],
[
50,
102
],
[
57,
105
],
[
64,
108
],
[
199,
110
],
[
50,
112
],
[
202,
117
],
[
50,
119
],
[
57,
121
],
[
64,
122
],
[
50,
125
],
[
135,
128
],
[
202,
131
],
[
50,
132
],
[
57,
133
],
[
64,
134
],
[
202,
138
],
[
50,
140
],
[
57,
142
],
[
64,
143
],
[
146,
145
],
[
196,
150
],
[
154,
153
],
[
199,
159
],
[
153,
165
],
[
145,
166
],
[
153,
170
],
[
145,
171
],
[
187,
172
],
[
189,
174
],
[
202,
178
],
[
196,
179
],
[
145,
180
],
[
153,
181
],
[
190,
184
],
[
193,
184
],
[
195,
187
],
[
189,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
201,
202
]
] | [
"n,a=map(int,input().split())\nx=list(map(int,input().split()))\nans=0\ndp=[[[0]*(sum(x)+1) for i in range(n+1)] for j in range(n+1)]\ndp[0][0][0]=1\nfor i in range(n+1):\n for j in range(i+1):\n for k in range(sum(x)+1):\n if i>=1 and k>=x[i-1] and j>=1:\n dp[i][j][k]=dp[i-1][j-1][k-x[i-1]]+dp[i-1][j][k]\n elif i>=1:\n dp[i][j][k]=dp[i-1][j][k]\nfor j in range(1,n+1):\n for k in range(sum(x)+1):\n if k%j==0 and k//j==a:\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",
"ans=0",
"ans",
"0",
"[[0]*(sum(x)+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]*(sum(x)+1) for i in range(n+1)]",
"dp=[[[0]*(sum(x)+1) for i in range(n+1)] for j in range(n+1)]",
"dp",
"[[[0]*(sum(x)+1) for i 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 i in range(n+1):\n for j in range(i+1):\n for k in range(sum(x)+1):\n if i>=1 and k>=x[i-1] and j>=1:\n dp[i][j][k]=dp[i-1][j-1][k-x[i-1]]+dp[i-1][j][k]\n elif i>=1:\n dp[i][j][k]=dp[i-1][j][k]",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for j in range(i+1):\n for k in range(sum(x)+1):\n if i>=1 and k>=x[i-1] and j>=1:\n dp[i][j][k]=dp[i-1][j-1][k-x[i-1]]+dp[i-1][j][k]\n elif i>=1:\n dp[i][j][k]=dp[i-1][j][k]",
"j",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"for k in range(sum(x)+1):\n if i>=1 and k>=x[i-1] and j>=1:\n dp[i][j][k]=dp[i-1][j-1][k-x[i-1]]+dp[i-1][j][k]\n elif i>=1:\n dp[i][j][k]=dp[i-1][j][k]",
"k",
"range(sum(x)+1)",
"range",
"sum(x)+1",
"sum(x)",
"sum",
"x",
"1",
"if i>=1 and k>=x[i-1] and j>=1:\n dp[i][j][k]=dp[i-1][j-1][k-x[i-1]]+dp[i-1][j][k]\n elif i>=1:\n dp[i][j][k]=dp[i-1][j][k]",
"i>=1 and k>=x[i-1] and j>=1",
"i>=1 and k>=x[i-1]",
"i>=1",
"i",
"1",
"k>=x[i-1]",
"k",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"j>=1",
"j",
"1",
"dp[i][j][k]=dp[i-1][j-1][k-x[i-1]]+dp[i-1][j][k]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j-1][k-x[i-1]]+dp[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",
"dp[i-1][j][k]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"k",
"elif i>=1:\n dp[i][j][k]=dp[i-1][j][k]",
"i>=1",
"i",
"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",
"for j in range(1,n+1):\n for k in range(sum(x)+1):\n if k%j==0 and k//j==a:\n ans+=dp[n][j][k]",
"j",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for k in range(sum(x)+1):\n if k%j==0 and k//j==a:\n ans+=dp[n][j][k]",
"k",
"range(sum(x)+1)",
"range",
"sum(x)+1",
"sum(x)",
"sum",
"x",
"1",
"if k%j==0 and k//j==a:\n ans+=dp[n][j][k]",
"k%j==0 and k//j==a",
"k%j==0",
"k%j",
"k",
"j",
"0",
"k//j==a",
"k//j",
"k",
"j",
"a",
"ans+=dp[n][j][k]",
"ans",
"dp[n][j][k]",
"[j]",
"[n]",
"dp",
"n",
"j",
"k",
"print(ans)",
"print",
"ans",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"ans+=dp[n][j][k]",
"dp[n][j][k]",
"ans",
"ans=0",
"0",
"ans",
"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]*(sum(x)+1) for i in range(n+1)] for j in range(n+1)]",
"[[[0]*(sum(x)+1) for i in range(n+1)] for j in range(n+1)]",
"dp"
] | n,a=map(int,input().split())
x=list(map(int,input().split()))
ans=0
dp=[[[0]*(sum(x)+1) for i in range(n+1)] for j in range(n+1)]
dp[0][0][0]=1
for i in range(n+1):
for j in range(i+1):
for k in range(sum(x)+1):
if i>=1 and k>=x[i-1] and j>=1:
dp[i][j][k]=dp[i-1][j-1][k-x[i-1]]+dp[i-1][j][k]
elif i>=1:
dp[i][j][k]=dp[i-1][j][k]
for j in range(1,n+1):
for k in range(sum(x)+1):
if k%j==0 and k//j==a:
ans+=dp[n][j][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,
41,
28,
13,
4,
13,
13,
4,
2,
18,
13,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
17,
4,
13,
0,
13,
13,
28,
13,
4,
13,
17,
0,
18,
18,
13,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
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,
4,
13,
2,
18,
18,
13,
13,
17,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
121,
2
],
[
121,
11
],
[
118,
13
],
[
27,
26
],
[
122,
29
],
[
119,
33
],
[
26,
34
],
[
116,
35
],
[
124,
37
],
[
42,
41
],
[
112,
48
],
[
52,
51
],
[
61,
56
],
[
113,
58
],
[
51,
59
],
[
64,
63
],
[
122,
68
],
[
72,
71
],
[
81,
76
],
[
113,
78
],
[
63,
79
],
[
71,
80
],
[
113,
84
],
[
63,
86
],
[
71,
88
],
[
113,
91
],
[
63,
93
],
[
71,
96
],
[
125,
98
],
[
119,
98
],
[
63,
100
],
[
113,
107
],
[
122,
108
],
[
112,
113
],
[
121,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
]
] | [
"n,k = map(int,input().split())\na = list(map(int,input().split()))\na = [a[i]-k for i in range(n)]\nDP = [[0 for i in range(5100)] for j in range(52)]\nfor i in range(52):\n DP[i][2530] = 1\nfor i in range(1,n+1):\n for j in range(5050):\n DP[i][j] = DP[i-1][j] + DP[i-1][j-a[i-1]]\nprint(DP[n][2530]-1)",
"n,k = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"k",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a[i]-k for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"a[i]-k",
"a[i]",
"a",
"i",
"k",
"a = [a[i]-k for i in range(n)]",
"a",
"[a[i]-k for i in range(n)]",
"[0 for i in range(5100)] for j in range(52)",
"for j in range(52)",
"j",
"range(52)",
"range",
"52",
"for j in range(52)",
"[0 for i in range(5100)]",
"DP = [[0 for i in range(5100)] for j in range(52)]",
"DP",
"[[0 for i in range(5100)] for j in range(52)]",
"for i in range(52):\n DP[i][2530] = 1",
"i",
"range(52)",
"range",
"52",
"DP[i][2530] = 1",
"DP[i][2530]",
"[i]",
"DP",
"i",
"2530",
"1",
"for i in range(1,n+1):\n for j in range(5050):\n DP[i][j] = DP[i-1][j] + DP[i-1][j-a[i-1]]",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for j in range(5050):\n DP[i][j] = DP[i-1][j] + DP[i-1][j-a[i-1]]",
"j",
"range(5050)",
"range",
"5050",
"DP[i][j] = DP[i-1][j] + DP[i-1][j-a[i-1]]",
"DP[i][j]",
"[i]",
"DP",
"i",
"j",
"DP[i-1][j] + DP[i-1][j-a[i-1]]",
"DP[i-1][j]",
"[i-1]",
"DP",
"i-1",
"i",
"1",
"j",
"DP[i-1][j-a[i-1]]",
"[i-1]",
"DP",
"i-1",
"i",
"1",
"j-a[i-1]",
"j",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"print(DP[n][2530]-1)",
"print",
"DP[n][2530]-1",
"DP[n][2530]",
"[n]",
"DP",
"n",
"2530",
"1",
"DP = [[0 for i in range(5100)] for j in range(52)]",
"[[0 for i in range(5100)] for j in range(52)]",
"DP",
"k = map(int,input().split())",
"map(int,input().split())",
"k",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"n,k = map(int,input().split())",
"map(int,input().split())",
"n",
"a = [a[i]-k for i in range(n)]",
"[a[i]-k for i in range(n)]",
"a"
] | n,k = map(int,input().split())
a = list(map(int,input().split()))
a = [a[i]-k for i in range(n)]
DP = [[0 for i in range(5100)] for j in range(52)]
for i in range(52):
DP[i][2530] = 1
for i in range(1,n+1):
for j in range(5050):
DP[i][j] = DP[i-1][j] + DP[i-1][j-a[i-1]]
print(DP[n][2530]-1) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
13,
17,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
13,
17,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
0,
13,
17,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
28,
13,
4,
13,
17,
17,
17,
0,
18,
13,
2,
13,
2,
13,
13,
18,
13,
13,
14,
2,
13,
13,
28,
13,
4,
13,
17,
17,
17,
0,
18,
13,
2,
13,
2,
13,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
2,
17,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13
] | [
[
187,
2
],
[
187,
15
],
[
181,
17
],
[
35,
34
],
[
184,
41
],
[
46,
45
],
[
190,
52
],
[
58,
55
],
[
191,
56
],
[
62,
61
],
[
166,
68
],
[
74,
71
],
[
167,
72
],
[
157,
76
],
[
160,
79
],
[
83,
82
],
[
182,
82
],
[
82,
86
],
[
188,
87
],
[
90,
89
],
[
103,
96
],
[
191,
97
],
[
89,
99
],
[
82,
101
],
[
188,
102
],
[
191,
104
],
[
89,
105
],
[
82,
108
],
[
188,
109
],
[
112,
111
],
[
125,
118
],
[
167,
119
],
[
111,
121
],
[
188,
123
],
[
82,
124
],
[
167,
126
],
[
111,
127
],
[
172,
129
],
[
133,
132
],
[
175,
137
],
[
191,
140
],
[
132,
141
],
[
167,
143
],
[
132,
144
],
[
178,
146
],
[
173,
149
],
[
158,
149
],
[
163,
151
],
[
164,
155
],
[
179,
155
],
[
176,
155
],
[
161,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
187,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
],
[
181,
182
],
[
184,
185
],
[
187,
188
],
[
190,
191
]
] | [
"N,A = map(int,input().rstrip().split(\" \"))\nX = list(map(int,input().rstrip().split(\" \")))\nDPq = [0 for _ in range(1300)]\nDPp = [0 for _ in range(1300)]\nDPp[0] = 1\nDPm = [0 for _ in range(1300)]\nDPm[0] = 1\njust = 0\nans = 0\nfor i in X:\n if i > A:\n for i2 in range(1250,-1,-1):\n DPp[i2 + (i - A)] += DPp[i2]\n elif i < A:\n for i2 in range(1250,-1,-1):\n DPm[i2 + (A - i)] += DPm[i2]\n else:\n just += 1\nfor i in range(1250):\n ans += DPp[i] * DPm[i]\nans *= 2 ** just\nans -=1\nprint(ans)",
"N,A = map(int,input().rstrip().split(\" \"))",
"N",
"map(int,input().rstrip().split(\" \"))",
"map",
"int",
"input().rstrip().split(\" \")",
"().rstrip().split",
"().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"split",
"\" \"",
"A",
"X = list(map(int,input().rstrip().split(\" \")))",
"X",
"list(map(int,input().rstrip().split(\" \")))",
"list",
"map(int,input().rstrip().split(\" \"))",
"map",
"int",
"input().rstrip().split(\" \")",
"().rstrip().split",
"().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"split",
"\" \"",
"0 for _ in range(1300)",
"for _ in range(1300)",
"_",
"range(1300)",
"range",
"1300",
"for _ in range(1300)",
"0",
"DPq = [0 for _ in range(1300)]",
"DPq",
"[0 for _ in range(1300)]",
"0 for _ in range(1300)",
"for _ in range(1300)",
"_",
"range(1300)",
"range",
"1300",
"for _ in range(1300)",
"0",
"DPp = [0 for _ in range(1300)]",
"DPp",
"[0 for _ in range(1300)]",
"DPp[0] = 1",
"DPp[0]",
"DPp",
"0",
"1",
"0 for _ in range(1300)",
"for _ in range(1300)",
"_",
"range(1300)",
"range",
"1300",
"for _ in range(1300)",
"0",
"DPm = [0 for _ in range(1300)]",
"DPm",
"[0 for _ in range(1300)]",
"DPm[0] = 1",
"DPm[0]",
"DPm",
"0",
"1",
"just = 0",
"just",
"0",
"ans = 0",
"ans",
"0",
"for i in X:\n if i > A:\n for i2 in range(1250,-1,-1):\n DPp[i2 + (i - A)] += DPp[i2]\n elif i < A:\n for i2 in range(1250,-1,-1):\n DPm[i2 + (A - i)] += DPm[i2]\n else:\n just += 1",
"i",
"X",
"if i > A:\n for i2 in range(1250,-1,-1):\n DPp[i2 + (i - A)] += DPp[i2]\n elif i < A:\n for i2 in range(1250,-1,-1):\n DPm[i2 + (A - i)] += DPm[i2]\n else:\n just += 1",
"i > A",
"i",
"A",
"for i2 in range(1250,-1,-1):\n DPp[i2 + (i - A)] += DPp[i2]\n ",
"i2",
"range(1250,-1,-1)",
"range",
"1250",
"-1",
"-1",
"DPp[i2 + (i - A)] += DPp[i2]",
"DPp[i2 + (i - A)]",
"DPp",
"i2 + (i - A)",
"i2",
"i - A",
"i",
"A",
"DPp[i2]",
"DPp",
"i2",
"elif i < A:\n for i2 in range(1250,-1,-1):\n DPm[i2 + (A - i)] += DPm[i2]\n ",
"i < A",
"i",
"A",
"for i2 in range(1250,-1,-1):\n DPm[i2 + (A - i)] += DPm[i2]\n ",
"i2",
"range(1250,-1,-1)",
"range",
"1250",
"-1",
"-1",
"DPm[i2 + (A - i)] += DPm[i2]",
"DPm[i2 + (A - i)]",
"DPm",
"i2 + (A - i)",
"i2",
"A - i",
"A",
"i",
"DPm[i2]",
"DPm",
"i2",
"just += 1",
"just",
"1",
"for i in range(1250):\n ans += DPp[i] * DPm[i]",
"i",
"range(1250)",
"range",
"1250",
"ans += DPp[i] * DPm[i]",
"ans",
"DPp[i] * DPm[i]",
"DPp[i]",
"DPp",
"i",
"DPm[i]",
"DPm",
"i",
"ans *= 2 ** just",
"ans",
"2 ** just",
"2",
"just",
"ans -=1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"just = 0",
"0",
"just",
"ans = 0",
"0",
"ans",
"ans -=1",
"1",
"ans",
"DPm = [0 for _ in range(1300)]",
"[0 for _ in range(1300)]",
"DPm",
"N,A = map(int,input().rstrip().split(\" \"))",
"map(int,input().rstrip().split(\" \"))",
"N",
"just += 1",
"1",
"just",
"ans += DPp[i] * DPm[i]",
"DPp[i] * DPm[i]",
"ans",
"ans *= 2 ** just",
"2 ** just",
"ans",
"X = list(map(int,input().rstrip().split(\" \")))",
"list(map(int,input().rstrip().split(\" \")))",
"X",
"DPq = [0 for _ in range(1300)]",
"[0 for _ in range(1300)]",
"DPq",
"A = map(int,input().rstrip().split(\" \"))",
"map(int,input().rstrip().split(\" \"))",
"A",
"DPp = [0 for _ in range(1300)]",
"[0 for _ in range(1300)]",
"DPp"
] | N,A = map(int,input().rstrip().split(" "))
X = list(map(int,input().rstrip().split(" ")))
DPq = [0 for _ in range(1300)]
DPp = [0 for _ in range(1300)]
DPp[0] = 1
DPm = [0 for _ in range(1300)]
DPm[0] = 1
just = 0
ans = 0
for i in X:
if i > A:
for i2 in range(1250,-1,-1):
DPp[i2 + (i - A)] += DPp[i2]
elif i < A:
for i2 in range(1250,-1,-1):
DPm[i2 + (A - i)] += DPm[i2]
else:
just += 1
for i in range(1250):
ans += DPp[i] * DPm[i]
ans *= 2 ** just
ans -=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,
2,
17,
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,
13,
4,
13,
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,
2,
40,
13,
17,
40,
13,
13,
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,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13
] | [
[
162,
2
],
[
162,
11
],
[
153,
13
],
[
159,
25
],
[
163,
28
],
[
32,
31
],
[
163,
35
],
[
156,
40
],
[
50,
43
],
[
157,
46
],
[
154,
56
],
[
60,
59
],
[
67,
66
],
[
160,
70
],
[
80,
73
],
[
157,
76
],
[
59,
78
],
[
66,
79
],
[
157,
83
],
[
59,
87
],
[
66,
88
],
[
59,
92
],
[
66,
95
],
[
105,
98
],
[
157,
101
],
[
59,
103
],
[
66,
104
],
[
157,
108
],
[
59,
113
],
[
66,
116
],
[
147,
119
],
[
123,
122
],
[
163,
127
],
[
144,
130
],
[
157,
134
],
[
163,
135
],
[
122,
136
],
[
122,
138
],
[
151,
139
],
[
145,
142
],
[
148,
142
],
[
144,
145
],
[
147,
148
],
[
162,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
],
[
162,
163
]
] | [
"N, A = map(int, input().split())\n\nx = list(map(int, input().split()))\n\nmaxint = 50 * N\n\ndp = [[[0] * (maxint + 1) for _ in range(N + 1)] for _ in range(N + 1)]\n\ndp[0][0][0] = 1\n\nfor xi, xe in enumerate(x, 1):\n for j in range(xi+1):\n for k in range(maxint + 1):\n dp[xi][j][k] = dp[xi - 1][j][k]\n \n if j >= 0 and k >= xe:\n dp[xi][j][k] += dp[xi - 1][j - 1][k - xe]\n \n\nres = 0\n\nfor i in range(1, N+1):\n res += dp[N][i][i * 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",
"maxint = 50 * N",
"maxint",
"50 * N",
"50",
"N",
"[[0] * (maxint + 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] * (maxint + 1) for _ in range(N + 1)]",
"dp = [[[0] * (maxint + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"dp",
"[[[0] * (maxint + 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 xi, xe in enumerate(x, 1):\n for j in range(xi+1):\n for k in range(maxint + 1):\n dp[xi][j][k] = dp[xi - 1][j][k]\n \n if j >= 0 and k >= xe:\n dp[xi][j][k] += dp[xi - 1][j - 1][k - xe]\n ",
"xi",
"xe",
"enumerate(x, 1)",
"enumerate",
"x",
"1",
"for j in range(xi+1):\n for k in range(maxint + 1):\n dp[xi][j][k] = dp[xi - 1][j][k]\n \n if j >= 0 and k >= xe:\n dp[xi][j][k] += dp[xi - 1][j - 1][k - xe]\n ",
"j",
"range(xi+1)",
"range",
"xi+1",
"xi",
"1",
"for k in range(maxint + 1):\n dp[xi][j][k] = dp[xi - 1][j][k]\n \n if j >= 0 and k >= xe:\n dp[xi][j][k] += dp[xi - 1][j - 1][k - xe]\n ",
"k",
"range(maxint + 1)",
"range",
"maxint + 1",
"maxint",
"1",
"dp[xi][j][k] = dp[xi - 1][j][k]",
"dp[xi][j][k]",
"[j]",
"[xi]",
"dp",
"xi",
"j",
"k",
"dp[xi - 1][j][k]",
"[j]",
"[xi - 1]",
"dp",
"xi - 1",
"xi",
"1",
"j",
"k",
"if j >= 0 and k >= xe:\n dp[xi][j][k] += dp[xi - 1][j - 1][k - xe]\n ",
"j >= 0 and k >= xe",
"j >= 0",
"j",
"0",
"k >= xe",
"k",
"xe",
"dp[xi][j][k] += dp[xi - 1][j - 1][k - xe]",
"dp[xi][j][k]",
"[j]",
"[xi]",
"dp",
"xi",
"j",
"k",
"dp[xi - 1][j - 1][k - xe]",
"[j - 1]",
"[xi - 1]",
"dp",
"xi - 1",
"xi",
"1",
"j - 1",
"j",
"1",
"k - xe",
"k",
"xe",
"res = 0",
"res",
"0",
"for i in range(1, N+1):\n res += dp[N][i][i * A]",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"res += dp[N][i][i * A]",
"res",
"dp[N][i][i * A]",
"[i]",
"[N]",
"dp",
"N",
"i",
"i * A",
"i",
"A",
"print(res)",
"print",
"res",
"res += dp[N][i][i * A]",
"dp[N][i][i * A]",
"res",
"res = 0",
"0",
"res",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [[[0] * (maxint + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"[[[0] * (maxint + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"dp",
"maxint = 50 * N",
"50 * N",
"maxint",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N"
] | N, A = map(int, input().split())
x = list(map(int, input().split()))
maxint = 50 * N
dp = [[[0] * (maxint + 1) for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
for xi, xe in enumerate(x, 1):
for j in range(xi+1):
for k in range(maxint + 1):
dp[xi][j][k] = dp[xi - 1][j][k]
if j >= 0 and k >= xe:
dp[xi][j][k] += dp[xi - 1][j - 1][k - xe]
res = 0
for i in range(1, N+1):
res += dp[N][i][i * A]
print(res) |
[
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,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
2,
39,
17,
17,
28,
13,
13,
28,
13,
8,
2,
13,
17,
4,
13,
17,
4,
13,
17,
17,
17,
14,
2,
18,
13,
13,
17,
9,
0,
18,
13,
2,
13,
13,
18,
13,
13,
0,
18,
13,
2,
17,
13,
17,
4,
13,
18,
13,
17,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
103,
2
],
[
103,
11
],
[
100,
13
],
[
101,
26
],
[
31,
30
],
[
101,
30
],
[
30,
34
],
[
104,
35
],
[
94,
37
],
[
91,
40
],
[
47,
46
],
[
95,
46
],
[
101,
46
],
[
50,
49
],
[
46,
52
],
[
92,
65
],
[
49,
66
],
[
75,
70
],
[
92,
71
],
[
49,
73
],
[
46,
74
],
[
92,
76
],
[
49,
77
],
[
84,
79
],
[
92,
80
],
[
46,
83
],
[
92,
88
],
[
91,
92
],
[
94,
95
],
[
103,
98
],
[
100,
101
],
[
103,
104
]
] | [
"N, A = map(int, input().split())\nx = list(map(int, input().split()))\n\nx.sort()\nx = [v - A for v in x]\n\ndp = [0] * 5001\nfor v in x:\n for i in range(2501) if v < 0 else range(5000, -1, -1):\n if dp[i] == 0:\n continue\n dp[i + v] += dp[i]\n dp[2500 + v] += 1\nprint(dp[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",
"x.sort()",
"x.sort",
"x",
"sort",
"v - A for v in x",
"for v in x",
"v",
"x",
"for v in x",
"v - A",
"v",
"A",
"x = [v - A for v in x]",
"x",
"[v - A for v in x]",
"dp = [0] * 5001",
"dp",
"[0] * 5001",
"[0]",
"0",
"5001",
"for v in x:\n for i in range(2501) if v < 0 else range(5000, -1, -1):\n if dp[i] == 0:\n continue\n dp[i + v] += dp[i]\n dp[2500 + v] += 1",
"v",
"x",
"for i in range(2501) if v < 0 else range(5000, -1, -1):\n if dp[i] == 0:\n continue\n dp[i + v] += dp[i]\n ",
"i",
"range(2501) if v < 0 else range(5000, -1, -1)",
"v < 0",
"v",
"0",
"range(2501)",
"range",
"2501",
"range(5000, -1, -1)",
"range",
"5000",
"-1",
"-1",
"if dp[i] == 0:\n continue\n ",
"dp[i] == 0",
"dp[i]",
"dp",
"i",
"0",
"continue",
"dp[i + v] += dp[i]",
"dp[i + v]",
"dp",
"i + v",
"i",
"v",
"dp[i]",
"dp",
"i",
"dp[2500 + v] += 1",
"dp[2500 + v]",
"dp",
"2500 + v",
"2500",
"v",
"1",
"print(dp[2500])",
"print",
"dp[2500]",
"dp",
"2500",
"dp = [0] * 5001",
"[0] * 5001",
"dp",
"x = [v - A for v in x]",
"[v - A for v in x]",
"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"
] | N, A = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
x = [v - A for v in x]
dp = [0] * 5001
for v in x:
for i in range(2501) if v < 0 else range(5000, -1, -1):
if dp[i] == 0:
continue
dp[i + v] += dp[i]
dp[2500 + v] += 1
print(dp[2500])
|
[
7,
15,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
2,
4,
13,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
18,
18,
13,
17,
2,
17,
17,
17,
28,
13,
13,
4,
13,
13,
17,
28,
13,
4,
13,
2,
2,
2,
17,
17,
17,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
14,
40,
40,
17,
2,
13,
13,
2,
2,
17,
17,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
2,
13,
13,
4,
13,
2,
18,
18,
13,
17,
2,
17,
17,
17,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13
] | [
[
6,
5
],
[
5,
18
],
[
142,
20
],
[
142,
22
],
[
26,
25
],
[
25,
39
],
[
143,
40
],
[
139,
42
],
[
47,
46
],
[
137,
50
],
[
145,
55
],
[
65,
58
],
[
146,
60
],
[
140,
71
],
[
75,
74
],
[
90,
85
],
[
146,
87
],
[
74,
89
],
[
146,
92
],
[
74,
96
],
[
74,
102
],
[
115,
110
],
[
146,
112
],
[
74,
114
],
[
146,
117
],
[
74,
122
],
[
146,
129
],
[
142,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
]
] | [
"import sys\nn, a = [int(i) for i in sys.stdin.readline().split()]\nx_ls = [int(i) - a for i in sys.stdin.readline().split()]\n#memo_ls[i][j] : i番目まででj - 50*50ができる通り数\nmemo_ls = [[0 for i in range(2 * 50 * 50 + 1)] for j in range(n+1)]\nmemo_ls[0][50*50] = 1\nfor i, x in enumerate(x_ls, 1):\n for j in range(2*50*50+1):\n memo_ls[i][j] = memo_ls[i-1][j]\n if 0 <= j - x <= 2*50*50:\n memo_ls[i][j] += memo_ls[i - 1][j - x]\nprint(memo_ls[-1][50*50] - 1)",
"import sys",
"sys",
"int(i) for i in sys.stdin.readline().split()",
"for i in sys.stdin.readline().split()",
"i",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for i in sys.stdin.readline().split()",
"int(i)",
"int",
"i",
"n, a = [int(i) for i in sys.stdin.readline().split()]",
"n",
"[int(i) for i in sys.stdin.readline().split()]",
"a",
"int(i) - a for i in sys.stdin.readline().split()",
"for i in sys.stdin.readline().split()",
"i",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for i in sys.stdin.readline().split()",
"int(i) - a",
"int(i)",
"int",
"i",
"a",
"x_ls = [int(i) - a for i in sys.stdin.readline().split()]",
"x_ls",
"[int(i) - a for i in sys.stdin.readline().split()]",
"[0 for i in range(2 * 50 * 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 * 50 * 50 + 1)]",
"memo_ls = [[0 for i in range(2 * 50 * 50 + 1)] for j in range(n+1)]",
"memo_ls",
"[[0 for i in range(2 * 50 * 50 + 1)] for j in range(n+1)]",
"memo_ls[0][50*50] = 1",
"memo_ls[0][50*50]",
"[0]",
"memo_ls",
"0",
"50*50",
"50",
"50",
"1",
"for i, x in enumerate(x_ls, 1):\n for j in range(2*50*50+1):\n memo_ls[i][j] = memo_ls[i-1][j]\n if 0 <= j - x <= 2*50*50:\n memo_ls[i][j] += memo_ls[i - 1][j - x]",
"i",
"x",
"enumerate(x_ls, 1)",
"enumerate",
"x_ls",
"1",
"for j in range(2*50*50+1):\n memo_ls[i][j] = memo_ls[i-1][j]\n if 0 <= j - x <= 2*50*50:\n memo_ls[i][j] += memo_ls[i - 1][j - x]",
"j",
"range(2*50*50+1)",
"range",
"2*50*50+1",
"2*50*50",
"2*50",
"2",
"50",
"50",
"1",
"memo_ls[i][j] = memo_ls[i-1][j]",
"memo_ls[i][j]",
"[i]",
"memo_ls",
"i",
"j",
"memo_ls[i-1][j]",
"[i-1]",
"memo_ls",
"i-1",
"i",
"1",
"j",
"if 0 <= j - x <= 2*50*50:\n memo_ls[i][j] += memo_ls[i - 1][j - x]",
"0 <= j - x <= 2*50*50",
"0 <= j - x",
"0",
"j - x",
"j",
"x",
"2*50*50",
"2*50",
"2",
"50",
"50",
"memo_ls[i][j] += memo_ls[i - 1][j - x]",
"memo_ls[i][j]",
"[i]",
"memo_ls",
"i",
"j",
"memo_ls[i - 1][j - x]",
"[i - 1]",
"memo_ls",
"i - 1",
"i",
"1",
"j - x",
"j",
"x",
"print(memo_ls[-1][50*50] - 1)",
"print",
"memo_ls[-1][50*50] - 1",
"memo_ls[-1][50*50]",
"[-1]",
"memo_ls",
"-1",
"50*50",
"50",
"50",
"1",
"n, a = [int(i) for i in sys.stdin.readline().split()]",
"[int(i) for i in sys.stdin.readline().split()]",
"n",
"x_ls = [int(i) - a for i in sys.stdin.readline().split()]",
"[int(i) - a for i in sys.stdin.readline().split()]",
"x_ls",
"a = [int(i) for i in sys.stdin.readline().split()]",
"[int(i) for i in sys.stdin.readline().split()]",
"a",
"memo_ls = [[0 for i in range(2 * 50 * 50 + 1)] for j in range(n+1)]",
"[[0 for i in range(2 * 50 * 50 + 1)] for j in range(n+1)]",
"memo_ls"
] | import sys
n, a = [int(i) for i in sys.stdin.readline().split()]
x_ls = [int(i) - a for i in sys.stdin.readline().split()]
#memo_ls[i][j] : i番目まででj - 50*50ができる通り数
memo_ls = [[0 for i in range(2 * 50 * 50 + 1)] for j in range(n+1)]
memo_ls[0][50*50] = 1
for i, x in enumerate(x_ls, 1):
for j in range(2*50*50+1):
memo_ls[i][j] = memo_ls[i-1][j]
if 0 <= j - x <= 2*50*50:
memo_ls[i][j] += memo_ls[i - 1][j - x]
print(memo_ls[-1][50*50] - 1) |
[
7,
12,
13,
14,
2,
13,
17,
14,
40,
13,
17,
14,
2,
2,
13,
13,
13,
29,
17,
29,
17,
14,
40,
18,
18,
18,
13,
13,
13,
13,
17,
29,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
2,
4,
13,
2,
13,
17,
13,
13,
4,
13,
2,
13,
17,
2,
13,
18,
13,
2,
13,
17,
2,
13,
17,
29,
18,
18,
18,
13,
13,
13,
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,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
4,
13,
4,
13,
13,
17,
17,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
79,
5
],
[
81,
9
],
[
81,
14
],
[
83,
15
],
[
83,
27
],
[
79,
28
],
[
81,
29
],
[
83,
36
],
[
79,
37
],
[
81,
38
],
[
47,
40
],
[
83,
44
],
[
79,
45
],
[
81,
46
],
[
79,
51
],
[
81,
53
],
[
83,
54
],
[
79,
58
],
[
81,
61
],
[
79,
65
],
[
83,
68
],
[
40,
71
],
[
83,
75
],
[
79,
76
],
[
81,
77
],
[
79,
79
],
[
81,
81
],
[
83,
83
],
[
134,
85
],
[
134,
94
],
[
140,
96
],
[
110,
109
],
[
129,
113
],
[
137,
118
],
[
132,
123
],
[
129,
124
],
[
134,
129
],
[
134,
135
],
[
137,
138
],
[
140,
141
]
] | [
"def f(n,x,i):\n if n == 0:\n if x != 0:\n if x / i == a:\n return 1\n return 0\n if memo[i][n][x] != -1:\n return memo[i][n][x]\n memo[i][n][x] = f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)\n return memo[i][n][x]\nn,a = map(int,input().split())\nary = list(map(int,input().split()))\nmemo = [[[-1 for _ in range(sum(ary)+1)] for _ in range(n+1)] for _ in range(n+1)]\nprint(f(n,0,0))",
"def f(n,x,i):\n if n == 0:\n if x != 0:\n if x / i == a:\n return 1\n return 0\n if memo[i][n][x] != -1:\n return memo[i][n][x]\n memo[i][n][x] = f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)\n return memo[i][n][x]",
"f",
"if n == 0:\n if x != 0:\n if x / i == a:\n return 1\n return 0\n ",
"n == 0",
"n",
"0",
"if x != 0:\n if x / i == a:\n return 1\n ",
"x != 0",
"x",
"0",
"if x / i == a:\n return 1\n ",
"x / i == a",
"x / i",
"x",
"i",
"a",
"return 1",
"1",
"return 0",
"0",
"if memo[i][n][x] != -1:\n return memo[i][n][x]\n ",
"memo[i][n][x] != -1",
"memo[i][n][x]",
"[n]",
"[i]",
"memo",
"i",
"n",
"x",
"-1",
"return memo[i][n][x]",
"memo[i][n][x]",
"[n]",
"[i]",
"memo",
"i",
"n",
"x",
"memo[i][n][x] = f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)",
"memo[i][n][x]",
"[n]",
"[i]",
"memo",
"i",
"n",
"x",
"f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)",
"f(n-1,x,i)",
"f",
"n-1",
"n",
"1",
"x",
"i",
"f(n-1,x+ary[n-1],i+1)",
"f",
"n-1",
"n",
"1",
"x+ary[n-1]",
"x",
"ary[n-1]",
"ary",
"n-1",
"n",
"1",
"i+1",
"i",
"1",
"return memo[i][n][x]",
"memo[i][n][x]",
"[n]",
"[i]",
"memo",
"i",
"n",
"x",
"n",
"n",
"x",
"x",
"i",
"i",
"n,a = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"ary = list(map(int,input().split()))",
"ary",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[-1 for _ in range(sum(ary)+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 for _ in range(sum(ary)+1)] for _ in range(n+1)]",
"memo = [[[-1 for _ in range(sum(ary)+1)] for _ in range(n+1)] for _ in range(n+1)]",
"memo",
"[[[-1 for _ in range(sum(ary)+1)] for _ in range(n+1)] for _ in range(n+1)]",
"print(f(n,0,0))",
"print",
"f(n,0,0)",
"f",
"n",
"0",
"0",
"n,a = map(int,input().split())",
"map(int,input().split())",
"n",
"def f(n,x,i):\n if n == 0:\n if x != 0:\n if x / i == a:\n return 1\n return 0\n if memo[i][n][x] != -1:\n return memo[i][n][x]\n memo[i][n][x] = f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)\n return memo[i][n][x]",
"def f(n,x,i):\n if n == 0:\n if x != 0:\n if x / i == a:\n return 1\n return 0\n if memo[i][n][x] != -1:\n return memo[i][n][x]\n memo[i][n][x] = f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)\n return memo[i][n][x]",
"f",
"a = map(int,input().split())",
"map(int,input().split())",
"a",
"memo = [[[-1 for _ in range(sum(ary)+1)] for _ in range(n+1)] for _ in range(n+1)]",
"[[[-1 for _ in range(sum(ary)+1)] for _ in range(n+1)] for _ in range(n+1)]",
"memo",
"ary = list(map(int,input().split()))",
"list(map(int,input().split()))",
"ary"
] | def f(n,x,i):
if n == 0:
if x != 0:
if x / i == a:
return 1
return 0
if memo[i][n][x] != -1:
return memo[i][n][x]
memo[i][n][x] = f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)
return memo[i][n][x]
n,a = map(int,input().split())
ary = list(map(int,input().split()))
memo = [[[-1 for _ in range(sum(ary)+1)] for _ in range(n+1)] for _ in range(n+1)]
print(f(n,0,0)) |
[
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,
12,
2,
13,
13,
23,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
14,
2,
13,
17,
0,
13,
13,
0,
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,
2,
17,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
40,
2,
13,
18,
13,
13,
2,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
2,
18,
18,
13,
13,
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,
2,
18,
18,
13,
13,
2,
17,
13,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13
] | [
[
172,
2
],
[
172,
11
],
[
181,
13
],
[
166,
25
],
[
158,
33
],
[
182,
35
],
[
163,
37
],
[
175,
40
],
[
44,
43
],
[
167,
43
],
[
43,
47
],
[
154,
50
],
[
43,
51
],
[
178,
53
],
[
43,
54
],
[
160,
56
],
[
182,
59
],
[
63,
62
],
[
161,
66
],
[
173,
66
],
[
169,
71
],
[
81,
74
],
[
170,
76
],
[
179,
80
],
[
176,
80
],
[
84,
83
],
[
161,
86
],
[
173,
86
],
[
89,
88
],
[
155,
93
],
[
164,
93
],
[
179,
94
],
[
176,
94
],
[
88,
99
],
[
167,
101
],
[
83,
102
],
[
155,
104
],
[
164,
104
],
[
179,
105
],
[
176,
105
],
[
114,
107
],
[
170,
109
],
[
83,
111
],
[
88,
113
],
[
170,
117
],
[
83,
118
],
[
88,
120
],
[
167,
122
],
[
83,
123
],
[
170,
126
],
[
83,
127
],
[
88,
128
],
[
137,
130
],
[
170,
132
],
[
83,
134
],
[
88,
136
],
[
170,
139
],
[
83,
140
],
[
88,
141
],
[
170,
147
],
[
161,
148
],
[
173,
148
],
[
179,
151
],
[
176,
151
],
[
43,
154
],
[
154,
155
],
[
172,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
],
[
43,
178
],
[
178,
179
],
[
181,
182
]
] | [
"N,A = map(int, input().split())\nalist = list(map(int, input().split()))\n\nblist = list(map(lambda x:x-A,alist))\nsum_plus = 0\nsum_minus = 0\nfor i in blist:\n if i >0:\n sum_plus +=i\n else:\n sum_minus +=i\n\nN=len(alist)\ndp = [[0 for i in range(sum_plus - sum_minus + 1)] for j in range(N+1)]\ndp[0][0-sum_minus]=1\n\nfor i in range(N):\n for j in range(sum_plus - sum_minus+1):\n if j-blist[i] <= (sum_plus - sum_minus):\n dp[i+1][j]=dp[i][j-blist[i]]+dp[i][j]\n else:\n dp[i+1][j]=dp[i][j]\n\nprint(dp[N][0-sum_minus]-1)",
"N,A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"alist = list(map(int, input().split()))",
"alist",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"blist = list(map(lambda x:x-A,alist))",
"blist",
"list(map(lambda x:x-A,alist))",
"list",
"map(lambda x:x-A,alist)",
"map",
"lambda x:x-A",
"x-A",
"x",
"A",
"x",
"alist",
"sum_plus = 0",
"sum_plus",
"0",
"sum_minus = 0",
"sum_minus",
"0",
"for i in blist:\n if i >0:\n sum_plus +=i\n else:\n sum_minus +=i",
"i",
"blist",
"if i >0:\n sum_plus +=i\n else:\n sum_minus +=i",
"i >0",
"i",
"0",
"sum_plus +=i",
"sum_plus",
"i",
"sum_minus +=i",
"sum_minus",
"i",
"N=len(alist)",
"N",
"len(alist)",
"len",
"alist",
"[0 for i in range(sum_plus - sum_minus + 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(sum_plus - sum_minus + 1)]",
"dp = [[0 for i in range(sum_plus - sum_minus + 1)] for j in range(N+1)]",
"dp",
"[[0 for i in range(sum_plus - sum_minus + 1)] for j in range(N+1)]",
"dp[0][0-sum_minus]=1",
"dp[0][0-sum_minus]",
"[0]",
"dp",
"0",
"0-sum_minus",
"0",
"sum_minus",
"1",
"for i in range(N):\n for j in range(sum_plus - sum_minus+1):\n if j-blist[i] <= (sum_plus - sum_minus):\n dp[i+1][j]=dp[i][j-blist[i]]+dp[i][j]\n else:\n dp[i+1][j]=dp[i][j]",
"i",
"range(N)",
"range",
"N",
"for j in range(sum_plus - sum_minus+1):\n if j-blist[i] <= (sum_plus - sum_minus):\n dp[i+1][j]=dp[i][j-blist[i]]+dp[i][j]\n else:\n dp[i+1][j]=dp[i][j]",
"j",
"range(sum_plus - sum_minus+1)",
"range",
"sum_plus - sum_minus+1",
"sum_plus - sum_minus",
"sum_plus",
"sum_minus",
"1",
"if j-blist[i] <= (sum_plus - sum_minus):\n dp[i+1][j]=dp[i][j-blist[i]]+dp[i][j]\n else:\n dp[i+1][j]=dp[i][j]",
"j-blist[i] <= (sum_plus - sum_minus)",
"j-blist[i]",
"j",
"blist[i]",
"blist",
"i",
"sum_plus - sum_minus",
"sum_plus",
"sum_minus",
"dp[i+1][j]=dp[i][j-blist[i]]+dp[i][j]",
"dp[i+1][j]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"j",
"dp[i][j-blist[i]]+dp[i][j]",
"dp[i][j-blist[i]]",
"[i]",
"dp",
"i",
"j-blist[i]",
"j",
"blist[i]",
"blist",
"i",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"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][0-sum_minus]-1)",
"print",
"dp[N][0-sum_minus]-1",
"dp[N][0-sum_minus]",
"[N]",
"dp",
"N",
"0-sum_minus",
"0",
"sum_minus",
"1",
"sum_plus +=i",
"i",
"sum_plus",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"N=len(alist)",
"len(alist)",
"N",
"sum_plus = 0",
"0",
"sum_plus",
"blist = list(map(lambda x:x-A,alist))",
"list(map(lambda x:x-A,alist))",
"blist",
"dp = [[0 for i in range(sum_plus - sum_minus + 1)] for j in range(N+1)]",
"[[0 for i in range(sum_plus - sum_minus + 1)] for j in range(N+1)]",
"dp",
"N,A = map(int, input().split())",
"map(int, input().split())",
"N",
"sum_minus = 0",
"0",
"sum_minus",
"sum_minus +=i",
"i",
"sum_minus",
"alist = list(map(int, input().split()))",
"list(map(int, input().split()))",
"alist"
] | N,A = map(int, input().split())
alist = list(map(int, input().split()))
blist = list(map(lambda x:x-A,alist))
sum_plus = 0
sum_minus = 0
for i in blist:
if i >0:
sum_plus +=i
else:
sum_minus +=i
N=len(alist)
dp = [[0 for i in range(sum_plus - sum_minus + 1)] for j in range(N+1)]
dp[0][0-sum_minus]=1
for i in range(N):
for j in range(sum_plus - sum_minus+1):
if j-blist[i] <= (sum_plus - sum_minus):
dp[i+1][j]=dp[i][j-blist[i]]+dp[i][j]
else:
dp[i+1][j]=dp[i][j]
print(dp[N][0-sum_minus]-1) |
[
7,
15,
12,
13,
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,
4,
13,
39,
17,
28,
13,
13,
0,
13,
4,
13,
13,
28,
13,
13,
4,
18,
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,
12,
13
] | [
[
6,
5
],
[
6,
14
],
[
18,
17
],
[
17,
27
],
[
14,
28
],
[
31,
30
],
[
34,
33
],
[
40,
39
],
[
30,
39
],
[
43,
42
],
[
33,
51
],
[
61,
51
],
[
59,
54
],
[
42,
55
],
[
39,
58
],
[
62,
61
],
[
42,
62
],
[
61,
67
],
[
33,
67
],
[
78,
75
]
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\nfrom collections import Counter, defaultdict\n\n\ndef main():\n N, A = map(int, input().split())\n X = [int(x) - A for x in input().split()]\n\n result = Counter([0])\n\n for x in X:\n dct = defaultdict(int)\n for k, v in result.items():\n dct[k + x] += v\n result += dct\n\n print(result[0] - 1)\n\n\nif __name__ == \"__main__\":\n main()",
"from collections import Counter, defaultdict",
"def main():\n N, A = map(int, input().split())\n X = [int(x) - A for x in input().split()]\n\n result = Counter([0])\n\n for x in X:\n dct = defaultdict(int)\n for k, v in result.items():\n dct[k + x] += v\n result += dct\n\n print(result[0] - 1)",
"main",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"int(x) - A for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x) - A",
"int(x)",
"int",
"x",
"A",
"X = [int(x) - A for x in input().split()]",
"X",
"[int(x) - A for x in input().split()]",
"result = Counter([0])",
"result",
"Counter([0])",
"Counter",
"[0]",
"0",
"for x in X:\n dct = defaultdict(int)\n for k, v in result.items():\n dct[k + x] += v\n result += dct\n\n ",
"x",
"X",
"dct = defaultdict(int)",
"dct",
"defaultdict(int)",
"defaultdict",
"int",
"for k, v in result.items():\n dct[k + x] += v\n ",
"k",
"v",
"result.items()",
"result.items",
"result",
"items",
"dct[k + x] += v",
"dct[k + x]",
"dct",
"k + x",
"k",
"x",
"v",
"result += dct",
"result",
"dct",
"print(result[0] - 1)",
"print",
"result[0] - 1",
"result[0]",
"result",
"0",
"1",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n N, A = map(int, input().split())\n X = [int(x) - A for x in input().split()]\n\n result = Counter([0])\n\n for x in X:\n dct = defaultdict(int)\n for k, v in result.items():\n dct[k + x] += v\n result += dct\n\n print(result[0] - 1)",
"def main():\n N, A = map(int, input().split())\n X = [int(x) - A for x in input().split()]\n\n result = Counter([0])\n\n for x in X:\n dct = defaultdict(int)\n for k, v in result.items():\n dct[k + x] += v\n result += dct\n\n print(result[0] - 1)",
"main"
] | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from collections import Counter, defaultdict
def main():
N, A = map(int, input().split())
X = [int(x) - A for x in input().split()]
result = Counter([0])
for x in X:
dct = defaultdict(int)
for k, v in result.items():
dct[k + x] += v
result += dct
print(result[0] - 1)
if __name__ == "__main__":
main()
|
[
7,
15,
15,
15,
13,
15,
13,
15,
13,
15,
15,
13,
15,
13,
15,
15,
15,
15,
4,
18,
13,
13,
17,
0,
13,
4,
13,
17,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
0,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
41,
28,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
13,
14,
40,
18,
13,
13,
17,
28,
13,
4,
13,
17,
17,
0,
18,
13,
13,
18,
13,
2,
13,
18,
13,
13,
28,
13,
4,
13,
17,
17,
17,
0,
18,
13,
13,
18,
13,
2,
13,
18,
13,
13,
4,
13,
2,
18,
13,
17,
17,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13
] | [
[
235,
24
],
[
39,
38
],
[
230,
44
],
[
48,
48
],
[
52,
51
],
[
224,
57
],
[
61,
61
],
[
65,
64
],
[
212,
70
],
[
74,
74
],
[
78,
77
],
[
245,
83
],
[
87,
87
],
[
91,
90
],
[
212,
98
],
[
102,
102
],
[
106,
105
],
[
114,
114
],
[
232,
116
],
[
238,
119
],
[
224,
121
],
[
238,
122
],
[
250,
124
],
[
224,
126
],
[
130,
129
],
[
251,
129
],
[
129,
133
],
[
215,
134
],
[
241,
136
],
[
217,
139
],
[
147,
144
],
[
218,
145
],
[
150,
149
],
[
239,
152
],
[
242,
156
],
[
251,
156
],
[
149,
157
],
[
161,
160
],
[
169,
166
],
[
218,
167
],
[
160,
168
],
[
218,
170
],
[
160,
172
],
[
242,
174
],
[
251,
174
],
[
149,
175
],
[
178,
177
],
[
187,
184
],
[
218,
185
],
[
177,
186
],
[
218,
188
],
[
177,
190
],
[
242,
192
],
[
251,
192
],
[
149,
193
],
[
218,
198
],
[
238,
215
],
[
217,
218
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
250,
251
]
] | [
"from collections import defaultdict, deque, Counter\nfrom heapq import heappush, heappop, heapify\nimport math\nimport bisect\nimport random\nfrom itertools import permutations, accumulate, combinations, product\nimport sys\nimport string\nfrom bisect import bisect_left, bisect_right\nfrom math import factorial, ceil, floor\nfrom operator import mul\nfrom functools import reduce\n\n\n\nsys.setrecursionlimit(2147483647)\nINF = float('inf')\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef I(): return int(sys.stdin.readline())\ndef LS(): return sys.stdin.readline().split()\ndef S(): return sys.stdin.readline().strip()\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef LSR(n): return [LS() for i in range(n)]\ndef SRL(n): return [list(S()) for i in range(n)]\ndef MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]\nmod = 1000000007\n\n\n\nn, a = LI()\nL = LI()\nL = [i - a for i in L]\ndp = defaultdict(int)\ndp[0] = 1\nfor i in range(n):\n if L[i] <= 0:\n for j in range(-2500, 2501):\n dp[j] += dp[j - L[i]]\n else:\n for j in range(2500, -2501, -1):\n dp[j] += dp[j - L[i]]\n\n\nprint(dp[0] - 1)",
"from collections import defaultdict, deque, Counter",
"from heapq import heappush, heappop, heapify",
"import math",
"math",
"import bisect",
"bisect",
"import random",
"random",
"from itertools import permutations, accumulate, combinations, product",
"import sys",
"sys",
"import string",
"string",
"from bisect import bisect_left, bisect_right",
"from math import factorial, ceil, floor",
"from operator import mul",
"from functools import reduce",
"sys.setrecursionlimit(2147483647)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"2147483647",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"def I(): return int(sys.stdin.readline())",
"I",
"def LS(): return sys.stdin.readline().split()",
"LS",
"def S(): return sys.stdin.readline().strip()",
"S",
"I() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"I()",
"I",
"def IR(n): return [I() for i in range(n)]",
"IR",
"n",
"n",
"LI() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LI()",
"LI",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"n",
"n",
"S() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"S()",
"S",
"def SR(n): return [S() for i in range(n)]",
"SR",
"n",
"n",
"LS() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LS()",
"LS",
"def LSR(n): return [LS() for i in range(n)]",
"LSR",
"n",
"n",
"list(S()) for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"list(S())",
"list",
"S()",
"S",
"def SRL(n): return [list(S()) for i in range(n)]",
"SRL",
"n",
"n",
"[int(j) for j in list(S())] for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"[int(j) for j in list(S())]",
"def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]",
"MSRL",
"n",
"n",
"mod = 1000000007",
"mod",
"1000000007",
"n, a = LI()",
"n",
"LI()",
"LI",
"a",
"L = LI()",
"L",
"LI()",
"LI",
"i - a for i in L",
"for i in L",
"i",
"L",
"for i in L",
"i - a",
"i",
"a",
"L = [i - a for i in L]",
"L",
"[i - a for i in L]",
"dp = defaultdict(int)",
"dp",
"defaultdict(int)",
"defaultdict",
"int",
"dp[0] = 1",
"dp[0]",
"dp",
"0",
"1",
"for i in range(n):\n if L[i] <= 0:\n for j in range(-2500, 2501):\n dp[j] += dp[j - L[i]]\n else:\n for j in range(2500, -2501, -1):\n dp[j] += dp[j - L[i]]",
"i",
"range(n)",
"range",
"n",
"if L[i] <= 0:\n for j in range(-2500, 2501):\n dp[j] += dp[j - L[i]]\n else:\n for j in range(2500, -2501, -1):\n dp[j] += dp[j - L[i]]",
"L[i] <= 0",
"L[i]",
"L",
"i",
"0",
"for j in range(-2500, 2501):\n dp[j] += dp[j - L[i]]\n ",
"j",
"range(-2500, 2501)",
"range",
"-2500",
"2501",
"dp[j] += dp[j - L[i]]",
"dp[j]",
"dp",
"j",
"dp[j - L[i]]",
"dp",
"j - L[i]",
"j",
"L[i]",
"L",
"i",
"for j in range(2500, -2501, -1):\n dp[j] += dp[j - L[i]]",
"j",
"range(2500, -2501, -1)",
"range",
"2500",
"-2501",
"-1",
"dp[j] += dp[j - L[i]]",
"dp[j]",
"dp",
"j",
"dp[j - L[i]]",
"dp",
"j - L[i]",
"j",
"L[i]",
"L",
"i",
"print(dp[0] - 1)",
"print",
"dp[0] - 1",
"dp[0]",
"dp",
"0",
"1",
"def IR(n): return [I() for i in range(n)]",
"def IR(n): return [I() for i in range(n)]",
"IR",
"def LIR(n): return [LI() for i in range(n)]",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"def LSR(n): return [LS() for i in range(n)]",
"def LSR(n): return [LS() for i in range(n)]",
"LSR",
"def S(): return sys.stdin.readline().strip()",
"def S(): return sys.stdin.readline().strip()",
"S",
"a = LI()",
"LI()",
"a",
"dp = defaultdict(int)",
"defaultdict(int)",
"dp",
"def SR(n): return [S() for i in range(n)]",
"def SR(n): return [S() for i in range(n)]",
"SR",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"def SRL(n): return [list(S()) for i in range(n)]",
"def SRL(n): return [list(S()) for i in range(n)]",
"SRL",
"def I(): return int(sys.stdin.readline())",
"def I(): return int(sys.stdin.readline())",
"I",
"mod = 1000000007",
"1000000007",
"mod",
"INF = float('inf')",
"float('inf')",
"INF",
"n, a = LI()",
"LI()",
"n",
"L = [i - a for i in L]",
"[i - a for i in L]",
"L",
"def LS(): return sys.stdin.readline().split()",
"def LS(): return sys.stdin.readline().split()",
"LS",
"def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]",
"def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]",
"MSRL",
"L = LI()",
"LI()",
"L"
] | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, a = LI()
L = LI()
L = [i - a for i in L]
dp = defaultdict(int)
dp[0] = 1
for i in range(n):
if L[i] <= 0:
for j in range(-2500, 2501):
dp[j] += dp[j - L[i]]
else:
for j in range(2500, -2501, -1):
dp[j] += dp[j - L[i]]
print(dp[0] - 1) |
[
7,
15,
13,
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,
12,
13,
0,
13,
4,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
4,
18,
13,
13,
13,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
4,
13,
13,
28,
13,
4,
13,
13,
17,
17,
28,
13,
13,
4,
18,
18,
13,
13,
13,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
13,
29,
13,
23,
13,
0,
13,
4,
13,
13,
4,
13,
4,
13,
18,
18,
13,
13,
2,
13,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13
] | [
[
6,
5
],
[
5,
14
],
[
128,
16
],
[
128,
18
],
[
22,
21
],
[
21,
30
],
[
119,
32
],
[
38,
37
],
[
101,
40
],
[
44,
43
],
[
37,
47
],
[
57,
56
],
[
64,
59
],
[
56,
61
],
[
101,
70
],
[
73,
72
],
[
56,
84
],
[
72,
85
],
[
97,
88
],
[
56,
90
],
[
72,
92
],
[
56,
99
],
[
101,
101
],
[
125,
103
],
[
132,
105
],
[
120,
106
],
[
126,
113
],
[
129,
117
],
[
119,
120
],
[
128,
123
],
[
125,
126
],
[
128,
129
]
] | [
"import collections\nN, A = [int(_) for _ in input().split()]\nX = [int(_) for _ in input().split()]\n\n\ndef calc(W):\n #dp[m][s]=m枚のカードの和がsとなるような選び方の総数\n M = len(W)\n dp = [collections.defaultdict(int) for _ in range(M + 1)]\n dp[0][0] = 1\n for i, w in enumerate(W):\n for j in range(i, -1, -1):\n for k, v in dp[j].items():\n dp[j + 1][k + w] += v\n return dp\n\n\ndpx = calc(X)\nprint(sum(dpx[i][i * A] for i in range(1, N + 1)))",
"import collections",
"collections",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"N, A = [int(_) for _ in input().split()]",
"N",
"[int(_) for _ in input().split()]",
"A",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"X = [int(_) for _ in input().split()]",
"X",
"[int(_) for _ in input().split()]",
"def calc(W):\n #dp[m][s]=m枚のカードの和がsとなるような選び方の総数\n M = len(W)\n dp = [collections.defaultdict(int) for _ in range(M + 1)]\n dp[0][0] = 1\n for i, w in enumerate(W):\n for j in range(i, -1, -1):\n for k, v in dp[j].items():\n dp[j + 1][k + w] += v\n return dp",
"calc",
"M = len(W)",
"M",
"len(W)",
"len",
"W",
"collections.defaultdict(int) for _ in range(M + 1)",
"for _ in range(M + 1)",
"_",
"range(M + 1)",
"range",
"M + 1",
"M",
"1",
"for _ in range(M + 1)",
"collections.defaultdict(int)",
"collections.defaultdict",
"collections",
"defaultdict",
"int",
"dp = [collections.defaultdict(int) for _ in range(M + 1)]",
"dp",
"[collections.defaultdict(int) for _ in range(M + 1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i, w in enumerate(W):\n for j in range(i, -1, -1):\n for k, v in dp[j].items():\n dp[j + 1][k + w] += v\n ",
"i",
"w",
"enumerate(W)",
"enumerate",
"W",
"for j in range(i, -1, -1):\n for k, v in dp[j].items():\n dp[j + 1][k + w] += v\n ",
"j",
"range(i, -1, -1)",
"range",
"i",
"-1",
"-1",
"for k, v in dp[j].items():\n dp[j + 1][k + w] += v\n ",
"k",
"v",
"dp[j].items()",
"[j].items",
"[j]",
"dp",
"j",
"items",
"dp[j + 1][k + w] += v",
"dp[j + 1][k + w]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"k + w",
"k",
"w",
"v",
"return dp",
"dp",
"W",
"W",
"dpx = calc(X)",
"dpx",
"calc(X)",
"calc",
"X",
"print(sum(dpx[i][i * A] for i in range(1, N + 1)))",
"print",
"sum(dpx[i][i * A] for i in range(1, N + 1))",
"sum",
"dpx[i][i * A]",
"[i]",
"dpx",
"i",
"i * A",
"i",
"A",
"X = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"X",
"N, A = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"N",
"dpx = calc(X)",
"calc(X)",
"dpx",
"A = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"A",
"def calc(W):\n #dp[m][s]=m枚のカードの和がsとなるような選び方の総数\n M = len(W)\n dp = [collections.defaultdict(int) for _ in range(M + 1)]\n dp[0][0] = 1\n for i, w in enumerate(W):\n for j in range(i, -1, -1):\n for k, v in dp[j].items():\n dp[j + 1][k + w] += v\n return dp",
"def calc(W):\n #dp[m][s]=m枚のカードの和がsとなるような選び方の総数\n M = len(W)\n dp = [collections.defaultdict(int) for _ in range(M + 1)]\n dp[0][0] = 1\n for i, w in enumerate(W):\n for j in range(i, -1, -1):\n for k, v in dp[j].items():\n dp[j + 1][k + w] += v\n return dp",
"calc"
] | import collections
N, A = [int(_) for _ in input().split()]
X = [int(_) for _ in input().split()]
def calc(W):
#dp[m][s]=m枚のカードの和がsとなるような選び方の総数
M = len(W)
dp = [collections.defaultdict(int) for _ in range(M + 1)]
dp[0][0] = 1
for i, w in enumerate(W):
for j in range(i, -1, -1):
for k, v in dp[j].items():
dp[j + 1][k + w] += v
return dp
dpx = calc(X)
print(sum(dpx[i][i * A] for i in range(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,
0,
13,
4,
13,
4,
13,
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,
17,
2,
13,
17,
0,
13,
2,
13,
17,
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,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
40,
17,
13,
40,
18,
13,
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,
18,
18,
18,
13,
13,
13,
13,
17,
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,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13
] | [
[
198,
2
],
[
198,
11
],
[
201,
13
],
[
213,
25
],
[
202,
30
],
[
193,
31
],
[
204,
33
],
[
199,
35
],
[
214,
36
],
[
40,
39
],
[
199,
43
],
[
210,
48
],
[
58,
51
],
[
211,
54
],
[
61,
60
],
[
199,
65
],
[
189,
68
],
[
60,
70
],
[
74,
73
],
[
199,
77
],
[
81,
80
],
[
205,
84
],
[
80,
88
],
[
202,
90
],
[
190,
91
],
[
100,
93
],
[
211,
96
],
[
60,
97
],
[
73,
98
],
[
80,
99
],
[
211,
103
],
[
60,
105
],
[
73,
107
],
[
80,
108
],
[
73,
113
],
[
202,
116
],
[
190,
117
],
[
80,
118
],
[
127,
120
],
[
211,
123
],
[
60,
124
],
[
73,
125
],
[
80,
126
],
[
211,
131
],
[
60,
133
],
[
73,
135
],
[
80,
136
],
[
211,
140
],
[
60,
142
],
[
73,
145
],
[
80,
148
],
[
202,
150
],
[
190,
151
],
[
160,
153
],
[
211,
156
],
[
60,
157
],
[
73,
158
],
[
80,
159
],
[
195,
162
],
[
166,
165
],
[
199,
170
],
[
207,
173
],
[
196,
175
],
[
208,
175
],
[
211,
179
],
[
199,
180
],
[
165,
181
],
[
165,
183
],
[
193,
184
],
[
208,
187
],
[
196,
187
],
[
189,
190
],
[
198,
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\nxmax=max(max(x),a)\n \nnx=n*xmax\ndp=[[[0]*(nx+1) for ii in range(n+1)] for i in range(n+1)]\n\ndp[0][0][0]=1\n\nfor j in range(1,n+1):\n jj=j-1\n for k in range(n+1):\n for s in range(nx+1):\n if s<x[jj]:\n dp[j][k][s]=dp[j-1][k][s]\n elif 1<=k and x[jj]<=s:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]\n else:\n dp[j][k][s]=0\n# if dp[j][k][s]!=0:\n# print(j,k,s,dp[j][k][s])\ndpsum=0\nfor k in range(1,n+1):\n dpsum=dpsum+dp[n][k][k*a]\n \nprint(dpsum)\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",
"xmax=max(max(x),a)",
"xmax",
"max(max(x),a)",
"max",
"max(x)",
"max",
"x",
"a",
"nx=n*xmax",
"nx",
"n*xmax",
"n",
"xmax",
"[[0]*(nx+1) for ii 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]*(nx+1) for ii in range(n+1)]",
"dp=[[[0]*(nx+1) for ii in range(n+1)] for i in range(n+1)]",
"dp",
"[[[0]*(nx+1) for ii 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(1,n+1):\n jj=j-1\n for k in range(n+1):\n for s in range(nx+1):\n if s<x[jj]:\n dp[j][k][s]=dp[j-1][k][s]\n elif 1<=k and x[jj]<=s:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]\n else:\n dp[j][k][s]=0\n# if dp[j][k][s]!=0:\n# print(j,k,s,dp[j][k][s])",
"j",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"jj=j-1",
"jj",
"j-1",
"j",
"1",
"for k in range(n+1):\n for s in range(nx+1):\n if s<x[jj]:\n dp[j][k][s]=dp[j-1][k][s]\n elif 1<=k and x[jj]<=s:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]\n else:\n dp[j][k][s]=0\n# if dp[j][k][s]!=0:\n# print(j,k,s,dp[j][k][s])",
"k",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for s in range(nx+1):\n if s<x[jj]:\n dp[j][k][s]=dp[j-1][k][s]\n elif 1<=k and x[jj]<=s:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]\n else:\n dp[j][k][s]=0\n# if dp[j][k][s]!=0:\n# print(j,k,s,dp[j][k][s])",
"s",
"range(nx+1)",
"range",
"nx+1",
"nx",
"1",
"if s<x[jj]:\n dp[j][k][s]=dp[j-1][k][s]\n elif 1<=k and x[jj]<=s:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]\n else:\n dp[j][k][s]=0\n# if dp[j][k][s]!=0:\n# print(j,k,s,dp[j][k][s])",
"s<x[jj]",
"s",
"x[jj]",
"x",
"jj",
"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 1<=k and x[jj]<=s:\n dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]\n ",
"1<=k and x[jj]<=s",
"1<=k",
"1",
"k",
"x[jj]<=s",
"x[jj]",
"x",
"jj",
"s",
"dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]",
"dp[j-1][k][s]",
"[k]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k",
"s",
"dp[j-1][k-1][s-x[jj]]",
"[k-1]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"k-1",
"k",
"1",
"s-x[jj]",
"s",
"x[jj]",
"x",
"jj",
"dp[j][k][s]=0",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"0",
"dpsum=0",
"dpsum",
"0",
"for k in range(1,n+1):\n dpsum=dpsum+dp[n][k][k*a]\n ",
"k",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"dpsum=dpsum+dp[n][k][k*a]",
"dpsum",
"dpsum+dp[n][k][k*a]",
"dpsum",
"dp[n][k][k*a]",
"[k]",
"[n]",
"dp",
"n",
"k",
"k*a",
"k",
"a",
"print(dpsum)",
"print",
"dpsum",
"jj=j-1",
"j-1",
"jj",
"a=map(int,input().split())",
"map(int,input().split())",
"a",
"dpsum=0",
"0",
"dpsum",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"x=list(map(int,input().split()))",
"list(map(int,input().split()))",
"x",
"nx=n*xmax",
"n*xmax",
"nx",
"dpsum=dpsum+dp[n][k][k*a]",
"dpsum+dp[n][k][k*a]",
"dpsum",
"dp=[[[0]*(nx+1) for ii in range(n+1)] for i in range(n+1)]",
"[[[0]*(nx+1) for ii in range(n+1)] for i in range(n+1)]",
"dp",
"xmax=max(max(x),a)",
"max(max(x),a)",
"xmax"
] | n,a=map(int,input().split())
x=list(map(int,input().split()))
xmax=max(max(x),a)
nx=n*xmax
dp=[[[0]*(nx+1) for ii in range(n+1)] for i in range(n+1)]
dp[0][0][0]=1
for j in range(1,n+1):
jj=j-1
for k in range(n+1):
for s in range(nx+1):
if s<x[jj]:
dp[j][k][s]=dp[j-1][k][s]
elif 1<=k and x[jj]<=s:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[jj]]
else:
dp[j][k][s]=0
# if dp[j][k][s]!=0:
# print(j,k,s,dp[j][k][s])
dpsum=0
for k in range(1,n+1):
dpsum=dpsum+dp[n][k][k*a]
print(dpsum)
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
2,
13,
13,
0,
13,
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,
13,
4,
13,
2,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
73,
3
],
[
73,
12
],
[
16,
15
],
[
15,
28
],
[
74,
29
],
[
76,
31
],
[
79,
34
],
[
42,
39
],
[
80,
40
],
[
45,
44
],
[
77,
44
],
[
80,
53
],
[
61,
56
],
[
80,
57
],
[
44,
60
],
[
80,
66
],
[
73,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
]
] | [
"from collections import defaultdict\n\nn, a = map(int, input().split())\narr = [x-a for x in list(map(int, input().split()))]\n\ndct = defaultdict(int)\ndct[0] = 1\n\nfor x in arr:\n for k, v in list(dct.items()):\n dct[k+x] += v\n\nprint(dct[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-a for x in list(map(int, input().split()))",
"for x in 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 list(map(int, input().split()))",
"x-a",
"x",
"a",
"arr = [x-a for x in list(map(int, input().split()))]",
"arr",
"[x-a for x in list(map(int, input().split()))]",
"dct = defaultdict(int)",
"dct",
"defaultdict(int)",
"defaultdict",
"int",
"dct[0] = 1",
"dct[0]",
"dct",
"0",
"1",
"for x in arr:\n for k, v in list(dct.items()):\n dct[k+x] += v",
"x",
"arr",
"for k, v in list(dct.items()):\n dct[k+x] += v",
"k",
"v",
"list(dct.items())",
"list",
"dct.items()",
"dct.items",
"dct",
"items",
"dct[k+x] += v",
"dct[k+x]",
"dct",
"k+x",
"k",
"x",
"v",
"print(dct[0]-1)",
"print",
"dct[0]-1",
"dct[0]",
"dct",
"0",
"1",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"arr = [x-a for x in list(map(int, input().split()))]",
"[x-a for x in list(map(int, input().split()))]",
"arr",
"dct = defaultdict(int)",
"defaultdict(int)",
"dct"
] | from collections import defaultdict
n, a = map(int, input().split())
arr = [x-a for x in list(map(int, input().split()))]
dct = defaultdict(int)
dct[0] = 1
for x in arr:
for k, v in list(dct.items()):
dct[k+x] += v
print(dct[0]-1) |
[
7,
15,
13,
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,
18,
13,
13,
39,
17,
17,
17,
0,
18,
13,
39,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
18,
13,
2,
13,
17,
0,
18,
13,
13,
2,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
13,
4,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13
] | [
[
122,
4
],
[
122,
13
],
[
17,
16
],
[
16,
25
],
[
113,
27
],
[
119,
30
],
[
43,
40
],
[
120,
41
],
[
46,
45
],
[
123,
50
],
[
128,
53
],
[
114,
55
],
[
45,
57
],
[
61,
60
],
[
123,
65
],
[
71,
68
],
[
120,
69
],
[
45,
70
],
[
120,
72
],
[
45,
74
],
[
80,
77
],
[
120,
78
],
[
45,
79
],
[
120,
82
],
[
45,
84
],
[
120,
87
],
[
45,
89
],
[
125,
92
],
[
96,
95
],
[
123,
100
],
[
131,
103
],
[
120,
105
],
[
123,
106
],
[
132,
111
],
[
126,
111
],
[
113,
114
],
[
122,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
]
] | [
"import numpy as np\nN, A = map(int, input().split())\nX = [int(c) for c in input().split()]\ndp = np.zeros((51,51,2501))\ndp[:,0,0] = 1\nfor i in range(1,N+1):\n c = X[i-1]\n for k in range(1,N+1):\n dp[i,k,:c] = dp[i-1,k,:c]\n dp[i,k,c:] = dp[i-1,k,c:]+dp[i-1,k-1,:2501-c]\nans = 0\nfor i in range(1,N+1):\n ans += dp[N,i,i*A]\nprint(int(ans))\n ",
"import numpy as np",
"numpy",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"int(c) for c in input().split()",
"for c in input().split()",
"c",
"input().split()",
"().split",
"()",
"input",
"split",
"for c in input().split()",
"int(c)",
"int",
"c",
"X = [int(c) for c in input().split()]",
"X",
"[int(c) for c in input().split()]",
"dp = np.zeros((51,51,2501))",
"dp",
"np.zeros((51,51,2501))",
"np.zeros",
"np",
"zeros",
"(51,51,2501)",
"51",
"51",
"2501",
"dp[:,0,0] = 1",
"dp[:,0,0]",
"dp",
":",
"1",
"for i in range(1,N+1):\n c = X[i-1]\n for k in range(1,N+1):\n dp[i,k,:c] = dp[i-1,k,:c]\n dp[i,k,c:] = dp[i-1,k,c:]+dp[i-1,k-1,:2501-c]",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"c = X[i-1]",
"c",
"X[i-1]",
"X",
"i-1",
"i",
"1",
"for k in range(1,N+1):\n dp[i,k,:c] = dp[i-1,k,:c]\n dp[i,k,c:] = dp[i-1,k,c:]+dp[i-1,k-1,:2501-c]",
"k",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"dp[i,k,:c] = dp[i-1,k,:c]",
"dp[i,k,:c]",
"dp",
"i",
"dp[i-1,k,:c]",
"dp",
"i-1",
"i",
"1",
"dp[i,k,c:] = dp[i-1,k,c:]+dp[i-1,k-1,:2501-c]",
"dp[i,k,c:]",
"dp",
"i",
"dp[i-1,k,c:]+dp[i-1,k-1,:2501-c]",
"dp[i-1,k,c:]",
"dp",
"i-1",
"i",
"1",
"dp[i-1,k-1,:2501-c]",
"dp",
"i-1",
"i",
"1",
"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]",
"dp",
"N",
"print(int(ans))",
"print",
"int(ans)",
"int",
"ans",
"X = [int(c) for c in input().split()]",
"[int(c) for c in input().split()]",
"X",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"dp = np.zeros((51,51,2501))",
"np.zeros((51,51,2501))",
"dp",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"ans = 0",
"0",
"ans",
"c = X[i-1]",
"X[i-1]",
"c",
"ans += dp[N,i,i*A]",
"dp[N,i,i*A]",
"ans"
] | import numpy as np
N, A = map(int, input().split())
X = [int(c) for c in input().split()]
dp = np.zeros((51,51,2501))
dp[:,0,0] = 1
for i in range(1,N+1):
c = X[i-1]
for k in range(1,N+1):
dp[i,k,:c] = dp[i-1,k,:c]
dp[i,k,c:] = dp[i-1,k,c:]+dp[i-1,k-1,:2501-c]
ans = 0
for i in range(1,N+1):
ans += dp[N,i,i*A]
print(int(ans))
|
[
7,
12,
13,
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,
0,
13,
2,
18,
13,
17,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
16,
15
],
[
13,
25
],
[
34,
33
],
[
40,
39
],
[
15,
39
],
[
33,
48
],
[
56,
51
],
[
33,
52
],
[
39,
55
],
[
33,
59
],
[
39,
63
],
[
68,
67
],
[
33,
70
],
[
67,
75
],
[
84,
81
]
] | [
"def abc044_c():\n #値入力\n _, A = map(int, input().split())\n X = list(map(lambda x : int(x)-A,input().split()))\n #初期値\n d = {0:1}\n for x in X:\n for k,v in list(d.items()):\n d[k + x] = d.get(k + x,0) + v #差分の合計\n ans = d[0] - 1 #差分合計0で初期値を除く\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 #初期値\n d = {0:1}\n for x in X:\n for k,v in list(d.items()):\n d[k + x] = d.get(k + x,0) + v #差分の合計\n ans = d[0] - 1 #差分合計0で初期値を除く\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 for k,v in list(d.items()):\n d[k + x] = d.get(k + x,0) + v #差分の合計\n ",
"x",
"X",
"for k,v in list(d.items()):\n d[k + x] = d.get(k + x,0) + v #差分の合計\n ",
"k",
"v",
"list(d.items())",
"list",
"d.items()",
"d.items",
"d",
"items",
"d[k + x] = d.get(k + x,0) + v",
"d[k + x]",
"d",
"k + x",
"k",
"x",
"d.get(k + x,0) + v",
"d.get(k + x,0)",
"d.get",
"d",
"get",
"k + x",
"k",
"x",
"0",
"v",
"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 #初期値\n d = {0:1}\n for x in X:\n for k,v in list(d.items()):\n d[k + x] = d.get(k + x,0) + v #差分の合計\n ans = d[0] - 1 #差分合計0で初期値を除く\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 #初期値\n d = {0:1}\n for x in X:\n for k,v in list(d.items()):\n d[k + x] = d.get(k + x,0) + v #差分の合計\n ans = d[0] - 1 #差分合計0で初期値を除く\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:
for k,v in list(d.items()):
d[k + x] = d.get(k + x,0) + v #差分の合計
ans = d[0] - 1 #差分合計0で初期値を除く
print(ans)
if __name__ == '__main__':
abc044_c() |
[
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,
4,
13,
2,
13,
17,
4,
2,
39,
17,
2,
2,
13,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
13,
17,
17,
28,
13,
4,
13,
2,
2,
13,
17,
17,
14,
2,
40,
2,
13,
18,
13,
13,
17,
2,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
2,
13,
18,
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,
29,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
12,
13,
10,
18,
13
] | [
[
168,
4
],
[
177,
11
],
[
162,
18
],
[
171,
32
],
[
165,
37
],
[
43,
42
],
[
169,
49
],
[
43,
51
],
[
43,
52
],
[
57,
56
],
[
42,
60
],
[
42,
68
],
[
73,
72
],
[
80,
75
],
[
72,
77
],
[
83,
82
],
[
42,
85
],
[
88,
87
],
[
42,
90
],
[
95,
94
],
[
42,
99
],
[
94,
106
],
[
82,
109
],
[
87,
112
],
[
120,
115
],
[
72,
117
],
[
87,
118
],
[
94,
119
],
[
72,
122
],
[
87,
124
],
[
94,
127
],
[
82,
130
],
[
133,
132
],
[
136,
135
],
[
42,
140
],
[
144,
143
],
[
72,
146
],
[
135,
147
],
[
51,
149
],
[
135,
150
],
[
143,
153
],
[
132,
153
],
[
175,
160
],
[
162,
163
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
177,
178
]
] | [
"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 dp = [[0] * (N * 50 + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, -1, -1):\n for k in range(N * 50 + 1):\n if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, N + 1):\n ans += dp[j][A * j]\n\n print(ans)\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 dp = [[0] * (N * 50 + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, -1, -1):\n for k in range(N * 50 + 1):\n if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, N + 1):\n ans += dp[j][A * j]\n\n print(ans)\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",
"[0] * (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] * (N * 50 + 1)",
"[0]",
"0",
"N * 50 + 1",
"N * 50",
"N",
"50",
"1",
"dp = [[0] * (N * 50 + 1) for j in range(N + 1)]",
"dp",
"[[0] * (N * 50 + 1) for j in range(N + 1)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i in range(N):\n for j in range(N, -1, -1):\n for k in range(N * 50 + 1):\n if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ",
"i",
"range(N)",
"range",
"N",
"for j in range(N, -1, -1):\n for k in range(N * 50 + 1):\n if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ",
"j",
"range(N, -1, -1)",
"range",
"N",
"-1",
"-1",
"for k in range(N * 50 + 1):\n if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ",
"k",
"range(N * 50 + 1)",
"range",
"N * 50 + 1",
"N * 50",
"N",
"50",
"1",
"if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ",
"k - X[i] >= 0 and j > 0",
"k - X[i] >= 0",
"k - X[i]",
"k",
"X[i]",
"X",
"i",
"0",
"j > 0",
"j",
"0",
"dp[j][k] += dp[j - 1][k - X[i]]",
"dp[j][k]",
"[j]",
"dp",
"j",
"k",
"dp[j - 1][k - X[i]]",
"[j - 1]",
"dp",
"j - 1",
"j",
"1",
"k - X[i]",
"k",
"X[i]",
"X",
"i",
"ans = 0",
"ans",
"0",
"for j in range(1, N + 1):\n ans += dp[j][A * j]\n\n ",
"j",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"ans += dp[j][A * j]",
"ans",
"dp[j][A * j]",
"[j]",
"dp",
"j",
"A * j",
"A",
"j",
"print(ans)",
"print",
"ans",
"return",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"readlines = sys.stdin.readlines",
"sys.stdin.readlines",
"readlines",
"MOD = 1000000007",
"1000000007",
"MOD",
"read = sys.stdin.read",
"sys.stdin.read",
"read",
"INF = 1 << 60",
"1 << 60",
"INF",
"def main():\n N, A, *X = map(int, read().split())\n\n dp = [[0] * (N * 50 + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, -1, -1):\n for k in range(N * 50 + 1):\n if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, N + 1):\n ans += dp[j][A * j]\n\n print(ans)\n return",
"def main():\n N, A, *X = map(int, read().split())\n\n dp = [[0] * (N * 50 + 1) for j in range(N + 1)]\n dp[0][0] = 1\n\n for i in range(N):\n for j in range(N, -1, -1):\n for k in range(N * 50 + 1):\n if k - X[i] >= 0 and j > 0:\n dp[j][k] += dp[j - 1][k - X[i]]\n\n ans = 0\n for j in range(1, N + 1):\n ans += dp[j][A * j]\n\n print(ans)\n return",
"main",
"readline = sys.stdin.readline",
"sys.stdin.readline",
"readline"
] | 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())
dp = [[0] * (N * 50 + 1) for j in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(N, -1, -1):
for k in range(N * 50 + 1):
if k - X[i] >= 0 and j > 0:
dp[j][k] += dp[j - 1][k - X[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[j][A * j]
print(ans)
return
if __name__ == '__main__':
main()
|
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
0,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
13,
0,
13,
13,
12,
13,
29,
2,
2,
13,
13,
2,
13,
17,
23,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
13,
13,
0,
18,
18,
13,
2,
13,
17,
13,
18,
13,
13,
0,
18,
18,
13,
2,
13,
17,
4,
13,
18,
13,
13,
17,
4,
13,
18,
18,
13,
13,
2,
13,
17,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
12,
13,
10,
13,
13,
10,
18,
13,
10,
2,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
12
],
[
150,
14
],
[
150,
16
],
[
141,
18
],
[
23,
22
],
[
139,
26
],
[
142,
32
],
[
144,
34
],
[
47,
41
],
[
151,
42
],
[
142,
44
],
[
47,
47
],
[
51,
50
],
[
50,
59
],
[
159,
61
],
[
65,
64
],
[
139,
67
],
[
156,
69
],
[
160,
72
],
[
64,
73
],
[
151,
74
],
[
153,
76
],
[
145,
78
],
[
64,
79
],
[
82,
81
],
[
142,
84
],
[
154,
88
],
[
81,
89
],
[
101,
92
],
[
145,
94
],
[
64,
96
],
[
81,
99
],
[
157,
100
],
[
154,
102
],
[
81,
103
],
[
112,
105
],
[
145,
107
],
[
64,
109
],
[
81,
111
],
[
154,
113
],
[
81,
114
],
[
127,
116
],
[
145,
118
],
[
64,
120
],
[
148,
123
],
[
160,
125
],
[
64,
126
],
[
145,
132
],
[
139,
133
],
[
142,
135
],
[
150,
139
],
[
141,
142
],
[
144,
145
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
]
] | [
"N, A = [int(_) for _ in input().split()]\n\nMAX_I = 5000\nmemo = [[0] * MAX_I for _ in range(N + 2)]\n\n\ndef cnv(v):\n return v - A + (MAX_I // 2)\n\n\nX = [int(_) for _ in input().split()]\nfor i in range(N):\n offset = X[i] - A\n # print('x', offset)\n\n mm = memo[i]\n for j in range(MAX_I):\n if mm[j] > 0:\n memo[i + 1][j + offset] += mm[j]\n memo[i + 1][j] += mm[j]\n\n memo[i + 1][cnv(X[i])] += 1\n\nprint(memo[N][MAX_I//2])",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"N, A = [int(_) for _ in input().split()]",
"N",
"[int(_) for _ in input().split()]",
"A",
"MAX_I = 5000",
"MAX_I",
"5000",
"[0] * MAX_I for _ in range(N + 2)",
"for _ in range(N + 2)",
"_",
"range(N + 2)",
"range",
"N + 2",
"N",
"2",
"for _ in range(N + 2)",
"[0] * MAX_I",
"[0]",
"0",
"MAX_I",
"memo = [[0] * MAX_I for _ in range(N + 2)]",
"memo",
"[[0] * MAX_I for _ in range(N + 2)]",
"def cnv(v):\n return v - A + (MAX_I // 2)",
"cnv",
"return v - A + (MAX_I // 2)",
"v - A + (MAX_I // 2)",
"v - A",
"v",
"A",
"MAX_I // 2",
"MAX_I",
"2",
"v",
"v",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"X = [int(_) for _ in input().split()]",
"X",
"[int(_) for _ in input().split()]",
"for i in range(N):\n offset = X[i] - A\n # print('x', offset)\n\n mm = memo[i]\n for j in range(MAX_I):\n if mm[j] > 0:\n memo[i + 1][j + offset] += mm[j]\n memo[i + 1][j] += mm[j]\n\n memo[i + 1][cnv(X[i])] += 1",
"i",
"range(N)",
"range",
"N",
"offset = X[i] - A",
"offset",
"X[i] - A",
"X[i]",
"X",
"i",
"A",
"mm = memo[i]",
"mm",
"memo[i]",
"memo",
"i",
"for j in range(MAX_I):\n if mm[j] > 0:\n memo[i + 1][j + offset] += mm[j]\n memo[i + 1][j] += mm[j]\n\n ",
"j",
"range(MAX_I)",
"range",
"MAX_I",
"if mm[j] > 0:\n memo[i + 1][j + offset] += mm[j]\n ",
"mm[j] > 0",
"mm[j]",
"mm",
"j",
"0",
"memo[i + 1][j + offset] += mm[j]",
"memo[i + 1][j + offset]",
"[i + 1]",
"memo",
"i + 1",
"i",
"1",
"j + offset",
"j",
"offset",
"mm[j]",
"mm",
"j",
"memo[i + 1][j] += mm[j]",
"memo[i + 1][j]",
"[i + 1]",
"memo",
"i + 1",
"i",
"1",
"j",
"mm[j]",
"mm",
"j",
"memo[i + 1][cnv(X[i])] += 1",
"memo[i + 1][cnv(X[i])]",
"[i + 1]",
"memo",
"i + 1",
"i",
"1",
"cnv(X[i])",
"cnv",
"X[i]",
"X",
"i",
"1",
"print(memo[N][MAX_I//2])",
"print",
"memo[N][MAX_I//2]",
"[N]",
"memo",
"N",
"MAX_I//2",
"MAX_I",
"2",
"N, A = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"N",
"MAX_I = 5000",
"5000",
"MAX_I",
"memo = [[0] * MAX_I for _ in range(N + 2)]",
"[[0] * MAX_I for _ in range(N + 2)]",
"memo",
"def cnv(v):\n return v - A + (MAX_I // 2)",
"def cnv(v):\n return v - A + (MAX_I // 2)",
"cnv",
"A = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"A",
"mm = memo[i]",
"memo[i]",
"mm",
"offset = X[i] - A",
"X[i] - A",
"offset",
"X = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"X"
] | N, A = [int(_) for _ in input().split()]
MAX_I = 5000
memo = [[0] * MAX_I for _ in range(N + 2)]
def cnv(v):
return v - A + (MAX_I // 2)
X = [int(_) for _ in input().split()]
for i in range(N):
offset = X[i] - A
# print('x', offset)
mm = memo[i]
for j in range(MAX_I):
if mm[j] > 0:
memo[i + 1][j + offset] += mm[j]
memo[i + 1][j] += mm[j]
memo[i + 1][cnv(X[i])] += 1
print(memo[N][MAX_I//2])
|
[
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,
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,
10,
4,
13,
10,
4,
13,
10,
21,
13,
10,
4,
13,
10,
4,
13
] | [
[
90,
2
],
[
90,
11
],
[
78,
13
],
[
81,
25
],
[
91,
33
],
[
79,
35
],
[
84,
37
],
[
44,
43
],
[
82,
43
],
[
79,
43
],
[
85,
52
],
[
60,
55
],
[
85,
56
],
[
43,
58
],
[
85,
63
],
[
43,
66
],
[
85,
74
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
90,
88
],
[
90,
91
]
] | [
"# N枚のカード\n# 平均aにしたい\nn, a = map(int, input().split())\n# 手持ちのカード\nx = list(map(int, input().split()))\n \n# aとの差を記録してリストに入れなおす\n# 「選んだカードの xi の平均が A」であることは，\n# 「選んだカードの (xi − A) の合計が 0」と言い換えることができる．\nx = list(map(lambda i: i-a, x))\n#print(x)\n \n# dp初期値(辞書型)\n# dp[0] = 1という意味\ndp = {0: 1}\n\n#xから1枚取り出す\nfor i in x:\n #dpにあるすべてのkey,valueに対して、\n #すでにdpにkeyがi+kのデータがあればそのvalue、なければ,0を返し、\n #それ+vをdpとする。\n \n # k=key\n # v=dp[key]のvalue\n for k,v in list(dp.items()):\n dp[i+k]=dp.get(i+k,0)+v\n \n #print(dp)\n\n#全部使わない選択肢だけ、回答から除外する\nprint(dp[0]-1)\n#print(dp)",
"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 = 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 #dpにあるすべてのkey,valueに対して、\n #すでにdpにkeyがi+kのデータがあればそのvalue、なければ,0を返し、\n #それ+vをdpとする。\n \n # k=key\n # v=dp[key]のvalue\n for k,v in list(dp.items()):\n dp[i+k]=dp.get(i+k,0)+v\n \n #print(dp)\n\n#全部使わない選択肢だけ、回答から除外する",
"i",
"x",
"for k,v in list(dp.items()):\n dp[i+k]=dp.get(i+k,0)+v\n \n #print(dp)\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",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"x = list(map(lambda i: i-a, x))",
"list(map(lambda i: i-a, x))",
"x",
"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にしたい
n, a = map(int, input().split())
# 手持ちのカード
x = list(map(int, input().split()))
# aとの差を記録してリストに入れなおす
# 「選んだカードの xi の平均が A」であることは，
# 「選んだカードの (xi − A) の合計が 0」と言い換えることができる．
x = list(map(lambda i: i-a, x))
#print(x)
# dp初期値(辞書型)
# dp[0] = 1という意味
dp = {0: 1}
#xから1枚取り出す
for i in x:
#dpにあるすべてのkey,valueに対して、
#すでにdpにkeyがi+kのデータがあればそのvalue、なければ,0を返し、
#それ+vをdpとする。
# k=key
# v=dp[key]のvalue
for k,v in list(dp.items()):
dp[i+k]=dp.get(i+k,0)+v
#print(dp)
#全部使わない選択肢だけ、回答から除外する
print(dp[0]-1)
#print(dp) |
[
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,
28,
13,
4,
13,
2,
13,
17,
0,
18,
18,
18,
13,
13,
17,
17,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
17,
14,
40,
2,
13,
18,
13,
13,
17,
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,
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,
18,
13,
10,
4,
13,
10,
4,
13
] | [
[
164,
2
],
[
164,
11
],
[
167,
13
],
[
27,
26
],
[
155,
33
],
[
37,
36
],
[
165,
40
],
[
50,
43
],
[
156,
46
],
[
36,
47
],
[
53,
52
],
[
165,
55
],
[
58,
57
],
[
52,
62
],
[
66,
65
],
[
65,
73
],
[
168,
75
],
[
52,
76
],
[
88,
79
],
[
156,
82
],
[
52,
84
],
[
57,
86
],
[
65,
87
],
[
156,
92
],
[
52,
93
],
[
57,
95
],
[
65,
98
],
[
168,
100
],
[
52,
101
],
[
156,
105
],
[
52,
106
],
[
57,
107
],
[
65,
108
],
[
119,
110
],
[
156,
113
],
[
52,
115
],
[
57,
117
],
[
65,
118
],
[
156,
122
],
[
52,
123
],
[
57,
124
],
[
65,
125
],
[
158,
127
],
[
131,
130
],
[
165,
135
],
[
161,
138
],
[
156,
142
],
[
165,
143
],
[
130,
144
],
[
153,
146
],
[
130,
147
],
[
162,
150
],
[
159,
150
],
[
164,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
]
] | [
"n,a=map(int,input().split())\nx=list(map(int,input().split()))\ndp=[[[0]*(2501) for i in range(51)] for j in range(51)]\n#dp[i][j][k]は、i番目まででj枚とって総数kとなる取り方\nfor i in range(n+1):\n dp[i][0][0]=1\nfor i in range(n):\n for j in range(1,i+2):\n for k in range(1,2501):\n if k-x[i]>=0:\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]\nans=0\nfor j in range(1,n+1):\n ans+=dp[n][j][a*j]\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 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)]",
"for i in range(n+1):\n dp[i][0][0]=1",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"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(1,i+2):\n for k in range(1,2501):\n if k-x[i]>=0:\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]",
"i",
"range(n)",
"range",
"n",
"for j in range(1,i+2):\n for k in range(1,2501):\n if k-x[i]>=0:\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]",
"j",
"range(1,i+2)",
"range",
"1",
"i+2",
"i",
"2",
"for k in range(1,2501):\n if k-x[i]>=0:\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]",
"k",
"range(1,2501)",
"range",
"1",
"2501",
"if k-x[i]>=0:\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]",
"k-x[i]>=0",
"k-x[i]",
"k",
"x[i]",
"x",
"i",
"0",
"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",
"ans=0",
"ans",
"0",
"for j in range(1,n+1):\n ans+=dp[n][j][a*j]",
"j",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"ans+=dp[n][j][a*j]",
"ans",
"dp[n][j][a*j]",
"[j]",
"[n]",
"dp",
"n",
"j",
"a*j",
"a",
"j",
"print(ans)",
"print",
"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",
"ans=0",
"0",
"ans",
"ans+=dp[n][j][a*j]",
"dp[n][j][a*j]",
"ans",
"n,a=map(int,input().split())",
"map(int,input().split())",
"n",
"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]*(2501) for i in range(51)] for j in range(51)]
#dp[i][j][k]は、i番目まででj枚とって総数kとなる取り方
for i in range(n+1):
dp[i][0][0]=1
for i in range(n):
for j in range(1,i+2):
for k in range(1,2501):
if k-x[i]>=0:
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]
ans=0
for j in range(1,n+1):
ans+=dp[n][j][a*j]
print(ans) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
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,
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,
13,
4,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
4,
13,
18,
13,
39,
13,
17,
14,
2,
13,
13,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
2,
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,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
13,
2,
13,
13,
3,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
18,
13
] | [
[
190,
4
],
[
14,
13
],
[
191,
20
],
[
14,
22
],
[
25,
24
],
[
191,
33
],
[
37,
36
],
[
24,
39
],
[
43,
42
],
[
13,
46
],
[
52,
51
],
[
61,
54
],
[
51,
57
],
[
24,
67
],
[
71,
70
],
[
13,
74
],
[
78,
77
],
[
24,
84
],
[
77,
90
],
[
100,
93
],
[
51,
96
],
[
70,
98
],
[
77,
99
],
[
51,
103
],
[
70,
107
],
[
77,
108
],
[
70,
112
],
[
77,
115
],
[
125,
118
],
[
51,
121
],
[
70,
123
],
[
77,
124
],
[
51,
129
],
[
70,
133
],
[
77,
134
],
[
51,
138
],
[
70,
143
],
[
77,
146
],
[
150,
149
],
[
153,
152
],
[
13,
157
],
[
152,
161
],
[
36,
163
],
[
22,
164
],
[
168,
167
],
[
51,
171
],
[
13,
172
],
[
152,
173
],
[
152,
175
],
[
22,
176
],
[
167,
179
],
[
149,
179
],
[
188,
185
],
[
190,
191
]
] | [
"import sys\ninput = sys.stdin.readline\n\n\ndef main():\n n, a = map(int, input().split())\n x = tuple(map(int, input().split()))\n\n sm_mx = sum(x)\n\n dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n dp[0][0][0] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(n + 1):\n for sm in range(sum(x[:i]) + 1):\n if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ans = 0\n for i in range(1, n + 1):\n if i > sm_mx / a:\n break\n ans += dp[n][i][i*a]\n\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 n, a = map(int, input().split())\n x = tuple(map(int, input().split()))\n\n sm_mx = sum(x)\n\n dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n dp[0][0][0] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(n + 1):\n for sm in range(sum(x[:i]) + 1):\n if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ans = 0\n for i in range(1, n + 1):\n if i > sm_mx / a:\n break\n ans += dp[n][i][i*a]\n\n print(ans)",
"main",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"x = tuple(map(int, input().split()))",
"x",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sm_mx = sum(x)",
"sm_mx",
"sum(x)",
"sum",
"x",
"[[0] * (sm_mx + 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] * (sm_mx + 1) for _ in range(n + 1)]",
"dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]",
"dp",
"[[[0] * (sm_mx + 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, e in enumerate(x, 1):\n for j in range(n + 1):\n for sm in range(sum(x[:i]) + 1):\n if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ",
"i",
"e",
"enumerate(x, 1)",
"enumerate",
"x",
"1",
"for j in range(n + 1):\n for sm in range(sum(x[:i]) + 1):\n if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ",
"j",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for sm in range(sum(x[:i]) + 1):\n if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ",
"sm",
"range(sum(x[:i]) + 1)",
"range",
"sum(x[:i]) + 1",
"sum(x[:i])",
"sum",
"x[:i]",
"x",
":i",
"i",
"1",
"if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ",
"sm < e",
"sm",
"e",
"dp[i][j][sm] = dp[i-1][j][sm]",
"dp[i][j][sm]",
"[j]",
"[i]",
"dp",
"i",
"j",
"sm",
"dp[i-1][j][sm]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"sm",
"elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ",
"j >= 1 and sm >= e",
"j >= 1",
"j",
"1",
"sm >= e",
"sm",
"e",
"dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]",
"dp[i][j][sm]",
"[j]",
"[i]",
"dp",
"i",
"j",
"sm",
"dp[i-1][j][sm] + dp[i-1][j-1][sm-e]",
"dp[i-1][j][sm]",
"[j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"sm",
"dp[i-1][j-1][sm-e]",
"[j-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"sm-e",
"sm",
"e",
"ans = 0",
"ans",
"0",
"for i in range(1, n + 1):\n if i > sm_mx / a:\n break\n ans += dp[n][i][i*a]\n\n ",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"if i > sm_mx / a:\n break\n ",
"i > sm_mx / a",
"i",
"sm_mx / a",
"sm_mx",
"a",
"break",
"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",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n n, a = map(int, input().split())\n x = tuple(map(int, input().split()))\n\n sm_mx = sum(x)\n\n dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n dp[0][0][0] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(n + 1):\n for sm in range(sum(x[:i]) + 1):\n if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ans = 0\n for i in range(1, n + 1):\n if i > sm_mx / a:\n break\n ans += dp[n][i][i*a]\n\n print(ans)",
"def main():\n n, a = map(int, input().split())\n x = tuple(map(int, input().split()))\n\n sm_mx = sum(x)\n\n dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]\n\n dp[0][0][0] = 1\n\n for i, e in enumerate(x, 1):\n for j in range(n + 1):\n for sm in range(sum(x[:i]) + 1):\n if sm < e:\n dp[i][j][sm] = dp[i-1][j][sm]\n elif j >= 1 and sm >= e:\n dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]\n\n ans = 0\n for i in range(1, n + 1):\n if i > sm_mx / a:\n break\n ans += dp[n][i][i*a]\n\n print(ans)",
"main",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input"
] | import sys
input = sys.stdin.readline
def main():
n, a = map(int, input().split())
x = tuple(map(int, input().split()))
sm_mx = sum(x)
dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for i, e in enumerate(x, 1):
for j in range(n + 1):
for sm in range(sum(x[:i]) + 1):
if sm < e:
dp[i][j][sm] = dp[i-1][j][sm]
elif j >= 1 and sm >= e:
dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]
ans = 0
for i in range(1, n + 1):
if i > sm_mx / a:
break
ans += dp[n][i][i*a]
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,
13,
4,
13,
0,
13,
13,
0,
18,
18,
18,
13,
17,
17,
17,
17,
14,
40,
18,
13,
17,
2,
13,
13,
0,
18,
18,
18,
13,
17,
17,
18,
13,
17,
17,
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,
13,
17,
2,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
17,
14,
2,
13,
2,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
17,
14,
2,
40,
13,
18,
13,
2,
13,
17,
40,
13,
17,
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,
2,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
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,
2,
13,
17,
13,
2,
13,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
224,
2
],
[
224,
11
],
[
215,
13
],
[
27,
26
],
[
222,
29
],
[
218,
33
],
[
43,
36
],
[
219,
39
],
[
216,
47
],
[
225,
50
],
[
222,
51
],
[
62,
53
],
[
219,
56
],
[
216,
60
],
[
65,
64
],
[
222,
68
],
[
72,
71
],
[
222,
75
],
[
79,
78
],
[
225,
83
],
[
222,
84
],
[
71,
89
],
[
78,
92
],
[
104,
95
],
[
219,
98
],
[
64,
100
],
[
71,
102
],
[
78,
103
],
[
71,
107
],
[
64,
109
],
[
121,
112
],
[
219,
115
],
[
64,
117
],
[
71,
119
],
[
78,
120
],
[
78,
125
],
[
216,
127
],
[
64,
129
],
[
71,
132
],
[
144,
135
],
[
219,
138
],
[
64,
140
],
[
71,
142
],
[
78,
143
],
[
219,
148
],
[
64,
149
],
[
71,
150
],
[
78,
151
],
[
219,
155
],
[
64,
156
],
[
71,
158
],
[
78,
161
],
[
216,
163
],
[
64,
165
],
[
177,
168
],
[
219,
171
],
[
64,
173
],
[
71,
175
],
[
78,
176
],
[
219,
180
],
[
64,
181
],
[
71,
182
],
[
78,
183
],
[
227,
185
],
[
189,
188
],
[
222,
193
],
[
212,
196
],
[
219,
200
],
[
222,
202
],
[
188,
204
],
[
225,
206
],
[
188,
207
],
[
213,
210
],
[
228,
210
],
[
212,
213
],
[
215,
216
],
[
218,
219
],
[
224,
222
],
[
224,
225
],
[
227,
228
]
] | [
"N, A = map(int, input().split())\nx = list(map(int, input().split()))\n\n#dp[j][k][s] = (x0...xj からk枚選んでxiの合計をsにするような選び方の総数)\ndp = [[[0] * (A * N + 1) for k in range(N + 1)] for j in range(N)]\n\ndp[0][0][0] = 1\nif x[0] <= A * N:\n dp[0][1][x[0]] = 1\n\nfor j in range(N - 1):\n for k in range(N + 1):\n for s in range(A * N + 1):\n if k == 0 and s == 0:\n dp[j + 1][k][s] = 1\n elif k > j + 2:\n dp[j + 1][k][s] = 0\n elif s >= x[j + 1] and k >= 1:\n dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]\n else:\n dp[j + 1][k][s] = dp[j][k][s]\n\nres = 0\nfor i in range(1, N + 1):\n res += dp[N - 1][i][A * i]\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",
"[[0] * (A * N + 1) for k in range(N + 1)] for j in range(N)",
"for j in range(N)",
"j",
"range(N)",
"range",
"N",
"for j in range(N)",
"[[0] * (A * N + 1) for k in range(N + 1)]",
"dp = [[[0] * (A * N + 1) for k in range(N + 1)] for j in range(N)]",
"dp",
"[[[0] * (A * N + 1) for k in range(N + 1)] for j in range(N)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"if x[0] <= A * N:\n dp[0][1][x[0]] = 1",
"x[0] <= A * N",
"x[0]",
"x",
"0",
"A * N",
"A",
"N",
"dp[0][1][x[0]] = 1",
"dp[0][1][x[0]]",
"[1]",
"[0]",
"dp",
"0",
"1",
"x[0]",
"x",
"0",
"1",
"for j in range(N - 1):\n for k in range(N + 1):\n for s in range(A * N + 1):\n if k == 0 and s == 0:\n dp[j + 1][k][s] = 1\n elif k > j + 2:\n dp[j + 1][k][s] = 0\n elif s >= x[j + 1] and k >= 1:\n dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]\n else:\n dp[j + 1][k][s] = dp[j][k][s]",
"j",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"for k in range(N + 1):\n for s in range(A * N + 1):\n if k == 0 and s == 0:\n dp[j + 1][k][s] = 1\n elif k > j + 2:\n dp[j + 1][k][s] = 0\n elif s >= x[j + 1] and k >= 1:\n dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]\n else:\n dp[j + 1][k][s] = dp[j][k][s]",
"k",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"for s in range(A * N + 1):\n if k == 0 and s == 0:\n dp[j + 1][k][s] = 1\n elif k > j + 2:\n dp[j + 1][k][s] = 0\n elif s >= x[j + 1] and k >= 1:\n dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]\n else:\n dp[j + 1][k][s] = dp[j][k][s]",
"s",
"range(A * N + 1)",
"range",
"A * N + 1",
"A * N",
"A",
"N",
"1",
"if k == 0 and s == 0:\n dp[j + 1][k][s] = 1\n elif k > j + 2:\n dp[j + 1][k][s] = 0\n elif s >= x[j + 1] and k >= 1:\n dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]\n else:\n dp[j + 1][k][s] = dp[j][k][s]",
"k == 0 and s == 0",
"k == 0",
"k",
"0",
"s == 0",
"s",
"0",
"dp[j + 1][k][s] = 1",
"dp[j + 1][k][s]",
"[k]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"k",
"s",
"1",
"elif k > j + 2:\n dp[j + 1][k][s] = 0\n ",
"k > j + 2",
"k",
"j + 2",
"j",
"2",
"dp[j + 1][k][s] = 0",
"dp[j + 1][k][s]",
"[k]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"k",
"s",
"0",
"elif s >= x[j + 1] and k >= 1:\n dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]\n ",
"s >= x[j + 1] and k >= 1",
"s >= x[j + 1]",
"s",
"x[j + 1]",
"x",
"j + 1",
"j",
"1",
"k >= 1",
"k",
"1",
"dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]",
"dp[j + 1][k][s]",
"[k]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"k",
"s",
"dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"dp[j][k - 1][s - x[j + 1]]",
"[k - 1]",
"[j]",
"dp",
"j",
"k - 1",
"k",
"1",
"s - x[j + 1]",
"s",
"x[j + 1]",
"x",
"j + 1",
"j",
"1",
"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",
"res = 0",
"res",
"0",
"for i in range(1, N + 1):\n res += dp[N - 1][i][A * i]",
"i",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"res += dp[N - 1][i][A * i]",
"res",
"dp[N - 1][i][A * i]",
"[i]",
"[N - 1]",
"dp",
"N - 1",
"N",
"1",
"i",
"A * i",
"A",
"i",
"print(res)",
"print",
"res",
"res += dp[N - 1][i][A * i]",
"dp[N - 1][i][A * i]",
"res",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"dp = [[[0] * (A * N + 1) for k in range(N + 1)] for j in range(N)]",
"[[[0] * (A * N + 1) for k in range(N + 1)] for j in range(N)]",
"dp",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"res = 0",
"0",
"res"
] | N, A = map(int, input().split())
x = list(map(int, input().split()))
#dp[j][k][s] = (x0...xj からk枚選んでxiの合計をsにするような選び方の総数)
dp = [[[0] * (A * N + 1) for k in range(N + 1)] for j in range(N)]
dp[0][0][0] = 1
if x[0] <= A * N:
dp[0][1][x[0]] = 1
for j in range(N - 1):
for k in range(N + 1):
for s in range(A * N + 1):
if k == 0 and s == 0:
dp[j + 1][k][s] = 1
elif k > j + 2:
dp[j + 1][k][s] = 0
elif s >= x[j + 1] and k >= 1:
dp[j + 1][k][s] = dp[j][k][s] + dp[j][k - 1][s - x[j + 1]]
else:
dp[j + 1][k][s] = dp[j][k][s]
res = 0
for i in range(1, N + 1):
res += dp[N - 1][i][A * i]
print(res) |
[
7,
0,
13,
4,
18,
4,
13,
13,
17,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
0,
13,
4,
18,
4,
13,
13,
17,
41,
28,
13,
13,
4,
4,
13,
13,
0,
13,
13,
41,
28,
13,
13,
4,
2,
4,
13,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
4,
13,
2,
13,
39,
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,
2,
2,
17,
13,
13,
17,
14,
2,
2,
13,
17,
2,
13,
2,
13,
13,
0,
18,
18,
13,
13,
13,
17,
14,
2,
40,
13,
17,
2,
2,
2,
13,
18,
13,
2,
13,
17,
17,
2,
2,
13,
18,
13,
13,
2,
2,
17,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
14,
2,
40,
13,
17,
40,
40,
17,
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,
13,
0,
18,
18,
13,
13,
13,
17,
4,
13,
2,
18,
18,
13,
13,
2,
13,
13,
17,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
228,
2
],
[
228,
9
],
[
225,
11
],
[
223,
14
],
[
234,
15
],
[
229,
18
],
[
213,
20
],
[
30,
29
],
[
214,
29
],
[
29,
34
],
[
237,
36
],
[
41,
40
],
[
238,
40
],
[
214,
40
],
[
40,
46
],
[
235,
47
],
[
229,
47
],
[
216,
49
],
[
231,
55
],
[
238,
59
],
[
214,
59
],
[
65,
64
],
[
226,
68
],
[
223,
68
],
[
219,
73
],
[
77,
76
],
[
226,
80
],
[
223,
80
],
[
84,
83
],
[
226,
90
],
[
223,
90
],
[
232,
91
],
[
76,
96
],
[
83,
99
],
[
226,
101
],
[
223,
101
],
[
232,
102
],
[
109,
104
],
[
220,
106
],
[
76,
107
],
[
83,
108
],
[
76,
113
],
[
83,
118
],
[
217,
120
],
[
76,
122
],
[
83,
127
],
[
217,
129
],
[
76,
130
],
[
226,
134
],
[
223,
134
],
[
232,
135
],
[
142,
137
],
[
220,
139
],
[
76,
140
],
[
83,
141
],
[
220,
144
],
[
76,
146
],
[
83,
148
],
[
76,
152
],
[
83,
158
],
[
217,
160
],
[
76,
162
],
[
226,
167
],
[
223,
167
],
[
232,
168
],
[
175,
170
],
[
220,
172
],
[
76,
173
],
[
83,
174
],
[
220,
178
],
[
76,
180
],
[
83,
182
],
[
220,
185
],
[
76,
187
],
[
83,
190
],
[
217,
192
],
[
76,
193
],
[
200,
195
],
[
220,
197
],
[
76,
198
],
[
83,
199
],
[
220,
206
],
[
226,
207
],
[
223,
207
],
[
226,
209
],
[
223,
209
],
[
232,
210
],
[
213,
214
],
[
216,
217
],
[
219,
220
],
[
228,
223
],
[
225,
226
],
[
228,
229
],
[
231,
232
],
[
234,
235
],
[
237,
238
]
] | [
"N, A = input().split(\" \")\nN, A = int(N), int(A)\nx = input().split(\" \")\nx = [int(i) for i in x]\ny = [0]+[int(i)-A for i in x]\nX = max(x+[A])\n\ndp = [[0 for t in range(2*N*X+1)] for j in range(N+1)]\n\nfor j in range(N+1):\n for t in range(2*N*X+1):\n if j == 0 and t == N*X: # 0枚の時は0しか達成できない\n dp[j][t] = 1\n elif j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X): # xの値が平均Aを超えてしまう場合は、前回の結果から場合の総数に変化なし\n dp[j][t] = dp[j-1][t]\n elif j >= 1 and 0 <= t-y[j-1] <= 2*N*X: # 前回の場合の総数に、今回の数を足して0になる場合の総数を足す\n dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]\n else:\n dp[j][t] = 0\nprint(dp[N][N*X] - 1)",
"N, A = input().split(\" \")",
"N",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"A",
"N, A = int(N), int(A)",
"N",
"int(N)",
"int",
"N",
"A",
"int(A)",
"int",
"A",
"x = input().split(\" \")",
"x",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"int(i) for i in x",
"for i in x",
"i",
"x",
"for i in x",
"int(i)",
"int",
"i",
"x = [int(i) for i in x]",
"x",
"[int(i) for i in x]",
"int(i)-A for i in x",
"for i in x",
"i",
"x",
"for i in x",
"int(i)-A",
"int(i)",
"int",
"i",
"A",
"y = [0]+[int(i)-A for i in x]",
"y",
"[0]+[int(i)-A for i in x]",
"[0]",
"0",
"[int(i)-A for i in x]",
"X = max(x+[A])",
"X",
"max(x+[A])",
"max",
"x+[A]",
"x",
"[A]",
"A",
"[0 for t in range(2*N*X+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 t in range(2*N*X+1)]",
"dp = [[0 for t in range(2*N*X+1)] for j in range(N+1)]",
"dp",
"[[0 for t in range(2*N*X+1)] for j in range(N+1)]",
"for j in range(N+1):\n for t in range(2*N*X+1):\n if j == 0 and t == N*X: # 0枚の時は0しか達成できない\n dp[j][t] = 1\n elif j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X): # xの値が平均Aを超えてしまう場合は、前回の結果から場合の総数に変化なし\n dp[j][t] = dp[j-1][t]\n elif j >= 1 and 0 <= t-y[j-1] <= 2*N*X: # 前回の場合の総数に、今回の数を足して0になる場合の総数を足す\n dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]\n else:\n dp[j][t] = 0",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for t in range(2*N*X+1):\n if j == 0 and t == N*X: # 0枚の時は0しか達成できない\n dp[j][t] = 1\n elif j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X): # xの値が平均Aを超えてしまう場合は、前回の結果から場合の総数に変化なし\n dp[j][t] = dp[j-1][t]\n elif j >= 1 and 0 <= t-y[j-1] <= 2*N*X: # 前回の場合の総数に、今回の数を足して0になる場合の総数を足す\n dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]\n else:\n dp[j][t] = 0",
"t",
"range(2*N*X+1)",
"range",
"2*N*X+1",
"2*N*X",
"2*N",
"2",
"N",
"X",
"1",
"if j == 0 and t == N*X: # 0枚の時は0しか達成できない\n dp[j][t] = 1\n elif j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X): # xの値が平均Aを超えてしまう場合は、前回の結果から場合の総数に変化なし\n dp[j][t] = dp[j-1][t]\n elif j >= 1 and 0 <= t-y[j-1] <= 2*N*X: # 前回の場合の総数に、今回の数を足して0になる場合の総数を足す\n dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]\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 j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X): # xの値が平均Aを超えてしまう場合は、前回の結果から場合の総数に変化なし\n dp[j][t] = dp[j-1][t]\n ",
"j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X)",
"j >= 1",
"j",
"1",
"t - y[j-1] < 0 or t-y[j] > 2*N*X",
"t - y[j-1] < 0",
"t - y[j-1]",
"t",
"y[j-1]",
"y",
"j-1",
"j",
"1",
"0",
"t-y[j] > 2*N*X",
"t-y[j]",
"t",
"y[j]",
"y",
"j",
"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 j >= 1 and 0 <= t-y[j-1] <= 2*N*X: # 前回の場合の総数に、今回の数を足して0になる場合の総数を足す\n dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]\n ",
"j >= 1 and 0 <= t-y[j-1] <= 2*N*X",
"j >= 1",
"j",
"1",
"0 <= t-y[j-1] <= 2*N*X",
"0 <= t-y[j-1]",
"0",
"t-y[j-1]",
"t",
"y[j-1]",
"y",
"j-1",
"j",
"1",
"2*N*X",
"2*N",
"2",
"N",
"X",
"dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]",
"dp[j][t]",
"[j]",
"dp",
"j",
"t",
"dp[j-1][t] + dp[j-1][t-y[j]]",
"dp[j-1][t]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"t",
"dp[j-1][t-y[j]]",
"[j-1]",
"dp",
"j-1",
"j",
"1",
"t-y[j]",
"t",
"y[j]",
"y",
"j",
"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 = input().split(\" \")",
"input().split(\" \")",
"x",
"y = [0]+[int(i)-A for i in x]",
"[0]+[int(i)-A for i in x]",
"y",
"dp = [[0 for t in range(2*N*X+1)] for j in range(N+1)]",
"[[0 for t in range(2*N*X+1)] for j in range(N+1)]",
"dp",
"N, A = input().split(\" \")",
"input().split(\" \")",
"N",
"N, A = int(N), int(A)",
"int(N)",
"N",
"A = input().split(\" \")",
"input().split(\" \")",
"A",
"X = max(x+[A])",
"max(x+[A])",
"X",
"A = int(N), int(A)",
"int(A)",
"A",
"x = [int(i) for i in x]",
"[int(i) for i in x]",
"x"
] | N, A = input().split(" ")
N, A = int(N), int(A)
x = input().split(" ")
x = [int(i) for i in x]
y = [0]+[int(i)-A for i in x]
X = max(x+[A])
dp = [[0 for t in range(2*N*X+1)] for j in range(N+1)]
for j in range(N+1):
for t in range(2*N*X+1):
if j == 0 and t == N*X: # 0枚の時は0しか達成できない
dp[j][t] = 1
elif j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X): # xの値が平均Aを超えてしまう場合は、前回の結果から場合の総数に変化なし
dp[j][t] = dp[j-1][t]
elif j >= 1 and 0 <= t-y[j-1] <= 2*N*X: # 前回の場合の総数に、今回の数を足して0になる場合の総数を足す
dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]
else:
dp[j][t] = 0
print(dp[N][N*X] - 1) |
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
21,
22,
17,
17,
28,
13,
2,
13,
13,
28,
13,
13,
4,
18,
4,
18,
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,
21,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
84,
4
],
[
84,
13
],
[
78,
15
],
[
75,
31
],
[
38,
37
],
[
79,
39
],
[
82,
40
],
[
76,
48
],
[
57,
52
],
[
76,
53
],
[
37,
55
],
[
76,
60
],
[
37,
63
],
[
76,
71
],
[
75,
76
],
[
78,
79
],
[
84,
82
],
[
84,
85
]
] | [
"import numpy as np\n \nn, a = map(int, input().split())\nx = np.array(list(map(int, input().split())))\n \ndp = {0:1}\nfor y in x-a:\n for k, v in dp.copy().items():\n dp[y+k] = dp.get(y+k, 0) + v \nprint(dp[0]-1)",
"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 = np.array(list(map(int, input().split())))",
"x",
"np.array(list(map(int, input().split())))",
"np.array",
"np",
"array",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"dp = {0:1}",
"dp",
"{0:1}",
"0",
"0",
"1",
"for y in x-a:\n for k, v in dp.copy().items():\n dp[y+k] = dp.get(y+k, 0) + v ",
"y",
"x-a",
"x",
"a",
"for k, v in dp.copy().items():\n dp[y+k] = dp.get(y+k, 0) + v ",
"k",
"v",
"dp.copy().items()",
"dp.copy().items",
"dp.copy()",
"dp.copy",
"dp",
"copy",
"items",
"dp[y+k] = dp.get(y+k, 0) + v",
"dp[y+k]",
"dp",
"y+k",
"y",
"k",
"dp.get(y+k, 0) + v",
"dp.get(y+k, 0)",
"dp.get",
"dp",
"get",
"y+k",
"y",
"k",
"0",
"v",
"print(dp[0]-1)",
"print",
"dp[0]-1",
"dp[0]",
"dp",
"0",
"1",
"dp = {0:1}",
"{0:1}",
"dp",
"x = np.array(list(map(int, input().split())))",
"np.array(list(map(int, input().split())))",
"x",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n"
] | import numpy as np
n, a = map(int, input().split())
x = np.array(list(map(int, input().split())))
dp = {0:1}
for y in x-a:
for k, v in dp.copy().items():
dp[y+k] = dp.get(y+k, 0) + v
print(dp[0]-1)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
12,
4,
13,
13,
23,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
12,
4,
13,
13,
23,
4,
18,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
4,
13,
4,
13,
4,
13,
13,
4,
13,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
39,
2,
13,
17,
2,
2,
17,
13,
17,
0,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
2,
17,
13,
17,
14,
40,
40,
17,
2,
13,
18,
13,
2,
13,
17,
2,
17,
13,
0,
18,
13,
13,
2,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
0,
18,
13,
13,
18,
13,
2,
13,
17,
4,
13,
2,
18,
13,
13,
17,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
159,
4
],
[
159,
19
],
[
150,
21
],
[
162,
37
],
[
151,
42
],
[
153,
44
],
[
163,
46
],
[
151,
46
],
[
160,
47
],
[
168,
49
],
[
154,
57
],
[
163,
57
],
[
151,
57
],
[
154,
62
],
[
163,
62
],
[
151,
62
],
[
157,
63
],
[
165,
65
],
[
157,
72
],
[
169,
77
],
[
81,
80
],
[
86,
83
],
[
166,
84
],
[
89,
88
],
[
157,
93
],
[
97,
96
],
[
169,
102
],
[
96,
109
],
[
154,
111
],
[
163,
111
],
[
151,
111
],
[
88,
113
],
[
169,
117
],
[
122,
119
],
[
166,
120
],
[
88,
121
],
[
166,
124
],
[
88,
126
],
[
166,
129
],
[
88,
131
],
[
137,
134
],
[
166,
135
],
[
88,
136
],
[
166,
138
],
[
88,
140
],
[
166,
146
],
[
157,
147
],
[
150,
151
],
[
153,
154
],
[
159,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
],
[
168,
169
]
] | [
"import numpy as np\nn,avea=tuple(map(lambda x:int(x),input().split()))\nx=list(map(lambda x:int(x), input().split()))\nx=np.array(x)\nx=x-avea\nw=max(abs(min(x)),abs(max(x)))*n\ndp=np.zeros((n+1,2*w+1),dtype=int)\ndp[0,w]=1\nfor i in range(1,n+1):\n for j in range(2*w+1):\n if 0<=j-x[i-1]<=2*w:\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]\nprint(dp[n,w]-1)",
"import numpy as np",
"numpy",
"n,avea=tuple(map(lambda x:int(x),input().split()))",
"n",
"tuple(map(lambda x:int(x),input().split()))",
"tuple",
"map(lambda x:int(x),input().split())",
"map",
"lambda x:int(x)",
"int(x)",
"int",
"x",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"avea",
"x=list(map(lambda x:int(x), input().split()))",
"x",
"list(map(lambda x:int(x), input().split()))",
"list",
"map(lambda x:int(x), input().split())",
"map",
"lambda x:int(x)",
"int(x)",
"int",
"x",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"x=np.array(x)",
"x",
"np.array(x)",
"np.array",
"np",
"array",
"x",
"x=x-avea",
"x",
"x-avea",
"x",
"avea",
"w=max(abs(min(x)),abs(max(x)))*n",
"w",
"max(abs(min(x)),abs(max(x)))*n",
"max(abs(min(x)),abs(max(x)))",
"max",
"abs(min(x))",
"abs",
"min(x)",
"min",
"x",
"abs(max(x))",
"abs",
"max(x)",
"max",
"x",
"n",
"dp=np.zeros((n+1,2*w+1),dtype=int)",
"dp",
"np.zeros((n+1,2*w+1),dtype=int)",
"np.zeros",
"np",
"zeros",
"(n+1,2*w+1)",
"n+1",
"n",
"1",
"2*w+1",
"2*w",
"2",
"w",
"1",
"dtype=int",
"dtype",
"int",
"dp[0,w]=1",
"dp[0,w]",
"dp",
"0",
"1",
"for i in range(1,n+1):\n for j in range(2*w+1):\n if 0<=j-x[i-1]<=2*w:\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]",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"for j in range(2*w+1):\n if 0<=j-x[i-1]<=2*w:\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]",
"j",
"range(2*w+1)",
"range",
"2*w+1",
"2*w",
"2",
"w",
"1",
"if 0<=j-x[i-1]<=2*w:\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]",
"0<=j-x[i-1]<=2*w",
"0<=j-x[i-1]",
"0",
"j-x[i-1]",
"j",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"2*w",
"2",
"w",
"dp[i,j]=dp[i-1,j]+dp[i-1,j-x[i-1]]",
"dp[i,j]",
"dp",
"i",
"dp[i-1,j]+dp[i-1,j-x[i-1]]",
"dp[i-1,j]",
"dp",
"i-1",
"i",
"1",
"dp[i-1,j-x[i-1]]",
"dp",
"i-1",
"i",
"1",
"dp[i,j]=dp[i-1,j]",
"dp[i,j]",
"dp",
"i",
"dp[i-1,j]",
"dp",
"i-1",
"i",
"1",
"print(dp[n,w]-1)",
"print",
"dp[n,w]-1",
"dp[n,w]",
"dp",
"n",
"1",
"x=list(map(lambda x:int(x), input().split()))",
"list(map(lambda x:int(x), input().split()))",
"x",
"x=x-avea",
"x-avea",
"x",
"n,avea=tuple(map(lambda x:int(x),input().split()))",
"tuple(map(lambda x:int(x),input().split()))",
"n",
"avea=tuple(map(lambda x:int(x),input().split()))",
"tuple(map(lambda x:int(x),input().split()))",
"avea",
"x=np.array(x)",
"np.array(x)",
"x",
"dp=np.zeros((n+1,2*w+1),dtype=int)",
"np.zeros((n+1,2*w+1),dtype=int)",
"dp",
"w=max(abs(min(x)),abs(max(x)))*n",
"max(abs(min(x)),abs(max(x)))*n",
"w"
] | import numpy as np
n,avea=tuple(map(lambda x:int(x),input().split()))
x=list(map(lambda x:int(x), input().split()))
x=np.array(x)
x=x-avea
w=max(abs(min(x)),abs(max(x)))*n
dp=np.zeros((n+1,2*w+1),dtype=int)
dp[0,w]=1
for i in range(1,n+1):
for j in range(2*w+1):
if 0<=j-x[i-1]<=2*w:
dp[i,j]=dp[i-1,j]+dp[i-1,j-x[i-1]]
else:
dp[i,j]=dp[i-1,j]
print(dp[n,w]-1)
|
[
7,
15,
13,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
31,
13,
12,
13,
0,
13,
4,
18,
13,
13,
39,
2,
13,
17,
17,
0,
13,
18,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
13,
0,
18,
13,
39,
17,
4,
18,
18,
13,
39,
17,
13,
0,
13,
4,
18,
13,
13,
17,
2,
13,
17,
4,
13,
4,
18,
18,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13
] | [
[
90,
6
],
[
90,
19
],
[
90,
20
],
[
26,
25
],
[
88,
32
],
[
37,
36
],
[
44,
41
],
[
25,
42
],
[
47,
46
],
[
88,
49
],
[
55,
51
],
[
25,
52
],
[
25,
58
],
[
64,
63
],
[
88,
70
],
[
25,
77
],
[
63,
78
],
[
94,
85
],
[
90,
88
],
[
90,
91
]
] | [
"import sys\nimport numpy as np\n\nn, a, *x = map(int, sys.stdin.read().split())\n\ndef main():\n dp = np.zeros((n + 1, 2501), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n dp[1:, x[i]:] += dp[:-1, :-x[i]].copy()\n i = np.arange(1, n + 1)\n print(dp[i, i * a].sum())\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"import numpy as np",
"numpy",
"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 dp = np.zeros((n + 1, 2501), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n dp[1:, x[i]:] += dp[:-1, :-x[i]].copy()\n i = np.arange(1, n + 1)\n print(dp[i, i * a].sum())",
"main",
"dp = np.zeros((n + 1, 2501), dtype=np.int64)",
"dp",
"np.zeros((n + 1, 2501), dtype=np.int64)",
"np.zeros",
"np",
"zeros",
"(n + 1, 2501)",
"n + 1",
"n",
"1",
"2501",
"dtype=np.int64",
"dtype",
"np.int64",
"np",
"int64",
"dp[0, 0] = 1",
"dp[0, 0]",
"dp",
"0",
"1",
"for i in range(n):\n dp[1:, x[i]:] += dp[:-1, :-x[i]].copy()\n ",
"i",
"range(n)",
"range",
"n",
"dp[1:, x[i]:] += dp[:-1, :-x[i]].copy()",
"dp[1:, x[i]:]",
"dp",
"1:",
"1",
"dp[:-1, :-x[i]].copy()",
"[:-1, :-x[i]].copy",
"[:-1, :-x[i]]",
"dp",
":-1",
"-1",
"copy",
"i = np.arange(1, n + 1)",
"i",
"np.arange(1, n + 1)",
"np.arange",
"np",
"arange",
"1",
"n + 1",
"n",
"1",
"print(dp[i, i * a].sum())",
"print",
"dp[i, i * a].sum()",
"[i, i * a].sum",
"[i, i * a]",
"dp",
"i",
"sum",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"n, a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"n",
"a, *x = map(int, sys.stdin.read().split())",
"map(int, sys.stdin.read().split())",
"a",
"def main():\n dp = np.zeros((n + 1, 2501), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n dp[1:, x[i]:] += dp[:-1, :-x[i]].copy()\n i = np.arange(1, n + 1)\n print(dp[i, i * a].sum())",
"def main():\n dp = np.zeros((n + 1, 2501), dtype=np.int64)\n dp[0, 0] = 1\n for i in range(n):\n dp[1:, x[i]:] += dp[:-1, :-x[i]].copy()\n i = np.arange(1, n + 1)\n print(dp[i, i * a].sum())",
"main"
] | import sys
import numpy as np
n, a, *x = map(int, sys.stdin.read().split())
def main():
dp = np.zeros((n + 1, 2501), dtype=np.int64)
dp[0, 0] = 1
for i in range(n):
dp[1:, x[i]:] += dp[:-1, :-x[i]].copy()
i = np.arange(1, n + 1)
print(dp[i, i * a].sum())
if __name__ == '__main__':
main() |
[
7,
17,
15,
13,
0,
13,
18,
18,
13,
13,
13,
15,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
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,
0,
18,
18,
18,
13,
13,
17,
17,
17,
28,
13,
13,
13,
4,
13,
4,
13,
13,
4,
13,
17,
2,
13,
17,
4,
13,
2,
13,
17,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
2,
18,
18,
18,
13,
13,
13,
13,
8,
2,
2,
13,
18,
13,
13,
17,
17,
18,
18,
18,
13,
13,
2,
13,
17,
2,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
13,
13,
14,
40,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
4,
13,
13,
17,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
13,
13
] | [
[
174,
5
],
[
175,
23
],
[
180,
26
],
[
184,
28
],
[
180,
29
],
[
162,
31
],
[
184,
33
],
[
171,
35
],
[
163,
38
],
[
42,
41
],
[
181,
45
],
[
189,
50
],
[
54,
53
],
[
181,
57
],
[
67,
60
],
[
190,
63
],
[
53,
64
],
[
181,
76
],
[
181,
81
],
[
172,
86
],
[
98,
89
],
[
190,
92
],
[
190,
102
],
[
163,
111
],
[
190,
118
],
[
163,
126
],
[
186,
129
],
[
133,
132
],
[
181,
137
],
[
165,
140
],
[
132,
142
],
[
178,
143
],
[
166,
146
],
[
172,
147
],
[
168,
149
],
[
190,
153
],
[
181,
154
],
[
132,
155
],
[
166,
156
],
[
169,
159
],
[
187,
159
],
[
162,
163
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
180,
178
],
[
180,
181
],
[
186,
187
],
[
189,
190
]
] | [
"# https://atcoder.jp/contests/abc044/tasks/arc060_a\n# ソートしてからごちゃごちゃやればどうにかなりそう(無理でした)\n\n'''\n解説満点解法1\nもしもk枚選んだとき、合計がsになる通りの数がわかったら？→s=k*Aとなる場合の数の合計をすれば良い\n\nk枚選んだとき、合計がsになる通りの数は典型的なDP！\ndp(j,k,s)... X[0:j]からk枚選んで、その合計をsにするような選び方の総数\nと定義すると、\ndp(j+1,k,s) = X[j]を選んだ結果sになったときの通りの数 + X[j]を選ばずにsになっている通りの数 なので\ndp(j+1,k,s) = dp(j,k-1,s-X[j]) + dp(j,k,s)\n\nあとは初期条件と境界条件と伝播条件を付け加える。\n境界条件 dp(j,k,0)=0 (数枚選んで合計が0になるのはありえない)\n初期条件 dp(j,0,0)=1 (ただし、0枚選んだときは1通りとなる)(s-X[j]=0のときに1通りとなってほしいという気持ちもある)\n\n伝播条件 s-X[j]<0に関しては dp(j-1,k-1,s-X[j])が必ず0通りとなる(ありえないので)\n'''\n\nimport sys\nread = sys.stdin.readline\nfrom itertools import product\n\n\ndef read_ints():\n return list(map(int, read().split()))\n\n\nN, A = read_ints()\nX = read_ints()\nS = sum(X)\n\n# 満点解法1\ndp = [[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]\nfor j in range(N + 1): # 初期条件\n dp[j][0][0] = 1 # 1枚も選ばずに0になるのは1通り\n\n\nfor j, k, s in product(range(N), range(1, N + 1), range(S + 1)):\n dp[j + 1][k][s] = dp[j][k][s] + \\\n (0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]])\n\n# s=k*Aとなるような通りの数の総数\nans = 0\nfor k in range(1, N + 1): # 0個はとる通りの数はいらない\n s = k * A\n if s <= S:\n ans += dp[N][k][s]\n\n# print(dp)\nprint(ans)\n\n\n'''\n満点解法2\n\n\n'''",
"'''\n解説満点解法1\nもしもk枚選んだとき、合計がsになる通りの数がわかったら？→s=k*Aとなる場合の数の合計をすれば良い\n\nk枚選んだとき、合計がsになる通りの数は典型的なDP！\ndp(j,k,s)... X[0:j]からk枚選んで、その合計をsにするような選び方の総数\nと定義すると、\ndp(j+1,k,s) = X[j]を選んだ結果sになったときの通りの数 + X[j]を選ばずにsになっている通りの数 なので\ndp(j+1,k,s) = dp(j,k-1,s-X[j]) + dp(j,k,s)\n\nあとは初期条件と境界条件と伝播条件を付け加える。\n境界条件 dp(j,k,0)=0 (数枚選んで合計が0になるのはありえない)\n初期条件 dp(j,0,0)=1 (ただし、0枚選んだときは1通りとなる)(s-X[j]=0のときに1通りとなってほしいという気持ちもある)\n\n伝播条件 s-X[j]<0に関しては dp(j-1,k-1,s-X[j])が必ず0通りとなる(ありえないので)\n'''",
"import sys",
"sys",
"read = sys.stdin.readline",
"read",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"from itertools import product",
"def read_ints():\n return list(map(int, read().split()))",
"read_ints",
"return list(map(int, read().split()))",
"list(map(int, read().split()))",
"list",
"map(int, read().split())",
"map",
"int",
"read().split()",
"().split",
"()",
"read",
"split",
"N, A = read_ints()",
"N",
"read_ints()",
"read_ints",
"A",
"X = read_ints()",
"X",
"read_ints()",
"read_ints",
"S = sum(X)",
"S",
"sum(X)",
"sum",
"X",
"[[0] * (S + 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] * (S + 1) for _ in range(N + 1)]",
"dp = [[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"dp",
"[[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"for j in range(N + 1): # 初期条件\n dp[j][0][0] = 1 # 1枚も選ばずに0になるのは1通り",
"j",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"dp[j][0][0] = 1",
"dp[j][0][0]",
"[0]",
"[j]",
"dp",
"j",
"0",
"0",
"1",
"for j, k, s in product(range(N), range(1, N + 1), range(S + 1)):\n dp[j + 1][k][s] = dp[j][k][s] + \\\n (0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]])\n\n# s=k*Aとなるような通りの数の総数",
"j",
"k",
"s",
"product(range(N), range(1, N + 1), range(S + 1))",
"product",
"range(N)",
"range",
"N",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"range(S + 1)",
"range",
"S + 1",
"S",
"1",
"dp[j + 1][k][s] = dp[j][k][s] + \\\n (0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]])",
"dp[j + 1][k][s]",
"[k]",
"[j + 1]",
"dp",
"j + 1",
"j",
"1",
"k",
"s",
"dp[j][k][s] + \\\n (0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]])",
"dp[j][k][s]",
"[k]",
"[j]",
"dp",
"j",
"k",
"s",
"0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]]",
"s - X[j] < 0",
"s - X[j]",
"s",
"X[j]",
"X",
"j",
"0",
"0",
"dp[j][k - 1][s - X[j]]",
"[k - 1]",
"[j]",
"dp",
"j",
"k - 1",
"k",
"1",
"s - X[j]",
"s",
"X[j]",
"X",
"j",
"ans = 0",
"ans",
"0",
"for k in range(1, N + 1): # 0個はとる通りの数はいらない\n s = k * A\n if s <= S:\n ans += dp[N][k][s]\n\n# print(dp)",
"k",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"s = k * A",
"s",
"k * A",
"k",
"A",
"if s <= S:\n ans += dp[N][k][s]\n\n# print(dp)",
"s <= S",
"s",
"S",
"ans += dp[N][k][s]",
"ans",
"dp[N][k][s]",
"[k]",
"[N]",
"dp",
"N",
"k",
"s",
"print(ans)",
"print",
"ans",
"'''\n満点解法2\n\n\n'''",
"X = read_ints()",
"read_ints()",
"X",
"s = k * A",
"k * A",
"s",
"ans += dp[N][k][s]",
"dp[N][k][s]",
"ans",
"S = sum(X)",
"sum(X)",
"S",
"read = sys.stdin.readline",
"sys.stdin.readline",
"read",
"A = read_ints()",
"read_ints()",
"A",
"N, A = read_ints()",
"read_ints()",
"N",
"def read_ints():\n return list(map(int, read().split()))",
"def read_ints():\n return list(map(int, read().split()))",
"read_ints",
"ans = 0",
"0",
"ans",
"dp = [[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"[[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]",
"dp"
] | # https://atcoder.jp/contests/abc044/tasks/arc060_a
# ソートしてからごちゃごちゃやればどうにかなりそう(無理でした)
'''
解説満点解法1
もしもk枚選んだとき、合計がsになる通りの数がわかったら？→s=k*Aとなる場合の数の合計をすれば良い
k枚選んだとき、合計がsになる通りの数は典型的なDP！
dp(j,k,s)... X[0:j]からk枚選んで、その合計をsにするような選び方の総数
と定義すると、
dp(j+1,k,s) = X[j]を選んだ結果sになったときの通りの数 + X[j]を選ばずにsになっている通りの数 なので
dp(j+1,k,s) = dp(j,k-1,s-X[j]) + dp(j,k,s)
あとは初期条件と境界条件と伝播条件を付け加える。
境界条件 dp(j,k,0)=0 (数枚選んで合計が0になるのはありえない)
初期条件 dp(j,0,0)=1 (ただし、0枚選んだときは1通りとなる)(s-X[j]=0のときに1通りとなってほしいという気持ちもある)
伝播条件 s-X[j]<0に関しては dp(j-1,k-1,s-X[j])が必ず0通りとなる(ありえないので)
'''
import sys
read = sys.stdin.readline
from itertools import product
def read_ints():
return list(map(int, read().split()))
N, A = read_ints()
X = read_ints()
S = sum(X)
# 満点解法1
dp = [[[0] * (S + 1) for _ in range(N + 1)] for _ in range(N + 1)]
for j in range(N + 1): # 初期条件
dp[j][0][0] = 1 # 1枚も選ばずに0になるのは1通り
for j, k, s in product(range(N), range(1, N + 1), range(S + 1)):
dp[j + 1][k][s] = dp[j][k][s] + \
(0 if s - X[j] < 0 else dp[j][k - 1][s - X[j]])
# s=k*Aとなるような通りの数の総数
ans = 0
for k in range(1, N + 1): # 0個はとる通りの数はいらない
s = k * A
if s <= S:
ans += dp[N][k][s]
# print(dp)
print(ans)
'''
満点解法2
'''
|
[
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,
17,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
14,
40,
13,
17,
0,
13,
13,
0,
13,
13,
28,
13,
4,
13,
13,
2,
13,
17,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
2,
13,
17,
13,
4,
13,
2,
18,
18,
13,
13,
17,
17,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13
] | [
[
141,
2
],
[
141,
11
],
[
138,
13
],
[
26,
25
],
[
133,
28
],
[
33,
30
],
[
139,
31
],
[
25,
32
],
[
142,
33
],
[
37,
36
],
[
133,
40
],
[
144,
45
],
[
53,
48
],
[
145,
50
],
[
126,
55
],
[
129,
58
],
[
62,
61
],
[
133,
66
],
[
135,
69
],
[
139,
71
],
[
61,
73
],
[
136,
77
],
[
147,
80
],
[
136,
81
],
[
150,
83
],
[
136,
84
],
[
87,
86
],
[
148,
89
],
[
130,
89
],
[
151,
91
],
[
127,
91
],
[
99,
94
],
[
145,
96
],
[
61,
97
],
[
86,
98
],
[
145,
102
],
[
61,
104
],
[
86,
107
],
[
136,
108
],
[
145,
111
],
[
61,
113
],
[
86,
115
],
[
145,
121
],
[
133,
122
],
[
126,
127
],
[
129,
130
],
[
141,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
],
[
136,
147
],
[
147,
148
],
[
136,
150
],
[
150,
151
]
] | [
"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(5001)] for i in range(N+1)]\ndp[0][2500] = 1\nu = 2500\nd = 2500\nfor i in range(1,N+1):\n x = X[i-1]\n if x <= 0:\n d += x\n else:\n u += x\n for j in range(d,u+1):\n dp[i][j] += dp[i-1][j-x] + dp[i-1][j]\nprint(dp[N][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",
"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(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 for i in range(5001)]",
"dp = [[0 for i in range(5001)] for i in range(N+1)]",
"dp",
"[[0 for i in range(5001)] for i in range(N+1)]",
"dp[0][2500] = 1",
"dp[0][2500]",
"[0]",
"dp",
"0",
"2500",
"1",
"u = 2500",
"u",
"2500",
"d = 2500",
"d",
"2500",
"for i in range(1,N+1):\n x = X[i-1]\n if x <= 0:\n d += x\n else:\n u += x\n for j in range(d,u+1):\n dp[i][j] += dp[i-1][j-x] + dp[i-1][j]",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"x = X[i-1]",
"x",
"X[i-1]",
"X",
"i-1",
"i",
"1",
"if x <= 0:\n d += x\n else:\n u += x\n ",
"x <= 0",
"x",
"0",
"d += x",
"d",
"x",
"u += x",
"u",
"x",
"for j in range(d,u+1):\n dp[i][j] += dp[i-1][j-x] + dp[i-1][j]",
"j",
"range(d,u+1)",
"range",
"d",
"u+1",
"u",
"1",
"dp[i][j] += dp[i-1][j-x] + dp[i-1][j]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j-x] + dp[i-1][j]",
"dp[i-1][j-x]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-x",
"j",
"x",
"dp[i-1][j]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j",
"print(dp[N][2500]-1)",
"print",
"dp[N][2500]-1",
"dp[N][2500]",
"[N]",
"dp",
"N",
"2500",
"1",
"u = 2500",
"2500",
"u",
"d = 2500",
"2500",
"d",
"N,A = map(int,input().split())",
"map(int,input().split())",
"N",
"x = X[i-1]",
"X[i-1]",
"x",
"X = list(map(int,input().split()))",
"list(map(int,input().split()))",
"X",
"A = map(int,input().split())",
"map(int,input().split())",
"A",
"dp = [[0 for i in range(5001)] for i in range(N+1)]",
"[[0 for i in range(5001)] for i in range(N+1)]",
"dp",
"d += x",
"x",
"d",
"u += x",
"x",
"u"
] | 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(5001)] for i in range(N+1)]
dp[0][2500] = 1
u = 2500
d = 2500
for i in range(1,N+1):
x = X[i-1]
if x <= 0:
d += x
else:
u += x
for j in range(d,u+1):
dp[i][j] += dp[i-1][j-x] + dp[i-1][j]
print(dp[N][2500]-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,
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,
17,
13,
14,
2,
18,
18,
18,
13,
13,
13,
13,
17,
9,
0,
18,
18,
18,
13,
2,
13,
17,
2,
13,
17,
2,
13,
18,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
18,
18,
18,
13,
13,
2,
13,
17,
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,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
155,
2
],
[
155,
11
],
[
149,
13
],
[
27,
26
],
[
147,
30
],
[
143,
35
],
[
45,
38
],
[
144,
41
],
[
48,
47
],
[
147,
50
],
[
53,
52
],
[
147,
55
],
[
58,
57
],
[
147,
62
],
[
144,
68
],
[
52,
69
],
[
47,
70
],
[
57,
71
],
[
90,
75
],
[
144,
78
],
[
52,
80
],
[
47,
83
],
[
57,
86
],
[
150,
88
],
[
47,
89
],
[
144,
93
],
[
52,
94
],
[
47,
95
],
[
57,
96
],
[
107,
98
],
[
144,
101
],
[
52,
102
],
[
47,
104
],
[
57,
106
],
[
144,
110
],
[
52,
111
],
[
47,
112
],
[
57,
113
],
[
152,
115
],
[
119,
118
],
[
147,
123
],
[
140,
126
],
[
144,
130
],
[
118,
131
],
[
147,
132
],
[
118,
134
],
[
156,
135
],
[
141,
138
],
[
153,
138
],
[
140,
141
],
[
143,
144
],
[
155,
147
],
[
149,
150
],
[
152,
153
],
[
155,
156
]
] | [
"N,A = map(int,input().split())\nX = list(map(int,input().split()))\ndp = [[[0 for _ in range(50*(N+2))] for _ in range(N+2)] for _ in range(N+2)]\n\ndp[0][0][0] = 1\n#kまでみた\nfor k in range(N):\n #used個使った\n for used in range(N):\n for i in range(50*N):\n #使う時\n if dp[used][k][i] == 0: \n continue\n dp[used+1][k+1][i+X[k]] += dp[used][k][i]\n dp[used][k+1][i] += dp[used][k][i]\nans = 0\nfor used in range(1,N+1):\n ans += dp[used][N][used*A]\nprint(ans)\n\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 for _ in range(50*(N+2))] for _ in range(N+2)] for _ in range(N+2)",
"for _ in range(N+2)",
"_",
"range(N+2)",
"range",
"N+2",
"N",
"2",
"for _ in range(N+2)",
"[[0 for _ in range(50*(N+2))] for _ in range(N+2)]",
"dp = [[[0 for _ in range(50*(N+2))] for _ in range(N+2)] for _ in range(N+2)]",
"dp",
"[[[0 for _ in range(50*(N+2))] for _ in range(N+2)] for _ in range(N+2)]",
"dp[0][0][0] = 1",
"dp[0][0][0]",
"[0]",
"[0]",
"dp",
"0",
"0",
"0",
"1",
"for k in range(N):\n #used個使った\n for used in range(N):\n for i in range(50*N):\n #使う時\n if dp[used][k][i] == 0: \n continue\n dp[used+1][k+1][i+X[k]] += dp[used][k][i]\n dp[used][k+1][i] += dp[used][k][i]",
"k",
"range(N)",
"range",
"N",
"for used in range(N):\n for i in range(50*N):\n #使う時\n if dp[used][k][i] == 0: \n continue\n dp[used+1][k+1][i+X[k]] += dp[used][k][i]\n dp[used][k+1][i] += dp[used][k][i]",
"used",
"range(N)",
"range",
"N",
"for i in range(50*N):\n #使う時\n if dp[used][k][i] == 0: \n continue\n dp[used+1][k+1][i+X[k]] += dp[used][k][i]\n dp[used][k+1][i] += dp[used][k][i]",
"i",
"range(50*N)",
"range",
"50*N",
"50",
"N",
"if dp[used][k][i] == 0: \n continue\n ",
"dp[used][k][i] == 0",
"dp[used][k][i]",
"[k]",
"[used]",
"dp",
"used",
"k",
"i",
"0",
"continue",
"dp[used+1][k+1][i+X[k]] += dp[used][k][i]",
"dp[used+1][k+1][i+X[k]]",
"[k+1]",
"[used+1]",
"dp",
"used+1",
"used",
"1",
"k+1",
"k",
"1",
"i+X[k]",
"i",
"X[k]",
"X",
"k",
"dp[used][k][i]",
"[k]",
"[used]",
"dp",
"used",
"k",
"i",
"dp[used][k+1][i] += dp[used][k][i]",
"dp[used][k+1][i]",
"[k+1]",
"[used]",
"dp",
"used",
"k+1",
"k",
"1",
"i",
"dp[used][k][i]",
"[k]",
"[used]",
"dp",
"used",
"k",
"i",
"ans = 0",
"ans",
"0",
"for used in range(1,N+1):\n ans += dp[used][N][used*A]",
"used",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[used][N][used*A]",
"ans",
"dp[used][N][used*A]",
"[N]",
"[used]",
"dp",
"used",
"N",
"used*A",
"used",
"A",
"print(ans)",
"print",
"ans",
"ans += dp[used][N][used*A]",
"dp[used][N][used*A]",
"ans",
"dp = [[[0 for _ in range(50*(N+2))] for _ in range(N+2)] for _ in range(N+2)]",
"[[[0 for _ in range(50*(N+2))] for _ in range(N+2)] for _ in range(N+2)]",
"dp",
"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",
"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 _ in range(50*(N+2))] for _ in range(N+2)] for _ in range(N+2)]
dp[0][0][0] = 1
#kまでみた
for k in range(N):
#used個使った
for used in range(N):
for i in range(50*N):
#使う時
if dp[used][k][i] == 0:
continue
dp[used+1][k+1][i+X[k]] += dp[used][k][i]
dp[used][k+1][i] += dp[used][k][i]
ans = 0
for used in range(1,N+1):
ans += dp[used][N][used*A]
print(ans)
|
[
7,
15,
13,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
0,
13,
13,
0,
13,
4,
18,
13,
13,
39,
2,
13,
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,
0,
18,
13,
2,
13,
17,
18,
13,
13,
14,
2,
18,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
39,
18,
13,
13,
18,
18,
13,
13,
39,
40,
18,
13,
13,
14,
2,
18,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
39,
18,
13,
13,
18,
18,
13,
13,
39,
40,
18,
13,
13,
0,
18,
13,
2,
13,
17,
18,
13,
13,
4,
13,
2,
18,
18,
13,
17,
2,
13,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
18,
13
] | [
[
177,
6
],
[
16,
15
],
[
178,
22
],
[
16,
24
],
[
27,
26
],
[
178,
39
],
[
43,
42
],
[
24,
45
],
[
26,
48
],
[
51,
50
],
[
24,
51
],
[
54,
53
],
[
15,
60
],
[
15,
66
],
[
42,
67
],
[
71,
70
],
[
80,
73
],
[
53,
75
],
[
15,
78
],
[
42,
79
],
[
83,
82
],
[
15,
85
],
[
92,
87
],
[
53,
88
],
[
82,
90
],
[
53,
93
],
[
82,
94
],
[
50,
98
],
[
26,
98
],
[
82,
99
],
[
112,
102
],
[
53,
104
],
[
82,
106
],
[
50,
110
],
[
26,
110
],
[
82,
111
],
[
53,
114
],
[
82,
115
],
[
50,
119
],
[
26,
119
],
[
82,
120
],
[
50,
124
],
[
26,
124
],
[
82,
125
],
[
138,
128
],
[
53,
130
],
[
82,
132
],
[
50,
136
],
[
26,
136
],
[
82,
137
],
[
53,
140
],
[
82,
141
],
[
50,
145
],
[
26,
145
],
[
82,
146
],
[
153,
148
],
[
53,
149
],
[
82,
151
],
[
53,
154
],
[
82,
155
],
[
53,
161
],
[
15,
164
],
[
42,
165
],
[
175,
172
],
[
177,
178
]
] | [
"import numpy as np\nimport sys\ninput = sys.stdin.readline\n\ndef main():\n N, A = map(int, input().split())\n x = np.array(list(map(int, input().split())))\n X = max(A, max(x))\n x -= A\n # print(x)\n dp = np.zeros((N+1, 2*N*X+1), dtype=int)\n # 初期化\n dp[0][N*X] = 1\n for i in range(N):\n dp[i+1] += dp[i]\n if x[i] > 0:\n dp[i+1][x[i]:] += dp[i][:-x[i]]\n elif x[i] < 0:\n dp[i+1][:x[i]] += dp[i][-x[i]:]\n else:\n dp[i+1] += dp[i]\n \n # print(dp[:, N*X-5:N*X+5])\n # print(x)\n print(dp[-1][N*X] - 1)\n\nif __name__ == \"__main__\":\n main()",
"import numpy as np",
"numpy",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def main():\n N, A = map(int, input().split())\n x = np.array(list(map(int, input().split())))\n X = max(A, max(x))\n x -= A\n # print(x)\n dp = np.zeros((N+1, 2*N*X+1), dtype=int)\n # 初期化\n dp[0][N*X] = 1\n for i in range(N):\n dp[i+1] += dp[i]\n if x[i] > 0:\n dp[i+1][x[i]:] += dp[i][:-x[i]]\n elif x[i] < 0:\n dp[i+1][:x[i]] += dp[i][-x[i]:]\n else:\n dp[i+1] += dp[i]\n \n # print(dp[:, N*X-5:N*X+5])\n # print(x)\n print(dp[-1][N*X] - 1)",
"main",
"N, A = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"x = np.array(list(map(int, input().split())))",
"x",
"np.array(list(map(int, input().split())))",
"np.array",
"np",
"array",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"X = max(A, max(x))",
"X",
"max(A, max(x))",
"max",
"A",
"max(x)",
"max",
"x",
"x -= A",
"x",
"A",
"dp = np.zeros((N+1, 2*N*X+1), dtype=int)",
"dp",
"np.zeros((N+1, 2*N*X+1), dtype=int)",
"np.zeros",
"np",
"zeros",
"(N+1, 2*N*X+1)",
"N+1",
"N",
"1",
"2*N*X+1",
"2*N*X",
"2*N",
"2",
"N",
"X",
"1",
"dtype=int",
"dtype",
"int",
"dp[0][N*X] = 1",
"dp[0][N*X]",
"[0]",
"dp",
"0",
"N*X",
"N",
"X",
"1",
"for i in range(N):\n dp[i+1] += dp[i]\n if x[i] > 0:\n dp[i+1][x[i]:] += dp[i][:-x[i]]\n elif x[i] < 0:\n dp[i+1][:x[i]] += dp[i][-x[i]:]\n else:\n dp[i+1] += dp[i]\n \n # print(dp[:, N*X-5:N*X+5])\n # print(x)\n ",
"i",
"range(N)",
"range",
"N",
"dp[i+1] += dp[i]",
"dp[i+1]",
"dp",
"i+1",
"i",
"1",
"dp[i]",
"dp",
"i",
"if x[i] > 0:\n dp[i+1][x[i]:] += dp[i][:-x[i]]\n elif x[i] < 0:\n dp[i+1][:x[i]] += dp[i][-x[i]:]\n else:\n dp[i+1] += dp[i]\n \n # print(dp[:, N*X-5:N*X+5])\n # print(x)\n ",
"x[i] > 0",
"x[i]",
"x",
"i",
"0",
"dp[i+1][x[i]:] += dp[i][:-x[i]]",
"dp[i+1][x[i]:]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
"x[i]:",
"x[i]",
"x",
"i",
"dp[i][:-x[i]]",
"[i]",
"dp",
"i",
":-x[i]",
"-x[i]",
"x[i]",
"x",
"i",
"elif x[i] < 0:\n dp[i+1][:x[i]] += dp[i][-x[i]:]\n ",
"x[i] < 0",
"x[i]",
"x",
"i",
"0",
"dp[i+1][:x[i]] += dp[i][-x[i]:]",
"dp[i+1][:x[i]]",
"[i+1]",
"dp",
"i+1",
"i",
"1",
":x[i]",
"x[i]",
"x",
"i",
"dp[i][-x[i]:]",
"[i]",
"dp",
"i",
"-x[i]:",
"-x[i]",
"x[i]",
"x",
"i",
"dp[i+1] += dp[i]",
"dp[i+1]",
"dp",
"i+1",
"i",
"1",
"dp[i]",
"dp",
"i",
"print(dp[-1][N*X] - 1)",
"print",
"dp[-1][N*X] - 1",
"dp[-1][N*X]",
"[-1]",
"dp",
"-1",
"N*X",
"N",
"X",
"1",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n N, A = map(int, input().split())\n x = np.array(list(map(int, input().split())))\n X = max(A, max(x))\n x -= A\n # print(x)\n dp = np.zeros((N+1, 2*N*X+1), dtype=int)\n # 初期化\n dp[0][N*X] = 1\n for i in range(N):\n dp[i+1] += dp[i]\n if x[i] > 0:\n dp[i+1][x[i]:] += dp[i][:-x[i]]\n elif x[i] < 0:\n dp[i+1][:x[i]] += dp[i][-x[i]:]\n else:\n dp[i+1] += dp[i]\n \n # print(dp[:, N*X-5:N*X+5])\n # print(x)\n print(dp[-1][N*X] - 1)",
"def main():\n N, A = map(int, input().split())\n x = np.array(list(map(int, input().split())))\n X = max(A, max(x))\n x -= A\n # print(x)\n dp = np.zeros((N+1, 2*N*X+1), dtype=int)\n # 初期化\n dp[0][N*X] = 1\n for i in range(N):\n dp[i+1] += dp[i]\n if x[i] > 0:\n dp[i+1][x[i]:] += dp[i][:-x[i]]\n elif x[i] < 0:\n dp[i+1][:x[i]] += dp[i][-x[i]:]\n else:\n dp[i+1] += dp[i]\n \n # print(dp[:, N*X-5:N*X+5])\n # print(x)\n print(dp[-1][N*X] - 1)",
"main",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input"
] | import numpy as np
import sys
input = sys.stdin.readline
def main():
N, A = map(int, input().split())
x = np.array(list(map(int, input().split())))
X = max(A, max(x))
x -= A
# print(x)
dp = np.zeros((N+1, 2*N*X+1), dtype=int)
# 初期化
dp[0][N*X] = 1
for i in range(N):
dp[i+1] += dp[i]
if x[i] > 0:
dp[i+1][x[i]:] += dp[i][:-x[i]]
elif x[i] < 0:
dp[i+1][:x[i]] += dp[i][-x[i]:]
else:
dp[i+1] += dp[i]
# print(dp[:, N*X-5:N*X+5])
# print(x)
print(dp[-1][N*X] - 1)
if __name__ == "__main__":
main() |
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
41,
28,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
2,
13,
13,
0,
13,
13,
4,
18,
13,
13,
0,
13,
4,
13,
28,
13,
13,
28,
13,
13,
4,
13,
4,
18,
13,
13,
0,
18,
13,
2,
13,
13,
2,
18,
13,
2,
13,
13,
13,
0,
18,
13,
13,
17,
4,
13,
18,
13,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
81,
3
],
[
81,
12
],
[
16,
15
],
[
15,
26
],
[
79,
27
],
[
75,
29
],
[
76,
33
],
[
84,
36
],
[
41,
40
],
[
76,
40
],
[
85,
49
],
[
57,
52
],
[
85,
53
],
[
40,
56
],
[
85,
59
],
[
40,
62
],
[
68,
65
],
[
85,
66
],
[
40,
67
],
[
85,
72
],
[
75,
76
],
[
81,
79
],
[
81,
82
],
[
84,
85
]
] | [
"from collections import Counter\n\nX, A = map(int, input().split())\nx = [i - A for i in map(int, input().split())]\nx.sort()\ndp = Counter()\n\nfor i in x:\n for j, k in list(dp.items()):\n dp[j + i] = dp[j + i] + k\n dp[i] += 1\n\nprint(dp[0])",
"from collections import Counter",
"X, A = map(int, input().split())",
"X",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"i - A for i in map(int, input().split())",
"for i in map(int, input().split())",
"i",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in map(int, input().split())",
"i - A",
"i",
"A",
"x = [i - A for i in map(int, input().split())]",
"x",
"[i - A for i in map(int, input().split())]",
"x.sort()",
"x.sort",
"x",
"sort",
"dp = Counter()",
"dp",
"Counter()",
"Counter",
"for i in x:\n for j, k in list(dp.items()):\n dp[j + i] = dp[j + i] + k\n dp[i] += 1",
"i",
"x",
"for j, k in list(dp.items()):\n dp[j + i] = dp[j + i] + k\n ",
"j",
"k",
"list(dp.items())",
"list",
"dp.items()",
"dp.items",
"dp",
"items",
"dp[j + i] = dp[j + i] + k",
"dp[j + i]",
"dp",
"j + i",
"j",
"i",
"dp[j + i] + k",
"dp[j + i]",
"dp",
"j + i",
"j",
"i",
"k",
"dp[i] += 1",
"dp[i]",
"dp",
"i",
"1",
"print(dp[0])",
"print",
"dp[0]",
"dp",
"0",
"x = [i - A for i in map(int, input().split())]",
"[i - A for i in map(int, input().split())]",
"x",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"X, A = map(int, input().split())",
"map(int, input().split())",
"X",
"dp = Counter()",
"Counter()",
"dp"
] | from collections import Counter
X, A = map(int, input().split())
x = [i - A for i in map(int, input().split())]
x.sort()
dp = Counter()
for i in x:
for j, k in list(dp.items()):
dp[j + i] = dp[j + i] + k
dp[i] += 1
print(dp[0]) |
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
2,
18,
13,
13,
17,
4,
17,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
2,
18,
13,
13,
17,
4,
17,
0,
18,
13,
13,
13,
28,
13,
4,
13,
17,
2,
18,
13,
13,
17,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
13,
18,
13,
13,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
4,
13,
13,
17,
18,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
13,
18,
18,
13,
13,
13,
18,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
14,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
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,
2,
4,
13,
13,
17,
14,
2,
40,
13,
17,
40,
2,
13,
18,
13,
13,
17,
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,
0,
18,
18,
18,
13,
2,
13,
17,
13,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
40,
2,
2,
13,
17,
13,
2,
4,
13,
13,
17,
3,
0,
13,
18,
18,
18,
13,
13,
2,
13,
17,
2,
2,
13,
17,
13,
4,
13,
13,
10,
6,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
12,
13,
10,
4,
13
] | [
[
9,
6
],
[
104,
7
],
[
106,
8
],
[
106,
9
],
[
14,
11
],
[
104,
12
],
[
108,
13
],
[
108,
14
],
[
18,
17
],
[
6,
21
],
[
104,
22
],
[
106,
23
],
[
31,
28
],
[
104,
29
],
[
35,
34
],
[
6,
38
],
[
104,
39
],
[
106,
40
],
[
48,
45
],
[
104,
46
],
[
51,
50
],
[
6,
55
],
[
104,
56
],
[
106,
57
],
[
65,
60
],
[
28,
61
],
[
104,
62
],
[
50,
64
],
[
28,
68
],
[
104,
69
],
[
50,
72
],
[
50,
74
],
[
11,
75
],
[
104,
76
],
[
108,
77
],
[
84,
79
],
[
45,
80
],
[
104,
81
],
[
50,
83
],
[
45,
87
],
[
104,
88
],
[
50,
91
],
[
50,
95
],
[
11,
97
],
[
104,
98
],
[
108,
99
],
[
11,
100
],
[
104,
101
],
[
108,
102
],
[
104,
104
],
[
106,
106
],
[
108,
108
],
[
140,
116
],
[
142,
118
],
[
140,
123
],
[
142,
126
],
[
144,
127
],
[
140,
130
],
[
144,
132
],
[
140,
134
],
[
140,
137
],
[
140,
140
],
[
142,
142
],
[
144,
144
],
[
335,
163
],
[
333,
165
],
[
335,
166
],
[
326,
168
],
[
333,
170
],
[
174,
173
],
[
336,
177
],
[
320,
182
],
[
192,
185
],
[
321,
188
],
[
195,
194
],
[
336,
197
],
[
200,
199
],
[
336,
203
],
[
207,
206
],
[
327,
212
],
[
199,
217
],
[
206,
221
],
[
327,
223
],
[
194,
224
],
[
236,
227
],
[
321,
230
],
[
194,
232
],
[
199,
234
],
[
206,
235
],
[
321,
240
],
[
194,
241
],
[
199,
242
],
[
206,
243
],
[
321,
247
],
[
194,
248
],
[
199,
250
],
[
206,
253
],
[
327,
255
],
[
194,
256
],
[
267,
258
],
[
321,
261
],
[
194,
263
],
[
199,
265
],
[
206,
266
],
[
321,
270
],
[
194,
271
],
[
199,
272
],
[
206,
273
],
[
323,
275
],
[
279,
278
],
[
336,
281
],
[
278,
286
],
[
318,
288
],
[
327,
292
],
[
329,
296
],
[
321,
300
],
[
336,
301
],
[
278,
303
],
[
278,
307
],
[
318,
309
],
[
330,
312
],
[
324,
312
],
[
335,
318
],
[
320,
321
],
[
323,
324
],
[
326,
327
],
[
329,
330
],
[
335,
336
]
] | [
"class Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod\ndef iparse():\n return list(map(int, input().split()))\n\nif __name__ == \"__main__\":\n n, a = iparse()\n x = iparse()\n\n dp = [[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \\\n for k in range(n + 10)]\n dp[0][0][0] = 1\n for i in range(n):\n for j in range(n + 1):\n for k in range(sum(x) + 1):\n if j >= 1 and k - x[i] >= 0:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ans = 0\n for i in range(n):\n if (i + 1) * a >= sum(x) + 10:\n break\n ans += dp[n][i + 1][(i+1)*a]\n print(ans)\n ",
"class Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod",
"Combination",
"def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n ",
"__init__",
"self.n = n",
"self.n",
"self",
"n",
"n",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"1 for i in range(self.n + 1)",
"for i in range(self.n + 1)",
"i",
"range(self.n + 1)",
"range",
"self.n + 1",
"self.n",
"self",
"n",
"1",
"for i in range(self.n + 1)",
"1",
"self.fac = [1 for i in range(self.n + 1)]",
"self.fac",
"self",
"fac",
"[1 for i in range(self.n + 1)]",
"1 for i in range(self.n + 1)",
"for i in range(self.n + 1)",
"i",
"range(self.n + 1)",
"range",
"self.n + 1",
"self.n",
"self",
"n",
"1",
"for i in range(self.n + 1)",
"1",
"self.finv = [1 for i in range(self.n + 1)]",
"self.finv",
"self",
"finv",
"[1 for i in range(self.n + 1)]",
"for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n ",
"i",
"range(2, self.n+1)",
"range",
"2",
"self.n+1",
"self.n",
"self",
"n",
"1",
"self.fac[i] = (self.fac[i - 1] * i) % self.mod",
"self.fac[i]",
"self.fac",
"self",
"fac",
"i",
"(self.fac[i - 1] * i) % self.mod",
"self.fac[i - 1] * i",
"self.fac[i - 1]",
"self.fac",
"self",
"fac",
"i - 1",
"i",
"1",
"i",
"self.mod",
"self",
"mod",
"self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod",
"self.finv[i]",
"self.finv",
"self",
"finv",
"i",
"(self.finv[i-1] * pow(i, -1, self.mod)) % self.mod",
"self.finv[i-1] * pow(i, -1, self.mod)",
"self.finv[i-1]",
"self.finv",
"self",
"finv",
"i-1",
"i",
"1",
"pow(i, -1, self.mod)",
"pow",
"i",
"-1",
"self.mod",
"self",
"mod",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"mod",
"mod",
"def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod",
"comb",
"return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod",
"self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod",
"self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod)",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"self.finv[n-m] * self.finv[m] % self.mod",
"self.finv[n-m] * self.finv[m]",
"self.finv[n-m]",
"self.finv",
"self",
"finv",
"n-m",
"n",
"m",
"self.finv[m]",
"self.finv",
"self",
"finv",
"m",
"self.mod",
"self",
"mod",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"m",
"m",
"def iparse():\n return list(map(int, input().split()))",
"iparse",
"return list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"if __name__ == \"__main__\":\n n, a = iparse()\n x = iparse()\n\n dp = [[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \\\n for k in range(n + 10)]\n dp[0][0][0] = 1\n for i in range(n):\n for j in range(n + 1):\n for k in range(sum(x) + 1):\n if j >= 1 and k - x[i] >= 0:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ans = 0\n for i in range(n):\n if (i + 1) * a >= sum(x) + 10:\n break\n ans += dp[n][i + 1][(i+1)*a]\n print(ans)\n ",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"n, a = iparse()",
"n",
"iparse()",
"iparse",
"a",
"x = iparse()",
"x",
"iparse()",
"iparse",
"[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \\\n for k in range(n + 10)",
"for k in range(n + 10)",
"k",
"range(n + 10)",
"range",
"n + 10",
"n",
"10",
"for k in range(n + 10)",
"[[0 for i in range(sum(x) + 10)] for j in range(n + 10)]",
"dp = [[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \\\n for k in range(n + 10)]",
"dp",
"[[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \\\n for k in range(n + 10)]",
"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(sum(x) + 1):\n if j >= 1 and k - x[i] >= 0:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"i",
"range(n)",
"range",
"n",
"for j in range(n + 1):\n for k in range(sum(x) + 1):\n if j >= 1 and k - x[i] >= 0:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"j",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for k in range(sum(x) + 1):\n if j >= 1 and k - x[i] >= 0:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"k",
"range(sum(x) + 1)",
"range",
"sum(x) + 1",
"sum(x)",
"sum",
"x",
"1",
"if j >= 1 and k - x[i] >= 0:\n dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]\n else:\n dp[i+1][j][k] = dp[i][j][k]\n ",
"j >= 1 and k - x[i] >= 0",
"j >= 1",
"j",
"1",
"k - x[i] >= 0",
"k - x[i]",
"k",
"x[i]",
"x",
"i",
"0",
"dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]",
"dp[i + 1][j][k]",
"[j]",
"[i + 1]",
"dp",
"i + 1",
"i",
"1",
"j",
"k",
"dp[i][j][k] + dp[i][j - 1][k - x[i]]",
"dp[i][j][k]",
"[j]",
"[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+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",
"ans = 0",
"ans",
"0",
"for i in range(n):\n if (i + 1) * a >= sum(x) + 10:\n break\n ans += dp[n][i + 1][(i+1)*a]\n ",
"i",
"range(n)",
"range",
"n",
"if (i + 1) * a >= sum(x) + 10:\n break\n ",
"(i + 1) * a >= sum(x) + 10",
"(i + 1) * a",
"i + 1",
"i",
"1",
"a",
"sum(x) + 10",
"sum(x)",
"sum",
"x",
"10",
"break",
"ans += dp[n][i + 1][(i+1)*a]",
"ans",
"dp[n][i + 1][(i+1)*a]",
"[i + 1]",
"[n]",
"dp",
"n",
"i + 1",
"i",
"1",
"(i+1)*a",
"i+1",
"i",
"1",
"a",
"print(ans)",
"print",
"ans",
"class Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod",
"class Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod",
"Combination",
"a = iparse()",
"iparse()",
"a",
"dp = [[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \\\n for k in range(n + 10)]",
"[[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \\\n for k in range(n + 10)]",
"dp",
"ans = 0",
"0",
"ans",
"x = iparse()",
"iparse()",
"x",
"ans += dp[n][i + 1][(i+1)*a]",
"dp[n][i + 1][(i+1)*a]",
"ans",
"def iparse():\n return list(map(int, input().split()))",
"def iparse():\n return list(map(int, input().split()))",
"iparse",
"n, a = iparse()",
"iparse()",
"n"
] | class Combination:
def __init__(self, n, mod):
self.n = n
self.mod = mod
self.fac = [1 for i in range(self.n + 1)]
self.finv = [1 for i in range(self.n + 1)]
for i in range(2, self.n+1):
self.fac[i] = (self.fac[i - 1] * i) % self.mod
self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod
def comb(self, n, m):
return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod
def iparse():
return list(map(int, input().split()))
if __name__ == "__main__":
n, a = iparse()
x = iparse()
dp = [[[0 for i in range(sum(x) + 10)] for j in range(n + 10)] \
for k in range(n + 10)]
dp[0][0][0] = 1
for i in range(n):
for j in range(n + 1):
for k in range(sum(x) + 1):
if j >= 1 and k - x[i] >= 0:
dp[i + 1][j][k] = dp[i][j][k] + dp[i][j - 1][k - x[i]]
else:
dp[i+1][j][k] = dp[i][j][k]
ans = 0
for i in range(n):
if (i + 1) * a >= sum(x) + 10:
break
ans += dp[n][i + 1][(i+1)*a]
print(ans)
|
[
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,
17,
0,
13,
17,
28,
13,
13,
0,
13,
13,
14,
2,
13,
17,
0,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
18,
13,
13,
39,
2,
13,
17,
13,
0,
13,
17,
0,
18,
18,
13,
17,
40,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
2,
13,
17,
13,
14,
2,
40,
17,
13,
2,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
4,
13,
2,
18,
18,
13,
13,
40,
13,
17,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13
] | [
[
161,
4
],
[
161,
13
],
[
152,
15
],
[
173,
27
],
[
155,
30
],
[
34,
33
],
[
153,
33
],
[
164,
36
],
[
162,
37
],
[
165,
40
],
[
33,
40
],
[
176,
43
],
[
165,
44
],
[
33,
44
],
[
158,
46
],
[
165,
47
],
[
33,
47
],
[
170,
49
],
[
159,
52
],
[
174,
52
],
[
177,
53
],
[
156,
53
],
[
167,
56
],
[
150,
63
],
[
68,
67
],
[
76,
70
],
[
168,
72
],
[
177,
75
],
[
156,
75
],
[
79,
78
],
[
150,
83
],
[
87,
86
],
[
171,
89
],
[
96,
91
],
[
168,
93
],
[
78,
94
],
[
86,
95
],
[
168,
98
],
[
78,
100
],
[
86,
102
],
[
146,
104
],
[
86,
107
],
[
153,
109
],
[
78,
111
],
[
162,
113
],
[
147,
118
],
[
147,
120
],
[
171,
121
],
[
128,
123
],
[
168,
125
],
[
78,
126
],
[
86,
127
],
[
168,
130
],
[
78,
132
],
[
147,
134
],
[
168,
140
],
[
150,
141
],
[
177,
143
],
[
156,
143
],
[
146,
147
],
[
161,
150
],
[
152,
153
],
[
155,
156
],
[
165,
158
],
[
33,
158
],
[
158,
159
],
[
161,
162
],
[
162,
164
],
[
164,
165
],
[
167,
168
],
[
170,
171
],
[
173,
174
],
[
165,
176
],
[
33,
176
],
[
176,
177
]
] | [
"import numpy as np\n\nN, A = map(int, input().split())\nx = list(map(int, input().split()))\nr = 0\nl = 0\nfor y in x:\n y -= A\n if y < 0:\n l += y\n else:\n r += y\n\nM = r-l+1\ndp = np.zeros((N+1,M), dtype='i8')\ndp[0][-l] = 1\n\nfor i in range(1, N+1):\n for j in range(M):\n dp[i][j] = dp[i-1][j]\n j2 = j-x[i-1]+A\n if 0 <= j2 and j2 < M:\n dp[i][j] += dp[i-1][j2]\n\nprint(dp[N][-l]-1)",
"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",
"r = 0",
"r",
"0",
"l = 0",
"l",
"0",
"for y in x:\n y -= A\n if y < 0:\n l += y\n else:\n r += y",
"y",
"x",
"y -= A",
"y",
"A",
"if y < 0:\n l += y\n else:\n r += y",
"y < 0",
"y",
"0",
"l += y",
"l",
"y",
"r += y",
"r",
"y",
"M = r-l+1",
"M",
"r-l+1",
"r-l",
"r",
"l",
"1",
"dp = np.zeros((N+1,M), dtype='i8')",
"dp",
"np.zeros((N+1,M), dtype='i8')",
"np.zeros",
"np",
"zeros",
"(N+1,M)",
"N+1",
"N",
"1",
"M",
"dtype='i8'",
"dtype",
"'i8'",
"dp[0][-l] = 1",
"dp[0][-l]",
"[0]",
"dp",
"0",
"-l",
"l",
"1",
"for i in range(1, N+1):\n for j in range(M):\n dp[i][j] = dp[i-1][j]\n j2 = j-x[i-1]+A\n if 0 <= j2 and j2 < M:\n dp[i][j] += dp[i-1][j2]",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"for j in range(M):\n dp[i][j] = dp[i-1][j]\n j2 = j-x[i-1]+A\n if 0 <= j2 and j2 < M:\n dp[i][j] += dp[i-1][j2]",
"j",
"range(M)",
"range",
"M",
"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",
"j2 = j-x[i-1]+A",
"j2",
"j-x[i-1]+A",
"j-x[i-1]",
"j",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"A",
"if 0 <= j2 and j2 < M:\n dp[i][j] += dp[i-1][j2]",
"0 <= j2 and j2 < M",
"0 <= j2",
"0",
"j2",
"j2 < M",
"j2",
"M",
"dp[i][j] += dp[i-1][j2]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i-1][j2]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j2",
"print(dp[N][-l]-1)",
"print",
"dp[N][-l]-1",
"dp[N][-l]",
"[N]",
"dp",
"N",
"-l",
"l",
"1",
"j2 = j-x[i-1]+A",
"j-x[i-1]+A",
"j2",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N",
"x = list(map(int, input().split()))",
"list(map(int, input().split()))",
"x",
"l = 0",
"0",
"l",
"r += y",
"y",
"r",
"A = map(int, input().split())",
"map(int, input().split())",
"A",
"y -= A",
"A",
"y",
"dp = np.zeros((N+1,M), dtype='i8')",
"np.zeros((N+1,M), dtype='i8')",
"dp",
"M = r-l+1",
"r-l+1",
"M",
"r = 0",
"0",
"r",
"l += y",
"y",
"l"
] | import numpy as np
N, A = map(int, input().split())
x = list(map(int, input().split()))
r = 0
l = 0
for y in x:
y -= A
if y < 0:
l += y
else:
r += y
M = r-l+1
dp = np.zeros((N+1,M), dtype='i8')
dp[0][-l] = 1
for i in range(1, N+1):
for j in range(M):
dp[i][j] = dp[i-1][j]
j2 = j-x[i-1]+A
if 0 <= j2 and j2 < M:
dp[i][j] += dp[i-1][j2]
print(dp[N][-l]-1)
|
[
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,
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,
4,
13,
13,
28,
13,
4,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
2,
2,
13,
13,
17,
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,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
16,
15
],
[
29,
28
],
[
4,
32
],
[
13,
40
],
[
4,
41
],
[
45,
44
],
[
52,
47
],
[
44,
49
],
[
15,
58
],
[
61,
60
],
[
71,
70
],
[
13,
76
],
[
4,
77
],
[
85,
80
],
[
44,
82
],
[
60,
83
],
[
70,
84
],
[
44,
87
],
[
60,
89
],
[
70,
92
],
[
44,
100
],
[
13,
103
],
[
109,
106
]
] | [
"def solve():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n \n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for i, x in enumerate(X):\n for j in reversed(range(1, i + 2)):\n for a in range(x, A * N + 1):\n dp[j][a] += dp[j - 1][a - x]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))\n \nsolve()",
"def solve():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n \n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for i, x in enumerate(X):\n for j in reversed(range(1, i + 2)):\n for a in range(x, A * N + 1):\n dp[j][a] += dp[j - 1][a - x]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))\n ",
"solve",
"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] * (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 i, x in enumerate(X):\n for j in reversed(range(1, i + 2)):\n for a in range(x, A * N + 1):\n dp[j][a] += dp[j - 1][a - x]\n ",
"i",
"x",
"enumerate(X)",
"enumerate",
"X",
"for j in reversed(range(1, i + 2)):\n for a in range(x, A * N + 1):\n dp[j][a] += dp[j - 1][a - x]\n ",
"j",
"reversed(range(1, i + 2))",
"reversed",
"range(1, i + 2)",
"range",
"1",
"i + 2",
"i",
"2",
"for a in range(x, A * N + 1):\n dp[j][a] += dp[j - 1][a - x]\n ",
"a",
"range(x, A * N + 1)",
"range",
"x",
"A * N + 1",
"A * N",
"A",
"N",
"1",
"dp[j][a] += dp[j - 1][a - x]",
"dp[j][a]",
"[j]",
"dp",
"j",
"a",
"dp[j - 1][a - x]",
"[j - 1]",
"dp",
"j - 1",
"j",
"1",
"a - x",
"a",
"x",
"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",
"solve()",
"solve",
"def solve():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n \n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for i, x in enumerate(X):\n for j in reversed(range(1, i + 2)):\n for a in range(x, A * N + 1):\n dp[j][a] += dp[j - 1][a - x]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))\n ",
"def solve():\n N, A = map(int, input().split())\n X = list(map(int, input().split()))\n \n dp = [[0] * (A * N + 1) for _ in range(N + 1)]\n dp[0][0] = 1\n for i, x in enumerate(X):\n for j in reversed(range(1, i + 2)):\n for a in range(x, A * N + 1):\n dp[j][a] += dp[j - 1][a - x]\n print(sum(dp[i][A * i] for i in range(1, N + 1)))\n ",
"solve"
] | def solve():
N, A = map(int, input().split())
X = list(map(int, input().split()))
dp = [[0] * (A * N + 1) for _ in range(N + 1)]
dp[0][0] = 1
for i, x in enumerate(X):
for j in reversed(range(1, i + 2)):
for a in range(x, A * N + 1):
dp[j][a] += dp[j - 1][a - x]
print(sum(dp[i][A * i] for i in range(1, N + 1)))
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,
41,
28,
13,
4,
13,
2,
13,
17,
4,
13,
0,
13,
13,
0,
13,
17,
0,
18,
18,
13,
17,
13,
17,
28,
13,
13,
4,
13,
13,
17,
0,
13,
2,
13,
13,
28,
13,
4,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
13,
14,
40,
40,
17,
2,
13,
13,
17,
0,
18,
18,
13,
13,
13,
18,
18,
13,
2,
13,
17,
2,
13,
13,
4,
13,
2,
18,
18,
13,
17,
13,
17,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] | [
[
119,
2
],
[
119,
11
],
[
113,
13
],
[
27,
26
],
[
111,
30
],
[
122,
35
],
[
125,
38
],
[
46,
41
],
[
123,
43
],
[
126,
45
],
[
114,
52
],
[
116,
55
],
[
120,
58
],
[
61,
60
],
[
70,
65
],
[
123,
67
],
[
60,
69
],
[
123,
72
],
[
60,
76
],
[
60,
82
],
[
117,
83
],
[
91,
86
],
[
123,
88
],
[
60,
90
],
[
123,
93
],
[
60,
98
],
[
117,
99
],
[
41,
103
],
[
123,
105
],
[
126,
107
],
[
119,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
]
] | [
"n, a = map(int, input().split())\nxlst = list(map(int, input().split()))\ndp = [[0 for _ in range(5001)] for _ in range(n + 1)]\ncenter = 2500\ndp[0][center] = 1\nfor i, x in enumerate(xlst, 1):\n num = x - a\n for j in range(5001):\n dp[i][j] = dp[i - 1][j]\n if 0 <= j - num <= 5000:\n dp[i][j] += dp[i - 1][j - num]\nprint(dp[-1][center] - 1)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"xlst = list(map(int, input().split()))",
"xlst",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[0 for _ in range(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 for _ in range(5001)]",
"dp = [[0 for _ in range(5001)] for _ in range(n + 1)]",
"dp",
"[[0 for _ in range(5001)] for _ in range(n + 1)]",
"center = 2500",
"center",
"2500",
"dp[0][center] = 1",
"dp[0][center]",
"[0]",
"dp",
"0",
"center",
"1",
"for i, x in enumerate(xlst, 1):\n num = x - a\n for j in range(5001):\n dp[i][j] = dp[i - 1][j]\n if 0 <= j - num <= 5000:\n dp[i][j] += dp[i - 1][j - num]",
"i",
"x",
"enumerate(xlst, 1)",
"enumerate",
"xlst",
"1",
"num = x - a",
"num",
"x - a",
"x",
"a",
"for j in range(5001):\n dp[i][j] = dp[i - 1][j]\n if 0 <= j - num <= 5000:\n dp[i][j] += dp[i - 1][j - num]",
"j",
"range(5001)",
"range",
"5001",
"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",
"if 0 <= j - num <= 5000:\n dp[i][j] += dp[i - 1][j - num]",
"0 <= j - num <= 5000",
"0 <= j - num",
"0",
"j - num",
"j",
"num",
"5000",
"dp[i][j] += dp[i - 1][j - num]",
"dp[i][j]",
"[i]",
"dp",
"i",
"j",
"dp[i - 1][j - num]",
"[i - 1]",
"dp",
"i - 1",
"i",
"1",
"j - num",
"j",
"num",
"print(dp[-1][center] - 1)",
"print",
"dp[-1][center] - 1",
"dp[-1][center]",
"[-1]",
"dp",
"-1",
"center",
"1",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"xlst = list(map(int, input().split()))",
"list(map(int, input().split()))",
"xlst",
"num = x - a",
"x - a",
"num",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"dp = [[0 for _ in range(5001)] for _ in range(n + 1)]",
"[[0 for _ in range(5001)] for _ in range(n + 1)]",
"dp",
"center = 2500",
"2500",
"center"
] | n, a = map(int, input().split())
xlst = list(map(int, input().split()))
dp = [[0 for _ in range(5001)] for _ in range(n + 1)]
center = 2500
dp[0][center] = 1
for i, x in enumerate(xlst, 1):
num = x - a
for j in range(5001):
dp[i][j] = dp[i - 1][j]
if 0 <= j - num <= 5000:
dp[i][j] += dp[i - 1][j - num]
print(dp[-1][center] - 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,
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,
18,
18,
18,
13,
13,
17,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
4,
13,
13,
17,
0,
18,
18,
18,
13,
13,
13,
13,
18,
18,
18,
13,
2,
13,
17,
13,
13,
14,
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,
14,
2,
2,
13,
13,
4,
13,
13,
3,
0,
13,
18,
18,
18,
13,
13,
13,
2,
13,
13,
4,
13,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
177,
2
],
[
177,
11
],
[
183,
13
],
[
27,
26
],
[
178,
30
],
[
168,
35
],
[
45,
38
],
[
169,
41
],
[
48,
47
],
[
178,
52
],
[
62,
55
],
[
169,
58
],
[
47,
59
],
[
65,
64
],
[
47,
69
],
[
73,
72
],
[
184,
79
],
[
89,
82
],
[
169,
85
],
[
47,
86
],
[
64,
87
],
[
72,
88
],
[
169,
92
],
[
47,
94
],
[
64,
96
],
[
72,
97
],
[
72,
101
],
[
184,
103
],
[
47,
105
],
[
116,
109
],
[
169,
112
],
[
47,
113
],
[
64,
114
],
[
72,
115
],
[
169,
119
],
[
47,
121
],
[
64,
124
],
[
72,
127
],
[
184,
129
],
[
47,
131
],
[
180,
134
],
[
138,
137
],
[
178,
142
],
[
137,
147
],
[
175,
148
],
[
184,
151
],
[
171,
154
],
[
169,
158
],
[
178,
159
],
[
137,
160
],
[
137,
162
],
[
175,
163
],
[
172,
166
],
[
181,
166
],
[
168,
169
],
[
171,
172
],
[
177,
175
],
[
177,
178
],
[
180,
181
],
[
183,
184
]
] | [
"N,A=map(int,input().split())\nxlist=list(map(int,input().split()))\n\ndp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]\ndp[0][0][0]=1\nfor i in range(1,N+1):\n dp[i][0][0]=1\n for j in range(1,i+1):\n for k in range(1,sum(xlist)+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)\n\nanswer=0\nfor j in range(1,N+1):\n if j*A>sum(xlist):\n break\n answer+=dp[N][j][j*A]\n \nprint(answer)",
"N,A=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"A",
"xlist=list(map(int,input().split()))",
"xlist",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[[0]*(sum(xlist)+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(xlist)+1) for _ in range(N+1)]",
"dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"[[[0]*(sum(xlist)+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(1,N+1):\n dp[i][0][0]=1\n for j in range(1,i+1):\n for k in range(1,sum(xlist)+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"dp[i][0][0]=1",
"dp[i][0][0]",
"[0]",
"[i]",
"dp",
"i",
"0",
"0",
"1",
"for j in range(1,i+1):\n for k in range(1,sum(xlist)+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)",
"j",
"range(1,i+1)",
"range",
"1",
"i+1",
"i",
"1",
"for k in range(1,sum(xlist)+1):\n dp[i][j][k]=dp[i-1][j][k]\n if k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)",
"k",
"range(1,sum(xlist)+1)",
"range",
"1",
"sum(xlist)+1",
"sum(xlist)",
"sum",
"xlist",
"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 k-xlist[i-1]>=0:\n dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]\n#print(dp)",
"k-xlist[i-1]>=0",
"k-xlist[i-1]",
"k",
"xlist[i-1]",
"xlist",
"i-1",
"i",
"1",
"0",
"dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]",
"dp[i][j][k]",
"[j]",
"[i]",
"dp",
"i",
"j",
"k",
"dp[i-1][j-1][k-xlist[i-1]]",
"[j-1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"j-1",
"j",
"1",
"k-xlist[i-1]",
"k",
"xlist[i-1]",
"xlist",
"i-1",
"i",
"1",
"answer=0",
"answer",
"0",
"for j in range(1,N+1):\n if j*A>sum(xlist):\n break\n answer+=dp[N][j][j*A]\n ",
"j",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if j*A>sum(xlist):\n break\n ",
"j*A>sum(xlist)",
"j*A",
"j",
"A",
"sum(xlist)",
"sum",
"xlist",
"break",
"answer+=dp[N][j][j*A]",
"answer",
"dp[N][j][j*A]",
"[j]",
"[N]",
"dp",
"N",
"j",
"j*A",
"j",
"A",
"print(answer)",
"print",
"answer",
"dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]",
"[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]",
"dp",
"answer+=dp[N][j][j*A]",
"dp[N][j][j*A]",
"answer",
"A=map(int,input().split())",
"map(int,input().split())",
"A",
"N,A=map(int,input().split())",
"map(int,input().split())",
"N",
"answer=0",
"0",
"answer",
"xlist=list(map(int,input().split()))",
"list(map(int,input().split()))",
"xlist"
] | N,A=map(int,input().split())
xlist=list(map(int,input().split()))
dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0]=1
for i in range(1,N+1):
dp[i][0][0]=1
for j in range(1,i+1):
for k in range(1,sum(xlist)+1):
dp[i][j][k]=dp[i-1][j][k]
if k-xlist[i-1]>=0:
dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]
#print(dp)
answer=0
for j in range(1,N+1):
if j*A>sum(xlist):
break
answer+=dp[N][j][j*A]
print(answer) |
[
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,
2,
39,
17,
17,
0,
13,
13,
0,
18,
18,
13,
17,
17,
17,
28,
13,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
28,
13,
4,
13,
13,
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,
13,
17,
0,
13,
18,
18,
13,
13,
2,
13,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] | [
[
122,
2
],
[
122,
11
],
[
113,
13
],
[
27,
26
],
[
123,
30
],
[
116,
38
],
[
46,
41
],
[
117,
43
],
[
114,
52
],
[
55,
54
],
[
64,
63
],
[
74,
69
],
[
117,
71
],
[
54,
72
],
[
63,
73
],
[
117,
76
],
[
54,
78
],
[
63,
81
],
[
119,
84
],
[
88,
87
],
[
123,
92
],
[
107,
95
],
[
117,
98
],
[
87,
99
],
[
111,
101
],
[
87,
102
],
[
108,
105
],
[
120,
105
],
[
107,
108
],
[
122,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
]
] | [
"N, A = map(int, input().split())\nX = list(map(int, input().split()))\ndp = [[0]*2501 for _ in range(N+1)] # dp[n][k] := カードn枚で合計kにする選び方の数\ndp[0][0] = 1\n\nfor i, x in enumerate(X):\n for n in range(i+1, 0, -1):\n for k in range(x, 2501):\n dp[n][k] += dp[n-1][k-x]\n\nans = 0\nfor n in range(1, N+1):\n ans += dp[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]*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)]",
"dp[0][0] = 1",
"dp[0][0]",
"[0]",
"dp",
"0",
"0",
"1",
"for i, x in enumerate(X):\n for n in range(i+1, 0, -1):\n for k in range(x, 2501):\n dp[n][k] += dp[n-1][k-x]",
"i",
"x",
"enumerate(X)",
"enumerate",
"X",
"for n in range(i+1, 0, -1):\n for k in range(x, 2501):\n dp[n][k] += dp[n-1][k-x]",
"n",
"range(i+1, 0, -1)",
"range",
"i+1",
"i",
"1",
"0",
"-1",
"for k in range(x, 2501):\n dp[n][k] += dp[n-1][k-x]",
"k",
"range(x, 2501)",
"range",
"x",
"2501",
"dp[n][k] += dp[n-1][k-x]",
"dp[n][k]",
"[n]",
"dp",
"n",
"k",
"dp[n-1][k-x]",
"[n-1]",
"dp",
"n-1",
"n",
"1",
"k-x",
"k",
"x",
"ans = 0",
"ans",
"0",
"for n in range(1, N+1):\n ans += dp[n][A*n]",
"n",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"ans += dp[n][A*n]",
"ans",
"dp[n][A*n]",
"[n]",
"dp",
"n",
"A*n",
"A",
"n",
"print(ans)",
"print",
"ans",
"ans += dp[n][A*n]",
"dp[n][A*n]",
"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)]",
"[[0]*2501 for _ in range(N+1)]",
"dp",
"ans = 0",
"0",
"ans",
"N, A = map(int, input().split())",
"map(int, input().split())",
"N"
] | N, A = map(int, input().split())
X = list(map(int, input().split()))
dp = [[0]*2501 for _ in range(N+1)] # dp[n][k] := カードn枚で合計kにする選び方の数
dp[0][0] = 1
for i, x in enumerate(X):
for n in range(i+1, 0, -1):
for k in range(x, 2501):
dp[n][k] += dp[n-1][k-x]
ans = 0
for n in range(1, N+1):
ans += dp[n][A*n]
print(ans) |
[
7,
12,
13,
0,
13,
4,
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,
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,
17,
13,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
15
],
[
19,
18
],
[
18,
28
],
[
15,
29
],
[
32,
31
],
[
35,
34
],
[
41,
40
],
[
31,
40
],
[
34,
49
],
[
57,
52
],
[
34,
53
],
[
40,
56
],
[
34,
60
],
[
40,
64
],
[
34,
71
],
[
82,
79
]
] | [
"def resolve():\n N, A = list(map(int, input().split()))\n X = [int(i) - A for i in input().split()]\n d = {0: 1}\n for x in X:\n for _sum, count in list(d.items()):\n d[_sum+x] = d.get(_sum+x, 0) + count\n\n print(d[0]-1)\n \n\n\nif '__main__' == __name__:\n resolve()\n",
"def resolve():\n N, A = list(map(int, input().split()))\n X = [int(i) - A for i in input().split()]\n d = {0: 1}\n for x in X:\n for _sum, count in list(d.items()):\n d[_sum+x] = d.get(_sum+x, 0) + count\n\n print(d[0]-1)\n ",
"resolve",
"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",
"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()]",
"d = {0: 1}",
"d",
"{0: 1}",
"0",
"0",
"1",
"for x in X:\n for _sum, count in list(d.items()):\n d[_sum+x] = d.get(_sum+x, 0) + count\n\n ",
"x",
"X",
"for _sum, count in list(d.items()):\n d[_sum+x] = d.get(_sum+x, 0) + count\n\n ",
"_sum",
"count",
"list(d.items())",
"list",
"d.items()",
"d.items",
"d",
"items",
"d[_sum+x] = d.get(_sum+x, 0) + count",
"d[_sum+x]",
"d",
"_sum+x",
"_sum",
"x",
"d.get(_sum+x, 0) + count",
"d.get(_sum+x, 0)",
"d.get",
"d",
"get",
"_sum+x",
"_sum",
"x",
"0",
"count",
"print(d[0]-1)",
"print",
"d[0]-1",
"d[0]",
"d",
"0",
"1",
"if '__main__' == __name__:\n resolve()",
"'__main__' == __name__",
"'__main__'",
"__name__",
"resolve()",
"resolve",
"def resolve():\n N, A = list(map(int, input().split()))\n X = [int(i) - A for i in input().split()]\n d = {0: 1}\n for x in X:\n for _sum, count in list(d.items()):\n d[_sum+x] = d.get(_sum+x, 0) + count\n\n print(d[0]-1)\n ",
"def resolve():\n N, A = list(map(int, input().split()))\n X = [int(i) - A for i in input().split()]\n d = {0: 1}\n for x in X:\n for _sum, count in list(d.items()):\n d[_sum+x] = d.get(_sum+x, 0) + count\n\n print(d[0]-1)\n ",
"resolve"
] | def resolve():
N, A = list(map(int, input().split()))
X = [int(i) - A for i in input().split()]
d = {0: 1}
for x in X:
for _sum, count in list(d.items()):
d[_sum+x] = d.get(_sum+x, 0) + count
print(d[0]-1)
if '__main__' == __name__:
resolve()
|
[
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,
2,
17,
13,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
2,
39,
17,
13,
0,
13,
13,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
13,
14,
40,
18,
18,
13,
13,
13,
17,
0,
18,
18,
13,
2,
13,
17,
2,
13,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
17,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
18,
13,
13,
2,
13,
2,
13,
17,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
142,
2
],
[
142,
11
],
[
139,
13
],
[
145,
25
],
[
125,
29
],
[
34,
33
],
[
125,
37
],
[
146,
43
],
[
130,
45
],
[
49,
48
],
[
125,
51
],
[
133,
53
],
[
140,
55
],
[
48,
56
],
[
59,
58
],
[
125,
64
],
[
68,
67
],
[
146,
70
],
[
131,
75
],
[
58,
76
],
[
67,
77
],
[
89,
80
],
[
131,
82
],
[
58,
84
],
[
67,
87
],
[
134,
88
],
[
131,
91
],
[
58,
92
],
[
67,
93
],
[
100,
95
],
[
131,
97
],
[
134,
99
],
[
136,
102
],
[
106,
105
],
[
125,
108
],
[
127,
110
],
[
131,
113
],
[
105,
114
],
[
143,
116
],
[
105,
118
],
[
128,
122
],
[
137,
122
],
[
142,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
]
] | [
"n, a = map(int, input().split())\nl = list(map(int, input().split()))\n\nt = 50*n+1\ndp = [[0]*t for _ in range(n+1)]\n\nfor i in range(n):\n x = l[i]\n for j in reversed(range(n+1)):\n for k in range(t):\n if dp[j][k] != 0:\n dp[j+1][k+x] += dp[j][k]\n dp[0][x] += 1\n\nans = 0\nfor i in range(n):\n ans += dp[i][a*(i+1)]\n\nprint(ans)",
"n, a = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a",
"l = list(map(int, input().split()))",
"l",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t = 50*n+1",
"t",
"50*n+1",
"50*n",
"50",
"n",
"1",
"[0]*t for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"[0]*t",
"[0]",
"0",
"t",
"dp = [[0]*t for _ in range(n+1)]",
"dp",
"[[0]*t for _ in range(n+1)]",
"for i in range(n):\n x = l[i]\n for j in reversed(range(n+1)):\n for k in range(t):\n if dp[j][k] != 0:\n dp[j+1][k+x] += dp[j][k]\n dp[0][x] += 1",
"i",
"range(n)",
"range",
"n",
"x = l[i]",
"x",
"l[i]",
"l",
"i",
"for j in reversed(range(n+1)):\n for k in range(t):\n if dp[j][k] != 0:\n dp[j+1][k+x] += dp[j][k]\n ",
"j",
"reversed(range(n+1))",
"reversed",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for k in range(t):\n if dp[j][k] != 0:\n dp[j+1][k+x] += dp[j][k]\n ",
"k",
"range(t)",
"range",
"t",
"if dp[j][k] != 0:\n dp[j+1][k+x] += dp[j][k]\n ",
"dp[j][k] != 0",
"dp[j][k]",
"[j]",
"dp",
"j",
"k",
"0",
"dp[j+1][k+x] += dp[j][k]",
"dp[j+1][k+x]",
"[j+1]",
"dp",
"j+1",
"j",
"1",
"k+x",
"k",
"x",
"dp[j][k]",
"[j]",
"dp",
"j",
"k",
"dp[0][x] += 1",
"dp[0][x]",
"[0]",
"dp",
"0",
"x",
"1",
"ans = 0",
"ans",
"0",
"for i in range(n):\n ans += dp[i][a*(i+1)]",
"i",
"range(n)",
"range",
"n",
"ans += dp[i][a*(i+1)]",
"ans",
"dp[i][a*(i+1)]",
"[i]",
"dp",
"i",
"a*(i+1)",
"a",
"i+1",
"i",
"1",
"print(ans)",
"print",
"ans",
"n, a = map(int, input().split())",
"map(int, input().split())",
"n",
"ans += dp[i][a*(i+1)]",
"dp[i][a*(i+1)]",
"ans",
"dp = [[0]*t for _ in range(n+1)]",
"[[0]*t for _ in range(n+1)]",
"dp",
"x = l[i]",
"l[i]",
"x",
"ans = 0",
"0",
"ans",
"l = list(map(int, input().split()))",
"list(map(int, input().split()))",
"l",
"a = map(int, input().split())",
"map(int, input().split())",
"a",
"t = 50*n+1",
"50*n+1",
"t"
] | n, a = map(int, input().split())
l = list(map(int, input().split()))
t = 50*n+1
dp = [[0]*t for _ in range(n+1)]
for i in range(n):
x = l[i]
for j in reversed(range(n+1)):
for k in range(t):
if dp[j][k] != 0:
dp[j+1][k+x] += dp[j][k]
dp[0][x] += 1
ans = 0
for i in range(n):
ans += dp[i][a*(i+1)]
print(ans) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.