week 3

Author: selfboot

.gitignore

@@ -0,0 +1 @@
+working

1.py

@@ -1,6 +1,8 @@
 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
 
+:w
+
 
 class Solution(object):
     def twoSum(self, nums, target):

18.py

@@ -0,0 +1,43 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def fourSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[List[int]]
+        """
+        nums = sorted(nums)
+        solution = []
+        length = len(nums)
+
+        for i in range(length - 3):
+            a = nums[i]
+            for j in range(i + 1, length - 2):
+                b = nums[j]
+
+                # Two points which are form head and bottom move toward
+                # to make the a + b + c + d == target
+                left = j + 1
+                right = length - 1
+                while left < right:
+                    c = nums[left]
+                    d = nums[right]
+                    if a + b + c + d < target:
+                        left += 1
+                    elif a + b + c + d > target:
+                        right -= 1
+                    else:
+                        solution.append([a, b, c, d])
+                        left += 1
+                        right -= 1
+
+        # remove the duplicate list
+        no_duplicate = []
+        for terms in solution:
+            if terms not in no_duplicate:
+                no_duplicate.append(terms)
+
+        return no_duplicate

19.py

@@ -0,0 +1,40 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution(object):
+    def removeNthFromEnd(self, head, n):
+        """
+        :type head: ListNode
+        :type n: int
+        :rtype: ListNode
+        """
+        counter = 1                         # The length of the list
+        head_counter = head
+        # Get te length of the list
+        while head_counter.next:
+            counter += 1
+            head_counter = head_counter.next
+
+        count_from_head = 1
+        head_keep = head
+        while head.next:
+            # The next node will be removed
+            if count_from_head == counter - n:
+                head.next = head.next.next
+                break
+            head = head.next
+            count_from_head += 1
+
+        # the node removed is the head.
+        if counter == n:
+            return head_keep.next
+
+        else:
+            return head_keep

20.py

@@ -0,0 +1,43 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    def isValid(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+        close_s = ""
+        for symbol in s:
+            if symbol == "(":
+                close_s = ")" + close_s
+
+            elif symbol == "[":
+                close_s = "]" + close_s
+
+            elif symbol == "{":
+                close_s = "}" + close_s
+
+            elif symbol == ")":
+                if close_s and close_s[0] == ")":
+                    close_s = close_s[1:]
+                    continue
+                else:
+                    return False
+            elif symbol == "]":
+                if close_s and close_s[0] == "]":
+                    close_s = close_s[1:]
+                    continue
+                else:
+                    return False
+            else:
+                if close_s and close_s[0] == "}":
+                    close_s = close_s[1:]
+                    continue
+                else:
+                    return False
+        if close_s == "":
+            return True
+        else:
+            return False

21.py

@@ -0,0 +1,49 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution(object):
+    def mergeTwoLists(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        while not l1 and not l2:
+            return None
+
+        merged_list = ListNode(0)
+        merged_head = merged_list
+
+        # Scan through l1 and l2, get the smaller one to merged list
+        while l1 and l2:
+            if l1.val <= l2.val:
+                node = ListNode(l1.val)
+                l1 = l1.next
+            else:
+                node = ListNode(l2.val)
+                l2 = l2.next
+            merged_list.next = node
+            merged_list = merged_list.next
+
+        # l2 has gone to the tail already and only need to scan l1
+        while l1:
+            node = ListNode(l1.val)
+            l1 = l1.next
+            merged_list.next = node
+            merged_list = merged_list.next
+
+        # l1 has gone to the tail already and only need to scan l2
+        while l2:
+            node = ListNode(l2.val)
+            l2 = l2.next
+            merged_list.next = node
+            merged_list = merged_list.next
+
+        return merged_head.next

22.py

@@ -0,0 +1,46 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+def generateParenthesis(self, n):
+    """
+    :type n: int
+    :rtype: List[str]
+    """
+
+    # node = [leftchild, rightchild, count"(", count")", current str]
+    if not n:
+        return [""]
+    solution = []
+    root = [None, None, 1, 0, "("]
+    self.generate_child_tree(root, n, solution)
+    return solution
+
+
+def generate_child_tree(self, node, n, solution):
+    # the node is the leave and the str is what we want
+    if node[2] == node[3] == n:
+        node[0] = None
+        node[1] = None
+        solution.append(node[4])
+
+    # the node have both left and right child
+    elif node[2] > node[3] and node[2] < n:
+        left_child = [None, None, node[2] + 1, node[3], node[4] + "("]
+        right_child = [None, None, node[2], node[3] + 1, node[4] + ")"]
+        node[0] = left_child
+        node[1] = right_child
+        self.generate_child_tree(left_child, n, solution)
+        self.generate_child_tree(right_child, n, solution)
+
+    # the node have only left child
+    elif node[2] == node[3] and node[2] < n:
+        left_child = [None, None, node[2] + 1, node[3], node[4] + "("]
+        node[0] = left_child
+        self.generate_child_tree(left_child, n, solution)
+
+    # the node have only left child
+    else:
+        right_child = [None, None, node[2], node[3] + 1, node[4] + ")"]
+        node[1] = right_child
+        self.generate_child_tree(right_child, n, solution)

23.py

@@ -0,0 +1,45 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+import heapq
+
+
+class Solution(object):
+    def mergeKLists(self, lists):
+        """
+        :type lists: List[ListNode]
+        :rtype: ListNode
+        """
+        if not lists:
+            return []
+
+        head = merged_list = ListNode(0)
+        heap_record = []
+        # push head of all the linked list to heap
+        for node in lists:
+            if node:
+                heap_record.append((node.val, node))
+        heapq.heapify(heap_record)
+
+        # get the min val and push the node into heap
+        while heap_record:
+            min_node = heapq.heappop(heap_record)
+            merged_list.next = min_node[1]
+            merged_list = merged_list.next
+            if min_node[1].next:
+                next_node = min_node[1].next
+                heapq.heappush(heap_record, (next_node.val, next_node))
+
+        return head.next

24.py

@@ -0,0 +1,42 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def swapPairs(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        result = before_node = ListNode(0)
+        before_node.next = head
+
+        """
+        Given a situation    : ... -> B -> | C -> D | -> E -> ...
+        Node before C is swaped, and then we should swap C and D,
+        so the result is     : ... -> B -> | D -> C | -> E -> ...
+        Assume B is before_node, C is head, then we need to:
+            1. B.next = D     ( B -> D, C -> D, D -> E)
+            2. D.next = C     ( B -> D, D -> C,   -> E)
+            3. C.next = E     ( B -> D, D -> C, C -> E)
+
+        """
+        while head:
+            if head.next:
+                next_node = head.next.next       # Keep E
+                before_node.next = head.next     # Step 1
+                head.next.next = head            # Step 2
+                head.next = next_node            # Step 3
+
+                # Scan next two node
+                before_node = head
+                head = head.next
+            else:
+                break
+        return result.next

25.py

@@ -0,0 +1,67 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution(object):
+    def reverseKGroup(self, head, k):
+        """
+        :type head: ListNode
+        :type k: int
+        :rtype: ListNode
+        """
+
+        if not head or k <= 1:
+            return head
+
+        solution = ListNode(0)
+        solution.next = head
+        before_node = solution
+        count = 0
+
+        # Get each k nodes and reverse all of them
+        while head:
+            count += 1
+            if count % k == 0:
+                after_node = head.next
+                before_node = self.reverse_k_nodes(before_node, after_node)
+                head = after_node
+            else:
+                head = head.next
+
+        return solution.next
+
+    def reverse_k_nodes(self, before_node, after_node):
+        """
+        Given a situation    : ... -> B -> | C -> ... -> X | -> Y -> ...
+        Nodes before C is swaped, and then we should swap node between C and X,
+        so the result is     : ... -> B -> | X -> ... -> C | -> Y -> ...
+        Then what we need to is:
+            1. Get node C and make it as tail in k-reversed-list:  C
+            2. Get all the other nodes and put each before the
+               head of current k-reversed-list:  X -> ... ->C
+            3. Make B.next = X and C.next = Y:
+                -> B -> | X -> ... -> C  | -> Y
+        """
+        if before_node.next == after_node:
+            pass
+
+        # Step 2
+        head = before_node.next
+        reversed_list_head = reversed_list_tail = head
+        cur_node = head.next
+        while cur_node != after_node:
+            keep_node = cur_node.next
+            cur_node.next = reversed_list_head
+            reversed_list_head = cur_node
+            cur_node = keep_node
+
+        # Step 3
+        before_node.next = reversed_list_head
+        reversed_list_tail.next = after_node
+        return reversed_list_tail