def insert_ll(ll, x):
"""
insert x into front of linked-list ll
"""
node = ListNode(x)
node.next = ll
return node
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_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_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 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 test2(self):
head = ListNode(1)
node2 = ListNode(2)
head.next = node2
s = Solution()
res = s.reverseBetween(head, 1, 2)
while res:
print res.val
res = res.next
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 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 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_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_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 main():
left = ListNode.build_num(99)
right = ListNode.build_num(1)
op = solution.Solution().addTwoNumbers
sum = op(left, right)
left.print_r()
print ""
right.print_r()
print ""
sum.print_r()
print ""
def test1(self):
head = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
head.next = node2
node2.next = node3
s = Solution()
res = s.reverseBetween(head, 1, 3)
while res:
print res.val
res = res.next
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 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 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 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 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 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 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 test():
sol = Solution()
head = ListNode(1)
p = ListNode(2); head.next = p; q = p
p = ListNode(3); q.next = p; q = p
p = ListNode(4); q.next = p; q = p
p = ListNode(5); q.next = p; q = p
p = sol.removeNthFromEnd(head, 2)
assert p.val == 1; p = p.next
assert p.val == 2; p = p.next
assert p.val == 3; p = p.next
assert p.val == 5; p = p.next
assert p is None
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
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 test_1():
sol = Solution()
n1 = ListNode(1)
n2 = ListNode(2)
n1.next = n2
n3 = ListNode(3)
n2.next = n3
n4 = ListNode(4)
n3.next = n4
n5 = ListNode(5)
n4.next = n5
n5.next = n2
assert sol.hasCycle(n1)
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 test_5():
sol = Solution()
l1 = ListNode(1)
p = ListNode(3); l1.next = p; q = p
p = ListNode(5); q.next = p; q = p
p = ListNode(5); q.next = p; q = p
p = sol.mergeKLists([None, l1])
assert p.val == 1; p = p.next
assert p.val == 3; p = p.next
assert p.val == 5; p = p.next
assert p.val == 5; p = p.next
assert p is None
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_4():
sol = Solution()
l1 = ListNode(1)
p = ListNode(3); l1.next = p; q = p
p = ListNode(5); q.next = p; q = p
p = ListNode(5); q.next = p; q = p
p = sol.mergeTwoLists(l1, None)
assert p.val == 1; p = p.next
assert p.val == 3; p = p.next
assert p.val == 5; p = p.next
assert p.val == 5; p = p.next
assert p is None
def test_solution():
head = ListNode(3)
head.next = ListNode(2)
head.next.next = ListNode(0)
head.next.next.next = ListNode(-4)
head.next.next.next.next = head.next
assert Solution().detect_cycle(head).val == 2
head = ListNode(1)
head.next = ListNode(2)
head.next.next = head
assert Solution().detect_cycle(head).val == 1
def test_solution_recursive_2():
l1 = ListNode(2)
l1.next = ListNode(4)
l1.next.next = ListNode(3)
l2 = ListNode(5)
l2.next = ListNode(6)
l2.next.next = ListNode(4)
# pudb.set_trace()
res = SolutionRecursive2().add_two_numbers(l1, l2)
assert res.val == 7
assert res.next.val == 0
assert res.next.next.val == 8
def test_0():
sol = Solution()
assert not sol.hasCycle(None)
n1 = ListNode(1)
n1.next = n1
assert sol.hasCycle(n1)
n1 = ListNode(1)
assert not sol.hasCycle(n1)
n1 = ListNode(1)
n2 = ListNode(2)
n1.next = n2
assert not sol.hasCycle(n1)
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 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 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 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_2():
sol = Solution()
l1 = ListNode(1)
p = ListNode(3); l1.next = p; q = p
p = ListNode(5); q.next = p; q = p
p = ListNode(5); q.next = p; q = p
l2 = ListNode(0)
p = ListNode(2); l2.next = p; q = p
p = ListNode(4); q.next = p; q = p
p = sol.mergeKLists([l2, l1])
assert p.val == 0; p = p.next
assert p.val == 1; p = p.next
assert p.val == 2; p = p.next
assert p.val == 3; p = p.next
assert p.val == 4; p = p.next
assert p.val == 5; p = p.next
assert p.val == 5; p = p.next
assert p is None
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 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_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 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 test3(self):
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
node4 = ListNode(4)
node5 = ListNode(5)
node6 = ListNode(6)
node7 = ListNode(7)
node8 = ListNode(8)
node9 = ListNode(9)
node10 = ListNode(10)
node11 = ListNode(11)
node12 = ListNode(12)
node13 = ListNode(13)
node13 = ListNode(13)
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5
node5.next = node6
node6.next = node1
node7.next = node8
node8.next = node9
node9.next = node10
node10.next = node11
node11.next = node12
node12.next = node13
node12.next = node7
s = Solution()
res = s.is_interset(node1, node7)
print res
self.assertFalse(res)
