#!/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)