Python pyllist.sllist函数代码示例

 def test_node_str(self):
     a = sllist([None, None]).first
     self.assertEqual(str(a), 'sllistnode(None)')
     b = sllist([1, None]).first
     self.assertEqual(str(b), 'sllistnode(1)')
     c = sllist(['abc', None]).first
     self.assertEqual(str(c), 'sllistnode(abc)')

 def test_node_repr(self):
     a = sllist([None]).first
     self.assertEqual(repr(a), '<sllistnode(None)>')
     b = sllist([1, None]).first
     self.assertEqual(repr(b), '<sllistnode(1)>')
     c = sllist(['abc', None]).first
     self.assertEqual(repr(c), '<sllistnode(\'abc\')>')

 def test_node_repr(self):
     a = sllist([None]).first
     self.assertEqual(repr(a), "<sllistnode(None)>")
     b = sllist([1, None]).first
     self.assertEqual(repr(b), "<sllistnode(1)>")
     c = sllist(["abc", None]).first
     self.assertEqual(repr(c), "<sllistnode('abc')>")

 def test_guards_after_concat(self):
     a = sllist([1, 2])
     b = sllist([3, 4])
     c = a + b
     self.assertIsNot(c.first, None)
     self.assertEqual(c.first.value, 1)
     self.assertIsNot(c.last, None)
     self.assertEqual(c.last.value, 4)

 def test_guards_after_concat_inplace(self):
     a = sllist([1, 2])
     b = sllist([3, 4])
     orig_a_first = a.first
     a += b
     self.assertIs(a.first, orig_a_first)
     self.assertEqual(a.first.value, 1)
     self.assertIsNot(a.last, None)
     self.assertEqual(a.last.value, 4)

 def test_insert_value_before_first(self):
     ll = sllist(xrange(4))
     ref = sllist([10, 0, 1, 2, 3])
     next = ll.nodeat(0)
     arg_node = sllistnode(10)
     new_node = ll.insert(arg_node, ll.nodeat(0))
     self.assertNotEqual(new_node, arg_node)
     self.assertEqual(new_node.value, 10)
     self.assertEqual(new_node.next, next)
     self.assertEqual(new_node, ll.first)
     self.assertEqual(ll, ref)

 def test_appendleft(self):
     ll = sllist(xrange(4))
     ref = sllist([10, 0, 1, 2, 3])
     next = ll.nodeat(0)
     arg_node = sllistnode(10)
     new_node = ll.appendleft(arg_node)
     self.assertNotEqual(new_node, arg_node)
     self.assertEqual(new_node.value, 10)
     self.assertEqual(new_node.next, next)
     self.assertEqual(ll.first, new_node)
     self.assertEqual(ll, ref)

 def test_insert_value_before(self):
     ll = sllist(xrange(4))
     ref = sllist([0, 1, 10, 2, 3])
     prev = ll.nodeat(1)
     next = ll.nodeat(2)
     arg_node = sllistnode(10)
     new_node = ll.insert(arg_node, ll.nodeat(2))
     self.assertNotEqual(new_node, arg_node)
     self.assertEqual(new_node.value, 10)
     self.assertEqual(new_node.next, next)
     self.assertEqual(prev.next, new_node)
     self.assertEqual(ll, ref)

 def test_appendright(self):
     ll = sllist(xrange(4))
     ref = sllist([0, 1, 2, 3, 10])
     prev = ll.nodeat(-1)
     arg_node = sllistnode(10)
     new_node = ll.appendright(arg_node)
     self.assertNotEqual(new_node, arg_node)
     self.assertEqual(new_node.value, 10)
     self.assertEqual(new_node.next, None)
     self.assertEqual(prev.next, new_node)
     self.assertEqual(ll.last, new_node)
     self.assertEqual(ll, ref)

 def test_concat(self):
     a_ref = range(0, 1024, 4)
     a = sllist(a_ref)
     b_ref = range(8092, 8092 + 1024, 4)
     b = sllist(b_ref)
     ab_ref = sllist(a_ref + b_ref)
     c = a + b
     self.assertEqual(c, ab_ref)
     self.assertEqual(len(c), len(ab_ref))
     c = a + b_ref
     self.assertEqual(c, ab_ref)
     self.assertEqual(len(c), len(ab_ref))

 def test_cmp(self):
     a = sllist(xrange(0, 1100))
     b = sllist(xrange(0, 1101))
     c = [xrange(0, 1100)]
     self.assertEqual(cmp(a, a), 0)
     self.assertEqual(cmp(a, b), -1)
     self.assertEqual(cmp(b, a), 1)
     self.assertEqual(cmp(a, c), 1)
     self.assertEqual(cmp(c, a), -1)
     self.assertEqual(cmp([], []), 0)
     self.assertEqual(cmp([], a), -1)
     self.assertEqual(cmp(a, []), 1)

 def test_concat_empty(self):
     empty = sllist()
     filled_ref = range(0, 1024, 4)
     filled = sllist(filled_ref)
     res = empty + empty
     self.assertEqual(res, sllist([] + []))
     self.assertEqual(len(res), 0)
     res = empty + filled
     self.assertEqual(res, sllist([] + filled_ref))
     self.assertEqual(len(res), len(filled_ref))
     res = filled + empty
     self.assertEqual(res, sllist(filled_ref + []))
     self.assertEqual(len(res), len(filled_ref))

 def test_init_empty(self):
     ll = sllist()
     self.assertEqual(len(ll), 0)
     self.assertEqual(ll.size, 0)
     self.assertEqual(list(ll), [])
     self.assertIs(ll.first, None)
     self.assertIs(ll.last, None)

 def test_guards_after_remove(self):
     ll = sllist([1, 2])
     ll.remove(ll.last)
     self.assertIs(ll.first, ll.last)
     ll.remove(ll.first)
     self.assertIs(ll.first, None)
     self.assertIs(ll.last, None)

def _add(letters):
    """
    Runs the loveAlgorithm to reduce a length-5 singly-linked list to length <= 2.

    Returns sllist([1]) if an infinite loop occurs on the input.
    """

    def step(sll):
        for node in sll.iternodes():
            try:
                node.value += node.next()
                if node.value >= 10:
                    sll.insertbefore(node, node.value/10)
                    node.value %= 10
            except TypeError:
                'reached end of sllist'
                sll.popright()

    visited = set()
    while len(letters) > 2:
        curr = str(letters)  # stringify the Sllist since you cannot hash a mutable object 
        if curr in visited:
            return sllist([1])
        visited.add(curr)

        step(letters)

    return letters