node_ids
listlengths 4
1.4k
| edge_index
listlengths 1
2.22k
| text
listlengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
17,
0,
13,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
18,
13,
13,
2,
18,
13,
13,
13,
14,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
17,
14,
2,
13,
18,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] |
[
[
117,
2
],
[
117,
11
],
[
96,
13
],
[
99,
25
],
[
118,
29
],
[
120,
31
],
[
123,
34
],
[
93,
39
],
[
43,
42
],
[
118,
45
],
[
124,
48
],
[
106,
48
],
[
97,
50
],
[
42,
51
],
[
105,
53
],
[
97,
55
],
[
42,
56
],
[
61,
58
],
[
100,
59
],
[
42,
60
],
[
97,
63
],
[
42,
64
],
[
124,
65
],
[
106,
65
],
[
94,
68
],
[
115,
68
],
[
58,
69
],
[
100,
70
],
[
42,
71
],
[
114,
73
],
[
58,
74
],
[
100,
75
],
[
42,
76
],
[
108,
78
],
[
94,
82
],
[
115,
82
],
[
58,
83
],
[
100,
84
],
[
42,
85
],
[
102,
87
],
[
103,
91
],
[
109,
91
],
[
121,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
117,
112
],
[
58,
114
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
]
] |
[
"N, T = map(int,input().split())\nprice = list(map(int,input().split()))\nbenefit = [0] * N\nans = 1\npr_low = float(\"inf\")\nbe_max = 0\nfor i in range(N):\n if pr_low > price[i]:\n pr_low = price[i]\n else:\n benefit[i] = price[i] - pr_low\n if be_max < benefit[i]:\n be_max = benefit[i]\n ans = 1\n elif be_max == benefit[i]:\n ans += 1\nprint(ans)",
"N, T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"price = list(map(int,input().split()))",
"price",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"benefit = [0] * N",
"benefit",
"[0] * N",
"[0]",
"0",
"N",
"ans = 1",
"ans",
"1",
"pr_low = float(\"inf\")",
"pr_low",
"float(\"inf\")",
"float",
"\"inf\"",
"be_max = 0",
"be_max",
"0",
"for i in range(N):\n if pr_low > price[i]:\n pr_low = price[i]\n else:\n benefit[i] = price[i] - pr_low\n if be_max < benefit[i]:\n be_max = benefit[i]\n ans = 1\n elif be_max == benefit[i]:\n ans += 1",
"i",
"range(N)",
"range",
"N",
"if pr_low > price[i]:\n pr_low = price[i]\n else:\n benefit[i] = price[i] - pr_low\n if be_max < benefit[i]:\n be_max = benefit[i]\n ans = 1\n elif be_max == benefit[i]:\n ans += 1",
"pr_low > price[i]",
"pr_low",
"price[i]",
"price",
"i",
"pr_low = price[i]",
"pr_low",
"price[i]",
"price",
"i",
"benefit[i] = price[i] - pr_low",
"benefit[i]",
"benefit",
"i",
"price[i] - pr_low",
"price[i]",
"price",
"i",
"pr_low",
"if be_max < benefit[i]:\n be_max = benefit[i]\n ans = 1\n elif be_max == benefit[i]:\n ans += 1",
"be_max < benefit[i]",
"be_max",
"benefit[i]",
"benefit",
"i",
"be_max = benefit[i]",
"be_max",
"benefit[i]",
"benefit",
"i",
"ans = 1",
"ans",
"1",
"elif be_max == benefit[i]:\n ans += 1",
"be_max == benefit[i]",
"be_max",
"benefit[i]",
"benefit",
"i",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"be_max = 0",
"0",
"be_max",
"price = list(map(int,input().split()))",
"list(map(int,input().split()))",
"price",
"benefit = [0] * N",
"[0] * N",
"benefit",
"ans += 1",
"1",
"ans",
"pr_low = price[i]",
"price[i]",
"pr_low",
"ans = 1",
"1",
"ans",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"be_max = benefit[i]",
"benefit[i]",
"be_max",
"N, T = map(int,input().split())",
"map(int,input().split())",
"N",
"ans = 1",
"1",
"ans",
"pr_low = float(\"inf\")",
"float(\"inf\")",
"pr_low"
] |
N, T = map(int,input().split())
price = list(map(int,input().split()))
benefit = [0] * N
ans = 1
pr_low = float("inf")
be_max = 0
for i in range(N):
if pr_low > price[i]:
pr_low = price[i]
else:
benefit[i] = price[i] - pr_low
if be_max < benefit[i]:
be_max = benefit[i]
ans = 1
elif be_max == benefit[i]:
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,
14,
2,
13,
17,
4,
13,
17,
4,
13,
0,
13,
39,
4,
18,
13,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
4,
13,
18,
13,
17,
18,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
4,
13,
18,
13,
2,
13,
17,
13,
0,
13,
4,
13,
18,
13,
13,
13,
4,
13,
4,
18,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
39,
13
] |
[
[
109,
2
],
[
109,
11
],
[
103,
13
],
[
107,
26
],
[
124,
34
],
[
125,
38
],
[
104,
42
],
[
104,
45
],
[
115,
48
],
[
104,
52
],
[
104,
55
],
[
118,
58
],
[
125,
60
],
[
64,
63
],
[
107,
67
],
[
125,
70
],
[
104,
74
],
[
63,
75
],
[
116,
76
],
[
122,
76
],
[
112,
78
],
[
125,
82
],
[
63,
84
],
[
119,
86
],
[
113,
86
],
[
121,
88
],
[
104,
92
],
[
63,
93
],
[
116,
94
],
[
122,
94
],
[
125,
99
],
[
113,
101
],
[
119,
101
],
[
103,
104
],
[
109,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
]
] |
[
"N, T = map(int, input().split())\na = list(map(int, input().split()))\nif N == 1:\n print(1)\n exit()\n\nans = []\nans.append(a[1] - a[0])\nmina = min(a[1], a[0])\nmaxri = ans[0]\nfor i in range(2, N):\n ans.append(a[i] - mina)\n maxri = max(ans[i - 1], maxri)\n mina = min(a[i], mina)\n\nprint(ans.count(maxri))",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"if N == 1:\n print(1)\n exit()",
"N == 1",
"N",
"1",
"print(1)",
"print",
"1",
"exit()",
"exit",
"ans = []",
"ans",
"[]",
"ans.append(a[1] - a[0])",
"ans.append",
"ans",
"append",
"a[1] - a[0]",
"a[1]",
"a",
"1",
"a[0]",
"a",
"0",
"mina = min(a[1], a[0])",
"mina",
"min(a[1], a[0])",
"min",
"a[1]",
"a",
"1",
"a[0]",
"a",
"0",
"maxri = ans[0]",
"maxri",
"ans[0]",
"ans",
"0",
"for i in range(2, N):\n ans.append(a[i] - mina)\n maxri = max(ans[i - 1], maxri)\n mina = min(a[i], mina)",
"i",
"range(2, N)",
"range",
"2",
"N",
"ans.append(a[i] - mina)",
"ans.append",
"ans",
"append",
"a[i] - mina",
"a[i]",
"a",
"i",
"mina",
"maxri = max(ans[i - 1], maxri)",
"maxri",
"max(ans[i - 1], maxri)",
"max",
"ans[i - 1]",
"ans",
"i - 1",
"i",
"1",
"maxri",
"mina = min(a[i], mina)",
"mina",
"min(a[i], mina)",
"min",
"a[i]",
"a",
"i",
"mina",
"print(ans.count(maxri))",
"print",
"ans.count(maxri)",
"ans.count",
"ans",
"count",
"maxri",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"maxri = max(ans[i - 1], maxri)",
"max(ans[i - 1], maxri)",
"maxri",
"mina = min(a[1], a[0])",
"min(a[1], a[0])",
"mina",
"maxri = ans[0]",
"ans[0]",
"maxri",
"mina = min(a[i], mina)",
"min(a[i], mina)",
"mina",
"ans = []",
"[]",
"ans"
] |
N, T = map(int, input().split())
a = list(map(int, input().split()))
if N == 1:
print(1)
exit()
ans = []
ans.append(a[1] - a[0])
mina = min(a[1], a[0])
maxri = ans[0]
for i in range(2, N):
ans.append(a[i] - mina)
maxri = max(ans[i - 1], maxri)
mina = min(a[i], mina)
print(ans.count(maxri))
|
[
7,
17,
15,
13,
15,
13,
15,
13,
15,
13,
15,
15,
13,
15,
0,
13,
18,
13,
13,
4,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
39,
17,
17,
39,
17,
17,
39,
17,
17,
39,
17,
17,
0,
13,
17,
12,
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,
39,
0,
13,
18,
13,
17,
28,
13,
18,
13,
39,
17,
14,
2,
13,
13,
4,
18,
13,
13,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
29,
17,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
12,
13,
10,
39,
13
] |
[
[
135,
15
],
[
138,
25
],
[
147,
32
],
[
141,
47
],
[
53,
52
],
[
136,
59
],
[
53,
61
],
[
65,
64
],
[
136,
68
],
[
64,
73
],
[
76,
75
],
[
79,
78
],
[
82,
81
],
[
75,
83
],
[
87,
86
],
[
75,
88
],
[
81,
93
],
[
103,
93
],
[
86,
94
],
[
78,
97
],
[
86,
100
],
[
81,
101
],
[
103,
101
],
[
104,
103
],
[
86,
104
],
[
107,
106
],
[
78,
109
],
[
112,
111
],
[
115,
114
],
[
78,
114
],
[
114,
118
],
[
106,
119
],
[
122,
121
],
[
121,
125
],
[
111,
125
],
[
145,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
147,
148
]
] |
[
"'''\n自宅用PCでの解答\n'''\nimport math\n#import numpy as np\nimport itertools\nimport queue\nimport bisect\nfrom collections import deque,defaultdict\nimport heapq as hpq\nfrom sys import stdin,setrecursionlimit\n#from scipy.sparse.csgraph import dijkstra\n#from scipy.sparse import csr_matrix\nipt = stdin.readline\nsetrecursionlimit(10**7)\nmod = 10**9+7 #998244353\ndir = [(-1,0),(0,-1),(1,0),(0,1)]\nalp = \"abcdefghijklmnopqrstuvwxyz\"\n\ndef main():\n n,t = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n bs = []\n mi = a[0]\n for i in a[1::]:\n if mi < i:\n bs.append(i-mi)\n else:\n mi = i\n ma = max(bs)\n cnt = 0\n for i in bs:\n if i == ma:\n cnt += 1\n\n print(cnt)\n return None\n\nif __name__ == '__main__':\n main()",
"'''\n自宅用PCでの解答\n'''",
"import math",
"math",
"import itertools",
"itertools",
"import queue",
"queue",
"import bisect",
"bisect",
"from collections import deque,defaultdict",
"import heapq as hpq",
"heapq",
"from sys import stdin,setrecursionlimit",
"ipt = stdin.readline",
"ipt",
"stdin.readline",
"stdin",
"readline",
"setrecursionlimit(10**7)",
"setrecursionlimit",
"10**7",
"10",
"7",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"dir = [(-1,0),(0,-1),(1,0),(0,1)]",
"dir",
"[(-1,0),(0,-1),(1,0),(0,1)]",
"(-1,0)",
"-1",
"0",
"(0,-1)",
"0",
"-1",
"(1,0)",
"1",
"0",
"(0,1)",
"0",
"1",
"alp = \"abcdefghijklmnopqrstuvwxyz\"",
"alp",
"\"abcdefghijklmnopqrstuvwxyz\"",
"def main():\n n,t = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n bs = []\n mi = a[0]\n for i in a[1::]:\n if mi < i:\n bs.append(i-mi)\n else:\n mi = i\n ma = max(bs)\n cnt = 0\n for i in bs:\n if i == ma:\n cnt += 1\n\n print(cnt)\n return None",
"main",
"n,t = map(int,ipt().split())",
"n",
"map(int,ipt().split())",
"map",
"int",
"ipt().split()",
"().split",
"()",
"ipt",
"split",
"t",
"int(i) for i in ipt().split()",
"for i in ipt().split()",
"i",
"ipt().split()",
"().split",
"()",
"ipt",
"split",
"for i in ipt().split()",
"int(i)",
"int",
"i",
"a = [int(i) for i in ipt().split()]",
"a",
"[int(i) for i in ipt().split()]",
"bs = []",
"bs",
"[]",
"mi = a[0]",
"mi",
"a[0]",
"a",
"0",
"for i in a[1::]:\n if mi < i:\n bs.append(i-mi)\n else:\n mi = i\n ",
"i",
"a[1::]",
"a",
"1::",
"1",
"if mi < i:\n bs.append(i-mi)\n else:\n mi = i\n ",
"mi < i",
"mi",
"i",
"bs.append(i-mi)",
"bs.append",
"bs",
"append",
"i-mi",
"i",
"mi",
"mi = i",
"mi",
"i",
"ma = max(bs)",
"ma",
"max(bs)",
"max",
"bs",
"cnt = 0",
"cnt",
"0",
"for i in bs:\n if i == ma:\n cnt += 1\n\n ",
"i",
"bs",
"if i == ma:\n cnt += 1\n\n ",
"i == ma",
"i",
"ma",
"cnt += 1",
"cnt",
"1",
"print(cnt)",
"print",
"cnt",
"return None",
"None",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"ipt = stdin.readline",
"stdin.readline",
"ipt",
"mod = 10**9+7",
"10**9+7",
"mod",
"alp = \"abcdefghijklmnopqrstuvwxyz\"",
"\"abcdefghijklmnopqrstuvwxyz\"",
"alp",
"def main():\n n,t = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n bs = []\n mi = a[0]\n for i in a[1::]:\n if mi < i:\n bs.append(i-mi)\n else:\n mi = i\n ma = max(bs)\n cnt = 0\n for i in bs:\n if i == ma:\n cnt += 1\n\n print(cnt)\n return None",
"def main():\n n,t = map(int,ipt().split())\n a = [int(i) for i in ipt().split()]\n bs = []\n mi = a[0]\n for i in a[1::]:\n if mi < i:\n bs.append(i-mi)\n else:\n mi = i\n ma = max(bs)\n cnt = 0\n for i in bs:\n if i == ma:\n cnt += 1\n\n print(cnt)\n return None",
"main",
"dir = [(-1,0),(0,-1),(1,0),(0,1)]",
"[(-1,0),(0,-1),(1,0),(0,1)]",
"dir"
] |
'''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7 #998244353
dir = [(-1,0),(0,-1),(1,0),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n,t = map(int,ipt().split())
a = [int(i) for i in ipt().split()]
bs = []
mi = a[0]
for i in a[1::]:
if mi < i:
bs.append(i-mi)
else:
mi = i
ma = max(bs)
cnt = 0
for i in bs:
if i == ma:
cnt += 1
print(cnt)
return None
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,
18,
13,
17,
0,
13,
18,
13,
17,
0,
13,
39,
28,
13,
4,
13,
13,
14,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
102,
2
],
[
102,
11
],
[
84,
13
],
[
87,
25
],
[
85,
27
],
[
81,
30
],
[
85,
32
],
[
93,
35
],
[
39,
38
],
[
103,
41
],
[
88,
44
],
[
91,
44
],
[
85,
46
],
[
38,
47
],
[
90,
49
],
[
85,
51
],
[
38,
52
],
[
94,
55
],
[
85,
59
],
[
38,
60
],
[
91,
61
],
[
88,
61
],
[
78,
63
],
[
94,
66
],
[
99,
68
],
[
94,
71
],
[
79,
73
],
[
100,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
102,
97
],
[
99,
100
],
[
102,
103
]
] |
[
"n, t = map(int, input().split())\na = list(map(int, input().split()))\nlowest = a[0]\nhighest = a[0]\nbaibai = []\nfor i in range(n):\n if lowest > a[i]:\n lowest = a[i]\n #print(highest, lowest)\n baibai.append(a[i]-lowest)\n\nmax_baibai = max(baibai)\nans = baibai.count(max_baibai)\n#print(baibai)\nprint(ans)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"lowest = a[0]",
"lowest",
"a[0]",
"a",
"0",
"highest = a[0]",
"highest",
"a[0]",
"a",
"0",
"baibai = []",
"baibai",
"[]",
"for i in range(n):\n if lowest > a[i]:\n lowest = a[i]\n #print(highest, lowest)\n baibai.append(a[i]-lowest)",
"i",
"range(n)",
"range",
"n",
"if lowest > a[i]:\n lowest = a[i]\n #print(highest, lowest)\n ",
"lowest > a[i]",
"lowest",
"a[i]",
"a",
"i",
"lowest = a[i]",
"lowest",
"a[i]",
"a",
"i",
"baibai.append(a[i]-lowest)",
"baibai.append",
"baibai",
"append",
"a[i]-lowest",
"a[i]",
"a",
"i",
"lowest",
"max_baibai = max(baibai)",
"max_baibai",
"max(baibai)",
"max",
"baibai",
"ans = baibai.count(max_baibai)",
"ans",
"baibai.count(max_baibai)",
"baibai.count",
"baibai",
"count",
"max_baibai",
"print(ans)",
"print",
"ans",
"max_baibai = max(baibai)",
"max(baibai)",
"max_baibai",
"highest = a[0]",
"a[0]",
"highest",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"lowest = a[0]",
"a[0]",
"lowest",
"lowest = a[i]",
"a[i]",
"lowest",
"baibai = []",
"[]",
"baibai",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"ans = baibai.count(max_baibai)",
"baibai.count(max_baibai)",
"ans",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n"
] |
n, t = map(int, input().split())
a = list(map(int, input().split()))
lowest = a[0]
highest = a[0]
baibai = []
for i in range(n):
if lowest > a[i]:
lowest = a[i]
#print(highest, lowest)
baibai.append(a[i]-lowest)
max_baibai = max(baibai)
ans = baibai.count(max_baibai)
#print(baibai)
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,
17,
15,
13,
0,
13,
39,
4,
18,
13,
13,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
13,
2,
18,
13,
13,
18,
13,
17,
0,
18,
13,
13,
17,
14,
2,
13,
2,
18,
13,
13,
18,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
17,
0,
18,
13,
13,
17,
4,
18,
13,
13,
13,
18,
13,
13,
0,
13,
4,
13,
4,
13,
4,
18,
13,
13,
4,
13,
18,
18,
13,
17,
17,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] |
[
[
132,
2
],
[
132,
11
],
[
126,
13
],
[
129,
25
],
[
135,
28
],
[
117,
33
],
[
118,
39
],
[
127,
41
],
[
45,
44
],
[
133,
48
],
[
136,
51
],
[
121,
51
],
[
127,
54
],
[
44,
55
],
[
118,
57
],
[
63,
60
],
[
130,
61
],
[
136,
62
],
[
121,
62
],
[
136,
66
],
[
121,
66
],
[
127,
69
],
[
44,
70
],
[
118,
72
],
[
120,
75
],
[
127,
78
],
[
44,
79
],
[
118,
81
],
[
87,
84
],
[
130,
85
],
[
121,
86
],
[
136,
86
],
[
118,
92
],
[
127,
94
],
[
44,
95
],
[
114,
97
],
[
130,
104
],
[
115,
110
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
132,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
]
] |
[
"n,t = map(int,input().split())\na = list(map(int,input().split()))\nmdic = {}\nmx = 0\nimport heapq\nh = []\nheapq.heappush(h,a[0])\n\nfor i in range(1,n):\n if mx == a[i]-h[0]:\n mdic[mx] += 1\n if mx < a[i]-h[0]:\n mx = a[i]-h[0]\n mdic[mx] = 1\n heapq.heappush(h,a[i])\n#print(h[0])\nmlist = sorted(list(mdic.items()))\n#print(mlist)\nprint(mlist[-1][1])\n",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mdic = {}",
"mdic",
"{}",
"mx = 0",
"mx",
"0",
"import heapq",
"heapq",
"h = []",
"h",
"[]",
"heapq.heappush(h,a[0])",
"heapq.heappush",
"heapq",
"heappush",
"h",
"a[0]",
"a",
"0",
"for i in range(1,n):\n if mx == a[i]-h[0]:\n mdic[mx] += 1\n if mx < a[i]-h[0]:\n mx = a[i]-h[0]\n mdic[mx] = 1\n heapq.heappush(h,a[i])\n#print(h[0])",
"i",
"range(1,n)",
"range",
"1",
"n",
"if mx == a[i]-h[0]:\n mdic[mx] += 1\n ",
"mx == a[i]-h[0]",
"mx",
"a[i]-h[0]",
"a[i]",
"a",
"i",
"h[0]",
"h",
"0",
"mdic[mx] += 1",
"mdic[mx]",
"mdic",
"mx",
"1",
"if mx < a[i]-h[0]:\n mx = a[i]-h[0]\n mdic[mx] = 1\n ",
"mx < a[i]-h[0]",
"mx",
"a[i]-h[0]",
"a[i]",
"a",
"i",
"h[0]",
"h",
"0",
"mx = a[i]-h[0]",
"mx",
"a[i]-h[0]",
"a[i]",
"a",
"i",
"h[0]",
"h",
"0",
"mdic[mx] = 1",
"mdic[mx]",
"mdic",
"mx",
"1",
"heapq.heappush(h,a[i])",
"heapq.heappush",
"heapq",
"heappush",
"h",
"a[i]",
"a",
"i",
"mlist = sorted(list(mdic.items()))",
"mlist",
"sorted(list(mdic.items()))",
"sorted",
"list(mdic.items())",
"list",
"mdic.items()",
"mdic.items",
"mdic",
"items",
"print(mlist[-1][1])",
"print",
"mlist[-1][1]",
"[-1]",
"mlist",
"-1",
"1",
"mlist = sorted(list(mdic.items()))",
"sorted(list(mdic.items()))",
"mlist",
"h = []",
"[]",
"h",
"mx = a[i]-h[0]",
"a[i]-h[0]",
"mx",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"mdic = {}",
"{}",
"mdic",
"n,t = map(int,input().split())",
"map(int,input().split())",
"n",
"mx = 0",
"0",
"mx"
] |
n,t = map(int,input().split())
a = list(map(int,input().split()))
mdic = {}
mx = 0
import heapq
h = []
heapq.heappush(h,a[0])
for i in range(1,n):
if mx == a[i]-h[0]:
mdic[mx] += 1
if mx < a[i]-h[0]:
mx = a[i]-h[0]
mdic[mx] = 1
heapq.heappush(h,a[i])
#print(h[0])
mlist = sorted(list(mdic.items()))
#print(mlist)
print(mlist[-1][1])
|
[
7,
15,
13,
15,
13,
12,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
17,
0,
13,
39,
4,
18,
13,
13,
13,
28,
13,
4,
13,
13,
14,
2,
13,
13,
0,
13,
17,
13,
4,
18,
13,
13,
13,
42,
2,
4,
13,
13,
17,
0,
13,
4,
18,
13,
13,
13,
14,
2,
13,
13,
4,
13,
13,
14,
2,
13,
17,
10,
12,
13
] |
[
[
9,
8
],
[
9,
23
],
[
26,
25
],
[
42,
41
],
[
45,
44
],
[
44,
50
],
[
53,
52
],
[
25,
55
],
[
52,
58
],
[
41,
59
],
[
62,
61
],
[
64,
63
],
[
44,
68
],
[
44,
73
],
[
77,
76
],
[
44,
81
],
[
63,
84
],
[
76,
85
],
[
61,
88
]
] |
[
"import sys\nimport heapq\ndef v():\n N,T=tuple(map(int,sys.stdin.readline().split()))\n A=list(map(int,sys.stdin.readline().split()))\n ma=0\n d=[]\n heapq.heapify(d)\n for a in reversed(A):\n if a<ma:heapq.heappush(d,a-ma)\n else:ma=a\n res,x=1,heapq.heappop(d)\n while len(d)>0:\n y=heapq.heappop(d)\n if x==y:res+=1\n print(res)\nif __name__=='__main__':v()",
"import sys",
"sys",
"import heapq",
"heapq",
"def v():\n N,T=tuple(map(int,sys.stdin.readline().split()))\n A=list(map(int,sys.stdin.readline().split()))\n ma=0\n d=[]\n heapq.heapify(d)\n for a in reversed(A):\n if a<ma:heapq.heappush(d,a-ma)\n else:ma=a\n res,x=1,heapq.heappop(d)\n while len(d)>0:\n y=heapq.heappop(d)\n if x==y:res+=1\n print(res)",
"v",
"N,T=tuple(map(int,sys.stdin.readline().split()))",
"N",
"tuple(map(int,sys.stdin.readline().split()))",
"tuple",
"map(int,sys.stdin.readline().split())",
"map",
"int",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"T",
"A=list(map(int,sys.stdin.readline().split()))",
"A",
"list(map(int,sys.stdin.readline().split()))",
"list",
"map(int,sys.stdin.readline().split())",
"map",
"int",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"ma=0",
"ma",
"0",
"d=[]",
"d",
"[]",
"heapq.heapify(d)",
"heapq.heapify",
"heapq",
"heapify",
"d",
"for a in reversed(A):\n if a<ma:heapq.heappush(d,a-ma)\n else:ma=a\n ",
"a",
"reversed(A)",
"reversed",
"A",
"if a<ma:heapq.heappush(d,a-ma)\n else:ma=a\n ",
"a<ma",
"a",
"ma",
"res,x=1,heapq.heappop(d)",
"res",
"1",
"x",
"heapq.heappop(d)",
"heapq.heappop",
"heapq",
"heappop",
"d",
"while len(d)>0:\n y=heapq.heappop(d)\n if x==y:res+=1\n ",
"len(d)>0",
"len(d)",
"len",
"d",
"0",
"y=heapq.heappop(d)",
"y",
"heapq.heappop(d)",
"heapq.heappop",
"heapq",
"heappop",
"d",
"if x==y:res+=1\n ",
"x==y",
"x",
"y",
"print(res)",
"print",
"res",
"if __name__=='__main__':v()",
"__name__=='__main__'",
"__name__",
"'__main__'",
"def v():\n N,T=tuple(map(int,sys.stdin.readline().split()))\n A=list(map(int,sys.stdin.readline().split()))\n ma=0\n d=[]\n heapq.heapify(d)\n for a in reversed(A):\n if a<ma:heapq.heappush(d,a-ma)\n else:ma=a\n res,x=1,heapq.heappop(d)\n while len(d)>0:\n y=heapq.heappop(d)\n if x==y:res+=1\n print(res)",
"def v():\n N,T=tuple(map(int,sys.stdin.readline().split()))\n A=list(map(int,sys.stdin.readline().split()))\n ma=0\n d=[]\n heapq.heapify(d)\n for a in reversed(A):\n if a<ma:heapq.heappush(d,a-ma)\n else:ma=a\n res,x=1,heapq.heappop(d)\n while len(d)>0:\n y=heapq.heappop(d)\n if x==y:res+=1\n print(res)",
"v"
] |
import sys
import heapq
def v():
N,T=tuple(map(int,sys.stdin.readline().split()))
A=list(map(int,sys.stdin.readline().split()))
ma=0
d=[]
heapq.heapify(d)
for a in reversed(A):
if a<ma:heapq.heappush(d,a-ma)
else:ma=a
res,x=1,heapq.heappop(d)
while len(d)>0:
y=heapq.heappop(d)
if x==y:res+=1
print(res)
if __name__=='__main__':v()
|
[
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,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
15,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
39,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
2,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
12,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13
] |
[
[
26,
25
],
[
135,
31
],
[
35,
35
],
[
137,
44
],
[
167,
49
],
[
170,
57
],
[
135,
59
],
[
170,
60
],
[
155,
62
],
[
147,
64
],
[
152,
66
],
[
128,
69
],
[
156,
71
],
[
149,
74
],
[
78,
77
],
[
171,
80
],
[
156,
84
],
[
77,
85
],
[
129,
86
],
[
141,
86
],
[
140,
88
],
[
156,
90
],
[
77,
91
],
[
153,
94
],
[
150,
96
],
[
162,
96
],
[
144,
96
],
[
143,
98
],
[
161,
101
],
[
150,
104
],
[
162,
104
],
[
144,
104
],
[
156,
107
],
[
77,
108
],
[
129,
109
],
[
141,
109
],
[
153,
112
],
[
162,
114
],
[
144,
114
],
[
150,
114
],
[
153,
119
],
[
153,
123
],
[
170,
126
],
[
128,
129
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
149,
150
],
[
152,
153
],
[
155,
156
],
[
161,
162
],
[
167,
168
],
[
170,
171
]
] |
[
"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 = float('inf')\nmod = 10 ** 9 + 7 \n#mod = 998244353\nfrom decimal import *\n#import numpy as np\n#decimal.getcontext().prec = 10\n\nN, T = MAP()\nA = LIST()\n\nlis = []\ntmp = A[0]\ntmp_max = 0\nfor i in range(N):\n\tif A[i] < tmp:\n\t\ttmp = A[i]\n\t\tlis.append(tmp_max)\n\t\ttmp_max = 0\n\telse:\n\t\ttmp_max = max(tmp_max, A[i]-tmp)\nlis.append(tmp_max)\n\nprint(lis.count(max(lis)))",
"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 = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"from decimal import *",
"N, T = MAP()",
"N",
"MAP()",
"MAP",
"T",
"A = LIST()",
"A",
"LIST()",
"LIST",
"lis = []",
"lis",
"[]",
"tmp = A[0]",
"tmp",
"A[0]",
"A",
"0",
"tmp_max = 0",
"tmp_max",
"0",
"for i in range(N):\n\tif A[i] < tmp:\n\t\ttmp = A[i]\n\t\tlis.append(tmp_max)\n\t\ttmp_max = 0\n\telse:\n\t\ttmp_max = max(tmp_max, A[i]-tmp)",
"i",
"range(N)",
"range",
"N",
"if A[i] < tmp:\n\t\ttmp = A[i]\n\t\tlis.append(tmp_max)\n\t\ttmp_max = 0\n\telse:\n\t\ttmp_max = max(tmp_max, A[i]-tmp)",
"A[i] < tmp",
"A[i]",
"A",
"i",
"tmp",
"tmp = A[i]",
"tmp",
"A[i]",
"A",
"i",
"lis.append(tmp_max)",
"lis.append",
"lis",
"append",
"tmp_max",
"tmp_max = 0",
"tmp_max",
"0",
"tmp_max = max(tmp_max, A[i]-tmp)",
"tmp_max",
"max(tmp_max, A[i]-tmp)",
"max",
"tmp_max",
"A[i]-tmp",
"A[i]",
"A",
"i",
"tmp",
"lis.append(tmp_max)",
"lis.append",
"lis",
"append",
"tmp_max",
"print(lis.count(max(lis)))",
"print",
"lis.count(max(lis))",
"lis.count",
"lis",
"count",
"max(lis)",
"max",
"lis",
"T = MAP()",
"MAP()",
"T",
"tmp = A[0]",
"A[0]",
"tmp",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"INF = float('inf')",
"float('inf')",
"INF",
"tmp = A[i]",
"A[i]",
"tmp",
"tmp_max = 0",
"0",
"tmp_max",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"tmp_max = 0",
"0",
"tmp_max",
"lis = []",
"[]",
"lis",
"A = LIST()",
"LIST()",
"A",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"tmp_max = max(tmp_max, A[i]-tmp)",
"max(tmp_max, A[i]-tmp)",
"tmp_max",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"N, T = MAP()",
"MAP()",
"N",
"def TUPLE(): return tuple(map(int, input().split()))",
"def TUPLE(): return tuple(map(int, input().split()))",
"TUPLE"
] |
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 = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, T = MAP()
A = LIST()
lis = []
tmp = A[0]
tmp_max = 0
for i in range(N):
if A[i] < tmp:
tmp = A[i]
lis.append(tmp_max)
tmp_max = 0
else:
tmp_max = max(tmp_max, A[i]-tmp)
lis.append(tmp_max)
print(lis.count(max(lis)))
|
[
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,
18,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
4,
13,
13,
18,
13,
2,
13,
17,
14,
2,
13,
2,
18,
13,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
17,
14,
2,
13,
2,
18,
13,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] |
[
[
105,
2
],
[
105,
11
],
[
87,
13
],
[
108,
25
],
[
88,
27
],
[
102,
30
],
[
99,
33
],
[
37,
36
],
[
94,
40
],
[
96,
42
],
[
109,
45
],
[
97,
45
],
[
88,
47
],
[
36,
49
],
[
103,
53
],
[
91,
53
],
[
88,
56
],
[
36,
57
],
[
97,
58
],
[
109,
58
],
[
90,
60
],
[
88,
63
],
[
36,
64
],
[
97,
65
],
[
109,
65
],
[
111,
67
],
[
103,
71
],
[
91,
71
],
[
88,
74
],
[
36,
75
],
[
97,
76
],
[
109,
76
],
[
84,
78
],
[
85,
82
],
[
112,
82
],
[
100,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
105,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
]
] |
[
"n,t = map(int, input().split())\na = list(map(int, input().split()))\nmin_a = a[0]\nmin_b = 0\ncnt = 0\nfor i in range(1, n):\n min_a = min(min_a, a[i-1])\n if min_b < a[i]-min_a:\n min_b = a[i]-min_a\n cnt = 1\n elif min_b == a[i]-min_a:\n cnt += 1\nprint(cnt)",
"n,t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_a = a[0]",
"min_a",
"a[0]",
"a",
"0",
"min_b = 0",
"min_b",
"0",
"cnt = 0",
"cnt",
"0",
"for i in range(1, n):\n min_a = min(min_a, a[i-1])\n if min_b < a[i]-min_a:\n min_b = a[i]-min_a\n cnt = 1\n elif min_b == a[i]-min_a:\n cnt += 1",
"i",
"range(1, n)",
"range",
"1",
"n",
"min_a = min(min_a, a[i-1])",
"min_a",
"min(min_a, a[i-1])",
"min",
"min_a",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"if min_b < a[i]-min_a:\n min_b = a[i]-min_a\n cnt = 1\n elif min_b == a[i]-min_a:\n cnt += 1",
"min_b < a[i]-min_a",
"min_b",
"a[i]-min_a",
"a[i]",
"a",
"i",
"min_a",
"min_b = a[i]-min_a",
"min_b",
"a[i]-min_a",
"a[i]",
"a",
"i",
"min_a",
"cnt = 1",
"cnt",
"1",
"elif min_b == a[i]-min_a:\n cnt += 1",
"min_b == a[i]-min_a",
"min_b",
"a[i]-min_a",
"a[i]",
"a",
"i",
"min_a",
"cnt += 1",
"cnt",
"1",
"print(cnt)",
"print",
"cnt",
"cnt += 1",
"1",
"cnt",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"min_b = a[i]-min_a",
"a[i]-min_a",
"min_b",
"n,t = map(int, input().split())",
"map(int, input().split())",
"n",
"min_a = min(min_a, a[i-1])",
"min(min_a, a[i-1])",
"min_a",
"cnt = 0",
"0",
"cnt",
"min_b = 0",
"0",
"min_b",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"min_a = a[0]",
"a[0]",
"min_a",
"cnt = 1",
"1",
"cnt"
] |
n,t = map(int, input().split())
a = list(map(int, input().split()))
min_a = a[0]
min_b = 0
cnt = 0
for i in range(1, n):
min_a = min(min_a, a[i-1])
if min_b < a[i]-min_a:
min_b = a[i]-min_a
cnt = 1
elif min_b == a[i]-min_a:
cnt += 1
print(cnt)
|
[
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,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
18,
13,
13,
2,
4,
18,
13,
13,
13,
17,
17,
4,
13,
18,
13,
4,
13,
4,
18,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] |
[
[
78,
2
],
[
78,
11
],
[
81,
13
],
[
84,
25
],
[
93,
30
],
[
34,
33
],
[
79,
36
],
[
87,
38
],
[
85,
41
],
[
88,
41
],
[
82,
43
],
[
33,
44
],
[
90,
46
],
[
82,
49
],
[
33,
50
],
[
88,
51
],
[
85,
51
],
[
56,
53
],
[
94,
54
],
[
91,
55
],
[
94,
59
],
[
91,
61
],
[
94,
67
],
[
94,
72
],
[
78,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
]
] |
[
"# 2019/10/09\n# 解説かんにんぐ\n\nn,t=map(int,input().split())\na=list(map(int,input().split()))\nmin_a=float('inf')\ncost={}\nfor i in range(n):\n min_a=min(min_a,a[i])\n c=a[i]-min_a\n cost[c]=cost.get(c,0)+1\nprint(cost[max(cost.keys())])",
"n,t=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_a=float('inf')",
"min_a",
"float('inf')",
"float",
"'inf'",
"cost={}",
"cost",
"{}",
"for i in range(n):\n min_a=min(min_a,a[i])\n c=a[i]-min_a\n cost[c]=cost.get(c,0)+1",
"i",
"range(n)",
"range",
"n",
"min_a=min(min_a,a[i])",
"min_a",
"min(min_a,a[i])",
"min",
"min_a",
"a[i]",
"a",
"i",
"c=a[i]-min_a",
"c",
"a[i]-min_a",
"a[i]",
"a",
"i",
"min_a",
"cost[c]=cost.get(c,0)+1",
"cost[c]",
"cost",
"c",
"cost.get(c,0)+1",
"cost.get(c,0)",
"cost.get",
"cost",
"get",
"c",
"0",
"1",
"print(cost[max(cost.keys())])",
"print",
"cost[max(cost.keys())]",
"cost",
"max(cost.keys())",
"max",
"cost.keys()",
"cost.keys",
"cost",
"keys",
"t=map(int,input().split())",
"map(int,input().split())",
"t",
"n,t=map(int,input().split())",
"map(int,input().split())",
"n",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"min_a=float('inf')",
"float('inf')",
"min_a",
"min_a=min(min_a,a[i])",
"min(min_a,a[i])",
"min_a",
"c=a[i]-min_a",
"a[i]-min_a",
"c",
"cost={}",
"{}",
"cost"
] |
# 2019/10/09
# 解説かんにんぐ
n,t=map(int,input().split())
a=list(map(int,input().split()))
min_a=float('inf')
cost={}
for i in range(n):
min_a=min(min_a,a[i])
c=a[i]-min_a
cost[c]=cost.get(c,0)+1
print(cost[max(cost.keys())])
|
[
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,
17,
0,
13,
17,
0,
13,
39,
28,
13,
13,
4,
13,
13,
4,
18,
13,
13,
39,
2,
13,
13,
13,
13,
14,
2,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
13,
4,
18,
13,
13,
0,
13,
17,
41,
28,
13,
13,
13,
13,
2,
13,
18,
18,
13,
17,
17,
4,
13,
0,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13
] |
[
[
121,
2
],
[
121,
11
],
[
118,
13
],
[
106,
25
],
[
127,
30
],
[
115,
33
],
[
119,
40
],
[
116,
43
],
[
107,
48
],
[
104,
48
],
[
107,
54
],
[
104,
54
],
[
124,
56
],
[
103,
59
],
[
107,
62
],
[
104,
62
],
[
116,
66
],
[
70,
69
],
[
116,
81
],
[
130,
87
],
[
109,
90
],
[
131,
95
],
[
116,
95
],
[
131,
98
],
[
116,
98
],
[
110,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
121,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
]
] |
[
"N, T = map(int, input().split())\nA = list(map(int, input().split()))\n\nmi = 10**18\nmiCnt = 1\nS = []\nfor i, a in enumerate(A):\n S.append((a - mi, i, miCnt))\n if a == mi:\n miCnt += 1\n mi = min(mi, a)\n\nS.sort(reverse=True)\nS = [c for v, i, c in S if v == S[0][0]]\nans = min(len(S), sum(S))\nprint(ans)",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mi = 10**18",
"mi",
"10**18",
"10",
"18",
"miCnt = 1",
"miCnt",
"1",
"S = []",
"S",
"[]",
"for i, a in enumerate(A):\n S.append((a - mi, i, miCnt))\n if a == mi:\n miCnt += 1\n mi = min(mi, a)",
"i",
"a",
"enumerate(A)",
"enumerate",
"A",
"S.append((a - mi, i, miCnt))",
"S.append",
"S",
"append",
"(a - mi, i, miCnt)",
"a - mi",
"a",
"mi",
"i",
"miCnt",
"if a == mi:\n miCnt += 1\n ",
"a == mi",
"a",
"mi",
"miCnt += 1",
"miCnt",
"1",
"mi = min(mi, a)",
"mi",
"min(mi, a)",
"min",
"mi",
"a",
"S.sort(reverse=True)",
"S.sort",
"S",
"sort",
"reverse=True",
"reverse",
"True",
"c for v, i, c in S if v == S[0][0]",
"for v, i, c in S if v == S[0][0]",
"v",
"i",
"c",
"S",
"v == S[0][0]",
"v",
"S[0][0]",
"[0]",
"S",
"0",
"0",
"if v == S[0][0]",
"c",
"S = [c for v, i, c in S if v == S[0][0]]",
"S",
"[c for v, i, c in S if v == S[0][0]]",
"ans = min(len(S), sum(S))",
"ans",
"min(len(S), sum(S))",
"min",
"len(S)",
"len",
"S",
"sum(S)",
"sum",
"S",
"print(ans)",
"print",
"ans",
"mi = min(mi, a)",
"min(mi, a)",
"mi",
"mi = 10**18",
"10**18",
"mi",
"ans = min(len(S), sum(S))",
"min(len(S), sum(S))",
"ans",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"S = []",
"[]",
"S",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"miCnt += 1",
"1",
"miCnt",
"miCnt = 1",
"1",
"miCnt",
"S = [c for v, i, c in S if v == S[0][0]]",
"[c for v, i, c in S if v == S[0][0]]",
"S"
] |
N, T = map(int, input().split())
A = list(map(int, input().split()))
mi = 10**18
miCnt = 1
S = []
for i, a in enumerate(A):
S.append((a - mi, i, miCnt))
if a == mi:
miCnt += 1
mi = min(mi, a)
S.sort(reverse=True)
S = [c for v, i, c in S if v == S[0][0]]
ans = min(len(S), sum(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,
0,
13,
2,
39,
39,
18,
13,
17,
17,
2,
39,
39,
17,
17,
2,
13,
17,
28,
13,
4,
13,
17,
13,
14,
40,
18,
18,
13,
2,
13,
17,
17,
18,
13,
13,
0,
13,
2,
2,
39,
39,
17,
17,
2,
13,
17,
39,
39,
18,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
40,
18,
18,
13,
13,
17,
18,
13,
13,
0,
13,
40,
4,
13,
17,
0,
13,
39,
0,
13,
17,
28,
13,
13,
4,
13,
13,
13,
14,
2,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
39,
13,
14,
2,
13,
2,
18,
13,
17,
18,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
4,
13,
4,
13,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
40,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13
] |
[
[
184,
2
],
[
184,
11
],
[
181,
13
],
[
172,
25
],
[
182,
30
],
[
170,
39
],
[
43,
42
],
[
170,
46
],
[
173,
51
],
[
42,
53
],
[
182,
57
],
[
42,
58
],
[
163,
60
],
[
170,
68
],
[
182,
73
],
[
170,
76
],
[
80,
79
],
[
170,
83
],
[
164,
91
],
[
79,
92
],
[
182,
95
],
[
79,
96
],
[
175,
98
],
[
166,
104
],
[
190,
107
],
[
173,
114
],
[
164,
115
],
[
176,
118
],
[
194,
118
],
[
193,
127
],
[
178,
136
],
[
176,
141
],
[
194,
141
],
[
167,
151
],
[
179,
151
],
[
191,
153
],
[
188,
153
],
[
187,
155
],
[
179,
161
],
[
167,
161
],
[
163,
164
],
[
166,
167
],
[
184,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
],
[
181,
182
],
[
184,
185
],
[
187,
188
],
[
190,
191
],
[
193,
194
]
] |
[
"N,T = map(int,input().split())\nA = list(map(int,input().split()))\nminA = [[A[0],0]] + [[-1,-1]]*(N-1)\nfor i in range(1,N):\n if minA[i-1][0] >= A[i]: minA[i] = [A[i],i]\n else: minA[i] = minA[i-1]\n \nmaxA = [[-1,-1]]*(N-1) + [[A[-1],N-1]]\nfor i in range(N-2,-1,-1):\n if maxA[i][0] <= A[i]: maxA[i] = [A[i],i]\n else: maxA[i] = maxA[i-1]\n\nmax_dif = -float('inf')\nmax_i = []\ncnt = 0\nfor mina, maxa in zip(minA, maxA):\n if max_dif < maxa[0]-mina[0]:\n max_dif = maxa[0]-mina[0]\n max_i = [cnt]\n elif max_dif == maxa[0]-mina[0]:\n max_i.append(cnt)\n cnt += 1\n\nprint(len(max_i))",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"minA = [[A[0],0]] + [[-1,-1]]*(N-1)",
"minA",
"[[A[0],0]] + [[-1,-1]]*(N-1)",
"[[A[0],0]]",
"[A[0],0]",
"A[0]",
"A",
"0",
"0",
"[[-1,-1]]*(N-1)",
"[[-1,-1]]",
"[-1,-1]",
"-1",
"-1",
"N-1",
"N",
"1",
"for i in range(1,N):\n if minA[i-1][0] >= A[i]: minA[i] = [A[i],i]\n else: minA[i] = minA[i-1]\n ",
"i",
"range(1,N)",
"range",
"1",
"N",
"if minA[i-1][0] >= A[i]: minA[i] = [A[i],i]\n else: minA[i] = minA[i-1]\n ",
"minA[i-1][0] >= A[i]",
"minA[i-1][0]",
"[i-1]",
"minA",
"i-1",
"i",
"1",
"0",
"A[i]",
"A",
"i",
"maxA = [[-1,-1]]*(N-1) + [[A[-1],N-1]]",
"maxA",
"[[-1,-1]]*(N-1) + [[A[-1],N-1]]",
"[[-1,-1]]*(N-1)",
"[[-1,-1]]",
"[-1,-1]",
"-1",
"-1",
"N-1",
"N",
"1",
"[[A[-1],N-1]]",
"[A[-1],N-1]",
"A[-1]",
"A",
"-1",
"N-1",
"N",
"1",
"for i in range(N-2,-1,-1):\n if maxA[i][0] <= A[i]: maxA[i] = [A[i],i]\n else: maxA[i] = maxA[i-1]",
"i",
"range(N-2,-1,-1)",
"range",
"N-2",
"N",
"2",
"-1",
"-1",
"if maxA[i][0] <= A[i]: maxA[i] = [A[i],i]\n else: maxA[i] = maxA[i-1]",
"maxA[i][0] <= A[i]",
"maxA[i][0]",
"[i]",
"maxA",
"i",
"0",
"A[i]",
"A",
"i",
"max_dif = -float('inf')",
"max_dif",
"-float('inf')",
"float('inf')",
"float",
"'inf'",
"max_i = []",
"max_i",
"[]",
"cnt = 0",
"cnt",
"0",
"for mina, maxa in zip(minA, maxA):\n if max_dif < maxa[0]-mina[0]:\n max_dif = maxa[0]-mina[0]\n max_i = [cnt]\n elif max_dif == maxa[0]-mina[0]:\n max_i.append(cnt)\n cnt += 1",
"mina",
"maxa",
"zip(minA, maxA)",
"zip",
"minA",
"maxA",
"if max_dif < maxa[0]-mina[0]:\n max_dif = maxa[0]-mina[0]\n max_i = [cnt]\n elif max_dif == maxa[0]-mina[0]:\n max_i.append(cnt)\n ",
"max_dif < maxa[0]-mina[0]",
"max_dif",
"maxa[0]-mina[0]",
"maxa[0]",
"maxa",
"0",
"mina[0]",
"mina",
"0",
"max_dif = maxa[0]-mina[0]",
"max_dif",
"maxa[0]-mina[0]",
"maxa[0]",
"maxa",
"0",
"mina[0]",
"mina",
"0",
"max_i = [cnt]",
"max_i",
"[cnt]",
"cnt",
"elif max_dif == maxa[0]-mina[0]:\n max_i.append(cnt)\n ",
"max_dif == maxa[0]-mina[0]",
"max_dif",
"maxa[0]-mina[0]",
"maxa[0]",
"maxa",
"0",
"mina[0]",
"mina",
"0",
"max_i.append(cnt)",
"max_i.append",
"max_i",
"append",
"cnt",
"cnt += 1",
"cnt",
"1",
"print(len(max_i))",
"print",
"len(max_i)",
"len",
"max_i",
"maxA = [[-1,-1]]*(N-1) + [[A[-1],N-1]]",
"[[-1,-1]]*(N-1) + [[A[-1],N-1]]",
"maxA",
"max_i = []",
"[]",
"max_i",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"minA = [[A[0],0]] + [[-1,-1]]*(N-1)",
"[[A[0],0]] + [[-1,-1]]*(N-1)",
"minA",
"max_dif = -float('inf')",
"-float('inf')",
"max_dif",
"max_i = [cnt]",
"[cnt]",
"max_i",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"cnt += 1",
"1",
"cnt",
"cnt = 0",
"0",
"cnt",
"max_dif = maxa[0]-mina[0]",
"maxa[0]-mina[0]",
"max_dif"
] |
N,T = map(int,input().split())
A = list(map(int,input().split()))
minA = [[A[0],0]] + [[-1,-1]]*(N-1)
for i in range(1,N):
if minA[i-1][0] >= A[i]: minA[i] = [A[i],i]
else: minA[i] = minA[i-1]
maxA = [[-1,-1]]*(N-1) + [[A[-1],N-1]]
for i in range(N-2,-1,-1):
if maxA[i][0] <= A[i]: maxA[i] = [A[i],i]
else: maxA[i] = maxA[i-1]
max_dif = -float('inf')
max_i = []
cnt = 0
for mina, maxa in zip(minA, maxA):
if max_dif < maxa[0]-mina[0]:
max_dif = maxa[0]-mina[0]
max_i = [cnt]
elif max_dif == maxa[0]-mina[0]:
max_i.append(cnt)
cnt += 1
print(len(max_i))
|
[
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,
18,
13,
17,
0,
13,
39,
28,
13,
13,
14,
2,
13,
13,
0,
13,
13,
4,
18,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13
] |
[
[
83,
2
],
[
83,
11
],
[
68,
13
],
[
74,
25
],
[
69,
27
],
[
80,
30
],
[
34,
33
],
[
69,
33
],
[
75,
37
],
[
72,
37
],
[
33,
38
],
[
71,
40
],
[
33,
41
],
[
81,
44
],
[
33,
47
],
[
72,
48
],
[
75,
48
],
[
86,
50
],
[
81,
53
],
[
77,
55
],
[
81,
58
],
[
87,
60
],
[
78,
63
],
[
83,
66
],
[
68,
69
],
[
33,
71
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] |
[
"N,T = map(int,input().split())\nA_s = list(map(int,input().split()))\nMIN = A_s[0]\nDIVS = []\nfor A in A_s:\n if MIN > A:\n MIN = A\n DIVS.append(A-MIN)\nMAX = max(DIVS)\nanswer = DIVS.count(MAX)\nprint(answer)",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A_s = list(map(int,input().split()))",
"A_s",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"MIN = A_s[0]",
"MIN",
"A_s[0]",
"A_s",
"0",
"DIVS = []",
"DIVS",
"[]",
"for A in A_s:\n if MIN > A:\n MIN = A\n DIVS.append(A-MIN)",
"A",
"A_s",
"if MIN > A:\n MIN = A\n ",
"MIN > A",
"MIN",
"A",
"MIN = A",
"MIN",
"A",
"DIVS.append(A-MIN)",
"DIVS.append",
"DIVS",
"append",
"A-MIN",
"A",
"MIN",
"MAX = max(DIVS)",
"MAX",
"max(DIVS)",
"max",
"DIVS",
"answer = DIVS.count(MAX)",
"answer",
"DIVS.count(MAX)",
"DIVS.count",
"DIVS",
"count",
"MAX",
"print(answer)",
"print",
"answer",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"A_s = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A_s",
"MIN = A",
"A",
"MIN",
"MIN = A_s[0]",
"A_s[0]",
"MIN",
"answer = DIVS.count(MAX)",
"DIVS.count(MAX)",
"answer",
"DIVS = []",
"[]",
"DIVS",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"MAX = max(DIVS)",
"max(DIVS)",
"MAX"
] |
N,T = map(int,input().split())
A_s = list(map(int,input().split()))
MIN = A_s[0]
DIVS = []
for A in A_s:
if MIN > A:
MIN = A
DIVS.append(A-MIN)
MAX = max(DIVS)
answer = DIVS.count(MAX)
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,
13,
4,
17,
0,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
18,
13,
13,
17,
0,
13,
13,
0,
18,
13,
13,
2,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
13,
0,
13,
39,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
2,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
17,
17,
0,
13,
18,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
28,
13,
4,
13,
13,
13,
17,
14,
2,
18,
13,
13,
13,
0,
13,
17,
0,
13,
13,
4,
13,
13,
10,
18,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
13,
13,
10,
13,
13
] |
[
[
214,
2
],
[
214,
11
],
[
199,
13
],
[
27,
26
],
[
215,
29
],
[
229,
33
],
[
178,
36
],
[
200,
38
],
[
42,
41
],
[
215,
45
],
[
193,
50
],
[
200,
52
],
[
41,
53
],
[
194,
56
],
[
179,
57
],
[
197,
57
],
[
62,
59
],
[
230,
60
],
[
41,
61
],
[
196,
64
],
[
194,
65
],
[
70,
67
],
[
230,
68
],
[
41,
69
],
[
179,
71
],
[
197,
71
],
[
194,
72
],
[
187,
74
],
[
181,
77
],
[
81,
80
],
[
215,
83
],
[
226,
85
],
[
67,
86
],
[
59,
86
],
[
230,
87
],
[
80,
88
],
[
227,
91
],
[
188,
92
],
[
233,
92
],
[
223,
94
],
[
200,
97
],
[
80,
98
],
[
227,
99
],
[
232,
101
],
[
227,
102
],
[
202,
104
],
[
108,
107
],
[
215,
110
],
[
67,
113
],
[
59,
113
],
[
230,
114
],
[
107,
115
],
[
233,
116
],
[
188,
116
],
[
203,
119
],
[
107,
121
],
[
220,
123
],
[
208,
126
],
[
215,
128
],
[
132,
131
],
[
203,
137
],
[
217,
142
],
[
203,
144
],
[
131,
145
],
[
211,
147
],
[
200,
150
],
[
218,
151
],
[
230,
153
],
[
218,
154
],
[
157,
156
],
[
209,
159
],
[
185,
159
],
[
218,
160
],
[
200,
165
],
[
156,
166
],
[
212,
167
],
[
224,
167
],
[
182,
167
],
[
197,
167
],
[
179,
167
],
[
190,
169
],
[
184,
172
],
[
218,
173
],
[
191,
176
],
[
221,
176
],
[
178,
179
],
[
181,
182
],
[
218,
184
],
[
184,
185
],
[
187,
188
],
[
190,
191
],
[
193,
194
],
[
194,
196
],
[
196,
197
],
[
199,
200
],
[
202,
203
],
[
214,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
67,
226
],
[
59,
226
],
[
226,
227
],
[
229,
230
],
[
227,
232
],
[
232,
233
]
] |
[
"N,T = map(int,input().split())\nA = list(map(int,input().split()))\nB = [0 for _ in range(N)]\namax = A[-1]\nfor i in range(N-2,-1,-1):\n a = A[i]\n if a>amax:\n B[i] = 0\n amax = a\n else:\n B[i] = amax-a\nbmax = 0\namax = 0\nfor i in range(N):\n b = B[i]\n if b>bmax:\n amax = A[i]+b\n bmax = b\nInd = []\nfor i in range(N):\n if B[i]==bmax:\n Ind.append(i)\ncnt = 0\ncur = N-1\nfor i in range(len(Ind)-1,-1,-1):\n j = Ind[i]\n amax = A[j]+B[j]\n for k in range(cur,j,-1):\n if A[k]==amax:\n cnt += 1\n cur = j\nprint(cnt)",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"0 for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"0",
"B = [0 for _ in range(N)]",
"B",
"[0 for _ in range(N)]",
"amax = A[-1]",
"amax",
"A[-1]",
"A",
"-1",
"for i in range(N-2,-1,-1):\n a = A[i]\n if a>amax:\n B[i] = 0\n amax = a\n else:\n B[i] = amax-a",
"i",
"range(N-2,-1,-1)",
"range",
"N-2",
"N",
"2",
"-1",
"-1",
"a = A[i]",
"a",
"A[i]",
"A",
"i",
"if a>amax:\n B[i] = 0\n amax = a\n else:\n B[i] = amax-a",
"a>amax",
"a",
"amax",
"B[i] = 0",
"B[i]",
"B",
"i",
"0",
"amax = a",
"amax",
"a",
"B[i] = amax-a",
"B[i]",
"B",
"i",
"amax-a",
"amax",
"a",
"bmax = 0",
"bmax",
"0",
"amax = 0",
"amax",
"0",
"for i in range(N):\n b = B[i]\n if b>bmax:\n amax = A[i]+b\n bmax = b",
"i",
"range(N)",
"range",
"N",
"b = B[i]",
"b",
"B[i]",
"B",
"i",
"if b>bmax:\n amax = A[i]+b\n bmax = b",
"b>bmax",
"b",
"bmax",
"amax = A[i]+b",
"amax",
"A[i]+b",
"A[i]",
"A",
"i",
"b",
"bmax = b",
"bmax",
"b",
"Ind = []",
"Ind",
"[]",
"for i in range(N):\n if B[i]==bmax:\n Ind.append(i)",
"i",
"range(N)",
"range",
"N",
"if B[i]==bmax:\n Ind.append(i)",
"B[i]==bmax",
"B[i]",
"B",
"i",
"bmax",
"Ind.append(i)",
"Ind.append",
"Ind",
"append",
"i",
"cnt = 0",
"cnt",
"0",
"cur = N-1",
"cur",
"N-1",
"N",
"1",
"for i in range(len(Ind)-1,-1,-1):\n j = Ind[i]\n amax = A[j]+B[j]\n for k in range(cur,j,-1):\n if A[k]==amax:\n cnt += 1\n cur = j",
"i",
"range(len(Ind)-1,-1,-1)",
"range",
"len(Ind)-1",
"len(Ind)",
"len",
"Ind",
"1",
"-1",
"-1",
"j = Ind[i]",
"j",
"Ind[i]",
"Ind",
"i",
"amax = A[j]+B[j]",
"amax",
"A[j]+B[j]",
"A[j]",
"A",
"j",
"B[j]",
"B",
"j",
"for k in range(cur,j,-1):\n if A[k]==amax:\n cnt += 1\n ",
"k",
"range(cur,j,-1)",
"range",
"cur",
"j",
"-1",
"if A[k]==amax:\n cnt += 1\n ",
"A[k]==amax",
"A[k]",
"A",
"k",
"amax",
"cnt += 1",
"cnt",
"1",
"cur = j",
"cur",
"j",
"print(cnt)",
"print",
"cnt",
"amax = A[-1]",
"A[-1]",
"amax",
"amax = 0",
"0",
"amax",
"cur = j",
"j",
"cur",
"bmax = 0",
"0",
"bmax",
"cnt += 1",
"1",
"cnt",
"a = A[i]",
"A[i]",
"a",
"amax = a",
"a",
"amax",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"Ind = []",
"[]",
"Ind",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"cur = N-1",
"N-1",
"cur",
"amax = A[j]+B[j]",
"A[j]+B[j]",
"amax",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"j = Ind[i]",
"Ind[i]",
"j",
"cnt = 0",
"0",
"cnt",
"amax = A[i]+b",
"A[i]+b",
"amax",
"b = B[i]",
"B[i]",
"b",
"B = [0 for _ in range(N)]",
"[0 for _ in range(N)]",
"B",
"bmax = b",
"b",
"bmax"
] |
N,T = map(int,input().split())
A = list(map(int,input().split()))
B = [0 for _ in range(N)]
amax = A[-1]
for i in range(N-2,-1,-1):
a = A[i]
if a>amax:
B[i] = 0
amax = a
else:
B[i] = amax-a
bmax = 0
amax = 0
for i in range(N):
b = B[i]
if b>bmax:
amax = A[i]+b
bmax = b
Ind = []
for i in range(N):
if B[i]==bmax:
Ind.append(i)
cnt = 0
cur = N-1
for i in range(len(Ind)-1,-1,-1):
j = Ind[i]
amax = A[j]+B[j]
for k in range(cur,j,-1):
if A[k]==amax:
cnt += 1
cur = j
print(cnt)
|
[
7,
12,
13,
29,
4,
13,
4,
13,
12,
13,
29,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
29,
13,
23,
13,
12,
13,
29,
4,
18,
4,
18,
18,
13,
13,
13,
13,
12,
13,
29,
4,
18,
13,
13,
13,
13,
23,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
18,
13,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
42,
2,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
13,
14,
40,
2,
13,
13,
4,
18,
13,
13,
13,
29,
4,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
42,
2,
4,
13,
13,
13,
0,
13,
4,
13,
13,
13,
17,
14,
40,
2,
13,
13,
4,
18,
13,
13,
13,
29,
4,
13,
13,
23,
13,
23,
13,
23,
13,
15,
15,
15,
15,
13,
15,
13,
15,
15,
13,
15,
13,
15,
13,
15,
15,
15,
15,
15,
13,
4,
18,
13,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
2,
39,
17,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
4,
13,
13,
18,
13,
40,
13,
0,
18,
13,
40,
13,
13,
23,
13,
4,
13,
13,
12,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
4,
13,
2,
18,
13,
13,
18,
13,
13,
13,
29,
13,
0,
13,
4,
13,
0,
13,
17,
42,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
18,
13,
13,
18,
13,
13,
13,
0,
18,
13,
13,
17,
0,
13,
17,
14,
2,
4,
13,
13,
3,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13
] |
[
[
37,
36
],
[
48,
39
],
[
48,
48
],
[
71,
68
],
[
73,
69
],
[
71,
71
],
[
73,
73
],
[
79,
78
],
[
96,
81
],
[
92,
87
],
[
94,
88
],
[
92,
92
],
[
94,
94
],
[
96,
96
],
[
101,
100
],
[
100,
106
],
[
135,
107
],
[
110,
109
],
[
131,
114
],
[
133,
115
],
[
109,
119
],
[
100,
120
],
[
100,
123
],
[
109,
125
],
[
100,
129
],
[
131,
131
],
[
133,
133
],
[
135,
135
],
[
140,
139
],
[
139,
145
],
[
173,
146
],
[
149,
148
],
[
364,
150
],
[
169,
151
],
[
171,
152
],
[
148,
157
],
[
139,
158
],
[
139,
161
],
[
148,
163
],
[
139,
167
],
[
169,
169
],
[
171,
171
],
[
173,
173
],
[
390,
200
],
[
387,
207
],
[
373,
209
],
[
387,
210
],
[
384,
212
],
[
343,
214
],
[
378,
216
],
[
340,
220
],
[
225,
224
],
[
255,
227
],
[
230,
229
],
[
233,
232
],
[
224,
237
],
[
241,
240
],
[
229,
243
],
[
240,
243
],
[
385,
245
],
[
232,
247
],
[
253,
249
],
[
255,
250
],
[
232,
252
],
[
240,
253
],
[
229,
253
],
[
255,
255
],
[
367,
257
],
[
379,
258
],
[
263,
262
],
[
266,
265
],
[
340,
269
],
[
273,
272
],
[
379,
277
],
[
265,
278
],
[
385,
280
],
[
265,
281
],
[
262,
282
],
[
272,
282
],
[
272,
284
],
[
262,
284
],
[
348,
286
],
[
394,
288
],
[
354,
290
],
[
296,
295
],
[
340,
299
],
[
379,
305
],
[
295,
306
],
[
312,
307
],
[
385,
308
],
[
295,
309
],
[
349,
310
],
[
358,
310
],
[
315,
312
],
[
385,
313
],
[
295,
314
],
[
375,
317
],
[
394,
322
],
[
349,
323
],
[
358,
323
],
[
367,
326
],
[
379,
327
],
[
357,
329
],
[
394,
331
],
[
376,
334
],
[
355,
334
],
[
387,
340
],
[
348,
349
],
[
354,
355
],
[
357,
358
],
[
375,
376
],
[
378,
379
],
[
384,
385
],
[
387,
388
],
[
390,
391
]
] |
[
"def getN():\n return int(input())\ndef getNM():\n return map(int, input().split())\ndef getList():\n return list(map(int, input().split()))\ndef getArray(intn):\n return [int(input()) for i in range(intn)]\ndef input():\n return sys.stdin.readline().rstrip()\ndef rand_N(ran1, ran2):\n return random.randint(ran1, ran2)\ndef rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]\ndef rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)\n\ndef rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)\n\nfrom collections import defaultdict, deque, Counter\nfrom sys import exit\nfrom decimal import *\nimport heapq\nimport math\nfrom fractions import gcd\nimport random\nimport string\nimport copy\nfrom itertools import permutations\nfrom operator import mul\nfrom functools import reduce\nfrom bisect import bisect_left, bisect_right\n\nimport sys\nsys.setrecursionlimit(1000000000)\nmod = 10 ** 9 + 7\n\n\n#############\n# Main Code #\n#############\n\n# print(rand_List(1, 10, 10))\nN, T = getNM()\nprice = getList()\nmax_list = [0] * N\n\n# この先訪れる店の中で最も値段が高い店の値段\ndef maximizer(num_list):\n num_N = len(num_list)\n res = 0\n for i in range(1, num_N + 1):\n res = max(res, price[-i])\n num_list[-i] = res\nmaximizer(max_list)\n\n# 最大マージンを調べる\ndef margin_checker():\n margin = 0\n for i in range(N - 1):\n margin = max(max_list[i] - price[i], margin)\n return margin\n\nmax_margin = margin_checker()\n\ncnt = 0\n# ループはしないはず\nwhile True:\n for i in range(N - 1):\n if max_list[i] - price[i] == max_margin:\n price[i] += 1\n cnt += 1\n if margin_checker() < max_margin:\n break\n # ループはしないはずだが念の為\n maximizer(max_list)\n max_margin = margin_checker()\nprint(cnt)",
"def getN():\n return int(input())",
"getN",
"return int(input())",
"int(input())",
"int",
"input()",
"input",
"def getNM():\n return map(int, input().split())",
"getNM",
"return map(int, input().split())",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def getList():\n return list(map(int, input().split()))",
"getList",
"return list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def getArray(intn):\n return [int(input()) for i in range(intn)]",
"getArray",
"int(input()) for i in range(intn)",
"for i in range(intn)",
"i",
"range(intn)",
"range",
"intn",
"for i in range(intn)",
"int(input())",
"int",
"input()",
"input",
"return [int(input()) for i in range(intn)]",
"[int(input()) for i in range(intn)]",
"intn",
"intn",
"def input():\n return sys.stdin.readline().rstrip()",
"input",
"return sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)",
"rand_N",
"return random.randint(ran1, ran2)",
"random.randint(ran1, ran2)",
"random.randint",
"random",
"randint",
"ran1",
"ran2",
"ran1",
"ran1",
"ran2",
"ran2",
"def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]",
"rand_List",
"random.randint(ran1, ran2) for i in range(rantime)",
"for i in range(rantime)",
"i",
"range(rantime)",
"range",
"rantime",
"for i in range(rantime)",
"random.randint(ran1, ran2)",
"random.randint",
"random",
"randint",
"ran1",
"ran2",
"return [random.randint(ran1, ran2) for i in range(rantime)]",
"[random.randint(ran1, ran2) for i in range(rantime)]",
"ran1",
"ran1",
"ran2",
"ran2",
"rantime",
"rantime",
"def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)",
"rand_ints_nodup",
"ns = []",
"ns",
"[]",
"while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n ",
"len(ns) < rantime",
"len(ns)",
"len",
"ns",
"rantime",
"n = random.randint(ran1, ran2)",
"n",
"random.randint(ran1, ran2)",
"random.randint",
"random",
"randint",
"ran1",
"ran2",
"if not n in ns:\n ns.append(n)\n ",
"not n in ns",
"n in ns",
"n",
"ns",
"ns.append(n)",
"ns.append",
"ns",
"append",
"n",
"return sorted(ns)",
"sorted(ns)",
"sorted",
"ns",
"ran1",
"ran1",
"ran2",
"ran2",
"rantime",
"rantime",
"def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)",
"rand_query",
"r_query = []",
"r_query",
"[]",
"while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n ",
"len(r_query) < rantime",
"len(r_query)",
"len",
"r_query",
"rantime",
"n_q = rand_ints_nodup(ran1, ran2, 2)",
"n_q",
"rand_ints_nodup(ran1, ran2, 2)",
"rand_ints_nodup",
"ran1",
"ran2",
"2",
"if not n_q in r_query:\n r_query.append(n_q)\n ",
"not n_q in r_query",
"n_q in r_query",
"n_q",
"r_query",
"r_query.append(n_q)",
"r_query.append",
"r_query",
"append",
"n_q",
"return sorted(r_query)",
"sorted(r_query)",
"sorted",
"r_query",
"ran1",
"ran1",
"ran2",
"ran2",
"rantime",
"rantime",
"from collections import defaultdict, deque, Counter",
"from sys import exit",
"from decimal import *",
"import heapq",
"heapq",
"import math",
"math",
"from fractions import gcd",
"import random",
"random",
"import string",
"string",
"import copy",
"copy",
"from itertools import permutations",
"from operator import mul",
"from functools import reduce",
"from bisect import bisect_left, bisect_right",
"import sys",
"sys",
"sys.setrecursionlimit(1000000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000000",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N, T = getNM()",
"N",
"getNM()",
"getNM",
"T",
"price = getList()",
"price",
"getList()",
"getList",
"max_list = [0] * N",
"max_list",
"[0] * N",
"[0]",
"0",
"N",
"def maximizer(num_list):\n num_N = len(num_list)\n res = 0\n for i in range(1, num_N + 1):\n res = max(res, price[-i])\n num_list[-i] = res",
"maximizer",
"num_N = len(num_list)",
"num_N",
"len(num_list)",
"len",
"num_list",
"res = 0",
"res",
"0",
"for i in range(1, num_N + 1):\n res = max(res, price[-i])\n num_list[-i] = res",
"i",
"range(1, num_N + 1)",
"range",
"1",
"num_N + 1",
"num_N",
"1",
"res = max(res, price[-i])",
"res",
"max(res, price[-i])",
"max",
"res",
"price[-i]",
"price",
"-i",
"i",
"num_list[-i] = res",
"num_list[-i]",
"num_list",
"-i",
"i",
"res",
"num_list",
"num_list",
"maximizer(max_list)",
"maximizer",
"max_list",
"def margin_checker():\n margin = 0\n for i in range(N - 1):\n margin = max(max_list[i] - price[i], margin)\n return margin",
"margin_checker",
"margin = 0",
"margin",
"0",
"for i in range(N - 1):\n margin = max(max_list[i] - price[i], margin)\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"margin = max(max_list[i] - price[i], margin)",
"margin",
"max(max_list[i] - price[i], margin)",
"max",
"max_list[i] - price[i]",
"max_list[i]",
"max_list",
"i",
"price[i]",
"price",
"i",
"margin",
"return margin",
"margin",
"max_margin = margin_checker()",
"max_margin",
"margin_checker()",
"margin_checker",
"cnt = 0",
"cnt",
"0",
"while True:\n for i in range(N - 1):\n if max_list[i] - price[i] == max_margin:\n price[i] += 1\n cnt += 1\n if margin_checker() < max_margin:\n break\n # ループはしないはずだが念の為\n maximizer(max_list)\n max_margin = margin_checker()",
"True",
"for i in range(N - 1):\n if max_list[i] - price[i] == max_margin:\n price[i] += 1\n cnt += 1\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"if max_list[i] - price[i] == max_margin:\n price[i] += 1\n cnt += 1\n ",
"max_list[i] - price[i] == max_margin",
"max_list[i] - price[i]",
"max_list[i]",
"max_list",
"i",
"price[i]",
"price",
"i",
"max_margin",
"price[i] += 1",
"price[i]",
"price",
"i",
"1",
"cnt += 1",
"cnt",
"1",
"if margin_checker() < max_margin:\n break\n # ループはしないはずだが念の為\n ",
"margin_checker() < max_margin",
"margin_checker()",
"margin_checker",
"max_margin",
"break",
"maximizer(max_list)",
"maximizer",
"max_list",
"max_margin = margin_checker()",
"max_margin",
"margin_checker()",
"margin_checker",
"print(cnt)",
"print",
"cnt",
"def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)",
"def rand_query(ran1, ran2, rantime):\n r_query = []\n while len(r_query) < rantime:\n n_q = rand_ints_nodup(ran1, ran2, 2)\n if not n_q in r_query:\n r_query.append(n_q)\n return sorted(r_query)",
"rand_query",
"N, T = getNM()",
"getNM()",
"N",
"def getList():\n return list(map(int, input().split()))",
"def getList():\n return list(map(int, input().split()))",
"getList",
"def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]",
"def rand_List(ran1, ran2, rantime):\n return [random.randint(ran1, ran2) for i in range(rantime)]",
"rand_List",
"max_margin = margin_checker()",
"margin_checker()",
"max_margin",
"def getArray(intn):\n return [int(input()) for i in range(intn)]",
"def getArray(intn):\n return [int(input()) for i in range(intn)]",
"getArray",
"cnt = 0",
"0",
"cnt",
"max_margin = margin_checker()",
"margin_checker()",
"max_margin",
"def getN():\n return int(input())",
"def getN():\n return int(input())",
"getN",
"def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)",
"def rand_ints_nodup(ran1, ran2, rantime):\n ns = []\n while len(ns) < rantime:\n n = random.randint(ran1, ran2)\n if not n in ns:\n ns.append(n)\n return sorted(ns)",
"rand_ints_nodup",
"def maximizer(num_list):\n num_N = len(num_list)\n res = 0\n for i in range(1, num_N + 1):\n res = max(res, price[-i])\n num_list[-i] = res",
"def maximizer(num_list):\n num_N = len(num_list)\n res = 0\n for i in range(1, num_N + 1):\n res = max(res, price[-i])\n num_list[-i] = res",
"maximizer",
"def input():\n return sys.stdin.readline().rstrip()",
"def input():\n return sys.stdin.readline().rstrip()",
"input",
"def getNM():\n return map(int, input().split())",
"def getNM():\n return map(int, input().split())",
"getNM",
"cnt += 1",
"1",
"cnt",
"max_list = [0] * N",
"[0] * N",
"max_list",
"def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)",
"def rand_N(ran1, ran2):\n return random.randint(ran1, ran2)",
"rand_N",
"price = getList()",
"getList()",
"price",
"T = getNM()",
"getNM()",
"T",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"def margin_checker():\n margin = 0\n for i in range(N - 1):\n margin = max(max_list[i] - price[i], margin)\n return margin",
"def margin_checker():\n margin = 0\n for i in range(N - 1):\n margin = max(max_list[i] - price[i], margin)\n return margin",
"margin_checker"
] |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
# print(rand_List(1, 10, 10))
N, T = getNM()
price = getList()
max_list = [0] * N
# この先訪れる店の中で最も値段が高い店の値段
def maximizer(num_list):
num_N = len(num_list)
res = 0
for i in range(1, num_N + 1):
res = max(res, price[-i])
num_list[-i] = res
maximizer(max_list)
# 最大マージンを調べる
def margin_checker():
margin = 0
for i in range(N - 1):
margin = max(max_list[i] - price[i], margin)
return margin
max_margin = margin_checker()
cnt = 0
# ループはしないはず
while True:
for i in range(N - 1):
if max_list[i] - price[i] == max_margin:
price[i] += 1
cnt += 1
if margin_checker() < max_margin:
break
# ループはしないはずだが念の為
maximizer(max_list)
max_margin = margin_checker()
print(cnt)
|
[
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,
18,
13,
17,
0,
13,
2,
39,
13,
13,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
18,
13,
2,
2,
13,
17,
13,
0,
18,
13,
2,
2,
13,
17,
13,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] |
[
[
120,
2
],
[
120,
11
],
[
108,
13
],
[
123,
25
],
[
109,
27
],
[
102,
30
],
[
121,
34
],
[
37,
36
],
[
121,
39
],
[
114,
41
],
[
124,
44
],
[
115,
44
],
[
109,
46
],
[
121,
49
],
[
36,
51
],
[
60,
53
],
[
103,
54
],
[
121,
57
],
[
36,
59
],
[
115,
60
],
[
124,
60
],
[
63,
62
],
[
121,
65
],
[
70,
67
],
[
109,
68
],
[
62,
69
],
[
103,
72
],
[
62,
73
],
[
67,
74
],
[
109,
75
],
[
62,
76
],
[
117,
78
],
[
109,
81
],
[
105,
83
],
[
87,
86
],
[
109,
86
],
[
86,
90
],
[
118,
91
],
[
111,
93
],
[
112,
97
],
[
106,
97
],
[
120,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
]
] |
[
"n,t=map(int,input().split())\nl=list(map(int,input().split()))\nm=l[-1]\nma=[m]*n\nfor i in range(n):\n m=max(m,l[n-1-i])\n ma[n-1-i]=m\nfor i in range(n):\n l[i]=ma[i]-l[i]\nk=max(l)\nans=0\nfor i in l:\n if i==k:\n ans+=1\nprint(ans)",
"n,t=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"l=list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"m=l[-1]",
"m",
"l[-1]",
"l",
"-1",
"ma=[m]*n",
"ma",
"[m]*n",
"[m]",
"m",
"n",
"for i in range(n):\n m=max(m,l[n-1-i])\n ma[n-1-i]=m",
"i",
"range(n)",
"range",
"n",
"m=max(m,l[n-1-i])",
"m",
"max(m,l[n-1-i])",
"max",
"m",
"l[n-1-i]",
"l",
"n-1-i",
"n-1",
"n",
"1",
"i",
"ma[n-1-i]=m",
"ma[n-1-i]",
"ma",
"n-1-i",
"n-1",
"n",
"1",
"i",
"m",
"for i in range(n):\n l[i]=ma[i]-l[i]",
"i",
"range(n)",
"range",
"n",
"l[i]=ma[i]-l[i]",
"l[i]",
"l",
"i",
"ma[i]-l[i]",
"ma[i]",
"ma",
"i",
"l[i]",
"l",
"i",
"k=max(l)",
"k",
"max(l)",
"max",
"l",
"ans=0",
"ans",
"0",
"for i in l:\n if i==k:\n ans+=1",
"i",
"l",
"if i==k:\n ans+=1",
"i==k",
"i",
"k",
"ans+=1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"t=map(int,input().split())",
"map(int,input().split())",
"t",
"ma=[m]*n",
"[m]*n",
"ma",
"ans=0",
"0",
"ans",
"l=list(map(int,input().split()))",
"list(map(int,input().split()))",
"l",
"ans+=1",
"1",
"ans",
"m=max(m,l[n-1-i])",
"max(m,l[n-1-i])",
"m",
"k=max(l)",
"max(l)",
"k",
"n,t=map(int,input().split())",
"map(int,input().split())",
"n",
"m=l[-1]",
"l[-1]",
"m"
] |
n,t=map(int,input().split())
l=list(map(int,input().split()))
m=l[-1]
ma=[m]*n
for i in range(n):
m=max(m,l[n-1-i])
ma[n-1-i]=m
for i in range(n):
l[i]=ma[i]-l[i]
k=max(l)
ans=0
for i in l:
if i==k:
ans+=1
print(ans)
|
[
7,
15,
13,
15,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
31,
13,
0,
13,
4,
13,
4,
13,
18,
4,
13,
4,
13,
18,
13,
39,
17,
13,
39,
17,
41,
28,
13,
13,
4,
13,
13,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
4,
13,
4,
18,
13,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13
] |
[
[
82,
5
],
[
85,
12
],
[
83,
19
],
[
85,
21
],
[
85,
22
],
[
70,
25
],
[
71,
49
],
[
73,
55
],
[
76,
58
],
[
74,
61
],
[
74,
66
],
[
77,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
85,
80
],
[
82,
83
],
[
85,
86
]
] |
[
"import sys\nfrom itertools import accumulate\nread = sys.stdin.read\n\nN, T, *A = map(int, read().split())\na_maximum = list(reversed(list(accumulate(A[::-1], max))[:-1]))\na = [j - i for i, j in zip(A, a_maximum)]\nminimum = max(a)\n\nprint(a.count(minimum))",
"import sys",
"sys",
"from itertools import accumulate",
"read = sys.stdin.read",
"read",
"sys.stdin.read",
"sys.stdin",
"sys",
"stdin",
"read",
"N, T, *A = map(int, read().split())",
"N",
"map(int, read().split())",
"map",
"int",
"read().split()",
"().split",
"()",
"read",
"split",
"T",
"*A",
"A",
"a_maximum = list(reversed(list(accumulate(A[::-1], max))[:-1]))",
"a_maximum",
"list(reversed(list(accumulate(A[::-1], max))[:-1]))",
"list",
"reversed(list(accumulate(A[::-1], max))[:-1])",
"reversed",
"list(accumulate(A[::-1], max))[:-1]",
"(accumulate(A[::-1], max))",
"list",
"accumulate(A[::-1], max)",
"accumulate",
"A[::-1]",
"A",
"::-1",
"-1",
"max",
":-1",
"-1",
"j - i for i, j in zip(A, a_maximum)",
"for i, j in zip(A, a_maximum)",
"i",
"j",
"zip(A, a_maximum)",
"zip",
"A",
"a_maximum",
"for i, j in zip(A, a_maximum)",
"j - i",
"j",
"i",
"a = [j - i for i, j in zip(A, a_maximum)]",
"a",
"[j - i for i, j in zip(A, a_maximum)]",
"minimum = max(a)",
"minimum",
"max(a)",
"max",
"a",
"print(a.count(minimum))",
"print",
"a.count(minimum)",
"a.count",
"a",
"count",
"minimum",
"a_maximum = list(reversed(list(accumulate(A[::-1], max))[:-1]))",
"list(reversed(list(accumulate(A[::-1], max))[:-1]))",
"a_maximum",
"a = [j - i for i, j in zip(A, a_maximum)]",
"[j - i for i, j in zip(A, a_maximum)]",
"a",
"minimum = max(a)",
"max(a)",
"minimum",
"T, *A = map(int, read().split())",
"map(int, read().split())",
"T",
"read = sys.stdin.read",
"sys.stdin.read",
"read",
"N, T, *A = map(int, read().split())",
"map(int, read().split())",
"N"
] |
import sys
from itertools import accumulate
read = sys.stdin.read
N, T, *A = map(int, read().split())
a_maximum = list(reversed(list(accumulate(A[::-1], max))[:-1]))
a = [j - i for i, j in zip(A, a_maximum)]
minimum = max(a)
print(a.count(minimum))
|
[
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,
39,
17,
17,
0,
13,
13,
0,
13,
18,
13,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
13,
0,
18,
13,
13,
39,
2,
13,
13,
13,
14,
2,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
39,
28,
13,
4,
13,
13,
14,
2,
18,
18,
13,
13,
17,
13,
14,
40,
18,
18,
13,
13,
17,
13,
4,
18,
13,
13,
18,
18,
13,
13,
17,
4,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
18,
13,
10,
13,
13,
10,
39,
13,
10,
4,
13,
10,
18,
13
] |
[
[
163,
2
],
[
163,
11
],
[
139,
13
],
[
27,
26
],
[
164,
29
],
[
151,
35
],
[
154,
38
],
[
140,
40
],
[
148,
43
],
[
164,
45
],
[
142,
48
],
[
52,
51
],
[
164,
55
],
[
166,
60
],
[
140,
62
],
[
51,
63
],
[
167,
66
],
[
155,
67
],
[
137,
67
],
[
136,
69
],
[
167,
70
],
[
157,
72
],
[
51,
73
],
[
78,
75
],
[
152,
76
],
[
51,
77
],
[
155,
80
],
[
137,
80
],
[
167,
81
],
[
143,
85
],
[
146,
85
],
[
155,
87
],
[
137,
87
],
[
167,
88
],
[
145,
90
],
[
155,
92
],
[
137,
92
],
[
167,
93
],
[
160,
95
],
[
99,
98
],
[
164,
101
],
[
75,
105
],
[
152,
106
],
[
98,
107
],
[
146,
109
],
[
143,
109
],
[
75,
113
],
[
152,
114
],
[
98,
115
],
[
161,
117
],
[
161,
120
],
[
75,
123
],
[
152,
124
],
[
98,
125
],
[
161,
131
],
[
163,
134
],
[
167,
136
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
51,
157
],
[
157,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
]
] |
[
"N,T = map(int,input().split())\nA = list(map(int,input().split()))\nB = [(0,-1) for _ in range(N)]\namax = A[-1]\nind = N-1\nbmax = 0\nfor i in range(N-2,-1,-1):\n a = A[i]\n if a>amax:\n amax = a\n ind = i\n else:\n B[i] = (amax-a,ind)\n if bmax<amax-a:\n bmax = amax-a\nC = []\nfor i in range(N):\n if B[i][0]==bmax:\n if B[i][1] not in C:\n C.append(B[i][1])\nprint(len(C))",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"(0,-1) for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"(0,-1)",
"0",
"-1",
"B = [(0,-1) for _ in range(N)]",
"B",
"[(0,-1) for _ in range(N)]",
"amax = A[-1]",
"amax",
"A[-1]",
"A",
"-1",
"ind = N-1",
"ind",
"N-1",
"N",
"1",
"bmax = 0",
"bmax",
"0",
"for i in range(N-2,-1,-1):\n a = A[i]\n if a>amax:\n amax = a\n ind = i\n else:\n B[i] = (amax-a,ind)\n if bmax<amax-a:\n bmax = amax-a",
"i",
"range(N-2,-1,-1)",
"range",
"N-2",
"N",
"2",
"-1",
"-1",
"a = A[i]",
"a",
"A[i]",
"A",
"i",
"if a>amax:\n amax = a\n ind = i\n else:\n B[i] = (amax-a,ind)\n if bmax<amax-a:\n bmax = amax-a",
"a>amax",
"a",
"amax",
"amax = a",
"amax",
"a",
"ind = i",
"ind",
"i",
"B[i] = (amax-a,ind)",
"B[i]",
"B",
"i",
"(amax-a,ind)",
"amax-a",
"amax",
"a",
"ind",
"if bmax<amax-a:\n bmax = amax-a",
"bmax<amax-a",
"bmax",
"amax-a",
"amax",
"a",
"bmax = amax-a",
"bmax",
"amax-a",
"amax",
"a",
"C = []",
"C",
"[]",
"for i in range(N):\n if B[i][0]==bmax:\n if B[i][1] not in C:\n C.append(B[i][1])",
"i",
"range(N)",
"range",
"N",
"if B[i][0]==bmax:\n if B[i][1] not in C:\n C.append(B[i][1])",
"B[i][0]==bmax",
"B[i][0]",
"[i]",
"B",
"i",
"0",
"bmax",
"if B[i][1] not in C:\n C.append(B[i][1])",
"B[i][1] not in C",
"B[i][1]",
"[i]",
"B",
"i",
"1",
"C",
"C.append(B[i][1])",
"C.append",
"C",
"append",
"B[i][1]",
"[i]",
"B",
"i",
"1",
"print(len(C))",
"print",
"len(C)",
"len",
"C",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"amax = a",
"a",
"amax",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"bmax = 0",
"0",
"bmax",
"bmax = amax-a",
"amax-a",
"bmax",
"ind = N-1",
"N-1",
"ind",
"B = [(0,-1) for _ in range(N)]",
"[(0,-1) for _ in range(N)]",
"B",
"amax = A[-1]",
"A[-1]",
"amax",
"ind = i",
"i",
"ind",
"C = []",
"[]",
"C",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"a = A[i]",
"A[i]",
"a"
] |
N,T = map(int,input().split())
A = list(map(int,input().split()))
B = [(0,-1) for _ in range(N)]
amax = A[-1]
ind = N-1
bmax = 0
for i in range(N-2,-1,-1):
a = A[i]
if a>amax:
amax = a
ind = i
else:
B[i] = (amax-a,ind)
if bmax<amax-a:
bmax = amax-a
C = []
for i in range(N):
if B[i][0]==bmax:
if B[i][1] not in C:
C.append(B[i][1])
print(len(C))
|
[
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,
18,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
18,
13,
39,
17,
14,
2,
13,
13,
0,
13,
13,
9,
14,
2,
2,
13,
13,
13,
0,
13,
17,
14,
2,
2,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13
] |
[
[
82,
2
],
[
82,
11
],
[
91,
13
],
[
97,
25
],
[
92,
27
],
[
94,
30
],
[
76,
33
],
[
37,
36
],
[
92,
38
],
[
36,
43
],
[
98,
44
],
[
86,
44
],
[
85,
46
],
[
36,
47
],
[
36,
52
],
[
86,
53
],
[
98,
53
],
[
95,
54
],
[
101,
54
],
[
103,
56
],
[
36,
61
],
[
86,
62
],
[
98,
62
],
[
95,
63
],
[
101,
63
],
[
100,
65
],
[
36,
67
],
[
86,
68
],
[
98,
68
],
[
88,
70
],
[
89,
74
],
[
104,
74
],
[
77,
74
],
[
76,
77
],
[
82,
80
],
[
82,
83
],
[
36,
85
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
]
] |
[
"N,T = map(int,input().split())\nA = list(map(int,input().split()))\nmn = A[0]\ngain = 0\nans = 1\nfor a in A[1:]:\n if a < mn:\n mn = a\n continue\n if a-mn == gain:\n ans += 1\n elif a-mn > gain:\n gain = a-mn\n ans = 1\nprint(ans)",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mn = A[0]",
"mn",
"A[0]",
"A",
"0",
"gain = 0",
"gain",
"0",
"ans = 1",
"ans",
"1",
"for a in A[1:]:\n if a < mn:\n mn = a\n continue\n if a-mn == gain:\n ans += 1\n elif a-mn > gain:\n gain = a-mn\n ans = 1",
"a",
"A[1:]",
"A",
"1:",
"1",
"if a < mn:\n mn = a\n continue\n ",
"a < mn",
"a",
"mn",
"mn = a",
"mn",
"a",
"continue",
"if a-mn == gain:\n ans += 1\n elif a-mn > gain:\n gain = a-mn\n ans = 1",
"a-mn == gain",
"a-mn",
"a",
"mn",
"gain",
"ans += 1",
"ans",
"1",
"elif a-mn > gain:\n gain = a-mn\n ans = 1",
"a-mn > gain",
"a-mn",
"a",
"mn",
"gain",
"gain = a-mn",
"gain",
"a-mn",
"a",
"mn",
"ans = 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"ans = 1",
"1",
"ans",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"mn = a",
"a",
"mn",
"ans = 1",
"1",
"ans",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"gain = 0",
"0",
"gain",
"mn = A[0]",
"A[0]",
"mn",
"gain = a-mn",
"a-mn",
"gain",
"ans += 1",
"1",
"ans"
] |
N,T = map(int,input().split())
A = list(map(int,input().split()))
mn = A[0]
gain = 0
ans = 1
for a in A[1:]:
if a < mn:
mn = a
continue
if a-mn == gain:
ans += 1
elif a-mn > gain:
gain = a-mn
ans = 1
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,
18,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
13,
13,
14,
2,
2,
18,
13,
13,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
17,
14,
2,
2,
18,
13,
13,
13,
13,
0,
13,
17,
0,
13,
18,
13,
13,
4,
13,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] |
[
[
115,
2
],
[
115,
11
],
[
15,
14
],
[
14,
23
],
[
100,
25
],
[
88,
28
],
[
101,
30
],
[
109,
33
],
[
103,
36
],
[
40,
39
],
[
113,
43
],
[
101,
47
],
[
39,
48
],
[
89,
49
],
[
98,
49
],
[
101,
54
],
[
39,
55
],
[
89,
56
],
[
98,
56
],
[
110,
57
],
[
92,
57
],
[
91,
59
],
[
101,
62
],
[
39,
63
],
[
89,
64
],
[
98,
64
],
[
106,
66
],
[
101,
72
],
[
39,
73
],
[
89,
74
],
[
98,
74
],
[
110,
75
],
[
92,
75
],
[
94,
77
],
[
97,
80
],
[
101,
82
],
[
39,
83
],
[
95,
86
],
[
107,
86
],
[
104,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
115,
113
],
[
115,
116
]
] |
[
"N, T = map(int, input().split())\nA = [int(x) for x in input().split()]\nbuy = A[0]\nmax_profit = 0\nans = 1\nfor i in range(1,N):\n if A[i] > buy:\n if A[i] - buy > max_profit:\n max_profit = A[i] - buy\n ans = 1\n elif A[i] - buy == max_profit:\n ans += 1\n else:\n buy = A[i]\nprint(ans)",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"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",
"A = [int(x) for x in input().split()]",
"A",
"[int(x) for x in input().split()]",
"buy = A[0]",
"buy",
"A[0]",
"A",
"0",
"max_profit = 0",
"max_profit",
"0",
"ans = 1",
"ans",
"1",
"for i in range(1,N):\n if A[i] > buy:\n if A[i] - buy > max_profit:\n max_profit = A[i] - buy\n ans = 1\n elif A[i] - buy == max_profit:\n ans += 1\n else:\n buy = A[i]",
"i",
"range(1,N)",
"range",
"1",
"N",
"if A[i] > buy:\n if A[i] - buy > max_profit:\n max_profit = A[i] - buy\n ans = 1\n elif A[i] - buy == max_profit:\n ans += 1\n else:\n buy = A[i]",
"A[i] > buy",
"A[i]",
"A",
"i",
"buy",
"if A[i] - buy > max_profit:\n max_profit = A[i] - buy\n ans = 1\n elif A[i] - buy == max_profit:\n ans += 1\n ",
"A[i] - buy > max_profit",
"A[i] - buy",
"A[i]",
"A",
"i",
"buy",
"max_profit",
"max_profit = A[i] - buy",
"max_profit",
"A[i] - buy",
"A[i]",
"A",
"i",
"buy",
"ans = 1",
"ans",
"1",
"elif A[i] - buy == max_profit:\n ans += 1\n ",
"A[i] - buy == max_profit",
"A[i] - buy",
"A[i]",
"A",
"i",
"buy",
"max_profit",
"ans += 1",
"ans",
"1",
"buy = A[i]",
"buy",
"A[i]",
"A",
"i",
"print(ans)",
"print",
"ans",
"buy = A[0]",
"A[0]",
"buy",
"max_profit = A[i] - buy",
"A[i] - buy",
"max_profit",
"ans += 1",
"1",
"ans",
"buy = A[i]",
"A[i]",
"buy",
"A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"A",
"ans = 1",
"1",
"ans",
"ans = 1",
"1",
"ans",
"max_profit = 0",
"0",
"max_profit",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"T = map(int, input().split())",
"map(int, input().split())",
"T"
] |
N, T = map(int, input().split())
A = [int(x) for x in input().split()]
buy = A[0]
max_profit = 0
ans = 1
for i in range(1,N):
if A[i] > buy:
if A[i] - buy > max_profit:
max_profit = A[i] - buy
ans = 1
elif A[i] - buy == max_profit:
ans += 1
else:
buy = A[i]
print(ans)
|
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
31,
13,
0,
13,
17,
0,
13,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
14,
2,
2,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
14,
2,
2,
13,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
5,
4
],
[
5,
17
],
[
5,
18
],
[
22,
21
],
[
25,
24
],
[
30,
29
],
[
33,
32
],
[
4,
35
],
[
38,
37
],
[
32,
40
],
[
37,
44
],
[
24,
45
],
[
65,
45
],
[
21,
46
],
[
48,
46
],
[
49,
48
],
[
37,
50
],
[
24,
51
],
[
65,
51
],
[
54,
53
],
[
37,
58
],
[
24,
59
],
[
65,
59
],
[
21,
60
],
[
48,
60
],
[
63,
62
],
[
66,
65
],
[
24,
68
],
[
65,
68
],
[
37,
69
],
[
62,
72
],
[
53,
72
],
[
29,
72
],
[
81,
78
]
] |
[
"def main():\n n, t, *a = map(int, open(0).read().split())\n b = 0\n c = float(\"Inf\")\n d = 0\n for i in range(n):\n x = a[i]\n if x - c > b:\n b = x - c\n d = 1\n elif x - c == b:\n d += 1\n c = min(c, x)\n\n print(d)\n\n\nif __name__ == '__main__':\n main()",
"def main():\n n, t, *a = map(int, open(0).read().split())\n b = 0\n c = float(\"Inf\")\n d = 0\n for i in range(n):\n x = a[i]\n if x - c > b:\n b = x - c\n d = 1\n elif x - c == b:\n d += 1\n c = min(c, x)\n\n print(d)",
"main",
"n, t, *a = 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",
"t",
"*a",
"a",
"b = 0",
"b",
"0",
"c = float(\"Inf\")",
"c",
"float(\"Inf\")",
"float",
"\"Inf\"",
"d = 0",
"d",
"0",
"for i in range(n):\n x = a[i]\n if x - c > b:\n b = x - c\n d = 1\n elif x - c == b:\n d += 1\n c = min(c, x)\n\n ",
"i",
"range(n)",
"range",
"n",
"x = a[i]",
"x",
"a[i]",
"a",
"i",
"if x - c > b:\n b = x - c\n d = 1\n elif x - c == b:\n d += 1\n ",
"x - c > b",
"x - c",
"x",
"c",
"b",
"b = x - c",
"b",
"x - c",
"x",
"c",
"d = 1",
"d",
"1",
"elif x - c == b:\n d += 1\n ",
"x - c == b",
"x - c",
"x",
"c",
"b",
"d += 1",
"d",
"1",
"c = min(c, x)",
"c",
"min(c, x)",
"min",
"c",
"x",
"print(d)",
"print",
"d",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n n, t, *a = map(int, open(0).read().split())\n b = 0\n c = float(\"Inf\")\n d = 0\n for i in range(n):\n x = a[i]\n if x - c > b:\n b = x - c\n d = 1\n elif x - c == b:\n d += 1\n c = min(c, x)\n\n print(d)",
"def main():\n n, t, *a = map(int, open(0).read().split())\n b = 0\n c = float(\"Inf\")\n d = 0\n for i in range(n):\n x = a[i]\n if x - c > b:\n b = x - c\n d = 1\n elif x - c == b:\n d += 1\n c = min(c, x)\n\n print(d)",
"main"
] |
def main():
n, t, *a = map(int, open(0).read().split())
b = 0
c = float("Inf")
d = 0
for i in range(n):
x = a[i]
if x - c > b:
b = x - c
d = 1
elif x - c == b:
d += 1
c = min(c, x)
print(d)
if __name__ == '__main__':
main()
|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
2,
39,
17,
13,
23,
13,
23,
13,
12,
13,
14,
2,
18,
18,
13,
13,
13,
17,
29,
13,
0,
18,
18,
13,
13,
13,
4,
18,
13,
13,
18,
18,
13,
13,
13,
29,
18,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
14,
2,
13,
13,
29,
14,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
13,
0,
13,
13,
13,
13,
0,
18,
18,
13,
13,
13,
18,
18,
13,
13,
13,
0,
18,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
40,
18,
18,
13,
13,
4,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
2,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
23,
13,
23,
13,
23,
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,
0,
13,
39,
0,
13,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
14,
2,
13,
18,
13,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
18,
13,
17,
0,
13,
4,
13,
13,
2,
18,
13,
13,
13,
28,
13,
4,
13,
13,
14,
2,
2,
18,
13,
13,
18,
13,
18,
13,
13,
13,
4,
18,
13,
13,
13,
18,
13,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
4,
18,
13,
13,
13,
17,
9,
4,
18,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
6,
13
] |
[
[
9,
6
],
[
19,
7
],
[
21,
8
],
[
21,
9
],
[
14,
11
],
[
19,
12
],
[
21,
17
],
[
19,
19
],
[
21,
21
],
[
56,
28
],
[
58,
30
],
[
58,
33
],
[
40,
35
],
[
56,
37
],
[
58,
39
],
[
56,
42
],
[
56,
46
],
[
58,
48
],
[
35,
50
],
[
56,
52
],
[
58,
54
],
[
56,
56
],
[
58,
58
],
[
63,
62
],
[
116,
65
],
[
23,
66
],
[
118,
67
],
[
70,
69
],
[
116,
72
],
[
23,
73
],
[
120,
74
],
[
62,
77
],
[
118,
77
],
[
69,
78
],
[
120,
78
],
[
116,
84
],
[
62,
86
],
[
118,
86
],
[
116,
89
],
[
69,
91
],
[
120,
91
],
[
94,
93
],
[
69,
94
],
[
120,
94
],
[
96,
95
],
[
93,
96
],
[
62,
96
],
[
118,
96
],
[
103,
98
],
[
116,
100
],
[
93,
102
],
[
62,
102
],
[
118,
102
],
[
116,
105
],
[
95,
107
],
[
69,
107
],
[
120,
107
],
[
114,
109
],
[
116,
111
],
[
95,
113
],
[
69,
113
],
[
120,
113
],
[
93,
114
],
[
62,
114
],
[
118,
114
],
[
116,
116
],
[
118,
118
],
[
120,
120
],
[
135,
127
],
[
135,
131
],
[
23,
132
],
[
137,
133
],
[
135,
135
],
[
137,
137
],
[
153,
144
],
[
23,
145
],
[
155,
146
],
[
153,
149
],
[
23,
150
],
[
157,
151
],
[
153,
153
],
[
155,
155
],
[
157,
157
],
[
162,
161
],
[
162,
170
],
[
173,
172
],
[
185,
184
],
[
161,
187
],
[
190,
189
],
[
193,
192
],
[
198,
197
],
[
201,
200
],
[
161,
203
],
[
206,
205
],
[
192,
208
],
[
205,
208
],
[
172,
210
],
[
200,
211
],
[
205,
214
],
[
192,
214
],
[
172,
216
],
[
200,
217
],
[
189,
220
],
[
200,
222
],
[
189,
225
],
[
189,
228
],
[
232,
231
],
[
197,
234
],
[
231,
234
],
[
172,
237
],
[
200,
238
],
[
205,
239
],
[
192,
239
],
[
242,
241
],
[
161,
244
],
[
172,
249
],
[
241,
250
],
[
172,
252
],
[
189,
254
],
[
241,
255
],
[
231,
256
],
[
197,
256
],
[
184,
259
],
[
60,
260
],
[
241,
261
],
[
189,
263
],
[
241,
264
],
[
267,
266
],
[
271,
270
],
[
161,
273
],
[
184,
278
],
[
122,
279
],
[
270,
280
],
[
266,
285
],
[
184,
289
],
[
23,
290
],
[
270,
291
],
[
266,
296
],
[
305,
302
]
] |
[
"class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n \n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n \n def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n \n self.parents[x] += self.parents[y]\n self.parents[y] = x\n \n def size(self, x):\n return -self.parents[self.find(x)]\n \n def isSame(self, x, y):\n return self.find(x) == self.find(y)\n\ndef solve():\n N, T = map(int,input().split())\n A = list(map(int,input().split()))\n\n uf = UnionFind(N)\n\n mn_idx_list = []\n mn = float('inf')\n max_diff = 0\n for i in range(N):\n mn = min(mn, A[i])\n if mn == A[i]:\n mn_idx_list.append(i)\n else:\n mn_idx_list.append(mn_idx_list[-1])\n\n max_diff = max(max_diff, A[i] - mn)\n \n for i in range(N):\n if A[i] - A[mn_idx_list[i]] == max_diff:\n uf.unite(i, mn_idx_list[i])\n \n parents_set = set()\n for i in range(N):\n if uf.size(i) == 1:\n continue\n parents_set.add(uf.find(i))\n \n print(len(parents_set))\n\nif __name__ == '__main__':\n solve()",
"class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n \n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n \n def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n \n self.parents[x] += self.parents[y]\n self.parents[y] = x\n \n def size(self, x):\n return -self.parents[self.find(x)]\n \n def isSame(self, x, y):\n return self.find(x) == self.find(y)",
"UnionFind",
"def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n \n ",
"__init__",
"self.n = n",
"self.n",
"self",
"n",
"n",
"self.parents = [-1] * n",
"self.parents",
"self",
"parents",
"[-1] * n",
"[-1]",
"-1",
"n",
"self",
"self",
"n",
"n",
"def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n \n ",
"find",
"if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n \n ",
"self.parents[x] < 0",
"self.parents[x]",
"self.parents",
"self",
"parents",
"x",
"0",
"return x",
"x",
"self.parents[x] = self.find(self.parents[x])",
"self.parents[x]",
"self.parents",
"self",
"parents",
"x",
"self.find(self.parents[x])",
"self.find",
"self",
"find",
"self.parents[x]",
"self.parents",
"self",
"parents",
"x",
"return self.parents[x]",
"self.parents[x]",
"self.parents",
"self",
"parents",
"x",
"self",
"self",
"x",
"x",
"def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n \n self.parents[x] += self.parents[y]\n self.parents[y] = x\n \n ",
"unite",
"x = self.find(x)",
"x",
"self.find(x)",
"self.find",
"self",
"find",
"x",
"y = self.find(y)",
"y",
"self.find(y)",
"self.find",
"self",
"find",
"y",
"if x == y:\n return\n\n ",
"x == y",
"x",
"y",
"return",
"if self.parents[x] > self.parents[y]:\n x, y = y, x\n \n ",
"self.parents[x] > self.parents[y]",
"self.parents[x]",
"self.parents",
"self",
"parents",
"x",
"self.parents[y]",
"self.parents",
"self",
"parents",
"y",
"x, y = y, x",
"x",
"y",
"y",
"x",
"self.parents[x] += self.parents[y]",
"self.parents[x]",
"self.parents",
"self",
"parents",
"x",
"self.parents[y]",
"self.parents",
"self",
"parents",
"y",
"self.parents[y] = x",
"self.parents[y]",
"self.parents",
"self",
"parents",
"y",
"x",
"self",
"self",
"x",
"x",
"y",
"y",
"def size(self, x):\n return -self.parents[self.find(x)]\n \n ",
"size",
"return -self.parents[self.find(x)]",
"-self.parents[self.find(x)]",
"self.parents[self.find(x)]",
"self.parents",
"self",
"parents",
"self.find(x)",
"self.find",
"self",
"find",
"x",
"self",
"self",
"x",
"x",
"def isSame(self, x, y):\n return self.find(x) == self.find(y)",
"isSame",
"return self.find(x) == self.find(y)",
"self.find(x) == self.find(y)",
"self.find(x)",
"self.find",
"self",
"find",
"x",
"self.find(y)",
"self.find",
"self",
"find",
"y",
"self",
"self",
"x",
"x",
"y",
"y",
"def solve():\n N, T = map(int,input().split())\n A = list(map(int,input().split()))\n\n uf = UnionFind(N)\n\n mn_idx_list = []\n mn = float('inf')\n max_diff = 0\n for i in range(N):\n mn = min(mn, A[i])\n if mn == A[i]:\n mn_idx_list.append(i)\n else:\n mn_idx_list.append(mn_idx_list[-1])\n\n max_diff = max(max_diff, A[i] - mn)\n \n for i in range(N):\n if A[i] - A[mn_idx_list[i]] == max_diff:\n uf.unite(i, mn_idx_list[i])\n \n parents_set = set()\n for i in range(N):\n if uf.size(i) == 1:\n continue\n parents_set.add(uf.find(i))\n \n print(len(parents_set))",
"solve",
"N, T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"uf = UnionFind(N)",
"uf",
"UnionFind(N)",
"UnionFind",
"N",
"mn_idx_list = []",
"mn_idx_list",
"[]",
"mn = float('inf')",
"mn",
"float('inf')",
"float",
"'inf'",
"max_diff = 0",
"max_diff",
"0",
"for i in range(N):\n mn = min(mn, A[i])\n if mn == A[i]:\n mn_idx_list.append(i)\n else:\n mn_idx_list.append(mn_idx_list[-1])\n\n max_diff = max(max_diff, A[i] - mn)\n \n ",
"i",
"range(N)",
"range",
"N",
"mn = min(mn, A[i])",
"mn",
"min(mn, A[i])",
"min",
"mn",
"A[i]",
"A",
"i",
"if mn == A[i]:\n mn_idx_list.append(i)\n else:\n mn_idx_list.append(mn_idx_list[-1])\n\n ",
"mn == A[i]",
"mn",
"A[i]",
"A",
"i",
"mn_idx_list.append(i)",
"mn_idx_list.append",
"mn_idx_list",
"append",
"i",
"mn_idx_list.append(mn_idx_list[-1])",
"mn_idx_list.append",
"mn_idx_list",
"append",
"mn_idx_list[-1]",
"mn_idx_list",
"-1",
"max_diff = max(max_diff, A[i] - mn)",
"max_diff",
"max(max_diff, A[i] - mn)",
"max",
"max_diff",
"A[i] - mn",
"A[i]",
"A",
"i",
"mn",
"for i in range(N):\n if A[i] - A[mn_idx_list[i]] == max_diff:\n uf.unite(i, mn_idx_list[i])\n \n ",
"i",
"range(N)",
"range",
"N",
"if A[i] - A[mn_idx_list[i]] == max_diff:\n uf.unite(i, mn_idx_list[i])\n \n ",
"A[i] - A[mn_idx_list[i]] == max_diff",
"A[i] - A[mn_idx_list[i]]",
"A[i]",
"A",
"i",
"A[mn_idx_list[i]]",
"A",
"mn_idx_list[i]",
"mn_idx_list",
"i",
"max_diff",
"uf.unite(i, mn_idx_list[i])",
"uf.unite",
"uf",
"unite",
"i",
"mn_idx_list[i]",
"mn_idx_list",
"i",
"parents_set = set()",
"parents_set",
"set()",
"set",
"for i in range(N):\n if uf.size(i) == 1:\n continue\n parents_set.add(uf.find(i))\n \n ",
"i",
"range(N)",
"range",
"N",
"if uf.size(i) == 1:\n continue\n ",
"uf.size(i) == 1",
"uf.size(i)",
"uf.size",
"uf",
"size",
"i",
"1",
"continue",
"parents_set.add(uf.find(i))",
"parents_set.add",
"parents_set",
"add",
"uf.find(i)",
"uf.find",
"uf",
"find",
"i",
"print(len(parents_set))",
"print",
"len(parents_set)",
"len",
"parents_set",
"if __name__ == '__main__':\n solve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"solve()",
"solve",
"def solve():\n N, T = map(int,input().split())\n A = list(map(int,input().split()))\n\n uf = UnionFind(N)\n\n mn_idx_list = []\n mn = float('inf')\n max_diff = 0\n for i in range(N):\n mn = min(mn, A[i])\n if mn == A[i]:\n mn_idx_list.append(i)\n else:\n mn_idx_list.append(mn_idx_list[-1])\n\n max_diff = max(max_diff, A[i] - mn)\n \n for i in range(N):\n if A[i] - A[mn_idx_list[i]] == max_diff:\n uf.unite(i, mn_idx_list[i])\n \n parents_set = set()\n for i in range(N):\n if uf.size(i) == 1:\n continue\n parents_set.add(uf.find(i))\n \n print(len(parents_set))",
"def solve():\n N, T = map(int,input().split())\n A = list(map(int,input().split()))\n\n uf = UnionFind(N)\n\n mn_idx_list = []\n mn = float('inf')\n max_diff = 0\n for i in range(N):\n mn = min(mn, A[i])\n if mn == A[i]:\n mn_idx_list.append(i)\n else:\n mn_idx_list.append(mn_idx_list[-1])\n\n max_diff = max(max_diff, A[i] - mn)\n \n for i in range(N):\n if A[i] - A[mn_idx_list[i]] == max_diff:\n uf.unite(i, mn_idx_list[i])\n \n parents_set = set()\n for i in range(N):\n if uf.size(i) == 1:\n continue\n parents_set.add(uf.find(i))\n \n print(len(parents_set))",
"solve",
"class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n \n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n \n def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n \n self.parents[x] += self.parents[y]\n self.parents[y] = x\n \n def size(self, x):\n return -self.parents[self.find(x)]\n \n def isSame(self, x, y):\n return self.find(x) == self.find(y)",
"class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n \n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n \n def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n \n self.parents[x] += self.parents[y]\n self.parents[y] = x\n \n def size(self, x):\n return -self.parents[self.find(x)]\n \n def isSame(self, x, y):\n return self.find(x) == self.find(y)",
"UnionFind"
] |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def isSame(self, x, y):
return self.find(x) == self.find(y)
def solve():
N, T = map(int,input().split())
A = list(map(int,input().split()))
uf = UnionFind(N)
mn_idx_list = []
mn = float('inf')
max_diff = 0
for i in range(N):
mn = min(mn, A[i])
if mn == A[i]:
mn_idx_list.append(i)
else:
mn_idx_list.append(mn_idx_list[-1])
max_diff = max(max_diff, A[i] - mn)
for i in range(N):
if A[i] - A[mn_idx_list[i]] == max_diff:
uf.unite(i, mn_idx_list[i])
parents_set = set()
for i in range(N):
if uf.size(i) == 1:
continue
parents_set.add(uf.find(i))
print(len(parents_set))
if __name__ == '__main__':
solve()
|
[
7,
15,
13,
15,
15,
15,
15,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
39,
4,
13,
13,
40,
18,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
13,
4,
13,
13,
0,
18,
13,
13,
2,
40,
13,
18,
13,
13,
4,
13,
13,
13,
4,
13,
13,
40,
18,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13
] |
[
[
123,
15
],
[
120,
20
],
[
30,
29
],
[
30,
38
],
[
41,
40
],
[
53,
52
],
[
29,
56
],
[
59,
58
],
[
58,
62
],
[
40,
65
],
[
29,
67
],
[
71,
70
],
[
29,
74
],
[
80,
79
],
[
58,
82
],
[
87,
84
],
[
52,
85
],
[
70,
86
],
[
79,
89
],
[
40,
91
],
[
70,
92
],
[
58,
95
],
[
79,
96
],
[
58,
99
],
[
40,
102
],
[
70,
103
],
[
52,
108
],
[
52,
112
],
[
127,
118
],
[
120,
121
],
[
123,
124
]
] |
[
"#!/usr/bin/env python3\nimport sys\nfrom collections import deque, Counter\nfrom heapq import heappop, heappush\nfrom bisect import bisect_right\nfrom itertools import accumulate\n\nsys.setrecursionlimit(10**6)\nINF = 10**12\nm = 10**9 + 7\n\ndef main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n cost = [0]*N# cost[i]: i番目で買ってから最適に売ることで得られる利益\n q = []\n heappush(q,-A[N-1])\n for i in range(N-2,-1,-1):\n v = heappop(q)\n cost[i] = -v-A[i]\n heappush(q,v)\n heappush(q,-A[i])\n # print(cost)\n print(cost.count(max(cost)))\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"from collections import deque, Counter",
"from heapq import heappop, heappush",
"from bisect import bisect_right",
"from itertools import accumulate",
"sys.setrecursionlimit(10**6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**6",
"10",
"6",
"INF = 10**12",
"INF",
"10**12",
"10",
"12",
"m = 10**9 + 7",
"m",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n cost = [0]*N# cost[i]: i番目で買ってから最適に売ることで得られる利益\n q = []\n heappush(q,-A[N-1])\n for i in range(N-2,-1,-1):\n v = heappop(q)\n cost[i] = -v-A[i]\n heappush(q,v)\n heappush(q,-A[i])\n # print(cost)\n print(cost.count(max(cost)))",
"main",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"cost = [0]*N",
"cost",
"[0]*N",
"[0]",
"0",
"N",
"q = []",
"q",
"[]",
"heappush(q,-A[N-1])",
"heappush",
"q",
"-A[N-1]",
"A[N-1]",
"A",
"N-1",
"N",
"1",
"for i in range(N-2,-1,-1):\n v = heappop(q)\n cost[i] = -v-A[i]\n heappush(q,v)\n heappush(q,-A[i])\n # print(cost)\n ",
"i",
"range(N-2,-1,-1)",
"range",
"N-2",
"N",
"2",
"-1",
"-1",
"v = heappop(q)",
"v",
"heappop(q)",
"heappop",
"q",
"cost[i] = -v-A[i]",
"cost[i]",
"cost",
"i",
"-v-A[i]",
"-v",
"v",
"A[i]",
"A",
"i",
"heappush(q,v)",
"heappush",
"q",
"v",
"heappush(q,-A[i])",
"heappush",
"q",
"-A[i]",
"A[i]",
"A",
"i",
"print(cost.count(max(cost)))",
"print",
"cost.count(max(cost))",
"cost.count",
"cost",
"count",
"max(cost)",
"max",
"cost",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"m = 10**9 + 7",
"10**9 + 7",
"m",
"INF = 10**12",
"10**12",
"INF",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n cost = [0]*N# cost[i]: i番目で買ってから最適に売ることで得られる利益\n q = []\n heappush(q,-A[N-1])\n for i in range(N-2,-1,-1):\n v = heappop(q)\n cost[i] = -v-A[i]\n heappush(q,v)\n heappush(q,-A[i])\n # print(cost)\n print(cost.count(max(cost)))",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n cost = [0]*N# cost[i]: i番目で買ってから最適に売ることで得られる利益\n q = []\n heappush(q,-A[N-1])\n for i in range(N-2,-1,-1):\n v = heappop(q)\n cost[i] = -v-A[i]\n heappush(q,v)\n heappush(q,-A[i])\n # print(cost)\n print(cost.count(max(cost)))",
"main"
] |
#!/usr/bin/env python3
import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate
sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7
def main():
N, T = map(int, input().split())
A = list(map(int, input().split()))
cost = [0]*N# cost[i]: i番目で買ってから最適に売ることで得られる利益
q = []
heappush(q,-A[N-1])
for i in range(N-2,-1,-1):
v = heappop(q)
cost[i] = -v-A[i]
heappush(q,v)
heappush(q,-A[i])
# print(cost)
print(cost.count(max(cost)))
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,
17,
0,
13,
17,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
2,
18,
13,
13,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
13,
14,
2,
2,
18,
13,
13,
13,
13,
0,
13,
13,
14,
2,
13,
18,
13,
13,
0,
13,
17,
0,
13,
18,
13,
13,
14,
2,
13,
18,
13,
13,
0,
13,
17,
4,
13,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13
] |
[
[
121,
2
],
[
121,
11
],
[
124,
13
],
[
103,
25
],
[
118,
28
],
[
136,
31
],
[
125,
33
],
[
109,
36
],
[
40,
39
],
[
113,
43
],
[
125,
48
],
[
39,
49
],
[
137,
50
],
[
128,
50
],
[
119,
51
],
[
131,
51
],
[
130,
53
],
[
125,
56
],
[
39,
57
],
[
137,
58
],
[
128,
58
],
[
115,
60
],
[
110,
61
],
[
107,
61
],
[
134,
61
],
[
125,
66
],
[
39,
67
],
[
137,
68
],
[
128,
68
],
[
119,
69
],
[
131,
69
],
[
100,
71
],
[
110,
72
],
[
107,
72
],
[
134,
72
],
[
137,
75
],
[
128,
75
],
[
125,
77
],
[
39,
78
],
[
133,
80
],
[
127,
83
],
[
125,
85
],
[
39,
86
],
[
137,
89
],
[
128,
89
],
[
125,
91
],
[
39,
92
],
[
106,
94
],
[
101,
98
],
[
116,
98
],
[
104,
98
],
[
110,
100
],
[
107,
100
],
[
134,
100
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
121,
113
],
[
110,
115
],
[
107,
115
],
[
134,
115
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
]
] |
[
"n,t=map(int,input().split())\nl=list(map(int,input().split()))\n#最大利益を実現する買い方の組がいくつあるか考えたい\n#ある地点で売るときはそれより前の地点の一番安いところで買うのが良いーnowminで判断しよう\ncount=0\nmax=0\nnowmin=l[0]\nnowmincount=1\nfor i in range(1,n):\n if l[i]-nowmin>max:\n max=l[i]-nowmin\n count=nowmincount\n elif l[i]-nowmin==max:\n count+=nowmincount\n elif nowmin>l[i]:\n nowmincount=1\n nowmin=l[i]\n elif nowmin==l[i]:\n nowmincount+=1\nprint(count)",
"n,t=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"l=list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"count=0",
"count",
"0",
"max=0",
"max",
"0",
"nowmin=l[0]",
"nowmin",
"l[0]",
"l",
"0",
"nowmincount=1",
"nowmincount",
"1",
"for i in range(1,n):\n if l[i]-nowmin>max:\n max=l[i]-nowmin\n count=nowmincount\n elif l[i]-nowmin==max:\n count+=nowmincount\n elif nowmin>l[i]:\n nowmincount=1\n nowmin=l[i]\n elif nowmin==l[i]:\n nowmincount+=1",
"i",
"range(1,n)",
"range",
"1",
"n",
"if l[i]-nowmin>max:\n max=l[i]-nowmin\n count=nowmincount\n elif l[i]-nowmin==max:\n count+=nowmincount\n elif nowmin>l[i]:\n nowmincount=1\n nowmin=l[i]\n elif nowmin==l[i]:\n nowmincount+=1",
"l[i]-nowmin>max",
"l[i]-nowmin",
"l[i]",
"l",
"i",
"nowmin",
"max",
"max=l[i]-nowmin",
"max",
"l[i]-nowmin",
"l[i]",
"l",
"i",
"nowmin",
"count=nowmincount",
"count",
"nowmincount",
"elif l[i]-nowmin==max:\n count+=nowmincount\n ",
"l[i]-nowmin==max",
"l[i]-nowmin",
"l[i]",
"l",
"i",
"nowmin",
"max",
"count+=nowmincount",
"count",
"nowmincount",
"elif nowmin>l[i]:\n nowmincount=1\n nowmin=l[i]\n ",
"nowmin>l[i]",
"nowmin",
"l[i]",
"l",
"i",
"nowmincount=1",
"nowmincount",
"1",
"nowmin=l[i]",
"nowmin",
"l[i]",
"l",
"i",
"elif nowmin==l[i]:\n nowmincount+=1",
"nowmin==l[i]",
"nowmin",
"l[i]",
"l",
"i",
"nowmincount+=1",
"nowmincount",
"1",
"print(count)",
"print",
"count",
"count+=nowmincount",
"nowmincount",
"count",
"count=0",
"0",
"count",
"nowmincount+=1",
"1",
"nowmincount",
"nowmincount=1",
"1",
"nowmincount",
"n,t=map(int,input().split())",
"map(int,input().split())",
"n",
"count=nowmincount",
"nowmincount",
"count",
"max=0",
"0",
"max",
"t=map(int,input().split())",
"map(int,input().split())",
"t",
"l=list(map(int,input().split()))",
"list(map(int,input().split()))",
"l",
"nowmin=l[i]",
"l[i]",
"nowmin",
"max=l[i]-nowmin",
"l[i]-nowmin",
"max",
"nowmincount=1",
"1",
"nowmincount",
"nowmin=l[0]",
"l[0]",
"nowmin"
] |
n,t=map(int,input().split())
l=list(map(int,input().split()))
#最大利益を実現する買い方の組がいくつあるか考えたい
#ある地点で売るときはそれより前の地点の一番安いところで買うのが良いーnowminで判断しよう
count=0
max=0
nowmin=l[0]
nowmincount=1
for i in range(1,n):
if l[i]-nowmin>max:
max=l[i]-nowmin
count=nowmincount
elif l[i]-nowmin==max:
count+=nowmincount
elif nowmin>l[i]:
nowmincount=1
nowmin=l[i]
elif nowmin==l[i]:
nowmincount+=1
print(count)
|
[
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,
39,
0,
13,
18,
13,
17,
28,
13,
18,
18,
13,
39,
17,
39,
17,
0,
13,
4,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
18,
13,
39,
17,
41,
28,
13,
13,
4,
13,
18,
13,
39,
17,
13,
4,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
41,
28,
13,
13,
2,
13,
13,
4,
17,
4,
13,
4,
13,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] |
[
[
114,
2
],
[
114,
11
],
[
117,
13
],
[
108,
25
],
[
96,
28
],
[
118,
30
],
[
34,
33
],
[
118,
36
],
[
111,
42
],
[
97,
45
],
[
112,
45
],
[
33,
46
],
[
109,
49
],
[
112,
51
],
[
97,
51
],
[
99,
53
],
[
109,
55
],
[
118,
65
],
[
100,
68
],
[
109,
68
],
[
112,
71
],
[
97,
71
],
[
120,
74
],
[
102,
77
],
[
121,
80
],
[
84,
83
],
[
121,
83
],
[
83,
86
],
[
103,
87
],
[
112,
87
],
[
97,
87
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
114,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
]
] |
[
"n, t = map(int, input().split())\nls = list(map(int, input().split()))\nms = []\nm = ls[-1]\nfor x in ls[1:][::-1]:\n m = max(m, x)\n ms.append(m)\nms = ms[::-1]\nds = [m - x for x, m in zip(ls[:-1], ms)]\nm = max(ds)\nprint(sum([1 for d in ds if d == m]))",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"ls = list(map(int, input().split()))",
"ls",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ms = []",
"ms",
"[]",
"m = ls[-1]",
"m",
"ls[-1]",
"ls",
"-1",
"for x in ls[1:][::-1]:\n m = max(m, x)\n ms.append(m)",
"x",
"ls[1:][::-1]",
"[1:]",
"ls",
"1:",
"1",
"::-1",
"-1",
"m = max(m, x)",
"m",
"max(m, x)",
"max",
"m",
"x",
"ms.append(m)",
"ms.append",
"ms",
"append",
"m",
"ms = ms[::-1]",
"ms",
"ms[::-1]",
"ms",
"::-1",
"-1",
"m - x for x, m in zip(ls[:-1], ms)",
"for x, m in zip(ls[:-1], ms)",
"x",
"m",
"zip(ls[:-1], ms)",
"zip",
"ls[:-1]",
"ls",
":-1",
"-1",
"ms",
"for x, m in zip(ls[:-1], ms)",
"m - x",
"m",
"x",
"ds = [m - x for x, m in zip(ls[:-1], ms)]",
"ds",
"[m - x for x, m in zip(ls[:-1], ms)]",
"m = max(ds)",
"m",
"max(ds)",
"max",
"ds",
"1 for d in ds if d == m",
"for d in ds if d == m",
"d",
"ds",
"d == m",
"d",
"m",
"if d == m",
"1",
"print(sum([1 for d in ds if d == m]))",
"print",
"sum([1 for d in ds if d == m])",
"sum",
"[1 for d in ds if d == m]",
"m = ls[-1]",
"ls[-1]",
"m",
"ms = ms[::-1]",
"ms[::-1]",
"ms",
"m = max(ds)",
"max(ds)",
"m",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"ms = []",
"[]",
"ms",
"m = max(m, x)",
"max(m, x)",
"m",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"ls = list(map(int, input().split()))",
"list(map(int, input().split()))",
"ls",
"ds = [m - x for x, m in zip(ls[:-1], ms)]",
"[m - x for x, m in zip(ls[:-1], ms)]",
"ds"
] |
n, t = map(int, input().split())
ls = list(map(int, input().split()))
ms = []
m = ls[-1]
for x in ls[1:][::-1]:
m = max(m, x)
ms.append(m)
ms = ms[::-1]
ds = [m - x for x, m in zip(ls[:-1], ms)]
m = max(ds)
print(sum([1 for d in ds if d == m]))
|
[
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,
18,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
0,
13,
17,
14,
2,
18,
13,
13,
13,
14,
2,
2,
13,
18,
13,
13,
13,
0,
13,
2,
13,
18,
13,
13,
0,
13,
17,
14,
2,
2,
13,
18,
13,
13,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13
] |
[
[
115,
2
],
[
115,
11
],
[
112,
13
],
[
127,
25
],
[
113,
27
],
[
121,
30
],
[
130,
33
],
[
106,
36
],
[
40,
39
],
[
116,
43
],
[
113,
50
],
[
39,
51
],
[
128,
52
],
[
104,
52
],
[
103,
54
],
[
113,
56
],
[
39,
57
],
[
109,
59
],
[
113,
64
],
[
39,
65
],
[
128,
66
],
[
104,
66
],
[
128,
70
],
[
104,
70
],
[
113,
72
],
[
39,
73
],
[
131,
74
],
[
125,
74
],
[
124,
76
],
[
128,
78
],
[
104,
78
],
[
113,
80
],
[
39,
81
],
[
133,
83
],
[
128,
88
],
[
104,
88
],
[
113,
90
],
[
39,
91
],
[
131,
92
],
[
125,
92
],
[
118,
94
],
[
119,
98
],
[
134,
98
],
[
107,
98
],
[
115,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
]
] |
[
"n, t = map(int, input().split())\na = list(map(int, input().split()))\n\nma = a[-1]\nm = 1\nmaxsaeki = 0\nans = 0\n\nfor i in range(n-2,-1,-1):\n if a[i] > ma:\n ma = a[i]\n m = 1\n elif a[i] < ma:\n if (ma - a[i]) > maxsaeki:\n maxsaeki = ma-a[i]\n ans = 1\n elif (ma - a[i]) == maxsaeki:\n ans += 1\n\nprint(ans)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ma = a[-1]",
"ma",
"a[-1]",
"a",
"-1",
"m = 1",
"m",
"1",
"maxsaeki = 0",
"maxsaeki",
"0",
"ans = 0",
"ans",
"0",
"for i in range(n-2,-1,-1):\n if a[i] > ma:\n ma = a[i]\n m = 1\n elif a[i] < ma:\n if (ma - a[i]) > maxsaeki:\n maxsaeki = ma-a[i]\n ans = 1\n elif (ma - a[i]) == maxsaeki:\n ans += 1",
"i",
"range(n-2,-1,-1)",
"range",
"n-2",
"n",
"2",
"-1",
"-1",
"if a[i] > ma:\n ma = a[i]\n m = 1\n elif a[i] < ma:\n if (ma - a[i]) > maxsaeki:\n maxsaeki = ma-a[i]\n ans = 1\n elif (ma - a[i]) == maxsaeki:\n ans += 1",
"a[i] > ma",
"a[i]",
"a",
"i",
"ma",
"ma = a[i]",
"ma",
"a[i]",
"a",
"i",
"m = 1",
"m",
"1",
"elif a[i] < ma:\n if (ma - a[i]) > maxsaeki:\n maxsaeki = ma-a[i]\n ans = 1\n elif (ma - a[i]) == maxsaeki:\n ans += 1",
"a[i] < ma",
"a[i]",
"a",
"i",
"ma",
"if (ma - a[i]) > maxsaeki:\n maxsaeki = ma-a[i]\n ans = 1\n elif (ma - a[i]) == maxsaeki:\n ans += 1",
"(ma - a[i]) > maxsaeki",
"ma - a[i]",
"ma",
"a[i]",
"a",
"i",
"maxsaeki",
"maxsaeki = ma-a[i]",
"maxsaeki",
"ma-a[i]",
"ma",
"a[i]",
"a",
"i",
"ans = 1",
"ans",
"1",
"elif (ma - a[i]) == maxsaeki:\n ans += 1",
"(ma - a[i]) == maxsaeki",
"ma - a[i]",
"ma",
"a[i]",
"a",
"i",
"maxsaeki",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"ma = a[i]",
"a[i]",
"ma",
"ans = 0",
"0",
"ans",
"m = 1",
"1",
"m",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"ans += 1",
"1",
"ans",
"m = 1",
"1",
"m",
"maxsaeki = ma-a[i]",
"ma-a[i]",
"maxsaeki",
"ma = a[-1]",
"a[-1]",
"ma",
"maxsaeki = 0",
"0",
"maxsaeki",
"ans = 1",
"1",
"ans"
] |
n, t = map(int, input().split())
a = list(map(int, input().split()))
ma = a[-1]
m = 1
maxsaeki = 0
ans = 0
for i in range(n-2,-1,-1):
if a[i] > ma:
ma = a[i]
m = 1
elif a[i] < ma:
if (ma - a[i]) > maxsaeki:
maxsaeki = ma-a[i]
ans = 1
elif (ma - a[i]) == maxsaeki:
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,
15,
0,
13,
4,
13,
13,
0,
13,
2,
17,
17,
28,
13,
13,
14,
2,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
0,
13,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13
] |
[
[
77,
2
],
[
77,
11
],
[
62,
13
],
[
59,
26
],
[
68,
31
],
[
37,
36
],
[
63,
36
],
[
36,
40
],
[
69,
41
],
[
65,
43
],
[
60,
48
],
[
71,
51
],
[
60,
53
],
[
66,
54
],
[
72,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
77,
75
],
[
77,
78
]
] |
[
"n, t = map(int, input().split())\nA = list(map(int, input().split()))\nfrom collections import defaultdict\nprof = defaultdict(int)\nlow = 10**9\nfor a in A:\n if a > low: prof[a - low] += 1\n else: low = a\nkmax = max(prof.keys())\nans = prof[kmax]\nprint(ans)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"from collections import defaultdict",
"prof = defaultdict(int)",
"prof",
"defaultdict(int)",
"defaultdict",
"int",
"low = 10**9",
"low",
"10**9",
"10",
"9",
"for a in A:\n if a > low: prof[a - low] += 1\n else: low = a",
"a",
"A",
"if a > low: prof[a - low] += 1\n else: low = a",
"a > low",
"a",
"low",
"kmax = max(prof.keys())",
"kmax",
"max(prof.keys())",
"max",
"prof.keys()",
"prof.keys",
"prof",
"keys",
"ans = prof[kmax]",
"ans",
"prof[kmax]",
"prof",
"kmax",
"print(ans)",
"print",
"ans",
"prof = defaultdict(int)",
"defaultdict(int)",
"prof",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"kmax = max(prof.keys())",
"max(prof.keys())",
"kmax",
"low = 10**9",
"10**9",
"low",
"ans = prof[kmax]",
"prof[kmax]",
"ans",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n"
] |
n, t = map(int, input().split())
A = list(map(int, input().split()))
from collections import defaultdict
prof = defaultdict(int)
low = 10**9
for a in A:
if a > low: prof[a - low] += 1
else: low = a
kmax = max(prof.keys())
ans = prof[kmax]
print(ans)
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
31,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
18,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
2,
18,
13,
13,
13,
14,
2,
18,
13,
13,
13,
0,
18,
13,
13,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13
] |
[
[
114,
3
],
[
114,
12
],
[
16,
14
],
[
117,
25
],
[
123,
30
],
[
108,
35
],
[
96,
38
],
[
42,
41
],
[
115,
45
],
[
126,
47
],
[
41,
51
],
[
124,
52
],
[
106,
52
],
[
60,
55
],
[
118,
56
],
[
124,
57
],
[
106,
57
],
[
127,
58
],
[
63,
60
],
[
118,
61
],
[
124,
62
],
[
106,
62
],
[
127,
63
],
[
41,
68
],
[
124,
69
],
[
106,
69
],
[
105,
71
],
[
41,
74
],
[
127,
77
],
[
109,
78
],
[
112,
78
],
[
111,
80
],
[
127,
81
],
[
102,
83
],
[
127,
87
],
[
109,
88
],
[
112,
88
],
[
120,
90
],
[
121,
94
],
[
103,
94
],
[
97,
94
],
[
96,
97
],
[
114,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
127,
111
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
]
] |
[
"from collections import defaultdict\n\nN, T = map(int, input().split())\n*a, = map(int, input().split())\nt = defaultdict(int)\nm = a[0]\np = 0\nans = 0\nfor i in range(1, N):\n c = a[i] - m\n if t[m] < c:\n t[m] = c\n if a[i] < m:\n m = a[i]\n if c > p:\n p = c\n ans = 1\n elif c == p:\n ans += 1\n\nprint(ans)",
"from collections import defaultdict",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"*a, = map(int, input().split())",
"*a",
"a",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t = defaultdict(int)",
"t",
"defaultdict(int)",
"defaultdict",
"int",
"m = a[0]",
"m",
"a[0]",
"a",
"0",
"p = 0",
"p",
"0",
"ans = 0",
"ans",
"0",
"for i in range(1, N):\n c = a[i] - m\n if t[m] < c:\n t[m] = c\n if a[i] < m:\n m = a[i]\n if c > p:\n p = c\n ans = 1\n elif c == p:\n ans += 1",
"i",
"range(1, N)",
"range",
"1",
"N",
"c = a[i] - m",
"c",
"a[i] - m",
"a[i]",
"a",
"i",
"m",
"if t[m] < c:\n t[m] = c\n ",
"t[m] < c",
"t[m]",
"t",
"m",
"c",
"t[m] = c",
"t[m]",
"t",
"m",
"c",
"if a[i] < m:\n m = a[i]\n ",
"a[i] < m",
"a[i]",
"a",
"i",
"m",
"m = a[i]",
"m",
"a[i]",
"a",
"i",
"if c > p:\n p = c\n ans = 1\n elif c == p:\n ans += 1",
"c > p",
"c",
"p",
"p = c",
"p",
"c",
"ans = 1",
"ans",
"1",
"elif c == p:\n ans += 1",
"c == p",
"c",
"p",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"ans = 1",
"1",
"ans",
"m = a[i]",
"a[i]",
"m",
"p = 0",
"0",
"p",
"p = c",
"c",
"p",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"t = defaultdict(int)",
"defaultdict(int)",
"t",
"ans += 1",
"1",
"ans",
"m = a[0]",
"a[0]",
"m",
"c = a[i] - m",
"a[i] - m",
"c"
] |
from collections import defaultdict
N, T = map(int, input().split())
*a, = map(int, input().split())
t = defaultdict(int)
m = a[0]
p = 0
ans = 0
for i in range(1, N):
c = a[i] - m
if t[m] < c:
t[m] = c
if a[i] < m:
m = a[i]
if c > p:
p = c
ans = 1
elif c == p:
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,
17,
13,
17,
0,
13,
39,
0,
13,
39,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
13,
14,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
13,
13,
0,
13,
18,
13,
13,
0,
13,
39,
0,
13,
39,
0,
13,
39,
13,
14,
2,
13,
17,
14,
40,
13,
13,
0,
13,
13,
0,
13,
39,
14,
2,
13,
13,
0,
13,
13,
13,
39,
13,
13,
17,
14,
2,
40,
4,
13,
13,
17,
40,
4,
13,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
17,
13,
10,
39,
13,
10,
13,
13,
10,
39,
13,
10,
39,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
2,
13,
10,
39,
13
] |
[
[
182,
2
],
[
182,
11
],
[
137,
13
],
[
134,
25
],
[
164,
27
],
[
188,
30
],
[
140,
33
],
[
143,
36
],
[
146,
39
],
[
43,
42
],
[
168,
45
],
[
191,
47
],
[
138,
50
],
[
42,
51
],
[
135,
52
],
[
174,
52
],
[
192,
55
],
[
179,
58
],
[
189,
63
],
[
156,
63
],
[
153,
63
],
[
144,
66
],
[
186,
66
],
[
150,
66
],
[
173,
68
],
[
138,
70
],
[
42,
71
],
[
149,
73
],
[
155,
76
],
[
194,
79
],
[
192,
84
],
[
165,
88
],
[
177,
88
],
[
192,
89
],
[
152,
91
],
[
141,
92
],
[
195,
92
],
[
159,
92
],
[
158,
94
],
[
165,
98
],
[
177,
98
],
[
192,
99
],
[
176,
101
],
[
192,
102
],
[
185,
103
],
[
161,
106
],
[
156,
113
],
[
153,
113
],
[
189,
113
],
[
186,
118
],
[
150,
118
],
[
144,
118
],
[
170,
121
],
[
156,
126
],
[
153,
126
],
[
189,
126
],
[
186,
129
],
[
150,
129
],
[
144,
129
],
[
171,
132
],
[
162,
132
],
[
180,
132
],
[
147,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
],
[
149,
150
],
[
141,
152
],
[
195,
152
],
[
159,
152
],
[
152,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
182,
168
],
[
170,
171
],
[
173,
174
],
[
192,
176
],
[
176,
177
],
[
179,
180
],
[
182,
183
],
[
185,
186
],
[
188,
189
],
[
191,
192
],
[
194,
195
]
] |
[
"n,t= map(int,input().split())\na= list(map(int,input().split()))\nmp,mprof = 999999999,0\nbid = []\nbsus = []\nsid = []\nnc=0\nfor i in range(n):\n cp = a[i]-mp\n if cp<0:\n nc += min(len(bid),len(sid))\n mp = a[i]\n sid=[]\n bid=[]\n bsus=[i]\n elif cp>0:\n if mprof <= cp:\n bid += bsus\n bsus = []\n if mprof < cp:\n mprof,sid,nc = cp,[i],0\n else:sid.append(i)\n else:bsus.append(i)\nelse:\n if len(bid)!=0 and len(sid)!=0:\n nc += min(len(bid),len(sid))\nprint(nc)",
"n,t= map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a= list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mp,mprof = 999999999,0",
"mp",
"999999999",
"mprof",
"0",
"bid = []",
"bid",
"[]",
"bsus = []",
"bsus",
"[]",
"sid = []",
"sid",
"[]",
"nc=0",
"nc",
"0",
"for i in range(n):\n cp = a[i]-mp\n if cp<0:\n nc += min(len(bid),len(sid))\n mp = a[i]\n sid=[]\n bid=[]\n bsus=[i]\n elif cp>0:\n if mprof <= cp:\n bid += bsus\n bsus = []\n if mprof < cp:\n mprof,sid,nc = cp,[i],0\n else:sid.append(i)\n else:bsus.append(i)\nelse:\n if len(bid)!=0 and len(sid)!=0:\n nc += min(len(bid),len(sid))",
"i",
"range(n)",
"range",
"n",
"cp = a[i]-mp",
"cp",
"a[i]-mp",
"a[i]",
"a",
"i",
"mp",
"if cp<0:\n nc += min(len(bid),len(sid))\n mp = a[i]\n sid=[]\n bid=[]\n bsus=[i]\n elif cp>0:\n if mprof <= cp:\n bid += bsus\n bsus = []\n if mprof < cp:\n mprof,sid,nc = cp,[i],0\n else:sid.append(i)\n else:bsus.append(i)",
"cp<0",
"cp",
"0",
"nc += min(len(bid),len(sid))",
"nc",
"min(len(bid),len(sid))",
"min",
"len(bid)",
"len",
"bid",
"len(sid)",
"len",
"sid",
"mp = a[i]",
"mp",
"a[i]",
"a",
"i",
"sid=[]",
"sid",
"[]",
"bid=[]",
"bid",
"[]",
"bsus=[i]",
"bsus",
"[i]",
"i",
"elif cp>0:\n if mprof <= cp:\n bid += bsus\n bsus = []\n if mprof < cp:\n mprof,sid,nc = cp,[i],0\n else:sid.append(i)\n ",
"cp>0",
"cp",
"0",
"if mprof <= cp:\n bid += bsus\n bsus = []\n if mprof < cp:\n mprof,sid,nc = cp,[i],0\n else:sid.append(i)\n ",
"mprof <= cp",
"mprof",
"cp",
"bid += bsus",
"bid",
"bsus",
"bsus = []",
"bsus",
"[]",
"if mprof < cp:\n mprof,sid,nc = cp,[i],0\n else:sid.append(i)\n ",
"mprof < cp",
"mprof",
"cp",
"mprof,sid,nc = cp,[i],0",
"mprof",
"cp",
"sid",
"[i]",
"i",
"nc",
"0",
"if len(bid)!=0 and len(sid)!=0:\n nc += min(len(bid),len(sid))",
"len(bid)!=0 and len(sid)!=0",
"len(bid)!=0",
"len(bid)",
"len",
"bid",
"0",
"len(sid)!=0",
"len(sid)",
"len",
"sid",
"0",
"nc += min(len(bid),len(sid))",
"nc",
"min(len(bid),len(sid))",
"min",
"len(bid)",
"len",
"bid",
"len(sid)",
"len",
"sid",
"print(nc)",
"print",
"nc",
"mp,mprof = 999999999,0",
"999999999",
"mp",
"a= list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"bsus = []",
"[]",
"bsus",
"sid = []",
"[]",
"sid",
"nc=0",
"0",
"nc",
"sid=[]",
"[]",
"sid",
"bid += bsus",
"bsus",
"bid",
"bid=[]",
"[]",
"bid",
"bsus = []",
"[]",
"bsus",
"nc = cp,[i],0",
"0",
"nc",
"mprof = 999999999,0",
"0",
"mprof",
"n,t= map(int,input().split())",
"map(int,input().split())",
"n",
"nc += min(len(bid),len(sid))",
"min(len(bid),len(sid))",
"nc",
"mp = a[i]",
"a[i]",
"mp",
"mprof,sid,nc = cp,[i],0",
"cp",
"mprof",
"nc += min(len(bid),len(sid))",
"min(len(bid),len(sid))",
"nc",
"t= map(int,input().split())",
"map(int,input().split())",
"t",
"sid,nc = cp,[i],0",
"[i]",
"sid",
"bid = []",
"[]",
"bid",
"cp = a[i]-mp",
"a[i]-mp",
"cp",
"bsus=[i]",
"[i]",
"bsus"
] |
n,t= map(int,input().split())
a= list(map(int,input().split()))
mp,mprof = 999999999,0
bid = []
bsus = []
sid = []
nc=0
for i in range(n):
cp = a[i]-mp
if cp<0:
nc += min(len(bid),len(sid))
mp = a[i]
sid=[]
bid=[]
bsus=[i]
elif cp>0:
if mprof <= cp:
bid += bsus
bsus = []
if mprof < cp:
mprof,sid,nc = cp,[i],0
else:sid.append(i)
else:bsus.append(i)
else:
if len(bid)!=0 and len(sid)!=0:
nc += min(len(bid),len(sid))
print(nc)
|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
2,
17,
4,
18,
2,
4,
13,
13,
17,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
2,
39,
17,
2,
2,
17,
18,
13,
13,
17,
0,
18,
18,
13,
13,
39,
2,
18,
13,
13,
17,
2,
2,
18,
13,
13,
17,
4,
13,
13,
13,
28,
13,
4,
13,
4,
13,
2,
18,
13,
13,
17,
0,
18,
18,
13,
13,
13,
4,
18,
13,
13,
18,
18,
13,
13,
2,
2,
17,
13,
17,
18,
18,
13,
13,
2,
2,
17,
13,
17,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
17,
0,
18,
18,
13,
13,
13,
13,
42,
13,
0,
13,
2,
2,
13,
17,
17,
0,
18,
18,
13,
13,
13,
4,
18,
13,
13,
18,
18,
13,
13,
2,
2,
17,
13,
17,
18,
18,
13,
13,
2,
2,
17,
13,
17,
23,
13,
23,
13,
23,
13,
12,
13,
4,
40,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
18,
13,
13,
2,
13,
17,
42,
2,
13,
13,
14,
2,
13,
17,
0,
13,
4,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
17,
0,
13,
17,
14,
2,
13,
17,
0,
13,
17,
0,
13,
4,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
17,
0,
13,
17,
0,
13,
17,
29,
13,
23,
13,
23,
13,
23,
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,
14,
2,
13,
17,
29,
17,
12,
13,
14,
40,
13,
13,
29,
13,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
4,
18,
13,
13,
2,
13,
17,
13,
18,
13,
13,
0,
18,
13,
13,
2,
4,
18,
13,
13,
13,
17,
17,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
0,
13,
13,
29,
18,
13,
13,
4,
13,
4,
13,
10,
6,
13,
10,
12,
13
] |
[
[
9,
6
],
[
99,
7
],
[
101,
16
],
[
23,
20
],
[
99,
21
],
[
103,
23
],
[
28,
25
],
[
99,
26
],
[
6,
34
],
[
99,
35
],
[
58,
39
],
[
25,
40
],
[
99,
41
],
[
6,
45
],
[
99,
46
],
[
6,
51
],
[
99,
52
],
[
101,
57
],
[
101,
58
],
[
61,
60
],
[
6,
66
],
[
99,
67
],
[
76,
71
],
[
25,
72
],
[
99,
73
],
[
60,
75
],
[
20,
77
],
[
99,
78
],
[
25,
81
],
[
99,
82
],
[
60,
87
],
[
25,
90
],
[
99,
91
],
[
60,
96
],
[
99,
99
],
[
101,
101
],
[
103,
103
],
[
108,
107
],
[
158,
110
],
[
119,
114
],
[
158,
116
],
[
107,
118
],
[
160,
118
],
[
162,
119
],
[
124,
123
],
[
107,
126
],
[
160,
126
],
[
123,
126
],
[
135,
130
],
[
158,
132
],
[
123,
134
],
[
107,
134
],
[
160,
134
],
[
158,
137
],
[
158,
141
],
[
123,
146
],
[
107,
146
],
[
160,
146
],
[
158,
150
],
[
123,
155
],
[
107,
155
],
[
160,
155
],
[
158,
158
],
[
160,
160
],
[
162,
162
],
[
245,
167
],
[
247,
168
],
[
171,
170
],
[
243,
172
],
[
176,
175
],
[
243,
177
],
[
181,
180
],
[
243,
183
],
[
170,
186
],
[
245,
186
],
[
170,
190
],
[
245,
190
],
[
235,
190
],
[
211,
190
],
[
175,
191
],
[
247,
191
],
[
238,
191
],
[
218,
191
],
[
170,
194
],
[
245,
194
],
[
235,
194
],
[
211,
194
],
[
198,
197
],
[
243,
200
],
[
180,
202
],
[
221,
202
],
[
197,
202
],
[
243,
205
],
[
170,
208
],
[
245,
208
],
[
235,
208
],
[
211,
208
],
[
212,
211
],
[
175,
215
],
[
247,
215
],
[
238,
215
],
[
218,
215
],
[
219,
218
],
[
222,
221
],
[
243,
224
],
[
197,
226
],
[
180,
226
],
[
221,
226
],
[
243,
229
],
[
218,
232
],
[
175,
232
],
[
247,
232
],
[
238,
232
],
[
236,
235
],
[
239,
238
],
[
221,
241
],
[
197,
241
],
[
180,
241
],
[
243,
243
],
[
245,
245
],
[
247,
247
],
[
252,
251
],
[
252,
260
],
[
263,
262
],
[
251,
275
],
[
290,
283
],
[
292,
284
],
[
290,
286
],
[
292,
288
],
[
290,
290
],
[
292,
292
],
[
295,
294
],
[
262,
297
],
[
280,
298
],
[
301,
300
],
[
304,
303
],
[
251,
306
],
[
309,
308
],
[
294,
312
],
[
164,
313
],
[
303,
315
],
[
251,
317
],
[
262,
319
],
[
303,
320
],
[
325,
322
],
[
300,
323
],
[
308,
324
],
[
300,
328
],
[
308,
330
],
[
335,
334
],
[
338,
337
],
[
300,
337
],
[
337,
341
],
[
334,
342
],
[
344,
342
],
[
345,
344
],
[
337,
345
],
[
300,
348
],
[
344,
349
],
[
334,
349
],
[
359,
353
]
] |
[
"class SegTree:\n def __init__(self, a, func):\n self.n = 2**(len(a) - 1).bit_length()\n self.f = func\n self.d = [0] * (2 * self.n - 1)\n self.d[self.n - 1:self.n - 1 + len(a)] = a\n for i in reversed(range(self.n - 1)):\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n\n def update(self, i, v):\n i += self.n - 1\n self.d[i] = v\n while i:\n i = (i - 1) // 2\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n # l <= i < r\n def query(self, l, r):\n assert l <= r\n l += self.n\n r += self.n\n s = self.d[l - 1]\n while l < r:\n if l & 1:\n s = self.f(s, self.d[l - 1])\n l += 1\n if r & 1:\n r -= 1\n s = self.f(s, self.d[r - 1])\n l //= 2\n r //= 2\n return s\ndef main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n if N == 2:\n return 1\n def func(a, b):\n if a >= b:\n return a\n return b\n s = SegTree(A, func)\n d = {}\n for i in range(N):\n t = s.query(i+1, N) - A[i]\n d[t] = d.get(t, 0) + 1\n m = 0\n for i in d:\n if i > m:\n m = i\n return d[m]\nprint(main())",
"class SegTree:\n def __init__(self, a, func):\n self.n = 2**(len(a) - 1).bit_length()\n self.f = func\n self.d = [0] * (2 * self.n - 1)\n self.d[self.n - 1:self.n - 1 + len(a)] = a\n for i in reversed(range(self.n - 1)):\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n\n def update(self, i, v):\n i += self.n - 1\n self.d[i] = v\n while i:\n i = (i - 1) // 2\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n # l <= i < r\n def query(self, l, r):\n assert l <= r\n l += self.n\n r += self.n\n s = self.d[l - 1]\n while l < r:\n if l & 1:\n s = self.f(s, self.d[l - 1])\n l += 1\n if r & 1:\n r -= 1\n s = self.f(s, self.d[r - 1])\n l //= 2\n r //= 2\n return s",
"SegTree",
"def __init__(self, a, func):\n self.n = 2**(len(a) - 1).bit_length()\n self.f = func\n self.d = [0] * (2 * self.n - 1)\n self.d[self.n - 1:self.n - 1 + len(a)] = a\n for i in reversed(range(self.n - 1)):\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n\n ",
"__init__",
"self.n = 2**(len(a) - 1).bit_length()",
"self.n",
"self",
"n",
"2**(len(a) - 1).bit_length()",
"2",
"(len(a) - 1).bit_length()",
"len(a) - 1).bit_length",
"len(a) - 1",
"len(a)",
"len",
"a",
"1",
"bit_length",
"self.f = func",
"self.f",
"self",
"f",
"func",
"self.d = [0] * (2 * self.n - 1)",
"self.d",
"self",
"d",
"[0] * (2 * self.n - 1)",
"[0]",
"0",
"2 * self.n - 1",
"2 * self.n",
"2",
"self.n",
"self",
"n",
"1",
"self.d[self.n - 1:self.n - 1 + len(a)] = a",
"self.d[self.n - 1:self.n - 1 + len(a)]",
"self.d",
"self",
"d",
"self.n - 1:self.n - 1 + len(a)",
"self.n - 1",
"self.n",
"self",
"n",
"1",
"self.n - 1 + len(a)",
"self.n - 1",
"self.n",
"self",
"n",
"1",
"len(a)",
"len",
"a",
"a",
"for i in reversed(range(self.n - 1)):\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n\n ",
"i",
"reversed(range(self.n - 1))",
"reversed",
"range(self.n - 1)",
"range",
"self.n - 1",
"self.n",
"self",
"n",
"1",
"self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])",
"self.d[i]",
"self.d",
"self",
"d",
"i",
"self.f(self.d[2 * i + 1], self.d[2 * i + 2])",
"self.f",
"self",
"f",
"self.d[2 * i + 1]",
"self.d",
"self",
"d",
"2 * i + 1",
"2 * i",
"2",
"i",
"1",
"self.d[2 * i + 2]",
"self.d",
"self",
"d",
"2 * i + 2",
"2 * i",
"2",
"i",
"2",
"self",
"self",
"a",
"a",
"func",
"func",
"def update(self, i, v):\n i += self.n - 1\n self.d[i] = v\n while i:\n i = (i - 1) // 2\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n # l <= i < r\n ",
"update",
"i += self.n - 1",
"i",
"self.n - 1",
"self.n",
"self",
"n",
"1",
"self.d[i] = v",
"self.d[i]",
"self.d",
"self",
"d",
"i",
"v",
"while i:\n i = (i - 1) // 2\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n # l <= i < r\n ",
"i",
"i = (i - 1) // 2",
"i",
"(i - 1) // 2",
"i - 1",
"i",
"1",
"2",
"self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])",
"self.d[i]",
"self.d",
"self",
"d",
"i",
"self.f(self.d[2 * i + 1], self.d[2 * i + 2])",
"self.f",
"self",
"f",
"self.d[2 * i + 1]",
"self.d",
"self",
"d",
"2 * i + 1",
"2 * i",
"2",
"i",
"1",
"self.d[2 * i + 2]",
"self.d",
"self",
"d",
"2 * i + 2",
"2 * i",
"2",
"i",
"2",
"self",
"self",
"i",
"i",
"v",
"v",
"def query(self, l, r):\n assert l <= r\n l += self.n\n r += self.n\n s = self.d[l - 1]\n while l < r:\n if l & 1:\n s = self.f(s, self.d[l - 1])\n l += 1\n if r & 1:\n r -= 1\n s = self.f(s, self.d[r - 1])\n l //= 2\n r //= 2\n return s",
"query",
"assert l <= r",
"l <= r",
"l",
"r",
"l += self.n",
"l",
"self.n",
"self",
"n",
"r += self.n",
"r",
"self.n",
"self",
"n",
"s = self.d[l - 1]",
"s",
"self.d[l - 1]",
"self.d",
"self",
"d",
"l - 1",
"l",
"1",
"while l < r:\n if l & 1:\n s = self.f(s, self.d[l - 1])\n l += 1\n if r & 1:\n r -= 1\n s = self.f(s, self.d[r - 1])\n l //= 2\n r //= 2\n ",
"l < r",
"l",
"r",
"if l & 1:\n s = self.f(s, self.d[l - 1])\n l += 1\n ",
"l & 1",
"l",
"1",
"s = self.f(s, self.d[l - 1])",
"s",
"self.f(s, self.d[l - 1])",
"self.f",
"self",
"f",
"s",
"self.d[l - 1]",
"self.d",
"self",
"d",
"l - 1",
"l",
"1",
"l += 1",
"l",
"1",
"if r & 1:\n r -= 1\n s = self.f(s, self.d[r - 1])\n ",
"r & 1",
"r",
"1",
"r -= 1",
"r",
"1",
"s = self.f(s, self.d[r - 1])",
"s",
"self.f(s, self.d[r - 1])",
"self.f",
"self",
"f",
"s",
"self.d[r - 1]",
"self.d",
"self",
"d",
"r - 1",
"r",
"1",
"l //= 2",
"l",
"2",
"r //= 2",
"r",
"2",
"return s",
"s",
"self",
"self",
"l",
"l",
"r",
"r",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n if N == 2:\n return 1\n def func(a, b):\n if a >= b:\n return a\n return b\n s = SegTree(A, func)\n d = {}\n for i in range(N):\n t = s.query(i+1, N) - A[i]\n d[t] = d.get(t, 0) + 1\n m = 0\n for i in d:\n if i > m:\n m = i\n return d[m]",
"main",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"if N == 2:\n return 1\n ",
"N == 2",
"N",
"2",
"return 1",
"1",
"def func(a, b):\n if a >= b:\n return a\n return b\n ",
"func",
"if a >= b:\n return a\n ",
"a >= b",
"a",
"b",
"return a",
"a",
"return b",
"b",
"a",
"a",
"b",
"b",
"s = SegTree(A, func)",
"s",
"SegTree(A, func)",
"SegTree",
"A",
"func",
"d = {}",
"d",
"{}",
"for i in range(N):\n t = s.query(i+1, N) - A[i]\n d[t] = d.get(t, 0) + 1\n ",
"i",
"range(N)",
"range",
"N",
"t = s.query(i+1, N) - A[i]",
"t",
"s.query(i+1, N) - A[i]",
"s.query(i+1, N)",
"s.query",
"s",
"query",
"i+1",
"i",
"1",
"N",
"A[i]",
"A",
"i",
"d[t] = d.get(t, 0) + 1",
"d[t]",
"d",
"t",
"d.get(t, 0) + 1",
"d.get(t, 0)",
"d.get",
"d",
"get",
"t",
"0",
"1",
"m = 0",
"m",
"0",
"for i in d:\n if i > m:\n m = i\n ",
"i",
"d",
"if i > m:\n m = i\n ",
"i > m",
"i",
"m",
"m = i",
"m",
"i",
"return d[m]",
"d[m]",
"d",
"m",
"print(main())",
"print",
"main()",
"main",
"class SegTree:\n def __init__(self, a, func):\n self.n = 2**(len(a) - 1).bit_length()\n self.f = func\n self.d = [0] * (2 * self.n - 1)\n self.d[self.n - 1:self.n - 1 + len(a)] = a\n for i in reversed(range(self.n - 1)):\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n\n def update(self, i, v):\n i += self.n - 1\n self.d[i] = v\n while i:\n i = (i - 1) // 2\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n # l <= i < r\n def query(self, l, r):\n assert l <= r\n l += self.n\n r += self.n\n s = self.d[l - 1]\n while l < r:\n if l & 1:\n s = self.f(s, self.d[l - 1])\n l += 1\n if r & 1:\n r -= 1\n s = self.f(s, self.d[r - 1])\n l //= 2\n r //= 2\n return s",
"class SegTree:\n def __init__(self, a, func):\n self.n = 2**(len(a) - 1).bit_length()\n self.f = func\n self.d = [0] * (2 * self.n - 1)\n self.d[self.n - 1:self.n - 1 + len(a)] = a\n for i in reversed(range(self.n - 1)):\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n\n def update(self, i, v):\n i += self.n - 1\n self.d[i] = v\n while i:\n i = (i - 1) // 2\n self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])\n # l <= i < r\n def query(self, l, r):\n assert l <= r\n l += self.n\n r += self.n\n s = self.d[l - 1]\n while l < r:\n if l & 1:\n s = self.f(s, self.d[l - 1])\n l += 1\n if r & 1:\n r -= 1\n s = self.f(s, self.d[r - 1])\n l //= 2\n r //= 2\n return s",
"SegTree",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n if N == 2:\n return 1\n def func(a, b):\n if a >= b:\n return a\n return b\n s = SegTree(A, func)\n d = {}\n for i in range(N):\n t = s.query(i+1, N) - A[i]\n d[t] = d.get(t, 0) + 1\n m = 0\n for i in d:\n if i > m:\n m = i\n return d[m]",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n if N == 2:\n return 1\n def func(a, b):\n if a >= b:\n return a\n return b\n s = SegTree(A, func)\n d = {}\n for i in range(N):\n t = s.query(i+1, N) - A[i]\n d[t] = d.get(t, 0) + 1\n m = 0\n for i in d:\n if i > m:\n m = i\n return d[m]",
"main"
] |
class SegTree:
def __init__(self, a, func):
self.n = 2**(len(a) - 1).bit_length()
self.f = func
self.d = [0] * (2 * self.n - 1)
self.d[self.n - 1:self.n - 1 + len(a)] = a
for i in reversed(range(self.n - 1)):
self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])
def update(self, i, v):
i += self.n - 1
self.d[i] = v
while i:
i = (i - 1) // 2
self.d[i] = self.f(self.d[2 * i + 1], self.d[2 * i + 2])
# l <= i < r
def query(self, l, r):
assert l <= r
l += self.n
r += self.n
s = self.d[l - 1]
while l < r:
if l & 1:
s = self.f(s, self.d[l - 1])
l += 1
if r & 1:
r -= 1
s = self.f(s, self.d[r - 1])
l //= 2
r //= 2
return s
def main():
N, T = map(int, input().split())
A = list(map(int, input().split()))
if N == 2:
return 1
def func(a, b):
if a >= b:
return a
return b
s = SegTree(A, func)
d = {}
for i in range(N):
t = s.query(i+1, N) - A[i]
d[t] = d.get(t, 0) + 1
m = 0
for i in d:
if i > m:
m = i
return d[m]
print(main())
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
29,
4,
18,
4,
18,
18,
13,
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,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
18,
13,
17,
28,
13,
18,
4,
13,
2,
13,
17,
39,
17,
14,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
18,
13,
13,
18,
13,
13,
0,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
18,
13,
13,
18,
13,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
17,
14,
2,
2,
18,
13,
13,
18,
13,
13,
13,
0,
13,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13
] |
[
[
178,
11
],
[
181,
16
],
[
38,
37
],
[
188,
44
],
[
38,
46
],
[
49,
48
],
[
188,
57
],
[
61,
60
],
[
48,
63
],
[
66,
65
],
[
69,
68
],
[
72,
71
],
[
75,
74
],
[
37,
78
],
[
83,
80
],
[
74,
81
],
[
48,
84
],
[
88,
87
],
[
37,
92
],
[
48,
99
],
[
87,
100
],
[
74,
102
],
[
87,
104
],
[
110,
107
],
[
74,
108
],
[
87,
109
],
[
48,
111
],
[
87,
112
],
[
117,
114
],
[
74,
115
],
[
87,
116
],
[
74,
118
],
[
87,
120
],
[
124,
123
],
[
127,
126
],
[
130,
129
],
[
37,
132
],
[
114,
136
],
[
107,
136
],
[
74,
137
],
[
129,
138
],
[
48,
140
],
[
129,
141
],
[
123,
142
],
[
68,
142
],
[
144,
142
],
[
145,
144
],
[
114,
146
],
[
107,
146
],
[
74,
147
],
[
129,
148
],
[
48,
150
],
[
129,
151
],
[
154,
153
],
[
114,
158
],
[
107,
158
],
[
74,
159
],
[
129,
160
],
[
48,
162
],
[
129,
163
],
[
123,
164
],
[
68,
164
],
[
144,
164
],
[
167,
166
],
[
166,
170
],
[
153,
170
],
[
126,
170
],
[
71,
170
],
[
185,
176
],
[
178,
179
],
[
181,
182
]
] |
[
"import sys\n\nsys.setrecursionlimit(10 ** 6)\nINF = float(\"inf\")\nMOD = 10 ** 9 + 7\n\n\ndef input():\n return sys.stdin.readline().strip()\n\n\ndef main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n A_ = sorted(A)\n\n j = -1\n diff = 0\n cnt = 0\n MAX = [0] * N\n MAX[-1] = A[-1]\n for i in range(N - 1)[::-1]:\n if A[i] > MAX[i + 1]:\n MAX[i] = A[i]\n else:\n MAX[i] = MAX[i + 1]\n\n diff = 0\n cnt = 0\n for i in range(N):\n if MAX[i] - A[i] > diff:\n diff = MAX[i] - A[i]\n cnt = 1\n elif MAX[i] - A[i] == diff:\n cnt += 1\n\n print(cnt)\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 6",
"10",
"6",
"INF = float(\"inf\")",
"INF",
"float(\"inf\")",
"float",
"\"inf\"",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def input():\n return sys.stdin.readline().strip()",
"input",
"return sys.stdin.readline().strip()",
"sys.stdin.readline().strip()",
"sys.stdin.readline().strip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"strip",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n A_ = sorted(A)\n\n j = -1\n diff = 0\n cnt = 0\n MAX = [0] * N\n MAX[-1] = A[-1]\n for i in range(N - 1)[::-1]:\n if A[i] > MAX[i + 1]:\n MAX[i] = A[i]\n else:\n MAX[i] = MAX[i + 1]\n\n diff = 0\n cnt = 0\n for i in range(N):\n if MAX[i] - A[i] > diff:\n diff = MAX[i] - A[i]\n cnt = 1\n elif MAX[i] - A[i] == diff:\n cnt += 1\n\n print(cnt)",
"main",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"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_ = sorted(A)",
"A_",
"sorted(A)",
"sorted",
"A",
"j = -1",
"j",
"-1",
"diff = 0",
"diff",
"0",
"cnt = 0",
"cnt",
"0",
"MAX = [0] * N",
"MAX",
"[0] * N",
"[0]",
"0",
"N",
"MAX[-1] = A[-1]",
"MAX[-1]",
"MAX",
"-1",
"A[-1]",
"A",
"-1",
"for i in range(N - 1)[::-1]:\n if A[i] > MAX[i + 1]:\n MAX[i] = A[i]\n else:\n MAX[i] = MAX[i + 1]\n\n ",
"i",
"range(N - 1)[::-1]",
"(N - 1)",
"range",
"N - 1",
"N",
"1",
"::-1",
"-1",
"if A[i] > MAX[i + 1]:\n MAX[i] = A[i]\n else:\n MAX[i] = MAX[i + 1]\n\n ",
"A[i] > MAX[i + 1]",
"A[i]",
"A",
"i",
"MAX[i + 1]",
"MAX",
"i + 1",
"i",
"1",
"MAX[i] = A[i]",
"MAX[i]",
"MAX",
"i",
"A[i]",
"A",
"i",
"MAX[i] = MAX[i + 1]",
"MAX[i]",
"MAX",
"i",
"MAX[i + 1]",
"MAX",
"i + 1",
"i",
"1",
"diff = 0",
"diff",
"0",
"cnt = 0",
"cnt",
"0",
"for i in range(N):\n if MAX[i] - A[i] > diff:\n diff = MAX[i] - A[i]\n cnt = 1\n elif MAX[i] - A[i] == diff:\n cnt += 1\n\n ",
"i",
"range(N)",
"range",
"N",
"if MAX[i] - A[i] > diff:\n diff = MAX[i] - A[i]\n cnt = 1\n elif MAX[i] - A[i] == diff:\n cnt += 1\n\n ",
"MAX[i] - A[i] > diff",
"MAX[i] - A[i]",
"MAX[i]",
"MAX",
"i",
"A[i]",
"A",
"i",
"diff",
"diff = MAX[i] - A[i]",
"diff",
"MAX[i] - A[i]",
"MAX[i]",
"MAX",
"i",
"A[i]",
"A",
"i",
"cnt = 1",
"cnt",
"1",
"elif MAX[i] - A[i] == diff:\n cnt += 1\n\n ",
"MAX[i] - A[i] == diff",
"MAX[i] - A[i]",
"MAX[i]",
"MAX",
"i",
"A[i]",
"A",
"i",
"diff",
"cnt += 1",
"cnt",
"1",
"print(cnt)",
"print",
"cnt",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"INF = float(\"inf\")",
"float(\"inf\")",
"INF",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n A_ = sorted(A)\n\n j = -1\n diff = 0\n cnt = 0\n MAX = [0] * N\n MAX[-1] = A[-1]\n for i in range(N - 1)[::-1]:\n if A[i] > MAX[i + 1]:\n MAX[i] = A[i]\n else:\n MAX[i] = MAX[i + 1]\n\n diff = 0\n cnt = 0\n for i in range(N):\n if MAX[i] - A[i] > diff:\n diff = MAX[i] - A[i]\n cnt = 1\n elif MAX[i] - A[i] == diff:\n cnt += 1\n\n print(cnt)",
"def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n A_ = sorted(A)\n\n j = -1\n diff = 0\n cnt = 0\n MAX = [0] * N\n MAX[-1] = A[-1]\n for i in range(N - 1)[::-1]:\n if A[i] > MAX[i + 1]:\n MAX[i] = A[i]\n else:\n MAX[i] = MAX[i + 1]\n\n diff = 0\n cnt = 0\n for i in range(N):\n if MAX[i] - A[i] > diff:\n diff = MAX[i] - A[i]\n cnt = 1\n elif MAX[i] - A[i] == diff:\n cnt += 1\n\n print(cnt)",
"main",
"def input():\n return sys.stdin.readline().strip()",
"def input():\n return sys.stdin.readline().strip()",
"input"
] |
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N, T = map(int, input().split())
A = list(map(int, input().split()))
A_ = sorted(A)
j = -1
diff = 0
cnt = 0
MAX = [0] * N
MAX[-1] = A[-1]
for i in range(N - 1)[::-1]:
if A[i] > MAX[i + 1]:
MAX[i] = A[i]
else:
MAX[i] = MAX[i + 1]
diff = 0
cnt = 0
for i in range(N):
if MAX[i] - A[i] > diff:
diff = MAX[i] - A[i]
cnt = 1
elif MAX[i] - A[i] == diff:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
|
[
7,
15,
13,
12,
13,
0,
13,
17,
0,
13,
4,
13,
17,
4,
18,
13,
13,
2,
17,
17,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
41,
28,
13,
4,
13,
13,
2,
13,
17,
4,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
13,
0,
13,
40,
13,
0,
13,
39,
0,
13,
40,
13,
0,
13,
39,
39,
39,
28,
13,
4,
13,
17,
13,
14,
2,
2,
13,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
2,
13,
17,
0,
18,
13,
17,
39,
13,
14,
2,
2,
13,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
18,
13,
17,
39,
2,
13,
17,
0,
18,
13,
17,
39,
13,
4,
18,
18,
13,
17,
13,
2,
13,
17,
14,
2,
13,
13,
0,
13,
13,
41,
28,
13,
18,
13,
17,
4,
39,
13,
18,
18,
13,
17,
17,
0,
13,
13,
14,
2,
13,
13,
9,
41,
28,
13,
18,
13,
17,
4,
39,
13,
18,
18,
13,
17,
17,
4,
18,
13,
13,
31,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
12,
18,
13,
17,
23,
28,
13,
13,
4,
13,
13,
14,
2,
40,
13,
17,
2,
18,
13,
17,
18,
18,
13,
2,
13,
17,
17,
4,
18,
13,
13,
13,
0,
13,
4,
13,
13,
0,
13,
12,
18,
13,
17,
23,
28,
13,
13,
4,
13,
13,
14,
2,
2,
40,
13,
17,
2,
18,
13,
17,
18,
18,
13,
2,
13,
17,
17,
2,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
7,
6
],
[
10,
9
],
[
36,
35
],
[
25,
37
],
[
36,
38
],
[
41,
40
],
[
29,
42
],
[
46,
45
],
[
35,
48
],
[
45,
50
],
[
40,
55
],
[
45,
56
],
[
40,
58
],
[
45,
60
],
[
64,
63
],
[
67,
66
],
[
9,
68
],
[
71,
70
],
[
74,
73
],
[
9,
75
],
[
78,
77
],
[
83,
82
],
[
35,
86
],
[
73,
90
],
[
131,
90
],
[
102,
90
],
[
63,
92
],
[
82,
94
],
[
63,
97
],
[
82,
99
],
[
103,
102
],
[
73,
104
],
[
131,
104
],
[
102,
104
],
[
63,
106
],
[
82,
108
],
[
114,
111
],
[
77,
112
],
[
73,
119
],
[
131,
119
],
[
102,
119
],
[
63,
121
],
[
82,
123
],
[
63,
126
],
[
82,
128
],
[
132,
131
],
[
63,
133
],
[
82,
135
],
[
141,
138
],
[
77,
139
],
[
82,
143
],
[
149,
146
],
[
77,
147
],
[
77,
154
],
[
82,
158
],
[
66,
162
],
[
165,
162
],
[
131,
163
],
[
102,
163
],
[
73,
163
],
[
166,
165
],
[
131,
166
],
[
102,
166
],
[
73,
166
],
[
170,
169
],
[
77,
171
],
[
77,
178
],
[
183,
182
],
[
66,
186
],
[
165,
186
],
[
131,
187
],
[
102,
187
],
[
73,
187
],
[
192,
191
],
[
77,
193
],
[
77,
200
],
[
182,
205
],
[
70,
205
],
[
211,
210
],
[
182,
213
],
[
70,
213
],
[
216,
215
],
[
182,
218
],
[
70,
218
],
[
221,
220
],
[
215,
231
],
[
215,
243
],
[
210,
250
],
[
255,
254
],
[
182,
257
],
[
70,
257
],
[
260,
259
],
[
254,
270
],
[
254,
283
],
[
210,
290
],
[
210,
293
],
[
210,
302
],
[
311,
308
]
] |
[
"#!/usr/bin/env python3\n\nimport sys\n# import time\n# import math\n# import numpy as np\n# import scipy.sparse.csgraph as cs # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall\n# import random # random, uniform, randint, randrange, shuffle, sample\n# import string # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits\n# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)\n# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).\n# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()\n# from collections import defaultdict # subclass of dict. defaultdict(facroty)\n# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)\n# from datetime import date, datetime # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj\n# from datetime.datetime import strptime # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj\n# from datetime import timedelta # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.\n# from copy import copy, deepcopy # use deepcopy to copy multi-dimentional matrix without reference\n# from functools import reduce # reduce(f, iter[, init])\n# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)\n# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).\n# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).\n# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])\n# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]\n# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]\n# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])\n# from itertools import combinations, combinations_with_replacement\n# from itertools import accumulate # accumulate(iter[, f])\n# from operator import itemgetter # itemgetter(1), itemgetter('key')\n# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)\n\n\n\ndef main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, t = mi()\n L = lmi()\n diff = [L[i] - L[i-1] for i in range(n) if i > 0]\n # print(diff)\n\n # sum(diff[i:j]) は L[i] で買い L[j] で売ることを示す\n max_subarray = -inf\n max_subarray_indices = []\n max_subarray_end_with_j = -inf\n max_subarray_end_with_j_indices = [[], []] # start_indices, j\n # diff[0:1] から diff[0:n-1] までを考察する\n for j in range(1, n):\n if max_subarray_end_with_j + diff[j-1] > diff[j-1]:\n max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]\n max_subarray_end_with_j_indices[1] = [j]\n elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:\n max_subarray_end_with_j = diff[j-1]\n max_subarray_end_with_j_indices[0] = [j-1]\n max_subarray_end_with_j_indices[1] = [j]\n else:\n max_subarray_end_with_j_indices[0].append(j-1)\n \n if max_subarray < max_subarray_end_with_j:\n max_subarray = max_subarray_end_with_j\n max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]\n elif max_subarray > max_subarray_end_with_j:\n continue\n else:\n max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])\n # print(max_subarray_end_with_j)\n # print(max_subarray_end_with_j_indices)\n # print(max_subarray)\n # print(max_subarray_indices)\n\n # print(max_subarray)\n # print(max_subarray_indices)\n\n s = set(max_subarray_indices)\n L1 = sorted(max_subarray_indices, key=lambda x: x[0])\n for i, elm in enumerate(L1):\n if i != 0 and elm[0] == L1[i-1][0]:\n s.remove(elm)\n L2 = sorted(max_subarray_indices, key=lambda x: x[1])\n for i, elm in enumerate(L2):\n if i != 0 and elm[1] == L2[i-1][1] and elm in s:\n s.remove(elm)\n print(len(list(s)))\n\n\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, t = mi()\n L = lmi()\n diff = [L[i] - L[i-1] for i in range(n) if i > 0]\n # print(diff)\n\n # sum(diff[i:j]) は L[i] で買い L[j] で売ることを示す\n max_subarray = -inf\n max_subarray_indices = []\n max_subarray_end_with_j = -inf\n max_subarray_end_with_j_indices = [[], []] # start_indices, j\n # diff[0:1] から diff[0:n-1] までを考察する\n for j in range(1, n):\n if max_subarray_end_with_j + diff[j-1] > diff[j-1]:\n max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]\n max_subarray_end_with_j_indices[1] = [j]\n elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:\n max_subarray_end_with_j = diff[j-1]\n max_subarray_end_with_j_indices[0] = [j-1]\n max_subarray_end_with_j_indices[1] = [j]\n else:\n max_subarray_end_with_j_indices[0].append(j-1)\n \n if max_subarray < max_subarray_end_with_j:\n max_subarray = max_subarray_end_with_j\n max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]\n elif max_subarray > max_subarray_end_with_j:\n continue\n else:\n max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])\n # print(max_subarray_end_with_j)\n # print(max_subarray_end_with_j_indices)\n # print(max_subarray)\n # print(max_subarray_indices)\n\n # print(max_subarray)\n # print(max_subarray_indices)\n\n s = set(max_subarray_indices)\n L1 = sorted(max_subarray_indices, key=lambda x: x[0])\n for i, elm in enumerate(L1):\n if i != 0 and elm[0] == L1[i-1][0]:\n s.remove(elm)\n L2 = sorted(max_subarray_indices, key=lambda x: x[1])\n for i, elm in enumerate(L2):\n if i != 0 and elm[1] == L2[i-1][1] and elm in s:\n s.remove(elm)\n print(len(list(s)))",
"main",
"mod = 1000000007",
"mod",
"1000000007",
"inf = float('inf')",
"inf",
"float('inf')",
"float",
"'inf'",
"sys.setrecursionlimit(10**6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**6",
"10",
"6",
"def input(): return sys.stdin.readline().rstrip()\n ",
"input",
"def ii(): return int(input())\n ",
"ii",
"def mi(): return map(int, input().split())\n ",
"mi",
"def mi_0(): return map(lambda x: int(x)-1, input().split())\n ",
"mi_0",
"def lmi(): return list(map(int, input().split()))\n ",
"lmi",
"def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n ",
"lmi_0",
"def li(): return list(input())\n \n \n ",
"li",
"n, t = mi()",
"n",
"mi()",
"mi",
"t",
"L = lmi()",
"L",
"lmi()",
"lmi",
"L[i] - L[i-1] for i in range(n) if i > 0",
"for i in range(n) if i > 0",
"i",
"range(n)",
"range",
"n",
"i > 0",
"i",
"0",
"if i > 0",
"L[i] - L[i-1]",
"L[i]",
"L",
"i",
"L[i-1]",
"L",
"i-1",
"i",
"1",
"diff = [L[i] - L[i-1] for i in range(n) if i > 0]",
"diff",
"[L[i] - L[i-1] for i in range(n) if i > 0]",
"max_subarray = -inf",
"max_subarray",
"-inf",
"inf",
"max_subarray_indices = []",
"max_subarray_indices",
"[]",
"max_subarray_end_with_j = -inf",
"max_subarray_end_with_j",
"-inf",
"inf",
"max_subarray_end_with_j_indices = [[], []]",
"max_subarray_end_with_j_indices",
"[[], []]",
"[]",
"[]",
"for j in range(1, n):\n if max_subarray_end_with_j + diff[j-1] > diff[j-1]:\n max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]\n max_subarray_end_with_j_indices[1] = [j]\n elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:\n max_subarray_end_with_j = diff[j-1]\n max_subarray_end_with_j_indices[0] = [j-1]\n max_subarray_end_with_j_indices[1] = [j]\n else:\n max_subarray_end_with_j_indices[0].append(j-1)\n \n if max_subarray < max_subarray_end_with_j:\n max_subarray = max_subarray_end_with_j\n max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]\n elif max_subarray > max_subarray_end_with_j:\n continue\n else:\n max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])\n # print(max_subarray_end_with_j)\n # print(max_subarray_end_with_j_indices)\n # print(max_subarray)\n # print(max_subarray_indices)\n\n # print(max_subarray)\n # print(max_subarray_indices)\n\n ",
"j",
"range(1, n)",
"range",
"1",
"n",
"if max_subarray_end_with_j + diff[j-1] > diff[j-1]:\n max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]\n max_subarray_end_with_j_indices[1] = [j]\n elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:\n max_subarray_end_with_j = diff[j-1]\n max_subarray_end_with_j_indices[0] = [j-1]\n max_subarray_end_with_j_indices[1] = [j]\n else:\n max_subarray_end_with_j_indices[0].append(j-1)\n \n ",
"max_subarray_end_with_j + diff[j-1] > diff[j-1]",
"max_subarray_end_with_j + diff[j-1]",
"max_subarray_end_with_j",
"diff[j-1]",
"diff",
"j-1",
"j",
"1",
"diff[j-1]",
"diff",
"j-1",
"j",
"1",
"max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]",
"max_subarray_end_with_j",
"max_subarray_end_with_j + diff[j-1]",
"max_subarray_end_with_j",
"diff[j-1]",
"diff",
"j-1",
"j",
"1",
"max_subarray_end_with_j_indices[1] = [j]",
"max_subarray_end_with_j_indices[1]",
"max_subarray_end_with_j_indices",
"1",
"[j]",
"j",
"elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:\n max_subarray_end_with_j = diff[j-1]\n max_subarray_end_with_j_indices[0] = [j-1]\n max_subarray_end_with_j_indices[1] = [j]\n ",
"max_subarray_end_with_j + diff[j-1] < diff[j-1]",
"max_subarray_end_with_j + diff[j-1]",
"max_subarray_end_with_j",
"diff[j-1]",
"diff",
"j-1",
"j",
"1",
"diff[j-1]",
"diff",
"j-1",
"j",
"1",
"max_subarray_end_with_j = diff[j-1]",
"max_subarray_end_with_j",
"diff[j-1]",
"diff",
"j-1",
"j",
"1",
"max_subarray_end_with_j_indices[0] = [j-1]",
"max_subarray_end_with_j_indices[0]",
"max_subarray_end_with_j_indices",
"0",
"[j-1]",
"j-1",
"j",
"1",
"max_subarray_end_with_j_indices[1] = [j]",
"max_subarray_end_with_j_indices[1]",
"max_subarray_end_with_j_indices",
"1",
"[j]",
"j",
"max_subarray_end_with_j_indices[0].append(j-1)",
"[0].append",
"[0]",
"max_subarray_end_with_j_indices",
"0",
"append",
"j-1",
"j",
"1",
"if max_subarray < max_subarray_end_with_j:\n max_subarray = max_subarray_end_with_j\n max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]\n elif max_subarray > max_subarray_end_with_j:\n continue\n else:\n max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])\n # print(max_subarray_end_with_j)\n # print(max_subarray_end_with_j_indices)\n # print(max_subarray)\n # print(max_subarray_indices)\n\n # print(max_subarray)\n # print(max_subarray_indices)\n\n ",
"max_subarray < max_subarray_end_with_j",
"max_subarray",
"max_subarray_end_with_j",
"max_subarray = max_subarray_end_with_j",
"max_subarray",
"max_subarray_end_with_j",
"(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]",
"for start in max_subarray_end_with_j_indices[0]",
"start",
"max_subarray_end_with_j_indices[0]",
"max_subarray_end_with_j_indices",
"0",
"for start in max_subarray_end_with_j_indices[0]",
"(start, max_subarray_end_with_j_indices[1][0])",
"start",
"max_subarray_end_with_j_indices[1][0]",
"[1]",
"max_subarray_end_with_j_indices",
"1",
"0",
"max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]",
"max_subarray_indices",
"[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]",
"elif max_subarray > max_subarray_end_with_j:\n continue\n ",
"max_subarray > max_subarray_end_with_j",
"max_subarray",
"max_subarray_end_with_j",
"continue",
"(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]",
"for start in max_subarray_end_with_j_indices[0]",
"start",
"max_subarray_end_with_j_indices[0]",
"max_subarray_end_with_j_indices",
"0",
"for start in max_subarray_end_with_j_indices[0]",
"(start, max_subarray_end_with_j_indices[1][0])",
"start",
"max_subarray_end_with_j_indices[1][0]",
"[1]",
"max_subarray_end_with_j_indices",
"1",
"0",
"max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])",
"max_subarray_indices.append",
"max_subarray_indices",
"append",
"*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]",
"[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]",
"s = set(max_subarray_indices)",
"s",
"set(max_subarray_indices)",
"set",
"max_subarray_indices",
"L1 = sorted(max_subarray_indices, key=lambda x: x[0])",
"L1",
"sorted(max_subarray_indices, key=lambda x: x[0])",
"sorted",
"max_subarray_indices",
"key=lambda x: x[0]",
"key",
"lambda x: x[0]",
"x[0]",
"x",
"0",
"x",
"for i, elm in enumerate(L1):\n if i != 0 and elm[0] == L1[i-1][0]:\n s.remove(elm)\n ",
"i",
"elm",
"enumerate(L1)",
"enumerate",
"L1",
"if i != 0 and elm[0] == L1[i-1][0]:\n s.remove(elm)\n ",
"i != 0 and elm[0] == L1[i-1][0]",
"i != 0",
"i",
"0",
"elm[0] == L1[i-1][0]",
"elm[0]",
"elm",
"0",
"L1[i-1][0]",
"[i-1]",
"L1",
"i-1",
"i",
"1",
"0",
"s.remove(elm)",
"s.remove",
"s",
"remove",
"elm",
"L2 = sorted(max_subarray_indices, key=lambda x: x[1])",
"L2",
"sorted(max_subarray_indices, key=lambda x: x[1])",
"sorted",
"max_subarray_indices",
"key=lambda x: x[1]",
"key",
"lambda x: x[1]",
"x[1]",
"x",
"1",
"x",
"for i, elm in enumerate(L2):\n if i != 0 and elm[1] == L2[i-1][1] and elm in s:\n s.remove(elm)\n ",
"i",
"elm",
"enumerate(L2)",
"enumerate",
"L2",
"if i != 0 and elm[1] == L2[i-1][1] and elm in s:\n s.remove(elm)\n ",
"i != 0 and elm[1] == L2[i-1][1] and elm in s",
"i != 0 and elm[1] == L2[i-1][1]",
"i != 0",
"i",
"0",
"elm[1] == L2[i-1][1]",
"elm[1]",
"elm",
"1",
"L2[i-1][1]",
"[i-1]",
"L2",
"i-1",
"i",
"1",
"1",
"elm in s",
"elm",
"s",
"s.remove(elm)",
"s.remove",
"s",
"remove",
"elm",
"print(len(list(s)))",
"print",
"len(list(s))",
"len",
"list(s)",
"list",
"s",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, t = mi()\n L = lmi()\n diff = [L[i] - L[i-1] for i in range(n) if i > 0]\n # print(diff)\n\n # sum(diff[i:j]) は L[i] で買い L[j] で売ることを示す\n max_subarray = -inf\n max_subarray_indices = []\n max_subarray_end_with_j = -inf\n max_subarray_end_with_j_indices = [[], []] # start_indices, j\n # diff[0:1] から diff[0:n-1] までを考察する\n for j in range(1, n):\n if max_subarray_end_with_j + diff[j-1] > diff[j-1]:\n max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]\n max_subarray_end_with_j_indices[1] = [j]\n elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:\n max_subarray_end_with_j = diff[j-1]\n max_subarray_end_with_j_indices[0] = [j-1]\n max_subarray_end_with_j_indices[1] = [j]\n else:\n max_subarray_end_with_j_indices[0].append(j-1)\n \n if max_subarray < max_subarray_end_with_j:\n max_subarray = max_subarray_end_with_j\n max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]\n elif max_subarray > max_subarray_end_with_j:\n continue\n else:\n max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])\n # print(max_subarray_end_with_j)\n # print(max_subarray_end_with_j_indices)\n # print(max_subarray)\n # print(max_subarray_indices)\n\n # print(max_subarray)\n # print(max_subarray_indices)\n\n s = set(max_subarray_indices)\n L1 = sorted(max_subarray_indices, key=lambda x: x[0])\n for i, elm in enumerate(L1):\n if i != 0 and elm[0] == L1[i-1][0]:\n s.remove(elm)\n L2 = sorted(max_subarray_indices, key=lambda x: x[1])\n for i, elm in enumerate(L2):\n if i != 0 and elm[1] == L2[i-1][1] and elm in s:\n s.remove(elm)\n print(len(list(s)))",
"def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n n, t = mi()\n L = lmi()\n diff = [L[i] - L[i-1] for i in range(n) if i > 0]\n # print(diff)\n\n # sum(diff[i:j]) は L[i] で買い L[j] で売ることを示す\n max_subarray = -inf\n max_subarray_indices = []\n max_subarray_end_with_j = -inf\n max_subarray_end_with_j_indices = [[], []] # start_indices, j\n # diff[0:1] から diff[0:n-1] までを考察する\n for j in range(1, n):\n if max_subarray_end_with_j + diff[j-1] > diff[j-1]:\n max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]\n max_subarray_end_with_j_indices[1] = [j]\n elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:\n max_subarray_end_with_j = diff[j-1]\n max_subarray_end_with_j_indices[0] = [j-1]\n max_subarray_end_with_j_indices[1] = [j]\n else:\n max_subarray_end_with_j_indices[0].append(j-1)\n \n if max_subarray < max_subarray_end_with_j:\n max_subarray = max_subarray_end_with_j\n max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]\n elif max_subarray > max_subarray_end_with_j:\n continue\n else:\n max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])\n # print(max_subarray_end_with_j)\n # print(max_subarray_end_with_j_indices)\n # print(max_subarray)\n # print(max_subarray_indices)\n\n # print(max_subarray)\n # print(max_subarray_indices)\n\n s = set(max_subarray_indices)\n L1 = sorted(max_subarray_indices, key=lambda x: x[0])\n for i, elm in enumerate(L1):\n if i != 0 and elm[0] == L1[i-1][0]:\n s.remove(elm)\n L2 = sorted(max_subarray_indices, key=lambda x: x[1])\n for i, elm in enumerate(L2):\n if i != 0 and elm[1] == L2[i-1][1] and elm in s:\n s.remove(elm)\n print(len(list(s)))",
"main"
] |
#!/usr/bin/env python3
import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random # random, uniform, randint, randrange, shuffle, sample
# import string # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
n, t = mi()
L = lmi()
diff = [L[i] - L[i-1] for i in range(n) if i > 0]
# print(diff)
# sum(diff[i:j]) は L[i] で買い L[j] で売ることを示す
max_subarray = -inf
max_subarray_indices = []
max_subarray_end_with_j = -inf
max_subarray_end_with_j_indices = [[], []] # start_indices, j
# diff[0:1] から diff[0:n-1] までを考察する
for j in range(1, n):
if max_subarray_end_with_j + diff[j-1] > diff[j-1]:
max_subarray_end_with_j = max_subarray_end_with_j + diff[j-1]
max_subarray_end_with_j_indices[1] = [j]
elif max_subarray_end_with_j + diff[j-1] < diff[j-1]:
max_subarray_end_with_j = diff[j-1]
max_subarray_end_with_j_indices[0] = [j-1]
max_subarray_end_with_j_indices[1] = [j]
else:
max_subarray_end_with_j_indices[0].append(j-1)
if max_subarray < max_subarray_end_with_j:
max_subarray = max_subarray_end_with_j
max_subarray_indices = [(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]]
elif max_subarray > max_subarray_end_with_j:
continue
else:
max_subarray_indices.append(*[(start, max_subarray_end_with_j_indices[1][0]) for start in max_subarray_end_with_j_indices[0]])
# print(max_subarray_end_with_j)
# print(max_subarray_end_with_j_indices)
# print(max_subarray)
# print(max_subarray_indices)
# print(max_subarray)
# print(max_subarray_indices)
s = set(max_subarray_indices)
L1 = sorted(max_subarray_indices, key=lambda x: x[0])
for i, elm in enumerate(L1):
if i != 0 and elm[0] == L1[i-1][0]:
s.remove(elm)
L2 = sorted(max_subarray_indices, key=lambda x: x[1])
for i, elm in enumerate(L2):
if i != 0 and elm[1] == L2[i-1][1] and elm in s:
s.remove(elm)
print(len(list(s)))
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,
17,
0,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
2,
18,
13,
13,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
17,
14,
2,
2,
18,
13,
13,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13
] |
[
[
97,
2
],
[
97,
11
],
[
85,
13
],
[
100,
25
],
[
103,
28
],
[
106,
31
],
[
86,
33
],
[
37,
36
],
[
83,
40
],
[
86,
45
],
[
36,
46
],
[
107,
47
],
[
89,
47
],
[
101,
48
],
[
95,
48
],
[
94,
50
],
[
86,
53
],
[
36,
54
],
[
107,
55
],
[
89,
55
],
[
109,
57
],
[
86,
63
],
[
36,
64
],
[
107,
65
],
[
89,
65
],
[
101,
66
],
[
95,
66
],
[
91,
68
],
[
88,
71
],
[
107,
74
],
[
89,
74
],
[
86,
76
],
[
36,
77
],
[
92,
80
],
[
110,
80
],
[
104,
80
],
[
97,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] |
[
"n, t = map(int, input().split())\nA = list(map(int, input().split()))\n\nmin_dif = 0\ncount = 0\nmin_val = A[0]\n\nfor i in range(1, n):\n if A[i]-min_val > min_dif:\n min_dif = A[i]-min_val\n count = 1\n elif A[i]-min_val == min_dif:\n count += 1\n\n min_val = min(min_val, A[i])\n\nprint(count)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_dif = 0",
"min_dif",
"0",
"count = 0",
"count",
"0",
"min_val = A[0]",
"min_val",
"A[0]",
"A",
"0",
"for i in range(1, n):\n if A[i]-min_val > min_dif:\n min_dif = A[i]-min_val\n count = 1\n elif A[i]-min_val == min_dif:\n count += 1\n\n min_val = min(min_val, A[i])",
"i",
"range(1, n)",
"range",
"1",
"n",
"if A[i]-min_val > min_dif:\n min_dif = A[i]-min_val\n count = 1\n elif A[i]-min_val == min_dif:\n count += 1\n\n ",
"A[i]-min_val > min_dif",
"A[i]-min_val",
"A[i]",
"A",
"i",
"min_val",
"min_dif",
"min_dif = A[i]-min_val",
"min_dif",
"A[i]-min_val",
"A[i]",
"A",
"i",
"min_val",
"count = 1",
"count",
"1",
"elif A[i]-min_val == min_dif:\n count += 1\n\n ",
"A[i]-min_val == min_dif",
"A[i]-min_val",
"A[i]",
"A",
"i",
"min_val",
"min_dif",
"count += 1",
"count",
"1",
"min_val = min(min_val, A[i])",
"min_val",
"min(min_val, A[i])",
"min",
"min_val",
"A[i]",
"A",
"i",
"print(count)",
"print",
"count",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"min_val = min(min_val, A[i])",
"min(min_val, A[i])",
"min_val",
"count += 1",
"1",
"count",
"min_dif = A[i]-min_val",
"A[i]-min_val",
"min_dif",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"min_dif = 0",
"0",
"min_dif",
"count = 0",
"0",
"count",
"min_val = A[0]",
"A[0]",
"min_val",
"count = 1",
"1",
"count"
] |
n, t = map(int, input().split())
A = list(map(int, input().split()))
min_dif = 0
count = 0
min_val = A[0]
for i in range(1, n):
if A[i]-min_val > min_dif:
min_dif = A[i]-min_val
count = 1
elif A[i]-min_val == min_dif:
count += 1
min_val = min(min_val, A[i])
print(count)
|
[
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,
39,
18,
13,
17,
0,
13,
39,
18,
13,
2,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
13,
18,
13,
17,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
2,
18,
13,
13,
18,
13,
17,
4,
18,
13,
13,
18,
13,
13,
4,
18,
13,
13,
18,
13,
17,
4,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
2,
18,
13,
13,
18,
13,
13,
13,
4,
18,
13,
13,
18,
13,
13,
4,
13,
4,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
180,
2
],
[
180,
11
],
[
165,
13
],
[
168,
25
],
[
166,
28
],
[
159,
31
],
[
166,
34
],
[
181,
36
],
[
40,
39
],
[
181,
43
],
[
166,
47
],
[
39,
48
],
[
169,
50
],
[
169,
54
],
[
166,
57
],
[
39,
58
],
[
169,
61
],
[
169,
64
],
[
68,
67
],
[
181,
71
],
[
166,
78
],
[
67,
79
],
[
160,
81
],
[
160,
85
],
[
166,
88
],
[
67,
89
],
[
160,
92
],
[
160,
95
],
[
160,
99
],
[
156,
102
],
[
106,
105
],
[
181,
108
],
[
171,
110
],
[
160,
113
],
[
105,
114
],
[
169,
116
],
[
105,
117
],
[
174,
119
],
[
157,
122
],
[
175,
122
],
[
172,
123
],
[
177,
125
],
[
130,
129
],
[
181,
132
],
[
160,
137
],
[
129,
138
],
[
169,
140
],
[
129,
141
],
[
175,
142
],
[
157,
142
],
[
178,
145
],
[
169,
148
],
[
129,
149
],
[
178,
154
],
[
156,
157
],
[
159,
160
],
[
180,
163
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
177,
178
],
[
180,
181
]
] |
[
"n,t=map(int,input().split())\na=list(map(int,input().split()))\n\nmi=[a[0]]\nma=[a[n-1]]\nfor i in range(1,n):\n if a[i]<mi[-1]:\n mi.append(a[i])\n else:\n mi.append(mi[-1])\n\nfor i in range(n-2,-1,-1):\n if a[i]>ma[-1]:\n ma.append(a[i])\n else:\n ma.append(ma[-1])\n\nma.reverse()\n\nsa=0\nfor i in range(n):\n x=ma[i]-mi[i]\n sa=max(sa,x)\nse=set()\nfor i in range(n):\n if ma[i]-mi[i]==sa:\n se.add(mi[i])\n\nprint(len(se))",
"n,t=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mi=[a[0]]",
"mi",
"[a[0]]",
"a[0]",
"a",
"0",
"ma=[a[n-1]]",
"ma",
"[a[n-1]]",
"a[n-1]",
"a",
"n-1",
"n",
"1",
"for i in range(1,n):\n if a[i]<mi[-1]:\n mi.append(a[i])\n else:\n mi.append(mi[-1])",
"i",
"range(1,n)",
"range",
"1",
"n",
"if a[i]<mi[-1]:\n mi.append(a[i])\n else:\n mi.append(mi[-1])",
"a[i]<mi[-1]",
"a[i]",
"a",
"i",
"mi[-1]",
"mi",
"-1",
"mi.append(a[i])",
"mi.append",
"mi",
"append",
"a[i]",
"a",
"i",
"mi.append(mi[-1])",
"mi.append",
"mi",
"append",
"mi[-1]",
"mi",
"-1",
"for i in range(n-2,-1,-1):\n if a[i]>ma[-1]:\n ma.append(a[i])\n else:\n ma.append(ma[-1])",
"i",
"range(n-2,-1,-1)",
"range",
"n-2",
"n",
"2",
"-1",
"-1",
"if a[i]>ma[-1]:\n ma.append(a[i])\n else:\n ma.append(ma[-1])",
"a[i]>ma[-1]",
"a[i]",
"a",
"i",
"ma[-1]",
"ma",
"-1",
"ma.append(a[i])",
"ma.append",
"ma",
"append",
"a[i]",
"a",
"i",
"ma.append(ma[-1])",
"ma.append",
"ma",
"append",
"ma[-1]",
"ma",
"-1",
"ma.reverse()",
"ma.reverse",
"ma",
"reverse",
"sa=0",
"sa",
"0",
"for i in range(n):\n x=ma[i]-mi[i]\n sa=max(sa,x)",
"i",
"range(n)",
"range",
"n",
"x=ma[i]-mi[i]",
"x",
"ma[i]-mi[i]",
"ma[i]",
"ma",
"i",
"mi[i]",
"mi",
"i",
"sa=max(sa,x)",
"sa",
"max(sa,x)",
"max",
"sa",
"x",
"se=set()",
"se",
"set()",
"set",
"for i in range(n):\n if ma[i]-mi[i]==sa:\n se.add(mi[i])",
"i",
"range(n)",
"range",
"n",
"if ma[i]-mi[i]==sa:\n se.add(mi[i])",
"ma[i]-mi[i]==sa",
"ma[i]-mi[i]",
"ma[i]",
"ma",
"i",
"mi[i]",
"mi",
"i",
"sa",
"se.add(mi[i])",
"se.add",
"se",
"add",
"mi[i]",
"mi",
"i",
"print(len(se))",
"print",
"len(se)",
"len",
"se",
"sa=0",
"0",
"sa",
"ma=[a[n-1]]",
"[a[n-1]]",
"ma",
"t=map(int,input().split())",
"map(int,input().split())",
"t",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"mi=[a[0]]",
"[a[0]]",
"mi",
"x=ma[i]-mi[i]",
"ma[i]-mi[i]",
"x",
"sa=max(sa,x)",
"max(sa,x)",
"sa",
"se=set()",
"set()",
"se",
"n,t=map(int,input().split())",
"map(int,input().split())",
"n"
] |
n,t=map(int,input().split())
a=list(map(int,input().split()))
mi=[a[0]]
ma=[a[n-1]]
for i in range(1,n):
if a[i]<mi[-1]:
mi.append(a[i])
else:
mi.append(mi[-1])
for i in range(n-2,-1,-1):
if a[i]>ma[-1]:
ma.append(a[i])
else:
ma.append(ma[-1])
ma.reverse()
sa=0
for i in range(n):
x=ma[i]-mi[i]
sa=max(sa,x)
se=set()
for i in range(n):
if ma[i]-mi[i]==sa:
se.add(mi[i])
print(len(se))
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
12,
2,
4,
13,
13,
17,
23,
0,
13,
12,
4,
13,
31,
13,
0,
13,
17,
23,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
12,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
2,
17,
17,
0,
13,
39,
28,
13,
13,
4,
18,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
4,
13,
13,
4,
13,
13,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] |
[
[
101,
11
],
[
119,
20
],
[
28,
27
],
[
39,
38
],
[
105,
44
],
[
48,
48
],
[
55,
54
],
[
123,
56
],
[
55,
57
],
[
60,
59
],
[
105,
61
],
[
64,
63
],
[
69,
68
],
[
72,
71
],
[
59,
71
],
[
68,
75
],
[
71,
78
],
[
63,
79
],
[
81,
79
],
[
82,
81
],
[
63,
84
],
[
81,
84
],
[
71,
85
],
[
88,
87
],
[
68,
90
],
[
68,
94
],
[
87,
97
],
[
108,
99
],
[
101,
102
],
[
119,
120
]
] |
[
"import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\ndef main():\n n,t=MI()\n aa=LI()\n mn=10**10\n pp=[]\n for a in aa:\n pp.append(a-mn)\n mn=min(mn,a)\n #print(pp)\n ans=pp.count(max(pp))\n print(ans)\n\nmain()",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 6",
"10",
"6",
"int1 = lambda x: int(x) - 1",
"int1",
"lambda x: int(x) - 1",
"int(x) - 1",
"int(x)",
"int",
"x",
"1",
"x",
"p2D = lambda x: print(*x, sep=\"\\n\")",
"p2D",
"lambda x: print(*x, sep=\"\\n\")",
"print(*x, sep=\"\\n\")",
"print",
"*x",
"x",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"x",
"def II(): return int(sys.stdin.readline())",
"II",
"def MI(): return map(int, sys.stdin.readline().split())",
"MI",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"LI() for _ in range(rows_number)",
"for _ in range(rows_number)",
"_",
"range(rows_number)",
"range",
"rows_number",
"for _ in range(rows_number)",
"LI()",
"LI",
"def LLI(rows_number): return [LI() for _ in range(rows_number)]",
"LLI",
"rows_number",
"rows_number",
"def SI(): return sys.stdin.readline()[:-1]",
"SI",
"def main():\n n,t=MI()\n aa=LI()\n mn=10**10\n pp=[]\n for a in aa:\n pp.append(a-mn)\n mn=min(mn,a)\n #print(pp)\n ans=pp.count(max(pp))\n print(ans)",
"main",
"n,t=MI()",
"n",
"MI()",
"MI",
"t",
"aa=LI()",
"aa",
"LI()",
"LI",
"mn=10**10",
"mn",
"10**10",
"10",
"10",
"pp=[]",
"pp",
"[]",
"for a in aa:\n pp.append(a-mn)\n mn=min(mn,a)\n #print(pp)\n ",
"a",
"aa",
"pp.append(a-mn)",
"pp.append",
"pp",
"append",
"a-mn",
"a",
"mn",
"mn=min(mn,a)",
"mn",
"min(mn,a)",
"min",
"mn",
"a",
"ans=pp.count(max(pp))",
"ans",
"pp.count(max(pp))",
"pp.count",
"pp",
"count",
"max(pp)",
"max",
"pp",
"print(ans)",
"print",
"ans",
"main()",
"main",
"int1 = lambda x: int(x) - 1",
"lambda x: int(x) - 1",
"int1",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"def main():\n n,t=MI()\n aa=LI()\n mn=10**10\n pp=[]\n for a in aa:\n pp.append(a-mn)\n mn=min(mn,a)\n #print(pp)\n ans=pp.count(max(pp))\n print(ans)",
"def main():\n n,t=MI()\n aa=LI()\n mn=10**10\n pp=[]\n for a in aa:\n pp.append(a-mn)\n mn=min(mn,a)\n #print(pp)\n ans=pp.count(max(pp))\n print(ans)",
"main",
"def LLI(rows_number): return [LI() for _ in range(rows_number)]",
"def LLI(rows_number): return [LI() for _ in range(rows_number)]",
"LLI",
"def SI(): return sys.stdin.readline()[:-1]",
"def SI(): return sys.stdin.readline()[:-1]",
"SI",
"def II(): return int(sys.stdin.readline())",
"def II(): return int(sys.stdin.readline())",
"II",
"p2D = lambda x: print(*x, sep=\"\\n\")",
"lambda x: print(*x, sep=\"\\n\")",
"p2D",
"def MI(): return map(int, sys.stdin.readline().split())",
"def MI(): return map(int, sys.stdin.readline().split())",
"MI"
] |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
n,t=MI()
aa=LI()
mn=10**10
pp=[]
for a in aa:
pp.append(a-mn)
mn=min(mn,a)
#print(pp)
ans=pp.count(max(pp))
print(ans)
main()
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
13,
14,
2,
2,
13,
13,
13,
0,
13,
17,
14,
2,
2,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
100,
4
],
[
106,
11
],
[
101,
18
],
[
106,
20
],
[
109,
22
],
[
101,
31
],
[
94,
34
],
[
85,
41
],
[
112,
44
],
[
48,
47
],
[
110,
47
],
[
88,
50
],
[
95,
53
],
[
89,
53
],
[
47,
54
],
[
47,
58
],
[
89,
59
],
[
95,
59
],
[
86,
60
],
[
104,
60
],
[
97,
62
],
[
47,
67
],
[
89,
68
],
[
95,
68
],
[
86,
69
],
[
104,
69
],
[
103,
71
],
[
47,
73
],
[
89,
74
],
[
95,
74
],
[
91,
76
],
[
92,
80
],
[
98,
80
],
[
113,
80
],
[
106,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
]
] |
[
"# python3 (3.4.3)\nimport sys\ninput = sys.stdin.readline\n\n# main\nN,T = map(int,input().split())\nA = list(map(int,input().split()))\n\nlowest = 10**9+1\nprofit = 0\nans = 0\n\nfor a in A:\n lowest = min(lowest, a)\n if a - lowest == profit:\n ans += 1\n elif a - lowest > profit:\n profit = a - lowest\n ans = 1\n\nprint(ans)\n",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"lowest = 10**9+1",
"lowest",
"10**9+1",
"10**9",
"10",
"9",
"1",
"profit = 0",
"profit",
"0",
"ans = 0",
"ans",
"0",
"for a in A:\n lowest = min(lowest, a)\n if a - lowest == profit:\n ans += 1\n elif a - lowest > profit:\n profit = a - lowest\n ans = 1",
"a",
"A",
"lowest = min(lowest, a)",
"lowest",
"min(lowest, a)",
"min",
"lowest",
"a",
"if a - lowest == profit:\n ans += 1\n elif a - lowest > profit:\n profit = a - lowest\n ans = 1",
"a - lowest == profit",
"a - lowest",
"a",
"lowest",
"profit",
"ans += 1",
"ans",
"1",
"elif a - lowest > profit:\n profit = a - lowest\n ans = 1",
"a - lowest > profit",
"a - lowest",
"a",
"lowest",
"profit",
"profit = a - lowest",
"profit",
"a - lowest",
"a",
"lowest",
"ans = 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"profit = 0",
"0",
"profit",
"lowest = min(lowest, a)",
"min(lowest, a)",
"lowest",
"ans = 1",
"1",
"ans",
"lowest = 10**9+1",
"10**9+1",
"lowest",
"ans += 1",
"1",
"ans",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"profit = a - lowest",
"a - lowest",
"profit",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"ans = 0",
"0",
"ans"
] |
# python3 (3.4.3)
import sys
input = sys.stdin.readline
# main
N,T = map(int,input().split())
A = list(map(int,input().split()))
lowest = 10**9+1
profit = 0
ans = 0
for a in A:
lowest = min(lowest, a)
if a - lowest == profit:
ans += 1
elif a - lowest > profit:
profit = a - lowest
ans = 1
print(ans)
|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
17,
0,
13,
17,
42,
2,
13,
13,
0,
13,
17,
0,
18,
13,
13,
2,
39,
18,
13,
13,
2,
2,
17,
13,
17,
0,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
17,
0,
18,
18,
13,
13,
13,
13,
42,
2,
13,
17,
0,
13,
2,
2,
13,
17,
17,
0,
18,
18,
13,
13,
13,
4,
13,
18,
18,
13,
13,
2,
2,
13,
17,
17,
18,
18,
13,
13,
2,
2,
13,
17,
17,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
40,
13,
13,
40,
13,
13,
29,
18,
13,
13,
14,
2,
40,
13,
13,
40,
13,
13,
29,
18,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
13,
2,
2,
17,
13,
17,
13,
2,
2,
13,
13,
17,
0,
13,
4,
18,
13,
13,
13,
13,
2,
2,
17,
13,
17,
2,
2,
13,
13,
17,
13,
29,
4,
13,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
4,
18,
13,
13,
13,
13,
17,
17,
18,
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,
0,
13,
4,
13,
13,
28,
13,
4,
13,
13,
4,
18,
13,
13,
13,
18,
13,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
4,
18,
13,
13,
2,
13,
17,
13,
18,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
13,
0,
13,
17,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
6,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
9,
6
],
[
40,
7
],
[
12,
11
],
[
11,
15
],
[
18,
15
],
[
42,
16
],
[
19,
18
],
[
24,
21
],
[
40,
22
],
[
40,
27
],
[
18,
32
],
[
11,
32
],
[
38,
35
],
[
40,
36
],
[
18,
38
],
[
11,
38
],
[
40,
40
],
[
42,
42
],
[
47,
46
],
[
97,
49
],
[
58,
53
],
[
97,
55
],
[
46,
57
],
[
99,
57
],
[
101,
58
],
[
46,
61
],
[
99,
61
],
[
64,
61
],
[
65,
64
],
[
46,
67
],
[
99,
67
],
[
64,
67
],
[
76,
71
],
[
97,
73
],
[
64,
75
],
[
46,
75
],
[
99,
75
],
[
97,
80
],
[
64,
84
],
[
46,
84
],
[
99,
84
],
[
97,
89
],
[
64,
93
],
[
46,
93
],
[
99,
93
],
[
97,
97
],
[
99,
99
],
[
101,
101
],
[
184,
107
],
[
176,
108
],
[
178,
110
],
[
182,
111
],
[
174,
114
],
[
176,
119
],
[
182,
120
],
[
184,
122
],
[
178,
123
],
[
174,
127
],
[
180,
129
],
[
132,
131
],
[
174,
134
],
[
176,
136
],
[
178,
137
],
[
180,
141
],
[
182,
143
],
[
182,
146
],
[
184,
147
],
[
151,
150
],
[
174,
153
],
[
176,
155
],
[
178,
156
],
[
180,
160
],
[
182,
164
],
[
184,
165
],
[
184,
167
],
[
131,
171
],
[
150,
172
],
[
174,
174
],
[
176,
176
],
[
178,
178
],
[
180,
180
],
[
182,
182
],
[
184,
184
],
[
200,
190
],
[
103,
191
],
[
202,
192
],
[
204,
193
],
[
200,
197
],
[
200,
200
],
[
202,
202
],
[
204,
204
],
[
325,
206
],
[
325,
215
],
[
322,
217
],
[
328,
229
],
[
308,
232
],
[
235,
234
],
[
308,
237
],
[
329,
240
],
[
44,
241
],
[
234,
242
],
[
323,
244
],
[
234,
245
],
[
304,
247
],
[
308,
251
],
[
254,
253
],
[
308,
256
],
[
261,
258
],
[
305,
259
],
[
253,
260
],
[
258,
263
],
[
305,
264
],
[
253,
265
],
[
329,
269
],
[
186,
270
],
[
253,
272
],
[
308,
274
],
[
323,
276
],
[
253,
277
],
[
313,
279
],
[
305,
282
],
[
316,
284
],
[
288,
287
],
[
308,
290
],
[
258,
293
],
[
305,
294
],
[
287,
295
],
[
314,
296
],
[
319,
298
],
[
320,
302
],
[
317,
302
],
[
304,
305
],
[
325,
308
],
[
313,
314
],
[
316,
317
],
[
319,
320
],
[
322,
323
],
[
325,
326
],
[
328,
329
]
] |
[
"class SEGTree:\n def __init__(self,n):\n self.Unit=0\n i=1\n while(i<n):\n i*=2\n self.SEG=[self.Unit]*(2*i-1)\n self.d=i\n def update(self,i,x):\n i+=self.d-1\n self.SEG[i]=x\n while i>0:\n i=(i-1)//2\n self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])\n def find(self,a,b,k,l,r):\n if r<=a or b<=l:\n return self.Unit\n if a<=l and r<=b:\n return self.SEG[k]\n else:\n c1=self.find(a,b,2*k+1,l,(l+r)//2)\n c2=self.find(a,b,2*k+2,(l+r)//2,r)\n return max(c1,c2)\n def get(self,a,b):\n return self.find(a,b,0,0,self.d)\n\nN,T=map(int,input().split())\nA=list(map(int,input().split()))\nSEG=SEGTree(N)\nfor i in range(N):\n SEG.update(i,A[i])\nli=[0]*N\nfor i in range(N):\n li[i]=max(li[i],SEG.get(i+1,N)-A[i])\nm=max(li)\nans=0\nfor i in range(N):\n if li[i]==m:\n ans+=1\nprint(ans)",
"class SEGTree:\n def __init__(self,n):\n self.Unit=0\n i=1\n while(i<n):\n i*=2\n self.SEG=[self.Unit]*(2*i-1)\n self.d=i\n def update(self,i,x):\n i+=self.d-1\n self.SEG[i]=x\n while i>0:\n i=(i-1)//2\n self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])\n def find(self,a,b,k,l,r):\n if r<=a or b<=l:\n return self.Unit\n if a<=l and r<=b:\n return self.SEG[k]\n else:\n c1=self.find(a,b,2*k+1,l,(l+r)//2)\n c2=self.find(a,b,2*k+2,(l+r)//2,r)\n return max(c1,c2)\n def get(self,a,b):\n return self.find(a,b,0,0,self.d)",
"SEGTree",
"def __init__(self,n):\n self.Unit=0\n i=1\n while(i<n):\n i*=2\n self.SEG=[self.Unit]*(2*i-1)\n self.d=i\n ",
"__init__",
"self.Unit=0",
"self.Unit",
"self",
"Unit",
"0",
"i=1",
"i",
"1",
"while(i<n):\n i*=2\n ",
"i<n",
"i",
"n",
"i*=2",
"i",
"2",
"self.SEG=[self.Unit]*(2*i-1)",
"self.SEG",
"self",
"SEG",
"[self.Unit]*(2*i-1)",
"[self.Unit]",
"self.Unit",
"self",
"Unit",
"2*i-1",
"2*i",
"2",
"i",
"1",
"self.d=i",
"self.d",
"self",
"d",
"i",
"self",
"self",
"n",
"n",
"def update(self,i,x):\n i+=self.d-1\n self.SEG[i]=x\n while i>0:\n i=(i-1)//2\n self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])\n ",
"update",
"i+=self.d-1",
"i",
"self.d-1",
"self.d",
"self",
"d",
"1",
"self.SEG[i]=x",
"self.SEG[i]",
"self.SEG",
"self",
"SEG",
"i",
"x",
"while i>0:\n i=(i-1)//2\n self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])\n ",
"i>0",
"i",
"0",
"i=(i-1)//2",
"i",
"(i-1)//2",
"i-1",
"i",
"1",
"2",
"self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])",
"self.SEG[i]",
"self.SEG",
"self",
"SEG",
"i",
"max(self.SEG[i*2+1],self.SEG[i*2+2])",
"max",
"self.SEG[i*2+1]",
"self.SEG",
"self",
"SEG",
"i*2+1",
"i*2",
"i",
"2",
"1",
"self.SEG[i*2+2]",
"self.SEG",
"self",
"SEG",
"i*2+2",
"i*2",
"i",
"2",
"2",
"self",
"self",
"i",
"i",
"x",
"x",
"def find(self,a,b,k,l,r):\n if r<=a or b<=l:\n return self.Unit\n if a<=l and r<=b:\n return self.SEG[k]\n else:\n c1=self.find(a,b,2*k+1,l,(l+r)//2)\n c2=self.find(a,b,2*k+2,(l+r)//2,r)\n return max(c1,c2)\n ",
"find",
"if r<=a or b<=l:\n return self.Unit\n ",
"r<=a or b<=l",
"r<=a",
"r",
"a",
"b<=l",
"b",
"l",
"return self.Unit",
"self.Unit",
"self",
"Unit",
"if a<=l and r<=b:\n return self.SEG[k]\n else:\n c1=self.find(a,b,2*k+1,l,(l+r)//2)\n c2=self.find(a,b,2*k+2,(l+r)//2,r)\n return max(c1,c2)\n ",
"a<=l and r<=b",
"a<=l",
"a",
"l",
"r<=b",
"r",
"b",
"return self.SEG[k]",
"self.SEG[k]",
"self.SEG",
"self",
"SEG",
"k",
"c1=self.find(a,b,2*k+1,l,(l+r)//2)",
"c1",
"self.find(a,b,2*k+1,l,(l+r)//2)",
"self.find",
"self",
"find",
"a",
"b",
"2*k+1",
"2*k",
"2",
"k",
"1",
"l",
"(l+r)//2",
"l+r",
"l",
"r",
"2",
"c2=self.find(a,b,2*k+2,(l+r)//2,r)",
"c2",
"self.find(a,b,2*k+2,(l+r)//2,r)",
"self.find",
"self",
"find",
"a",
"b",
"2*k+2",
"2*k",
"2",
"k",
"2",
"(l+r)//2",
"l+r",
"l",
"r",
"2",
"r",
"return max(c1,c2)",
"max(c1,c2)",
"max",
"c1",
"c2",
"self",
"self",
"a",
"a",
"b",
"b",
"k",
"k",
"l",
"l",
"r",
"r",
"def get(self,a,b):\n return self.find(a,b,0,0,self.d)",
"get",
"return self.find(a,b,0,0,self.d)",
"self.find(a,b,0,0,self.d)",
"self.find",
"self",
"find",
"a",
"b",
"0",
"0",
"self.d",
"self",
"d",
"self",
"self",
"a",
"a",
"b",
"b",
"N,T=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"SEG=SEGTree(N)",
"SEG",
"SEGTree(N)",
"SEGTree",
"N",
"for i in range(N):\n SEG.update(i,A[i])",
"i",
"range(N)",
"range",
"N",
"SEG.update(i,A[i])",
"SEG.update",
"SEG",
"update",
"i",
"A[i]",
"A",
"i",
"li=[0]*N",
"li",
"[0]*N",
"[0]",
"0",
"N",
"for i in range(N):\n li[i]=max(li[i],SEG.get(i+1,N)-A[i])",
"i",
"range(N)",
"range",
"N",
"li[i]=max(li[i],SEG.get(i+1,N)-A[i])",
"li[i]",
"li",
"i",
"max(li[i],SEG.get(i+1,N)-A[i])",
"max",
"li[i]",
"li",
"i",
"SEG.get(i+1,N)-A[i]",
"SEG.get(i+1,N)",
"SEG.get",
"SEG",
"get",
"i+1",
"i",
"1",
"N",
"A[i]",
"A",
"i",
"m=max(li)",
"m",
"max(li)",
"max",
"li",
"ans=0",
"ans",
"0",
"for i in range(N):\n if li[i]==m:\n ans+=1",
"i",
"range(N)",
"range",
"N",
"if li[i]==m:\n ans+=1",
"li[i]==m",
"li[i]",
"li",
"i",
"m",
"ans+=1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"li=[0]*N",
"[0]*N",
"li",
"N,T=map(int,input().split())",
"map(int,input().split())",
"N",
"class SEGTree:\n def __init__(self,n):\n self.Unit=0\n i=1\n while(i<n):\n i*=2\n self.SEG=[self.Unit]*(2*i-1)\n self.d=i\n def update(self,i,x):\n i+=self.d-1\n self.SEG[i]=x\n while i>0:\n i=(i-1)//2\n self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])\n def find(self,a,b,k,l,r):\n if r<=a or b<=l:\n return self.Unit\n if a<=l and r<=b:\n return self.SEG[k]\n else:\n c1=self.find(a,b,2*k+1,l,(l+r)//2)\n c2=self.find(a,b,2*k+2,(l+r)//2,r)\n return max(c1,c2)\n def get(self,a,b):\n return self.find(a,b,0,0,self.d)",
"class SEGTree:\n def __init__(self,n):\n self.Unit=0\n i=1\n while(i<n):\n i*=2\n self.SEG=[self.Unit]*(2*i-1)\n self.d=i\n def update(self,i,x):\n i+=self.d-1\n self.SEG[i]=x\n while i>0:\n i=(i-1)//2\n self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])\n def find(self,a,b,k,l,r):\n if r<=a or b<=l:\n return self.Unit\n if a<=l and r<=b:\n return self.SEG[k]\n else:\n c1=self.find(a,b,2*k+1,l,(l+r)//2)\n c2=self.find(a,b,2*k+2,(l+r)//2,r)\n return max(c1,c2)\n def get(self,a,b):\n return self.find(a,b,0,0,self.d)",
"SEGTree",
"m=max(li)",
"max(li)",
"m",
"ans=0",
"0",
"ans",
"ans+=1",
"1",
"ans",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"T=map(int,input().split())",
"map(int,input().split())",
"T",
"SEG=SEGTree(N)",
"SEGTree(N)",
"SEG"
] |
class SEGTree:
def __init__(self,n):
self.Unit=0
i=1
while(i<n):
i*=2
self.SEG=[self.Unit]*(2*i-1)
self.d=i
def update(self,i,x):
i+=self.d-1
self.SEG[i]=x
while i>0:
i=(i-1)//2
self.SEG[i]=max(self.SEG[i*2+1],self.SEG[i*2+2])
def find(self,a,b,k,l,r):
if r<=a or b<=l:
return self.Unit
if a<=l and r<=b:
return self.SEG[k]
else:
c1=self.find(a,b,2*k+1,l,(l+r)//2)
c2=self.find(a,b,2*k+2,(l+r)//2,r)
return max(c1,c2)
def get(self,a,b):
return self.find(a,b,0,0,self.d)
N,T=map(int,input().split())
A=list(map(int,input().split()))
SEG=SEGTree(N)
for i in range(N):
SEG.update(i,A[i])
li=[0]*N
for i in range(N):
li[i]=max(li[i],SEG.get(i+1,N)-A[i])
m=max(li)
ans=0
for i in range(N):
if li[i]==m:
ans+=1
print(ans)
|
[
7,
12,
13,
29,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
18,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
17,
0,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
13,
0,
18,
13,
2,
13,
13,
2,
4,
18,
13,
13,
2,
13,
13,
17,
17,
0,
13,
4,
13,
4,
18,
13,
13,
4,
13,
18,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] |
[
[
29,
28
],
[
122,
30
],
[
29,
31
],
[
34,
33
],
[
125,
35
],
[
38,
37
],
[
33,
39
],
[
43,
42
],
[
46,
45
],
[
49,
48
],
[
33,
48
],
[
37,
52
],
[
71,
52
],
[
48,
53
],
[
60,
55
],
[
45,
56
],
[
42,
58
],
[
77,
58
],
[
74,
58
],
[
37,
59
],
[
71,
59
],
[
45,
63
],
[
42,
66
],
[
77,
66
],
[
74,
66
],
[
37,
67
],
[
71,
67
],
[
72,
71
],
[
48,
72
],
[
75,
74
],
[
48,
75
],
[
78,
77
],
[
42,
80
],
[
77,
80
],
[
74,
80
],
[
48,
81
],
[
88,
83
],
[
45,
84
],
[
77,
86
],
[
74,
86
],
[
42,
86
],
[
71,
87
],
[
37,
87
],
[
45,
91
],
[
77,
94
],
[
74,
94
],
[
42,
94
],
[
71,
95
],
[
37,
95
],
[
100,
99
],
[
45,
104
],
[
45,
109
],
[
99,
110
],
[
119,
116
]
] |
[
"def read_values():\n return map(int, input().split())\n\n\ndef read_list():\n return list(map(int, input().split()))\n\n\ndef main():\n N, T = read_values()\n A = read_list()\n\n m = A[0]\n p = 0\n D = {}\n for a in A:\n if m > a:\n D[p - m] = D.setdefault(p - m, 0) + 1\n m = a\n p = a\n else:\n p = max(p, a)\n D[p - m] = D.setdefault(p - m, 0) + 1\n\n k = max(D.keys())\n print(D[k])\n\n\nif __name__ == \"__main__\":\n main()",
"def read_values():\n return map(int, input().split())",
"read_values",
"return map(int, input().split())",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def read_list():\n return list(map(int, input().split()))",
"read_list",
"return list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def main():\n N, T = read_values()\n A = read_list()\n\n m = A[0]\n p = 0\n D = {}\n for a in A:\n if m > a:\n D[p - m] = D.setdefault(p - m, 0) + 1\n m = a\n p = a\n else:\n p = max(p, a)\n D[p - m] = D.setdefault(p - m, 0) + 1\n\n k = max(D.keys())\n print(D[k])",
"main",
"N, T = read_values()",
"N",
"read_values()",
"read_values",
"T",
"A = read_list()",
"A",
"read_list()",
"read_list",
"m = A[0]",
"m",
"A[0]",
"A",
"0",
"p = 0",
"p",
"0",
"D = {}",
"D",
"{}",
"for a in A:\n if m > a:\n D[p - m] = D.setdefault(p - m, 0) + 1\n m = a\n p = a\n else:\n p = max(p, a)\n ",
"a",
"A",
"if m > a:\n D[p - m] = D.setdefault(p - m, 0) + 1\n m = a\n p = a\n else:\n p = max(p, a)\n ",
"m > a",
"m",
"a",
"D[p - m] = D.setdefault(p - m, 0) + 1",
"D[p - m]",
"D",
"p - m",
"p",
"m",
"D.setdefault(p - m, 0) + 1",
"D.setdefault(p - m, 0)",
"D.setdefault",
"D",
"setdefault",
"p - m",
"p",
"m",
"0",
"1",
"m = a",
"m",
"a",
"p = a",
"p",
"a",
"p = max(p, a)",
"p",
"max(p, a)",
"max",
"p",
"a",
"D[p - m] = D.setdefault(p - m, 0) + 1",
"D[p - m]",
"D",
"p - m",
"p",
"m",
"D.setdefault(p - m, 0) + 1",
"D.setdefault(p - m, 0)",
"D.setdefault",
"D",
"setdefault",
"p - m",
"p",
"m",
"0",
"1",
"k = max(D.keys())",
"k",
"max(D.keys())",
"max",
"D.keys()",
"D.keys",
"D",
"keys",
"print(D[k])",
"print",
"D[k]",
"D",
"k",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n N, T = read_values()\n A = read_list()\n\n m = A[0]\n p = 0\n D = {}\n for a in A:\n if m > a:\n D[p - m] = D.setdefault(p - m, 0) + 1\n m = a\n p = a\n else:\n p = max(p, a)\n D[p - m] = D.setdefault(p - m, 0) + 1\n\n k = max(D.keys())\n print(D[k])",
"def main():\n N, T = read_values()\n A = read_list()\n\n m = A[0]\n p = 0\n D = {}\n for a in A:\n if m > a:\n D[p - m] = D.setdefault(p - m, 0) + 1\n m = a\n p = a\n else:\n p = max(p, a)\n D[p - m] = D.setdefault(p - m, 0) + 1\n\n k = max(D.keys())\n print(D[k])",
"main",
"def read_values():\n return map(int, input().split())",
"def read_values():\n return map(int, input().split())",
"read_values",
"def read_list():\n return list(map(int, input().split()))",
"def read_list():\n return list(map(int, input().split()))",
"read_list"
] |
def read_values():
return map(int, input().split())
def read_list():
return list(map(int, input().split()))
def main():
N, T = read_values()
A = read_list()
m = A[0]
p = 0
D = {}
for a in A:
if m > a:
D[p - m] = D.setdefault(p - m, 0) + 1
m = a
p = a
else:
p = max(p, a)
D[p - m] = D.setdefault(p - m, 0) + 1
k = max(D.keys())
print(D[k])
if __name__ == "__main__":
main()
|
[
7,
15,
0,
13,
4,
13,
17,
13,
0,
31,
13,
4,
13,
13,
4,
18,
13,
13,
0,
13,
2,
4,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
2,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
45,
3
],
[
45,
7
],
[
11,
9
],
[
43,
10
],
[
43,
16
],
[
39,
19
],
[
43,
23
],
[
43,
28
],
[
40,
34
],
[
40,
37
],
[
39,
40
],
[
45,
43
],
[
45,
46
]
] |
[
"from numpy import*;_,a=open(0);*a,=map(int,a.split());c=array(a)-minimum.accumulate(a);print(sum(c==max(c)))",
"from numpy import*",
"_,a=open(0)",
"_",
"open(0)",
"open",
"0",
"a",
"*a,=map(int,a.split())",
"*a",
"a",
"map(int,a.split())",
"map",
"int",
"a.split()",
"a.split",
"a",
"split",
"c=array(a)-minimum.accumulate(a)",
"c",
"array(a)-minimum.accumulate(a)",
"array(a)",
"array",
"a",
"minimum.accumulate(a)",
"minimum.accumulate",
"minimum",
"accumulate",
"a",
"print(sum(c==max(c)))",
"print",
"sum(c==max(c))",
"sum",
"c==max(c)",
"c",
"max(c)",
"max",
"c",
"c=array(a)-minimum.accumulate(a)",
"array(a)-minimum.accumulate(a)",
"c",
"a=open(0)",
"open(0)",
"a",
"_,a=open(0)",
"open(0)",
"_"
] |
from numpy import*;_,a=open(0);*a,=map(int,a.split());c=array(a)-minimum.accumulate(a);print(sum(c==max(c)))
|
[
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,
39,
28,
13,
4,
13,
13,
14,
2,
13,
17,
0,
13,
18,
13,
13,
0,
13,
13,
14,
2,
13,
18,
13,
13,
4,
18,
13,
13,
2,
13,
13,
0,
13,
18,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
14,
2,
13,
2,
13,
17,
4,
18,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
39,
13
] |
[
[
135,
2
],
[
135,
11
],
[
114,
13
],
[
141,
25
],
[
29,
28
],
[
124,
31
],
[
28,
34
],
[
132,
37
],
[
115,
39
],
[
28,
40
],
[
129,
42
],
[
133,
43
],
[
112,
43
],
[
133,
46
],
[
112,
46
],
[
115,
48
],
[
28,
49
],
[
142,
52
],
[
130,
55
],
[
118,
55
],
[
139,
55
],
[
133,
56
],
[
112,
56
],
[
111,
58
],
[
115,
60
],
[
28,
61
],
[
138,
63
],
[
112,
64
],
[
133,
64
],
[
117,
66
],
[
130,
69
],
[
118,
69
],
[
139,
69
],
[
115,
71
],
[
28,
72
],
[
28,
75
],
[
124,
77
],
[
142,
81
],
[
118,
84
],
[
139,
84
],
[
130,
84
],
[
112,
85
],
[
133,
85
],
[
120,
87
],
[
142,
90
],
[
108,
92
],
[
96,
95
],
[
142,
95
],
[
95,
99
],
[
121,
100
],
[
126,
102
],
[
127,
106
],
[
109,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
135,
124
],
[
126,
127
],
[
133,
129
],
[
112,
129
],
[
129,
130
],
[
132,
133
],
[
135,
136
],
[
112,
138
],
[
133,
138
],
[
138,
139
],
[
141,
142
]
] |
[
"N,T=map(int, input().split())\nA=list(map(int, input().split()))\nL=[]\nfor i in range(N):\n if i==0:\n now=A[i]\n nowmax=now\n if now>A[i]:\n L.append(nowmax-now)\n now=A[i]\n nowmax=now\n else:\n nowmax=max(nowmax,A[i])\n if i==N-1:\n L.append(nowmax-now)\nMAX=max(L)\nans=0\n#print(L)\nfor l in L:\n if l==MAX:\n ans+=1\nprint(ans)",
"N,T=map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A=list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L=[]",
"L",
"[]",
"for i in range(N):\n if i==0:\n now=A[i]\n nowmax=now\n if now>A[i]:\n L.append(nowmax-now)\n now=A[i]\n nowmax=now\n else:\n nowmax=max(nowmax,A[i])\n if i==N-1:\n L.append(nowmax-now)",
"i",
"range(N)",
"range",
"N",
"if i==0:\n now=A[i]\n nowmax=now\n ",
"i==0",
"i",
"0",
"now=A[i]",
"now",
"A[i]",
"A",
"i",
"nowmax=now",
"nowmax",
"now",
"if now>A[i]:\n L.append(nowmax-now)\n now=A[i]\n nowmax=now\n else:\n nowmax=max(nowmax,A[i])\n ",
"now>A[i]",
"now",
"A[i]",
"A",
"i",
"L.append(nowmax-now)",
"L.append",
"L",
"append",
"nowmax-now",
"nowmax",
"now",
"now=A[i]",
"now",
"A[i]",
"A",
"i",
"nowmax=now",
"nowmax",
"now",
"nowmax=max(nowmax,A[i])",
"nowmax",
"max(nowmax,A[i])",
"max",
"nowmax",
"A[i]",
"A",
"i",
"if i==N-1:\n L.append(nowmax-now)",
"i==N-1",
"i",
"N-1",
"N",
"1",
"L.append(nowmax-now)",
"L.append",
"L",
"append",
"nowmax-now",
"nowmax",
"now",
"MAX=max(L)",
"MAX",
"max(L)",
"max",
"L",
"ans=0",
"ans",
"0",
"for l in L:\n if l==MAX:\n ans+=1",
"l",
"L",
"if l==MAX:\n ans+=1",
"l==MAX",
"l",
"MAX",
"ans+=1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"ans=0",
"0",
"ans",
"now=A[i]",
"A[i]",
"now",
"A=list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"nowmax=max(nowmax,A[i])",
"max(nowmax,A[i])",
"nowmax",
"MAX=max(L)",
"max(L)",
"MAX",
"N,T=map(int, input().split())",
"map(int, input().split())",
"N",
"ans+=1",
"1",
"ans",
"nowmax=now",
"now",
"nowmax",
"now=A[i]",
"A[i]",
"now",
"T=map(int, input().split())",
"map(int, input().split())",
"T",
"nowmax=now",
"now",
"nowmax",
"L=[]",
"[]",
"L"
] |
N,T=map(int, input().split())
A=list(map(int, input().split()))
L=[]
for i in range(N):
if i==0:
now=A[i]
nowmax=now
if now>A[i]:
L.append(nowmax-now)
now=A[i]
nowmax=now
else:
nowmax=max(nowmax,A[i])
if i==N-1:
L.append(nowmax-now)
MAX=max(L)
ans=0
#print(L)
for l in L:
if l==MAX:
ans+=1
print(ans)
|
[
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,
4,
18,
18,
13,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
4,
18,
2,
13,
4,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
71,
4
],
[
71,
13
],
[
59,
15
],
[
74,
31
],
[
60,
38
],
[
68,
40
],
[
60,
42
],
[
75,
43
],
[
62,
45
],
[
69,
49
],
[
69,
52
],
[
63,
57
],
[
59,
60
],
[
62,
63
],
[
71,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] |
[
"import numpy as np\nN,T = map(int,input().split())\nA = np.array(list(map(int,input().split())))\nA_cummin = np.minimum.accumulate(A)\nprofit = A - A_cummin\nans = (profit == profit.max()).sum()\nprint(ans)",
"import numpy as np",
"numpy",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = np.array(list(map(int,input().split())))",
"A",
"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",
"A_cummin = np.minimum.accumulate(A)",
"A_cummin",
"np.minimum.accumulate(A)",
"np.minimum.accumulate",
"np.minimum",
"np",
"minimum",
"accumulate",
"A",
"profit = A - A_cummin",
"profit",
"A - A_cummin",
"A",
"A_cummin",
"ans = (profit == profit.max()).sum()",
"ans",
"(profit == profit.max()).sum()",
"profit == profit.max()).sum",
"profit == profit.max()",
"profit",
"profit.max()",
"profit.max",
"profit",
"max",
"sum",
"print(ans)",
"print",
"ans",
"A = np.array(list(map(int,input().split())))",
"np.array(list(map(int,input().split())))",
"A",
"ans = (profit == profit.max()).sum()",
"(profit == profit.max()).sum()",
"ans",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"profit = A - A_cummin",
"A - A_cummin",
"profit",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"A_cummin = np.minimum.accumulate(A)",
"np.minimum.accumulate(A)",
"A_cummin"
] |
import numpy as np
N,T = map(int,input().split())
A = np.array(list(map(int,input().split())))
A_cummin = np.minimum.accumulate(A)
profit = A - A_cummin
ans = (profit == profit.max()).sum()
print(ans)
|
[
7,
15,
13,
15,
15,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
4,
18,
2,
13,
17,
13,
0,
13,
2,
39,
17,
2,
17,
13,
12,
13,
28,
13,
4,
13,
13,
0,
18,
13,
2,
2,
13,
13,
17,
18,
13,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
18,
13,
13,
4,
13,
18,
13,
2,
2,
17,
13,
17,
18,
13,
2,
2,
17,
13,
17,
23,
13,
12,
13,
0,
13,
2,
13,
17,
0,
18,
13,
13,
13,
42,
40,
13,
17,
0,
13,
2,
2,
13,
17,
17,
0,
18,
13,
13,
4,
13,
18,
13,
2,
2,
17,
13,
17,
18,
13,
2,
2,
17,
13,
17,
23,
13,
23,
13,
12,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
42,
2,
13,
13,
14,
2,
13,
17,
0,
13,
17,
0,
13,
4,
13,
13,
18,
13,
2,
13,
17,
14,
2,
13,
17,
0,
13,
4,
13,
13,
18,
13,
2,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
29,
13,
23,
13,
23,
13,
4,
13,
13,
0,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
18,
13,
13,
0,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
13,
13,
0,
18,
13,
13,
17,
0,
13,
4,
13,
4,
18,
13,
13,
0,
13,
17,
4,
13,
18,
18,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
18,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
12,
13,
10,
4,
13
] |
[
[
302,
6
],
[
305,
15
],
[
332,
24
],
[
296,
33
],
[
306,
40
],
[
296,
42
],
[
311,
44
],
[
306,
53
],
[
299,
56
],
[
294,
62
],
[
326,
66
],
[
300,
72
],
[
77,
76
],
[
294,
79
],
[
88,
81
],
[
327,
82
],
[
76,
85
],
[
300,
86
],
[
121,
89
],
[
76,
90
],
[
93,
92
],
[
300,
96
],
[
104,
101
],
[
327,
102
],
[
92,
103
],
[
327,
107
],
[
92,
111
],
[
327,
114
],
[
92,
118
],
[
121,
121
],
[
126,
125
],
[
300,
127
],
[
133,
130
],
[
327,
131
],
[
125,
132
],
[
166,
132
],
[
168,
133
],
[
125,
136
],
[
166,
136
],
[
139,
136
],
[
140,
139
],
[
125,
142
],
[
166,
142
],
[
139,
142
],
[
149,
146
],
[
327,
147
],
[
139,
148
],
[
125,
148
],
[
166,
148
],
[
327,
152
],
[
139,
156
],
[
125,
156
],
[
166,
156
],
[
327,
159
],
[
139,
163
],
[
125,
163
],
[
166,
163
],
[
166,
166
],
[
168,
168
],
[
173,
172
],
[
231,
174
],
[
300,
175
],
[
178,
177
],
[
233,
179
],
[
300,
180
],
[
183,
182
],
[
172,
186
],
[
223,
186
],
[
220,
186
],
[
177,
187
],
[
226,
187
],
[
193,
187
],
[
177,
190
],
[
226,
190
],
[
193,
190
],
[
194,
193
],
[
197,
196
],
[
182,
199
],
[
210,
199
],
[
196,
199
],
[
327,
201
],
[
193,
203
],
[
177,
203
],
[
226,
203
],
[
172,
207
],
[
223,
207
],
[
220,
207
],
[
211,
210
],
[
196,
213
],
[
182,
213
],
[
210,
213
],
[
327,
215
],
[
172,
217
],
[
223,
217
],
[
220,
217
],
[
221,
220
],
[
224,
223
],
[
227,
226
],
[
210,
229
],
[
196,
229
],
[
182,
229
],
[
231,
231
],
[
233,
233
],
[
315,
235
],
[
312,
236
],
[
317,
238
],
[
244,
243
],
[
294,
247
],
[
320,
250
],
[
312,
252
],
[
243,
253
],
[
329,
255
],
[
336,
257
],
[
243,
259
],
[
294,
262
],
[
308,
265
],
[
330,
267
],
[
321,
268
],
[
273,
270
],
[
318,
271
],
[
309,
272
],
[
338,
275
],
[
318,
280
],
[
284,
283
],
[
339,
289
],
[
318,
289
],
[
296,
294
],
[
296,
297
],
[
299,
300
],
[
302,
303
],
[
305,
306
],
[
308,
309
],
[
311,
312
],
[
317,
318
],
[
320,
321
],
[
326,
327
],
[
329,
330
],
[
332,
333
],
[
338,
339
]
] |
[
"# -*- coding: utf-8 -*-\nimport sys \nfrom collections import deque\nfrom collections import defaultdict\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n\nN, T = map(int, readline().split())\nA = list(map(int,readline().split()))\n\n### セグメント木\n# 0-index\n# N: 処理する区間の長さ\nN0 = 2**(N-1).bit_length()\ndata = [0]*(2*N0)\n\n# 初期化\ndef init(A):\n for i in range(N):\n data[i+N0-1] = A[i]\n for i in range(N0-2,-1,-1):\n data[i] = max(data[2*i+1],data[2*i+2])\n\n# a_k の値を x に更新\ndef update(k, x):\n k += N0-1\n data[k] = x\n while k >= 0:\n k = (k - 1) // 2\n data[k] = max(data[2*k+1], data[2*k+2])\n\n# 区間[l, r)の最小値\ndef query(l, r):\n L = l + N0; R = r + N0\n s = 0\n while L < R:\n if R & 1:\n R -= 1\n s = max(s, data[R-1])\n\n if L & 1:\n s = max(s, data[L-1])\n L += 1\n L >>= 1; R >>= 1\n return s\n\ninit(A)\nd = defaultdict(int)\nfor i in range(N-1):\n a = A[i]\n high = query(i+1,N+1)\n p = high - a\n d[p] += 1\nd = sorted(d.items(),reverse=True)\nprint(d[0][1])",
"import sys",
"sys",
"from collections import deque",
"from collections import defaultdict",
"read = sys.stdin.buffer.read",
"read",
"sys.stdin.buffer.read",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"read",
"readline = sys.stdin.buffer.readline",
"readline",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"readlines = sys.stdin.buffer.readlines",
"readlines",
"sys.stdin.buffer.readlines",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readlines",
"N, T = map(int, readline().split())",
"N",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"T",
"A = list(map(int,readline().split()))",
"A",
"list(map(int,readline().split()))",
"list",
"map(int,readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"N0 = 2**(N-1).bit_length()",
"N0",
"2**(N-1).bit_length()",
"2",
"(N-1).bit_length()",
"N-1).bit_length",
"N-1",
"N",
"1",
"bit_length",
"data = [0]*(2*N0)",
"data",
"[0]*(2*N0)",
"[0]",
"0",
"2*N0",
"2",
"N0",
"def init(A):\n for i in range(N):\n data[i+N0-1] = A[i]\n for i in range(N0-2,-1,-1):\n data[i] = max(data[2*i+1],data[2*i+2])\n\n# a_k の値を x に更新",
"init",
"for i in range(N):\n data[i+N0-1] = A[i]\n ",
"i",
"range(N)",
"range",
"N",
"data[i+N0-1] = A[i]",
"data[i+N0-1]",
"data",
"i+N0-1",
"i+N0",
"i",
"N0",
"1",
"A[i]",
"A",
"i",
"for i in range(N0-2,-1,-1):\n data[i] = max(data[2*i+1],data[2*i+2])\n\n# a_k の値を x に更新",
"i",
"range(N0-2,-1,-1)",
"range",
"N0-2",
"N0",
"2",
"-1",
"-1",
"data[i] = max(data[2*i+1],data[2*i+2])",
"data[i]",
"data",
"i",
"max(data[2*i+1],data[2*i+2])",
"max",
"data[2*i+1]",
"data",
"2*i+1",
"2*i",
"2",
"i",
"1",
"data[2*i+2]",
"data",
"2*i+2",
"2*i",
"2",
"i",
"2",
"A",
"A",
"def update(k, x):\n k += N0-1\n data[k] = x\n while k >= 0:\n k = (k - 1) // 2\n data[k] = max(data[2*k+1], data[2*k+2])\n\n# 区間[l, r)の最小値",
"update",
"k += N0-1",
"k",
"N0-1",
"N0",
"1",
"data[k] = x",
"data[k]",
"data",
"k",
"x",
"while k >= 0:\n k = (k - 1) // 2\n data[k] = max(data[2*k+1], data[2*k+2])\n\n# 区間[l, r)の最小値",
"k >= 0",
"k",
"0",
"k = (k - 1) // 2",
"k",
"(k - 1) // 2",
"k - 1",
"k",
"1",
"2",
"data[k] = max(data[2*k+1], data[2*k+2])",
"data[k]",
"data",
"k",
"max(data[2*k+1], data[2*k+2])",
"max",
"data[2*k+1]",
"data",
"2*k+1",
"2*k",
"2",
"k",
"1",
"data[2*k+2]",
"data",
"2*k+2",
"2*k",
"2",
"k",
"2",
"k",
"k",
"x",
"x",
"def query(l, r):\n L = l + N0; R = r + N0\n s = 0\n while L < R:\n if R & 1:\n R -= 1\n s = max(s, data[R-1])\n\n if L & 1:\n s = max(s, data[L-1])\n L += 1\n L >>= 1; R >>= 1\n return s",
"query",
"L = l + N0",
"L",
"l + N0",
"l",
"N0",
"R = r + N0",
"R",
"r + N0",
"r",
"N0",
"s = 0",
"s",
"0",
"while L < R:\n if R & 1:\n R -= 1\n s = max(s, data[R-1])\n\n if L & 1:\n s = max(s, data[L-1])\n L += 1\n L >>= 1; R >>= 1\n ",
"L < R",
"L",
"R",
"if R & 1:\n R -= 1\n s = max(s, data[R-1])\n\n ",
"R & 1",
"R",
"1",
"R -= 1",
"R",
"1",
"s = max(s, data[R-1])",
"s",
"max(s, data[R-1])",
"max",
"s",
"data[R-1]",
"data",
"R-1",
"R",
"1",
"if L & 1:\n s = max(s, data[L-1])\n L += 1\n ",
"L & 1",
"L",
"1",
"s = max(s, data[L-1])",
"s",
"max(s, data[L-1])",
"max",
"s",
"data[L-1]",
"data",
"L-1",
"L",
"1",
"L += 1",
"L",
"1",
"L >>= 1",
"L",
"1",
"R >>= 1",
"R",
"1",
"return s",
"s",
"l",
"l",
"r",
"r",
"init(A)",
"init",
"A",
"d = defaultdict(int)",
"d",
"defaultdict(int)",
"defaultdict",
"int",
"for i in range(N-1):\n a = A[i]\n high = query(i+1,N+1)\n p = high - a\n d[p] += 1",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"a = A[i]",
"a",
"A[i]",
"A",
"i",
"high = query(i+1,N+1)",
"high",
"query(i+1,N+1)",
"query",
"i+1",
"i",
"1",
"N+1",
"N",
"1",
"p = high - a",
"p",
"high - a",
"high",
"a",
"d[p] += 1",
"d[p]",
"d",
"p",
"1",
"d = sorted(d.items(),reverse=True)",
"d",
"sorted(d.items(),reverse=True)",
"sorted",
"d.items()",
"d.items",
"d",
"items",
"reverse=True",
"reverse",
"True",
"print(d[0][1])",
"print",
"d[0][1]",
"[0]",
"d",
"0",
"1",
"N, T = map(int, readline().split())",
"map(int, readline().split())",
"N",
"T = map(int, readline().split())",
"map(int, readline().split())",
"T",
"N0 = 2**(N-1).bit_length()",
"2**(N-1).bit_length()",
"N0",
"read = sys.stdin.buffer.read",
"sys.stdin.buffer.read",
"read",
"readline = sys.stdin.buffer.readline",
"sys.stdin.buffer.readline",
"readline",
"p = high - a",
"high - a",
"p",
"A = list(map(int,readline().split()))",
"list(map(int,readline().split()))",
"A",
"def init(A):\n for i in range(N):\n data[i+N0-1] = A[i]\n for i in range(N0-2,-1,-1):\n data[i] = max(data[2*i+1],data[2*i+2])\n\n# a_k の値を x に更新",
"def init(A):\n for i in range(N):\n data[i+N0-1] = A[i]\n for i in range(N0-2,-1,-1):\n data[i] = max(data[2*i+1],data[2*i+2])\n\n# a_k の値を x に更新",
"init",
"d = defaultdict(int)",
"defaultdict(int)",
"d",
"a = A[i]",
"A[i]",
"a",
"def update(k, x):\n k += N0-1\n data[k] = x\n while k >= 0:\n k = (k - 1) // 2\n data[k] = max(data[2*k+1], data[2*k+2])\n\n# 区間[l, r)の最小値",
"def update(k, x):\n k += N0-1\n data[k] = x\n while k >= 0:\n k = (k - 1) // 2\n data[k] = max(data[2*k+1], data[2*k+2])\n\n# 区間[l, r)の最小値",
"update",
"data = [0]*(2*N0)",
"[0]*(2*N0)",
"data",
"high = query(i+1,N+1)",
"query(i+1,N+1)",
"high",
"readlines = sys.stdin.buffer.readlines",
"sys.stdin.buffer.readlines",
"readlines",
"def query(l, r):\n L = l + N0; R = r + N0\n s = 0\n while L < R:\n if R & 1:\n R -= 1\n s = max(s, data[R-1])\n\n if L & 1:\n s = max(s, data[L-1])\n L += 1\n L >>= 1; R >>= 1\n return s",
"def query(l, r):\n L = l + N0; R = r + N0\n s = 0\n while L < R:\n if R & 1:\n R -= 1\n s = max(s, data[R-1])\n\n if L & 1:\n s = max(s, data[L-1])\n L += 1\n L >>= 1; R >>= 1\n return s",
"query",
"d = sorted(d.items(),reverse=True)",
"sorted(d.items(),reverse=True)",
"d"
] |
# -*- coding: utf-8 -*-
import sys
from collections import deque
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, T = map(int, readline().split())
A = list(map(int,readline().split()))
### セグメント木
# 0-index
# N: 処理する区間の長さ
N0 = 2**(N-1).bit_length()
data = [0]*(2*N0)
# 初期化
def init(A):
for i in range(N):
data[i+N0-1] = A[i]
for i in range(N0-2,-1,-1):
data[i] = max(data[2*i+1],data[2*i+2])
# a_k の値を x に更新
def update(k, x):
k += N0-1
data[k] = x
while k >= 0:
k = (k - 1) // 2
data[k] = max(data[2*k+1], data[2*k+2])
# 区間[l, r)の最小値
def query(l, r):
L = l + N0; R = r + N0
s = 0
while L < R:
if R & 1:
R -= 1
s = max(s, data[R-1])
if L & 1:
s = max(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
init(A)
d = defaultdict(int)
for i in range(N-1):
a = A[i]
high = query(i+1,N+1)
p = high - a
d[p] += 1
d = sorted(d.items(),reverse=True)
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,
0,
13,
4,
13,
17,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
0,
18,
13,
13,
2,
18,
13,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
82,
2
],
[
82,
11
],
[
67,
13
],
[
79,
25
],
[
76,
30
],
[
71,
34
],
[
37,
36
],
[
71,
39
],
[
73,
41
],
[
80,
44
],
[
74,
44
],
[
68,
46
],
[
36,
47
],
[
52,
49
],
[
77,
50
],
[
36,
51
],
[
68,
54
],
[
36,
55
],
[
74,
56
],
[
80,
56
],
[
77,
61
],
[
77,
65
],
[
67,
68
],
[
82,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
]
] |
[
"n,t = map(int,input().split())\na =list(map(int,input().split()))\nMIN = float(\"inf\")\nb = [0] * n\nfor i in range(n):\n MIN = min(MIN,a[i])\n b[i] = a[i]-MIN\nprint(b.count(max(b)))",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a =list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"MIN = float(\"inf\")",
"MIN",
"float(\"inf\")",
"float",
"\"inf\"",
"b = [0] * n",
"b",
"[0] * n",
"[0]",
"0",
"n",
"for i in range(n):\n MIN = min(MIN,a[i])\n b[i] = a[i]-MIN",
"i",
"range(n)",
"range",
"n",
"MIN = min(MIN,a[i])",
"MIN",
"min(MIN,a[i])",
"min",
"MIN",
"a[i]",
"a",
"i",
"b[i] = a[i]-MIN",
"b[i]",
"b",
"i",
"a[i]-MIN",
"a[i]",
"a",
"i",
"MIN",
"print(b.count(max(b)))",
"print",
"b.count(max(b))",
"b.count",
"b",
"count",
"max(b)",
"max",
"b",
"a =list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"n,t = map(int,input().split())",
"map(int,input().split())",
"n",
"MIN = min(MIN,a[i])",
"min(MIN,a[i])",
"MIN",
"b = [0] * n",
"[0] * n",
"b",
"MIN = float(\"inf\")",
"float(\"inf\")",
"MIN",
"t = map(int,input().split())",
"map(int,input().split())",
"t"
] |
n,t = map(int,input().split())
a =list(map(int,input().split()))
MIN = float("inf")
b = [0] * n
for i in range(n):
MIN = min(MIN,a[i])
b[i] = a[i]-MIN
print(b.count(max(b)))
|
[
7,
0,
13,
2,
17,
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,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
42,
2,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
40,
13,
17,
0,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] |
[
[
115,
2
],
[
118,
7
],
[
118,
16
],
[
97,
18
],
[
94,
30
],
[
121,
33
],
[
103,
36
],
[
112,
39
],
[
113,
43
],
[
92,
43
],
[
119,
44
],
[
124,
46
],
[
98,
49
],
[
113,
50
],
[
92,
50
],
[
98,
52
],
[
104,
53
],
[
107,
53
],
[
125,
56
],
[
122,
57
],
[
89,
57
],
[
85,
59
],
[
125,
63
],
[
122,
64
],
[
89,
64
],
[
88,
66
],
[
125,
67
],
[
100,
69
],
[
125,
73
],
[
106,
76
],
[
113,
77
],
[
92,
77
],
[
91,
79
],
[
101,
83
],
[
86,
83
],
[
95,
83
],
[
85,
86
],
[
125,
88
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
113,
106
],
[
92,
106
],
[
106,
107
],
[
118,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
]
] |
[
"INF = 10**10\nn,t = map(int,input().split())\nA = list(map(int,input().split()))\n\nans = 0\ncost = 0\nl = 0\nr = 1\nwhile r<n: \n dif = A[r] - A[l]\n if dif == cost:\n ans += 1\n elif dif > cost :\n cost = dif\n ans = 1 \n else:\n pass\n if dif <= 0:\n l = r\n r += 1\n \nprint(ans) ",
"INF = 10**10",
"INF",
"10**10",
"10",
"10",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = 0",
"ans",
"0",
"cost = 0",
"cost",
"0",
"l = 0",
"l",
"0",
"r = 1",
"r",
"1",
"while r<n: \n dif = A[r] - A[l]\n if dif == cost:\n ans += 1\n elif dif > cost :\n cost = dif\n ans = 1 \n else:\n pass\n if dif <= 0:\n l = r\n r += 1\n ",
"r<n",
"r",
"n",
"dif = A[r] - A[l]",
"dif",
"A[r] - A[l]",
"A[r]",
"A",
"r",
"A[l]",
"A",
"l",
"if dif == cost:\n ans += 1\n elif dif > cost :\n cost = dif\n ans = 1 \n else:\n pass\n ",
"dif == cost",
"dif",
"cost",
"ans += 1",
"ans",
"1",
"elif dif > cost :\n cost = dif\n ans = 1 \n ",
"dif > cost",
"dif",
"cost",
"cost = dif",
"cost",
"dif",
"ans = 1",
"ans",
"1",
"if dif <= 0:\n l = r\n ",
"dif <= 0",
"dif",
"0",
"l = r",
"l",
"r",
"r += 1",
"r",
"1",
"print(ans)",
"print",
"ans",
"ans += 1",
"1",
"ans",
"cost = dif",
"dif",
"cost",
"r += 1",
"1",
"r",
"ans = 0",
"0",
"ans",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"ans = 1",
"1",
"ans",
"l = 0",
"0",
"l",
"l = r",
"r",
"l",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"r = 1",
"1",
"r",
"INF = 10**10",
"10**10",
"INF",
"n,t = map(int,input().split())",
"map(int,input().split())",
"n",
"cost = 0",
"0",
"cost",
"dif = A[r] - A[l]",
"A[r] - A[l]",
"dif"
] |
INF = 10**10
n,t = map(int,input().split())
A = list(map(int,input().split()))
ans = 0
cost = 0
l = 0
r = 1
while r<n:
dif = A[r] - A[l]
if dif == cost:
ans += 1
elif dif > cost :
cost = dif
ans = 1
else:
pass
if dif <= 0:
l = r
r += 1
print(ans)
|
[
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,
39,
2,
18,
13,
2,
13,
17,
17,
0,
13,
39,
17,
17,
4,
18,
13,
13,
13,
28,
13,
4,
13,
17,
13,
0,
13,
2,
2,
18,
13,
17,
17,
18,
13,
2,
2,
13,
17,
13,
14,
2,
13,
18,
13,
17,
0,
13,
39,
13,
17,
14,
2,
13,
18,
13,
17,
0,
18,
13,
17,
17,
4,
18,
13,
13,
13,
2,
18,
13,
2,
2,
13,
17,
13,
17,
4,
13,
18,
13,
17,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
2,
13,
10,
39,
13
] |
[
[
118,
4
],
[
118,
13
],
[
17,
16
],
[
16,
25
],
[
115,
27
],
[
121,
30
],
[
116,
34
],
[
119,
36
],
[
124,
40
],
[
122,
48
],
[
51,
50
],
[
119,
54
],
[
127,
56
],
[
122,
60
],
[
116,
64
],
[
119,
67
],
[
50,
69
],
[
128,
72
],
[
125,
74
],
[
131,
74
],
[
130,
77
],
[
128,
83
],
[
125,
85
],
[
131,
85
],
[
91,
88
],
[
125,
89
],
[
131,
89
],
[
122,
96
],
[
116,
99
],
[
119,
102
],
[
50,
104
],
[
131,
109
],
[
125,
109
],
[
118,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
]
] |
[
"import heapq\nn,t = map(int,input().split())\nai = [int(i) for i in input().split()]\n\n\nrev_ai = [ai[n-1]*(-1)]\n\nans = [0,0]\n\nheapq.heapify(rev_ai)\n#print(rev_ai)\nfor i in range(1,n):\n #print(ai[n-1-i])\n dif = rev_ai[0]*(-1) - ai[n-1-i]\n if dif > ans[0]:\n ans = [dif,1]\n elif dif == ans[0]:\n ans[1] += 1\n #print(rev_ai[0])\n heapq.heappush(rev_ai,ai[n-1-i]*(-1))\n\nprint(ans[1])",
"import heapq",
"heapq",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"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",
"ai = [int(i) for i in input().split()]",
"ai",
"[int(i) for i in input().split()]",
"rev_ai = [ai[n-1]*(-1)]",
"rev_ai",
"[ai[n-1]*(-1)]",
"ai[n-1]*(-1)",
"ai[n-1]",
"ai",
"n-1",
"n",
"1",
"-1",
"ans = [0,0]",
"ans",
"[0,0]",
"0",
"0",
"heapq.heapify(rev_ai)",
"heapq.heapify",
"heapq",
"heapify",
"rev_ai",
"for i in range(1,n):\n #print(ai[n-1-i])\n dif = rev_ai[0]*(-1) - ai[n-1-i]\n if dif > ans[0]:\n ans = [dif,1]\n elif dif == ans[0]:\n ans[1] += 1\n #print(rev_ai[0])\n heapq.heappush(rev_ai,ai[n-1-i]*(-1))",
"i",
"range(1,n)",
"range",
"1",
"n",
"dif = rev_ai[0]*(-1) - ai[n-1-i]",
"dif",
"rev_ai[0]*(-1) - ai[n-1-i]",
"rev_ai[0]*(-1)",
"rev_ai[0]",
"rev_ai",
"0",
"-1",
"ai[n-1-i]",
"ai",
"n-1-i",
"n-1",
"n",
"1",
"i",
"if dif > ans[0]:\n ans = [dif,1]\n elif dif == ans[0]:\n ans[1] += 1\n #print(rev_ai[0])\n ",
"dif > ans[0]",
"dif",
"ans[0]",
"ans",
"0",
"ans = [dif,1]",
"ans",
"[dif,1]",
"dif",
"1",
"elif dif == ans[0]:\n ans[1] += 1\n #print(rev_ai[0])\n ",
"dif == ans[0]",
"dif",
"ans[0]",
"ans",
"0",
"ans[1] += 1",
"ans[1]",
"ans",
"1",
"1",
"heapq.heappush(rev_ai,ai[n-1-i]*(-1))",
"heapq.heappush",
"heapq",
"heappush",
"rev_ai",
"ai[n-1-i]*(-1)",
"ai[n-1-i]",
"ai",
"n-1-i",
"n-1",
"n",
"1",
"i",
"-1",
"print(ans[1])",
"print",
"ans[1]",
"ans",
"1",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"ai = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"ai",
"n,t = map(int,input().split())",
"map(int,input().split())",
"n",
"rev_ai = [ai[n-1]*(-1)]",
"[ai[n-1]*(-1)]",
"rev_ai",
"ans = [0,0]",
"[0,0]",
"ans",
"dif = rev_ai[0]*(-1) - ai[n-1-i]",
"rev_ai[0]*(-1) - ai[n-1-i]",
"dif",
"ans = [dif,1]",
"[dif,1]",
"ans"
] |
import heapq
n,t = map(int,input().split())
ai = [int(i) for i in input().split()]
rev_ai = [ai[n-1]*(-1)]
ans = [0,0]
heapq.heapify(rev_ai)
#print(rev_ai)
for i in range(1,n):
#print(ai[n-1-i])
dif = rev_ai[0]*(-1) - ai[n-1-i]
if dif > ans[0]:
ans = [dif,1]
elif dif == ans[0]:
ans[1] += 1
#print(rev_ai[0])
heapq.heappush(rev_ai,ai[n-1-i]*(-1))
print(ans[1])
|
[
7,
12,
13,
0,
13,
17,
42,
17,
14,
40,
13,
2,
13,
17,
0,
13,
2,
39,
17,
13,
3,
0,
13,
17,
29,
13,
23,
13,
12,
13,
0,
13,
2,
4,
13,
13,
17,
0,
18,
13,
13,
13,
0,
13,
17,
42,
17,
14,
2,
13,
17,
3,
0,
18,
13,
13,
4,
13,
18,
13,
2,
17,
13,
18,
13,
2,
2,
17,
13,
17,
0,
13,
17,
29,
23,
13,
23,
13,
12,
13,
0,
13,
2,
4,
13,
13,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
17,
42,
17,
14,
2,
13,
13,
3,
14,
2,
2,
13,
17,
17,
0,
13,
17,
0,
13,
4,
13,
13,
18,
13,
13,
0,
13,
2,
2,
13,
17,
17,
14,
2,
2,
13,
17,
17,
0,
13,
17,
0,
13,
4,
13,
13,
18,
13,
13,
0,
13,
2,
2,
13,
17,
17,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
28,
13,
4,
13,
13,
4,
13,
13,
18,
13,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
2,
13,
17,
0,
18,
13,
13,
2,
4,
13,
2,
13,
17,
2,
13,
17,
18,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] |
[
[
5,
4
],
[
4,
10
],
[
22,
10
],
[
27,
12
],
[
16,
15
],
[
4,
19
],
[
22,
19
],
[
23,
22
],
[
15,
25
],
[
27,
27
],
[
32,
31
],
[
41,
38
],
[
31,
40
],
[
75,
40
],
[
77,
41
],
[
44,
43
],
[
43,
49
],
[
31,
49
],
[
75,
49
],
[
71,
49
],
[
56,
53
],
[
43,
55
],
[
31,
55
],
[
75,
55
],
[
71,
55
],
[
43,
62
],
[
31,
62
],
[
75,
62
],
[
71,
62
],
[
43,
68
],
[
31,
68
],
[
75,
68
],
[
71,
68
],
[
72,
71
],
[
75,
75
],
[
77,
77
],
[
82,
81
],
[
89,
88
],
[
96,
95
],
[
81,
101
],
[
155,
101
],
[
122,
101
],
[
111,
101
],
[
88,
102
],
[
157,
102
],
[
146,
102
],
[
135,
102
],
[
81,
107
],
[
155,
107
],
[
122,
107
],
[
111,
107
],
[
112,
111
],
[
115,
114
],
[
95,
117
],
[
138,
117
],
[
114,
117
],
[
81,
120
],
[
155,
120
],
[
122,
120
],
[
111,
120
],
[
123,
122
],
[
81,
125
],
[
155,
125
],
[
122,
125
],
[
111,
125
],
[
88,
131
],
[
157,
131
],
[
146,
131
],
[
135,
131
],
[
136,
135
],
[
139,
138
],
[
114,
141
],
[
95,
141
],
[
138,
141
],
[
88,
144
],
[
157,
144
],
[
146,
144
],
[
135,
144
],
[
147,
146
],
[
88,
149
],
[
157,
149
],
[
146,
149
],
[
135,
149
],
[
138,
153
],
[
114,
153
],
[
95,
153
],
[
155,
155
],
[
157,
157
],
[
262,
159
],
[
262,
168
],
[
265,
170
],
[
241,
182
],
[
245,
184
],
[
263,
185
],
[
247,
187
],
[
242,
190
],
[
193,
192
],
[
263,
195
],
[
260,
197
],
[
192,
198
],
[
266,
200
],
[
192,
201
],
[
250,
203
],
[
263,
207
],
[
210,
209
],
[
263,
213
],
[
219,
216
],
[
251,
217
],
[
209,
218
],
[
254,
221
],
[
209,
223
],
[
263,
226
],
[
266,
229
],
[
209,
230
],
[
251,
235
],
[
251,
239
],
[
241,
242
],
[
247,
248
],
[
250,
251
],
[
262,
257
],
[
262,
263
],
[
265,
266
]
] |
[
"def make_tree(n):\n i = 2\n while True:\n if i >= n * 2:\n tree = [0] * i\n break\n else:\n i *= 2\n return tree\n\ndef update(i, x):\n i += len(tree) // 2\n tree[i] = x\n i //= 2\n while True:\n if i == 0:\n break\n tree[i] = max(tree[2 * i], tree[2 * i + 1])\n i //= 2\n return\n\ndef find(s, t):\n s += len(tree) // 2\n t += len(tree) // 2\n ans = 0\n while True:\n if s > t:\n break\n if s % 2 == 0:\n s //= 2\n else:\n ans = max(ans, tree[s])\n s = (s + 1) // 2\n if t % 2 == 1:\n t //= 2\n else:\n ans = max(ans, tree[t])\n t = (t - 1) // 2\n return ans\n\nn, t = map(int, input().split())\na = list(map(int, input().split()))\ntree = make_tree(n)\nl = len(tree)\nfor i in range(n):\n update(i, a[i])\nb = [0] * n\nfor i in range(n - 1):\n b[i] = find(i + 1, n - 1) - a[i]\nprint(b.count(max(b)))",
"def make_tree(n):\n i = 2\n while True:\n if i >= n * 2:\n tree = [0] * i\n break\n else:\n i *= 2\n return tree",
"make_tree",
"i = 2",
"i",
"2",
"while True:\n if i >= n * 2:\n tree = [0] * i\n break\n else:\n i *= 2\n ",
"True",
"if i >= n * 2:\n tree = [0] * i\n break\n else:\n i *= 2\n ",
"i >= n * 2",
"i",
"n * 2",
"n",
"2",
"tree = [0] * i",
"tree",
"[0] * i",
"[0]",
"0",
"i",
"break",
"i *= 2",
"i",
"2",
"return tree",
"tree",
"n",
"n",
"def update(i, x):\n i += len(tree) // 2\n tree[i] = x\n i //= 2\n while True:\n if i == 0:\n break\n tree[i] = max(tree[2 * i], tree[2 * i + 1])\n i //= 2\n return",
"update",
"i += len(tree) // 2",
"i",
"len(tree) // 2",
"len(tree)",
"len",
"tree",
"2",
"tree[i] = x",
"tree[i]",
"tree",
"i",
"x",
"i //= 2",
"i",
"2",
"while True:\n if i == 0:\n break\n tree[i] = max(tree[2 * i], tree[2 * i + 1])\n i //= 2\n ",
"True",
"if i == 0:\n break\n ",
"i == 0",
"i",
"0",
"break",
"tree[i] = max(tree[2 * i], tree[2 * i + 1])",
"tree[i]",
"tree",
"i",
"max(tree[2 * i], tree[2 * i + 1])",
"max",
"tree[2 * i]",
"tree",
"2 * i",
"2",
"i",
"tree[2 * i + 1]",
"tree",
"2 * i + 1",
"2 * i",
"2",
"i",
"1",
"i //= 2",
"i",
"2",
"return",
"i",
"i",
"x",
"x",
"def find(s, t):\n s += len(tree) // 2\n t += len(tree) // 2\n ans = 0\n while True:\n if s > t:\n break\n if s % 2 == 0:\n s //= 2\n else:\n ans = max(ans, tree[s])\n s = (s + 1) // 2\n if t % 2 == 1:\n t //= 2\n else:\n ans = max(ans, tree[t])\n t = (t - 1) // 2\n return ans",
"find",
"s += len(tree) // 2",
"s",
"len(tree) // 2",
"len(tree)",
"len",
"tree",
"2",
"t += len(tree) // 2",
"t",
"len(tree) // 2",
"len(tree)",
"len",
"tree",
"2",
"ans = 0",
"ans",
"0",
"while True:\n if s > t:\n break\n if s % 2 == 0:\n s //= 2\n else:\n ans = max(ans, tree[s])\n s = (s + 1) // 2\n if t % 2 == 1:\n t //= 2\n else:\n ans = max(ans, tree[t])\n t = (t - 1) // 2\n ",
"True",
"if s > t:\n break\n ",
"s > t",
"s",
"t",
"break",
"if s % 2 == 0:\n s //= 2\n else:\n ans = max(ans, tree[s])\n s = (s + 1) // 2\n ",
"s % 2 == 0",
"s % 2",
"s",
"2",
"0",
"s //= 2",
"s",
"2",
"ans = max(ans, tree[s])",
"ans",
"max(ans, tree[s])",
"max",
"ans",
"tree[s]",
"tree",
"s",
"s = (s + 1) // 2",
"s",
"(s + 1) // 2",
"s + 1",
"s",
"1",
"2",
"if t % 2 == 1:\n t //= 2\n else:\n ans = max(ans, tree[t])\n t = (t - 1) // 2\n ",
"t % 2 == 1",
"t % 2",
"t",
"2",
"1",
"t //= 2",
"t",
"2",
"ans = max(ans, tree[t])",
"ans",
"max(ans, tree[t])",
"max",
"ans",
"tree[t]",
"tree",
"t",
"t = (t - 1) // 2",
"t",
"(t - 1) // 2",
"t - 1",
"t",
"1",
"2",
"return ans",
"ans",
"s",
"s",
"t",
"t",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"tree = make_tree(n)",
"tree",
"make_tree(n)",
"make_tree",
"n",
"l = len(tree)",
"l",
"len(tree)",
"len",
"tree",
"for i in range(n):\n update(i, a[i])",
"i",
"range(n)",
"range",
"n",
"update(i, a[i])",
"update",
"i",
"a[i]",
"a",
"i",
"b = [0] * n",
"b",
"[0] * n",
"[0]",
"0",
"n",
"for i in range(n - 1):\n b[i] = find(i + 1, n - 1) - a[i]",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"b[i] = find(i + 1, n - 1) - a[i]",
"b[i]",
"b",
"i",
"find(i + 1, n - 1) - a[i]",
"find(i + 1, n - 1)",
"find",
"i + 1",
"i",
"1",
"n - 1",
"n",
"1",
"a[i]",
"a",
"i",
"print(b.count(max(b)))",
"print",
"b.count(max(b))",
"b.count",
"b",
"count",
"max(b)",
"max",
"b",
"tree = make_tree(n)",
"make_tree(n)",
"tree",
"def make_tree(n):\n i = 2\n while True:\n if i >= n * 2:\n tree = [0] * i\n break\n else:\n i *= 2\n return tree",
"def make_tree(n):\n i = 2\n while True:\n if i >= n * 2:\n tree = [0] * i\n break\n else:\n i *= 2\n return tree",
"make_tree",
"l = len(tree)",
"len(tree)",
"l",
"b = [0] * n",
"[0] * n",
"b",
"def find(s, t):\n s += len(tree) // 2\n t += len(tree) // 2\n ans = 0\n while True:\n if s > t:\n break\n if s % 2 == 0:\n s //= 2\n else:\n ans = max(ans, tree[s])\n s = (s + 1) // 2\n if t % 2 == 1:\n t //= 2\n else:\n ans = max(ans, tree[t])\n t = (t - 1) // 2\n return ans",
"def find(s, t):\n s += len(tree) // 2\n t += len(tree) // 2\n ans = 0\n while True:\n if s > t:\n break\n if s % 2 == 0:\n s //= 2\n else:\n ans = max(ans, tree[s])\n s = (s + 1) // 2\n if t % 2 == 1:\n t //= 2\n else:\n ans = max(ans, tree[t])\n t = (t - 1) // 2\n return ans",
"find",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"def update(i, x):\n i += len(tree) // 2\n tree[i] = x\n i //= 2\n while True:\n if i == 0:\n break\n tree[i] = max(tree[2 * i], tree[2 * i + 1])\n i //= 2\n return",
"def update(i, x):\n i += len(tree) // 2\n tree[i] = x\n i //= 2\n while True:\n if i == 0:\n break\n tree[i] = max(tree[2 * i], tree[2 * i + 1])\n i //= 2\n return",
"update",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] |
def make_tree(n):
i = 2
while True:
if i >= n * 2:
tree = [0] * i
break
else:
i *= 2
return tree
def update(i, x):
i += len(tree) // 2
tree[i] = x
i //= 2
while True:
if i == 0:
break
tree[i] = max(tree[2 * i], tree[2 * i + 1])
i //= 2
return
def find(s, t):
s += len(tree) // 2
t += len(tree) // 2
ans = 0
while True:
if s > t:
break
if s % 2 == 0:
s //= 2
else:
ans = max(ans, tree[s])
s = (s + 1) // 2
if t % 2 == 1:
t //= 2
else:
ans = max(ans, tree[t])
t = (t - 1) // 2
return ans
n, t = map(int, input().split())
a = list(map(int, input().split()))
tree = make_tree(n)
l = len(tree)
for i in range(n):
update(i, a[i])
b = [0] * n
for i in range(n - 1):
b[i] = find(i + 1, n - 1) - a[i]
print(b.count(max(b)))
|
[
7,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
13,
15,
15,
15,
13,
15,
13,
0,
13,
12,
4,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
17,
12,
13,
0,
13,
39,
0,
13,
13,
14,
2,
13,
17,
29,
13,
28,
13,
4,
13,
17,
2,
4,
13,
40,
2,
40,
2,
13,
17,
17,
17,
14,
2,
2,
13,
13,
17,
0,
13,
17,
42,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
13,
4,
18,
13,
13,
39,
13,
13,
14,
40,
13,
17,
4,
18,
13,
13,
39,
13,
17,
14,
2,
13,
39,
4,
18,
13,
13,
39,
13,
17,
29,
13,
23,
13,
12,
13,
0,
13,
17,
42,
13,
14,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
17,
0,
13,
2,
13,
13,
29,
2,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
17,
29,
17,
0,
13,
13,
0,
13,
2,
13,
17,
42,
40,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
17,
29,
13,
23,
13,
23,
13,
23,
13,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
14,
2,
13,
2,
13,
13,
0,
13,
17,
14,
2,
13,
2,
13,
13,
0,
13,
17,
0,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13
] |
[
[
298,
20
],
[
271,
25
],
[
299,
30
],
[
280,
32
],
[
299,
42
],
[
50,
49
],
[
53,
52
],
[
129,
53
],
[
129,
56
],
[
49,
59
],
[
62,
61
],
[
129,
72
],
[
52,
79
],
[
95,
79
],
[
61,
80
],
[
84,
83
],
[
52,
88
],
[
95,
88
],
[
61,
89
],
[
93,
92
],
[
96,
95
],
[
61,
96
],
[
49,
99
],
[
95,
106
],
[
52,
106
],
[
49,
110
],
[
49,
117
],
[
49,
121
],
[
49,
127
],
[
129,
129
],
[
134,
133
],
[
161,
139
],
[
147,
139
],
[
143,
142
],
[
159,
144
],
[
150,
144
],
[
163,
145
],
[
148,
147
],
[
151,
150
],
[
159,
152
],
[
150,
152
],
[
163,
153
],
[
142,
156
],
[
133,
156
],
[
163,
157
],
[
159,
159
],
[
161,
161
],
[
163,
163
],
[
197,
168
],
[
174,
173
],
[
197,
174
],
[
177,
176
],
[
197,
178
],
[
176,
182
],
[
192,
182
],
[
199,
183
],
[
186,
185
],
[
173,
188
],
[
185,
188
],
[
176,
189
],
[
192,
189
],
[
201,
190
],
[
193,
192
],
[
185,
195
],
[
173,
195
],
[
197,
197
],
[
199,
199
],
[
201,
201
],
[
295,
203
],
[
301,
208
],
[
283,
215
],
[
281,
217
],
[
283,
218
],
[
304,
220
],
[
281,
222
],
[
268,
224
],
[
296,
225
],
[
286,
227
],
[
307,
230
],
[
234,
233
],
[
305,
233
],
[
308,
237
],
[
317,
237
],
[
233,
239
],
[
269,
240
],
[
290,
240
],
[
310,
242
],
[
308,
246
],
[
317,
246
],
[
233,
248
],
[
269,
249
],
[
290,
249
],
[
319,
251
],
[
316,
254
],
[
233,
256
],
[
269,
257
],
[
290,
257
],
[
289,
259
],
[
233,
262
],
[
269,
263
],
[
290,
263
],
[
320,
266
],
[
311,
266
],
[
287,
266
],
[
296,
268
],
[
268,
269
],
[
271,
272
],
[
283,
275
],
[
280,
281
],
[
283,
284
],
[
286,
287
],
[
289,
290
],
[
295,
296
],
[
298,
299
],
[
301,
302
],
[
304,
305
],
[
307,
308
],
[
310,
311
],
[
316,
317
],
[
319,
320
]
] |
[
"# input()\n# int(input())\n# map(int, input().split())\n# list(map(int, input().split()))\n# list(map(int, list(input()))) # スペースがない数字リストを読み込み\nimport math\nimport fractions\nimport sys\nimport bisect\nimport heapq # 優先度付きキュー(最小値取り出し)\nimport collections\nfrom collections import Counter\nfrom collections import deque\nimport pprint\nimport itertools\n\nsr = lambda: input()\nir = lambda: int(sr())\nlr = lambda: list(map(int, sr().split()))\n\n\"\"\"nを素因数分解\"\"\"\n\"\"\"2以上の整数n => [[素因数, 指数], ...]の2次元リスト\"\"\"\n\n\ndef factorization(n):\n arr = []\n temp = n\n if n == 1:\n return arr\n\n for i in range(2, int(-(-n ** 0.5 // 1)) + 1):\n if temp % i == 0:\n cnt = 0\n while temp % i == 0:\n cnt += 1\n temp //= i\n arr.append([i, cnt])\n\n if temp != 1:\n arr.append([temp, 1])\n\n if arr == []:\n arr.append([n, 1])\n\n return arr\n\n\n# a^n\ndef power(a, n, mod):\n x = 1\n while n:\n if n & 1:\n x *= a % mod\n n >>= 1\n a *= a % mod\n return x % mod\n\n\n# n*(n-1)*...*(l+1)*l\ndef kaijo(n, l, mod):\n if n == 0:\n return 1\n a = n\n tmp = n - 1\n while (tmp >= l):\n a = a * tmp % mod\n tmp -= 1\n return a\n\n\ninf = 10 ** 18\nmod = 10 ** 9 + 7\n\nn,t = lr()\na = lr()\nmin_num = inf\nans = 0\nmax_num = 0\nfor num in a:\n if max_num == num-min_num:\n ans+=1\n elif max_num < num-min_num:\n ans = 1\n max_num = num-min_num\n min_num = min(num,min_num)\nprint(ans)",
"import math",
"math",
"import fractions",
"fractions",
"import sys",
"sys",
"import bisect",
"bisect",
"import heapq",
"heapq",
"import collections",
"collections",
"from collections import Counter",
"from collections import deque",
"import pprint",
"pprint",
"import itertools",
"itertools",
"sr = lambda: input()",
"sr",
"lambda: input()",
"input()",
"input",
"ir = lambda: int(sr())",
"ir",
"lambda: int(sr())",
"int(sr())",
"int",
"sr()",
"sr",
"lr = lambda: list(map(int, sr().split()))",
"lr",
"lambda: list(map(int, sr().split()))",
"list(map(int, sr().split()))",
"list",
"map(int, sr().split())",
"map",
"int",
"sr().split()",
"().split",
"()",
"sr",
"split",
"\"\"\"nを素因数分解\"\"\"",
"\"\"\"2以上の整数n => [[素因数, 指数], ...]の2次元リスト\"\"\"",
"def factorization(n):\n arr = []\n temp = n\n if n == 1:\n return arr\n\n for i in range(2, int(-(-n ** 0.5 // 1)) + 1):\n if temp % i == 0:\n cnt = 0\n while temp % i == 0:\n cnt += 1\n temp //= i\n arr.append([i, cnt])\n\n if temp != 1:\n arr.append([temp, 1])\n\n if arr == []:\n arr.append([n, 1])\n\n return arr\n\n\n# a^n",
"factorization",
"arr = []",
"arr",
"[]",
"temp = n",
"temp",
"n",
"if n == 1:\n return arr\n\n ",
"n == 1",
"n",
"1",
"return arr",
"arr",
"for i in range(2, int(-(-n ** 0.5 // 1)) + 1):\n if temp % i == 0:\n cnt = 0\n while temp % i == 0:\n cnt += 1\n temp //= i\n arr.append([i, cnt])\n\n ",
"i",
"range(2, int(-(-n ** 0.5 // 1)) + 1)",
"range",
"2",
"int(-(-n ** 0.5 // 1)) + 1",
"int(-(-n ** 0.5 // 1))",
"int",
"-(-n ** 0.5 // 1)",
"-n ** 0.5 // 1",
"-n ** 0.5",
"n ** 0.5",
"n",
"0.5",
"1",
"1",
"if temp % i == 0:\n cnt = 0\n while temp % i == 0:\n cnt += 1\n temp //= i\n arr.append([i, cnt])\n\n ",
"temp % i == 0",
"temp % i",
"temp",
"i",
"0",
"cnt = 0",
"cnt",
"0",
"while temp % i == 0:\n cnt += 1\n temp //= i\n ",
"temp % i == 0",
"temp % i",
"temp",
"i",
"0",
"cnt += 1",
"cnt",
"1",
"temp //= i",
"temp",
"i",
"arr.append([i, cnt])",
"arr.append",
"arr",
"append",
"[i, cnt]",
"i",
"cnt",
"if temp != 1:\n arr.append([temp, 1])\n\n ",
"temp != 1",
"temp",
"1",
"arr.append([temp, 1])",
"arr.append",
"arr",
"append",
"[temp, 1]",
"temp",
"1",
"if arr == []:\n arr.append([n, 1])\n\n ",
"arr == []",
"arr",
"[]",
"arr.append([n, 1])",
"arr.append",
"arr",
"append",
"[n, 1]",
"n",
"1",
"return arr",
"arr",
"n",
"n",
"def power(a, n, mod):\n x = 1\n while n:\n if n & 1:\n x *= a % mod\n n >>= 1\n a *= a % mod\n return x % mod\n\n\n# n*(n-1)*...*(l+1)*l",
"power",
"x = 1",
"x",
"1",
"while n:\n if n & 1:\n x *= a % mod\n n >>= 1\n a *= a % mod\n ",
"n",
"if n & 1:\n x *= a % mod\n ",
"n & 1",
"n",
"1",
"x *= a % mod",
"x",
"a % mod",
"a",
"mod",
"n >>= 1",
"n",
"1",
"a *= a % mod",
"a",
"a % mod",
"a",
"mod",
"return x % mod",
"x % mod",
"x",
"mod",
"a",
"a",
"n",
"n",
"mod",
"mod",
"def kaijo(n, l, mod):\n if n == 0:\n return 1\n a = n\n tmp = n - 1\n while (tmp >= l):\n a = a * tmp % mod\n tmp -= 1\n return a",
"kaijo",
"if n == 0:\n return 1\n ",
"n == 0",
"n",
"0",
"return 1",
"1",
"a = n",
"a",
"n",
"tmp = n - 1",
"tmp",
"n - 1",
"n",
"1",
"while (tmp >= l):\n a = a * tmp % mod\n tmp -= 1\n ",
"tmp >= l",
"tmp",
"l",
"a = a * tmp % mod",
"a",
"a * tmp % mod",
"a * tmp",
"a",
"tmp",
"mod",
"tmp -= 1",
"tmp",
"1",
"return a",
"a",
"n",
"n",
"l",
"l",
"mod",
"mod",
"inf = 10 ** 18",
"inf",
"10 ** 18",
"10",
"18",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"n,t = lr()",
"n",
"lr()",
"lr",
"t",
"a = lr()",
"a",
"lr()",
"lr",
"min_num = inf",
"min_num",
"inf",
"ans = 0",
"ans",
"0",
"max_num = 0",
"max_num",
"0",
"for num in a:\n if max_num == num-min_num:\n ans+=1\n elif max_num < num-min_num:\n ans = 1\n max_num = num-min_num\n min_num = min(num,min_num)",
"num",
"a",
"if max_num == num-min_num:\n ans+=1\n elif max_num < num-min_num:\n ans = 1\n max_num = num-min_num\n ",
"max_num == num-min_num",
"max_num",
"num-min_num",
"num",
"min_num",
"ans+=1",
"ans",
"1",
"elif max_num < num-min_num:\n ans = 1\n max_num = num-min_num\n ",
"max_num < num-min_num",
"max_num",
"num-min_num",
"num",
"min_num",
"ans = 1",
"ans",
"1",
"max_num = num-min_num",
"max_num",
"num-min_num",
"num",
"min_num",
"min_num = min(num,min_num)",
"min_num",
"min(num,min_num)",
"min",
"num",
"min_num",
"print(ans)",
"print",
"ans",
"min_num = inf",
"inf",
"min_num",
"ir = lambda: int(sr())",
"lambda: int(sr())",
"ir",
"t = lr()",
"lr()",
"t",
"def power(a, n, mod):\n x = 1\n while n:\n if n & 1:\n x *= a % mod\n n >>= 1\n a *= a % mod\n return x % mod\n\n\n# n*(n-1)*...*(l+1)*l",
"def power(a, n, mod):\n x = 1\n while n:\n if n & 1:\n x *= a % mod\n n >>= 1\n a *= a % mod\n return x % mod\n\n\n# n*(n-1)*...*(l+1)*l",
"power",
"lr = lambda: list(map(int, sr().split()))",
"lambda: list(map(int, sr().split()))",
"lr",
"n,t = lr()",
"lr()",
"n",
"ans = 0",
"0",
"ans",
"min_num = min(num,min_num)",
"min(num,min_num)",
"min_num",
"def kaijo(n, l, mod):\n if n == 0:\n return 1\n a = n\n tmp = n - 1\n while (tmp >= l):\n a = a * tmp % mod\n tmp -= 1\n return a",
"def kaijo(n, l, mod):\n if n == 0:\n return 1\n a = n\n tmp = n - 1\n while (tmp >= l):\n a = a * tmp % mod\n tmp -= 1\n return a",
"kaijo",
"inf = 10 ** 18",
"10 ** 18",
"inf",
"sr = lambda: input()",
"lambda: input()",
"sr",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"a = lr()",
"lr()",
"a",
"max_num = 0",
"0",
"max_num",
"ans+=1",
"1",
"ans",
"def factorization(n):\n arr = []\n temp = n\n if n == 1:\n return arr\n\n for i in range(2, int(-(-n ** 0.5 // 1)) + 1):\n if temp % i == 0:\n cnt = 0\n while temp % i == 0:\n cnt += 1\n temp //= i\n arr.append([i, cnt])\n\n if temp != 1:\n arr.append([temp, 1])\n\n if arr == []:\n arr.append([n, 1])\n\n return arr\n\n\n# a^n",
"def factorization(n):\n arr = []\n temp = n\n if n == 1:\n return arr\n\n for i in range(2, int(-(-n ** 0.5 // 1)) + 1):\n if temp % i == 0:\n cnt = 0\n while temp % i == 0:\n cnt += 1\n temp //= i\n arr.append([i, cnt])\n\n if temp != 1:\n arr.append([temp, 1])\n\n if arr == []:\n arr.append([n, 1])\n\n return arr\n\n\n# a^n",
"factorization",
"max_num = num-min_num",
"num-min_num",
"max_num",
"ans = 1",
"1",
"ans"
] |
# input()
# int(input())
# map(int, input().split())
# list(map(int, input().split()))
# list(map(int, list(input()))) # スペースがない数字リストを読み込み
import math
import fractions
import sys
import bisect
import heapq # 優先度付きキュー(最小値取り出し)
import collections
from collections import Counter
from collections import deque
import pprint
import itertools
sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""
def factorization(n):
arr = []
temp = n
if n == 1:
return arr
for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == []:
arr.append([n, 1])
return arr
# a^n
def power(a, n, mod):
x = 1
while n:
if n & 1:
x *= a % mod
n >>= 1
a *= a % mod
return x % mod
# n*(n-1)*...*(l+1)*l
def kaijo(n, l, mod):
if n == 0:
return 1
a = n
tmp = n - 1
while (tmp >= l):
a = a * tmp % mod
tmp -= 1
return a
inf = 10 ** 18
mod = 10 ** 9 + 7
n,t = lr()
a = lr()
min_num = inf
ans = 0
max_num = 0
for num in a:
if max_num == num-min_num:
ans+=1
elif max_num < num-min_num:
ans = 1
max_num = num-min_num
min_num = min(num,min_num)
print(ans)
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
39,
18,
13,
2,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
2,
40,
13,
17,
0,
13,
4,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
18,
13,
39,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
40,
18,
13,
13,
2,
13,
17,
2,
18,
13,
2,
13,
17,
2,
13,
17,
0,
18,
13,
13,
17,
0,
13,
17,
28,
13,
4,
18,
13,
13,
14,
2,
2,
18,
13,
13,
17,
2,
13,
13,
0,
13,
13,
4,
13,
18,
13,
13,
10,
4,
13,
10,
39,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13
] |
[
[
149,
3
],
[
149,
12
],
[
167,
14
],
[
170,
26
],
[
168,
28
],
[
138,
30
],
[
140,
33
],
[
168,
36
],
[
138,
38
],
[
42,
41
],
[
138,
45
],
[
155,
47
],
[
168,
49
],
[
41,
52
],
[
161,
55
],
[
171,
58
],
[
162,
58
],
[
156,
59
],
[
141,
62
],
[
162,
64
],
[
171,
64
],
[
143,
66
],
[
141,
68
],
[
158,
72
],
[
78,
77
],
[
138,
82
],
[
164,
85
],
[
168,
90
],
[
77,
91
],
[
150,
93
],
[
144,
97
],
[
141,
97
],
[
77,
99
],
[
150,
102
],
[
108,
105
],
[
159,
106
],
[
165,
107
],
[
152,
110
],
[
114,
113
],
[
159,
116
],
[
159,
122
],
[
113,
123
],
[
113,
126
],
[
153,
127
],
[
147,
127
],
[
146,
129
],
[
113,
130
],
[
159,
134
],
[
147,
135
],
[
153,
135
],
[
149,
138
],
[
140,
141
],
[
143,
144
],
[
113,
146
],
[
146,
147
],
[
149,
150
],
[
152,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
],
[
170,
171
]
] |
[
"from collections import defaultdict\n\nN,T=map(int,input().split())\nA=list(map(int,input().split()))\n\nm=A[N-1]\nmaxlist=[A[N-1]]\nfor i in range(1,N):\n a=A[-i-1]\n m=max(m,a)\n maxlist.append(m)\n\nmaxlist=maxlist[::-1]\n\nbenefit=defaultdict(int)\n\nfor i in range(0,N-1):\n b=-A[i]*(T//2)+maxlist[i+1]*(T//2)\n benefit[b]+=1\n\nans=0\nfor key in benefit.keys():\n if benefit[key]>0 and key>ans:\n ans=key\n\nprint(benefit[ans])",
"from collections import defaultdict",
"N,T=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"m=A[N-1]",
"m",
"A[N-1]",
"A",
"N-1",
"N",
"1",
"maxlist=[A[N-1]]",
"maxlist",
"[A[N-1]]",
"A[N-1]",
"A",
"N-1",
"N",
"1",
"for i in range(1,N):\n a=A[-i-1]\n m=max(m,a)\n maxlist.append(m)",
"i",
"range(1,N)",
"range",
"1",
"N",
"a=A[-i-1]",
"a",
"A[-i-1]",
"A",
"-i-1",
"-i",
"i",
"1",
"m=max(m,a)",
"m",
"max(m,a)",
"max",
"m",
"a",
"maxlist.append(m)",
"maxlist.append",
"maxlist",
"append",
"m",
"maxlist=maxlist[::-1]",
"maxlist",
"maxlist[::-1]",
"maxlist",
"::-1",
"-1",
"benefit=defaultdict(int)",
"benefit",
"defaultdict(int)",
"defaultdict",
"int",
"for i in range(0,N-1):\n b=-A[i]*(T//2)+maxlist[i+1]*(T//2)\n benefit[b]+=1",
"i",
"range(0,N-1)",
"range",
"0",
"N-1",
"N",
"1",
"b=-A[i]*(T//2)+maxlist[i+1]*(T//2)",
"b",
"-A[i]*(T//2)+maxlist[i+1]*(T//2)",
"-A[i]*(T//2)",
"-A[i]",
"A[i]",
"A",
"i",
"T//2",
"T",
"2",
"maxlist[i+1]*(T//2)",
"maxlist[i+1]",
"maxlist",
"i+1",
"i",
"1",
"T//2",
"T",
"2",
"benefit[b]+=1",
"benefit[b]",
"benefit",
"b",
"1",
"ans=0",
"ans",
"0",
"for key in benefit.keys():\n if benefit[key]>0 and key>ans:\n ans=key",
"key",
"benefit.keys()",
"benefit.keys",
"benefit",
"keys",
"if benefit[key]>0 and key>ans:\n ans=key",
"benefit[key]>0 and key>ans",
"benefit[key]>0",
"benefit[key]",
"benefit",
"key",
"0",
"key>ans",
"key",
"ans",
"ans=key",
"ans",
"key",
"print(benefit[ans])",
"print",
"benefit[ans]",
"benefit",
"ans",
"N,T=map(int,input().split())",
"map(int,input().split())",
"N",
"maxlist=[A[N-1]]",
"[A[N-1]]",
"maxlist",
"maxlist=maxlist[::-1]",
"maxlist[::-1]",
"maxlist",
"ans=key",
"key",
"ans",
"T=map(int,input().split())",
"map(int,input().split())",
"T",
"ans=0",
"0",
"ans",
"a=A[-i-1]",
"A[-i-1]",
"a",
"benefit=defaultdict(int)",
"defaultdict(int)",
"benefit",
"m=max(m,a)",
"max(m,a)",
"m",
"b=-A[i]*(T//2)+maxlist[i+1]*(T//2)",
"-A[i]*(T//2)+maxlist[i+1]*(T//2)",
"b",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"m=A[N-1]",
"A[N-1]",
"m"
] |
from collections import defaultdict
N,T=map(int,input().split())
A=list(map(int,input().split()))
m=A[N-1]
maxlist=[A[N-1]]
for i in range(1,N):
a=A[-i-1]
m=max(m,a)
maxlist.append(m)
maxlist=maxlist[::-1]
benefit=defaultdict(int)
for i in range(0,N-1):
b=-A[i]*(T//2)+maxlist[i+1]*(T//2)
benefit[b]+=1
ans=0
for key in benefit.keys():
if benefit[key]>0 and key>ans:
ans=key
print(benefit[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,
18,
13,
39,
17,
0,
13,
39,
0,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
18,
13,
13,
39,
13,
13,
0,
13,
39,
28,
13,
13,
4,
13,
13,
18,
13,
39,
17,
4,
18,
13,
13,
39,
2,
18,
13,
17,
13,
18,
13,
17,
4,
18,
13,
13,
0,
13,
17,
0,
13,
18,
18,
13,
17,
17,
15,
0,
13,
4,
13,
28,
13,
13,
13,
14,
40,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
39,
13
] |
[
[
136,
2
],
[
136,
11
],
[
157,
13
],
[
160,
25
],
[
158,
27
],
[
139,
31
],
[
148,
34
],
[
133,
37
],
[
161,
44
],
[
149,
48
],
[
152,
48
],
[
151,
50
],
[
154,
53
],
[
137,
56
],
[
140,
61
],
[
163,
67
],
[
158,
74
],
[
140,
76
],
[
164,
81
],
[
152,
86
],
[
149,
86
],
[
152,
90
],
[
149,
90
],
[
164,
94
],
[
98,
97
],
[
142,
100
],
[
164,
103
],
[
145,
108
],
[
143,
118
],
[
152,
118
],
[
149,
118
],
[
146,
121
],
[
146,
128
],
[
136,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
],
[
142,
143
],
[
145,
146
],
[
148,
149
],
[
151,
152
],
[
154,
155
],
[
157,
158
],
[
160,
161
],
[
163,
164
]
] |
[
"\n\nN,T = map(int, input().split())\nAs = list(map(int, input().split()))\nAsR = As[::-1]\nmxs = []\nmx = 0\nind = 0\nfor i, a in enumerate(AsR):\n if a > mx:\n mx = a\n ind = N-i-1\n mxs.append((mx,ind))\npairs = []\nfor a,mx in zip(As,mxs[::-1]):\n # print(mx[0]-a,mx[1])\n pairs.append((mx[0]-a,mx[1]))\npairs.sort(reverse=True)\nmx = pairs[0][0]\nfrom collections import defaultdict\nans = set()\nfor x, i in pairs:\n if x != mx:break\n ans.add(i)\nprint(len(ans))",
"N,T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"As = list(map(int, input().split()))",
"As",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"AsR = As[::-1]",
"AsR",
"As[::-1]",
"As",
"::-1",
"-1",
"mxs = []",
"mxs",
"[]",
"mx = 0",
"mx",
"0",
"ind = 0",
"ind",
"0",
"for i, a in enumerate(AsR):\n if a > mx:\n mx = a\n ind = N-i-1\n mxs.append((mx,ind))",
"i",
"a",
"enumerate(AsR)",
"enumerate",
"AsR",
"if a > mx:\n mx = a\n ind = N-i-1\n ",
"a > mx",
"a",
"mx",
"mx = a",
"mx",
"a",
"ind = N-i-1",
"ind",
"N-i-1",
"N-i",
"N",
"i",
"1",
"mxs.append((mx,ind))",
"mxs.append",
"mxs",
"append",
"(mx,ind)",
"mx",
"ind",
"pairs = []",
"pairs",
"[]",
"for a,mx in zip(As,mxs[::-1]):\n # print(mx[0]-a,mx[1])\n pairs.append((mx[0]-a,mx[1]))",
"a",
"mx",
"zip(As,mxs[::-1])",
"zip",
"As",
"mxs[::-1]",
"mxs",
"::-1",
"-1",
"pairs.append((mx[0]-a,mx[1]))",
"pairs.append",
"pairs",
"append",
"(mx[0]-a,mx[1])",
"mx[0]-a",
"mx[0]",
"mx",
"0",
"a",
"mx[1]",
"mx",
"1",
"pairs.sort(reverse=True)",
"pairs.sort",
"pairs",
"sort",
"reverse=True",
"reverse",
"True",
"mx = pairs[0][0]",
"mx",
"pairs[0][0]",
"[0]",
"pairs",
"0",
"0",
"from collections import defaultdict",
"ans = set()",
"ans",
"set()",
"set",
"for x, i in pairs:\n if x != mx:break\n ans.add(i)",
"x",
"i",
"pairs",
"if x != mx:break\n ",
"x != mx",
"x",
"mx",
"ans.add(i)",
"ans.add",
"ans",
"add",
"i",
"print(len(ans))",
"print",
"len(ans)",
"len",
"ans",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"ind = 0",
"0",
"ind",
"N,T = map(int, input().split())",
"map(int, input().split())",
"N",
"mxs = []",
"[]",
"mxs",
"mx = pairs[0][0]",
"pairs[0][0]",
"mx",
"ans = set()",
"set()",
"ans",
"mx = 0",
"0",
"mx",
"mx = a",
"a",
"mx",
"ind = N-i-1",
"N-i-1",
"ind",
"As = list(map(int, input().split()))",
"list(map(int, input().split()))",
"As",
"AsR = As[::-1]",
"As[::-1]",
"AsR",
"pairs = []",
"[]",
"pairs"
] |
N,T = map(int, input().split())
As = list(map(int, input().split()))
AsR = As[::-1]
mxs = []
mx = 0
ind = 0
for i, a in enumerate(AsR):
if a > mx:
mx = a
ind = N-i-1
mxs.append((mx,ind))
pairs = []
for a,mx in zip(As,mxs[::-1]):
# print(mx[0]-a,mx[1])
pairs.append((mx[0]-a,mx[1]))
pairs.sort(reverse=True)
mx = pairs[0][0]
from collections import defaultdict
ans = set()
for x, i in pairs:
if x != mx:break
ans.add(i)
print(len(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,
39,
18,
13,
17,
13,
39,
18,
13,
17,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
18,
13,
13,
4,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
18,
13,
2,
2,
13,
17,
13,
0,
13,
18,
13,
39,
17,
0,
13,
17,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
39,
18,
13,
2,
13,
17,
18,
13,
13,
14,
2,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
4,
18,
13,
13,
39,
18,
13,
2,
13,
17,
18,
13,
13,
4,
13,
4,
13,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
188,
2
],
[
188,
11
],
[
185,
13
],
[
164,
25
],
[
186,
28
],
[
173,
30
],
[
186,
33
],
[
37,
36
],
[
189,
40
],
[
165,
43
],
[
165,
48
],
[
36,
50
],
[
186,
53
],
[
36,
54
],
[
174,
57
],
[
174,
62
],
[
36,
64
],
[
186,
67
],
[
189,
70
],
[
36,
72
],
[
182,
74
],
[
174,
76
],
[
191,
80
],
[
176,
83
],
[
88,
87
],
[
189,
91
],
[
192,
95
],
[
168,
95
],
[
183,
98
],
[
174,
98
],
[
87,
100
],
[
165,
103
],
[
87,
104
],
[
167,
106
],
[
183,
109
],
[
174,
109
],
[
87,
111
],
[
165,
114
],
[
87,
115
],
[
179,
117
],
[
180,
122
],
[
177,
122
],
[
183,
126
],
[
174,
126
],
[
87,
128
],
[
165,
131
],
[
87,
132
],
[
192,
135
],
[
168,
135
],
[
183,
138
],
[
174,
138
],
[
87,
140
],
[
165,
143
],
[
87,
144
],
[
177,
147
],
[
180,
147
],
[
183,
151
],
[
174,
151
],
[
87,
153
],
[
165,
156
],
[
87,
157
],
[
180,
162
],
[
177,
162
],
[
164,
165
],
[
167,
168
],
[
188,
171
],
[
173,
174
],
[
176,
177
],
[
179,
180
],
[
182,
183
],
[
185,
186
],
[
188,
189
],
[
191,
192
]
] |
[
"# 自分をiとしたとき自分よりあとのjと比べj-iが最大になる箇所の数を数える、という感じ\n# （Tは不要？） b\n# A[i]はユニークなので\n# 左から最小、右から最大を保存?（なんでこれが浮かんだ？）\n# 7 10 4 5 9 3 6 8 2 1\n# 最小: 7 7 4 4 4 3 3 3 2 1\n# 最大: 10 10 9 9 9 8 8 8 2 1\n# dif maxの数になる\n# だるそうなので集合でやる（ユニークなので）\nn, t = map(int, input().split())\narr = list(map(int, input().split()))\nmin_from_left, max_from_right = [arr[0]], [arr[-1]]\nfor i in range(1, n):\n min_from_left.append(min(min_from_left[i - 1], arr[i]))\n max_from_right.append(max(max_from_right[i - 1], arr[n - 1 - i]))\n\nmax_from_right = max_from_right[::-1]\nmax_dif = 0\ndifs = set()\nfor i in range(n - 1):\n if max_dif < max_from_right[i + 1] - min_from_left[i]:\n max_dif = max_from_right[i + 1] - min_from_left[i]\n difs = set()\n difs.add((max_from_right[i + 1], min_from_left[i]))\n elif max_dif == max_from_right[i + 1] - min_from_left[i]:\n difs.add((max_from_right[i + 1], min_from_left[i]))\nprint(len(difs))",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"arr = list(map(int, input().split()))",
"arr",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_from_left, max_from_right = [arr[0]], [arr[-1]]",
"min_from_left",
"[arr[0]]",
"arr[0]",
"arr",
"0",
"max_from_right",
"[arr[-1]]",
"arr[-1]",
"arr",
"-1",
"for i in range(1, n):\n min_from_left.append(min(min_from_left[i - 1], arr[i]))\n max_from_right.append(max(max_from_right[i - 1], arr[n - 1 - i]))",
"i",
"range(1, n)",
"range",
"1",
"n",
"min_from_left.append(min(min_from_left[i - 1], arr[i]))",
"min_from_left.append",
"min_from_left",
"append",
"min(min_from_left[i - 1], arr[i])",
"min",
"min_from_left[i - 1]",
"min_from_left",
"i - 1",
"i",
"1",
"arr[i]",
"arr",
"i",
"max_from_right.append(max(max_from_right[i - 1], arr[n - 1 - i]))",
"max_from_right.append",
"max_from_right",
"append",
"max(max_from_right[i - 1], arr[n - 1 - i])",
"max",
"max_from_right[i - 1]",
"max_from_right",
"i - 1",
"i",
"1",
"arr[n - 1 - i]",
"arr",
"n - 1 - i",
"n - 1",
"n",
"1",
"i",
"max_from_right = max_from_right[::-1]",
"max_from_right",
"max_from_right[::-1]",
"max_from_right",
"::-1",
"-1",
"max_dif = 0",
"max_dif",
"0",
"difs = set()",
"difs",
"set()",
"set",
"for i in range(n - 1):\n if max_dif < max_from_right[i + 1] - min_from_left[i]:\n max_dif = max_from_right[i + 1] - min_from_left[i]\n difs = set()\n difs.add((max_from_right[i + 1], min_from_left[i]))\n elif max_dif == max_from_right[i + 1] - min_from_left[i]:\n difs.add((max_from_right[i + 1], min_from_left[i]))",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if max_dif < max_from_right[i + 1] - min_from_left[i]:\n max_dif = max_from_right[i + 1] - min_from_left[i]\n difs = set()\n difs.add((max_from_right[i + 1], min_from_left[i]))\n elif max_dif == max_from_right[i + 1] - min_from_left[i]:\n difs.add((max_from_right[i + 1], min_from_left[i]))",
"max_dif < max_from_right[i + 1] - min_from_left[i]",
"max_dif",
"max_from_right[i + 1] - min_from_left[i]",
"max_from_right[i + 1]",
"max_from_right",
"i + 1",
"i",
"1",
"min_from_left[i]",
"min_from_left",
"i",
"max_dif = max_from_right[i + 1] - min_from_left[i]",
"max_dif",
"max_from_right[i + 1] - min_from_left[i]",
"max_from_right[i + 1]",
"max_from_right",
"i + 1",
"i",
"1",
"min_from_left[i]",
"min_from_left",
"i",
"difs = set()",
"difs",
"set()",
"set",
"difs.add((max_from_right[i + 1], min_from_left[i]))",
"difs.add",
"difs",
"add",
"(max_from_right[i + 1], min_from_left[i])",
"max_from_right[i + 1]",
"max_from_right",
"i + 1",
"i",
"1",
"min_from_left[i]",
"min_from_left",
"i",
"elif max_dif == max_from_right[i + 1] - min_from_left[i]:\n difs.add((max_from_right[i + 1], min_from_left[i]))",
"max_dif == max_from_right[i + 1] - min_from_left[i]",
"max_dif",
"max_from_right[i + 1] - min_from_left[i]",
"max_from_right[i + 1]",
"max_from_right",
"i + 1",
"i",
"1",
"min_from_left[i]",
"min_from_left",
"i",
"difs.add((max_from_right[i + 1], min_from_left[i]))",
"difs.add",
"difs",
"add",
"(max_from_right[i + 1], min_from_left[i])",
"max_from_right[i + 1]",
"max_from_right",
"i + 1",
"i",
"1",
"min_from_left[i]",
"min_from_left",
"i",
"print(len(difs))",
"print",
"len(difs)",
"len",
"difs",
"min_from_left, max_from_right = [arr[0]], [arr[-1]]",
"[arr[0]]",
"min_from_left",
"max_dif = max_from_right[i + 1] - min_from_left[i]",
"max_from_right[i + 1] - min_from_left[i]",
"max_dif",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"max_from_right = [arr[0]], [arr[-1]]",
"[arr[-1]]",
"max_from_right",
"difs = set()",
"set()",
"difs",
"difs = set()",
"set()",
"difs",
"max_from_right = max_from_right[::-1]",
"max_from_right[::-1]",
"max_from_right",
"arr = list(map(int, input().split()))",
"list(map(int, input().split()))",
"arr",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"max_dif = 0",
"0",
"max_dif"
] |
# 自分をiとしたとき自分よりあとのjと比べj-iが最大になる箇所の数を数える、という感じ
# （Tは不要？） b
# A[i]はユニークなので
# 左から最小、右から最大を保存?（なんでこれが浮かんだ？）
# 7 10 4 5 9 3 6 8 2 1
# 最小: 7 7 4 4 4 3 3 3 2 1
# 最大: 10 10 9 9 9 8 8 8 2 1
# dif maxの数になる
# だるそうなので集合でやる（ユニークなので）
n, t = map(int, input().split())
arr = list(map(int, input().split()))
min_from_left, max_from_right = [arr[0]], [arr[-1]]
for i in range(1, n):
min_from_left.append(min(min_from_left[i - 1], arr[i]))
max_from_right.append(max(max_from_right[i - 1], arr[n - 1 - i]))
max_from_right = max_from_right[::-1]
max_dif = 0
difs = set()
for i in range(n - 1):
if max_dif < max_from_right[i + 1] - min_from_left[i]:
max_dif = max_from_right[i + 1] - min_from_left[i]
difs = set()
difs.add((max_from_right[i + 1], min_from_left[i]))
elif max_dif == max_from_right[i + 1] - min_from_left[i]:
difs.add((max_from_right[i + 1], min_from_left[i]))
print(len(difs))
|
[
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,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
2,
18,
13,
13,
13,
17,
0,
13,
4,
13,
13,
18,
13,
13,
4,
13,
18,
13,
4,
13,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
78,
3
],
[
78,
12
],
[
69,
14
],
[
81,
26
],
[
66,
31
],
[
70,
33
],
[
37,
36
],
[
76,
40
],
[
49,
42
],
[
82,
43
],
[
70,
46
],
[
36,
47
],
[
67,
48
],
[
73,
48
],
[
72,
51
],
[
67,
54
],
[
73,
54
],
[
70,
56
],
[
36,
57
],
[
82,
61
],
[
82,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
78,
76
],
[
78,
79
],
[
81,
82
]
] |
[
"from collections import defaultdict\n\nN, T = map(int, input().split())\nA = tuple(map(int, input().split()))\n\nB = defaultdict(int)\nam = A[0]\nfor i in range(1, N):\n B[A[i] - am] += 1\n am = min(am, A[i])\n\nprint(B[max(B)])",
"from collections import defaultdict",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = tuple(map(int, input().split()))",
"A",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"B = defaultdict(int)",
"B",
"defaultdict(int)",
"defaultdict",
"int",
"am = A[0]",
"am",
"A[0]",
"A",
"0",
"for i in range(1, N):\n B[A[i] - am] += 1\n am = min(am, A[i])",
"i",
"range(1, N)",
"range",
"1",
"N",
"B[A[i] - am] += 1",
"B[A[i] - am]",
"B",
"A[i] - am",
"A[i]",
"A",
"i",
"am",
"1",
"am = min(am, A[i])",
"am",
"min(am, A[i])",
"min",
"am",
"A[i]",
"A",
"i",
"print(B[max(B)])",
"print",
"B[max(B)]",
"B",
"max(B)",
"max",
"B",
"am = A[0]",
"A[0]",
"am",
"A = tuple(map(int, input().split()))",
"tuple(map(int, input().split()))",
"A",
"am = min(am, A[i])",
"min(am, A[i])",
"am",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"B = defaultdict(int)",
"defaultdict(int)",
"B"
] |
from collections import defaultdict
N, T = map(int, input().split())
A = tuple(map(int, input().split()))
B = defaultdict(int)
am = A[0]
for i in range(1, N):
B[A[i] - am] += 1
am = min(am, A[i])
print(B[max(B)])
|
[
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,
17,
0,
13,
13,
0,
13,
18,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
14,
40,
2,
18,
13,
13,
13,
13,
0,
13,
2,
18,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] |
[
[
114,
2
],
[
114,
11
],
[
90,
13
],
[
27,
26
],
[
103,
29
],
[
108,
33
],
[
96,
36
],
[
91,
38
],
[
105,
41
],
[
45,
44
],
[
103,
47
],
[
91,
51
],
[
44,
52
],
[
97,
53
],
[
94,
53
],
[
93,
55
],
[
91,
57
],
[
44,
58
],
[
91,
63
],
[
44,
64
],
[
94,
65
],
[
97,
65
],
[
106,
66
],
[
100,
66
],
[
99,
68
],
[
91,
71
],
[
44,
72
],
[
94,
73
],
[
97,
73
],
[
109,
76
],
[
100,
78
],
[
106,
78
],
[
111,
80
],
[
109,
83
],
[
100,
85
],
[
106,
85
],
[
112,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
114,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
]
] |
[
"n,t=map(int,input().split())\na=list(map(int,input().split()))\nb=[0 for i in range(n)]\nmi=a[0]\nsa=0\nfor i in range(n):\n if a[i]<mi:\n mi=a[i]\n if a[i]-mi>=sa:\n sa=a[i]-mi\n b.append(sa)\nans=b.count(sa)\nprint(ans)",
"n,t=map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"0 for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"0",
"b=[0 for i in range(n)]",
"b",
"[0 for i in range(n)]",
"mi=a[0]",
"mi",
"a[0]",
"a",
"0",
"sa=0",
"sa",
"0",
"for i in range(n):\n if a[i]<mi:\n mi=a[i]\n if a[i]-mi>=sa:\n sa=a[i]-mi\n b.append(sa)",
"i",
"range(n)",
"range",
"n",
"if a[i]<mi:\n mi=a[i]\n ",
"a[i]<mi",
"a[i]",
"a",
"i",
"mi",
"mi=a[i]",
"mi",
"a[i]",
"a",
"i",
"if a[i]-mi>=sa:\n sa=a[i]-mi\n b.append(sa)",
"a[i]-mi>=sa",
"a[i]-mi",
"a[i]",
"a",
"i",
"mi",
"sa",
"sa=a[i]-mi",
"sa",
"a[i]-mi",
"a[i]",
"a",
"i",
"mi",
"b.append(sa)",
"b.append",
"b",
"append",
"sa",
"ans=b.count(sa)",
"ans",
"b.count(sa)",
"b.count",
"b",
"count",
"sa",
"print(ans)",
"print",
"ans",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"mi=a[i]",
"a[i]",
"mi",
"mi=a[0]",
"a[0]",
"mi",
"sa=a[i]-mi",
"a[i]-mi",
"sa",
"n,t=map(int,input().split())",
"map(int,input().split())",
"n",
"sa=0",
"0",
"sa",
"b=[0 for i in range(n)]",
"[0 for i in range(n)]",
"b",
"ans=b.count(sa)",
"b.count(sa)",
"ans",
"t=map(int,input().split())",
"map(int,input().split())",
"t"
] |
n,t=map(int,input().split())
a=list(map(int,input().split()))
b=[0 for i in range(n)]
mi=a[0]
sa=0
for i in range(n):
if a[i]<mi:
mi=a[i]
if a[i]-mi>=sa:
sa=a[i]-mi
b.append(sa)
ans=b.count(sa)
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,
17,
0,
13,
17,
0,
13,
17,
28,
13,
13,
14,
2,
13,
13,
0,
13,
13,
9,
14,
2,
2,
13,
13,
13,
0,
13,
17,
9,
14,
2,
2,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
9,
4,
13,
2,
13,
17,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
95,
2
],
[
95,
11
],
[
98,
13
],
[
101,
25
],
[
89,
30
],
[
92,
33
],
[
37,
36
],
[
99,
36
],
[
36,
40
],
[
102,
41
],
[
78,
41
],
[
77,
43
],
[
36,
44
],
[
36,
49
],
[
102,
50
],
[
78,
50
],
[
90,
51
],
[
84,
51
],
[
80,
53
],
[
36,
59
],
[
78,
60
],
[
102,
60
],
[
90,
61
],
[
84,
61
],
[
83,
63
],
[
36,
65
],
[
78,
66
],
[
102,
66
],
[
104,
68
],
[
105,
74
],
[
81,
74
],
[
93,
74
],
[
36,
77
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
95,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
]
] |
[
"n, t = map(int, input().split())\n\nalist = list(map(int, input().split()))\n\nlowest = float('INF')\n\ngain = 0\n\nrepeat = 0\n\nfor al in alist:\n if al < lowest:\n lowest = al\n continue\n else:\n if al - lowest == gain:\n repeat += 1\n continue\n if al - lowest > gain:\n gain = al - lowest\n repeat = 0\n continue\n\nprint(repeat + 1)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"alist = list(map(int, input().split()))",
"alist",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"lowest = float('INF')",
"lowest",
"float('INF')",
"float",
"'INF'",
"gain = 0",
"gain",
"0",
"repeat = 0",
"repeat",
"0",
"for al in alist:\n if al < lowest:\n lowest = al\n continue\n else:\n if al - lowest == gain:\n repeat += 1\n continue\n if al - lowest > gain:\n gain = al - lowest\n repeat = 0\n continue",
"al",
"alist",
"if al < lowest:\n lowest = al\n continue\n else:\n if al - lowest == gain:\n repeat += 1\n continue\n if al - lowest > gain:\n gain = al - lowest\n repeat = 0\n continue",
"al < lowest",
"al",
"lowest",
"lowest = al",
"lowest",
"al",
"continue",
"if al - lowest == gain:\n repeat += 1\n continue\n ",
"al - lowest == gain",
"al - lowest",
"al",
"lowest",
"gain",
"repeat += 1",
"repeat",
"1",
"continue",
"if al - lowest > gain:\n gain = al - lowest\n repeat = 0\n continue",
"al - lowest > gain",
"al - lowest",
"al",
"lowest",
"gain",
"gain = al - lowest",
"gain",
"al - lowest",
"al",
"lowest",
"repeat = 0",
"repeat",
"0",
"continue",
"print(repeat + 1)",
"print",
"repeat + 1",
"repeat",
"1",
"lowest = al",
"al",
"lowest",
"repeat += 1",
"1",
"repeat",
"gain = al - lowest",
"al - lowest",
"gain",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"gain = 0",
"0",
"gain",
"repeat = 0",
"0",
"repeat",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"alist = list(map(int, input().split()))",
"list(map(int, input().split()))",
"alist",
"lowest = float('INF')",
"float('INF')",
"lowest",
"repeat = 0",
"0",
"repeat"
] |
n, t = map(int, input().split())
alist = list(map(int, input().split()))
lowest = float('INF')
gain = 0
repeat = 0
for al in alist:
if al < lowest:
lowest = al
continue
else:
if al - lowest == gain:
repeat += 1
continue
if al - lowest > gain:
gain = al - lowest
repeat = 0
continue
print(repeat + 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,
39,
0,
13,
18,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
13,
4,
18,
13,
13,
2,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] |
[
[
70,
2
],
[
70,
11
],
[
58,
13
],
[
73,
25
],
[
64,
28
],
[
59,
30
],
[
34,
33
],
[
59,
33
],
[
61,
36
],
[
33,
39
],
[
65,
40
],
[
62,
40
],
[
74,
43
],
[
33,
46
],
[
62,
47
],
[
65,
47
],
[
74,
52
],
[
74,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
70,
68
],
[
70,
71
],
[
73,
74
]
] |
[
"N,T = map(int,input().split())\nA = list(map(int,input().split()))\nv = []\n\nm = A[0]\nfor i in A:\n m = min(i,m)\n v.append(i-m)\n\nprint(v.count(max(v)))",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"v = []",
"v",
"[]",
"m = A[0]",
"m",
"A[0]",
"A",
"0",
"for i in A:\n m = min(i,m)\n v.append(i-m)",
"i",
"A",
"m = min(i,m)",
"m",
"min(i,m)",
"min",
"i",
"m",
"v.append(i-m)",
"v.append",
"v",
"append",
"i-m",
"i",
"m",
"print(v.count(max(v)))",
"print",
"v.count(max(v))",
"v.count",
"v",
"count",
"max(v)",
"max",
"v",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"m = min(i,m)",
"min(i,m)",
"m",
"m = A[0]",
"A[0]",
"m",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"v = []",
"[]",
"v"
] |
N,T = map(int,input().split())
A = list(map(int,input().split()))
v = []
m = A[0]
for i in A:
m = min(i,m)
v.append(i-m)
print(v.count(max(v)))
|
[
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,
17,
0,
13,
39,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
13,
13,
13,
0,
13,
4,
13,
13,
4,
13,
4,
18,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
18,
13
] |
[
[
83,
2
],
[
83,
11
],
[
77,
13
],
[
92,
25
],
[
81,
27
],
[
86,
30
],
[
98,
33
],
[
78,
35
],
[
39,
38
],
[
81,
41
],
[
78,
45
],
[
38,
46
],
[
99,
47
],
[
96,
47
],
[
95,
49
],
[
78,
51
],
[
38,
52
],
[
87,
55
],
[
78,
60
],
[
38,
61
],
[
96,
62
],
[
99,
62
],
[
93,
63
],
[
89,
65
],
[
87,
68
],
[
87,
73
],
[
90,
75
],
[
77,
78
],
[
83,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
]
] |
[
"n,t = map(int,input().split())\na = list(map(int,input().split()))\n\n#リンゴを買う個数\napple = n//2\n\n#街iで売った時の利益\nb = []\nmi = a[0]\nfor i in range(n):\n if a[i] < mi:\n mi = a[i]\n b.append((a[i]-mi)*apple)\n\nma = max(b)\n\nprint(b.count(ma))",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"apple = n//2",
"apple",
"n//2",
"n",
"2",
"b = []",
"b",
"[]",
"mi = a[0]",
"mi",
"a[0]",
"a",
"0",
"for i in range(n):\n if a[i] < mi:\n mi = a[i]\n b.append((a[i]-mi)*apple)",
"i",
"range(n)",
"range",
"n",
"if a[i] < mi:\n mi = a[i]\n ",
"a[i] < mi",
"a[i]",
"a",
"i",
"mi",
"mi = a[i]",
"mi",
"a[i]",
"a",
"i",
"b.append((a[i]-mi)*apple)",
"b.append",
"b",
"append",
"(a[i]-mi)*apple",
"a[i]-mi",
"a[i]",
"a",
"i",
"mi",
"apple",
"ma = max(b)",
"ma",
"max(b)",
"max",
"b",
"print(b.count(ma))",
"print",
"b.count(ma)",
"b.count",
"b",
"count",
"ma",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"n,t = map(int,input().split())",
"map(int,input().split())",
"n",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"b = []",
"[]",
"b",
"ma = max(b)",
"max(b)",
"ma",
"apple = n//2",
"n//2",
"apple",
"mi = a[i]",
"a[i]",
"mi",
"mi = a[0]",
"a[0]",
"mi"
] |
n,t = map(int,input().split())
a = list(map(int,input().split()))
#リンゴを買う個数
apple = n//2
#街iで売った時の利益
b = []
mi = a[0]
for i in range(n):
if a[i] < mi:
mi = a[i]
b.append((a[i]-mi)*apple)
ma = max(b)
print(b.count(ma))
|
[
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,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
14,
2,
13,
2,
18,
13,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
17,
14,
2,
13,
2,
18,
13,
13,
13,
14,
40,
13,
0,
13,
17,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] |
[
[
150,
2
],
[
150,
11
],
[
147,
13
],
[
138,
25
],
[
123,
28
],
[
148,
30
],
[
34,
33
],
[
130,
36
],
[
124,
39
],
[
121,
39
],
[
148,
41
],
[
33,
42
],
[
120,
44
],
[
148,
46
],
[
33,
47
],
[
139,
50
],
[
154,
50
],
[
148,
53
],
[
33,
54
],
[
121,
55
],
[
124,
55
],
[
153,
57
],
[
148,
60
],
[
33,
61
],
[
121,
62
],
[
124,
62
],
[
114,
64
],
[
117,
67
],
[
135,
70
],
[
148,
72
],
[
76,
75
],
[
130,
78
],
[
136,
81
],
[
121,
81
],
[
124,
81
],
[
145,
81
],
[
148,
83
],
[
75,
84
],
[
144,
86
],
[
148,
88
],
[
75,
89
],
[
141,
91
],
[
154,
95
],
[
139,
95
],
[
148,
98
],
[
75,
99
],
[
145,
100
],
[
136,
100
],
[
121,
100
],
[
124,
100
],
[
142,
103
],
[
115,
103
],
[
133,
103
],
[
126,
105
],
[
132,
108
],
[
127,
112
],
[
118,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
150,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
153,
154
]
] |
[
"n,T = map(int,input().split())\n\na = list(map(int,input().split()))\nmaxDiff = 0\ncurMin = a[0]\nfor i in range(n):\n if curMin > a[i]:\n curMin = a[i]\n if maxDiff < a[i] - curMin:\n maxDiff = a[i] - curMin\n\nisCovered = False\ncount = 0\n\ncurMin = a[0]\n\nfor i in range(n):\n if curMin > a[i]:\n curMin = a[i]\n isCovered = False\n if maxDiff == a[i] - curMin:\n if not isCovered:\n count += 1\n isCovered = True\n\nprint(count)",
"n,T = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"maxDiff = 0",
"maxDiff",
"0",
"curMin = a[0]",
"curMin",
"a[0]",
"a",
"0",
"for i in range(n):\n if curMin > a[i]:\n curMin = a[i]\n if maxDiff < a[i] - curMin:\n maxDiff = a[i] - curMin",
"i",
"range(n)",
"range",
"n",
"if curMin > a[i]:\n curMin = a[i]\n ",
"curMin > a[i]",
"curMin",
"a[i]",
"a",
"i",
"curMin = a[i]",
"curMin",
"a[i]",
"a",
"i",
"if maxDiff < a[i] - curMin:\n maxDiff = a[i] - curMin",
"maxDiff < a[i] - curMin",
"maxDiff",
"a[i] - curMin",
"a[i]",
"a",
"i",
"curMin",
"maxDiff = a[i] - curMin",
"maxDiff",
"a[i] - curMin",
"a[i]",
"a",
"i",
"curMin",
"isCovered = False",
"isCovered",
"False",
"count = 0",
"count",
"0",
"curMin = a[0]",
"curMin",
"a[0]",
"a",
"0",
"for i in range(n):\n if curMin > a[i]:\n curMin = a[i]\n isCovered = False\n if maxDiff == a[i] - curMin:\n if not isCovered:\n count += 1\n isCovered = True",
"i",
"range(n)",
"range",
"n",
"if curMin > a[i]:\n curMin = a[i]\n isCovered = False\n ",
"curMin > a[i]",
"curMin",
"a[i]",
"a",
"i",
"curMin = a[i]",
"curMin",
"a[i]",
"a",
"i",
"isCovered = False",
"isCovered",
"False",
"if maxDiff == a[i] - curMin:\n if not isCovered:\n count += 1\n isCovered = True",
"maxDiff == a[i] - curMin",
"maxDiff",
"a[i] - curMin",
"a[i]",
"a",
"i",
"curMin",
"if not isCovered:\n count += 1\n isCovered = True",
"not isCovered",
"isCovered",
"count += 1",
"count",
"1",
"isCovered = True",
"isCovered",
"True",
"print(count)",
"print",
"count",
"isCovered = False",
"False",
"isCovered",
"count = 0",
"0",
"count",
"curMin = a[i]",
"a[i]",
"curMin",
"curMin = a[0]",
"a[0]",
"curMin",
"count += 1",
"1",
"count",
"n,T = map(int,input().split())",
"map(int,input().split())",
"n",
"isCovered = True",
"True",
"isCovered",
"curMin = a[0]",
"a[0]",
"curMin",
"maxDiff = 0",
"0",
"maxDiff",
"isCovered = False",
"False",
"isCovered",
"curMin = a[i]",
"a[i]",
"curMin",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"maxDiff = a[i] - curMin",
"a[i] - curMin",
"maxDiff"
] |
n,T = map(int,input().split())
a = list(map(int,input().split()))
maxDiff = 0
curMin = a[0]
for i in range(n):
if curMin > a[i]:
curMin = a[i]
if maxDiff < a[i] - curMin:
maxDiff = a[i] - curMin
isCovered = False
count = 0
curMin = a[0]
for i in range(n):
if curMin > a[i]:
curMin = a[i]
isCovered = False
if maxDiff == a[i] - curMin:
if not isCovered:
count += 1
isCovered = True
print(count)
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
17,
4,
18,
13,
13,
2,
17,
17,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
2,
13,
17,
0,
18,
13,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
18,
13
] |
[
[
141,
4
],
[
138,
11
],
[
132,
18
],
[
33,
32
],
[
142,
39
],
[
33,
41
],
[
44,
43
],
[
142,
52
],
[
56,
55
],
[
32,
59
],
[
64,
61
],
[
55,
62
],
[
43,
65
],
[
69,
68
],
[
32,
72
],
[
80,
77
],
[
55,
78
],
[
68,
79
],
[
55,
83
],
[
68,
85
],
[
43,
88
],
[
68,
89
],
[
92,
91
],
[
32,
95
],
[
98,
97
],
[
32,
101
],
[
107,
104
],
[
91,
105
],
[
97,
106
],
[
55,
109
],
[
97,
111
],
[
43,
114
],
[
97,
115
],
[
91,
120
],
[
91,
124
],
[
136,
130
],
[
132,
133
],
[
138,
139
],
[
141,
142
]
] |
[
"import sys\n\nreadline = sys.stdin.readline\nMOD = 10 ** 9 + 7\nINF = float('INF')\nsys.setrecursionlimit(10 ** 5)\n\n\ndef main():\n n, t = map(int, readline().split())\n a = list(map(int, readline().split()))\n\n cum_max = [0] * n\n cum_max[-1] = a[-1]\n\n for i in range(n - 2, -1, -1):\n cum_max[i] = max(cum_max[i + 1], a[i])\n\n profit = [0] * n\n for i in range(n-1):\n profit[i] = cum_max[i+1] - a[i]\n\n print(profit.count(max(profit)))\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"readline = sys.stdin.readline",
"readline",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"INF = float('INF')",
"INF",
"float('INF')",
"float",
"'INF'",
"sys.setrecursionlimit(10 ** 5)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 5",
"10",
"5",
"def main():\n n, t = map(int, readline().split())\n a = list(map(int, readline().split()))\n\n cum_max = [0] * n\n cum_max[-1] = a[-1]\n\n for i in range(n - 2, -1, -1):\n cum_max[i] = max(cum_max[i + 1], a[i])\n\n profit = [0] * n\n for i in range(n-1):\n profit[i] = cum_max[i+1] - a[i]\n\n print(profit.count(max(profit)))",
"main",
"n, t = map(int, readline().split())",
"n",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"t",
"a = list(map(int, readline().split()))",
"a",
"list(map(int, readline().split()))",
"list",
"map(int, readline().split())",
"map",
"int",
"readline().split()",
"().split",
"()",
"readline",
"split",
"cum_max = [0] * n",
"cum_max",
"[0] * n",
"[0]",
"0",
"n",
"cum_max[-1] = a[-1]",
"cum_max[-1]",
"cum_max",
"-1",
"a[-1]",
"a",
"-1",
"for i in range(n - 2, -1, -1):\n cum_max[i] = max(cum_max[i + 1], a[i])\n\n ",
"i",
"range(n - 2, -1, -1)",
"range",
"n - 2",
"n",
"2",
"-1",
"-1",
"cum_max[i] = max(cum_max[i + 1], a[i])",
"cum_max[i]",
"cum_max",
"i",
"max(cum_max[i + 1], a[i])",
"max",
"cum_max[i + 1]",
"cum_max",
"i + 1",
"i",
"1",
"a[i]",
"a",
"i",
"profit = [0] * n",
"profit",
"[0] * n",
"[0]",
"0",
"n",
"for i in range(n-1):\n profit[i] = cum_max[i+1] - a[i]\n\n ",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"profit[i] = cum_max[i+1] - a[i]",
"profit[i]",
"profit",
"i",
"cum_max[i+1] - a[i]",
"cum_max[i+1]",
"cum_max",
"i+1",
"i",
"1",
"a[i]",
"a",
"i",
"print(profit.count(max(profit)))",
"print",
"profit.count(max(profit))",
"profit.count",
"profit",
"count",
"max(profit)",
"max",
"profit",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"INF = float('INF')",
"float('INF')",
"INF",
"def main():\n n, t = map(int, readline().split())\n a = list(map(int, readline().split()))\n\n cum_max = [0] * n\n cum_max[-1] = a[-1]\n\n for i in range(n - 2, -1, -1):\n cum_max[i] = max(cum_max[i + 1], a[i])\n\n profit = [0] * n\n for i in range(n-1):\n profit[i] = cum_max[i+1] - a[i]\n\n print(profit.count(max(profit)))",
"def main():\n n, t = map(int, readline().split())\n a = list(map(int, readline().split()))\n\n cum_max = [0] * n\n cum_max[-1] = a[-1]\n\n for i in range(n - 2, -1, -1):\n cum_max[i] = max(cum_max[i + 1], a[i])\n\n profit = [0] * n\n for i in range(n-1):\n profit[i] = cum_max[i+1] - a[i]\n\n print(profit.count(max(profit)))",
"main",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"readline = sys.stdin.readline",
"sys.stdin.readline",
"readline"
] |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, t = map(int, readline().split())
a = list(map(int, readline().split()))
cum_max = [0] * n
cum_max[-1] = a[-1]
for i in range(n - 2, -1, -1):
cum_max[i] = max(cum_max[i + 1], a[i])
profit = [0] * n
for i in range(n-1):
profit[i] = cum_max[i+1] - a[i]
print(profit.count(max(profit)))
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,
21,
22,
17,
18,
13,
17,
22,
17,
17,
22,
17,
17,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
13,
18,
13,
17,
0,
18,
13,
17,
18,
13,
13,
14,
2,
2,
18,
13,
13,
18,
13,
17,
18,
13,
17,
0,
18,
13,
17,
2,
18,
13,
13,
18,
13,
17,
0,
18,
13,
17,
17,
14,
2,
2,
18,
13,
13,
18,
13,
17,
18,
13,
17,
0,
18,
13,
17,
17,
4,
13,
18,
13,
17,
10,
4,
13,
10,
4,
13,
10,
21,
13,
10,
4,
13
] |
[
[
119,
2
],
[
119,
11
],
[
110,
13
],
[
116,
25
],
[
40,
39
],
[
120,
43
],
[
111,
47
],
[
39,
48
],
[
117,
50
],
[
56,
53
],
[
117,
54
],
[
111,
57
],
[
39,
58
],
[
111,
63
],
[
39,
64
],
[
117,
66
],
[
117,
69
],
[
75,
72
],
[
117,
73
],
[
111,
77
],
[
39,
78
],
[
117,
80
],
[
86,
83
],
[
117,
84
],
[
111,
91
],
[
39,
92
],
[
117,
94
],
[
117,
97
],
[
103,
100
],
[
117,
101
],
[
117,
107
],
[
110,
111
],
[
119,
114
],
[
116,
117
],
[
119,
120
]
] |
[
"n, t = map(int,input().split())\nA = list(map(int,input().split()))\n\ndict = {\"tmpmin\":A[0],\"maxvalue\":0,\"pairs\":0}\nfor i in range(1,n):\n if A[i] < dict[\"tmpmin\"]:\n dict[\"tmpmin\"] = A[i]\n else:\n if A[i] - dict[\"tmpmin\"] > dict[\"maxvalue\"]:\n dict[\"maxvalue\"] = A[i] - dict[\"tmpmin\"]\n dict[\"pairs\"] = 1\n elif A[i] - dict[\"tmpmin\"] == dict[\"maxvalue\"]:\n dict[\"pairs\"] += 1\nprint(dict[\"pairs\"])",
"n, t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"dict = {\"tmpmin\":A[0],\"maxvalue\":0,\"pairs\":0}",
"dict",
"{\"tmpmin\":A[0],\"maxvalue\":0,\"pairs\":0}",
"\"tmpmin\"",
"\"tmpmin\"",
"A[0]",
"A",
"0",
"\"maxvalue\"",
"\"maxvalue\"",
"0",
"\"pairs\"",
"\"pairs\"",
"0",
"for i in range(1,n):\n if A[i] < dict[\"tmpmin\"]:\n dict[\"tmpmin\"] = A[i]\n else:\n if A[i] - dict[\"tmpmin\"] > dict[\"maxvalue\"]:\n dict[\"maxvalue\"] = A[i] - dict[\"tmpmin\"]\n dict[\"pairs\"] = 1\n elif A[i] - dict[\"tmpmin\"] == dict[\"maxvalue\"]:\n dict[\"pairs\"] += 1",
"i",
"range(1,n)",
"range",
"1",
"n",
"if A[i] < dict[\"tmpmin\"]:\n dict[\"tmpmin\"] = A[i]\n else:\n if A[i] - dict[\"tmpmin\"] > dict[\"maxvalue\"]:\n dict[\"maxvalue\"] = A[i] - dict[\"tmpmin\"]\n dict[\"pairs\"] = 1\n elif A[i] - dict[\"tmpmin\"] == dict[\"maxvalue\"]:\n dict[\"pairs\"] += 1",
"A[i] < dict[\"tmpmin\"]",
"A[i]",
"A",
"i",
"dict[\"tmpmin\"]",
"dict",
"\"tmpmin\"",
"dict[\"tmpmin\"] = A[i]",
"dict[\"tmpmin\"]",
"dict",
"\"tmpmin\"",
"A[i]",
"A",
"i",
"if A[i] - dict[\"tmpmin\"] > dict[\"maxvalue\"]:\n dict[\"maxvalue\"] = A[i] - dict[\"tmpmin\"]\n dict[\"pairs\"] = 1\n elif A[i] - dict[\"tmpmin\"] == dict[\"maxvalue\"]:\n dict[\"pairs\"] += 1",
"A[i] - dict[\"tmpmin\"] > dict[\"maxvalue\"]",
"A[i] - dict[\"tmpmin\"]",
"A[i]",
"A",
"i",
"dict[\"tmpmin\"]",
"dict",
"\"tmpmin\"",
"dict[\"maxvalue\"]",
"dict",
"\"maxvalue\"",
"dict[\"maxvalue\"] = A[i] - dict[\"tmpmin\"]",
"dict[\"maxvalue\"]",
"dict",
"\"maxvalue\"",
"A[i] - dict[\"tmpmin\"]",
"A[i]",
"A",
"i",
"dict[\"tmpmin\"]",
"dict",
"\"tmpmin\"",
"dict[\"pairs\"] = 1",
"dict[\"pairs\"]",
"dict",
"\"pairs\"",
"1",
"elif A[i] - dict[\"tmpmin\"] == dict[\"maxvalue\"]:\n dict[\"pairs\"] += 1",
"A[i] - dict[\"tmpmin\"] == dict[\"maxvalue\"]",
"A[i] - dict[\"tmpmin\"]",
"A[i]",
"A",
"i",
"dict[\"tmpmin\"]",
"dict",
"\"tmpmin\"",
"dict[\"maxvalue\"]",
"dict",
"\"maxvalue\"",
"dict[\"pairs\"] += 1",
"dict[\"pairs\"]",
"dict",
"\"pairs\"",
"1",
"print(dict[\"pairs\"])",
"print",
"dict[\"pairs\"]",
"dict",
"\"pairs\"",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"dict = {\"tmpmin\":A[0],\"maxvalue\":0,\"pairs\":0}",
"{\"tmpmin\":A[0],\"maxvalue\":0,\"pairs\":0}",
"dict",
"n, t = map(int,input().split())",
"map(int,input().split())",
"n"
] |
n, t = map(int,input().split())
A = list(map(int,input().split()))
dict = {"tmpmin":A[0],"maxvalue":0,"pairs":0}
for i in range(1,n):
if A[i] < dict["tmpmin"]:
dict["tmpmin"] = A[i]
else:
if A[i] - dict["tmpmin"] > dict["maxvalue"]:
dict["maxvalue"] = A[i] - dict["tmpmin"]
dict["pairs"] = 1
elif A[i] - dict["tmpmin"] == dict["maxvalue"]:
dict["pairs"] += 1
print(dict["pairs"])
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
31,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
18,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
2,
18,
13,
13,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] |
[
[
103,
2
],
[
103,
11
],
[
15,
13
],
[
88,
24
],
[
85,
29
],
[
97,
32
],
[
36,
35
],
[
101,
39
],
[
106,
41
],
[
35,
45
],
[
89,
46
],
[
95,
46
],
[
35,
51
],
[
89,
52
],
[
95,
52
],
[
94,
54
],
[
35,
57
],
[
107,
60
],
[
86,
61
],
[
92,
61
],
[
91,
63
],
[
107,
64
],
[
82,
66
],
[
107,
70
],
[
86,
71
],
[
92,
71
],
[
79,
73
],
[
80,
77
],
[
83,
77
],
[
98,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
107,
91
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
103,
101
],
[
103,
104
],
[
106,
107
]
] |
[
"N, T = map(int, input().split())\n*a, = map(int, input().split())\nm = a[0]\np = 0\nans = 0\nfor i in range(1, N):\n c = a[i] - m\n if a[i] < m:\n m = a[i]\n if c > p:\n p = c\n ans = 1\n elif c == p:\n ans += 1\n\nprint(ans)",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"*a, = map(int, input().split())",
"*a",
"a",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"m = a[0]",
"m",
"a[0]",
"a",
"0",
"p = 0",
"p",
"0",
"ans = 0",
"ans",
"0",
"for i in range(1, N):\n c = a[i] - m\n if a[i] < m:\n m = a[i]\n if c > p:\n p = c\n ans = 1\n elif c == p:\n ans += 1",
"i",
"range(1, N)",
"range",
"1",
"N",
"c = a[i] - m",
"c",
"a[i] - m",
"a[i]",
"a",
"i",
"m",
"if a[i] < m:\n m = a[i]\n ",
"a[i] < m",
"a[i]",
"a",
"i",
"m",
"m = a[i]",
"m",
"a[i]",
"a",
"i",
"if c > p:\n p = c\n ans = 1\n elif c == p:\n ans += 1",
"c > p",
"c",
"p",
"p = c",
"p",
"c",
"ans = 1",
"ans",
"1",
"elif c == p:\n ans += 1",
"c == p",
"c",
"p",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"ans += 1",
"1",
"ans",
"ans = 1",
"1",
"ans",
"p = 0",
"0",
"p",
"m = a[0]",
"a[0]",
"m",
"p = c",
"c",
"p",
"m = a[i]",
"a[i]",
"m",
"ans = 0",
"0",
"ans",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"c = a[i] - m",
"a[i] - m",
"c"
] |
N, T = map(int, input().split())
*a, = map(int, input().split())
m = a[0]
p = 0
ans = 0
for i in range(1, N):
c = a[i] - m
if a[i] < m:
m = a[i]
if c > p:
p = c
ans = 1
elif c == p:
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,
39,
17,
13,
0,
18,
13,
17,
18,
13,
17,
28,
13,
4,
13,
17,
2,
40,
13,
17,
17,
0,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
4,
13,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
2,
18,
13,
13,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] |
[
[
116,
2
],
[
116,
11
],
[
107,
13
],
[
110,
25
],
[
117,
29
],
[
34,
31
],
[
111,
32
],
[
108,
35
],
[
39,
38
],
[
117,
44
],
[
51,
48
],
[
111,
49
],
[
38,
50
],
[
111,
54
],
[
38,
56
],
[
108,
59
],
[
38,
60
],
[
119,
62
],
[
66,
65
],
[
117,
69
],
[
125,
72
],
[
120,
75
],
[
126,
75
],
[
48,
77
],
[
111,
78
],
[
65,
79
],
[
108,
81
],
[
65,
82
],
[
122,
84
],
[
88,
87
],
[
117,
91
],
[
48,
96
],
[
111,
97
],
[
87,
98
],
[
108,
100
],
[
87,
101
],
[
126,
102
],
[
120,
102
],
[
123,
105
],
[
107,
108
],
[
110,
111
],
[
116,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
]
] |
[
"n, t = map(int, input().split())\na = list(map(int, input().split()))\nmax_value = [0] * n #a[i]以降の最大値\nmax_value[-1] = a[-1]\nfor i in range(-2, -n - 1, -1):\n max_value[i] = max(max_value[i + 1], a[i])\nmax_profit = 0\nfor i in range(n - 1):\n max_profit = max(max_profit, max_value[i] - a[i])\nans = 0\nfor i in range(n - 1):\n if max_value[i] - a[i] == max_profit: ans += 1\nprint(ans)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"max_value = [0] * n",
"max_value",
"[0] * n",
"[0]",
"0",
"n",
"max_value[-1] = a[-1]",
"max_value[-1]",
"max_value",
"-1",
"a[-1]",
"a",
"-1",
"for i in range(-2, -n - 1, -1):\n max_value[i] = max(max_value[i + 1], a[i])",
"i",
"range(-2, -n - 1, -1)",
"range",
"-2",
"-n - 1",
"-n",
"n",
"1",
"-1",
"max_value[i] = max(max_value[i + 1], a[i])",
"max_value[i]",
"max_value",
"i",
"max(max_value[i + 1], a[i])",
"max",
"max_value[i + 1]",
"max_value",
"i + 1",
"i",
"1",
"a[i]",
"a",
"i",
"max_profit = 0",
"max_profit",
"0",
"for i in range(n - 1):\n max_profit = max(max_profit, max_value[i] - a[i])",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"max_profit = max(max_profit, max_value[i] - a[i])",
"max_profit",
"max(max_profit, max_value[i] - a[i])",
"max",
"max_profit",
"max_value[i] - a[i]",
"max_value[i]",
"max_value",
"i",
"a[i]",
"a",
"i",
"ans = 0",
"ans",
"0",
"for i in range(n - 1):\n if max_value[i] - a[i] == max_profit: ans += 1",
"i",
"range(n - 1)",
"range",
"n - 1",
"n",
"1",
"if max_value[i] - a[i] == max_profit: ans ",
"max_value[i] - a[i] == max_profit",
"max_value[i] - a[i]",
"max_value[i]",
"max_value",
"i",
"a[i]",
"a",
"i",
"max_profit",
"print(ans)",
"print",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"max_value = [0] * n",
"[0] * n",
"max_value",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"max_profit = 0",
"0",
"max_profit",
"ans = 0",
"0",
"ans",
"max_profit = max(max_profit, max_value[i] - a[i])",
"max(max_profit, max_value[i] - a[i])",
"max_profit"
] |
n, t = map(int, input().split())
a = list(map(int, input().split()))
max_value = [0] * n #a[i]以降の最大値
max_value[-1] = a[-1]
for i in range(-2, -n - 1, -1):
max_value[i] = max(max_value[i + 1], a[i])
max_profit = 0
for i in range(n - 1):
max_profit = max(max_profit, max_value[i] - a[i])
ans = 0
for i in range(n - 1):
if max_value[i] - a[i] == max_profit: ans += 1
print(ans)
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
41,
28,
13,
4,
13,
13,
4,
18,
13,
17,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
18,
13,
2,
13,
17,
4,
13,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
4,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
18,
13,
18,
13,
13,
17,
0,
13,
2,
18,
13,
13,
13,
0,
13,
18,
13,
18,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13
] |
[
[
159,
3
],
[
159,
12
],
[
147,
14
],
[
141,
26
],
[
148,
29
],
[
174,
31
],
[
37,
36
],
[
160,
39
],
[
148,
42
],
[
144,
45
],
[
49,
48
],
[
160,
52
],
[
60,
55
],
[
145,
56
],
[
48,
58
],
[
148,
63
],
[
48,
65
],
[
145,
68
],
[
48,
69
],
[
150,
71
],
[
75,
74
],
[
160,
78
],
[
165,
80
],
[
148,
85
],
[
74,
86
],
[
145,
88
],
[
74,
90
],
[
151,
92
],
[
166,
92
],
[
168,
94
],
[
98,
97
],
[
160,
100
],
[
107,
102
],
[
175,
103
],
[
148,
105
],
[
97,
106
],
[
171,
109
],
[
148,
112
],
[
97,
113
],
[
166,
114
],
[
151,
114
],
[
177,
116
],
[
102,
117
],
[
175,
118
],
[
148,
120
],
[
97,
121
],
[
156,
123
],
[
142,
126
],
[
172,
127
],
[
175,
129
],
[
172,
130
],
[
162,
132
],
[
178,
135
],
[
157,
136
],
[
163,
139
],
[
169,
139
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
159,
154
],
[
156,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
102,
177
],
[
177,
178
]
] |
[
"from collections import Counter\nn, t = map(int, input().split())\na = list(map(int, input().split()))\ncnt = Counter(a)\ncnt_tmp = Counter()\n#i番目以下の最小値\nmin_a = [a[0] for _ in range(n)]\nfor i in range(n-1):\n min_a[i+1] = min(a[i+1], min_a[i])\n\nres = 0\nfor i in range(1, n):\n res = max(a[i] - min_a[i-1], res)\n\nans = 0\nfor i in range(n):\n cnt_tmp[a[i]] += 1\n x = a[i] + res\n cnt_a = cnt_tmp[a[i]]\n cnt_x = cnt[x] - cnt_tmp[x]\n ans += min(cnt_a, cnt_x)\n\nprint(ans)",
"from collections import Counter",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"cnt = Counter(a)",
"cnt",
"Counter(a)",
"Counter",
"a",
"cnt_tmp = Counter()",
"cnt_tmp",
"Counter()",
"Counter",
"a[0] for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"a[0]",
"a",
"0",
"min_a = [a[0] for _ in range(n)]",
"min_a",
"[a[0] for _ in range(n)]",
"for i in range(n-1):\n min_a[i+1] = min(a[i+1], min_a[i])",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"min_a[i+1] = min(a[i+1], min_a[i])",
"min_a[i+1]",
"min_a",
"i+1",
"i",
"1",
"min(a[i+1], min_a[i])",
"min",
"a[i+1]",
"a",
"i+1",
"i",
"1",
"min_a[i]",
"min_a",
"i",
"res = 0",
"res",
"0",
"for i in range(1, n):\n res = max(a[i] - min_a[i-1], res)",
"i",
"range(1, n)",
"range",
"1",
"n",
"res = max(a[i] - min_a[i-1], res)",
"res",
"max(a[i] - min_a[i-1], res)",
"max",
"a[i] - min_a[i-1]",
"a[i]",
"a",
"i",
"min_a[i-1]",
"min_a",
"i-1",
"i",
"1",
"res",
"ans = 0",
"ans",
"0",
"for i in range(n):\n cnt_tmp[a[i]] += 1\n x = a[i] + res\n cnt_a = cnt_tmp[a[i]]\n cnt_x = cnt[x] - cnt_tmp[x]\n ans += min(cnt_a, cnt_x)",
"i",
"range(n)",
"range",
"n",
"cnt_tmp[a[i]] += 1",
"cnt_tmp[a[i]]",
"cnt_tmp",
"a[i]",
"a",
"i",
"1",
"x = a[i] + res",
"x",
"a[i] + res",
"a[i]",
"a",
"i",
"res",
"cnt_a = cnt_tmp[a[i]]",
"cnt_a",
"cnt_tmp[a[i]]",
"cnt_tmp",
"a[i]",
"a",
"i",
"cnt_x = cnt[x] - cnt_tmp[x]",
"cnt_x",
"cnt[x] - cnt_tmp[x]",
"cnt[x]",
"cnt",
"x",
"cnt_tmp[x]",
"cnt_tmp",
"x",
"ans += min(cnt_a, cnt_x)",
"ans",
"min(cnt_a, cnt_x)",
"min",
"cnt_a",
"cnt_x",
"print(ans)",
"print",
"ans",
"cnt = Counter(a)",
"Counter(a)",
"cnt",
"min_a = [a[0] for _ in range(n)]",
"[a[0] for _ in range(n)]",
"min_a",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"res = 0",
"0",
"res",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"cnt_x = cnt[x] - cnt_tmp[x]",
"cnt[x] - cnt_tmp[x]",
"cnt_x",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"ans += min(cnt_a, cnt_x)",
"min(cnt_a, cnt_x)",
"ans",
"res = max(a[i] - min_a[i-1], res)",
"max(a[i] - min_a[i-1], res)",
"res",
"ans = 0",
"0",
"ans",
"x = a[i] + res",
"a[i] + res",
"x",
"cnt_tmp = Counter()",
"Counter()",
"cnt_tmp",
"cnt_a = cnt_tmp[a[i]]",
"cnt_tmp[a[i]]",
"cnt_a"
] |
from collections import Counter
n, t = map(int, input().split())
a = list(map(int, input().split()))
cnt = Counter(a)
cnt_tmp = Counter()
#i番目以下の最小値
min_a = [a[0] for _ in range(n)]
for i in range(n-1):
min_a[i+1] = min(a[i+1], min_a[i])
res = 0
for i in range(1, n):
res = max(a[i] - min_a[i-1], res)
ans = 0
for i in range(n):
cnt_tmp[a[i]] += 1
x = a[i] + res
cnt_a = cnt_tmp[a[i]]
cnt_x = cnt[x] - cnt_tmp[x]
ans += min(cnt_a, cnt_x)
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,
17,
0,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
13,
9,
14,
2,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
14,
2,
13,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
18,
13,
10,
18,
13
] |
[
[
4,
3
],
[
3,
12
],
[
113,
14
],
[
113,
16
],
[
20,
19
],
[
19,
28
],
[
89,
30
],
[
101,
33
],
[
92,
36
],
[
119,
39
],
[
90,
41
],
[
45,
44
],
[
114,
48
],
[
116,
50
],
[
90,
52
],
[
44,
53
],
[
120,
56
],
[
96,
56
],
[
117,
57
],
[
95,
59
],
[
117,
60
],
[
102,
64
],
[
99,
64
],
[
117,
66
],
[
96,
67
],
[
120,
67
],
[
98,
69
],
[
117,
71
],
[
96,
72
],
[
120,
72
],
[
104,
74
],
[
102,
78
],
[
99,
78
],
[
117,
80
],
[
96,
81
],
[
120,
81
],
[
107,
83
],
[
108,
87
],
[
105,
87
],
[
93,
87
],
[
89,
90
],
[
92,
93
],
[
117,
95
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
113,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
]
] |
[
"N, T = [int(_) for _ in input().split()]\nA = [int(_) for _ in input().split()]\n\nmax_diff = 0\ncnt = 0\nmin_a = A[0]\nfor i in range(1, N):\n a = A[i]\n if min_a > a:\n min_a = a\n continue\n\n if max_diff < a - min_a:\n max_diff = a - min_a\n cnt = 1\n elif max_diff == a - min_a:\n cnt += 1\nprint(cnt)",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"N, T = [int(_) for _ in input().split()]",
"N",
"[int(_) for _ in input().split()]",
"T",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"A = [int(_) for _ in input().split()]",
"A",
"[int(_) for _ in input().split()]",
"max_diff = 0",
"max_diff",
"0",
"cnt = 0",
"cnt",
"0",
"min_a = A[0]",
"min_a",
"A[0]",
"A",
"0",
"for i in range(1, N):\n a = A[i]\n if min_a > a:\n min_a = a\n continue\n\n if max_diff < a - min_a:\n max_diff = a - min_a\n cnt = 1\n elif max_diff == a - min_a:\n cnt += 1",
"i",
"range(1, N)",
"range",
"1",
"N",
"a = A[i]",
"a",
"A[i]",
"A",
"i",
"if min_a > a:\n min_a = a\n continue\n\n ",
"min_a > a",
"min_a",
"a",
"min_a = a",
"min_a",
"a",
"continue",
"if max_diff < a - min_a:\n max_diff = a - min_a\n cnt = 1\n elif max_diff == a - min_a:\n cnt += 1",
"max_diff < a - min_a",
"max_diff",
"a - min_a",
"a",
"min_a",
"max_diff = a - min_a",
"max_diff",
"a - min_a",
"a",
"min_a",
"cnt = 1",
"cnt",
"1",
"elif max_diff == a - min_a:\n cnt += 1",
"max_diff == a - min_a",
"max_diff",
"a - min_a",
"a",
"min_a",
"cnt += 1",
"cnt",
"1",
"print(cnt)",
"print",
"cnt",
"A = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"A",
"cnt = 0",
"0",
"cnt",
"min_a = a",
"a",
"min_a",
"max_diff = a - min_a",
"a - min_a",
"max_diff",
"max_diff = 0",
"0",
"max_diff",
"cnt = 1",
"1",
"cnt",
"cnt += 1",
"1",
"cnt",
"T = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"T",
"N, T = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"N",
"a = A[i]",
"A[i]",
"a",
"min_a = A[0]",
"A[0]",
"min_a"
] |
N, T = [int(_) for _ in input().split()]
A = [int(_) for _ in input().split()]
max_diff = 0
cnt = 0
min_a = A[0]
for i in range(1, N):
a = A[i]
if min_a > a:
min_a = a
continue
if max_diff < a - min_a:
max_diff = a - min_a
cnt = 1
elif max_diff == a - min_a:
cnt += 1
print(cnt)
|
[
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,
17,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
4,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
18,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
4,
13,
4,
18,
13,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
96,
2
],
[
96,
11
],
[
99,
13
],
[
84,
25
],
[
81,
28
],
[
90,
31
],
[
88,
35
],
[
38,
37
],
[
88,
42
],
[
47,
44
],
[
91,
45
],
[
37,
46
],
[
44,
49
],
[
91,
50
],
[
37,
51
],
[
82,
53
],
[
94,
53
],
[
100,
55
],
[
37,
56
],
[
93,
58
],
[
82,
61
],
[
94,
61
],
[
100,
63
],
[
37,
64
],
[
78,
66
],
[
91,
69
],
[
91,
74
],
[
79,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
96,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
]
] |
[
"N,T=map(int,input().split())\nA=list(map(int,input().split()))\nans=0\nmax_=0\nB=[0]*N\nfor i in reversed(range(N)):\n B[i]=max(B[i],max_-A[i])\n max_=max(max_,A[i])\nm=max(B)\nprint(B.count(m))",
"N,T=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans=0",
"ans",
"0",
"max_=0",
"max_",
"0",
"B=[0]*N",
"B",
"[0]*N",
"[0]",
"0",
"N",
"for i in reversed(range(N)):\n B[i]=max(B[i],max_-A[i])\n max_=max(max_,A[i])",
"i",
"reversed(range(N))",
"reversed",
"range(N)",
"range",
"N",
"B[i]=max(B[i],max_-A[i])",
"B[i]",
"B",
"i",
"max(B[i],max_-A[i])",
"max",
"B[i]",
"B",
"i",
"max_-A[i]",
"max_",
"A[i]",
"A",
"i",
"max_=max(max_,A[i])",
"max_",
"max(max_,A[i])",
"max",
"max_",
"A[i]",
"A",
"i",
"m=max(B)",
"m",
"max(B)",
"max",
"B",
"print(B.count(m))",
"print",
"B.count(m)",
"B.count",
"B",
"count",
"m",
"m=max(B)",
"max(B)",
"m",
"max_=0",
"0",
"max_",
"ans=0",
"0",
"ans",
"N,T=map(int,input().split())",
"map(int,input().split())",
"N",
"B=[0]*N",
"[0]*N",
"B",
"max_=max(max_,A[i])",
"max(max_,A[i])",
"max_",
"T=map(int,input().split())",
"map(int,input().split())",
"T",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A"
] |
N,T=map(int,input().split())
A=list(map(int,input().split()))
ans=0
max_=0
B=[0]*N
for i in reversed(range(N)):
B[i]=max(B[i],max_-A[i])
max_=max(max_,A[i])
m=max(B)
print(B.count(m))
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
13,
4,
13,
13,
4,
39,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
0,
13,
12,
18,
13,
17,
23,
0,
13,
17,
0,
13,
17,
0,
13,
2,
39,
17,
13,
28,
13,
13,
13,
14,
18,
13,
13,
9,
0,
18,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
13,
14,
18,
13,
13,
3,
0,
18,
13,
13,
17,
0,
13,
2,
18,
13,
13,
13,
14,
2,
13,
13,
0,
13,
17,
0,
13,
13,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13
] |
[
[
134,
2
],
[
134,
11
],
[
131,
13
],
[
132,
30
],
[
143,
36
],
[
125,
39
],
[
144,
42
],
[
45,
44
],
[
155,
51
],
[
146,
54
],
[
140,
57
],
[
135,
61
],
[
141,
68
],
[
75,
72
],
[
141,
73
],
[
78,
77
],
[
135,
83
],
[
141,
86
],
[
77,
87
],
[
93,
90
],
[
141,
91
],
[
77,
92
],
[
122,
95
],
[
132,
98
],
[
77,
99
],
[
123,
103
],
[
147,
104
],
[
150,
104
],
[
137,
106
],
[
149,
109
],
[
123,
110
],
[
123,
113
],
[
147,
114
],
[
150,
114
],
[
152,
116
],
[
153,
120
],
[
138,
120
],
[
156,
120
],
[
122,
123
],
[
125,
126
],
[
134,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
],
[
123,
149
],
[
149,
150
],
[
152,
153
],
[
155,
156
]
] |
[
"n, t = map(int, input().split())\nA = tuple(map(int, input().split()))\nAI = [(i, a) for i, a in enumerate(A)]\nAI = sorted(AI, key=lambda x: x[1])\n\n# 小さい順に見ていく\ncount = 0\nmaxdiff = 0\nvisited = [0] * n\nfor i, a in AI:\n if visited[i]:\n continue\n visited[i] = 1\n\n for j in range(i+1, n):\n if visited[j]:\n break\n visited[j] = 1\n diff = A[j] - a\n if diff > maxdiff:\n count = 1\n maxdiff = diff\n elif diff == maxdiff:\n count += 1\nprint(count)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = tuple(map(int, input().split()))",
"A",
"tuple(map(int, input().split()))",
"tuple",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"(i, a) for i, a in enumerate(A)",
"for i, a in enumerate(A)",
"i",
"a",
"enumerate(A)",
"enumerate",
"A",
"for i, a in enumerate(A)",
"(i, a)",
"i",
"a",
"AI = [(i, a) for i, a in enumerate(A)]",
"AI",
"[(i, a) for i, a in enumerate(A)]",
"AI = sorted(AI, key=lambda x: x[1])",
"AI",
"sorted(AI, key=lambda x: x[1])",
"sorted",
"AI",
"key=lambda x: x[1]",
"key",
"lambda x: x[1]",
"x[1]",
"x",
"1",
"x",
"count = 0",
"count",
"0",
"maxdiff = 0",
"maxdiff",
"0",
"visited = [0] * n",
"visited",
"[0] * n",
"[0]",
"0",
"n",
"for i, a in AI:\n if visited[i]:\n continue\n visited[i] = 1\n\n for j in range(i+1, n):\n if visited[j]:\n break\n visited[j] = 1\n diff = A[j] - a\n if diff > maxdiff:\n count = 1\n maxdiff = diff\n elif diff == maxdiff:\n count += 1",
"i",
"a",
"AI",
"if visited[i]:\n continue\n ",
"visited[i]",
"visited",
"i",
"continue",
"visited[i] = 1",
"visited[i]",
"visited",
"i",
"1",
"for j in range(i+1, n):\n if visited[j]:\n break\n visited[j] = 1\n diff = A[j] - a\n if diff > maxdiff:\n count = 1\n maxdiff = diff\n elif diff == maxdiff:\n count += 1",
"j",
"range(i+1, n)",
"range",
"i+1",
"i",
"1",
"n",
"if visited[j]:\n break\n ",
"visited[j]",
"visited",
"j",
"break",
"visited[j] = 1",
"visited[j]",
"visited",
"j",
"1",
"diff = A[j] - a",
"diff",
"A[j] - a",
"A[j]",
"A",
"j",
"a",
"if diff > maxdiff:\n count = 1\n maxdiff = diff\n elif diff == maxdiff:\n count += 1",
"diff > maxdiff",
"diff",
"maxdiff",
"count = 1",
"count",
"1",
"maxdiff = diff",
"maxdiff",
"diff",
"elif diff == maxdiff:\n count += 1",
"diff == maxdiff",
"diff",
"maxdiff",
"count += 1",
"count",
"1",
"print(count)",
"print",
"count",
"diff = A[j] - a",
"A[j] - a",
"diff",
"AI = sorted(AI, key=lambda x: x[1])",
"sorted(AI, key=lambda x: x[1])",
"AI",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"A = tuple(map(int, input().split()))",
"tuple(map(int, input().split()))",
"A",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"count = 1",
"1",
"count",
"visited = [0] * n",
"[0] * n",
"visited",
"AI = [(i, a) for i, a in enumerate(A)]",
"[(i, a) for i, a in enumerate(A)]",
"AI",
"maxdiff = 0",
"0",
"maxdiff",
"maxdiff = diff",
"diff",
"maxdiff",
"count += 1",
"1",
"count",
"count = 0",
"0",
"count"
] |
n, t = map(int, input().split())
A = tuple(map(int, input().split()))
AI = [(i, a) for i, a in enumerate(A)]
AI = sorted(AI, key=lambda x: x[1])
# 小さい順に見ていく
count = 0
maxdiff = 0
visited = [0] * n
for i, a in AI:
if visited[i]:
continue
visited[i] = 1
for j in range(i+1, n):
if visited[j]:
break
visited[j] = 1
diff = A[j] - a
if diff > maxdiff:
count = 1
maxdiff = diff
elif diff == maxdiff:
count += 1
print(count)
|
[
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,
17,
0,
13,
39,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
2,
2,
13,
18,
13,
13,
17,
0,
13,
39,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
0,
13,
4,
18,
13,
13,
18,
13,
17,
4,
13,
13,
10,
13,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
39,
13,
10,
18,
13
] |
[
[
100,
2
],
[
100,
11
],
[
15,
14
],
[
14,
23
],
[
85,
25
],
[
94,
28
],
[
106,
31
],
[
109,
34
],
[
86,
36
],
[
40,
39
],
[
92,
43
],
[
110,
50
],
[
104,
50
],
[
86,
52
],
[
39,
53
],
[
88,
56
],
[
110,
59
],
[
104,
59
],
[
86,
61
],
[
39,
62
],
[
103,
64
],
[
86,
66
],
[
39,
67
],
[
89,
70
],
[
107,
70
],
[
97,
73
],
[
89,
76
],
[
107,
76
],
[
89,
79
],
[
107,
79
],
[
98,
83
],
[
85,
86
],
[
88,
89
],
[
100,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
]
] |
[
"N, T = map(int, input().split())\nA = [int(c) for c in input().split()]\nflag = True\nls = []\nst = A[-1]\nfor i in range(N-2,-1,-1):\n if st-A[i]>0:\n ls += [st-A[i]]\n else:\n st = A[i]\nls.sort()\nans = ls.count(ls[-1])\nprint(ans)",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"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",
"A = [int(c) for c in input().split()]",
"A",
"[int(c) for c in input().split()]",
"flag = True",
"flag",
"True",
"ls = []",
"ls",
"[]",
"st = A[-1]",
"st",
"A[-1]",
"A",
"-1",
"for i in range(N-2,-1,-1):\n if st-A[i]>0:\n ls += [st-A[i]]\n else:\n st = A[i]",
"i",
"range(N-2,-1,-1)",
"range",
"N-2",
"N",
"2",
"-1",
"-1",
"if st-A[i]>0:\n ls += [st-A[i]]\n else:\n st = A[i]",
"st-A[i]>0",
"st-A[i]",
"st",
"A[i]",
"A",
"i",
"0",
"ls += [st-A[i]]",
"ls",
"[st-A[i]]",
"st-A[i]",
"st",
"A[i]",
"A",
"i",
"st = A[i]",
"st",
"A[i]",
"A",
"i",
"ls.sort()",
"ls.sort",
"ls",
"sort",
"ans = ls.count(ls[-1])",
"ans",
"ls.count(ls[-1])",
"ls.count",
"ls",
"count",
"ls[-1]",
"ls",
"-1",
"print(ans)",
"print",
"ans",
"A = [int(c) for c in input().split()]",
"[int(c) for c in input().split()]",
"A",
"ls += [st-A[i]]",
"[st-A[i]]",
"ls",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"flag = True",
"True",
"flag",
"ans = ls.count(ls[-1])",
"ls.count(ls[-1])",
"ans",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"st = A[i]",
"A[i]",
"st",
"ls = []",
"[]",
"ls",
"st = A[-1]",
"A[-1]",
"st"
] |
N, T = map(int, input().split())
A = [int(c) for c in input().split()]
flag = True
ls = []
st = A[-1]
for i in range(N-2,-1,-1):
if st-A[i]>0:
ls += [st-A[i]]
else:
st = A[i]
ls.sort()
ans = ls.count(ls[-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,
18,
13,
17,
0,
13,
39,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
86,
2
],
[
86,
11
],
[
89,
13
],
[
77,
25
],
[
90,
27
],
[
74,
30
],
[
34,
33
],
[
87,
37
],
[
90,
41
],
[
33,
42
],
[
78,
43
],
[
81,
43
],
[
80,
45
],
[
90,
47
],
[
33,
48
],
[
83,
50
],
[
90,
53
],
[
33,
54
],
[
78,
55
],
[
81,
55
],
[
75,
58
],
[
84,
60
],
[
75,
65
],
[
75,
69
],
[
86,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] |
[
"N, T = map(int, input().split())\nA = list(map(int, input().split()))\n\nm = A[0]\nl = []\nfor i in range(1, N):\n if A[i] < m:\n m = A[i]\n else:\n d = A[i] - m\n l.append(d)\nprint(l.count(max(l)))",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"m = A[0]",
"m",
"A[0]",
"A",
"0",
"l = []",
"l",
"[]",
"for i in range(1, N):\n if A[i] < m:\n m = A[i]\n else:\n d = A[i] - m\n l.append(d)",
"i",
"range(1, N)",
"range",
"1",
"N",
"if A[i] < m:\n m = A[i]\n else:\n d = A[i] - m\n l.append(d)",
"A[i] < m",
"A[i]",
"A",
"i",
"m",
"m = A[i]",
"m",
"A[i]",
"A",
"i",
"d = A[i] - m",
"d",
"A[i] - m",
"A[i]",
"A",
"i",
"m",
"l.append(d)",
"l.append",
"l",
"append",
"d",
"print(l.count(max(l)))",
"print",
"l.count(max(l))",
"l.count",
"l",
"count",
"max(l)",
"max",
"l",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"l = []",
"[]",
"l",
"m = A[0]",
"A[0]",
"m",
"m = A[i]",
"A[i]",
"m",
"d = A[i] - m",
"A[i] - m",
"d",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A"
] |
N, T = map(int, input().split())
A = list(map(int, input().split()))
m = A[0]
l = []
for i in range(1, N):
if A[i] < m:
m = A[i]
else:
d = A[i] - m
l.append(d)
print(l.count(max(l)))
|
[
7,
15,
0,
13,
4,
13,
17,
13,
0,
31,
13,
4,
13,
13,
4,
18,
13,
13,
0,
13,
2,
4,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
18,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
47,
3
],
[
47,
7
],
[
11,
9
],
[
48,
10
],
[
48,
16
],
[
41,
19
],
[
48,
23
],
[
48,
28
],
[
42,
35
],
[
42,
39
],
[
41,
42
],
[
47,
45
],
[
47,
48
]
] |
[
"from numpy import*;_,a=open(0);*a,=map(int,a.split());c=array(a)-minimum.accumulate(a);print(list(c).count(max(c)))",
"from numpy import*",
"_,a=open(0)",
"_",
"open(0)",
"open",
"0",
"a",
"*a,=map(int,a.split())",
"*a",
"a",
"map(int,a.split())",
"map",
"int",
"a.split()",
"a.split",
"a",
"split",
"c=array(a)-minimum.accumulate(a)",
"c",
"array(a)-minimum.accumulate(a)",
"array(a)",
"array",
"a",
"minimum.accumulate(a)",
"minimum.accumulate",
"minimum",
"accumulate",
"a",
"print(list(c).count(max(c)))",
"print",
"list(c).count(max(c))",
"(c).count",
"(c)",
"list",
"c",
"count",
"max(c)",
"max",
"c",
"c=array(a)-minimum.accumulate(a)",
"array(a)-minimum.accumulate(a)",
"c",
"_,a=open(0)",
"open(0)",
"_",
"a=open(0)",
"open(0)",
"a"
] |
from numpy import*;_,a=open(0);*a,=map(int,a.split());c=array(a)-minimum.accumulate(a);print(list(c).count(max(c)))
|
[
7,
12,
13,
15,
0,
13,
2,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
31,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
13,
18,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
6,
5
],
[
11,
10
],
[
11,
19
],
[
23,
21
],
[
33,
32
],
[
37,
36
],
[
40,
39
],
[
43,
42
],
[
46,
45
],
[
42,
47
],
[
32,
49
],
[
36,
53
],
[
56,
53
],
[
45,
54
],
[
57,
56
],
[
45,
57
],
[
60,
59
],
[
36,
63
],
[
56,
63
],
[
45,
64
],
[
67,
66
],
[
32,
70
],
[
42,
71
],
[
66,
74
],
[
59,
74
],
[
39,
74
],
[
83,
80
]
] |
[
"def main():\n from heapq import heappush\n\n inf = 1 << 30\n\n N, T = map(int, input().split())\n *A, = map(int, input().split())\n\n h = [inf]\n ma = -1\n cnt = 0\n for x in A:\n d = x - h[0]\n if ma < d:\n ma = d\n cnt = 1\n elif ma == d:\n cnt += 1\n heappush(h, x)\n\n print(cnt)\n\n\nif __name__ == '__main__':\n main()",
"def main():\n from heapq import heappush\n\n inf = 1 << 30\n\n N, T = map(int, input().split())\n *A, = map(int, input().split())\n\n h = [inf]\n ma = -1\n cnt = 0\n for x in A:\n d = x - h[0]\n if ma < d:\n ma = d\n cnt = 1\n elif ma == d:\n cnt += 1\n heappush(h, x)\n\n print(cnt)",
"main",
"from heapq import heappush",
"inf = 1 << 30",
"inf",
"1 << 30",
"1",
"30",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"*A, = map(int, input().split())",
"*A",
"A",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"h = [inf]",
"h",
"[inf]",
"inf",
"ma = -1",
"ma",
"-1",
"cnt = 0",
"cnt",
"0",
"for x in A:\n d = x - h[0]\n if ma < d:\n ma = d\n cnt = 1\n elif ma == d:\n cnt += 1\n heappush(h, x)\n\n ",
"x",
"A",
"d = x - h[0]",
"d",
"x - h[0]",
"x",
"h[0]",
"h",
"0",
"if ma < d:\n ma = d\n cnt = 1\n elif ma == d:\n cnt += 1\n ",
"ma < d",
"ma",
"d",
"ma = d",
"ma",
"d",
"cnt = 1",
"cnt",
"1",
"elif ma == d:\n cnt += 1\n ",
"ma == d",
"ma",
"d",
"cnt += 1",
"cnt",
"1",
"heappush(h, x)",
"heappush",
"h",
"x",
"print(cnt)",
"print",
"cnt",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n from heapq import heappush\n\n inf = 1 << 30\n\n N, T = map(int, input().split())\n *A, = map(int, input().split())\n\n h = [inf]\n ma = -1\n cnt = 0\n for x in A:\n d = x - h[0]\n if ma < d:\n ma = d\n cnt = 1\n elif ma == d:\n cnt += 1\n heappush(h, x)\n\n print(cnt)",
"def main():\n from heapq import heappush\n\n inf = 1 << 30\n\n N, T = map(int, input().split())\n *A, = map(int, input().split())\n\n h = [inf]\n ma = -1\n cnt = 0\n for x in A:\n d = x - h[0]\n if ma < d:\n ma = d\n cnt = 1\n elif ma == d:\n cnt += 1\n heappush(h, x)\n\n print(cnt)",
"main"
] |
def main():
from heapq import heappush
inf = 1 << 30
N, T = map(int, input().split())
*A, = map(int, input().split())
h = [inf]
ma = -1
cnt = 0
for x in A:
d = x - h[0]
if ma < d:
ma = d
cnt = 1
elif ma == d:
cnt += 1
heappush(h, x)
print(cnt)
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
13,
0,
13,
17,
28,
13,
13,
14,
2,
2,
13,
17,
2,
13,
17,
0,
13,
13,
0,
13,
13,
9,
14,
2,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
13,
13,
14,
2,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
13,
14,
2,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
8,
2,
13,
13,
13,
17,
0,
13,
13,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
8,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13
] |
[
[
187,
2
],
[
187,
12
],
[
235,
14
],
[
220,
25
],
[
166,
28
],
[
223,
31
],
[
229,
34
],
[
208,
37
],
[
211,
40
],
[
202,
43
],
[
221,
44
],
[
193,
46
],
[
50,
49
],
[
236,
49
],
[
167,
54
],
[
233,
54
],
[
206,
54
],
[
170,
54
],
[
224,
57
],
[
173,
57
],
[
200,
57
],
[
169,
60
],
[
49,
61
],
[
199,
63
],
[
49,
64
],
[
170,
68
],
[
167,
68
],
[
233,
68
],
[
206,
68
],
[
49,
69
],
[
181,
71
],
[
238,
74
],
[
203,
77
],
[
242,
77
],
[
197,
77
],
[
245,
77
],
[
239,
77
],
[
230,
78
],
[
185,
78
],
[
215,
78
],
[
182,
79
],
[
209,
79
],
[
191,
79
],
[
200,
82
],
[
224,
82
],
[
173,
82
],
[
49,
83
],
[
214,
85
],
[
170,
89
],
[
167,
89
],
[
233,
89
],
[
206,
89
],
[
49,
90
],
[
205,
92
],
[
49,
93
],
[
190,
95
],
[
212,
99
],
[
248,
99
],
[
206,
101
],
[
170,
101
],
[
167,
101
],
[
233,
101
],
[
200,
102
],
[
224,
102
],
[
173,
102
],
[
244,
104
],
[
239,
107
],
[
203,
107
],
[
242,
107
],
[
197,
107
],
[
245,
107
],
[
215,
108
],
[
230,
108
],
[
185,
108
],
[
191,
109
],
[
182,
109
],
[
209,
109
],
[
212,
112
],
[
248,
112
],
[
206,
114
],
[
170,
114
],
[
167,
114
],
[
233,
114
],
[
200,
115
],
[
224,
115
],
[
173,
115
],
[
247,
117
],
[
206,
119
],
[
170,
119
],
[
167,
119
],
[
233,
119
],
[
200,
120
],
[
224,
120
],
[
173,
120
],
[
217,
122
],
[
196,
125
],
[
239,
128
],
[
203,
128
],
[
242,
128
],
[
197,
128
],
[
245,
128
],
[
215,
129
],
[
230,
129
],
[
185,
129
],
[
191,
130
],
[
182,
130
],
[
209,
130
],
[
200,
133
],
[
224,
133
],
[
173,
133
],
[
49,
134
],
[
172,
136
],
[
49,
137
],
[
232,
139
],
[
49,
140
],
[
184,
142
],
[
178,
145
],
[
197,
148
],
[
245,
148
],
[
239,
148
],
[
203,
148
],
[
242,
148
],
[
221,
149
],
[
197,
150
],
[
245,
150
],
[
239,
150
],
[
203,
150
],
[
242,
150
],
[
241,
153
],
[
221,
154
],
[
242,
157
],
[
197,
157
],
[
245,
157
],
[
239,
157
],
[
203,
157
],
[
221,
158
],
[
226,
160
],
[
242,
161
],
[
197,
161
],
[
245,
161
],
[
239,
161
],
[
203,
161
],
[
227,
164
],
[
179,
164
],
[
218,
164
],
[
194,
164
],
[
166,
167
],
[
49,
169
],
[
169,
170
],
[
49,
172
],
[
172,
173
],
[
187,
176
],
[
178,
179
],
[
181,
182
],
[
184,
185
],
[
187,
188
],
[
190,
191
],
[
193,
194
],
[
196,
197
],
[
49,
199
],
[
199,
200
],
[
221,
202
],
[
202,
203
],
[
49,
205
],
[
205,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
242,
226
],
[
197,
226
],
[
245,
226
],
[
239,
226
],
[
203,
226
],
[
226,
227
],
[
229,
230
],
[
49,
232
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
221,
241
],
[
241,
242
],
[
244,
245
],
[
247,
248
]
] |
[
"n, t = map(int, input().split(\" \"))\n\na = map(int, input().split(\" \"))\n\nINF = 1000000000000\n\nmax_price = -1\nmin_price = -1\n\nmin_pos = 1\nmax_pos = 1\nmax_diff = 0\ntmp = INF\nans = 0\n\nfor c in a:\n if max_price < 0 or min_price < 0:\n max_price = c\n min_price = c\n continue\n\n if max_price == c:\n max_pos += 1\n tmp = min(tmp, min_pos, max_pos)\n\n if min_price == c:\n min_pos += 1\n\n if max_price < c:\n max_price = c\n max_pos = 1\n\n if max_diff == max_price - min_price:\n tmp = min(tmp, min_pos, max_pos)\n\n elif max_diff < max_price - min_price:\n max_diff = max_price - min_price\n ans = 0\n tmp = min(tmp, min_pos, max_pos)\n\n if min_price > c:\n min_price = c\n max_price = c\n min_pos = 1\n ans += (tmp if tmp < INF else 0)\n tmp = INF\n\nif tmp < INF:\n ans += tmp\n\nprint(ans)",
"n, t = map(int, input().split(\" \"))",
"n",
"map(int, input().split(\" \"))",
"map",
"int",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"t",
"a = map(int, input().split(\" \"))",
"a",
"map(int, input().split(\" \"))",
"map",
"int",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"INF = 1000000000000",
"INF",
"1000000000000",
"max_price = -1",
"max_price",
"-1",
"min_price = -1",
"min_price",
"-1",
"min_pos = 1",
"min_pos",
"1",
"max_pos = 1",
"max_pos",
"1",
"max_diff = 0",
"max_diff",
"0",
"tmp = INF",
"tmp",
"INF",
"ans = 0",
"ans",
"0",
"for c in a:\n if max_price < 0 or min_price < 0:\n max_price = c\n min_price = c\n continue\n\n if max_price == c:\n max_pos += 1\n tmp = min(tmp, min_pos, max_pos)\n\n if min_price == c:\n min_pos += 1\n\n if max_price < c:\n max_price = c\n max_pos = 1\n\n if max_diff == max_price - min_price:\n tmp = min(tmp, min_pos, max_pos)\n\n elif max_diff < max_price - min_price:\n max_diff = max_price - min_price\n ans = 0\n tmp = min(tmp, min_pos, max_pos)\n\n if min_price > c:\n min_price = c\n max_price = c\n min_pos = 1\n ans += (tmp if tmp < INF else 0)\n tmp = INF",
"c",
"a",
"if max_price < 0 or min_price < 0:\n max_price = c\n min_price = c\n continue\n\n ",
"max_price < 0 or min_price < 0",
"max_price < 0",
"max_price",
"0",
"min_price < 0",
"min_price",
"0",
"max_price = c",
"max_price",
"c",
"min_price = c",
"min_price",
"c",
"continue",
"if max_price == c:\n max_pos += 1\n tmp = min(tmp, min_pos, max_pos)\n\n ",
"max_price == c",
"max_price",
"c",
"max_pos += 1",
"max_pos",
"1",
"tmp = min(tmp, min_pos, max_pos)",
"tmp",
"min(tmp, min_pos, max_pos)",
"min",
"tmp",
"min_pos",
"max_pos",
"if min_price == c:\n min_pos += 1\n\n ",
"min_price == c",
"min_price",
"c",
"min_pos += 1",
"min_pos",
"1",
"if max_price < c:\n max_price = c\n max_pos = 1\n\n if max_diff == max_price - min_price:\n tmp = min(tmp, min_pos, max_pos)\n\n elif max_diff < max_price - min_price:\n max_diff = max_price - min_price\n ans = 0\n tmp = min(tmp, min_pos, max_pos)\n\n ",
"max_price < c",
"max_price",
"c",
"max_price = c",
"max_price",
"c",
"max_pos = 1",
"max_pos",
"1",
"if max_diff == max_price - min_price:\n tmp = min(tmp, min_pos, max_pos)\n\n elif max_diff < max_price - min_price:\n max_diff = max_price - min_price\n ans = 0\n tmp = min(tmp, min_pos, max_pos)\n\n ",
"max_diff == max_price - min_price",
"max_diff",
"max_price - min_price",
"max_price",
"min_price",
"tmp = min(tmp, min_pos, max_pos)",
"tmp",
"min(tmp, min_pos, max_pos)",
"min",
"tmp",
"min_pos",
"max_pos",
"elif max_diff < max_price - min_price:\n max_diff = max_price - min_price\n ans = 0\n tmp = min(tmp, min_pos, max_pos)\n\n ",
"max_diff < max_price - min_price",
"max_diff",
"max_price - min_price",
"max_price",
"min_price",
"max_diff = max_price - min_price",
"max_diff",
"max_price - min_price",
"max_price",
"min_price",
"ans = 0",
"ans",
"0",
"tmp = min(tmp, min_pos, max_pos)",
"tmp",
"min(tmp, min_pos, max_pos)",
"min",
"tmp",
"min_pos",
"max_pos",
"if min_price > c:\n min_price = c\n max_price = c\n min_pos = 1\n ans += (tmp if tmp < INF else 0)\n tmp = INF",
"min_price > c",
"min_price",
"c",
"min_price = c",
"min_price",
"c",
"max_price = c",
"max_price",
"c",
"min_pos = 1",
"min_pos",
"1",
"ans += (tmp if tmp < INF else 0)",
"ans",
"tmp if tmp < INF else 0",
"tmp < INF",
"tmp",
"INF",
"tmp",
"0",
"tmp = INF",
"tmp",
"INF",
"if tmp < INF:\n ans += tmp",
"tmp < INF",
"tmp",
"INF",
"ans += tmp",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"max_price = -1",
"-1",
"max_price",
"max_price = c",
"c",
"max_price",
"min_price = c",
"c",
"min_price",
"n, t = map(int, input().split(\" \"))",
"map(int, input().split(\" \"))",
"n",
"ans += (tmp if tmp < INF else 0)",
"tmp if tmp < INF else 0",
"ans",
"max_pos += 1",
"1",
"max_pos",
"min_pos = 1",
"1",
"min_pos",
"t = map(int, input().split(\" \"))",
"map(int, input().split(\" \"))",
"t",
"max_pos = 1",
"1",
"max_pos",
"ans = 0",
"0",
"ans",
"tmp = min(tmp, min_pos, max_pos)",
"min(tmp, min_pos, max_pos)",
"tmp",
"min_price = c",
"c",
"min_price",
"tmp = INF",
"INF",
"tmp",
"max_price = c",
"c",
"max_price",
"max_pos = 1",
"1",
"max_pos",
"max_diff = 0",
"0",
"max_diff",
"min_pos += 1",
"1",
"min_pos",
"ans = 0",
"0",
"ans",
"INF = 1000000000000",
"1000000000000",
"INF",
"min_price = -1",
"-1",
"min_price",
"ans += tmp",
"tmp",
"ans",
"min_pos = 1",
"1",
"min_pos",
"max_price = c",
"c",
"max_price",
"a = map(int, input().split(\" \"))",
"map(int, input().split(\" \"))",
"a",
"tmp = min(tmp, min_pos, max_pos)",
"min(tmp, min_pos, max_pos)",
"tmp",
"tmp = INF",
"INF",
"tmp",
"tmp = min(tmp, min_pos, max_pos)",
"min(tmp, min_pos, max_pos)",
"tmp",
"max_diff = max_price - min_price",
"max_price - min_price",
"max_diff"
] |
n, t = map(int, input().split(" "))
a = map(int, input().split(" "))
INF = 1000000000000
max_price = -1
min_price = -1
min_pos = 1
max_pos = 1
max_diff = 0
tmp = INF
ans = 0
for c in a:
if max_price < 0 or min_price < 0:
max_price = c
min_price = c
continue
if max_price == c:
max_pos += 1
tmp = min(tmp, min_pos, max_pos)
if min_price == c:
min_pos += 1
if max_price < c:
max_price = c
max_pos = 1
if max_diff == max_price - min_price:
tmp = min(tmp, min_pos, max_pos)
elif max_diff < max_price - min_price:
max_diff = max_price - min_price
ans = 0
tmp = min(tmp, min_pos, max_pos)
if min_price > c:
min_price = c
max_price = c
min_pos = 1
ans += (tmp if tmp < INF else 0)
tmp = INF
if tmp < INF:
ans += tmp
print(ans)
|
[
7,
15,
13,
13,
13,
13,
13,
13,
13,
13,
12,
13,
4,
18,
13,
13,
2,
17,
17,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
0,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
2,
17,
4,
18,
13,
13,
0,
13,
2,
39,
17,
2,
13,
17,
12,
13,
0,
13,
2,
13,
17,
0,
18,
13,
13,
13,
42,
2,
13,
17,
0,
13,
2,
2,
13,
17,
17,
0,
18,
13,
13,
4,
13,
18,
13,
2,
2,
13,
17,
17,
18,
13,
2,
2,
13,
17,
17,
23,
13,
23,
13,
12,
13,
14,
2,
40,
13,
13,
40,
13,
13,
14,
2,
40,
13,
13,
40,
13,
13,
0,
13,
4,
13,
13,
13,
2,
2,
13,
17,
17,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
2,
2,
13,
17,
17,
2,
2,
13,
13,
17,
13,
29,
4,
13,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
39,
28,
13,
13,
4,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
13,
13,
13,
4,
13,
2,
13,
17,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
2,
4,
13,
2,
13,
17,
2,
13,
17,
17,
17,
13,
18,
13,
2,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
22,
21
],
[
21,
34
],
[
37,
36
],
[
41,
40
],
[
36,
42
],
[
41,
43
],
[
46,
45
],
[
40,
50
],
[
54,
53
],
[
45,
58
],
[
64,
63
],
[
45,
65
],
[
71,
68
],
[
53,
69
],
[
63,
70
],
[
104,
70
],
[
106,
71
],
[
63,
74
],
[
104,
74
],
[
77,
74
],
[
78,
77
],
[
63,
80
],
[
104,
80
],
[
77,
80
],
[
87,
84
],
[
53,
85
],
[
77,
86
],
[
63,
86
],
[
104,
86
],
[
53,
90
],
[
77,
93
],
[
63,
93
],
[
104,
93
],
[
53,
97
],
[
77,
100
],
[
63,
100
],
[
104,
100
],
[
104,
104
],
[
106,
106
],
[
165,
112
],
[
171,
113
],
[
173,
115
],
[
167,
116
],
[
165,
120
],
[
173,
121
],
[
167,
123
],
[
171,
124
],
[
127,
126
],
[
165,
129
],
[
167,
130
],
[
169,
133
],
[
171,
136
],
[
171,
139
],
[
173,
140
],
[
144,
143
],
[
165,
146
],
[
167,
147
],
[
169,
150
],
[
171,
155
],
[
173,
156
],
[
173,
158
],
[
126,
162
],
[
143,
163
],
[
165,
165
],
[
167,
167
],
[
169,
169
],
[
171,
171
],
[
173,
173
],
[
176,
175
],
[
193,
192
],
[
192,
195
],
[
175,
198
],
[
192,
200
],
[
61,
202
],
[
192,
206
],
[
209,
208
],
[
212,
211
],
[
215,
214
],
[
40,
218
],
[
221,
220
],
[
108,
223
],
[
214,
225
],
[
40,
228
],
[
45,
232
],
[
175,
234
],
[
214,
236
],
[
220,
240
],
[
192,
240
],
[
208,
241
],
[
243,
241
],
[
244,
243
],
[
220,
244
],
[
192,
244
],
[
247,
246
],
[
220,
250
],
[
192,
250
],
[
208,
251
],
[
243,
251
],
[
254,
253
],
[
253,
257
],
[
246,
257
],
[
211,
257
],
[
266,
263
]
] |
[
"import sys,queue,math,copy,itertools,bisect,collections,heapq\n\ndef main():\n sys.setrecursionlimit(10**7)\n LI = lambda : [int(x) for x in sys.stdin.readline().split()]\n\n N,_ = LI()\n N0 = 2 ** N.bit_length()\n st = [0] * (N0*2)\n\n def add(p,x):\n p += N0-1\n st[p] = x\n while p > 0:\n p = (p-1) // 2\n st[p] = max(st[p*2+1],st[p*2+2])\n\n def get(a,b,x,l,r):\n if a <= l and r <= b: return st[x]\n if a >= r or b <= l: return 0\n vl = get(a,b,x*2+1,l,(l+r)//2)\n vr = get(a,b,x*2+2,(l+r)//2,r)\n return max(vl,vr)\n\n A = []\n for e,a in enumerate(sys.stdin.readline().split()):\n a = int(a)\n A.append(a)\n add(e+1,a)\n max_a = -1\n max_cnt = 0\n for i in range(1,N):\n a = get(i+1,N+1,0,0,N0) - A[i-1]\n if a > max_a:\n max_a = a; max_cnt = 1\n elif a == max_a:\n max_cnt += 1\n\n print(max_cnt)\n\n\nif __name__ == '__main__':\n main()",
"import sys,queue,math,copy,itertools,bisect,collections,heapq",
"sys",
"queue",
"math",
"copy",
"itertools",
"bisect",
"collections",
"heapq",
"def main():\n sys.setrecursionlimit(10**7)\n LI = lambda : [int(x) for x in sys.stdin.readline().split()]\n\n N,_ = LI()\n N0 = 2 ** N.bit_length()\n st = [0] * (N0*2)\n\n def add(p,x):\n p += N0-1\n st[p] = x\n while p > 0:\n p = (p-1) // 2\n st[p] = max(st[p*2+1],st[p*2+2])\n\n def get(a,b,x,l,r):\n if a <= l and r <= b: return st[x]\n if a >= r or b <= l: return 0\n vl = get(a,b,x*2+1,l,(l+r)//2)\n vr = get(a,b,x*2+2,(l+r)//2,r)\n return max(vl,vr)\n\n A = []\n for e,a in enumerate(sys.stdin.readline().split()):\n a = int(a)\n A.append(a)\n add(e+1,a)\n max_a = -1\n max_cnt = 0\n for i in range(1,N):\n a = get(i+1,N+1,0,0,N0) - A[i-1]\n if a > max_a:\n max_a = a; max_cnt = 1\n elif a == max_a:\n max_cnt += 1\n\n print(max_cnt)",
"main",
"sys.setrecursionlimit(10**7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**7",
"10",
"7",
"int(x) for x in sys.stdin.readline().split()",
"for x in sys.stdin.readline().split()",
"x",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for x in sys.stdin.readline().split()",
"int(x)",
"int",
"x",
"LI = lambda : [int(x) for x in sys.stdin.readline().split()]",
"LI",
"lambda : [int(x) for x in sys.stdin.readline().split()]",
"[int(x) for x in sys.stdin.readline().split()]",
"N,_ = LI()",
"N",
"LI()",
"LI",
"_",
"N0 = 2 ** N.bit_length()",
"N0",
"2 ** N.bit_length()",
"2",
"N.bit_length()",
"N.bit_length",
"N",
"bit_length",
"st = [0] * (N0*2)",
"st",
"[0] * (N0*2)",
"[0]",
"0",
"N0*2",
"N0",
"2",
"def add(p,x):\n p += N0-1\n st[p] = x\n while p > 0:\n p = (p-1) // 2\n st[p] = max(st[p*2+1],st[p*2+2])\n\n ",
"add",
"p += N0-1",
"p",
"N0-1",
"N0",
"1",
"st[p] = x",
"st[p]",
"st",
"p",
"x",
"while p > 0:\n p = (p-1) // 2\n st[p] = max(st[p*2+1],st[p*2+2])\n\n ",
"p > 0",
"p",
"0",
"p = (p-1) // 2",
"p",
"(p-1) // 2",
"p-1",
"p",
"1",
"2",
"st[p] = max(st[p*2+1],st[p*2+2])",
"st[p]",
"st",
"p",
"max(st[p*2+1],st[p*2+2])",
"max",
"st[p*2+1]",
"st",
"p*2+1",
"p*2",
"p",
"2",
"1",
"st[p*2+2]",
"st",
"p*2+2",
"p*2",
"p",
"2",
"2",
"p",
"p",
"x",
"x",
"def get(a,b,x,l,r):\n if a <= l and r <= b: return st[x]\n if a >= r or b <= l: return 0\n vl = get(a,b,x*2+1,l,(l+r)//2)\n vr = get(a,b,x*2+2,(l+r)//2,r)\n return max(vl,vr)\n\n ",
"get",
"if a <= l and r <= b: return st[x]\n ",
"a <= l and r <= b",
"a <= l",
"a",
"l",
"r <= b",
"r",
"b",
"if a >= r or b <= l: return 0\n ",
"a >= r or b <= l",
"a >= r",
"a",
"r",
"b <= l",
"b",
"l",
"vl = get(a,b,x*2+1,l,(l+r)//2)",
"vl",
"get(a,b,x*2+1,l,(l+r)//2)",
"get",
"a",
"b",
"x*2+1",
"x*2",
"x",
"2",
"1",
"l",
"(l+r)//2",
"l+r",
"l",
"r",
"2",
"vr = get(a,b,x*2+2,(l+r)//2,r)",
"vr",
"get(a,b,x*2+2,(l+r)//2,r)",
"get",
"a",
"b",
"x*2+2",
"x*2",
"x",
"2",
"2",
"(l+r)//2",
"l+r",
"l",
"r",
"2",
"r",
"return max(vl,vr)",
"max(vl,vr)",
"max",
"vl",
"vr",
"a",
"a",
"b",
"b",
"x",
"x",
"l",
"l",
"r",
"r",
"A = []",
"A",
"[]",
"for e,a in enumerate(sys.stdin.readline().split()):\n a = int(a)\n A.append(a)\n add(e+1,a)\n ",
"e",
"a",
"enumerate(sys.stdin.readline().split())",
"enumerate",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"a = int(a)",
"a",
"int(a)",
"int",
"a",
"A.append(a)",
"A.append",
"A",
"append",
"a",
"add(e+1,a)",
"add",
"e+1",
"e",
"1",
"a",
"max_a = -1",
"max_a",
"-1",
"max_cnt = 0",
"max_cnt",
"0",
"for i in range(1,N):\n a = get(i+1,N+1,0,0,N0) - A[i-1]\n if a > max_a:\n max_a = a; max_cnt = 1\n elif a == max_a:\n max_cnt += 1\n\n ",
"i",
"range(1,N)",
"range",
"1",
"N",
"a = get(i+1,N+1,0,0,N0) - A[i-1]",
"a",
"get(i+1,N+1,0,0,N0) - A[i-1]",
"get(i+1,N+1,0,0,N0)",
"get",
"i+1",
"i",
"1",
"N+1",
"N",
"1",
"0",
"0",
"N0",
"A[i-1]",
"A",
"i-1",
"i",
"1",
"if a > max_a:\n max_a = a; max_cnt = 1\n elif a == max_a:\n max_cnt += 1\n\n ",
"a > max_a",
"a",
"max_a",
"max_a = a",
"max_a",
"a",
"max_cnt = 1",
"max_cnt",
"1",
"elif a == max_a:\n max_cnt += 1\n\n ",
"a == max_a",
"a",
"max_a",
"max_cnt += 1",
"max_cnt",
"1",
"print(max_cnt)",
"print",
"max_cnt",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n sys.setrecursionlimit(10**7)\n LI = lambda : [int(x) for x in sys.stdin.readline().split()]\n\n N,_ = LI()\n N0 = 2 ** N.bit_length()\n st = [0] * (N0*2)\n\n def add(p,x):\n p += N0-1\n st[p] = x\n while p > 0:\n p = (p-1) // 2\n st[p] = max(st[p*2+1],st[p*2+2])\n\n def get(a,b,x,l,r):\n if a <= l and r <= b: return st[x]\n if a >= r or b <= l: return 0\n vl = get(a,b,x*2+1,l,(l+r)//2)\n vr = get(a,b,x*2+2,(l+r)//2,r)\n return max(vl,vr)\n\n A = []\n for e,a in enumerate(sys.stdin.readline().split()):\n a = int(a)\n A.append(a)\n add(e+1,a)\n max_a = -1\n max_cnt = 0\n for i in range(1,N):\n a = get(i+1,N+1,0,0,N0) - A[i-1]\n if a > max_a:\n max_a = a; max_cnt = 1\n elif a == max_a:\n max_cnt += 1\n\n print(max_cnt)",
"def main():\n sys.setrecursionlimit(10**7)\n LI = lambda : [int(x) for x in sys.stdin.readline().split()]\n\n N,_ = LI()\n N0 = 2 ** N.bit_length()\n st = [0] * (N0*2)\n\n def add(p,x):\n p += N0-1\n st[p] = x\n while p > 0:\n p = (p-1) // 2\n st[p] = max(st[p*2+1],st[p*2+2])\n\n def get(a,b,x,l,r):\n if a <= l and r <= b: return st[x]\n if a >= r or b <= l: return 0\n vl = get(a,b,x*2+1,l,(l+r)//2)\n vr = get(a,b,x*2+2,(l+r)//2,r)\n return max(vl,vr)\n\n A = []\n for e,a in enumerate(sys.stdin.readline().split()):\n a = int(a)\n A.append(a)\n add(e+1,a)\n max_a = -1\n max_cnt = 0\n for i in range(1,N):\n a = get(i+1,N+1,0,0,N0) - A[i-1]\n if a > max_a:\n max_a = a; max_cnt = 1\n elif a == max_a:\n max_cnt += 1\n\n print(max_cnt)",
"main"
] |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
N,_ = LI()
N0 = 2 ** N.bit_length()
st = [0] * (N0*2)
def add(p,x):
p += N0-1
st[p] = x
while p > 0:
p = (p-1) // 2
st[p] = max(st[p*2+1],st[p*2+2])
def get(a,b,x,l,r):
if a <= l and r <= b: return st[x]
if a >= r or b <= l: return 0
vl = get(a,b,x*2+1,l,(l+r)//2)
vr = get(a,b,x*2+2,(l+r)//2,r)
return max(vl,vr)
A = []
for e,a in enumerate(sys.stdin.readline().split()):
a = int(a)
A.append(a)
add(e+1,a)
max_a = -1
max_cnt = 0
for i in range(1,N):
a = get(i+1,N+1,0,0,N0) - A[i-1]
if a > max_a:
max_a = a; max_cnt = 1
elif a == max_a:
max_cnt += 1
print(max_cnt)
if __name__ == '__main__':
main()
|
[
7,
15,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
17,
0,
13,
4,
13,
13,
28,
13,
13,
0,
13,
4,
13,
13,
13,
0,
18,
13,
2,
13,
13,
17,
4,
13,
18,
13,
4,
13,
4,
18,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
6,
5
],
[
6,
14
],
[
17,
16
],
[
29,
28
],
[
36,
35
],
[
39,
38
],
[
44,
43
],
[
16,
43
],
[
47,
46
],
[
28,
49
],
[
46,
49
],
[
43,
50
],
[
57,
52
],
[
38,
53
],
[
43,
55
],
[
46,
56
],
[
28,
56
],
[
38,
61
],
[
38,
66
],
[
76,
73
]
] |
[
"#!/usr/bin/python3\n# -*- coding:utf-8 -*-\n\nfrom collections import defaultdict\n\ndef main():\n n, t = map(int, input().split())\n la = list(map(int, input().split()))\n min_a = 10**9 + 7\n max_a = -1\n \n cnts = defaultdict(int)\n for a in la:\n min_a = min(min_a, a)\n cnts[a - min_a] += 1\n print(cnts[max(cnts.keys())])\n\nif __name__=='__main__':\n main()\n",
"from collections import defaultdict",
"def main():\n n, t = map(int, input().split())\n la = list(map(int, input().split()))\n min_a = 10**9 + 7\n max_a = -1\n \n cnts = defaultdict(int)\n for a in la:\n min_a = min(min_a, a)\n cnts[a - min_a] += 1\n print(cnts[max(cnts.keys())])",
"main",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"la = list(map(int, input().split()))",
"la",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_a = 10**9 + 7",
"min_a",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"max_a = -1",
"max_a",
"-1",
"cnts = defaultdict(int)",
"cnts",
"defaultdict(int)",
"defaultdict",
"int",
"for a in la:\n min_a = min(min_a, a)\n cnts[a - min_a] += 1\n ",
"a",
"la",
"min_a = min(min_a, a)",
"min_a",
"min(min_a, a)",
"min",
"min_a",
"a",
"cnts[a - min_a] += 1",
"cnts[a - min_a]",
"cnts",
"a - min_a",
"a",
"min_a",
"1",
"print(cnts[max(cnts.keys())])",
"print",
"cnts[max(cnts.keys())]",
"cnts",
"max(cnts.keys())",
"max",
"cnts.keys()",
"cnts.keys",
"cnts",
"keys",
"if __name__=='__main__':\n main()",
"__name__=='__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n n, t = map(int, input().split())\n la = list(map(int, input().split()))\n min_a = 10**9 + 7\n max_a = -1\n \n cnts = defaultdict(int)\n for a in la:\n min_a = min(min_a, a)\n cnts[a - min_a] += 1\n print(cnts[max(cnts.keys())])",
"def main():\n n, t = map(int, input().split())\n la = list(map(int, input().split()))\n min_a = 10**9 + 7\n max_a = -1\n \n cnts = defaultdict(int)\n for a in la:\n min_a = min(min_a, a)\n cnts[a - min_a] += 1\n print(cnts[max(cnts.keys())])",
"main"
] |
#!/usr/bin/python3
# -*- coding:utf-8 -*-
from collections import defaultdict
def main():
n, t = map(int, input().split())
la = list(map(int, input().split()))
min_a = 10**9 + 7
max_a = -1
cnts = defaultdict(int)
for a in la:
min_a = min(min_a, a)
cnts[a - min_a] += 1
print(cnts[max(cnts.keys())])
if __name__=='__main__':
main()
|
[
7,
15,
13,
15,
13,
15,
4,
18,
13,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
13,
41,
28,
13,
4,
13,
13,
4,
2,
39,
4,
13,
13,
13,
12,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
14,
2,
13,
17,
4,
13,
17,
4,
13,
0,
13,
39,
4,
18,
13,
13,
18,
13,
17,
4,
18,
13,
13,
4,
13,
18,
13,
17,
18,
13,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
17,
9,
4,
18,
13,
13,
4,
13,
18,
13,
17,
13,
0,
13,
2,
39,
17,
13,
28,
13,
13,
4,
13,
13,
14,
2,
13,
17,
0,
18,
13,
17,
17,
9,
0,
18,
13,
13,
4,
13,
2,
18,
13,
13,
18,
13,
2,
13,
17,
17,
0,
13,
4,
13,
13,
4,
13,
4,
18,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13
] |
[
[
219,
12
],
[
222,
19
],
[
204,
31
],
[
223,
36
],
[
216,
38
],
[
223,
46
],
[
213,
49
],
[
217,
54
],
[
201,
56
],
[
223,
59
],
[
63,
62
],
[
76,
76
],
[
78,
78
],
[
80,
80
],
[
85,
84
],
[
217,
86
],
[
85,
87
],
[
90,
89
],
[
214,
91
],
[
84,
94
],
[
103,
102
],
[
102,
106
],
[
89,
109
],
[
102,
113
],
[
89,
118
],
[
89,
121
],
[
89,
128
],
[
102,
136
],
[
102,
141
],
[
146,
145
],
[
84,
149
],
[
102,
155
],
[
164,
161
],
[
145,
162
],
[
170,
167
],
[
145,
168
],
[
89,
174
],
[
102,
177
],
[
184,
183
],
[
145,
186
],
[
145,
191
],
[
183,
193
],
[
208,
199
],
[
201,
202
],
[
204,
205
],
[
213,
214
],
[
216,
217
],
[
219,
220
],
[
222,
223
]
] |
[
"import sys\nimport math\nfrom collections import deque\n\nsys.setrecursionlimit(1000000)\nMOD = 10 ** 9 + 7\ninput = lambda: sys.stdin.readline().strip()\nNI = lambda: int(input())\nNMI = lambda: map(int, input().split())\nNLI = lambda: list(NMI())\nSI = lambda: input()\n\n\ndef make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]\n\n\ndef main():\n N, T = NMI()\n A = NLI()\n\n if N == 1:\n print(1)\n exit()\n\n A_min = []\n A_min.append(A[0])\n A_min.append(min(A[0], A[1]))\n for i, a in enumerate(A):\n if i < 2:\n continue\n A_min.append(min(A_min[-1], a))\n\n diff = [0] * N\n for i, am in enumerate(A_min):\n if i == 0:\n diff[0] = 0\n continue\n diff[i] = max(A[i] - A_min[i-1], 0)\n diff_max = max(diff)\n print(diff.count(diff_max))\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"import math",
"math",
"from collections import deque",
"sys.setrecursionlimit(1000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"input = lambda: sys.stdin.readline().strip()",
"input",
"lambda: sys.stdin.readline().strip()",
"sys.stdin.readline().strip()",
"sys.stdin.readline().strip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"strip",
"NI = lambda: int(input())",
"NI",
"lambda: int(input())",
"int(input())",
"int",
"input()",
"input",
"NMI = lambda: map(int, input().split())",
"NMI",
"lambda: map(int, input().split())",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"NLI = lambda: list(NMI())",
"NLI",
"lambda: list(NMI())",
"list(NMI())",
"list",
"NMI()",
"NMI",
"SI = lambda: input()",
"SI",
"lambda: input()",
"input()",
"input",
"[int(num)] * w for _ in range(h)",
"for _ in range(h)",
"_",
"range(h)",
"range",
"h",
"for _ in range(h)",
"[int(num)] * w",
"[int(num)]",
"int(num)",
"int",
"num",
"w",
"def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]",
"make_grid",
"h",
"h",
"w",
"w",
"num",
"num",
"def main():\n N, T = NMI()\n A = NLI()\n\n if N == 1:\n print(1)\n exit()\n\n A_min = []\n A_min.append(A[0])\n A_min.append(min(A[0], A[1]))\n for i, a in enumerate(A):\n if i < 2:\n continue\n A_min.append(min(A_min[-1], a))\n\n diff = [0] * N\n for i, am in enumerate(A_min):\n if i == 0:\n diff[0] = 0\n continue\n diff[i] = max(A[i] - A_min[i-1], 0)\n diff_max = max(diff)\n print(diff.count(diff_max))",
"main",
"N, T = NMI()",
"N",
"NMI()",
"NMI",
"T",
"A = NLI()",
"A",
"NLI()",
"NLI",
"if N == 1:\n print(1)\n exit()\n\n ",
"N == 1",
"N",
"1",
"print(1)",
"print",
"1",
"exit()",
"exit",
"A_min = []",
"A_min",
"[]",
"A_min.append(A[0])",
"A_min.append",
"A_min",
"append",
"A[0]",
"A",
"0",
"A_min.append(min(A[0], A[1]))",
"A_min.append",
"A_min",
"append",
"min(A[0], A[1])",
"min",
"A[0]",
"A",
"0",
"A[1]",
"A",
"1",
"for i, a in enumerate(A):\n if i < 2:\n continue\n A_min.append(min(A_min[-1], a))\n\n ",
"i",
"a",
"enumerate(A)",
"enumerate",
"A",
"if i < 2:\n continue\n ",
"i < 2",
"i",
"2",
"continue",
"A_min.append(min(A_min[-1], a))",
"A_min.append",
"A_min",
"append",
"min(A_min[-1], a)",
"min",
"A_min[-1]",
"A_min",
"-1",
"a",
"diff = [0] * N",
"diff",
"[0] * N",
"[0]",
"0",
"N",
"for i, am in enumerate(A_min):\n if i == 0:\n diff[0] = 0\n continue\n diff[i] = max(A[i] - A_min[i-1], 0)\n ",
"i",
"am",
"enumerate(A_min)",
"enumerate",
"A_min",
"if i == 0:\n diff[0] = 0\n continue\n ",
"i == 0",
"i",
"0",
"diff[0] = 0",
"diff[0]",
"diff",
"0",
"0",
"continue",
"diff[i] = max(A[i] - A_min[i-1], 0)",
"diff[i]",
"diff",
"i",
"max(A[i] - A_min[i-1], 0)",
"max",
"A[i] - A_min[i-1]",
"A[i]",
"A",
"i",
"A_min[i-1]",
"A_min",
"i-1",
"i",
"1",
"0",
"diff_max = max(diff)",
"diff_max",
"max(diff)",
"max",
"diff",
"print(diff.count(diff_max))",
"print",
"diff.count(diff_max)",
"diff.count",
"diff",
"count",
"diff_max",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"SI = lambda: input()",
"lambda: input()",
"SI",
"NI = lambda: int(input())",
"lambda: int(input())",
"NI",
"def main():\n N, T = NMI()\n A = NLI()\n\n if N == 1:\n print(1)\n exit()\n\n A_min = []\n A_min.append(A[0])\n A_min.append(min(A[0], A[1]))\n for i, a in enumerate(A):\n if i < 2:\n continue\n A_min.append(min(A_min[-1], a))\n\n diff = [0] * N\n for i, am in enumerate(A_min):\n if i == 0:\n diff[0] = 0\n continue\n diff[i] = max(A[i] - A_min[i-1], 0)\n diff_max = max(diff)\n print(diff.count(diff_max))",
"def main():\n N, T = NMI()\n A = NLI()\n\n if N == 1:\n print(1)\n exit()\n\n A_min = []\n A_min.append(A[0])\n A_min.append(min(A[0], A[1]))\n for i, a in enumerate(A):\n if i < 2:\n continue\n A_min.append(min(A_min[-1], a))\n\n diff = [0] * N\n for i, am in enumerate(A_min):\n if i == 0:\n diff[0] = 0\n continue\n diff[i] = max(A[i] - A_min[i-1], 0)\n diff_max = max(diff)\n print(diff.count(diff_max))",
"main",
"def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]",
"def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]",
"make_grid",
"NLI = lambda: list(NMI())",
"lambda: list(NMI())",
"NLI",
"NMI = lambda: map(int, input().split())",
"lambda: map(int, input().split())",
"NMI",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"input = lambda: sys.stdin.readline().strip()",
"lambda: sys.stdin.readline().strip()",
"input"
] |
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
N, T = NMI()
A = NLI()
if N == 1:
print(1)
exit()
A_min = []
A_min.append(A[0])
A_min.append(min(A[0], A[1]))
for i, a in enumerate(A):
if i < 2:
continue
A_min.append(min(A_min[-1], a))
diff = [0] * N
for i, am in enumerate(A_min):
if i == 0:
diff[0] = 0
continue
diff[i] = max(A[i] - A_min[i-1], 0)
diff_max = max(diff)
print(diff.count(diff_max))
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,
2,
39,
17,
2,
13,
17,
0,
13,
2,
39,
17,
13,
0,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
0,
13,
2,
39,
2,
13,
17,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
2,
13,
13,
18,
13,
2,
2,
13,
13,
17,
0,
18,
13,
2,
13,
13,
18,
13,
2,
13,
13,
0,
18,
13,
2,
13,
13,
2,
13,
13,
0,
18,
13,
2,
13,
13,
18,
13,
2,
2,
13,
13,
17,
0,
18,
13,
2,
13,
13,
18,
13,
2,
2,
13,
13,
17,
0,
18,
13,
2,
13,
13,
2,
18,
13,
2,
13,
13,
18,
13,
2,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
2,
39,
17,
13,
28,
13,
13,
0,
18,
13,
18,
13,
13,
17,
4,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
211,
2
],
[
211,
11
],
[
208,
13
],
[
205,
25
],
[
212,
30
],
[
193,
33
],
[
212,
37
],
[
44,
39
],
[
194,
40
],
[
212,
42
],
[
209,
45
],
[
212,
47
],
[
199,
50
],
[
212,
54
],
[
212,
56
],
[
59,
58
],
[
212,
63
],
[
209,
68
],
[
212,
70
],
[
58,
71
],
[
194,
73
],
[
212,
76
],
[
58,
77
],
[
85,
80
],
[
194,
81
],
[
212,
83
],
[
58,
84
],
[
209,
86
],
[
212,
88
],
[
58,
89
],
[
96,
91
],
[
200,
92
],
[
212,
94
],
[
58,
95
],
[
212,
97
],
[
58,
98
],
[
105,
100
],
[
194,
101
],
[
212,
103
],
[
58,
104
],
[
194,
106
],
[
212,
109
],
[
58,
110
],
[
118,
113
],
[
200,
114
],
[
212,
116
],
[
58,
117
],
[
200,
119
],
[
212,
122
],
[
58,
123
],
[
131,
126
],
[
206,
127
],
[
212,
129
],
[
58,
130
],
[
194,
133
],
[
212,
135
],
[
58,
136
],
[
209,
138
],
[
212,
140
],
[
58,
141
],
[
214,
143
],
[
206,
146
],
[
202,
148
],
[
152,
151
],
[
212,
155
],
[
206,
160
],
[
151,
161
],
[
215,
162
],
[
203,
165
],
[
151,
167
],
[
190,
169
],
[
212,
173
],
[
176,
175
],
[
203,
175
],
[
183,
178
],
[
191,
179
],
[
200,
181
],
[
175,
182
],
[
191,
188
],
[
190,
191
],
[
193,
194
],
[
211,
197
],
[
199,
200
],
[
202,
203
],
[
205,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
]
] |
[
"N,T = map(int,input().split())\nA = list(map(int,input().split()))\n\ndata = [0]*(N-1)\nM = [0]*N\nM[N-1] = A[N-1]\nM_index = [N-1]*N\n\nfor i in range(2,N+1):\n if A[N-i] > M[N-i+1]:\n M[N-i] = A[N-i]\n M_index[N-i] = N-i\n else:\n M[N-i] = M[N-i+1]\n M_index[N-i] = M_index[N-i+1]\n data[N-i] = M[N-i] - A[N-i]\n\nm = max(data)\nl = []\nfor i in range(N-1):\n if data[i] == m:\n l.append(i)\n\nans = [0]*N\nfor x in l:\n ans[M_index[x]] = 1\n\n#####\n#print(\"A\",A)\n#print(\"M\",M)\n#print(\"M_index\",M_index)\n#print(\"data\",data)\n#print(\"ans\",ans)\n#####\n\nprint(sum(ans))",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"data = [0]*(N-1)",
"data",
"[0]*(N-1)",
"[0]",
"0",
"N-1",
"N",
"1",
"M = [0]*N",
"M",
"[0]*N",
"[0]",
"0",
"N",
"M[N-1] = A[N-1]",
"M[N-1]",
"M",
"N-1",
"N",
"1",
"A[N-1]",
"A",
"N-1",
"N",
"1",
"M_index = [N-1]*N",
"M_index",
"[N-1]*N",
"[N-1]",
"N-1",
"N",
"1",
"N",
"for i in range(2,N+1):\n if A[N-i] > M[N-i+1]:\n M[N-i] = A[N-i]\n M_index[N-i] = N-i\n else:\n M[N-i] = M[N-i+1]\n M_index[N-i] = M_index[N-i+1]\n data[N-i] = M[N-i] - A[N-i]",
"i",
"range(2,N+1)",
"range",
"2",
"N+1",
"N",
"1",
"if A[N-i] > M[N-i+1]:\n M[N-i] = A[N-i]\n M_index[N-i] = N-i\n else:\n M[N-i] = M[N-i+1]\n M_index[N-i] = M_index[N-i+1]\n ",
"A[N-i] > M[N-i+1]",
"A[N-i]",
"A",
"N-i",
"N",
"i",
"M[N-i+1]",
"M",
"N-i+1",
"N-i",
"N",
"i",
"1",
"M[N-i] = A[N-i]",
"M[N-i]",
"M",
"N-i",
"N",
"i",
"A[N-i]",
"A",
"N-i",
"N",
"i",
"M_index[N-i] = N-i",
"M_index[N-i]",
"M_index",
"N-i",
"N",
"i",
"N-i",
"N",
"i",
"M[N-i] = M[N-i+1]",
"M[N-i]",
"M",
"N-i",
"N",
"i",
"M[N-i+1]",
"M",
"N-i+1",
"N-i",
"N",
"i",
"1",
"M_index[N-i] = M_index[N-i+1]",
"M_index[N-i]",
"M_index",
"N-i",
"N",
"i",
"M_index[N-i+1]",
"M_index",
"N-i+1",
"N-i",
"N",
"i",
"1",
"data[N-i] = M[N-i] - A[N-i]",
"data[N-i]",
"data",
"N-i",
"N",
"i",
"M[N-i] - A[N-i]",
"M[N-i]",
"M",
"N-i",
"N",
"i",
"A[N-i]",
"A",
"N-i",
"N",
"i",
"m = max(data)",
"m",
"max(data)",
"max",
"data",
"l = []",
"l",
"[]",
"for i in range(N-1):\n if data[i] == m:\n l.append(i)",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if data[i] == m:\n l.append(i)",
"data[i] == m",
"data[i]",
"data",
"i",
"m",
"l.append(i)",
"l.append",
"l",
"append",
"i",
"ans = [0]*N",
"ans",
"[0]*N",
"[0]",
"0",
"N",
"for x in l:\n ans[M_index[x]] = 1\n\n#####\n#print(\"A\",A)\n#print(\"M\",M)\n#print(\"M_index\",M_index)\n#print(\"data\",data)\n#print(\"ans\",ans)\n#####",
"x",
"l",
"ans[M_index[x]] = 1",
"ans[M_index[x]]",
"ans",
"M_index[x]",
"M_index",
"x",
"1",
"print(sum(ans))",
"print",
"sum(ans)",
"sum",
"ans",
"ans = [0]*N",
"[0]*N",
"ans",
"M = [0]*N",
"[0]*N",
"M",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"M_index = [N-1]*N",
"[N-1]*N",
"M_index",
"l = []",
"[]",
"l",
"data = [0]*(N-1)",
"[0]*(N-1)",
"data",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"m = max(data)",
"max(data)",
"m"
] |
N,T = map(int,input().split())
A = list(map(int,input().split()))
data = [0]*(N-1)
M = [0]*N
M[N-1] = A[N-1]
M_index = [N-1]*N
for i in range(2,N+1):
if A[N-i] > M[N-i+1]:
M[N-i] = A[N-i]
M_index[N-i] = N-i
else:
M[N-i] = M[N-i+1]
M_index[N-i] = M_index[N-i+1]
data[N-i] = M[N-i] - A[N-i]
m = max(data)
l = []
for i in range(N-1):
if data[i] == m:
l.append(i)
ans = [0]*N
for x in l:
ans[M_index[x]] = 1
#####
#print("A",A)
#print("M",M)
#print("M_index",M_index)
#print("data",data)
#print("ans",ans)
#####
print(sum(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,
17,
0,
13,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
107,
2
],
[
107,
11
],
[
89,
13
],
[
27,
26
],
[
108,
29
],
[
95,
33
],
[
92,
36
],
[
90,
38
],
[
42,
41
],
[
108,
45
],
[
50,
47
],
[
96,
48
],
[
41,
49
],
[
90,
52
],
[
41,
53
],
[
93,
54
],
[
111,
54
],
[
110,
56
],
[
93,
59
],
[
111,
59
],
[
90,
61
],
[
41,
62
],
[
98,
64
],
[
96,
67
],
[
113,
69
],
[
73,
72
],
[
108,
75
],
[
47,
78
],
[
96,
79
],
[
72,
80
],
[
99,
81
],
[
104,
83
],
[
105,
87
],
[
114,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
107,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
]
] |
[
"n , t = map(int,input().split())\na = list(map(int,input().split()))\nk = [0 for i in range(n)]\nnowmin = a[0]\nfor i in range(1,n):\n k[i] = a[i] - nowmin\n nowmin = min(nowmin,a[i])\n\nmaxri = max(k)\nans = 0\nfor i in range(n):\n if k[i] == maxri:\n ans += 1\nprint(ans)",
"n , t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"0 for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"0",
"k = [0 for i in range(n)]",
"k",
"[0 for i in range(n)]",
"nowmin = a[0]",
"nowmin",
"a[0]",
"a",
"0",
"for i in range(1,n):\n k[i] = a[i] - nowmin\n nowmin = min(nowmin,a[i])",
"i",
"range(1,n)",
"range",
"1",
"n",
"k[i] = a[i] - nowmin",
"k[i]",
"k",
"i",
"a[i] - nowmin",
"a[i]",
"a",
"i",
"nowmin",
"nowmin = min(nowmin,a[i])",
"nowmin",
"min(nowmin,a[i])",
"min",
"nowmin",
"a[i]",
"a",
"i",
"maxri = max(k)",
"maxri",
"max(k)",
"max",
"k",
"ans = 0",
"ans",
"0",
"for i in range(n):\n if k[i] == maxri:\n ans += 1",
"i",
"range(n)",
"range",
"n",
"if k[i] == maxri:\n ans += 1",
"k[i] == maxri",
"k[i]",
"k",
"i",
"maxri",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"nowmin = a[0]",
"a[0]",
"nowmin",
"k = [0 for i in range(n)]",
"[0 for i in range(n)]",
"k",
"maxri = max(k)",
"max(k)",
"maxri",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"ans += 1",
"1",
"ans",
"n , t = map(int,input().split())",
"map(int,input().split())",
"n",
"nowmin = min(nowmin,a[i])",
"min(nowmin,a[i])",
"nowmin",
"ans = 0",
"0",
"ans"
] |
n , t = map(int,input().split())
a = list(map(int,input().split()))
k = [0 for i in range(n)]
nowmin = a[0]
for i in range(1,n):
k[i] = a[i] - nowmin
nowmin = min(nowmin,a[i])
maxri = max(k)
ans = 0
for i in range(n):
if k[i] == maxri:
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,
39,
17,
13,
0,
18,
13,
17,
18,
13,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
2,
40,
13,
17,
4,
13,
18,
13,
40,
13,
18,
13,
2,
40,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
18,
13,
13,
18,
13,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
17,
14,
2,
2,
18,
13,
13,
18,
13,
13,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13
] |
[
[
133,
2
],
[
133,
11
],
[
115,
13
],
[
136,
25
],
[
113,
29
],
[
34,
31
],
[
137,
32
],
[
116,
35
],
[
39,
38
],
[
113,
42
],
[
50,
44
],
[
137,
45
],
[
38,
48
],
[
137,
53
],
[
38,
55
],
[
116,
57
],
[
38,
60
],
[
130,
63
],
[
118,
66
],
[
70,
69
],
[
113,
72
],
[
137,
77
],
[
69,
78
],
[
116,
80
],
[
69,
81
],
[
119,
82
],
[
122,
82
],
[
121,
84
],
[
137,
87
],
[
69,
88
],
[
116,
90
],
[
69,
91
],
[
124,
93
],
[
137,
99
],
[
69,
100
],
[
116,
102
],
[
69,
103
],
[
119,
104
],
[
122,
104
],
[
127,
106
],
[
128,
110
],
[
125,
110
],
[
131,
110
],
[
133,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
133,
134
],
[
136,
137
]
] |
[
"n,t = map(int,input().split())\na = list(map(int,input().split()))\n\nmax1 = [0] * n\nmax1[-1] = a[-1]\n\nfor i in range(1, n):\n max1[-i-1] = max(max1[-i], a[-i-1])\n\nans = 0\ntmp = -1\n\nfor i in range(n):\n if max1[i] - a[i] > tmp:\n tmp = max1[i] - a[i]\n ans = 1\n elif max1[i] - a[i] == tmp:\n ans += 1\n\nprint(ans)",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"max1 = [0] * n",
"max1",
"[0] * n",
"[0]",
"0",
"n",
"max1[-1] = a[-1]",
"max1[-1]",
"max1",
"-1",
"a[-1]",
"a",
"-1",
"for i in range(1, n):\n max1[-i-1] = max(max1[-i], a[-i-1])",
"i",
"range(1, n)",
"range",
"1",
"n",
"max1[-i-1] = max(max1[-i], a[-i-1])",
"max1[-i-1]",
"max1",
"-i-1",
"-i",
"i",
"1",
"max(max1[-i], a[-i-1])",
"max",
"max1[-i]",
"max1",
"-i",
"i",
"a[-i-1]",
"a",
"-i-1",
"-i",
"i",
"1",
"ans = 0",
"ans",
"0",
"tmp = -1",
"tmp",
"-1",
"for i in range(n):\n if max1[i] - a[i] > tmp:\n tmp = max1[i] - a[i]\n ans = 1\n elif max1[i] - a[i] == tmp:\n ans += 1",
"i",
"range(n)",
"range",
"n",
"if max1[i] - a[i] > tmp:\n tmp = max1[i] - a[i]\n ans = 1\n elif max1[i] - a[i] == tmp:\n ans += 1",
"max1[i] - a[i] > tmp",
"max1[i] - a[i]",
"max1[i]",
"max1",
"i",
"a[i]",
"a",
"i",
"tmp",
"tmp = max1[i] - a[i]",
"tmp",
"max1[i] - a[i]",
"max1[i]",
"max1",
"i",
"a[i]",
"a",
"i",
"ans = 1",
"ans",
"1",
"elif max1[i] - a[i] == tmp:\n ans += 1",
"max1[i] - a[i] == tmp",
"max1[i] - a[i]",
"max1[i]",
"max1",
"i",
"a[i]",
"a",
"i",
"tmp",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"n,t = map(int,input().split())",
"map(int,input().split())",
"n",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"tmp = -1",
"-1",
"tmp",
"tmp = max1[i] - a[i]",
"max1[i] - a[i]",
"tmp",
"ans = 1",
"1",
"ans",
"ans += 1",
"1",
"ans",
"ans = 0",
"0",
"ans",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"max1 = [0] * n",
"[0] * n",
"max1"
] |
n,t = map(int,input().split())
a = list(map(int,input().split()))
max1 = [0] * n
max1[-1] = a[-1]
for i in range(1, n):
max1[-i-1] = max(max1[-i], a[-i-1])
ans = 0
tmp = -1
for i in range(n):
if max1[i] - a[i] > tmp:
tmp = max1[i] - a[i]
ans = 1
elif max1[i] - a[i] == tmp:
ans += 1
print(ans)
|
[
7,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
2,
2,
17,
17,
17,
17,
28,
13,
13,
0,
18,
13,
2,
13,
18,
13,
17,
18,
13,
17,
14,
2,
13,
18,
13,
17,
0,
13,
39,
13,
17,
14,
2,
13,
18,
13,
17,
0,
18,
13,
17,
17,
0,
13,
4,
13,
4,
18,
13,
13,
0,
13,
12,
18,
13,
17,
23,
0,
13,
17,
4,
13,
18,
18,
13,
17,
17,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13
] |
[
[
119,
3
],
[
119,
12
],
[
107,
14
],
[
101,
26
],
[
116,
31
],
[
41,
40
],
[
108,
40
],
[
50,
43
],
[
102,
44
],
[
40,
46
],
[
117,
48
],
[
105,
48
],
[
117,
51
],
[
105,
51
],
[
40,
55
],
[
117,
57
],
[
105,
57
],
[
104,
60
],
[
40,
66
],
[
117,
68
],
[
105,
68
],
[
74,
71
],
[
117,
72
],
[
105,
72
],
[
110,
76
],
[
102,
81
],
[
85,
84
],
[
92,
91
],
[
111,
97
],
[
102,
97
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
119,
114
],
[
116,
117
],
[
119,
120
]
] |
[
"from collections import defaultdict\nn, t = map(int, input().split())\na = list(map(int, input().split()))\n\nans = defaultdict(int)\nmin_v = [10**9+1, 1]\n\nfor v in a:\n ans[v - min_v[0]] += min_v[1]\n if v < min_v[0]:\n min_v = [v, 1]\n elif v == min_v[0]:\n min_v[1] += 1\nans= sorted(ans.items(), key=lambda x:x[0], reverse=True)\nprint(ans[0][1])",
"from collections import defaultdict",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = defaultdict(int)",
"ans",
"defaultdict(int)",
"defaultdict",
"int",
"min_v = [10**9+1, 1]",
"min_v",
"[10**9+1, 1]",
"10**9+1",
"10**9",
"10",
"9",
"1",
"1",
"for v in a:\n ans[v - min_v[0]] += min_v[1]\n if v < min_v[0]:\n min_v = [v, 1]\n elif v == min_v[0]:\n min_v[1] += 1",
"v",
"a",
"ans[v - min_v[0]] += min_v[1]",
"ans[v - min_v[0]]",
"ans",
"v - min_v[0]",
"v",
"min_v[0]",
"min_v",
"0",
"min_v[1]",
"min_v",
"1",
"if v < min_v[0]:\n min_v = [v, 1]\n elif v == min_v[0]:\n min_v[1] += 1",
"v < min_v[0]",
"v",
"min_v[0]",
"min_v",
"0",
"min_v = [v, 1]",
"min_v",
"[v, 1]",
"v",
"1",
"elif v == min_v[0]:\n min_v[1] += 1",
"v == min_v[0]",
"v",
"min_v[0]",
"min_v",
"0",
"min_v[1] += 1",
"min_v[1]",
"min_v",
"1",
"1",
"ans= sorted(ans.items(), key=lambda x:x[0], reverse=True)",
"ans",
"sorted(ans.items(), key=lambda x:x[0], reverse=True)",
"sorted",
"ans.items()",
"ans.items",
"ans",
"items",
"key=lambda x:x[0]",
"key",
"lambda x:x[0]",
"x[0]",
"x",
"0",
"x",
"reverse=True",
"reverse",
"True",
"print(ans[0][1])",
"print",
"ans[0][1]",
"[0]",
"ans",
"0",
"1",
"ans = defaultdict(int)",
"defaultdict(int)",
"ans",
"min_v = [v, 1]",
"[v, 1]",
"min_v",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"ans= sorted(ans.items(), key=lambda x:x[0], reverse=True)",
"sorted(ans.items(), key=lambda x:x[0], reverse=True)",
"ans",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"min_v = [10**9+1, 1]",
"[10**9+1, 1]",
"min_v",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n"
] |
from collections import defaultdict
n, t = map(int, input().split())
a = list(map(int, input().split()))
ans = defaultdict(int)
min_v = [10**9+1, 1]
for v in a:
ans[v - min_v[0]] += min_v[1]
if v < min_v[0]:
min_v = [v, 1]
elif v == min_v[0]:
min_v[1] += 1
ans= sorted(ans.items(), key=lambda x:x[0], reverse=True)
print(ans[0][1])
|
[
7,
12,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
40,
4,
13,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
4,
13,
13,
14,
2,
2,
13,
18,
13,
13,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
2,
13,
13,
17,
0,
18,
13,
2,
13,
13,
17,
14,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
40,
4,
13,
17,
0,
13,
4,
13,
4,
18,
13,
13,
4,
13,
18,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
5,
4
],
[
5,
15
],
[
18,
17
],
[
30,
29
],
[
33,
32
],
[
39,
38
],
[
17,
40
],
[
44,
43
],
[
17,
49
],
[
38,
53
],
[
89,
53
],
[
17,
55
],
[
43,
56
],
[
32,
58
],
[
94,
58
],
[
63,
58
],
[
17,
60
],
[
43,
61
],
[
64,
63
],
[
17,
65
],
[
43,
66
],
[
29,
69
],
[
63,
72
],
[
32,
72
],
[
94,
72
],
[
38,
73
],
[
89,
73
],
[
81,
76
],
[
29,
77
],
[
63,
79
],
[
32,
79
],
[
94,
79
],
[
38,
80
],
[
89,
80
],
[
38,
84
],
[
89,
84
],
[
17,
86
],
[
43,
87
],
[
90,
89
],
[
17,
91
],
[
43,
92
],
[
95,
94
],
[
101,
100
],
[
29,
105
],
[
29,
110
],
[
100,
111
],
[
120,
117
]
] |
[
"def resolve():\n N, T = list(map(int, input().split()))\n A = list(map(int, input().split()))\n counts = {}\n a_max = -float(\"inf\")\n a_min = A[0]\n for i in range(1, len(A)):\n if a_min < A[i] and a_max < A[i]:\n a_max = A[i]\n counts.setdefault(a_max-a_min, 0)\n counts[a_max-a_min] += 1\n if a_min > A[i]:\n a_min = A[i]\n a_max = -float(\"inf\")\n #print(counts)\n maxdiff = max(counts.keys())\n print(counts[maxdiff])\n\n\nif __name__ == '__main__':\n resolve()",
"def resolve():\n N, T = list(map(int, input().split()))\n A = list(map(int, input().split()))\n counts = {}\n a_max = -float(\"inf\")\n a_min = A[0]\n for i in range(1, len(A)):\n if a_min < A[i] and a_max < A[i]:\n a_max = A[i]\n counts.setdefault(a_max-a_min, 0)\n counts[a_max-a_min] += 1\n if a_min > A[i]:\n a_min = A[i]\n a_max = -float(\"inf\")\n #print(counts)\n maxdiff = max(counts.keys())\n print(counts[maxdiff])",
"resolve",
"N, T = list(map(int, input().split()))",
"N",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"counts = {}",
"counts",
"{}",
"a_max = -float(\"inf\")",
"a_max",
"-float(\"inf\")",
"float(\"inf\")",
"float",
"\"inf\"",
"a_min = A[0]",
"a_min",
"A[0]",
"A",
"0",
"for i in range(1, len(A)):\n if a_min < A[i] and a_max < A[i]:\n a_max = A[i]\n counts.setdefault(a_max-a_min, 0)\n counts[a_max-a_min] += 1\n if a_min > A[i]:\n a_min = A[i]\n a_max = -float(\"inf\")\n #print(counts)\n ",
"i",
"range(1, len(A))",
"range",
"1",
"len(A)",
"len",
"A",
"if a_min < A[i] and a_max < A[i]:\n a_max = A[i]\n counts.setdefault(a_max-a_min, 0)\n counts[a_max-a_min] += 1\n ",
"a_min < A[i] and a_max < A[i]",
"a_min < A[i]",
"a_min",
"A[i]",
"A",
"i",
"a_max < A[i]",
"a_max",
"A[i]",
"A",
"i",
"a_max = A[i]",
"a_max",
"A[i]",
"A",
"i",
"counts.setdefault(a_max-a_min, 0)",
"counts.setdefault",
"counts",
"setdefault",
"a_max-a_min",
"a_max",
"a_min",
"0",
"counts[a_max-a_min] += 1",
"counts[a_max-a_min]",
"counts",
"a_max-a_min",
"a_max",
"a_min",
"1",
"if a_min > A[i]:\n a_min = A[i]\n a_max = -float(\"inf\")\n #print(counts)\n ",
"a_min > A[i]",
"a_min",
"A[i]",
"A",
"i",
"a_min = A[i]",
"a_min",
"A[i]",
"A",
"i",
"a_max = -float(\"inf\")",
"a_max",
"-float(\"inf\")",
"float(\"inf\")",
"float",
"\"inf\"",
"maxdiff = max(counts.keys())",
"maxdiff",
"max(counts.keys())",
"max",
"counts.keys()",
"counts.keys",
"counts",
"keys",
"print(counts[maxdiff])",
"print",
"counts[maxdiff]",
"counts",
"maxdiff",
"if __name__ == '__main__':\n resolve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"resolve()",
"resolve",
"def resolve():\n N, T = list(map(int, input().split()))\n A = list(map(int, input().split()))\n counts = {}\n a_max = -float(\"inf\")\n a_min = A[0]\n for i in range(1, len(A)):\n if a_min < A[i] and a_max < A[i]:\n a_max = A[i]\n counts.setdefault(a_max-a_min, 0)\n counts[a_max-a_min] += 1\n if a_min > A[i]:\n a_min = A[i]\n a_max = -float(\"inf\")\n #print(counts)\n maxdiff = max(counts.keys())\n print(counts[maxdiff])",
"def resolve():\n N, T = list(map(int, input().split()))\n A = list(map(int, input().split()))\n counts = {}\n a_max = -float(\"inf\")\n a_min = A[0]\n for i in range(1, len(A)):\n if a_min < A[i] and a_max < A[i]:\n a_max = A[i]\n counts.setdefault(a_max-a_min, 0)\n counts[a_max-a_min] += 1\n if a_min > A[i]:\n a_min = A[i]\n a_max = -float(\"inf\")\n #print(counts)\n maxdiff = max(counts.keys())\n print(counts[maxdiff])",
"resolve"
] |
def resolve():
N, T = list(map(int, input().split()))
A = list(map(int, input().split()))
counts = {}
a_max = -float("inf")
a_min = A[0]
for i in range(1, len(A)):
if a_min < A[i] and a_max < A[i]:
a_max = A[i]
counts.setdefault(a_max-a_min, 0)
counts[a_max-a_min] += 1
if a_min > A[i]:
a_min = A[i]
a_max = -float("inf")
#print(counts)
maxdiff = max(counts.keys())
print(counts[maxdiff])
if __name__ == '__main__':
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,
39,
17,
2,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
2,
17,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
17,
14,
2,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] |
[
[
138,
2
],
[
138,
11
],
[
120,
13
],
[
126,
25
],
[
124,
30
],
[
34,
33
],
[
124,
38
],
[
43,
40
],
[
127,
41
],
[
33,
42
],
[
121,
46
],
[
33,
47
],
[
127,
49
],
[
33,
51
],
[
141,
54
],
[
129,
59
],
[
132,
62
],
[
66,
65
],
[
124,
68
],
[
130,
71
],
[
136,
71
],
[
127,
74
],
[
65,
76
],
[
121,
79
],
[
65,
80
],
[
117,
82
],
[
130,
86
],
[
136,
86
],
[
127,
89
],
[
65,
91
],
[
121,
94
],
[
65,
95
],
[
135,
97
],
[
127,
100
],
[
65,
102
],
[
121,
105
],
[
65,
106
],
[
114,
108
],
[
115,
112
],
[
118,
112
],
[
133,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
138,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
]
] |
[
"n, t = map(int, input().split())\na = list(map(int, input().split()))\n\ncmax = [0] * (n+1)\nfor i in reversed(range(n)):\n cmax[i] = max(a[i], cmax[i+1])\n\nm = 10 ** 18\nd = 0\nans = 0\nfor i in range(n):\n if d == cmax[i+1] - a[i]:\n ans += 1\n elif d < cmax[i+1] - a[i]:\n d = cmax[i+1] - a[i]\n ans = 1\nprint(ans)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"cmax = [0] * (n+1)",
"cmax",
"[0] * (n+1)",
"[0]",
"0",
"n+1",
"n",
"1",
"for i in reversed(range(n)):\n cmax[i] = max(a[i], cmax[i+1])",
"i",
"reversed(range(n))",
"reversed",
"range(n)",
"range",
"n",
"cmax[i] = max(a[i], cmax[i+1])",
"cmax[i]",
"cmax",
"i",
"max(a[i], cmax[i+1])",
"max",
"a[i]",
"a",
"i",
"cmax[i+1]",
"cmax",
"i+1",
"i",
"1",
"m = 10 ** 18",
"m",
"10 ** 18",
"10",
"18",
"d = 0",
"d",
"0",
"ans = 0",
"ans",
"0",
"for i in range(n):\n if d == cmax[i+1] - a[i]:\n ans += 1\n elif d < cmax[i+1] - a[i]:\n d = cmax[i+1] - a[i]\n ans = 1",
"i",
"range(n)",
"range",
"n",
"if d == cmax[i+1] - a[i]:\n ans += 1\n elif d < cmax[i+1] - a[i]:\n d = cmax[i+1] - a[i]\n ans = 1",
"d == cmax[i+1] - a[i]",
"d",
"cmax[i+1] - a[i]",
"cmax[i+1]",
"cmax",
"i+1",
"i",
"1",
"a[i]",
"a",
"i",
"ans += 1",
"ans",
"1",
"elif d < cmax[i+1] - a[i]:\n d = cmax[i+1] - a[i]\n ans = 1",
"d < cmax[i+1] - a[i]",
"d",
"cmax[i+1] - a[i]",
"cmax[i+1]",
"cmax",
"i+1",
"i",
"1",
"a[i]",
"a",
"i",
"d = cmax[i+1] - a[i]",
"d",
"cmax[i+1] - a[i]",
"cmax[i+1]",
"cmax",
"i+1",
"i",
"1",
"a[i]",
"a",
"i",
"ans = 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"ans = 1",
"1",
"ans",
"ans += 1",
"1",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"cmax = [0] * (n+1)",
"[0] * (n+1)",
"cmax",
"d = 0",
"0",
"d",
"ans = 0",
"0",
"ans",
"d = cmax[i+1] - a[i]",
"cmax[i+1] - a[i]",
"d",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"m = 10 ** 18",
"10 ** 18",
"m"
] |
n, t = map(int, input().split())
a = list(map(int, input().split()))
cmax = [0] * (n+1)
for i in reversed(range(n)):
cmax[i] = max(a[i], cmax[i+1])
m = 10 ** 18
d = 0
ans = 0
for i in range(n):
if d == cmax[i+1] - a[i]:
ans += 1
elif d < cmax[i+1] - a[i]:
d = cmax[i+1] - a[i]
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,
2,
17,
17,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
14,
2,
13,
2,
18,
13,
13,
13,
0,
13,
17,
14,
2,
2,
18,
13,
13,
13,
13,
0,
13,
17,
0,
13,
2,
18,
13,
13,
13,
9,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] |
[
[
108,
2
],
[
108,
11
],
[
96,
13
],
[
93,
25
],
[
84,
32
],
[
111,
35
],
[
39,
38
],
[
91,
41
],
[
99,
43
],
[
94,
46
],
[
100,
46
],
[
97,
48
],
[
38,
49
],
[
85,
52
],
[
103,
52
],
[
97,
55
],
[
38,
56
],
[
100,
57
],
[
94,
57
],
[
105,
59
],
[
97,
65
],
[
38,
66
],
[
100,
67
],
[
94,
67
],
[
85,
68
],
[
103,
68
],
[
87,
70
],
[
102,
73
],
[
97,
76
],
[
38,
77
],
[
100,
78
],
[
94,
78
],
[
88,
82
],
[
106,
82
],
[
112,
82
],
[
84,
85
],
[
87,
88
],
[
108,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
]
] |
[
"N, T = map(int, input().split())\nA = list(map(int, input().split()))\n\nmin_num = 10 ** 9 + 7\ndiff = 0\ncount = 0\nfor i in range(N):\n min_num = min(min_num, A[i])\n if diff == A[i] - min_num:\n count += 1\n elif A[i] - min_num > diff:\n count = 1\n diff = A[i] - min_num\n else:\n continue\n\nprint(count)",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_num = 10 ** 9 + 7",
"min_num",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"diff = 0",
"diff",
"0",
"count = 0",
"count",
"0",
"for i in range(N):\n min_num = min(min_num, A[i])\n if diff == A[i] - min_num:\n count += 1\n elif A[i] - min_num > diff:\n count = 1\n diff = A[i] - min_num\n else:\n continue",
"i",
"range(N)",
"range",
"N",
"min_num = min(min_num, A[i])",
"min_num",
"min(min_num, A[i])",
"min",
"min_num",
"A[i]",
"A",
"i",
"if diff == A[i] - min_num:\n count += 1\n elif A[i] - min_num > diff:\n count = 1\n diff = A[i] - min_num\n else:\n continue",
"diff == A[i] - min_num",
"diff",
"A[i] - min_num",
"A[i]",
"A",
"i",
"min_num",
"count += 1",
"count",
"1",
"elif A[i] - min_num > diff:\n count = 1\n diff = A[i] - min_num\n ",
"A[i] - min_num > diff",
"A[i] - min_num",
"A[i]",
"A",
"i",
"min_num",
"diff",
"count = 1",
"count",
"1",
"diff = A[i] - min_num",
"diff",
"A[i] - min_num",
"A[i]",
"A",
"i",
"min_num",
"continue",
"print(count)",
"print",
"count",
"diff = 0",
"0",
"diff",
"count = 1",
"1",
"count",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"min_num = 10 ** 9 + 7",
"10 ** 9 + 7",
"min_num",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"min_num = min(min_num, A[i])",
"min(min_num, A[i])",
"min_num",
"diff = A[i] - min_num",
"A[i] - min_num",
"diff",
"count += 1",
"1",
"count",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"count = 0",
"0",
"count"
] |
N, T = map(int, input().split())
A = list(map(int, input().split()))
min_num = 10 ** 9 + 7
diff = 0
count = 0
for i in range(N):
min_num = min(min_num, A[i])
if diff == A[i] - min_num:
count += 1
elif A[i] - min_num > diff:
count = 1
diff = A[i] - min_num
else:
continue
print(count)
|
[
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,
39,
0,
13,
4,
13,
17,
28,
13,
13,
0,
13,
4,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
39,
28,
13,
13,
4,
13,
13,
13,
4,
18,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
4,
13,
4,
18,
13,
13,
18,
13,
17,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] |
[
[
98,
4
],
[
98,
13
],
[
83,
15
],
[
101,
27
],
[
95,
30
],
[
36,
35
],
[
84,
35
],
[
89,
38
],
[
35,
41
],
[
96,
42
],
[
90,
42
],
[
102,
45
],
[
90,
47
],
[
96,
47
],
[
80,
49
],
[
84,
56
],
[
102,
57
],
[
81,
60
],
[
92,
66
],
[
81,
69
],
[
93,
74
],
[
81,
74
],
[
93,
77
],
[
81,
77
],
[
80,
81
],
[
83,
84
],
[
98,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
]
] |
[
"# solution\nimport io\n\nnim,mike = map(int,input().split())\narray = list(map(int,input().split()))\narrays = []\nmin_a = float(\"inf\")\nfor a in array:\n min_a = min(a, min_a)\n arrays.append(min_a)\narray2 = []\nfor a,b in zip(array, arrays):\n array2.append(a-b)\narray2 = sorted(array2)\nprint(array2.count(array2[-1]))",
"import io",
"io",
"nim,mike = map(int,input().split())",
"nim",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mike",
"array = list(map(int,input().split()))",
"array",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"arrays = []",
"arrays",
"[]",
"min_a = float(\"inf\")",
"min_a",
"float(\"inf\")",
"float",
"\"inf\"",
"for a in array:\n min_a = min(a, min_a)\n arrays.append(min_a)",
"a",
"array",
"min_a = min(a, min_a)",
"min_a",
"min(a, min_a)",
"min",
"a",
"min_a",
"arrays.append(min_a)",
"arrays.append",
"arrays",
"append",
"min_a",
"array2 = []",
"array2",
"[]",
"for a,b in zip(array, arrays):\n array2.append(a-b)",
"a",
"b",
"zip(array, arrays)",
"zip",
"array",
"arrays",
"array2.append(a-b)",
"array2.append",
"array2",
"append",
"a-b",
"a",
"b",
"array2 = sorted(array2)",
"array2",
"sorted(array2)",
"sorted",
"array2",
"print(array2.count(array2[-1]))",
"print",
"array2.count(array2[-1])",
"array2.count",
"array2",
"count",
"array2[-1]",
"array2",
"-1",
"array2 = []",
"[]",
"array2",
"array = list(map(int,input().split()))",
"list(map(int,input().split()))",
"array",
"nim,mike = map(int,input().split())",
"map(int,input().split())",
"nim",
"min_a = min(a, min_a)",
"min(a, min_a)",
"min_a",
"array2 = sorted(array2)",
"sorted(array2)",
"array2",
"min_a = float(\"inf\")",
"float(\"inf\")",
"min_a",
"mike = map(int,input().split())",
"map(int,input().split())",
"mike",
"arrays = []",
"[]",
"arrays"
] |
# solution
import io
nim,mike = map(int,input().split())
array = list(map(int,input().split()))
arrays = []
min_a = float("inf")
for a in array:
min_a = min(a, min_a)
arrays.append(min_a)
array2 = []
for a,b in zip(array, arrays):
array2.append(a-b)
array2 = sorted(array2)
print(array2.count(array2[-1]))
|
[
7,
15,
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,
13,
13,
0,
13,
4,
13,
2,
13,
13,
4,
13,
18,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
61,
4
],
[
61,
13
],
[
58,
15
],
[
49,
27
],
[
59,
32
],
[
55,
35
],
[
56,
44
],
[
56,
47
],
[
49,
50
],
[
61,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
]
] |
[
"from itertools import accumulate\nfrom collections import Counter\nN, T = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(accumulate(A, min))\nC = Counter(b-a for a, b in zip(A, B))\nprint(C[min(C)])",
"from itertools import accumulate",
"from collections import Counter",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"B = list(accumulate(A, min))",
"B",
"list(accumulate(A, min))",
"list",
"accumulate(A, min)",
"accumulate",
"A",
"min",
"C = Counter(b-a for a, b in zip(A, B))",
"C",
"Counter(b-a for a, b in zip(A, B))",
"Counter",
"b-a",
"b",
"a",
"print(C[min(C)])",
"print",
"C[min(C)]",
"C",
"min(C)",
"min",
"C",
"B = list(accumulate(A, min))",
"list(accumulate(A, min))",
"B",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"C = Counter(b-a for a, b in zip(A, B))",
"Counter(b-a for a, b in zip(A, B))",
"C",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"T = map(int, input().split())",
"map(int, input().split())",
"T"
] |
from itertools import accumulate
from collections import Counter
N, T = map(int, input().split())
A = list(map(int, input().split()))
B = list(accumulate(A, min))
C = Counter(b-a for a, b in zip(A, B))
print(C[min(C)])
|
[
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,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
13,
9,
14,
2,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
14,
2,
13,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13
] |
[
[
111,
2
],
[
111,
11
],
[
96,
13
],
[
84,
25
],
[
105,
28
],
[
99,
31
],
[
97,
33
],
[
37,
36
],
[
112,
40
],
[
108,
42
],
[
97,
44
],
[
36,
45
],
[
100,
48
],
[
82,
48
],
[
109,
49
],
[
81,
51
],
[
109,
52
],
[
85,
56
],
[
103,
56
],
[
109,
58
],
[
82,
59
],
[
100,
59
],
[
102,
61
],
[
109,
63
],
[
82,
64
],
[
100,
64
],
[
90,
66
],
[
85,
70
],
[
103,
70
],
[
109,
72
],
[
82,
73
],
[
100,
73
],
[
93,
75
],
[
94,
79
],
[
91,
79
],
[
106,
79
],
[
109,
81
],
[
81,
82
],
[
84,
85
],
[
111,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
]
] |
[
"N,T=map(int,input().split())\nA=list(map(int,input().split()))\n\nd = 0\ncnt = 0\nmin_a = A[0]\nfor i in range(1, N):\n a = A[i]\n if min_a > a:\n min_a = a\n continue\n \n if d < a - min_a:\n d = a - min_a\n cnt = 1\n elif d == a - min_a:\n cnt += 1\nprint(cnt)",
"N,T=map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"d = 0",
"d",
"0",
"cnt = 0",
"cnt",
"0",
"min_a = A[0]",
"min_a",
"A[0]",
"A",
"0",
"for i in range(1, N):\n a = A[i]\n if min_a > a:\n min_a = a\n continue\n \n if d < a - min_a:\n d = a - min_a\n cnt = 1\n elif d == a - min_a:\n cnt += 1",
"i",
"range(1, N)",
"range",
"1",
"N",
"a = A[i]",
"a",
"A[i]",
"A",
"i",
"if min_a > a:\n min_a = a\n continue\n \n ",
"min_a > a",
"min_a",
"a",
"min_a = a",
"min_a",
"a",
"continue",
"if d < a - min_a:\n d = a - min_a\n cnt = 1\n elif d == a - min_a:\n cnt += 1",
"d < a - min_a",
"d",
"a - min_a",
"a",
"min_a",
"d = a - min_a",
"d",
"a - min_a",
"a",
"min_a",
"cnt = 1",
"cnt",
"1",
"elif d == a - min_a:\n cnt += 1",
"d == a - min_a",
"d",
"a - min_a",
"a",
"min_a",
"cnt += 1",
"cnt",
"1",
"print(cnt)",
"print",
"cnt",
"min_a = a",
"a",
"min_a",
"d = 0",
"0",
"d",
"T=map(int,input().split())",
"map(int,input().split())",
"T",
"cnt = 1",
"1",
"cnt",
"cnt += 1",
"1",
"cnt",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"min_a = A[0]",
"A[0]",
"min_a",
"d = a - min_a",
"a - min_a",
"d",
"cnt = 0",
"0",
"cnt",
"a = A[i]",
"A[i]",
"a",
"N,T=map(int,input().split())",
"map(int,input().split())",
"N"
] |
N,T=map(int,input().split())
A=list(map(int,input().split()))
d = 0
cnt = 0
min_a = A[0]
for i in range(1, N):
a = A[i]
if min_a > a:
min_a = a
continue
if d < a - min_a:
d = a - min_a
cnt = 1
elif d == a - min_a:
cnt += 1
print(cnt)
|
[
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,
39,
0,
13,
2,
17,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
4,
18,
13,
13,
2,
18,
13,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
39,
13,
10,
13,
13
] |
[
[
4,
3
],
[
3,
12
],
[
87,
14
],
[
87,
16
],
[
20,
19
],
[
19,
28
],
[
78,
30
],
[
84,
33
],
[
81,
36
],
[
42,
41
],
[
76,
44
],
[
72,
46
],
[
82,
49
],
[
73,
49
],
[
79,
51
],
[
41,
52
],
[
85,
55
],
[
79,
59
],
[
41,
60
],
[
73,
61
],
[
82,
61
],
[
85,
66
],
[
85,
70
],
[
72,
73
],
[
87,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
]
] |
[
"N,T = [int(x) for x in input().split()]\na = [int(x) for x in input().split()]\nans = []\nmi = 10**9\nfor i in range(N):\n mi = min(mi,a[i])\n ans.append(a[i]-mi)\nprint(ans.count(max(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,T = [int(x) for x in input().split()]",
"N",
"[int(x) for x in input().split()]",
"T",
"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",
"a = [int(x) for x in input().split()]",
"a",
"[int(x) for x in input().split()]",
"ans = []",
"ans",
"[]",
"mi = 10**9",
"mi",
"10**9",
"10",
"9",
"for i in range(N):\n mi = min(mi,a[i])\n ans.append(a[i]-mi)",
"i",
"range(N)",
"range",
"N",
"mi = min(mi,a[i])",
"mi",
"min(mi,a[i])",
"min",
"mi",
"a[i]",
"a",
"i",
"ans.append(a[i]-mi)",
"ans.append",
"ans",
"append",
"a[i]-mi",
"a[i]",
"a",
"i",
"mi",
"print(ans.count(max(ans)))",
"print",
"ans.count(max(ans))",
"ans.count",
"ans",
"count",
"max(ans)",
"max",
"ans",
"mi = min(mi,a[i])",
"min(mi,a[i])",
"mi",
"N,T = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"N",
"a = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"a",
"mi = 10**9",
"10**9",
"mi",
"ans = []",
"[]",
"ans",
"T = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"T"
] |
N,T = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
ans = []
mi = 10**9
for i in range(N):
mi = min(mi,a[i])
ans.append(a[i]-mi)
print(ans.count(max(ans)))
|
[
7,
12,
13,
12,
13,
12,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
0,
13,
2,
39,
17,
13,
28,
13,
13,
4,
13,
4,
13,
13,
14,
2,
13,
17,
0,
18,
13,
2,
13,
17,
13,
9,
0,
13,
2,
2,
13,
13,
17,
0,
18,
13,
13,
4,
13,
13,
18,
13,
2,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
14,
2,
13,
2,
13,
17,
9,
0,
13,
2,
18,
13,
2,
13,
17,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] |
[
[
159,
8
],
[
153,
15
],
[
151,
17
],
[
153,
18
],
[
126,
20
],
[
142,
22
],
[
120,
24
],
[
154,
28
],
[
127,
36
],
[
47,
42
],
[
121,
43
],
[
154,
45
],
[
117,
50
],
[
154,
53
],
[
60,
57
],
[
121,
58
],
[
118,
59
],
[
121,
64
],
[
118,
66
],
[
123,
69
],
[
144,
72
],
[
127,
79
],
[
118,
82
],
[
154,
84
],
[
132,
88
],
[
121,
91
],
[
118,
93
],
[
133,
98
],
[
124,
99
],
[
139,
99
],
[
138,
101
],
[
133,
102
],
[
156,
104
],
[
133,
108
],
[
124,
109
],
[
139,
109
],
[
129,
111
],
[
130,
115
],
[
157,
115
],
[
145,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
153,
136
],
[
133,
138
],
[
138,
139
],
[
144,
145
],
[
153,
154
],
[
156,
157
],
[
159,
160
]
] |
[
"def I(): return int(input())\ndef MI(): return map(int, input().split())\ndef LMI(): return list(map(int, input().split()))\nMOD = 10 ** 9 + 7\n\nN, T = MI()\nA = LMI()\n\n# m[i] := i以降で最大の値\nm = [0] * N\nfor j, a in enumerate(reversed(A)):\n if j == 0:\n m[N - 1] = a\n continue\n i = N - j - 1\n m[i] = max(a, m[i + 1])\n\nM = 0\nM_cnt = 0\nfor i, a in enumerate(A):\n if i == N - 1:\n continue\n diff = m[i + 1] - a\n if diff > M:\n M = diff\n M_cnt = 1\n elif diff == M:\n M_cnt += 1\nprint(M_cnt)",
"def I(): return int(input())",
"I",
"def MI(): return map(int, input().split())",
"MI",
"def LMI(): return list(map(int, input().split()))",
"LMI",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N, T = MI()",
"N",
"MI()",
"MI",
"T",
"A = LMI()",
"A",
"LMI()",
"LMI",
"m = [0] * N",
"m",
"[0] * N",
"[0]",
"0",
"N",
"for j, a in enumerate(reversed(A)):\n if j == 0:\n m[N - 1] = a\n continue\n i = N - j - 1\n m[i] = max(a, m[i + 1])",
"j",
"a",
"enumerate(reversed(A))",
"enumerate",
"reversed(A)",
"reversed",
"A",
"if j == 0:\n m[N - 1] = a\n continue\n ",
"j == 0",
"j",
"0",
"m[N - 1] = a",
"m[N - 1]",
"m",
"N - 1",
"N",
"1",
"a",
"continue",
"i = N - j - 1",
"i",
"N - j - 1",
"N - j",
"N",
"j",
"1",
"m[i] = max(a, m[i + 1])",
"m[i]",
"m",
"i",
"max(a, m[i + 1])",
"max",
"a",
"m[i + 1]",
"m",
"i + 1",
"i",
"1",
"M = 0",
"M",
"0",
"M_cnt = 0",
"M_cnt",
"0",
"for i, a in enumerate(A):\n if i == N - 1:\n continue\n diff = m[i + 1] - a\n if diff > M:\n M = diff\n M_cnt = 1\n elif diff == M:\n M_cnt += 1",
"i",
"a",
"enumerate(A)",
"enumerate",
"A",
"if i == N - 1:\n continue\n ",
"i == N - 1",
"i",
"N - 1",
"N",
"1",
"continue",
"diff = m[i + 1] - a",
"diff",
"m[i + 1] - a",
"m[i + 1]",
"m",
"i + 1",
"i",
"1",
"a",
"if diff > M:\n M = diff\n M_cnt = 1\n elif diff == M:\n M_cnt += 1",
"diff > M",
"diff",
"M",
"M = diff",
"M",
"diff",
"M_cnt = 1",
"M_cnt",
"1",
"elif diff == M:\n M_cnt += 1",
"diff == M",
"diff",
"M",
"M_cnt += 1",
"M_cnt",
"1",
"print(M_cnt)",
"print",
"M_cnt",
"i = N - j - 1",
"N - j - 1",
"i",
"m = [0] * N",
"[0] * N",
"m",
"M = 0",
"0",
"M",
"A = LMI()",
"LMI()",
"A",
"M_cnt += 1",
"1",
"M_cnt",
"diff = m[i + 1] - a",
"m[i + 1] - a",
"diff",
"T = MI()",
"MI()",
"T",
"M = diff",
"diff",
"M",
"def LMI(): return list(map(int, input().split()))",
"def LMI(): return list(map(int, input().split()))",
"LMI",
"M_cnt = 0",
"0",
"M_cnt",
"def I(): return int(input())",
"def I(): return int(input())",
"I",
"def MI(): return map(int, input().split())",
"def MI(): return map(int, input().split())",
"MI",
"N, T = MI()",
"MI()",
"N",
"M_cnt = 1",
"1",
"M_cnt",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD"
] |
def I(): return int(input())
def MI(): return map(int, input().split())
def LMI(): return list(map(int, input().split()))
MOD = 10 ** 9 + 7
N, T = MI()
A = LMI()
# m[i] := i以降で最大の値
m = [0] * N
for j, a in enumerate(reversed(A)):
if j == 0:
m[N - 1] = a
continue
i = N - j - 1
m[i] = max(a, m[i + 1])
M = 0
M_cnt = 0
for i, a in enumerate(A):
if i == N - 1:
continue
diff = m[i + 1] - a
if diff > M:
M = diff
M_cnt = 1
elif diff == M:
M_cnt += 1
print(M_cnt)
|
[
7,
15,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
0,
13,
18,
18,
18,
13,
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,
0,
13,
17,
0,
13,
39,
13,
17,
0,
13,
4,
13,
14,
2,
18,
13,
17,
18,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
39,
18,
13,
17,
17,
28,
13,
4,
13,
2,
13,
17,
14,
13,
14,
2,
18,
13,
13,
18,
13,
2,
13,
17,
14,
2,
18,
13,
17,
18,
13,
13,
0,
13,
39,
18,
13,
13,
13,
0,
13,
17,
14,
2,
18,
13,
13,
18,
13,
2,
13,
17,
0,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
17,
14,
2,
13,
13,
4,
18,
13,
13,
39,
18,
13,
17,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
39,
18,
13,
17,
13,
9,
14,
40,
13,
0,
13,
2,
18,
13,
2,
13,
17,
18,
13,
17,
14,
2,
13,
13,
4,
18,
13,
13,
39,
18,
13,
17,
2,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
39,
18,
13,
17,
2,
13,
17,
4,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
17,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
12,
13
] |
[
[
246,
4
],
[
243,
13
],
[
249,
29
],
[
240,
34
],
[
40,
39
],
[
244,
46
],
[
40,
48
],
[
40,
49
],
[
53,
52
],
[
56,
55
],
[
61,
60
],
[
73,
72
],
[
76,
75
],
[
79,
78
],
[
86,
85
],
[
39,
89
],
[
85,
97
],
[
85,
101
],
[
78,
106
],
[
55,
106
],
[
112,
106
],
[
85,
110
],
[
113,
112
],
[
85,
116
],
[
120,
119
],
[
85,
125
],
[
85,
129
],
[
133,
132
],
[
136,
135
],
[
85,
139
],
[
78,
141
],
[
55,
141
],
[
112,
141
],
[
52,
145
],
[
161,
145
],
[
135,
146
],
[
60,
149
],
[
164,
149
],
[
78,
153
],
[
55,
153
],
[
112,
153
],
[
52,
158
],
[
161,
158
],
[
135,
159
],
[
162,
161
],
[
135,
162
],
[
165,
164
],
[
164,
169
],
[
60,
169
],
[
78,
173
],
[
55,
173
],
[
112,
173
],
[
119,
179
],
[
132,
179
],
[
75,
179
],
[
72,
179
],
[
182,
181
],
[
39,
186
],
[
112,
189
],
[
78,
189
],
[
55,
189
],
[
161,
193
],
[
52,
193
],
[
181,
194
],
[
135,
194
],
[
164,
197
],
[
60,
197
],
[
112,
201
],
[
78,
201
],
[
55,
201
],
[
39,
204
],
[
161,
208
],
[
52,
208
],
[
181,
209
],
[
135,
209
],
[
212,
211
],
[
181,
212
],
[
135,
212
],
[
215,
214
],
[
214,
219
],
[
164,
219
],
[
60,
219
],
[
112,
223
],
[
78,
223
],
[
55,
223
],
[
39,
226
],
[
214,
232
],
[
164,
232
],
[
60,
232
],
[
253,
238
],
[
240,
241
],
[
243,
244
],
[
246,
247
],
[
249,
250
]
] |
[
"# coding: utf-8\nimport sys\n#from operator import itemgetter\nsysread = sys.stdin.buffer.readline\nread = sys.stdin.buffer.read\n#from heapq import heappop, heappush\n#from collections import defaultdict\nsys.setrecursionlimit(10**7)\n#import math\n#from itertools import product, accumulate, combinations, product\n#import bisect\n#import numpy as np\n#from copy import deepcopy\n#from collections import deque\n#from decimal import Decimal\n#from numba import jit\n\nINF = 1 << 50\nEPS = 1e-8\n\n\ndef run():\n N, T , *A = map(int, read().split())\n max_gap = 0\n current_min = (INF, -1)\n pairs = set()\n if A[0] > A[1]:\n down = True\n else:\n down = False\n current_min = (A[0], 0)\n\n for i in range(N-1):\n if down:\n if A[i] < A[i+1]:\n if current_min[0] > A[i]:\n current_min = (A[i], i)\n down = False\n else:\n if A[i] > A[i+1]:\n down = True\n gap = A[i] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n if not down:\n gap = A[N-1] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], N-1))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], N-1))\n print(len(pairs))\n\n\nif __name__ == \"__main__\":\n run()",
"import sys",
"sys",
"sysread = sys.stdin.buffer.readline",
"sysread",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"read = sys.stdin.buffer.read",
"read",
"sys.stdin.buffer.read",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"read",
"sys.setrecursionlimit(10**7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**7",
"10",
"7",
"INF = 1 << 50",
"INF",
"1 << 50",
"1",
"50",
"EPS = 1e-8",
"EPS",
"1e-8",
"def run():\n N, T , *A = map(int, read().split())\n max_gap = 0\n current_min = (INF, -1)\n pairs = set()\n if A[0] > A[1]:\n down = True\n else:\n down = False\n current_min = (A[0], 0)\n\n for i in range(N-1):\n if down:\n if A[i] < A[i+1]:\n if current_min[0] > A[i]:\n current_min = (A[i], i)\n down = False\n else:\n if A[i] > A[i+1]:\n down = True\n gap = A[i] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n if not down:\n gap = A[N-1] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], N-1))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], N-1))\n print(len(pairs))",
"run",
"N, T , *A = map(int, read().split())",
"N",
"map(int, read().split())",
"map",
"int",
"read().split()",
"().split",
"()",
"read",
"split",
"T",
"*A",
"A",
"max_gap = 0",
"max_gap",
"0",
"current_min = (INF, -1)",
"current_min",
"(INF, -1)",
"INF",
"-1",
"pairs = set()",
"pairs",
"set()",
"set",
"if A[0] > A[1]:\n down = True\n else:\n down = False\n current_min = (A[0], 0)\n\n ",
"A[0] > A[1]",
"A[0]",
"A",
"0",
"A[1]",
"A",
"1",
"down = True",
"down",
"True",
"down = False",
"down",
"False",
"current_min = (A[0], 0)",
"current_min",
"(A[0], 0)",
"A[0]",
"A",
"0",
"0",
"for i in range(N-1):\n if down:\n if A[i] < A[i+1]:\n if current_min[0] > A[i]:\n current_min = (A[i], i)\n down = False\n else:\n if A[i] > A[i+1]:\n down = True\n gap = A[i] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n ",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if down:\n if A[i] < A[i+1]:\n if current_min[0] > A[i]:\n current_min = (A[i], i)\n down = False\n else:\n if A[i] > A[i+1]:\n down = True\n gap = A[i] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n ",
"down",
"if A[i] < A[i+1]:\n if current_min[0] > A[i]:\n current_min = (A[i], i)\n down = False\n ",
"A[i] < A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"if current_min[0] > A[i]:\n current_min = (A[i], i)\n ",
"current_min[0] > A[i]",
"current_min[0]",
"current_min",
"0",
"A[i]",
"A",
"i",
"current_min = (A[i], i)",
"current_min",
"(A[i], i)",
"A[i]",
"A",
"i",
"i",
"down = False",
"down",
"False",
"if A[i] > A[i+1]:\n down = True\n gap = A[i] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n ",
"A[i] > A[i+1]",
"A[i]",
"A",
"i",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"down = True",
"down",
"True",
"gap = A[i] - current_min[0]",
"gap",
"A[i] - current_min[0]",
"A[i]",
"A",
"i",
"current_min[0]",
"current_min",
"0",
"if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n ",
"max_gap == gap",
"max_gap",
"gap",
"pairs.add((current_min[1], i))",
"pairs.add",
"pairs",
"add",
"(current_min[1], i)",
"current_min[1]",
"current_min",
"1",
"i",
"elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n ",
"max_gap < gap",
"max_gap",
"gap",
"max_gap = gap",
"max_gap",
"gap",
"pairs = set()",
"pairs",
"set()",
"set",
"pairs.add((current_min[1], i))",
"pairs.add",
"pairs",
"add",
"(current_min[1], i)",
"current_min[1]",
"current_min",
"1",
"i",
"continue",
"if not down:\n gap = A[N-1] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], N-1))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], N-1))\n ",
"not down",
"down",
"gap = A[N-1] - current_min[0]",
"gap",
"A[N-1] - current_min[0]",
"A[N-1]",
"A",
"N-1",
"N",
"1",
"current_min[0]",
"current_min",
"0",
"if max_gap == gap:\n pairs.add((current_min[1], N-1))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], N-1))\n ",
"max_gap == gap",
"max_gap",
"gap",
"pairs.add((current_min[1], N-1))",
"pairs.add",
"pairs",
"add",
"(current_min[1], N-1)",
"current_min[1]",
"current_min",
"1",
"N-1",
"N",
"1",
"elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], N-1))\n ",
"max_gap < gap",
"max_gap",
"gap",
"max_gap = gap",
"max_gap",
"gap",
"pairs = set()",
"pairs",
"set()",
"set",
"pairs.add((current_min[1], N-1))",
"pairs.add",
"pairs",
"add",
"(current_min[1], N-1)",
"current_min[1]",
"current_min",
"1",
"N-1",
"N",
"1",
"print(len(pairs))",
"print",
"len(pairs)",
"len",
"pairs",
"if __name__ == \"__main__\":\n run()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"run()",
"run",
"EPS = 1e-8",
"1e-8",
"EPS",
"read = sys.stdin.buffer.read",
"sys.stdin.buffer.read",
"read",
"sysread = sys.stdin.buffer.readline",
"sys.stdin.buffer.readline",
"sysread",
"INF = 1 << 50",
"1 << 50",
"INF",
"def run():\n N, T , *A = map(int, read().split())\n max_gap = 0\n current_min = (INF, -1)\n pairs = set()\n if A[0] > A[1]:\n down = True\n else:\n down = False\n current_min = (A[0], 0)\n\n for i in range(N-1):\n if down:\n if A[i] < A[i+1]:\n if current_min[0] > A[i]:\n current_min = (A[i], i)\n down = False\n else:\n if A[i] > A[i+1]:\n down = True\n gap = A[i] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n if not down:\n gap = A[N-1] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], N-1))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], N-1))\n print(len(pairs))",
"def run():\n N, T , *A = map(int, read().split())\n max_gap = 0\n current_min = (INF, -1)\n pairs = set()\n if A[0] > A[1]:\n down = True\n else:\n down = False\n current_min = (A[0], 0)\n\n for i in range(N-1):\n if down:\n if A[i] < A[i+1]:\n if current_min[0] > A[i]:\n current_min = (A[i], i)\n down = False\n else:\n if A[i] > A[i+1]:\n down = True\n gap = A[i] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], i))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], i))\n else:\n continue\n if not down:\n gap = A[N-1] - current_min[0]\n if max_gap == gap:\n pairs.add((current_min[1], N-1))\n elif max_gap < gap:\n max_gap = gap\n pairs = set()\n pairs.add((current_min[1], N-1))\n print(len(pairs))",
"run"
] |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
def run():
N, T , *A = map(int, read().split())
max_gap = 0
current_min = (INF, -1)
pairs = set()
if A[0] > A[1]:
down = True
else:
down = False
current_min = (A[0], 0)
for i in range(N-1):
if down:
if A[i] < A[i+1]:
if current_min[0] > A[i]:
current_min = (A[i], i)
down = False
else:
if A[i] > A[i+1]:
down = True
gap = A[i] - current_min[0]
if max_gap == gap:
pairs.add((current_min[1], i))
elif max_gap < gap:
max_gap = gap
pairs = set()
pairs.add((current_min[1], i))
else:
continue
if not down:
gap = A[N-1] - current_min[0]
if max_gap == gap:
pairs.add((current_min[1], N-1))
elif max_gap < gap:
max_gap = gap
pairs = set()
pairs.add((current_min[1], N-1))
print(len(pairs))
if __name__ == "__main__":
run()
|
[
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,
39,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
4,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
18,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
86,
2
],
[
86,
11
],
[
71,
13
],
[
74,
25
],
[
80,
28
],
[
72,
30
],
[
34,
33
],
[
84,
37
],
[
72,
41
],
[
33,
42
],
[
81,
43
],
[
78,
43
],
[
77,
45
],
[
72,
47
],
[
33,
48
],
[
75,
51
],
[
72,
55
],
[
33,
56
],
[
81,
57
],
[
78,
57
],
[
89,
59
],
[
75,
62
],
[
75,
66
],
[
90,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
86,
84
],
[
86,
87
],
[
89,
90
]
] |
[
"N, T = map(int, input().split())\nA = list(map(int, input().split()))\n\nB = []\nAmin = A[0]\n\nfor i in range(1, N):\n if A[i] < Amin:\n Amin = A[i]\n else:\n B.append(A[i] - Amin)\n\nresult = B.count(max(B))\nprint(result)",
"N, T = map(int, input().split())",
"N",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"B = []",
"B",
"[]",
"Amin = A[0]",
"Amin",
"A[0]",
"A",
"0",
"for i in range(1, N):\n if A[i] < Amin:\n Amin = A[i]\n else:\n B.append(A[i] - Amin)",
"i",
"range(1, N)",
"range",
"1",
"N",
"if A[i] < Amin:\n Amin = A[i]\n else:\n B.append(A[i] - Amin)",
"A[i] < Amin",
"A[i]",
"A",
"i",
"Amin",
"Amin = A[i]",
"Amin",
"A[i]",
"A",
"i",
"B.append(A[i] - Amin)",
"B.append",
"B",
"append",
"A[i] - Amin",
"A[i]",
"A",
"i",
"Amin",
"result = B.count(max(B))",
"result",
"B.count(max(B))",
"B.count",
"B",
"count",
"max(B)",
"max",
"B",
"print(result)",
"print",
"result",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"B = []",
"[]",
"B",
"Amin = A[i]",
"A[i]",
"Amin",
"Amin = A[0]",
"A[0]",
"Amin",
"N, T = map(int, input().split())",
"map(int, input().split())",
"N",
"T = map(int, input().split())",
"map(int, input().split())",
"T",
"result = B.count(max(B))",
"B.count(max(B))",
"result"
] |
N, T = map(int, input().split())
A = list(map(int, input().split()))
B = []
Amin = A[0]
for i in range(1, N):
if A[i] < Amin:
Amin = A[i]
else:
B.append(A[i] - Amin)
result = B.count(max(B))
print(result)
|
[
7,
12,
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,
39,
0,
13,
18,
13,
13,
4,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
4,
13,
4,
13,
18,
13,
17,
18,
13,
13,
0,
13,
39,
0,
13,
18,
13,
13,
28,
13,
4,
13,
13,
4,
13,
2,
18,
13,
13,
18,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
5,
4
],
[
5,
13
],
[
17,
16
],
[
16,
25
],
[
28,
27
],
[
31,
30
],
[
34,
33
],
[
30,
35
],
[
33,
38
],
[
27,
40
],
[
44,
43
],
[
4,
47
],
[
33,
49
],
[
30,
53
],
[
27,
56
],
[
43,
57
],
[
60,
59
],
[
63,
62
],
[
59,
64
],
[
68,
67
],
[
4,
70
],
[
62,
72
],
[
33,
72
],
[
27,
75
],
[
67,
76
],
[
30,
78
],
[
67,
79
],
[
59,
84
],
[
59,
88
],
[
97,
94
]
] |
[
"def main():\n n,t = map(int,input().split())\n a = [int(x) for x in input().split()]\n a_min = []\n ap = a_min.append\n ap(a[0])\n for i in range(1,n):\n ap(min(a_min[-1],a[i]))\n a_sub = []\n ap = a_sub.append\n for i in range(n):\n ap(a[i]-a_min[i])\n print(a_sub.count(max(a_sub)))\nif __name__ == \"__main__\":\n main()",
"def main():\n n,t = map(int,input().split())\n a = [int(x) for x in input().split()]\n a_min = []\n ap = a_min.append\n ap(a[0])\n for i in range(1,n):\n ap(min(a_min[-1],a[i]))\n a_sub = []\n ap = a_sub.append\n for i in range(n):\n ap(a[i]-a_min[i])\n print(a_sub.count(max(a_sub)))",
"main",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"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",
"a = [int(x) for x in input().split()]",
"a",
"[int(x) for x in input().split()]",
"a_min = []",
"a_min",
"[]",
"ap = a_min.append",
"ap",
"a_min.append",
"a_min",
"append",
"ap(a[0])",
"ap",
"a[0]",
"a",
"0",
"for i in range(1,n):\n ap(min(a_min[-1],a[i]))\n ",
"i",
"range(1,n)",
"range",
"1",
"n",
"ap(min(a_min[-1],a[i]))",
"ap",
"min(a_min[-1],a[i])",
"min",
"a_min[-1]",
"a_min",
"-1",
"a[i]",
"a",
"i",
"a_sub = []",
"a_sub",
"[]",
"ap = a_sub.append",
"ap",
"a_sub.append",
"a_sub",
"append",
"for i in range(n):\n ap(a[i]-a_min[i])\n ",
"i",
"range(n)",
"range",
"n",
"ap(a[i]-a_min[i])",
"ap",
"a[i]-a_min[i]",
"a[i]",
"a",
"i",
"a_min[i]",
"a_min",
"i",
"print(a_sub.count(max(a_sub)))",
"print",
"a_sub.count(max(a_sub))",
"a_sub.count",
"a_sub",
"count",
"max(a_sub)",
"max",
"a_sub",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n n,t = map(int,input().split())\n a = [int(x) for x in input().split()]\n a_min = []\n ap = a_min.append\n ap(a[0])\n for i in range(1,n):\n ap(min(a_min[-1],a[i]))\n a_sub = []\n ap = a_sub.append\n for i in range(n):\n ap(a[i]-a_min[i])\n print(a_sub.count(max(a_sub)))",
"def main():\n n,t = map(int,input().split())\n a = [int(x) for x in input().split()]\n a_min = []\n ap = a_min.append\n ap(a[0])\n for i in range(1,n):\n ap(min(a_min[-1],a[i]))\n a_sub = []\n ap = a_sub.append\n for i in range(n):\n ap(a[i]-a_min[i])\n print(a_sub.count(max(a_sub)))",
"main"
] |
def main():
n,t = map(int,input().split())
a = [int(x) for x in input().split()]
a_min = []
ap = a_min.append
ap(a[0])
for i in range(1,n):
ap(min(a_min[-1],a[i]))
a_sub = []
ap = a_sub.append
for i in range(n):
ap(a[i]-a_min[i])
print(a_sub.count(max(a_sub)))
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,
39,
17,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
14,
2,
2,
18,
13,
2,
13,
17,
13,
18,
13,
17,
0,
13,
39,
2,
18,
13,
2,
13,
17,
13,
14,
2,
2,
18,
13,
2,
13,
17,
13,
18,
13,
17,
4,
18,
13,
13,
2,
18,
13,
2,
13,
17,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
18,
13,
10,
39,
13
] |
[
[
114,
2
],
[
114,
11
],
[
102,
13
],
[
120,
25
],
[
117,
29
],
[
103,
31
],
[
35,
34
],
[
109,
38
],
[
103,
43
],
[
34,
44
],
[
118,
45
],
[
106,
45
],
[
105,
47
],
[
103,
49
],
[
34,
50
],
[
103,
55
],
[
34,
57
],
[
106,
59
],
[
118,
59
],
[
121,
61
],
[
112,
61
],
[
111,
64
],
[
103,
68
],
[
34,
70
],
[
106,
72
],
[
118,
72
],
[
103,
77
],
[
34,
79
],
[
106,
81
],
[
118,
81
],
[
121,
83
],
[
112,
83
],
[
121,
87
],
[
112,
87
],
[
103,
91
],
[
34,
93
],
[
106,
95
],
[
118,
95
],
[
112,
100
],
[
121,
100
],
[
102,
103
],
[
105,
106
],
[
114,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
]
] |
[
"N, T = map(int,input().split())\nA = list(map(int,input().split()))\nmax_profit = [0]\nMin = A[0]\nfor i in range(N-1):\n if A[i] < Min:\n Min = A[i]\n if A[i+1] - Min > max_profit[0]:\n max_profit = [A[i+1] - Min]\n elif A[i+1] - Min == max_profit[0]:\n max_profit.append(A[i+1] - Min)\nprint(len(max_profit))\n",
"N, T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"max_profit = [0]",
"max_profit",
"[0]",
"0",
"Min = A[0]",
"Min",
"A[0]",
"A",
"0",
"for i in range(N-1):\n if A[i] < Min:\n Min = A[i]\n if A[i+1] - Min > max_profit[0]:\n max_profit = [A[i+1] - Min]\n elif A[i+1] - Min == max_profit[0]:\n max_profit.append(A[i+1] - Min)",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i] < Min:\n Min = A[i]\n ",
"A[i] < Min",
"A[i]",
"A",
"i",
"Min",
"Min = A[i]",
"Min",
"A[i]",
"A",
"i",
"if A[i+1] - Min > max_profit[0]:\n max_profit = [A[i+1] - Min]\n elif A[i+1] - Min == max_profit[0]:\n max_profit.append(A[i+1] - Min)",
"A[i+1] - Min > max_profit[0]",
"A[i+1] - Min",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"Min",
"max_profit[0]",
"max_profit",
"0",
"max_profit = [A[i+1] - Min]",
"max_profit",
"[A[i+1] - Min]",
"A[i+1] - Min",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"Min",
"elif A[i+1] - Min == max_profit[0]:\n max_profit.append(A[i+1] - Min)",
"A[i+1] - Min == max_profit[0]",
"A[i+1] - Min",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"Min",
"max_profit[0]",
"max_profit",
"0",
"max_profit.append(A[i+1] - Min)",
"max_profit.append",
"max_profit",
"append",
"A[i+1] - Min",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"Min",
"print(len(max_profit))",
"print",
"len(max_profit)",
"len",
"max_profit",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"Min = A[i]",
"A[i]",
"Min",
"N, T = map(int,input().split())",
"map(int,input().split())",
"N",
"max_profit = [A[i+1] - Min]",
"[A[i+1] - Min]",
"max_profit",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"Min = A[0]",
"A[0]",
"Min",
"max_profit = [0]",
"[0]",
"max_profit"
] |
N, T = map(int,input().split())
A = list(map(int,input().split()))
max_profit = [0]
Min = A[0]
for i in range(N-1):
if A[i] < Min:
Min = A[i]
if A[i+1] - Min > max_profit[0]:
max_profit = [A[i+1] - Min]
elif A[i+1] - Min == max_profit[0]:
max_profit.append(A[i+1] - Min)
print(len(max_profit))
|
[
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,
17,
0,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13
] |
[
[
103,
2
],
[
103,
11
],
[
85,
13
],
[
88,
25
],
[
94,
28
],
[
91,
31
],
[
86,
33
],
[
98,
35
],
[
39,
38
],
[
98,
42
],
[
86,
49
],
[
38,
50
],
[
92,
51
],
[
107,
51
],
[
106,
53
],
[
86,
55
],
[
38,
56
],
[
112,
58
],
[
107,
60
],
[
92,
60
],
[
86,
62
],
[
38,
63
],
[
113,
66
],
[
89,
67
],
[
116,
67
],
[
115,
69
],
[
113,
70
],
[
109,
72
],
[
113,
76
],
[
89,
77
],
[
116,
77
],
[
100,
79
],
[
101,
83
],
[
110,
83
],
[
95,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
103,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
113,
115
],
[
115,
116
]
] |
[
"a,b=map(int,input().split())\nk=list(map(int,input().split()))\n\nsa=0\nans=1\n\nn=k[a-1]\n\nfor i in range(a-2,-1,-1):\n if k[i]>n:\n n=k[i]\n tmp=n-k[i]\n if tmp>sa:\n sa=tmp\n ans=1\n elif tmp==sa:\n ans+=1\n\n \n\nprint(ans)",
"a,b=map(int,input().split())",
"a",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"b",
"k=list(map(int,input().split()))",
"k",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sa=0",
"sa",
"0",
"ans=1",
"ans",
"1",
"n=k[a-1]",
"n",
"k[a-1]",
"k",
"a-1",
"a",
"1",
"for i in range(a-2,-1,-1):\n if k[i]>n:\n n=k[i]\n tmp=n-k[i]\n if tmp>sa:\n sa=tmp\n ans=1\n elif tmp==sa:\n ans+=1\n\n ",
"i",
"range(a-2,-1,-1)",
"range",
"a-2",
"a",
"2",
"-1",
"-1",
"if k[i]>n:\n n=k[i]\n ",
"k[i]>n",
"k[i]",
"k",
"i",
"n",
"n=k[i]",
"n",
"k[i]",
"k",
"i",
"tmp=n-k[i]",
"tmp",
"n-k[i]",
"n",
"k[i]",
"k",
"i",
"if tmp>sa:\n sa=tmp\n ans=1\n elif tmp==sa:\n ans+=1\n\n ",
"tmp>sa",
"tmp",
"sa",
"sa=tmp",
"sa",
"tmp",
"ans=1",
"ans",
"1",
"elif tmp==sa:\n ans+=1\n\n ",
"tmp==sa",
"tmp",
"sa",
"ans+=1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"k=list(map(int,input().split()))",
"list(map(int,input().split()))",
"k",
"sa=0",
"0",
"sa",
"n=k[a-1]",
"k[a-1]",
"n",
"ans=1",
"1",
"ans",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"ans+=1",
"1",
"ans",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"n=k[i]",
"k[i]",
"n",
"ans=1",
"1",
"ans",
"tmp=n-k[i]",
"n-k[i]",
"tmp",
"sa=tmp",
"tmp",
"sa"
] |
a,b=map(int,input().split())
k=list(map(int,input().split()))
sa=0
ans=1
n=k[a-1]
for i in range(a-2,-1,-1):
if k[i]>n:
n=k[i]
tmp=n-k[i]
if tmp>sa:
sa=tmp
ans=1
elif tmp==sa:
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,
17,
0,
13,
17,
0,
13,
39,
28,
13,
18,
13,
39,
17,
0,
13,
4,
13,
13,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
0,
13,
39,
28,
13,
4,
13,
13,
4,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13
] |
[
[
115,
2
],
[
115,
11
],
[
97,
13
],
[
94,
25
],
[
91,
30
],
[
109,
33
],
[
37,
36
],
[
98,
38
],
[
106,
42
],
[
92,
45
],
[
107,
45
],
[
36,
46
],
[
110,
49
],
[
107,
51
],
[
92,
51
],
[
110,
54
],
[
103,
57
],
[
61,
60
],
[
116,
63
],
[
104,
66
],
[
98,
70
],
[
60,
71
],
[
95,
72
],
[
113,
72
],
[
112,
74
],
[
95,
77
],
[
113,
77
],
[
98,
79
],
[
60,
80
],
[
104,
85
],
[
104,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
115,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
]
] |
[
"n, t = map(int, input().split())\nns = list(map(int, input().split()))\nmin_n = 10 ** 10\nmax_n = 0\nmax_l = []\nfor i in ns[::-1]:\n max_n = max(max_n, i)\n max_l.append(max_n)\nmax_l.reverse()\nl = []\nfor i in range(n):\n l.append(ns[i]-min_n)\n min_n = min(min_n, ns[i])\nprint(l.count(max(l)))",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"ns = list(map(int, input().split()))",
"ns",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_n = 10 ** 10",
"min_n",
"10 ** 10",
"10",
"10",
"max_n = 0",
"max_n",
"0",
"max_l = []",
"max_l",
"[]",
"for i in ns[::-1]:\n max_n = max(max_n, i)\n max_l.append(max_n)",
"i",
"ns[::-1]",
"ns",
"::-1",
"-1",
"max_n = max(max_n, i)",
"max_n",
"max(max_n, i)",
"max",
"max_n",
"i",
"max_l.append(max_n)",
"max_l.append",
"max_l",
"append",
"max_n",
"max_l.reverse()",
"max_l.reverse",
"max_l",
"reverse",
"l = []",
"l",
"[]",
"for i in range(n):\n l.append(ns[i]-min_n)\n min_n = min(min_n, ns[i])",
"i",
"range(n)",
"range",
"n",
"l.append(ns[i]-min_n)",
"l.append",
"l",
"append",
"ns[i]-min_n",
"ns[i]",
"ns",
"i",
"min_n",
"min_n = min(min_n, ns[i])",
"min_n",
"min(min_n, ns[i])",
"min",
"min_n",
"ns[i]",
"ns",
"i",
"print(l.count(max(l)))",
"print",
"l.count(max(l))",
"l.count",
"l",
"count",
"max(l)",
"max",
"l",
"max_n = 0",
"0",
"max_n",
"min_n = 10 ** 10",
"10 ** 10",
"min_n",
"ns = list(map(int, input().split()))",
"list(map(int, input().split()))",
"ns",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"l = []",
"[]",
"l",
"max_n = max(max_n, i)",
"max(max_n, i)",
"max_n",
"max_l = []",
"[]",
"max_l",
"min_n = min(min_n, ns[i])",
"min(min_n, ns[i])",
"min_n",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n"
] |
n, t = map(int, input().split())
ns = list(map(int, input().split()))
min_n = 10 ** 10
max_n = 0
max_l = []
for i in ns[::-1]:
max_n = max(max_n, i)
max_l.append(max_n)
max_l.reverse()
l = []
for i in range(n):
l.append(ns[i]-min_n)
min_n = min(min_n, ns[i])
print(l.count(max(l)))
|
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
18,
13,
13,
13,
0,
18,
13,
18,
13,
13,
17,
0,
18,
13,
18,
13,
13,
17,
14,
2,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
18,
13,
2,
13,
17,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13
] |
[
[
140,
4
],
[
140,
20
],
[
134,
22
],
[
137,
41
],
[
155,
44
],
[
143,
47
],
[
122,
52
],
[
56,
55
],
[
141,
59
],
[
135,
64
],
[
55,
65
],
[
123,
66
],
[
73,
68
],
[
123,
69
],
[
135,
71
],
[
55,
72
],
[
80,
75
],
[
123,
76
],
[
135,
78
],
[
55,
79
],
[
144,
83
],
[
132,
83
],
[
135,
85
],
[
55,
86
],
[
131,
88
],
[
135,
90
],
[
55,
91
],
[
125,
93
],
[
135,
96
],
[
55,
98
],
[
132,
100
],
[
144,
100
],
[
138,
103
],
[
147,
103
],
[
126,
104
],
[
146,
106
],
[
126,
107
],
[
149,
109
],
[
138,
113
],
[
147,
113
],
[
126,
114
],
[
152,
116
],
[
153,
120
],
[
150,
120
],
[
156,
120
],
[
122,
123
],
[
125,
126
],
[
140,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
126,
146
],
[
146,
147
],
[
149,
150
],
[
152,
153
],
[
155,
156
]
] |
[
"import sys\n\nN, T = map(int, sys.stdin.readline().strip().split())\nA = list(map(int, sys.stdin.readline().strip().split()))\n\n# 利益の最大額\nmax_profit = 0\nmax_count = 0\n# その時点での最小金額\ntmp_min = float(\"inf\")\n# 売買金額のカウント\ncount = {}\n\nfor i in range(N-1):\n if A[i] not in count:\n count[A[i]] = 0\n count[A[i]] += 1\n\n if tmp_min > A[i]:\n tmp_min = A[i]\n\n profit = A[i+1] - tmp_min\n if max_profit < profit:\n max_profit = profit\n max_count = 1\n elif max_profit == profit:\n max_count += 1\n\n # print(\"max_profit\", max_profit, \"tmp_min\", tmp_min)\n\nprint(max_count)",
"import sys",
"sys",
"N, T = map(int, sys.stdin.readline().strip().split())",
"N",
"map(int, sys.stdin.readline().strip().split())",
"map",
"int",
"sys.stdin.readline().strip().split()",
"sys.stdin.readline().strip().split",
"sys.stdin.readline().strip()",
"sys.stdin.readline().strip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"strip",
"split",
"T",
"A = list(map(int, sys.stdin.readline().strip().split()))",
"A",
"list(map(int, sys.stdin.readline().strip().split()))",
"list",
"map(int, sys.stdin.readline().strip().split())",
"map",
"int",
"sys.stdin.readline().strip().split()",
"sys.stdin.readline().strip().split",
"sys.stdin.readline().strip()",
"sys.stdin.readline().strip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"strip",
"split",
"max_profit = 0",
"max_profit",
"0",
"max_count = 0",
"max_count",
"0",
"tmp_min = float(\"inf\")",
"tmp_min",
"float(\"inf\")",
"float",
"\"inf\"",
"count = {}",
"count",
"{}",
"for i in range(N-1):\n if A[i] not in count:\n count[A[i]] = 0\n count[A[i]] += 1\n\n if tmp_min > A[i]:\n tmp_min = A[i]\n\n profit = A[i+1] - tmp_min\n if max_profit < profit:\n max_profit = profit\n max_count = 1\n elif max_profit == profit:\n max_count += 1\n\n # print(\"max_profit\", max_profit, \"tmp_min\", tmp_min)",
"i",
"range(N-1)",
"range",
"N-1",
"N",
"1",
"if A[i] not in count:\n count[A[i]] = 0\n ",
"A[i] not in count",
"A[i]",
"A",
"i",
"count",
"count[A[i]] = 0",
"count[A[i]]",
"count",
"A[i]",
"A",
"i",
"0",
"count[A[i]] += 1",
"count[A[i]]",
"count",
"A[i]",
"A",
"i",
"1",
"if tmp_min > A[i]:\n tmp_min = A[i]\n\n ",
"tmp_min > A[i]",
"tmp_min",
"A[i]",
"A",
"i",
"tmp_min = A[i]",
"tmp_min",
"A[i]",
"A",
"i",
"profit = A[i+1] - tmp_min",
"profit",
"A[i+1] - tmp_min",
"A[i+1]",
"A",
"i+1",
"i",
"1",
"tmp_min",
"if max_profit < profit:\n max_profit = profit\n max_count = 1\n elif max_profit == profit:\n max_count += 1\n\n # print(\"max_profit\", max_profit, \"tmp_min\", tmp_min)",
"max_profit < profit",
"max_profit",
"profit",
"max_profit = profit",
"max_profit",
"profit",
"max_count = 1",
"max_count",
"1",
"elif max_profit == profit:\n max_count += 1\n\n # print(\"max_profit\", max_profit, \"tmp_min\", tmp_min)",
"max_profit == profit",
"max_profit",
"profit",
"max_count += 1",
"max_count",
"1",
"print(max_count)",
"print",
"max_count",
"count = {}",
"{}",
"count",
"profit = A[i+1] - tmp_min",
"A[i+1] - tmp_min",
"profit",
"T = map(int, sys.stdin.readline().strip().split())",
"map(int, sys.stdin.readline().strip().split())",
"T",
"tmp_min = A[i]",
"A[i]",
"tmp_min",
"A = list(map(int, sys.stdin.readline().strip().split()))",
"list(map(int, sys.stdin.readline().strip().split()))",
"A",
"max_profit = 0",
"0",
"max_profit",
"N, T = map(int, sys.stdin.readline().strip().split())",
"map(int, sys.stdin.readline().strip().split())",
"N",
"tmp_min = float(\"inf\")",
"float(\"inf\")",
"tmp_min",
"max_profit = profit",
"profit",
"max_profit",
"max_count = 1",
"1",
"max_count",
"max_count += 1",
"1",
"max_count",
"max_count = 0",
"0",
"max_count"
] |
import sys
N, T = map(int, sys.stdin.readline().strip().split())
A = list(map(int, sys.stdin.readline().strip().split()))
# 利益の最大額
max_profit = 0
max_count = 0
# その時点での最小金額
tmp_min = float("inf")
# 売買金額のカウント
count = {}
for i in range(N-1):
if A[i] not in count:
count[A[i]] = 0
count[A[i]] += 1
if tmp_min > A[i]:
tmp_min = A[i]
profit = A[i+1] - tmp_min
if max_profit < profit:
max_profit = profit
max_count = 1
elif max_profit == profit:
max_count += 1
# print("max_profit", max_profit, "tmp_min", tmp_min)
print(max_count)
|
[
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,
18,
13,
17,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
13,
14,
2,
13,
13,
0,
13,
2,
13,
13,
14,
40,
13,
13,
0,
18,
13,
13,
39,
4,
18,
18,
13,
13,
13,
13,
14,
2,
13,
13,
9,
0,
13,
13,
0,
13,
4,
13,
4,
13,
4,
18,
13,
13,
0,
13,
12,
18,
13,
17,
23,
0,
13,
17,
4,
13,
4,
13,
18,
18,
13,
17,
17,
10,
17,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13
] |
[
[
124,
2
],
[
124,
11
],
[
121,
13
],
[
106,
25
],
[
130,
28
],
[
122,
30
],
[
34,
33
],
[
119,
37
],
[
112,
39
],
[
122,
41
],
[
33,
42
],
[
113,
45
],
[
131,
46
],
[
128,
46
],
[
109,
48
],
[
113,
50
],
[
131,
51
],
[
128,
51
],
[
110,
54
],
[
107,
55
],
[
60,
57
],
[
107,
58
],
[
110,
59
],
[
57,
63
],
[
107,
64
],
[
110,
65
],
[
33,
67
],
[
113,
70
],
[
131,
71
],
[
128,
71
],
[
127,
74
],
[
113,
75
],
[
115,
77
],
[
107,
84
],
[
88,
87
],
[
95,
94
],
[
116,
102
],
[
107,
102
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
124,
119
],
[
121,
122
],
[
124,
125
],
[
113,
127
],
[
127,
128
],
[
130,
131
]
] |
[
"N,T = map(int,input().split())\nA = list(map(int,input().split()))\nC = {}\namin = A[0]\nfor i in range(1,N):\n a = A[i]\n if a>amin:\n b = a-amin\n if b not in C:\n C[b] = []\n C[b].append(i)\n elif a==amin:\n continue\n else:\n amin = a\nC = sorted(list(C.items()),key=lambda x:x[0],reverse=True)\nprint(len(C[0][1]))",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"C = {}",
"C",
"{}",
"amin = A[0]",
"amin",
"A[0]",
"A",
"0",
"for i in range(1,N):\n a = A[i]\n if a>amin:\n b = a-amin\n if b not in C:\n C[b] = []\n C[b].append(i)\n elif a==amin:\n continue\n else:\n amin = a",
"i",
"range(1,N)",
"range",
"1",
"N",
"a = A[i]",
"a",
"A[i]",
"A",
"i",
"if a>amin:\n b = a-amin\n if b not in C:\n C[b] = []\n C[b].append(i)\n elif a==amin:\n continue\n else:\n amin = a",
"a>amin",
"a",
"amin",
"b = a-amin",
"b",
"a-amin",
"a",
"amin",
"if b not in C:\n C[b] = []\n ",
"b not in C",
"b",
"C",
"C[b] = []",
"C[b]",
"C",
"b",
"[]",
"C[b].append(i)",
"[b].append",
"[b]",
"C",
"b",
"append",
"i",
"elif a==amin:\n continue\n ",
"a==amin",
"a",
"amin",
"continue",
"amin = a",
"amin",
"a",
"C = sorted(list(C.items()),key=lambda x:x[0],reverse=True)",
"C",
"sorted(list(C.items()),key=lambda x:x[0],reverse=True)",
"sorted",
"list(C.items())",
"list",
"C.items()",
"C.items",
"C",
"items",
"key=lambda x:x[0]",
"key",
"lambda x:x[0]",
"x[0]",
"x",
"0",
"x",
"reverse=True",
"reverse",
"True",
"print(len(C[0][1]))",
"print",
"len(C[0][1])",
"len",
"C[0][1]",
"[0]",
"C",
"0",
"1",
"C = {}",
"{}",
"C",
"b = a-amin",
"a-amin",
"b",
"a = A[i]",
"A[i]",
"a",
"C = sorted(list(C.items()),key=lambda x:x[0],reverse=True)",
"sorted(list(C.items()),key=lambda x:x[0],reverse=True)",
"C",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"amin = a",
"a",
"amin",
"amin = A[0]",
"A[0]",
"amin"
] |
N,T = map(int,input().split())
A = list(map(int,input().split()))
C = {}
amin = A[0]
for i in range(1,N):
a = A[i]
if a>amin:
b = a-amin
if b not in C:
C[b] = []
C[b].append(i)
elif a==amin:
continue
else:
amin = a
C = sorted(list(C.items()),key=lambda x:x[0],reverse=True)
print(len(C[0][1]))
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
12,
4,
13,
4,
18,
18,
13,
13,
13,
0,
13,
12,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
4,
13,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
31,
13,
32,
4,
13,
0,
13,
18,
13,
13,
32,
13,
23,
16,
0,
13,
4,
13,
13,
0,
13,
4,
13,
4,
2,
13,
17,
4,
2,
4,
13,
13,
13,
12,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
18,
13,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
17,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
2,
13,
17,
18,
13,
13,
14,
40,
13,
17,
9,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
2,
13,
13,
40,
18,
13,
13,
13,
4,
18,
13,
13,
18,
13,
13,
0,
13,
4,
13,
13,
4,
2,
13,
17,
29,
13,
4,
13,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13
] |
[
[
244,
11
],
[
241,
22
],
[
247,
37
],
[
242,
42
],
[
253,
44
],
[
256,
56
],
[
67,
66
],
[
259,
75
],
[
242,
77
],
[
259,
78
],
[
262,
80
],
[
248,
82
],
[
251,
85
],
[
263,
91
],
[
251,
92
],
[
97,
96
],
[
251,
100
],
[
105,
102
],
[
96,
103
],
[
263,
106
],
[
110,
109
],
[
251,
113
],
[
118,
115
],
[
96,
116
],
[
109,
117
],
[
96,
121
],
[
109,
123
],
[
263,
126
],
[
109,
127
],
[
130,
129
],
[
251,
133
],
[
140,
135
],
[
129,
136
],
[
251,
138
],
[
263,
141
],
[
251,
143
],
[
147,
146
],
[
251,
150
],
[
158,
155
],
[
129,
156
],
[
146,
157
],
[
129,
161
],
[
146,
163
],
[
263,
166
],
[
146,
167
],
[
170,
169
],
[
173,
172
],
[
177,
176
],
[
251,
180
],
[
184,
183
],
[
129,
186
],
[
176,
188
],
[
115,
190
],
[
96,
191
],
[
176,
192
],
[
183,
195
],
[
183,
200
],
[
169,
201
],
[
203,
201
],
[
204,
203
],
[
183,
204
],
[
207,
206
],
[
183,
211
],
[
169,
212
],
[
203,
212
],
[
115,
214
],
[
96,
215
],
[
176,
216
],
[
172,
217
],
[
206,
217
],
[
172,
220
],
[
206,
220
],
[
115,
222
],
[
96,
223
],
[
176,
224
],
[
227,
226
],
[
206,
229
],
[
172,
229
],
[
226,
232
],
[
226,
235
],
[
266,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
259,
251
],
[
253,
254
],
[
256,
257
],
[
259,
260
],
[
262,
263
]
] |
[
"import sys\n\nsys.setrecursionlimit(10 ** 8)\nini = lambda: int(sys.stdin.readline())\ninm = lambda: map(int, sys.stdin.readline().split())\ninl = lambda: list(inm())\nins = lambda: sys.stdin.readline().rstrip()\ndebug = lambda *a, **kw: print(*a, **dict(file=sys.stderr, **kw))\n\nN, T = inm()\nA = inl()\nassert N > 1\nassert len(A) == N\n\n\ndef solve():\n lmin = [None] * N\n lmin[0] = A[0]\n for i in range(1, N):\n lmin[i] = min(lmin[i - 1], A[i])\n\n rmax = [None] * N\n rmax[N - 1] = A[N - 1]\n for i in range(N - 2, -1, -1):\n rmax[i] = max(rmax[i + 1], A[i])\n\n gap = -1\n gmin = set()\n for i in range(N - 1):\n g = rmax[i + 1] - lmin[i]\n if g <= 0:\n continue\n if g > gap:\n gap = g\n gmin = {lmin[i]}\n # debug(f\"{gap=}: {rmax[i+1]} - {lmin[i]}\")\n elif g == gap and lmin[i] not in gmin:\n gmin.add(lmin[i])\n buy = len(gmin)\n assert buy > 0\n return buy\n\n\nprint(solve())",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 8)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 8",
"10",
"8",
"ini = lambda: int(sys.stdin.readline())",
"ini",
"lambda: int(sys.stdin.readline())",
"int(sys.stdin.readline())",
"int",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"inm = lambda: map(int, sys.stdin.readline().split())",
"inm",
"lambda: map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"map",
"int",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"inl = lambda: list(inm())",
"inl",
"lambda: list(inm())",
"list(inm())",
"list",
"inm()",
"inm",
"ins = lambda: sys.stdin.readline().rstrip()",
"ins",
"lambda: sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"debug = lambda *a, **kw: print(*a, **dict(file=sys.stderr, **kw))",
"debug",
"lambda *a, **kw: print(*a, **dict(file=sys.stderr, **kw))",
"print(*a, **dict(file=sys.stderr, **kw))",
"print",
"*a",
"a",
"**dict(file=sys.stderr, **kw)",
"dict(file=sys.stderr, **kw)",
"dict",
"file=sys.stderr",
"file",
"sys.stderr",
"sys",
"stderr",
"**kw",
"kw",
"*a",
"**kw",
"N, T = inm()",
"N",
"inm()",
"inm",
"T",
"A = inl()",
"A",
"inl()",
"inl",
"assert N > 1",
"N > 1",
"N",
"1",
"assert len(A) == N",
"len(A) == N",
"len(A)",
"len",
"A",
"N",
"def solve():\n lmin = [None] * N\n lmin[0] = A[0]\n for i in range(1, N):\n lmin[i] = min(lmin[i - 1], A[i])\n\n rmax = [None] * N\n rmax[N - 1] = A[N - 1]\n for i in range(N - 2, -1, -1):\n rmax[i] = max(rmax[i + 1], A[i])\n\n gap = -1\n gmin = set()\n for i in range(N - 1):\n g = rmax[i + 1] - lmin[i]\n if g <= 0:\n continue\n if g > gap:\n gap = g\n gmin = {lmin[i]}\n # debug(f\"{gap=}: {rmax[i+1]} - {lmin[i]}\")\n elif g == gap and lmin[i] not in gmin:\n gmin.add(lmin[i])\n buy = len(gmin)\n assert buy > 0\n return buy",
"solve",
"lmin = [None] * N",
"lmin",
"[None] * N",
"[None]",
"None",
"N",
"lmin[0] = A[0]",
"lmin[0]",
"lmin",
"0",
"A[0]",
"A",
"0",
"for i in range(1, N):\n lmin[i] = min(lmin[i - 1], A[i])\n\n ",
"i",
"range(1, N)",
"range",
"1",
"N",
"lmin[i] = min(lmin[i - 1], A[i])",
"lmin[i]",
"lmin",
"i",
"min(lmin[i - 1], A[i])",
"min",
"lmin[i - 1]",
"lmin",
"i - 1",
"i",
"1",
"A[i]",
"A",
"i",
"rmax = [None] * N",
"rmax",
"[None] * N",
"[None]",
"None",
"N",
"rmax[N - 1] = A[N - 1]",
"rmax[N - 1]",
"rmax",
"N - 1",
"N",
"1",
"A[N - 1]",
"A",
"N - 1",
"N",
"1",
"for i in range(N - 2, -1, -1):\n rmax[i] = max(rmax[i + 1], A[i])\n\n ",
"i",
"range(N - 2, -1, -1)",
"range",
"N - 2",
"N",
"2",
"-1",
"-1",
"rmax[i] = max(rmax[i + 1], A[i])",
"rmax[i]",
"rmax",
"i",
"max(rmax[i + 1], A[i])",
"max",
"rmax[i + 1]",
"rmax",
"i + 1",
"i",
"1",
"A[i]",
"A",
"i",
"gap = -1",
"gap",
"-1",
"gmin = set()",
"gmin",
"set()",
"set",
"for i in range(N - 1):\n g = rmax[i + 1] - lmin[i]\n if g <= 0:\n continue\n if g > gap:\n gap = g\n gmin = {lmin[i]}\n # debug(f\"{gap=}: {rmax[i+1]} - {lmin[i]}\")\n elif g == gap and lmin[i] not in gmin:\n gmin.add(lmin[i])\n ",
"i",
"range(N - 1)",
"range",
"N - 1",
"N",
"1",
"g = rmax[i + 1] - lmin[i]",
"g",
"rmax[i + 1] - lmin[i]",
"rmax[i + 1]",
"rmax",
"i + 1",
"i",
"1",
"lmin[i]",
"lmin",
"i",
"if g <= 0:\n continue\n ",
"g <= 0",
"g",
"0",
"continue",
"if g > gap:\n gap = g\n gmin = {lmin[i]}\n # debug(f\"{gap=}: {rmax[i+1]} - {lmin[i]}\")\n elif g == gap and lmin[i] not in gmin:\n gmin.add(lmin[i])\n ",
"g > gap",
"g",
"gap",
"gap = g",
"gap",
"g",
"gmin = {lmin[i]}",
"gmin",
"{lmin[i]}",
"elif g == gap and lmin[i] not in gmin:\n gmin.add(lmin[i])\n ",
"g == gap and lmin[i] not in gmin",
"g == gap",
"g",
"gap",
"lmin[i] not in gmin",
"lmin[i]",
"lmin",
"i",
"gmin",
"gmin.add(lmin[i])",
"gmin.add",
"gmin",
"add",
"lmin[i]",
"lmin",
"i",
"buy = len(gmin)",
"buy",
"len(gmin)",
"len",
"gmin",
"assert buy > 0",
"buy > 0",
"buy",
"0",
"return buy",
"buy",
"print(solve())",
"print",
"solve()",
"solve",
"inm = lambda: map(int, sys.stdin.readline().split())",
"lambda: map(int, sys.stdin.readline().split())",
"inm",
"ini = lambda: int(sys.stdin.readline())",
"lambda: int(sys.stdin.readline())",
"ini",
"inl = lambda: list(inm())",
"lambda: list(inm())",
"inl",
"N, T = inm()",
"inm()",
"N",
"ins = lambda: sys.stdin.readline().rstrip()",
"lambda: sys.stdin.readline().rstrip()",
"ins",
"debug = lambda *a, **kw: print(*a, **dict(file=sys.stderr, **kw))",
"lambda *a, **kw: print(*a, **dict(file=sys.stderr, **kw))",
"debug",
"T = inm()",
"inm()",
"T",
"A = inl()",
"inl()",
"A",
"def solve():\n lmin = [None] * N\n lmin[0] = A[0]\n for i in range(1, N):\n lmin[i] = min(lmin[i - 1], A[i])\n\n rmax = [None] * N\n rmax[N - 1] = A[N - 1]\n for i in range(N - 2, -1, -1):\n rmax[i] = max(rmax[i + 1], A[i])\n\n gap = -1\n gmin = set()\n for i in range(N - 1):\n g = rmax[i + 1] - lmin[i]\n if g <= 0:\n continue\n if g > gap:\n gap = g\n gmin = {lmin[i]}\n # debug(f\"{gap=}: {rmax[i+1]} - {lmin[i]}\")\n elif g == gap and lmin[i] not in gmin:\n gmin.add(lmin[i])\n buy = len(gmin)\n assert buy > 0\n return buy",
"def solve():\n lmin = [None] * N\n lmin[0] = A[0]\n for i in range(1, N):\n lmin[i] = min(lmin[i - 1], A[i])\n\n rmax = [None] * N\n rmax[N - 1] = A[N - 1]\n for i in range(N - 2, -1, -1):\n rmax[i] = max(rmax[i + 1], A[i])\n\n gap = -1\n gmin = set()\n for i in range(N - 1):\n g = rmax[i + 1] - lmin[i]\n if g <= 0:\n continue\n if g > gap:\n gap = g\n gmin = {lmin[i]}\n # debug(f\"{gap=}: {rmax[i+1]} - {lmin[i]}\")\n elif g == gap and lmin[i] not in gmin:\n gmin.add(lmin[i])\n buy = len(gmin)\n assert buy > 0\n return buy",
"solve"
] |
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print(*a, **dict(file=sys.stderr, **kw))
N, T = inm()
A = inl()
assert N > 1
assert len(A) == N
def solve():
lmin = [None] * N
lmin[0] = A[0]
for i in range(1, N):
lmin[i] = min(lmin[i - 1], A[i])
rmax = [None] * N
rmax[N - 1] = A[N - 1]
for i in range(N - 2, -1, -1):
rmax[i] = max(rmax[i + 1], A[i])
gap = -1
gmin = set()
for i in range(N - 1):
g = rmax[i + 1] - lmin[i]
if g <= 0:
continue
if g > gap:
gap = g
gmin = {lmin[i]}
# debug(f"{gap=}: {rmax[i+1]} - {lmin[i]}")
elif g == gap and lmin[i] not in gmin:
gmin.add(lmin[i])
buy = len(gmin)
assert buy > 0
return buy
print(solve())
|
[
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,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
18,
13,
13,
17,
0,
13,
18,
13,
4,
13,
4,
18,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] |
[
[
87,
3
],
[
87,
12
],
[
93,
14
],
[
96,
26
],
[
84,
31
],
[
94,
33
],
[
37,
36
],
[
88,
40
],
[
94,
44
],
[
36,
45
],
[
85,
46
],
[
91,
46
],
[
90,
48
],
[
94,
50
],
[
36,
51
],
[
78,
53
],
[
94,
56
],
[
36,
57
],
[
85,
58
],
[
91,
58
],
[
63,
60
],
[
97,
61
],
[
79,
62
],
[
99,
65
],
[
97,
67
],
[
97,
72
],
[
100,
76
],
[
78,
79
],
[
87,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
]
] |
[
"from collections import defaultdict as dd\nN,T = map(int,input().split())\na = list(map(int,input().split()))\ndic=dd(int)\nmi = a[0]\nfor i in range(1,N):\n if a[i] < mi:\n mi = a[i]\n else:\n profit = a[i]-mi\n dic[profit] += 1\nres = dic[max(dic.keys())]\nprint(res)",
"from collections import defaultdict as dd",
"N,T = map(int,input().split())",
"N",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"T",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"dic=dd(int)",
"dic",
"dd(int)",
"dd",
"int",
"mi = a[0]",
"mi",
"a[0]",
"a",
"0",
"for i in range(1,N):\n if a[i] < mi:\n mi = a[i]\n else:\n profit = a[i]-mi\n dic[profit] += 1",
"i",
"range(1,N)",
"range",
"1",
"N",
"if a[i] < mi:\n mi = a[i]\n else:\n profit = a[i]-mi\n dic[profit] += 1",
"a[i] < mi",
"a[i]",
"a",
"i",
"mi",
"mi = a[i]",
"mi",
"a[i]",
"a",
"i",
"profit = a[i]-mi",
"profit",
"a[i]-mi",
"a[i]",
"a",
"i",
"mi",
"dic[profit] += 1",
"dic[profit]",
"dic",
"profit",
"1",
"res = dic[max(dic.keys())]",
"res",
"dic[max(dic.keys())]",
"dic",
"max(dic.keys())",
"max",
"dic.keys()",
"dic.keys",
"dic",
"keys",
"print(res)",
"print",
"res",
"profit = a[i]-mi",
"a[i]-mi",
"profit",
"T = map(int,input().split())",
"map(int,input().split())",
"T",
"mi = a[0]",
"a[0]",
"mi",
"N,T = map(int,input().split())",
"map(int,input().split())",
"N",
"mi = a[i]",
"a[i]",
"mi",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"dic=dd(int)",
"dd(int)",
"dic",
"res = dic[max(dic.keys())]",
"dic[max(dic.keys())]",
"res"
] |
from collections import defaultdict as dd
N,T = map(int,input().split())
a = list(map(int,input().split()))
dic=dd(int)
mi = a[0]
for i in range(1,N):
if a[i] < mi:
mi = a[i]
else:
profit = a[i]-mi
dic[profit] += 1
res = dic[max(dic.keys())]
print(res)
|
[
7,
15,
13,
15,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
0,
13,
17,
28,
13,
18,
13,
39,
17,
14,
2,
13,
13,
0,
13,
13,
4,
18,
13,
13,
13,
0,
13,
18,
13,
39,
17,
0,
13,
4,
13,
13,
28,
13,
13,
4,
13,
13,
13,
0,
18,
13,
2,
13,
13,
17,
0,
13,
4,
13,
4,
18,
13,
13,
0,
13,
17,
4,
13,
18,
18,
13,
17,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13
] |
[
[
128,
12
],
[
125,
17
],
[
27,
26
],
[
27,
35
],
[
38,
37
],
[
50,
49
],
[
53,
52
],
[
56,
55
],
[
37,
57
],
[
52,
62
],
[
65,
62
],
[
55,
63
],
[
66,
65
],
[
55,
66
],
[
49,
69
],
[
65,
71
],
[
52,
71
],
[
74,
73
],
[
49,
75
],
[
80,
79
],
[
37,
88
],
[
73,
89
],
[
49,
89
],
[
96,
91
],
[
79,
92
],
[
99,
98
],
[
79,
103
],
[
107,
106
],
[
98,
112
],
[
123,
120
],
[
125,
126
],
[
128,
129
]
] |
[
"import sys\nfrom collections import defaultdict\n\nsys.setrecursionlimit(10 ** 7)\nf_inf = float('inf')\nmod = 10 ** 9 + 7\n\n\ndef resolve():\n n, t = map(int, input().split())\n A = list(map(int, input().split()))\n\n MAX_S = []\n max_s = 0\n for a in A[::-1]:\n if max_s < a:\n max_s = a\n MAX_S.append(max_s)\n MAX_S = MAX_S[::-1]\n\n cnt = defaultdict(int)\n for a, s in zip(A, MAX_S):\n cnt[s - a] += 1\n\n res = sorted(cnt.items(), reverse=True)\n print(res[0][1])\n\n\nif __name__ == '__main__':\n resolve()",
"import sys",
"sys",
"from collections import defaultdict",
"sys.setrecursionlimit(10 ** 7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 7",
"10",
"7",
"f_inf = float('inf')",
"f_inf",
"float('inf')",
"float",
"'inf'",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def resolve():\n n, t = map(int, input().split())\n A = list(map(int, input().split()))\n\n MAX_S = []\n max_s = 0\n for a in A[::-1]:\n if max_s < a:\n max_s = a\n MAX_S.append(max_s)\n MAX_S = MAX_S[::-1]\n\n cnt = defaultdict(int)\n for a, s in zip(A, MAX_S):\n cnt[s - a] += 1\n\n res = sorted(cnt.items(), reverse=True)\n print(res[0][1])",
"resolve",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"MAX_S = []",
"MAX_S",
"[]",
"max_s = 0",
"max_s",
"0",
"for a in A[::-1]:\n if max_s < a:\n max_s = a\n MAX_S.append(max_s)\n ",
"a",
"A[::-1]",
"A",
"::-1",
"-1",
"if max_s < a:\n max_s = a\n ",
"max_s < a",
"max_s",
"a",
"max_s = a",
"max_s",
"a",
"MAX_S.append(max_s)",
"MAX_S.append",
"MAX_S",
"append",
"max_s",
"MAX_S = MAX_S[::-1]",
"MAX_S",
"MAX_S[::-1]",
"MAX_S",
"::-1",
"-1",
"cnt = defaultdict(int)",
"cnt",
"defaultdict(int)",
"defaultdict",
"int",
"for a, s in zip(A, MAX_S):\n cnt[s - a] += 1\n\n ",
"a",
"s",
"zip(A, MAX_S)",
"zip",
"A",
"MAX_S",
"cnt[s - a] += 1",
"cnt[s - a]",
"cnt",
"s - a",
"s",
"a",
"1",
"res = sorted(cnt.items(), reverse=True)",
"res",
"sorted(cnt.items(), reverse=True)",
"sorted",
"cnt.items()",
"cnt.items",
"cnt",
"items",
"reverse=True",
"reverse",
"True",
"print(res[0][1])",
"print",
"res[0][1]",
"[0]",
"res",
"0",
"1",
"if __name__ == '__main__':\n resolve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"resolve()",
"resolve",
"def resolve():\n n, t = map(int, input().split())\n A = list(map(int, input().split()))\n\n MAX_S = []\n max_s = 0\n for a in A[::-1]:\n if max_s < a:\n max_s = a\n MAX_S.append(max_s)\n MAX_S = MAX_S[::-1]\n\n cnt = defaultdict(int)\n for a, s in zip(A, MAX_S):\n cnt[s - a] += 1\n\n res = sorted(cnt.items(), reverse=True)\n print(res[0][1])",
"def resolve():\n n, t = map(int, input().split())\n A = list(map(int, input().split()))\n\n MAX_S = []\n max_s = 0\n for a in A[::-1]:\n if max_s < a:\n max_s = a\n MAX_S.append(max_s)\n MAX_S = MAX_S[::-1]\n\n cnt = defaultdict(int)\n for a, s in zip(A, MAX_S):\n cnt[s - a] += 1\n\n res = sorted(cnt.items(), reverse=True)\n print(res[0][1])",
"resolve",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"f_inf = float('inf')",
"float('inf')",
"f_inf"
] |
import sys
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, t = map(int, input().split())
A = list(map(int, input().split()))
MAX_S = []
max_s = 0
for a in A[::-1]:
if max_s < a:
max_s = a
MAX_S.append(max_s)
MAX_S = MAX_S[::-1]
cnt = defaultdict(int)
for a, s in zip(A, MAX_S):
cnt[s - a] += 1
res = sorted(cnt.items(), reverse=True)
print(res[0][1])
if __name__ == '__main__':
resolve()
|
[
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,
18,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
13,
13,
0,
13,
18,
13,
13,
9,
0,
13,
2,
18,
13,
13,
13,
14,
2,
13,
13,
0,
13,
13,
0,
13,
17,
14,
2,
13,
13,
0,
13,
17,
4,
13,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] |
[
[
108,
2
],
[
108,
11
],
[
15,
14
],
[
14,
23
],
[
111,
25
],
[
96,
28
],
[
112,
30
],
[
105,
33
],
[
90,
36
],
[
40,
39
],
[
109,
43
],
[
112,
47
],
[
39,
48
],
[
97,
49
],
[
85,
49
],
[
84,
51
],
[
112,
53
],
[
39,
54
],
[
87,
57
],
[
112,
60
],
[
39,
61
],
[
85,
62
],
[
97,
62
],
[
91,
65
],
[
100,
65
],
[
88,
66
],
[
99,
68
],
[
88,
69
],
[
114,
71
],
[
91,
75
],
[
100,
75
],
[
88,
76
],
[
93,
78
],
[
94,
82
],
[
115,
82
],
[
106,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
88,
99
],
[
99,
100
],
[
108,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
]
] |
[
"n, t = map(int, input().split())\na = [int(x) for x in input().split()]\n\nminimum = a[0]\ncount = 0\nprofit = 0\nfor i in range(1, n):\n if a[i] < minimum:\n minimum = a[i]\n continue\n \n k = a[i]-minimum\n if profit < k:\n profit = k\n count = 1\n elif profit == k:\n count += 1\n\nprint(count)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"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",
"a = [int(x) for x in input().split()]",
"a",
"[int(x) for x in input().split()]",
"minimum = a[0]",
"minimum",
"a[0]",
"a",
"0",
"count = 0",
"count",
"0",
"profit = 0",
"profit",
"0",
"for i in range(1, n):\n if a[i] < minimum:\n minimum = a[i]\n continue\n \n k = a[i]-minimum\n if profit < k:\n profit = k\n count = 1\n elif profit == k:\n count += 1",
"i",
"range(1, n)",
"range",
"1",
"n",
"if a[i] < minimum:\n minimum = a[i]\n continue\n \n ",
"a[i] < minimum",
"a[i]",
"a",
"i",
"minimum",
"minimum = a[i]",
"minimum",
"a[i]",
"a",
"i",
"continue",
"k = a[i]-minimum",
"k",
"a[i]-minimum",
"a[i]",
"a",
"i",
"minimum",
"if profit < k:\n profit = k\n count = 1\n elif profit == k:\n count += 1",
"profit < k",
"profit",
"k",
"profit = k",
"profit",
"k",
"count = 1",
"count",
"1",
"elif profit == k:\n count += 1",
"profit == k",
"profit",
"k",
"count += 1",
"count",
"1",
"print(count)",
"print",
"count",
"minimum = a[i]",
"a[i]",
"minimum",
"k = a[i]-minimum",
"a[i]-minimum",
"k",
"profit = 0",
"0",
"profit",
"count += 1",
"1",
"count",
"minimum = a[0]",
"a[0]",
"minimum",
"profit = k",
"k",
"profit",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"count = 0",
"0",
"count",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"a = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"a",
"count = 1",
"1",
"count"
] |
n, t = map(int, input().split())
a = [int(x) for x in input().split()]
minimum = a[0]
count = 0
profit = 0
for i in range(1, n):
if a[i] < minimum:
minimum = a[i]
continue
k = a[i]-minimum
if profit < k:
profit = k
count = 1
elif profit == k:
count += 1
print(count)
|
[
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,
17,
0,
13,
39,
28,
13,
4,
13,
17,
13,
14,
2,
13,
18,
13,
40,
13,
0,
13,
18,
13,
40,
13,
4,
18,
13,
13,
13,
0,
13,
18,
13,
39,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
13,
18,
13,
13,
14,
2,
13,
13,
0,
18,
13,
13,
17,
0,
18,
13,
13,
17,
0,
13,
4,
13,
4,
18,
13,
13,
4,
13,
18,
13,
17,
10,
17,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
134,
2
],
[
134,
11
],
[
116,
13
],
[
107,
25
],
[
122,
28
],
[
110,
31
],
[
35,
34
],
[
135,
38
],
[
123,
41
],
[
126,
41
],
[
117,
43
],
[
34,
45
],
[
125,
47
],
[
117,
49
],
[
34,
51
],
[
111,
54
],
[
126,
56
],
[
123,
56
],
[
119,
58
],
[
111,
60
],
[
65,
64
],
[
135,
68
],
[
113,
71
],
[
120,
74
],
[
111,
74
],
[
64,
75
],
[
117,
77
],
[
64,
78
],
[
114,
81
],
[
108,
82
],
[
87,
84
],
[
108,
85
],
[
114,
86
],
[
92,
89
],
[
108,
90
],
[
114,
91
],
[
128,
94
],
[
108,
99
],
[
129,
104
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
134,
132
],
[
134,
135
]
] |
[
"n, t = map(int,input().split())\na = list(map(int, input().split()))\n\nresult = {}\nm = 0\nchecker = []\nfor i in range(1, n):\n if m<a[-i]:\n m = a[-i]\n checker.append(m)\nchecker = checker[::-1]\nfor i in range(n-1):\n s = checker[i]-a[i]\n if s in result:\n result[s] += 1\n else:\n result[s] = 1\nx = max(result.items())\nprint(x[1])",
"n, t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"result = {}",
"result",
"{}",
"m = 0",
"m",
"0",
"checker = []",
"checker",
"[]",
"for i in range(1, n):\n if m<a[-i]:\n m = a[-i]\n checker.append(m)",
"i",
"range(1, n)",
"range",
"1",
"n",
"if m<a[-i]:\n m = a[-i]\n ",
"m<a[-i]",
"m",
"a[-i]",
"a",
"-i",
"i",
"m = a[-i]",
"m",
"a[-i]",
"a",
"-i",
"i",
"checker.append(m)",
"checker.append",
"checker",
"append",
"m",
"checker = checker[::-1]",
"checker",
"checker[::-1]",
"checker",
"::-1",
"-1",
"for i in range(n-1):\n s = checker[i]-a[i]\n if s in result:\n result[s] += 1\n else:\n result[s] = 1",
"i",
"range(n-1)",
"range",
"n-1",
"n",
"1",
"s = checker[i]-a[i]",
"s",
"checker[i]-a[i]",
"checker[i]",
"checker",
"i",
"a[i]",
"a",
"i",
"if s in result:\n result[s] += 1\n else:\n result[s] = 1",
"s in result",
"s",
"result",
"result[s] += 1",
"result[s]",
"result",
"s",
"1",
"result[s] = 1",
"result[s]",
"result",
"s",
"1",
"x = max(result.items())",
"x",
"max(result.items())",
"max",
"result.items()",
"result.items",
"result",
"items",
"print(x[1])",
"print",
"x[1]",
"x",
"1",
"result = {}",
"{}",
"result",
"checker = []",
"[]",
"checker",
"s = checker[i]-a[i]",
"checker[i]-a[i]",
"s",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"checker = checker[::-1]",
"checker[::-1]",
"checker",
"m = 0",
"0",
"m",
"m = a[-i]",
"a[-i]",
"m",
"x = max(result.items())",
"max(result.items())",
"x",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"n, t = map(int,input().split())",
"map(int,input().split())",
"n"
] |
n, t = map(int,input().split())
a = list(map(int, input().split()))
result = {}
m = 0
checker = []
for i in range(1, n):
if m<a[-i]:
m = a[-i]
checker.append(m)
checker = checker[::-1]
for i in range(n-1):
s = checker[i]-a[i]
if s in result:
result[s] += 1
else:
result[s] = 1
x = max(result.items())
print(x[1])
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
17,
0,
13,
18,
13,
17,
28,
13,
18,
13,
39,
17,
4,
18,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
86,
2
],
[
86,
11
],
[
83,
13
],
[
77,
25
],
[
74,
29
],
[
84,
31
],
[
35,
34
],
[
84,
36
],
[
78,
41
],
[
34,
44
],
[
75,
45
],
[
72,
45
],
[
71,
47
],
[
75,
50
],
[
72,
50
],
[
34,
51
],
[
89,
53
],
[
78,
56
],
[
80,
58
],
[
78,
61
],
[
90,
63
],
[
81,
66
],
[
86,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] |
[
"n, t = map(int, input().split())\nA = list(map(int, input().split()))\nB = [0]\n\nm = A[0]\nfor a in A[1:]:\n B.append(a - m)\n m = min(m, a)\n \nmx = max(B)\n\nans = B.count(mx)\nprint(ans)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"B = [0]",
"B",
"[0]",
"0",
"m = A[0]",
"m",
"A[0]",
"A",
"0",
"for a in A[1:]:\n B.append(a - m)\n m = min(m, a)\n ",
"a",
"A[1:]",
"A",
"1:",
"1",
"B.append(a - m)",
"B.append",
"B",
"append",
"a - m",
"a",
"m",
"m = min(m, a)",
"m",
"min(m, a)",
"min",
"m",
"a",
"mx = max(B)",
"mx",
"max(B)",
"max",
"B",
"ans = B.count(mx)",
"ans",
"B.count(mx)",
"B.count",
"B",
"count",
"mx",
"print(ans)",
"print",
"ans",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"m = min(m, a)",
"min(m, a)",
"m",
"m = A[0]",
"A[0]",
"m",
"B = [0]",
"[0]",
"B",
"ans = B.count(mx)",
"B.count(mx)",
"ans",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"mx = max(B)",
"max(B)",
"mx"
] |
n, t = map(int, input().split())
A = list(map(int, input().split()))
B = [0]
m = A[0]
for a in A[1:]:
B.append(a - m)
m = min(m, a)
mx = max(B)
ans = B.count(mx)
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,
2,
17,
17,
17,
0,
13,
2,
39,
17,
13,
0,
13,
13,
28,
13,
13,
4,
13,
13,
0,
18,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
84,
2
],
[
84,
11
],
[
99,
13
],
[
78,
25
],
[
96,
32
],
[
85,
36
],
[
87,
38
],
[
79,
39
],
[
100,
45
],
[
50,
47
],
[
97,
48
],
[
88,
52
],
[
82,
52
],
[
81,
54
],
[
88,
57
],
[
82,
57
],
[
90,
60
],
[
97,
63
],
[
93,
65
],
[
97,
68
],
[
91,
70
],
[
94,
73
],
[
84,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
79,
87
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
]
] |
[
"n, t = map(int, input().split())\na = list(map(int, input().split()))\nINF = 10 ** 9 + 1\n\nprofit = [0] * n\nbuy_mn = INF\nfor i, e in enumerate(a):\n profit[i] = e - buy_mn\n buy_mn = min(buy_mn, e)\n\nprofit_mx = max(profit)\nans = profit.count(profit_mx)\nprint(ans)",
"n, t = map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"INF = 10 ** 9 + 1",
"INF",
"10 ** 9 + 1",
"10 ** 9",
"10",
"9",
"1",
"profit = [0] * n",
"profit",
"[0] * n",
"[0]",
"0",
"n",
"buy_mn = INF",
"buy_mn",
"INF",
"for i, e in enumerate(a):\n profit[i] = e - buy_mn\n buy_mn = min(buy_mn, e)",
"i",
"e",
"enumerate(a)",
"enumerate",
"a",
"profit[i] = e - buy_mn",
"profit[i]",
"profit",
"i",
"e - buy_mn",
"e",
"buy_mn",
"buy_mn = min(buy_mn, e)",
"buy_mn",
"min(buy_mn, e)",
"min",
"buy_mn",
"e",
"profit_mx = max(profit)",
"profit_mx",
"max(profit)",
"max",
"profit",
"ans = profit.count(profit_mx)",
"ans",
"profit.count(profit_mx)",
"profit.count",
"profit",
"count",
"profit_mx",
"print(ans)",
"print",
"ans",
"t = map(int, input().split())",
"map(int, input().split())",
"t",
"INF = 10 ** 9 + 1",
"10 ** 9 + 1",
"INF",
"buy_mn = min(buy_mn, e)",
"min(buy_mn, e)",
"buy_mn",
"n, t = map(int, input().split())",
"map(int, input().split())",
"n",
"buy_mn = INF",
"INF",
"buy_mn",
"profit_mx = max(profit)",
"max(profit)",
"profit_mx",
"ans = profit.count(profit_mx)",
"profit.count(profit_mx)",
"ans",
"profit = [0] * n",
"[0] * n",
"profit",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] |
n, t = map(int, input().split())
a = list(map(int, input().split()))
INF = 10 ** 9 + 1
profit = [0] * n
buy_mn = INF
for i, e in enumerate(a):
profit[i] = e - buy_mn
buy_mn = min(buy_mn, e)
profit_mx = max(profit)
ans = profit.count(profit_mx)
print(ans)
|
[
7,
15,
13,
13,
13,
13,
13,
0,
13,
12,
4,
18,
4,
18,
4,
18,
18,
18,
13,
13,
13,
13,
13,
13,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
13,
0,
13,
17,
0,
13,
17,
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,
2,
39,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
13,
18,
13,
13,
0,
18,
13,
13,
2,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
4,
13,
18,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
126,
8
],
[
141,
26
],
[
135,
31
],
[
144,
38
],
[
142,
39
],
[
138,
41
],
[
147,
44
],
[
159,
47
],
[
123,
50
],
[
127,
57
],
[
123,
59
],
[
129,
61
],
[
127,
70
],
[
150,
73
],
[
121,
77
],
[
132,
79
],
[
130,
81
],
[
85,
84
],
[
121,
87
],
[
156,
89
],
[
133,
92
],
[
157,
92
],
[
130,
94
],
[
84,
95
],
[
100,
97
],
[
151,
98
],
[
84,
99
],
[
130,
102
],
[
84,
103
],
[
157,
104
],
[
133,
104
],
[
153,
106
],
[
151,
111
],
[
154,
115
],
[
151,
118
],
[
123,
121
],
[
123,
124
],
[
126,
127
],
[
129,
130
],
[
132,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
142,
144
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
]
] |
[
"#!/usr/bin/env python3\nimport sys, math, itertools, collections, bisect\ninput = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')\ninf = float('inf') ;mod = 10**9+7\nmans = inf ;ans = 0 ;count = 0 ;pro = 1\n\nn,t = map(int,input().split())\nA = list(map(int,input().split()))\nB = [0] * n\nacumin = A[0]\nfor i in range(n):\n acumin = min(acumin,A[i])\n B[i] = A[i] - acumin\nC = collections.Counter(B)\nprint(C[max(B)])",
"import sys, math, itertools, collections, bisect",
"sys",
"math",
"itertools",
"collections",
"bisect",
"input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"input",
"lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"sys.stdin.buffer.readline().rstrip().decode",
"sys.stdin.buffer.readline().rstrip()",
"sys.stdin.buffer.readline().rstrip",
"sys.stdin.buffer.readline()",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"rstrip",
"decode",
"'utf-8'",
"inf = float('inf')",
"inf",
"float('inf')",
"float",
"'inf'",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"mans = inf",
"mans",
"inf",
"ans = 0",
"ans",
"0",
"count = 0",
"count",
"0",
"pro = 1",
"pro",
"1",
"n,t = map(int,input().split())",
"n",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"B = [0] * n",
"B",
"[0] * n",
"[0]",
"0",
"n",
"acumin = A[0]",
"acumin",
"A[0]",
"A",
"0",
"for i in range(n):\n acumin = min(acumin,A[i])\n B[i] = A[i] - acumin",
"i",
"range(n)",
"range",
"n",
"acumin = min(acumin,A[i])",
"acumin",
"min(acumin,A[i])",
"min",
"acumin",
"A[i]",
"A",
"i",
"B[i] = A[i] - acumin",
"B[i]",
"B",
"i",
"A[i] - acumin",
"A[i]",
"A",
"i",
"acumin",
"C = collections.Counter(B)",
"C",
"collections.Counter(B)",
"collections.Counter",
"collections",
"Counter",
"B",
"print(C[max(B)])",
"print",
"C[max(B)]",
"C",
"max(B)",
"max",
"B",
"n,t = map(int,input().split())",
"map(int,input().split())",
"n",
"t = map(int,input().split())",
"map(int,input().split())",
"t",
"input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"input",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"acumin = A[0]",
"A[0]",
"acumin",
"mod = 10**9+7",
"10**9+7",
"mod",
"ans = 0",
"0",
"ans",
"inf = float('inf')",
"float('inf')",
"inf",
"mans = inf",
"inf",
"mans",
"count = 0",
"0",
"count",
"B = [0] * n",
"[0] * n",
"B",
"C = collections.Counter(B)",
"collections.Counter(B)",
"C",
"acumin = min(acumin,A[i])",
"min(acumin,A[i])",
"acumin",
"pro = 1",
"1",
"pro"
] |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,t = map(int,input().split())
A = list(map(int,input().split()))
B = [0] * n
acumin = A[0]
for i in range(n):
acumin = min(acumin,A[i])
B[i] = A[i] - acumin
C = collections.Counter(B)
print(C[max(B)])
|
[
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,
39,
4,
13,
17,
17,
17,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
13,
17,
0,
18,
18,
13,
13,
17,
18,
13,
13,
0,
18,
18,
13,
13,
17,
4,
13,
18,
18,
13,
2,
13,
17,
17,
18,
13,
13,
14,
2,
18,
18,
13,
2,
13,
17,
17,
2,
18,
13,
13,
18,
18,
13,
2,
13,
17,
17,
0,
18,
18,
13,
13,
17,
2,
18,
13,
13,
18,
18,
13,
2,
13,
17,
17,
0,
18,
18,
13,
13,
17,
17,
14,
2,
18,
18,
13,
2,
13,
17,
17,
2,
18,
13,
13,
18,
18,
13,
2,
13,
17,
17,
0,
18,
18,
13,
13,
17,
18,
18,
13,
2,
13,
17,
17,
0,
18,
18,
13,
13,
17,
2,
18,
18,
13,
2,
13,
17,
17,
17,
0,
18,
18,
13,
13,
17,
18,
18,
13,
2,
13,
17,
17,
0,
18,
18,
13,
13,
17,
18,
18,
13,
2,
13,
17,
17,
4,
13,
18,
18,
13,
17,
17,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
211,
2
],
[
211,
11
],
[
208,
13
],
[
27,
26
],
[
206,
29
],
[
202,
38
],
[
42,
41
],
[
206,
44
],
[
41,
47
],
[
55,
50
],
[
203,
52
],
[
41,
53
],
[
209,
56
],
[
41,
57
],
[
64,
59
],
[
203,
61
],
[
41,
62
],
[
203,
68
],
[
41,
70
],
[
209,
74
],
[
41,
75
],
[
203,
80
],
[
41,
82
],
[
209,
87
],
[
41,
88
],
[
203,
91
],
[
41,
93
],
[
102,
97
],
[
203,
99
],
[
41,
100
],
[
209,
104
],
[
41,
105
],
[
203,
108
],
[
41,
110
],
[
119,
114
],
[
203,
116
],
[
41,
117
],
[
203,
124
],
[
41,
126
],
[
209,
131
],
[
41,
132
],
[
203,
135
],
[
41,
137
],
[
146,
141
],
[
203,
143
],
[
41,
144
],
[
203,
148
],
[
41,
150
],
[
159,
154
],
[
203,
156
],
[
41,
157
],
[
203,
162
],
[
41,
164
],
[
174,
169
],
[
203,
171
],
[
41,
172
],
[
203,
176
],
[
41,
178
],
[
187,
182
],
[
203,
184
],
[
41,
185
],
[
203,
189
],
[
41,
191
],
[
203,
198
],
[
202,
203
],
[
211,
206
],
[
208,
209
],
[
211,
212
]
] |
[
"n,t= map(int, input().split())\na= list(map(int, input().split()))\n\n# dp[i][0]:０からiまでの区間に置けるMIN\n# dp[i][1]:その区間での左から右への差の最大値\n# dp[i][2]:最大値をとるものがいくつあるか\ndp=[[float('inf'),0,0] for i in range(n)]\n\nfor i in range(n):\n if i==0:\n dp[i][0]=a[i]\n else:\n dp[i][0]=min(dp[i-1][0],a[i])\n if dp[i-1][1]<a[i]-dp[i-1][0]:\n dp[i][1]=a[i]-dp[i-1][0]\n dp[i][2]=1\n elif dp[i-1][1]==a[i]-dp[i-1][0]:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]+1\n else:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]\n\n\nprint(dp[-1][2])",
"n,t= map(int, input().split())",
"n",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"t",
"a= list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[float('inf'),0,0] for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"[float('inf'),0,0]",
"float('inf')",
"float",
"'inf'",
"0",
"0",
"dp=[[float('inf'),0,0] for i in range(n)]",
"dp",
"[[float('inf'),0,0] for i in range(n)]",
"for i in range(n):\n if i==0:\n dp[i][0]=a[i]\n else:\n dp[i][0]=min(dp[i-1][0],a[i])\n if dp[i-1][1]<a[i]-dp[i-1][0]:\n dp[i][1]=a[i]-dp[i-1][0]\n dp[i][2]=1\n elif dp[i-1][1]==a[i]-dp[i-1][0]:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]+1\n else:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]",
"i",
"range(n)",
"range",
"n",
"if i==0:\n dp[i][0]=a[i]\n else:\n dp[i][0]=min(dp[i-1][0],a[i])\n if dp[i-1][1]<a[i]-dp[i-1][0]:\n dp[i][1]=a[i]-dp[i-1][0]\n dp[i][2]=1\n elif dp[i-1][1]==a[i]-dp[i-1][0]:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]+1\n else:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]",
"i==0",
"i",
"0",
"dp[i][0]=a[i]",
"dp[i][0]",
"[i]",
"dp",
"i",
"0",
"a[i]",
"a",
"i",
"dp[i][0]=min(dp[i-1][0],a[i])",
"dp[i][0]",
"[i]",
"dp",
"i",
"0",
"min(dp[i-1][0],a[i])",
"min",
"dp[i-1][0]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"0",
"a[i]",
"a",
"i",
"if dp[i-1][1]<a[i]-dp[i-1][0]:\n dp[i][1]=a[i]-dp[i-1][0]\n dp[i][2]=1\n elif dp[i-1][1]==a[i]-dp[i-1][0]:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]+1\n else:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]",
"dp[i-1][1]<a[i]-dp[i-1][0]",
"dp[i-1][1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"1",
"a[i]-dp[i-1][0]",
"a[i]",
"a",
"i",
"dp[i-1][0]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"0",
"dp[i][1]=a[i]-dp[i-1][0]",
"dp[i][1]",
"[i]",
"dp",
"i",
"1",
"a[i]-dp[i-1][0]",
"a[i]",
"a",
"i",
"dp[i-1][0]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"0",
"dp[i][2]=1",
"dp[i][2]",
"[i]",
"dp",
"i",
"2",
"1",
"elif dp[i-1][1]==a[i]-dp[i-1][0]:\n dp[i][1]=dp[i-1][1]\n dp[i][2]=dp[i-1][2]+1\n ",
"dp[i-1][1]==a[i]-dp[i-1][0]",
"dp[i-1][1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"1",
"a[i]-dp[i-1][0]",
"a[i]",
"a",
"i",
"dp[i-1][0]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"0",
"dp[i][1]=dp[i-1][1]",
"dp[i][1]",
"[i]",
"dp",
"i",
"1",
"dp[i-1][1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"1",
"dp[i][2]=dp[i-1][2]+1",
"dp[i][2]",
"[i]",
"dp",
"i",
"2",
"dp[i-1][2]+1",
"dp[i-1][2]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"2",
"1",
"dp[i][1]=dp[i-1][1]",
"dp[i][1]",
"[i]",
"dp",
"i",
"1",
"dp[i-1][1]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"1",
"dp[i][2]=dp[i-1][2]",
"dp[i][2]",
"[i]",
"dp",
"i",
"2",
"dp[i-1][2]",
"[i-1]",
"dp",
"i-1",
"i",
"1",
"2",
"print(dp[-1][2])",
"print",
"dp[-1][2]",
"[-1]",
"dp",
"-1",
"2",
"dp=[[float('inf'),0,0] for i in range(n)]",
"[[float('inf'),0,0] for i in range(n)]",
"dp",
"n,t= map(int, input().split())",
"map(int, input().split())",
"n",
"a= list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"t= map(int, input().split())",
"map(int, input().split())",
"t"
] |
n,t= map(int, input().split())
a= list(map(int, input().split()))
# dp[i][0]:０からiまでの区間に置けるMIN
# dp[i][1]:その区間での左から右への差の最大値
# dp[i][2]:最大値をとるものがいくつあるか
dp=[[float('inf'),0,0] for i in range(n)]
for i in range(n):
if i==0:
dp[i][0]=a[i]
else:
dp[i][0]=min(dp[i-1][0],a[i])
if dp[i-1][1]<a[i]-dp[i-1][0]:
dp[i][1]=a[i]-dp[i-1][0]
dp[i][2]=1
elif dp[i-1][1]==a[i]-dp[i-1][0]:
dp[i][1]=dp[i-1][1]
dp[i][2]=dp[i-1][2]+1
else:
dp[i][1]=dp[i-1][1]
dp[i][2]=dp[i-1][2]
print(dp[-1][2])
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.