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