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)}")
