def test_example_2(self):
l1 = ListNode()
l2 = ListNode()
expected = ListNode(0)
self.assert_linked_lists_equal( expected, Solution.add_two_numbers( l1, l2 ) )
def test_addTwoNumbers_withTwoDigits_shouldReturnTreeDigitResult(self):
l1 = ListNode(9)
l1.next = ListNode(8)
l2 = ListNode(7)
l2.next = ListNode(6)
self.assertEqual([6, 5, 1], Solution().addTwoNumbers(l1, l2).toArray())
def test_addTwoNumbers_withTwoDigits_shouldReturnTwoDigitResult(self):
l1 = ListNode(1)
l1.next = ListNode(2)
l2 = ListNode(2)
l2.next = ListNode(4)
self.assertEqual([3, 6], Solution().addTwoNumbers(l1, l2).toArray())
def create_linked_list(l): root = ListNode(0) start = ListNode(l[0]) root.next = start for el in l[1:]: start.next = ListNode(el) start = start.next return root.next
def test_removeNthFromEnd(self):
s = Solution()
l1 = ListNode([1, 2, 3, 4, 5])
result = s.removeNthFromEnd(l1, 2)
expected = ListNode([1, 2, 3, 5])
self.assertEqual(result, expected)
def test_solution_2():
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(2)
head.next.next.next = ListNode(3)
new_head = Solution().deleteDuplicates(head)
assert new_head.val == 1
assert new_head.next.val == 3
def test_solution():
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
res = Solution().reverseList(head)
assert res.val == 3
assert res.next.val == 2
assert res.next.next.val == 1
def test_solution_2():
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
res = SolutionRecursive().reverse_list(head)
assert res.val == 3
assert res.next.val == 2
assert res.next.next.val == 1
def test_solution_recursive_2():
head = ListNode(1)
head.next = ListNode(1)
head.next.next = ListNode(2)
head.next.next.next = ListNode(3)
new_head = SolutionRecursive().deleteDuplicates(head)
assert new_head.val == 2
assert new_head.next.val == 3
def create_linked_list(self, list: List[int]) -> ListNode:
head = ListNode(list[0])
last = head
for num in list[1:]:
last.next = ListNode(num)
last = last.next
return head
def make_list(lst):
h = None
p = None
for i in lst:
if p is None:
h = p = ListNode(i)
else:
p.next = ListNode(i)
p = p.next
return h
def test():
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)
k = 2
pudb.set_trace()
rotate(head, k)
def mkListNode(nums):
"""
:type: nums: List
:rtype: ListNode
"""
head = lnp = ListNode(0)
for i in range(len(nums)):
lnp.next = ListNode(nums[i])
lnp = lnp.next
return head.next
def test_mergeTwoLists(self):
s = Solution()
l1 = ListNode([1, 2, 4])
l2 = ListNode([1, 3, 4])
result = s.mergeTwoLists(l1, l2)
expected = ListNode([1, 1, 2, 3, 4, 4])
self.assertEqual(result, expected)
def create_linked_list(raw_list: list) -> Optional[ListNode]:
if not raw_list:
return None
head = ListNode(val=raw_list[0])
node = head
for i, _ in enumerate(raw_list):
if i + 1 < len(raw_list):
node.next = ListNode(raw_list[i + 1])
node = node.next
return head
def test():
root = ListNode(0)
a = ListNode(1)
b = ListNode(2)
root.next = a
root.next.next = b
assert split(root, 1) == a
assert root.next == None
assert split(None, 1) == None
assert split(None, 4) == None
def make_list(lst):
head = None
n = None
for i in lst:
if head is None:
n = head = ListNode(i)
else:
n.next = ListNode(i)
n = n.next
return head
def testIterative(self):
testHead = ListNode(4)
p = testHead
p.next = ListNode(3)
p = p.next
p.next = ListNode(2)
p = p.next
p.next = ListNode(1)
p = p.next
p.next = ListNode(0)
self.customAssertEqual(testHead, Solution().reverseIteratively(testHead))
def listnum(nums):
"""
:type nums Array
:rtype ListNode
"""
l = ListNode(0)
node = l
for x in nums:
node.next = ListNode(x)
node = node.next
return l.next
def init_test_list(l1_vals: List[int], l2_vals: List[int]):
l1, l2 = ListNode(), ListNode()
la, lb = l1, l2
# Preparing test data
for val in l1_vals:
la.next = ListNode(val)
la = la.next
for val in l2_vals:
lb.next = ListNode(val)
lb = lb.next
return l1.next, l2.next
def mkListNode(nums, p):
"""
:type: nums: List
:rtype: ListNode
"""
head = lnp = ListNode(0)
ret = None
for i in range(len(nums)):
lnp.next = ListNode(nums[i])
lnp = lnp.next
if lnp.val == p:
ret = lnp
return head.next, ret
def build_linked_list(raw_list: list) -> ListNode:
root = ListNode(raw_list[0])
node = root
for i, val in enumerate(raw_list):
if i + 1 >= len(raw_list):
node.next = None
break
node.next = ListNode(val=raw_list[i + 1])
node = node.next
return root
def test_solution():
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)
m = 2
n = 4
res = Solution().reverseBetween(head, m, n)
assert res.val == 1
assert res.next.val == 4
assert res.next.next.val == 3
assert res.next.next.next.val == 2
assert res.next.next.next.next.val == 5
def test1(self):
l1 = ListNode(2)
l1.next = ListNode(4)
l1.next.next = ListNode(3)
l2 = ListNode(5)
l2.next = ListNode(6)
l2.next.next = ListNode(4)
ans = ListNode(7)
ans.next = ListNode(0)
ans.next.next = ListNode(8)
self.customAssertEqual(Solution().addTwoNumbers(l1, l2), ans)
def test_example_1(self):
l1 = ListNode(val = 2)
l1.next = ListNode(val = 4)
l1.next.next = ListNode(val = 3)
l2 = ListNode(val = 5)
l2.next = ListNode(val = 6)
l2.next.next = ListNode(val = 4)
expected = ListNode(val = 7)
expected.next = ListNode(val = 0)
expected.next.next = ListNode(val = 8)
self.assert_linked_lists_equal( expected, Solution.add_two_numbers( l1, l2 ) )
def run_test(test_input, expected, solution):
head = None
curr = None
for val in test_input:
if curr == None:
curr = ListNode(val)
head = curr
else:
curr.next = ListNode(val)
curr = curr.next
new_head = solution().swapPairs(head)
for i, val in enumerate(expected):
msg = "i:", i
assert new_head.val == val, msg
new_head = new_head.next
def mkListNode(nums, i, dic):
"""
:type: nums: List
:rtype: ListNode
"""
if nums[i] in dic:
return dic[nums[i]]
head = ListNode(nums[i])
dic[nums[i]] = head
if i + 1 < len(nums):
head.next = mkListNode(nums, i + 1, dic)
return head
def test_answer():
expectedAnswer = [2, 0, 6]
# [5, 7, 4]
l1 = ListNode(5)
l1_head = l1
l1.next = ListNode(7)
l1 = l1.next
l1.next = ListNode(4)
# [7, 2, 1]
l2 = ListNode(7)
l2_head = l2
l2.next = ListNode(2)
l2 = l2.next
l2.next = ListNode(1)
sn = Solution()
ret_list_node = sn.addTwoNumbers(l1_head, l2_head)
answer = [ret_list_node.val]
while ret_list_node.next is not None:
answer.append(ret_list_node.next.val)
ret_list_node = ret_list_node.next
assert (len(expectedAnswer) == len(answer)
and sorted(expectedAnswer) == sorted(answer))
def test_addTwoNumbers_withTreeDigits_shouldReturnTreeDigitResult(self):
l1 = ListNode(2)
l1.next = ListNode(4)
l1.next.next = ListNode(3)
l2 = ListNode(5)
l2.next = ListNode(6)
l2.next.next = ListNode(4)
self.assertEqual([7, 0, 8], Solution().addTwoNumbers(l1, l2).toArray())
def test_solution():
l1 = ListNode(2)
l1.next = ListNode(4)
l1.next.next = ListNode(3)
l2 = ListNode(5)
l2.next = ListNode(6)
l2.next.next = ListNode(4)
res = Solution().addTwoNumbers(l1, l2)
assert res.val == 7
assert res.next.val == 0
assert res.next.next.val == 8
