Python from_values示例

示例#1

文件： test_rotate_list.py 项目： qianbinbin/leetcode

    def test1(self):
        head1 = linked_lists.from_values(*VALUES1)
        head1 = SOLUTION1.rotateRight(head1, K1)
        self.assertTrue(linked_lists.equals(EXPECTED1, head1))

        head2 = linked_lists.from_values(*VALUES2)
        head2 = SOLUTION1.rotateRight(head2, K2)
        self.assertTrue(linked_lists.equals(EXPECTED2, head2))

示例#2

from unittest import TestCase

from leetcodepy.convert_sorted_list_to_binary_search_tree import *
from leetcodepy.utils import linked_lists, trees

SOLUTION1 = Solution1()

HEAD1 = linked_lists.from_values(-10, -3, 0, 5, 9)
EXPECTED1 = trees.from_values(0, -3, 9, -10, None, 5)

HEAD2 = linked_lists.from_values()
EXPECTED2 = trees.from_values()


class TestConvertSortedListToBinarySearchTree(TestCase):
    def test1(self):
        self.assertTrue(
            trees.equals(EXPECTED1, SOLUTION1.sortedListToBST(HEAD1)))
        self.assertTrue(
            trees.equals(EXPECTED2, SOLUTION1.sortedListToBST(HEAD2)))

示例#3

def HEAD3():
    return linked_lists.from_values(1)

示例#4

from unittest import TestCase

from leetcodepy.swap_nodes_in_pairs import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def HEAD1():
    return linked_lists.from_values(1, 2, 3, 4)


EXPECTED1 = linked_lists.from_values(2, 1, 4, 3)

HEAD2 = None
EXPECTED2 = None


def HEAD3():
    return linked_lists.from_values(1)


EXPECTED3 = linked_lists.from_values(1)


class TestSwapNodesInPairs(TestCase):
    def test1(self):
        self.assertTrue(linked_lists.equals(EXPECTED1, SOLUTION1.swapPairs(HEAD1())))
        self.assertTrue(linked_lists.equals(EXPECTED2, SOLUTION1.swapPairs(HEAD2)))
        self.assertTrue(linked_lists.equals(EXPECTED3, SOLUTION1.swapPairs(HEAD3())))

示例#5

from unittest import TestCase

from leetcodepy.remove_duplicates_from_sorted_list_ii import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def HEAD1():
    return linked_lists.from_values(1, 2, 3, 3, 4, 4, 5)


EXPECTED1 = linked_lists.from_values(1, 2, 5)


def HEAD2():
    return linked_lists.from_values(1, 1, 1, 2, 3)


EXPECTED2 = linked_lists.from_values(2, 3)


class TestRemoveDuplicatesFromSortedListII(TestCase):
    def test1(self):
        self.assertTrue(
            linked_lists.equals(EXPECTED1,
                                SOLUTION1.deleteDuplicates(HEAD1())))
        self.assertTrue(
            linked_lists.equals(EXPECTED2,
                                SOLUTION1.deleteDuplicates(HEAD2())))

示例#6

def HEAD2():
    return linked_lists.from_values(5)

示例#7

文件： test_reorder_list.py 项目： qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.reorder_list import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def HEAD1():
    return linked_lists.from_values(1, 2, 3, 4)


EXPECTED1 = linked_lists.from_values(1, 4, 2, 3)


def HEAD2():
    return linked_lists.from_values(1, 2, 3, 4, 5)


EXPECTED2 = linked_lists.from_values(1, 5, 2, 4, 3)


class TestReorderList(TestCase):
    def test1(self):
        head1 = HEAD1()
        SOLUTION1.reorderList(head1)
        self.assertTrue(linked_lists.equals(EXPECTED1, head1))

        head2 = HEAD2()
        SOLUTION1.reorderList(head2)
        self.assertTrue(linked_lists.equals(EXPECTED2, head2))

示例#8

文件： test_sort_list.py 项目： qianbinbin/leetcode

