(oj: leetcode): new solutions.

oj/leetcode/partition_list.py

@@ -0,0 +1,78 @@
+class ListNode:
+
+    def __init__(self, x, next=None):
+        self.val = x
+        self.next = next
+
+
+def dump_list(head):
+    node = head
+    vals = []
+    while node is not None:
+        vals.append(node.val)
+        node = node.next
+    print(vals)
+
+
+class Solution:
+
+    def partition(self, head, x):
+
+        def pop(prev):
+            node = prev.next
+            if not node:
+                return
+            prev.next = prev.next.next
+            return node
+
+        def insert_after(to, node):
+            node.next = to.next
+            to.next = node
+
+        sential = ListNode(42)
+        sential.next = head
+        rv_sential = ListNode(42)
+
+        last_inserted_node, prev_node = rv_sential, sential
+        while prev_node is not None and prev_node.next is not None:
+            if prev_node.next.val < x:
+                node = pop(prev_node)
+                insert_after(last_inserted_node, node)
+                last_inserted_node = node
+            else:
+                prev_node = prev_node.next
+        last_inserted_node.next = sential.next
+
+        return rv_sential.next
+
+
+if __name__ == '__main__':
+
+    def make_list(*nums):
+        sential = last_inserted = ListNode(42)
+        for num in nums:
+            node = ListNode(num)
+            last_inserted.next = node
+            last_inserted = node
+        return sential.next
+
+    def is_list(head, nums):
+        node = head
+        for num in nums:
+            assert node is not None
+            assert num == node.val
+            node = node.next
+
+    s = Solution()
+
+    sl = make_list(1, 4, 3, 2, 5, 2)
+    l = s.partition(sl, 3)
+    is_list(l, [1, 2, 2, 4, 3, 5])
+
+    sl = make_list(1, 1, 1)
+    l = s.partition(sl, 3)
+    is_list(l, [1, 1, 1])
+
+    sl = make_list(4, 4, 4)
+    l = s.partition(sl, 3)
+    is_list(l, [4, 4, 4])

oj/leetcode/remove_duplicates_from_sorted_list_2.py

@@ -0,0 +1,70 @@
+class ListNode:
+
+    def __init__(self, x, next=None):
+        self.val = x
+        self.next = next
+
+
+class Solution:
+
+    def deleteDuplicates(self, head):
+
+        def peek(node):
+            if node is None:
+                return None
+            next_node = node.next
+            if next_node is None:
+                return None
+            return next_node.val
+
+        def skip_to_new_val(prev_node, node, val):
+            while node is not None and node.val == val:
+                node = node.next
+            prev_node.next = node
+
+        sential = prev_node = ListNode(42)
+        sential.next = head
+
+        node = head
+        while node is not None:
+            if peek(node) == node.val:
+                skip_to_new_val(prev_node, node, node.val)
+            else:
+                prev_node = node
+            node = prev_node.next
+
+        return sential.next
+
+
+if __name__ == '__main__':
+
+    def make_list(*nums):
+        sential = last_inserted = ListNode(42)
+        for num in nums:
+            node = ListNode(num)
+            last_inserted.next = node
+            last_inserted = node
+        return sential.next
+
+    def is_list(head, nums):
+        node = head
+        for num in nums:
+            assert node is not None
+            assert num == node.val
+            node = node.next
+
+    s = Solution()
+
+    sl = make_list(1, 2, 3, 3, 4, 4, 5)
+    l = s.deleteDuplicates(sl)
+    is_list(l, [1, 2, 5])
+
+    sl = make_list(1, 1, 1, 2, 3)
+    l = s.deleteDuplicates(sl)
+    is_list(l, [2, 3])
+
+    sl = make_list(1, 2, 3)
+    l = s.deleteDuplicates(sl)
+    is_list(l, [1, 2, 3])
+
+    assert s.deleteDuplicates(None) is None

oj/leetcode/rotate_list.py

@@ -0,0 +1,54 @@
+class ListNode:
+
+    def __init__(self, x, next=None):
+        self.val = x
+        self.next = next
+
+
+class Solution:
+
+    def rotateRight(self, head, k):
+        if not head or k <= 0:
+            return head
+
+        def get_length(node):
+            length = 0
+            while node is not None:
+                length = length + 1
+                node = node.next
+            return length
+
+        length = get_length(head)
+        k = k % length
+
+        slow, fast = head, head
+
+        while k > 0:
+            fast, k = fast.next, k - 1
+
+        while fast and fast.next:
+            slow, fast = slow.next, fast.next
+
+        fast.next = head
+        head = slow.next
+        slow.next = None
+
+        return head
+
+
+if __name__ == '__main__':
+    s = Solution()
+
+    sl = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5)))))
+    l = s.rotateRight(sl, 2)
+    assert 4 == l.val
+    assert 5 == l.next.val
+    assert 1 == l.next.next.val
+    assert 2 == l.next.next.next.val
+    assert 3 == l.next.next.next.next.val
+
+    sl = ListNode(1)
+    l = s.rotateRight(sl, 1)
+    assert 1 == l.val
+
+    assert s.rotateRight(None, 1) is None