def test_solution(self):
self.assertEqual(
False,
Solution().isPalindrome(common.create_linked_list([1, 2])))
self.assertEqual(
True,
Solution().isPalindrome(common.create_linked_list([1, 2, 2, 1])))
def test_solution(self):
self.assertEqual(
[1, 3, 5, 2, 4],
common.convert_linked_list_to_list(
Solution().oddEvenList(common.create_linked_list([1, 2, 3, 4, 5]))))
self.assertEqual(
[2, 3, 6, 7, 1, 5, 4],
common.convert_linked_list_to_list(
Solution().oddEvenList(common.create_linked_list([2, 1, 3, 5, 6, 4, 7]))))
def test_solution(self):
self.assertEqual([1, 2, 3, 4],
common.convert_linked_list_to_list(
Solution().insertionSortList(
common.create_linked_list([4, 2, 1, 3]))))
self.assertEqual([-1, 0, 3, 4, 5],
common.convert_linked_list_to_list(
Solution().insertionSortList(
common.create_linked_list([-1, 5, 3, 4, 0]))))
def test_solution(self):
self.assertEqual([1, 2],
common.convert_linked_list_to_list(
Solution().deleteDuplicates(
common.create_linked_list([1, 1, 2]))))
self.assertEqual([1, 2, 3],
common.convert_linked_list_to_list(
Solution().deleteDuplicates(
common.create_linked_list([1, 1, 2, 3, 3]))))
def test_solution(self):
l = common.create_linked_list([1, 2, 3, 4])
end_node = common.get_linked_list_node(l, 3)
end_node.next = common.get_linked_list_node(l, 1)
self.assertEqual(True, Solution().hasCycle(l))
l = common.create_linked_list([1, 2])
end_node = common.get_linked_list_node(l, 1)
end_node.next = common.get_linked_list_node(l, 0)
self.assertEqual(True, Solution().hasCycle(l))
self.assertEqual(False,
Solution().hasCycle(common.create_linked_list([1])))
def test_solution(self):
l = common.create_linked_list([1, 2, 3, 4])
Solution().reorderList(l)
self.assertEqual([1, 4, 2, 3], common.convert_linked_list_to_list(l))
l = common.create_linked_list([1, 2, 3, 4, 5])
Solution().reorderList(l)
self.assertEqual([1, 5, 2, 4, 3],
common.convert_linked_list_to_list(l))
l = common.create_linked_list([])
Solution().reorderList(l)
self.assertEqual([], common.convert_linked_list_to_list(l))
def test_solution(self):
self.assertEqual(
[2, 1, 4, 3, 5],
common.convert_linked_list_to_list(Solution().reverseKGroup(
common.create_linked_list([1, 2, 3, 4, 5]), 2)))
self.assertEqual(
[3, 2, 1, 4, 5],
common.convert_linked_list_to_list(Solution().reverseKGroup(
common.create_linked_list([1, 2, 3, 4, 5]), 3)))
self.assertEqual([2, 1],
common.convert_linked_list_to_list(
Solution().reverseKGroup(
common.create_linked_list([1, 2]), 2)))
def test_solution(self):
self.assertEqual(
[4, 5, 1, 2, 3],
common.convert_linked_list_to_list(Solution().rotateRight(
common.create_linked_list([1, 2, 3, 4, 5]), 2)))
self.assertEqual([2, 0, 1],
common.convert_linked_list_to_list(
Solution().rotateRight(
common.create_linked_list([0, 1, 2]), 4)))
self.assertEqual([1],
common.convert_linked_list_to_list(
Solution().rotateRight(
common.create_linked_list([1]), 1)))
def test_solution(self):
l = common.create_linked_list([4, 5, 1, 9])
Solution().deleteNode(common.get_linked_list_node(l, 1))
self.assertEqual(
[4, 1, 9],
common.convert_linked_list_to_list(l)
)
l = common.create_linked_list([4, 5, 1, 9])
Solution().deleteNode(common.get_linked_list_node(l, 2))
self.assertEqual(
[4, 5, 9],
common.convert_linked_list_to_list(l)
)
def test_solution(self):
lists = [
common.create_linked_list([1, 4, 5]),
common.create_linked_list([1, 3, 4]),
common.create_linked_list([2, 6]),
]
self.assertEqual([1, 1, 2, 3, 4, 4, 5, 6],
common.convert_linked_list_to_list(
Solution().mergeKLists(lists)))
lists = [
common.create_linked_list([]),
common.create_linked_list([1]),
]
self.assertEqual([1],
common.convert_linked_list_to_list(
Solution().mergeKLists(lists)))
def test_solution(self):
l = common.create_linked_list([1, 2, 3, 4])
end_node = common.get_linked_list_node(l, 3)
end_node.next = common.get_linked_list_node(l, 1)
self.assertEqual(common.get_linked_list_node(l, 1),
Solution().detectCycle(l))
l = common.create_linked_list([1, 2])
end_node = common.get_linked_list_node(l, 1)
end_node.next = common.get_linked_list_node(l, 0)
self.assertEqual(common.get_linked_list_node(l, 0),
Solution().detectCycle(l))
self.assertEqual(
None,
Solution().detectCycle(common.create_linked_list([1])))
def test_solution(self):
self.assertEqual(
[1, 2, 3, 4, 5],
common.convert_linked_list_to_list(
Solution().removeElements(common.create_linked_list([1, 2, 6, 3, 4, 5, 6]), 6)))
if fast_runner == slow_runner:
break
if fast_runner is None or fast_runner.next is None:
return None
slow_runner = first_node
while fast_runner is not slow_runner:
fast_runner = fast_runner.next
slow_runner = slow_runner.next
return fast_runner
def print_result(loop_node: LinkedListNode):
is_looped = loop_node is not None
print(f'IS looped (id {loop_node.id})' if is_looped else 'Is NOT looped')
if __name__ == '__main__':
looped_list = create_linked_list(20)
get_linked_list_last_node(
looped_list).next = looped_list.next.next.next.next.next.next.next
non_looped_list = create_linked_list(20)
print()
print_result(check_is_looped_list1(looped_list))
print_result(check_is_looped_list1(non_looped_list))
print()
print_result(check_is_looped_list2(looped_list))
print_result(check_is_looped_list2(non_looped_list))
print()
def test_solution(self):
self.assertEqual([1, 1, 2, 3, 4, 4],
common.convert_linked_list_to_list(
Solution().mergeTwoLists(
common.create_linked_list([1, 2, 4]),
common.create_linked_list([1, 3, 4]))))
def test_solution(self):
self.assertEqual(
[1, 2, 2, 4, 3, 5],
common.convert_linked_list_to_list(Solution().partition(
common.create_linked_list([1, 4, 3, 2, 5, 2]), 3)))
while first.next is not None:
first_length += 1
first = first.next
second_length = 1
while second.next is not None:
second_length += 1
second = second.next
return first == second, first_length, second_length
def get_intersecting_message(node: LinkedListNode) -> str:
return 'not intersecting' if node is None else f'intersecting (id {str(node.id)})'
if __name__ == '__main__':
first_non_intersecting = create_linked_list(10)
second_non_intersecting = create_linked_list(13)
first_intersecting = create_linked_list(20)
second_intersecting = create_linked_list(10)
intersecting_node = first_intersecting.next.next.next.next.next.next.next.next.next.next.next.next.next
intersecting_node.next = second_intersecting.next.next.next
candidate = check_node_intersection1(first_non_intersecting,
second_non_intersecting)
print('Expect non-intersection, and is: ' +
get_intersecting_message(candidate))
print()
candidate = check_node_intersection1(first_intersecting,
second_intersecting)
print('Expect intersection, and is: ' +
from models.linked_list_node import LinkedListNode
def partition_linked_list(current_node: LinkedListNode, partition: int):
if current_node.next is not None:
(connect_node, last_node) = partition_linked_list(current_node.next, partition)
else:
return (current_node, current_node)
if current_node.value >= partition and current_node.next is not None:
last_node.next = current_node
current_node.next = None
return (connect_node, current_node)
else:
current_node.next = connect_node
return (current_node, last_node)
if __name__ == '__main__':
node_count = 20
first_node = create_linked_list(node_count)
print_linked_list('Initial list 1:', first_node)
print()
partition = int(input('Partition value: '))
(first_node, _) = partition_linked_list(first_node, partition)
print_linked_list('After partitioning:', first_node)
print()
def test_solution(self):
self.assertEqual(
[1, 4, 3, 2, 5],
common.convert_linked_list_to_list(
Solution().reverseBetween(common.create_linked_list([1, 2, 3, 4, 5]), 2, 4)))
def test_solution(self):
self.assertEqual(
[5, 4, 3, 2, 1],
common.convert_linked_list_to_list(
Solution().reverseList(common.create_linked_list([1, 2, 3, 4, 5])))
)
def test_solution(self):
n1 = common.create_linked_list([2, 4, 3])
n2 = common.create_linked_list([5, 6, 4])
n3 = Solution().addTwoNumbers(n1, n2)
self.assertEqual([7, 0, 8], common.convert_linked_list_to_list(n3))
def test_solution(self):
self.assertEqual(
[1, 2, 3, 5],
common.convert_linked_list_to_list(Solution().removeNthFromEnd(
common.create_linked_list([1, 2, 3, 4, 5]), 2)))
def test_solution(self):
self.assertEqual(
[0, -3, 9, -10, None, 5],
common.convert_binary_tree_to_list(Solution().sortedListToBST(
common.create_linked_list([-10, -3, 0, 5, 9]))))
result = node
return (result, carryover)
def pad_linked_list_from_left(head: LinkedListNode, count: int, value: int):
node = None
for i in range(count):
node = LinkedListNode(head.id - 1, value)
node.next = head
head = node
return node
if __name__ == '__main__':
first_number = create_linked_list(3)
print_linked_list('First number reverse:', first_number)
second_number = create_linked_list(3)
print_linked_list('Second number reverse:', second_number)
print()
sum = linked_list_to_number_reverse_order(first_number) + linked_list_to_number_reverse_order(second_number)
print(f'Sum (reverse): {sum}')
print_linked_list('Sum list (reverse):', number_to_linked_list_reverse_order(sum))
print()
first_number = create_linked_list(3)
print_linked_list('First number forward:', first_number)
second_number = create_linked_list(3)
print_linked_list('Second number forward:', second_number)
