#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
from typing import List
from leetcode import aatest_helper
class Solution:
def findContentChildren(self, g: List[int], s: List[int]) -> int:
g.sort()
s.sort()
i, j, n, m = 0, 0, len(g), len(s)
res = 0
while i < n and j < m:
if s[j] >= g[i]:
i += 1
j += 1
res += 1
else:
j += 1
return res
cases = [([1, 2, 3], [1, 1], 1), ([1, 2], [1, 2, 3], 2),
([10, 9, 8, 7], [5, 6, 7, 8], 2)]
sol = Solution()
aatest_helper.run_test_cases(sol.findContentChildren, cases)
def test():
cases = [([1, 2, 3], 6), ([3, 7, 4, 5], 144), ([1, 3, 1, 4, 1, 5], 13)]
sol = Solution()
fn = sol.minScoreTriangulation
run_test_cases(fn, cases)
s, e, res = 0, max_radius, max_radius
while s <= e:
m = (s + e) // 2
if ok_to_cover(m):
res = min(res, m)
e = m - 1
else:
s = m + 1
return res
cases = [
([
282475249, 622650073, 984943658, 144108930, 470211272, 101027544,
457850878, 458777923
], [
823564440, 115438165, 784484492, 74243042, 114807987, 137522503,
441282327, 16531729, 823378840, 143542612
], 161834419),
([1, 5], [2], 3),
([1, 2, 3], [2], 1),
([1, 2, 3, 4], [1, 4], 1),
([1, 5], [10], 9),
([1], [1, 2, 3, 4], 0),
([1, 2, 3, 5, 15], [2, 30], 13),
]
sol = Solution()
fn = sol.findRadius
run_test_cases(fn, cases)
value = (a, b, c)
ans.append(value)
j += 1
k -= 1
while j < k and nums[j] == nums[j - 1]:
j += 1
while j < k and nums[k] == nums[k + 1]:
k -= 1
elif value > target:
k -= 1
while j < k and nums[k] == nums[k + 1]:
k -= 1
else:
j += 1
while j < k and nums[j] == nums[j - 1]:
j += 1
return ans
cases = [([-1, 0, 1, 2, -1, -4], [(-1, -1, 2), (-1, 0, 1)]),
([-4, -2, -2, -2, 0, 1, 2, 2, 2, 3, 3, 4, 4, 6, 6], [(-4, -2, 6),
(-4, 0, 4),
(-4, 1, 3),
(-4, 2, 2),
(-2, -2, 4),
(-2, 0, 2)]),
([0] * 512, [(0, 0, 0)])]
sol = Solution()
aatest_helper.run_test_cases(sol.threeSum, cases)
src_idxs = set([i for i in range(n) if S in my_routes[i]])
dst_idxs = set([i for i in range(n) if T in my_routes[i]])
# 如果存在交集的话，那么不用任何换乘
if src_idxs & dst_idxs:
return 1
sts = [(i, j) for i in src_idxs for j in dst_idxs]
res = (n + 1)
for s, t in sts:
val = shortest_path(s, t)
if val != -1:
res = min(res, val)
if res == (n + 1):
return -1
return res + 1
cases = [
([[1, 2, 7], [3, 6, 7]], 1, 6, 2),
([[1, 2, 3], [3, 4, 5], [4, 5, 6]], 1, 6, 3),
([[1, 2, 3], [3, 4, 5], [4, 5, 6], [2, 3, 6]], 1, 6, 2),
([[1, 2, 3]], 1, 4, -1),
([[1, 7], [3, 5]], 5, 5, 0),
# aatest_helper.read_case_from_file('/Users/dirlt/playbook/input.in', 1),
]
sol = Solution()
aatest_helper.run_test_cases(sol.numBusesToDestination, cases)
res[p]['emails'].append(email)
ans = []
for v in res.values():
name = v['name']
emails = v['emails']
emails.sort()
ans.append([name] + emails)
return ans
cases = [([["John", "*****@*****.**", "*****@*****.**"],
["John", "*****@*****.**"],
["John", "*****@*****.**", "*****@*****.**"],
["Mary", "*****@*****.**"]], [[
"John", '*****@*****.**', '*****@*****.**',
'*****@*****.**'
], ["John", "*****@*****.**"], ["Mary", "*****@*****.**"]]),
([["Alex", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["Ethan", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["Kevin", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["Gabe", "*****@*****.**", "*****@*****.**", "*****@*****.**"],
["Gabe", "*****@*****.**", "*****@*****.**", "*****@*****.**"]],
[['Alex', '*****@*****.**', '*****@*****.**', '*****@*****.**'],
['Ethan', '*****@*****.**', '*****@*****.**'],
['Kevin', '*****@*****.**', '*****@*****.**'],
['Gabe', '*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**']])]
sol = Solution()
aatest_helper.run_test_cases(sol.accountsMerge, cases)
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
from leetcode import aatest_helper
class Solution(object):
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
prev = None
k = 0
for v in nums:
if v == prev:
continue
nums[k] = v
k += 1
prev = v
return k
cases = [
([1, 1, 2], 2),
([0, 0, 1, 1, 1, 2, 2, 3, 3, 4], 5),
]
sol = Solution()
aatest_helper.run_test_cases(sol.removeDuplicates, cases)
def minAreaRect(self, points: List[List[int]]) -> int:
xindex = defaultdict(set)
for (x, y) in points:
xindex[x].add(y)
xs = list(xindex.keys())
xs.sort()
init_ans = 1 << 30
ans = init_ans
for i in range(len(xs)):
ys0 = xindex[xs[i]]
for j in range(i + 1, len(xs)):
spx = xs[j] - xs[i]
ys1 = xindex[xs[j]]
ys = list(ys0 & ys1)
ys.sort()
for u in range(len(ys)):
for v in range(u + 1, len(ys)):
spy = ys[v] - ys[u]
area = spy * spx
ans = min(ans, area)
if ans == init_ans:
ans = 0
return ans
cases = [([[1, 1], [1, 3], [3, 1], [3, 3], [2, 2]], 4),
([[1, 1], [1, 3], [3, 1], [3, 3], [4, 1], [4, 3]], 2)]
sol = Solution()
aatest_helper.run_test_cases(sol.minAreaRect, cases)
def commonChars(self, A: List[str]) -> List[str]:
def make_dist(s):
v = [0] * 26
for c in s:
v[ord(c) - ord('a')] += 1
return v
n = len(A)
if n == 0:
return []
inf = 500
res = [inf] * 26
for i in range(n):
tmp = make_dist(A[i])
for j in range(26):
res[j] = min(res[j], tmp[j])
ans = []
for i in range(26):
if res[i] and res[i] != inf:
ans.extend([chr(i + ord('a'))] * res[i])
return ans
cases = [(["bella", "label", "roller"], ["e", "l", "l"]),
(["cool", "lock", "cook"], ["c", "o"])]
sol = Solution()
aatest_helper.run_test_cases(sol.commonChars, cases)
:rtype: List[List[int]]
"""
nums.sort()
ans = []
n = len(nums)
# O(n^3)
for i in range(0, n):
for j in range(i + 1, n):
k, l = j + 1, n - 1
while k < l:
value = nums[i] + nums[j] + nums[k] + nums[l]
if value == target:
t = (nums[i], nums[j], nums[k], nums[l])
ans.append(t)
k += 1
elif value > target:
l -= 1
else:
k += 1
ans = [list(x) for x in set(ans)]
return ans
cases = [([1, 0, -1, 0, -2, 2], 0, [[-2, -1, 1, 2], [-2, 0, 0, 2],
[-1, 0, 0, 1]])]
sol = Solution()
aatest_helper.run_test_cases(sol.fourSum, cases)
def find_lower_bound():
dc = DistinctCounter()
bound = [-1] * n
offset = -1
for i in range(n):
if i != 0:
dc.remove(A[i - 1])
found, offset = walk_until_first_k(dc, offset, K)
if found:
bound[i] = offset
# dc.remove(A[offset])
return bound
low_bound = find_lower_bound()
up_bound = find_upper_bound()
ans = 0
for i in range(n):
if up_bound[i] != -1 and low_bound[i] != -1:
ans += (up_bound[i] - low_bound[i] + 1)
return ans
cases = [
([1, 2, 1, 2, 3], 2, 7),
([1, 2, 1, 3, 4], 3, 3),
([1, 2], 1, 2),
# aatest_helper.read_case_from_file('/Users/dirlt/playbook/input.in.com', 9944),
]
sol = Solution()
aatest_helper.run_test_cases(sol.subarraysWithKDistinct, cases)
self.right = None
class Solution:
def rangeSumBST(self, root: TreeNode, L: int, R: int) -> int:
def fn(root):
if root is None:
return 0
ans = 0
if root.val < L:
ans += fn(root.right)
elif root.val > R:
ans += fn(root.left)
else:
ans += root.val
ans += fn(root.right)
ans += fn(root.left)
return ans
ans = fn(root)
return ans
null = None
cases = [(aatest_helper.list_to_tree([10, 5, 15, 3, 7, null, 18]), 7, 15, 32),
(aatest_helper.list_to_tree([10, 5, 15, 3, 7, 13, 18, 1, null,
6]), 6, 10, 23)]
sol = Solution()
aatest_helper.run_test_cases(sol.rangeSumBST, cases)
def updateMatrix(self, matrix):
# write your code here
n = len(matrix)
m = len(matrix[0])
dist = [[-1] * m for _ in range(n)]
queue = Queue()
for r in range(n):
for c in range(m):
if matrix[r][c] == 0:
dist[r][c] = 0
queue.put((r, c, 0))
while not queue.empty():
(x, y, d) = queue.get()
for dx, dy in ((0, 1), (0, -1), (1, 0), (-1, 0)):
x2 = x + dx
y2 = y + dy
if 0 <= x2 < n and 0 <= y2 < m and matrix[x2][y2] == 1:
if dist[x2][y2] == -1:
dist[x2][y2] = (d + 1)
queue.put((x2, y2, d + 1))
return dist
cases = [([[0, 0, 0], [0, 1, 0], [1, 1, 1]], [[0, 0, 0], [0, 1, 0], [1, 2,
1]])]
sol = Solution()
aatest_helper.run_test_cases(sol.updateMatrix, cases)
# coding:utf-8
# Copyright (C) dirlt
from typing import List
from leetcode import aatest_helper
class Solution:
def prefixesDivBy5(self, A: List[int]) -> List[bool]:
res = []
rem = 0
for x in A:
rem = (rem << 1) + x
rem = rem % 5
res.append(rem == 0)
return res
sol = Solution()
true = True
false = False
cases = [
([0, 1, 1], [true, false, false]),
([1, 1, 1], [false, false, false]),
([0, 1, 1, 1, 1, 1], [true, false, false, false, true, false]),
([1, 1, 1, 0, 1], [false, false, false, false, false]),
]
aatest_helper.run_test_cases(sol.prefixesDivBy5, cases)
[907, 52], [976, 114], [694, 924], [23, 358], [776, 866], [322, 744],
[35, 708], [359, 339], [661, 433], [995, 697], [760, 154], [348, 446],
[559, 319], [509, 631], [339, 441], [414, 705], [52, 939], [725, 319],
[568, 235], [269, 143], [744, 505], [859, 305], [233, 746], [637, 269],
[353, 249], [348, 275], [860, 501], [772, 492], [839, 747], [10, 351],
[205, 350], [784, 245], [800, 199], [655, 343], [570, 307], [492, 842],
[486, 795], [58, 887], [852, 408], [36, 626], [849, 134], [651, 268],
[922, 592], [90, 333], [429, 503], [392, 579], [4, 593], [908, 203],
[955, 346], [628, 749], [943, 910], [545, 784], [370, 946], [43, 614],
[759, 816], [656, 508], [980, 375], [58, 863], [220, 612], [856, 290],
[980, 302], [492, 408], [802, 875], [998, 867], [87, 571], [884, 318],
[33, 632], [626, 343], [62, 957], [647, 701], [588, 616], [371, 697],
[562, 118], [52, 51], [521, 510], [242, 992], [663, 113], [490, 371],
[77, 114], [418, 39], [998, 83], [926, 390], [810, 326], [437, 589],
[69, 288], [38, 36], [409, 665], [192, 467], [754, 367], [110, 273],
[223, 55], [39, 401], [108, 260], [556, 173], [937, 764], [548, 773],
[576, 576], [292, 430], [912, 245], [104, 729], [565, 43], [637, 645],
[118, 438], [149, 453], [58, 39], [171, 356], [87, 298], [10, 663],
[673, 138], [798, 572], [986, 395], [43, 37], [841, 367], [357, 474],
[414, 315], [444, 302], [165, 120], [841, 417], [840, 993], [706, 315],
[63, 520], [339, 390], [942, 877], [406, 593], [606, 202], [492, 58],
[130, 644], [452, 534], [810, 792], [843, 705], [900, 642], [194, 302],
[222, 415], [654, 793], [253, 966], [206, 997], [702, 730], [948, 861],
[444, 788], [809, 457], [400, 646], [321, 64], [598, 627], [302, 222],
[465, 455], [681, 994], [824, 975], [277, 310], [268, 121], [498, 622],
[800, 657], [90, 715], [804, 34], [106, 3], [711, 960], [810, 16],
[703, 499], [972, 271], [762, 992]], 40),
]
sol = Solution()
aatest_helper.run_test_cases(sol.maxEnvelopes, cases)
return 0
n, m = amount + 1, len(coins)
dp = []
for i in range(n):
dp.append([0] * m)
for i in range(m):
dp[0][i] = 1
for v in range(1, n):
for c in range(m):
res = 0
if (v - coins[c]) >= 0:
res += dp[v - coins[c]][c]
if c >= 0:
res += dp[v][c - 1]
dp[v][c] = res
return dp[n - 1][m - 1]
sol = Solution()
cases = [
(5, [1, 2, 5, ], 4),
(3, [2], 0),
(10, [10], 1)
]
aatest_helper.run_test_cases(sol.change, cases)
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
from collections import Counter
from typing import List
from leetcode import aatest_helper
class Solution:
def subarraysDivByK(self, A: List[int], K: int) -> int:
rems = Counter()
res, acc = 0, 0
rems[0] = 1
for v in A:
acc = (acc + v) % K
res += rems[acc]
rems[acc] += 1
return res
cases = [([4, 5, 0, -2, -3, 1], 5, 7), ([5, 0], 5, 3), ([4, 5, 0], 5, 3)]
sol = Solution()
aatest_helper.run_test_cases(sol.subarraysDivByK, cases)
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
from leetcode import aatest_helper
class Solution:
def minAddToMakeValid(self, S: str) -> int:
res, depth = 0, 0
for c in S:
if c == '(':
depth += 1
continue
if depth <= 0:
res += 1
else:
depth -= 1
res += depth
return res
cases = [("())", 1), ("(((", 3), ("()", 0), ("()))((", 4)]
sol = Solution()
aatest_helper.run_test_cases(sol.minAddToMakeValid, cases)
c = S[i]
if c in pos:
most_right[i] = pos[c]
else:
pos[c] = i
# print(most_right)
def find_part(p):
s, e = p, p
while s < n and s <= e:
r = most_right[s]
if r == -1:
r = s
s += 1
e = max(e, r)
return e
p, res = 0, []
while p < n:
end = find_part(p)
res.append((end - p) + 1)
p = end + 1
return res
sol = Solution()
cases = [("ababcbacadefegdehijhklij", [9, 7, 8]), ("abcde", [1, 1, 1, 1, 1])]
aatest_helper.run_test_cases(sol.partitionLabels, cases)