Python convert_linked_list_to_list Exemples

Exemple #1

Fichier : test_l0147_insertion_sort_list.py Projet : sprax/1337

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

Exemple #2

Fichier : test_l0328_odd_even_linked_list.py Projet : sprax/1337

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

Exemple #3

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

Exemple #4

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

Exemple #5

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

Exemple #6

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

Exemple #7

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

Exemple #8

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

Exemple #9

Fichier : test_l0203_remove_linked_list_elements.py Projet : sprax/1337

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

Exemple #10

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

Exemple #11

Fichier : test_l0206_reverse_linked_list.py Projet : sprax/1337

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

Exemple #12

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

Exemple #13

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

Exemple #14

Fichier : test_l0092_reverse_linked_list_2.py Projet : sprax/1337

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

Exemple #15

Fichier : test_l0086_partition_list.py Projet : sprax/1337

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