class Solution: def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode: s = ListNode(0) s.next = head x = s z = s for i in range(n): x = x.next while x.next: x = x.next z = z.next z.next = z.next.next return s.next if __name__ == '__main__': solver = Solution() # test cases cases = [ ([1], 1), ([1, 2, 3, 4, 5], 1), ([1, 2, 3, 4, 5], 4), ([1, 2, 3, 4, 5], 2), ] cases = [(listToListNode(head), n) for head, n in cases] rslts = [solver.removeNthFromEnd(head, n) for head, n in cases] for cs, rs in zip(cases, rslts): print( f"case: {traverseListNode(cs[0])}, {cs[1]} | solution: {traverseListNode(rs)}" )
currK = currK.next if i % k == 0: prev, curr = currK, holdK for _ in range(k): curr.next, curr, prev = prev, curr.next, curr prevK.next, prevK, holdK = prev, holdK, currK i += 1 return s.next if __name__ == '__main__': solver = Solution() cases = [ ([], 2), ([1], 1), ([1], 2), ([4, 2], 1), ([4, 2], 2), ([1, 2, 3, 4], 1), ([1, 2, 3, 4], 2), ([1, 2, 3, 4], 3), ([1, 2, 3, 4, 5, 6, 7, 8], 1), ([1, 2, 3, 4, 5, 6, 7, 8], 2), ([1, 2, 3, 4, 5, 6, 7], 3), ] cases = [(listToListNode(x), k) for x, k in cases] rslts = [solver.reverseKGroup(l, k) for l, k in cases] for cs, rs in zip(cases, rslts): print( f"case: {traverseListNode(cs[0])} - {cs[1]} | solution: {traverseListNode(rs)}" )
for _ in range(k - 1): if r is not None: r = r.next if r is not None: h = r r = r.next h.next = None # merge and connect, so that l -> mergeSorted(x, y) -> r if y is not None and not x == y: l = self.merge(l, x, y, r) else: break k *= 2 return s.next if __name__ == '__main__': solver = Solution() cases = [ # [], [1], [1, 2], [3, 2], [4, 3, 1, 2], [-1, 5, 3, 4, 0], [5, -1, 4, 3, 0] ] cases = [listToListNode(x) for x in cases] rslts = [solver.sortList(head) for head in cases] for cs, rs in zip(cases, rslts): print(f"case: {cs.display()} | solution: {rs.display()}")
node = node.prev if k: node.prev = ListNode(k) node.prev.next = node node = node.prev # sentinel if node == s: node = None else: s.prev.next = None return node if __name__ == '__main__': solver = Solution() cases = [ ([], []), ([], [4]), ([], [1, 0]), ([5], [5]), ([5], [4, 2]), ([2], [9, 9, 8]), ([4, 2], [4, 7, 2, 3]), ([2, 4, 3], [5, 6, 4]), ] cases = [(listToListNode(x1), listToListNode(x2)) for x1, x2 in cases] rslts = [solver.addTwoNumbers(l1, l2) for (l1, l2) in cases] for cs, rs in zip(cases, rslts): print( f"case: {cs[0].display() if cs[0] else None} + {cs[1].display() if cs[1] else None} | solution: {rs.display() if rs else None}" )
# hold x, move z z = x # move z to b-next b += 1 while k < b: z = z.next k += 1 # connect a-prev -> list2 -> b-next x.next = y while y.next: y = y.next y.next = z return list1 if __name__ == '__main__': solver = Solution() cases = [ ([0, 1, 2, 3, 4, 5], 3, 4, [10, 11, 12, 13, 14]), ] cases = [(listToListNode(l1), a, b, listToListNode(l2)) for l1, a, b, l2 in cases] rslts = [ solver.mergeInBetween(list1, a, b, list2) for list1, a, b, list2 in cases ] for cs, rs in zip(cases, rslts): print( f"case: {cs[0].display()}, {cs[1]}, {cs[2]}, {cs[3].display()}\nsolution: {rs.display()}" )
node.right = self.simulateInorderTraversal(m + 1, r) return node def sortedListToBST(self, head: ListNode) -> TreeNode: """Algorithms: 1. Convert to sorted array + recursion: Time Complexity O(N), Space Complexity O(N). 2. Two pointer find middle + recursion: Time Complexity O(NlogN), Space Complexity O(logN). 3. Direct conversion via simulation of inorder travel: Time Complexity O(N), Space Complexity O(logN). """ if not head: return None size = self.getLength(head) self.head = head return self.simulateInorderTraversal(0, size) if __name__ == '__main__': solver = Solution() cases = [ [], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7, 8], ] cases = [(listToListNode(x)) for x in cases] rslts = [solver.sortedListToBST(head) for head in cases] for cs, rs in zip(cases, rslts): print(f"case: {cs.display()}, solution:\n{rs.display()}")
from config.listnode import ListNode, listToListNode class Solution: def middleNode(self, head: ListNode) -> ListNode: x, y = head, head while y: y = y.next if y: y = y.next x = x.next return x if __name__ == '__main__': solver = Solution() cases = [ [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7, 8], ] cases = [listToListNode(l) for l in cases] rslts = [solver.middleNode(head) for head in cases] for cs, rs in zip(cases, rslts): print( f"case: {cs.display() if cs else None} | solution: {rs.display() if rs else None}" )
from typing import List from config.listnode import ListNode, listToListNode class Solution: def numComponents(self, head: ListNode, G: List[int]) -> int: G = set(G) count, inside, node = 0, False, head while node: if node.val in G and not inside: count += 1 inside = True if node.val not in G and inside: inside = False node = node.next return count if __name__ == '__main__': solver = Solution() cases = [ ([0, 1, 2, 3, 4], [0, 3, 1, 4]), ] cases = [(listToListNode(l), G) for l, G in cases] rslts = [solver.numComponents(head, G) for (head, G) in cases] for cs, rs in zip(cases, rslts): print(f"case: {cs[0].display()} + {cs[1:]} | solution: {rs}")
class Solution: def removeElements(self, head: ListNode, val: int) -> ListNode: s = ListNode('') s.next = head prev, node = s, head while node: if node.val == val: # skip node, hold prev prev.next = node.next else: # move prev to forward prev = node node = node.next return s.next if __name__ == '__main__': solver = Solution() cases = [ ([], 0), ([1], 1), ([1, 1], 1), ([1, 4, 2], 4), ([1, 4, 2], 2), ] cases = [(listToListNode(l), val) for l, val in cases] rslts = [solver.removeElements(head, val) for head, val in cases] for cs, rs in zip(cases, rslts): print(f"case: {cs[0].display()} + {cs[1:]} | solution: {rs.display()}")
s = ListNode('') s.next = head prev, node = s, head while node: count = 0 while node and count < m: prev, node = node, node.next count += 1 hold = prev if count == m: count = 0 while node and count < n: prev, node = node, node.next count += 1 prev = hold # passthrough prev.next = node return s.next if __name__ == '__main__': solver = Solution() cases = [ ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, 3), ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, 4), ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 4, 2), ] cases = [(listToListNode(l), m, n) for l, m, n in cases] rslts = [solver.deleteNodes(head, m, n) for head, m, n in cases] for cs, rs in zip(cases, rslts): print(f"case: {cs[0].display()} + {cs[1:]} | solution: {rs.display()}")
q = g = ListNode('') z = head while z: if z.val < x: l.next = z l = l.next else: g.next = z g = g.next z = z.next l.next = q.next g.next = None return p.next if __name__ == '__main__': solver = Solution() cases = [ ([], 0), ([1], 0), ([1, 1], 1), ([1, 3, 2], 3), ([1, 3, 2], 2), ([1, 4, 3, 2, 5, 2], 3), ] cases = [(listToListNode(l), x) for l, x in cases] rslts = [solver.partition(l, x) for l, x in cases] for cs, rs in zip(cases, rslts): print( f"case: {traverseListNode(cs[0])} - {cs[1]} | solution: {traverseListNode(rs)}" )
zs.append(y.next) if x.left: q.append((x.left, zs + [head])) if x.right: q.append((x.right, zs + [head])) return False if __name__ == '__main__': solver = Solution() cases = [ ([4, 2, 8], [ 1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3 ]), ([1, 4, 2, 6], [ 1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3 ]), ([1, 4, 2, 6, 8], [ 1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1, 3 ]), ] cases = [(listToListNode(x), listToTreeNode(y)) for x, y in cases] rslts = [solver.isSubPath(head, root) for head, root in cases] for cs, rs in zip(cases, rslts): print( f"case:\n{cs[0].display() if cs[0] else None}\n{cs[1].display() if cs[1] else None}\nsolution: {rs}" )
for j in range(i): ans.append(d[j]) d[j].next = None for j in range(i, k): ans.append(None) else: q, r = i // k, i % k for j in range(k): if j < r: ans.append(d[q * j + j]) d[q * (j + 1) + (j + 1) - 1].next = None else: ans.append(d[q * j + r]) d[min(q * (j + 1) + r - 1, i - 1)].next = None return ans if __name__ == '__main__': solver = Solution() cases = [ ([1, 2, 3], 2), ([1, 2, 3], 3), ([1, 2, 3], 5), ] cases = [(listToListNode(l), k) for l, k in cases] rslts = [solver.splitListToParts(l, k) for (l, k) in cases] for cs, rs in zip(cases, rslts): print( f"case: {cs[0].display()} + {cs[1:]} | solution: {[rsi.display() if rsi else None for rsi in rs]}" )
# heapq.heappush(h, (lists[i].val, i)) # return s.next # class Solution: # def mergeKLists(self, lists: List[ListNode]) -> ListNode: # k = len(lists) # q = PriorityQueue() # for l in lists: # if l: # q.put((l.val, l)) # s = ListNode(0) # x = s # while q: # val, v = q.get() # if v.next: # q.put((v.next.val, v)) # x.next = v # x = x.next # return s.next if __name__ == '__main__': solver = Solution() cases = [ [[1, 4, 5], [1, 3, 4], [2, 6]], [[1, 4, 5], [1, 3, 4], [2, 6], [4]], [[1, 4, 5], [1, 3, 4], [2, 6], []], ] cases = [[listToListNode(y) for y in x] for x in cases] rslts = [solver.mergeKLists(lists) for lists in cases] for cs, rs in zip(cases, rslts): print(f"case: {cs} | solution: {traverseListNode(rs)}")