13: "d", 14: "e", 15: "f", } class Solution: def toHex(self, num: int) -> str: if num == 0: return "0" if num < 0: return self.toHex((((2**32) - 1) ^ (-num)) + 1) a, b = divmod(num, 16) if a == 0: return n10_to_n16[b] else: return self.toHex(a) + n10_to_n16[b] # @lc code=end from tool import t f = Solution().toHex t(f(0), "0") t(f(1), "1") t(f(9), "9") t(f(10), "a") t(f(26), "1a") t(f(-1), "ffffffff")
# # @lc code=start valid_numbers = set([str(i) for i in range(1, 27)]) class Solution: def numDecodings(self, s: str) -> int: # dp[i] 表示 s[i:] 能够表示为多少个单词 dp = [0] * (len(s) + 1) dp[len(s)] = 1 for i in range(len(s) - 1, -1, -1): if s[i] in valid_numbers: dp[i] += dp[i + 1] if i != len(s) - 1 and s[i:i + 2] in valid_numbers: dp[i] += dp[i + 2] return dp[0] # @lc code=end if __name__ == "__main__": from tool import t f = Solution().numDecodings t(f("12"), 2) t(f("226"), 3)
def is_safe(index: int) -> bool: if safe_map[index] is None: if not graph[index]: safe_map[index] = True else: safe_map[index] = False has_unsafe = False for next_index in graph[index]: if not is_safe(next_index): has_unsafe = True break if not has_unsafe: safe_map[index] = True return safe_map[index] result = [] for i in range(len(graph)): if is_safe(i): result.append(i) return result # @lc code=end if __name__ == "__main__": from tool import t f = Solution().eventualSafeNodes t(f([[1, 2], [2, 3], [5], [0], [5], [], []]), [2, 4, 5, 6]) t(f([[1, 2, 3, 4], [1, 2], [3, 4], [0, 4], []]), [4])
return s # def minSteps(self, n: int) -> int: # if n == 1: # return 0 # @lru_cache # def run(screen: int, pasted: int) -> int: # assert screen + pasted <= n # if screen + pasted == n: # return 1 # elif screen + pasted < n: # # Paste # case1 = 1 + run(screen + pasted, pasted) # # Copy and Paste # case2 = 2 + run(2 * screen, screen) # return min(case1, case2) # else: # return 1001 # return run(1, 1) + 1 # @lc code=end if __name__ == "__main__": from tool import t f = Solution().minSteps t(f(3), 3) t(f(4), 4)
while 0 <= i < m and 0 <= j < n: result.append(matrix[i][j]) i -= 1 j += 1 else: if line < n: i = 0 j = line else: j = n - 1 i = line - j assert i + j == line while 0 <= i < m and 0 <= j < n: result.append(matrix[i][j]) i += 1 j -= 1 return result return result # @lc code=end if __name__ == "__main__": from tool import t f = Solution().findDiagonalOrder t(f([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), [1, 2, 4, 7, 5, 3, 6, 8, 9]) t(f([[2, 3]]), [2, 3])
# # @lc code=start from typing import List class Solution: def minPathSum(self, grid: List[List[int]]) -> int: for i in range(len(grid)): for j in range(len(grid[0])): if i == 0 and j == 0: grid[0][0] = -grid[0][0] elif i == 0: grid[i][j] = grid[i][j - 1] - grid[i][j] elif j == 0: grid[i][j] = grid[i - 1][j] - grid[i][j] else: grid[i][j] = max(grid[i][j - 1], grid[i - 1][j]) - grid[i][j] # assert grid[i][j] <= 0, debug return -grid[len(grid) - 1][len(grid[0]) - 1] # @lc code=end if __name__ == "__main__": from tool import t f = Solution().minPathSum t(f([[1, 3, 1], [1, 5, 1], [4, 2, 1]]), 7) t(f([[1, 2, 3], [4, 5, 6]]), 12)
if k == 0: for i in range(len(nums) - 1): if nums[i] == nums[i + 1] == 0: return True return False else: # mods[x] = v 表示 sum(nums[0:x]) % k == v mods = {0: 0} # magic! mod = 0 for index, num in enumerate(nums): mod = (mod + num) % k if mod in mods: if index + 1 - mods[mod] >= 2: return True else: mods[mod] = index + 1 return False # @lc code=end if __name__ == "__main__": from tool import t f = Solution().checkSubarraySum t(f([23, 2, 4, 6, 7], 6), True) t(f([1, 1], 2), True) t(f([1, 0], 2), False)
def nthUglyNumber(self, n: int) -> int: if n == 0: return [] seq = [1] i2, i3, i5 = 0, 0, 0 while len(seq) < n: n2, n3, n5 = seq[i2] * 2, seq[i3] * 3, seq[i5] * 5 if n2 <= n3 and n2 <= n5: i2 += 1 if n2 > seq[-1]: seq.append(n2) if n3 <= n2 and n3 <= n5: i3 += 1 if n3 > seq[-1]: seq.append(n3) if n5 <= n2 and n5 <= n3: i5 += 1 if n5 > seq[-1]: seq.append(n5) return seq[-1] # @lc code=end if __name__ == "__main__": from tool import t f = Solution().nthUglyNumber t(f(10), 12)
class Solution: def countBits(self, num): if num == 0: return [0] result = [0] while True: loop_size = len(result) for i in range(loop_size): result.append(result[i] + 1) if len(result) > num: break if len(result) > num: break return result # @lc code=end if __name__ == "__main__": from tool import t f = Solution().countBits t(f(0), [0]) t(f(1), [0, 1]) t(f(2), [0, 1, 1]) t(f(3), [0, 1, 1, 2])
ps: List[tuple] = [] max_weight = 0 for point, weight in counter.items(): ps.append((point[0], point[1], weight)) max_weight = max(max_weight, weight) all_km: Dict[tuple, int] = {} while ps: x1, y1, w1 = ps.pop() curr_km: Dict[tuple, int] = defaultdict(int) for x2, y2, w2 in ps: k, m = cal_km(x1, y1, x2, y2) if (k, m) not in all_km: curr_km[(k, m)] += w2 assert len(curr_km.keys() & all_km.keys()) == 0 for km, point_num in curr_km.items(): all_km[(km)] = point_num + w1 return max(all_km.values()) if all_km else max_weight # @lc code=end if __name__ == "__main__": from tool import t f = Solution().maxPoints t(f([[1, 1], [2, 2], [3, 3]]), 3) t(f([[1, 1], [3, 2], [5, 3], [4, 1], [2, 3], [1, 4]]), 4) t(f([[0, 0]]), 1)
if value >= remainder: dp[choosable] = True return True else: next_choosable = choosable - (1 << i) assert 1 & (next_choosable >> i) == 0 if not can_i_win(next_choosable, remainder - value, dp): dp[choosable] = True return True dp[choosable] = False return False class Solution: def canIWin(self, maxChoosableInteger: int, desiredTotal: int) -> bool: if sum(list(range(1, maxChoosableInteger + 1))) < desiredTotal: return False return can_i_win((1 << (maxChoosableInteger)) - 1, desiredTotal, {}) # @lc code=end if __name__ == "__main__": f = Solution().canIWin from tool import t t(f(10, 11), False) t(f(10, 0), True) t(f(10, 1), True) t(f(19, 79), True) t(f(18, 79), True)
return True return False class Solution: def pyramidTransition(self, bottom: str, allowed: List[str]) -> bool: allowed_map: Dict[str, List[str]] = defaultdict(list) for a, b, c in allowed: allowed_map[a + b].append(c) return pyramid_transition(bottom, allowed_map) # @lc code=end if __name__ == "__main__": from tool import t t(list(iter_product([["A", "B"], ["C", "D", "E"]])), [ "AC", "AD", "AE", "BC", "BD", "BE", ]) t(list(iter_product([["A", "B"], ["C", "D", "E"], []])), []) f = Solution().pyramidTransition t(f("BCD", allowed=["BCG", "CDE", "GEA", "FFF"]), True) t(f("AABA", allowed=["AAA", "AAB", "ABA", "ABB", "BAC"]), False)
# What if the matrix is stored on disk, and the memory is limited such that you # can only load at most one row of the matrix into the memory at once? # What if the matrix is so large that you can only load up a partial row into # the memory at once? # # # from typing import List # @lc code=start class Solution: def isToeplitzMatrix(self, matrix: List[List[int]]) -> bool: for i in range(len(matrix) - 1): r1 = matrix[i] r2 = matrix[i + 1] for j in range(len(r1) - 1): if r1[j] != r2[j + 1]: return False return True # @lc code=end if __name__ == "__main__": from tool import t f = Solution().isToeplitzMatrix t(f([[1, 2, 3, 4], [5, 1, 2, 3], [9, 5, 1, 2]]), True) t(f([[1, 2], [2, 2]]), False)
return [] # int(S[0:i]) + int(S[i:j]) = int(S[j:k]) for i in range(1, len(s)): n1 = int(s[0:i]) if str(n1) != s[0:i] or n1 > MAX: continue for j in range(i + 1, len(s) - 1): n2 = int(s[i:j]) if str(n2) != s[i:j] or n2 > MAX: continue fib = is_fibonacci(n1, n2, s[j:]) if fib and all(f <= MAX for f in fib): return [n1, n2, *fib] return [] # @lc code=end if __name__ == "__main__": from tool import t f = Solution().splitIntoFibonacci t(f("123456579"), [123, 456, 579]) t(f("11235813"), [1, 1, 2, 3, 5, 8, 13]) t(f("112358130"), []) t(f("0123"), []) # t(f("1101111"), [110, 1, 111]) t(f("1101111"), [11, 0, 11, 11])
# @lc code=start from typing import List class Solution: def find132pattern(self, nums: List[int]) -> bool: smallest = float('inf') stack = [] for i in nums: while stack and i >= stack[-1][-1]: stack.pop() if stack and i > stack[-1][0]: return True stack.append((smallest,i)) smallest = min(smallest,i) return False # @lc code=end if __name__ == "__main__": f = Solution().find132pattern from tool import t # t(f([1, 2, 3, 4]), False) # t(f([3, 1, 4, 2]), True) # t(f([-1, 3, 2, 0]), True) # t(f([1, 3, 2, 4, 5, 6, 7, 8, 9, 10]), True) # t(f([-2, 1, 1, -2, 1, 2]), False) t(f([10, 12, 6, 8, 3, 11]), True)
# Your Twitter object will be instantiated and called as such: # obj = Twitter() # obj.postTweet(user_id,tweet_id) # param_2 = obj.getNewsFeed(user_id) # obj.follow(follower_id,followee_id) # obj.unfollow(follower_id,followee_id) # @lc code=end if __name__ == "__main__": from tool import t if True: twitter = Twitter() twitter.postTweet(1, 5) t(twitter.getNewsFeed(1), [5]) twitter.follow(1, 2) twitter.postTweet(2, 6) t(twitter.getNewsFeed(1), [6, 5]) twitter.unfollow(1, 2) t(twitter.getNewsFeed(1), [5]) if True: twitter = Twitter() twitter.postTweet(1, 5) twitter.postTweet(1, 3) t(twitter.getNewsFeed(1), [3, 5])
def _get_area(self, row, col): if row < 0 or col < 0: return 0 else: return self.matrix[row][col] def sumRegion(self, row1: int, col1: int, row2: int, col2: int) -> int: return ( self._get_area(row2, col2) - self._get_area(row1 - 1, col2) - self._get_area(row2, col1 - 1) + self._get_area(row1 - 1, col1 - 1) ) # Your NumMatrix object will be instantiated and called as such: # obj = NumMatrix(matrix) # param_1 = obj.sumRegion(row1,col1,row2,col2) # @lc code=end if __name__ == "__main__": from tool import t matrix = [[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]] f = NumMatrix(matrix) t(f.sumRegion(2, 1, 4, 3), 8) t(f.sumRegion(1, 1, 2, 2), 11) t(f.sumRegion(1, 2, 2, 4), 12)
def findMedianSortedArrays_v2(nums1: List[int], nums2: List[int]) -> float: pass class Solution: def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float: return findMedianSortedArrays_v2(nums1, nums2) # @lc code=end if __name__ == "__main__": from tool import t f = Solution().findMedianSortedArrays import ipdb # ipdb.set_trace() for i in range(10): # There is some random operations t(f([1, 3], [2]), 2) t(f([1, 2], [3, 4]), 2.5) t(f([0, 0], [0, 0]), 0) t(f([], [1]), 1) t(f([2], []), 2) t(f([1, 3], [2, 7]), 2.5) t(f([1, 2], [1, 2]), 1.5)
res = 0 max_len = 0 for i in range(len(values)): l[i] = 1 for j in range(0, i): if values[j] < values[i]: l[i] = max(l[i], l[j] + 1) max_len = max(max_len, l[i]) for i in range(len(values)): if l[i] == 1: c[i] = 1 else: c[i] = 0 for j in range(0, i): if values[j] < values[i] and l[j] == l[i] - 1: c[i] += c[j] if l[i] == max_len: res += c[i] return res # @lc code=end if __name__ == "__main__": from tool import t f = Solution().findNumberOfLIS t(f([1, 3, 5, 4, 7]), 2) t(f([2, 2, 2, 2, 2]), 5)
result = self.grayCode(n - 1) length = len(result) for i in range(length - 1, -1, -1): result.append((1 << (n - 1)) + result[i]) return result # @lc code=end if __name__ == "__main__": from tool import t f = Solution().grayCode # fmt:off t(f(2), [int(i, 2) for i in [ "00", "01", "11", "10", ]]) t(f(3), [ int(i, 2) for i in [ '000', '001', '011', '010', '110', '111', '101', '100', ] ])
passed = {deadend: -1 for deadend in deadends} q = Queue() q.put(("0000", 0)) while not q.empty(): key, steps = q.get() if key in passed: continue if key == target: return steps passed[key] = steps for next_key in get_next_keys(key): if next_key not in passed: q.put((next_key, steps + 1)) return -1 # @lc code=end if __name__ == "__main__": from tool import t f = Solution().openLock t(f(["8888"], "0009"), 1) t(f(["8888"], "0008"), 2) t( f(["8887", "8889", "8878", "8898", "8788", "8988", "7888", "9888"], "8888"), -1)