def HEAD2():
    return linked_lists.from_values(-1, 5, 3, 4, 0)

示例#9

文件： test_partition_list.py 项目： qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.partition_list import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()

HEAD1 = linked_lists.from_values(1, 4, 3, 2, 5, 2)
X1 = 3
EXPECTED1 = linked_lists.from_values(1, 2, 2, 4, 3, 5)

HEAD2 = linked_lists.from_values(2, 1)
X2 = 2
EXPECTED2 = linked_lists.from_values(1, 2)


class TestPartitionList(TestCase):
    def test1(self):
        self.assertTrue(
            linked_lists.equals(EXPECTED1, SOLUTION1.partition(HEAD1, X1)))
        self.assertTrue(
            linked_lists.equals(EXPECTED2, SOLUTION1.partition(HEAD2, X2)))

示例#10

文件： test_merge_k_sorted_lists.py 项目： qianbinbin/leetcode

def LISTS1():
    return [
        linked_lists.from_values(1, 4, 5),
        linked_lists.from_values(1, 3, 4),
        linked_lists.from_values(2, 6)
    ]

示例#11

文件： test_merge_k_sorted_lists.py 项目： qianbinbin/leetcode

from leetcodepy.merge_k_sorted_lists import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()
SOLUTION2 = Solution2()


def LISTS1():
    return [
        linked_lists.from_values(1, 4, 5),
        linked_lists.from_values(1, 3, 4),
        linked_lists.from_values(2, 6)
    ]


EXPECTED1 = linked_lists.from_values(1, 1, 2, 3, 4, 4, 5, 6)

LISTS2 = []
EXPECTED2 = None

LISTS3 = [None]
EXPECTED3 = None


class TestMergeKSortedLists(TestCase):
    def test1(self):
        self.assertTrue(
            linked_lists.equals(EXPECTED1, SOLUTION1.mergeKLists(LISTS1())))
        self.assertTrue(
            linked_lists.equals(EXPECTED2, SOLUTION1.mergeKLists(LISTS2)))
        self.assertTrue(

示例#12

from unittest import TestCase

from leetcodepy.reverse_nodes_in_k_group import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def HEAD1():
    return linked_lists.from_values(1, 2, 3, 4, 5)


K1 = 2
EXPECTED1 = linked_lists.from_values(2, 1, 4, 3, 5)


def HEAD2():
    return linked_lists.from_values(1, 2, 3, 4, 5)


K2 = 3
EXPECTED2 = linked_lists.from_values(3, 2, 1, 4, 5)


def HEAD3():
    return linked_lists.from_values(1, 2, 3, 4, 5)


K3 = 1
EXPECTED3 = linked_lists.from_values(1, 2, 3, 4, 5)

示例#13

文件： test_rotate_list.py 项目： qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.rotate_list import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()

VALUES1 = (1, 2, 3, 4, 5)
K1 = 2
EXPECTED1 = linked_lists.from_values(4, 5, 1, 2, 3)

VALUES2 = (0, 1, 2)
K2 = 4
EXPECTED2 = linked_lists.from_values(2, 0, 1)


class TestRotateList(TestCase):
    def test1(self):
        head1 = linked_lists.from_values(*VALUES1)
        head1 = SOLUTION1.rotateRight(head1, K1)
        self.assertTrue(linked_lists.equals(EXPECTED1, head1))

        head2 = linked_lists.from_values(*VALUES2)
        head2 = SOLUTION1.rotateRight(head2, K2)
        self.assertTrue(linked_lists.equals(EXPECTED2, head2))

示例#14

文件： test_add_two_numbers.py 项目： qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.add_two_numbers import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()

L11 = linked_lists.from_values(2, 4, 3)
L12 = linked_lists.from_values(5, 6, 4)
EXPECTED1 = linked_lists.from_values(7, 0, 8)

L21 = linked_lists.from_values(0)
L22 = linked_lists.from_values(0)
EXPECTED2 = linked_lists.from_values(0)

L31 = linked_lists.from_values(9, 9, 9, 9, 9, 9, 9)
L32 = linked_lists.from_values(9, 9, 9, 9)
EXPECTED3 = linked_lists.from_values(8, 9, 9, 9, 0, 0, 0, 1)


class TestAddTwoNumbers(TestCase):
    def test1(self):
        self.assertTrue(
            linked_lists.equals(EXPECTED1, SOLUTION1.addTwoNumbers(L11, L12)))
        self.assertTrue(
            linked_lists.equals(EXPECTED2, SOLUTION1.addTwoNumbers(L21, L22)))
        self.assertTrue(
            linked_lists.equals(EXPECTED3, SOLUTION1.addTwoNumbers(L31, L32)))

示例#15

文件： test_merge_two_sorted_lists.py 项目： qianbinbin/leetcode

from leetcodepy.merge_two_sorted_lists import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def L11():
    return linked_lists.from_values(1, 2, 4)


def L12():
    return linked_lists.from_values(1, 3, 4)


EXPECTED1 = linked_lists.from_values(1, 1, 2, 3, 4, 4)

L21 = None
L22 = None
EXPECTED2 = linked_lists.from_values()

L31 = None


def L32():
    return linked_lists.from_values(0)


EXPECTED3 = linked_lists.from_values(0)

示例#16

文件： test_sort_list.py 项目： qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.sort_list import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def HEAD1():
    return linked_lists.from_values(4, 2, 1, 3)


EXPECTED1 = linked_lists.from_values(1, 2, 3, 4)


def HEAD2():
    return linked_lists.from_values(-1, 5, 3, 4, 0)


EXPECTED2 = linked_lists.from_values(-1, 0, 3, 4, 5)


def HEAD3():
    return linked_lists.from_values()


EXPECTED3 = linked_lists.from_values()


class TestSortList(TestCase):
    def test1(self):

示例#17

文件： test_merge_two_sorted_lists.py 项目： qianbinbin/leetcode

def L12():
    return linked_lists.from_values(1, 3, 4)

示例#18

文件： test_sort_list.py 项目： qianbinbin/leetcode

def HEAD1():
    return linked_lists.from_values(4, 2, 1, 3)

示例#19

文件： test_merge_two_sorted_lists.py 项目： qianbinbin/leetcode

def L32():
    return linked_lists.from_values(0)

示例#20

from unittest import TestCase

from leetcodepy.reverse_linked_list_ii import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def HEAD1():
    return linked_lists.from_values(1, 2, 3, 4, 5)


LEFT1, RIGHT1 = 2, 4
EXPECTED1 = linked_lists.from_values(1, 4, 3, 2, 5)


def HEAD2():
    return linked_lists.from_values(5)


LEFT2, RIGHT2 = 1, 1
EXPECTED2 = linked_lists.from_values(5)


class TestReverseLinkedListII(TestCase):
    def test1(self):
        self.assertTrue(
            linked_lists.equals(
                EXPECTED1, SOLUTION1.reverseBetween(HEAD1(), LEFT1, RIGHT1)))
        self.assertTrue(
            linked_lists.equals(

示例#21

文件： test_merge_two_sorted_lists.py 项目： qianbinbin/leetcode

def L11():
    return linked_lists.from_values(1, 2, 4)

示例#22

def HEAD1():
    return linked_lists.from_values(1, 2, 3, 4, 5)

示例#23

文件： test_remove_nth_node_from_end_of_list.py 项目： qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.remove_nth_node_from_end_of_list import *
from leetcodepy.utils import linked_lists

SOLUTION1 = Solution1()


def HEAD1():
    return linked_lists.from_values(1, 2, 3, 4, 5)


N1 = 2
EXPECTED1 = linked_lists.from_values(1, 2, 3, 5)


def HEAD2():
    return linked_lists.from_values(1)


N2 = 1
EXPECTED2 = None


def HEAD3():
    return linked_lists.from_values(1, 2)


N3 = 1
EXPECTED3 = linked_lists.from_values(1)