[main] Added generateParenthesis and merge sorted lists and swap pairs

Author: cthacker-udel

pythonProblems/leetcode/generateParenthesis.py

@@ -0,0 +1,21 @@
+from typing import List
+
+class Solution:
+    def __init__(self):
+        self.pairs = []
+
+    def generateParenthesis(self, n: int) -> List[str]:
+        def generate_sub_pair(accumulator: str = '', open_count: int = 0, closed_count: int = 0) -> List[str]:
+            if closed_count > open_count:
+                return ['']
+            if open_count == n and closed_count == n:
+                return [accumulator]
+            if (open_count + closed_count) > (n * 2):
+                return ['']
+            return generate_sub_pair(accumulator + '(', open_count + 1, closed_count) + generate_sub_pair(accumulator + ')', open_count, closed_count + 1)
+        return [x for x in generate_sub_pair() if x != '']
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.generateParenthesis(3))

pythonProblems/leetcode/mergeSortedLists.py

@@ -0,0 +1,68 @@
+# Definition for singly-linked list.
+from typing import List, Optional, Tuple, Union
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val: int = val
+        self.next: Union[ListNode, None] = next
+
+
+class Solution:
+
+    def __init__(self):
+        self.lists = []
+
+    def ret_node_value_and_next(self, index: int) -> Union[int, List]:
+        val = self.lists[index].val if self.lists[index] is not None else None
+        next = self.lists[index].next if self.lists[index] is not None else None
+        if next:
+            self.lists[index] = next
+        else:
+            self.lists[index] = None
+        return val if val != None else []
+
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        if len(self.lists) == 0:
+            self.lists = lists
+        nodes = []
+        new_head = None
+        loop = True
+        while loop:
+            result = [Solution.ret_node_value_and_next(
+                self, ind) for ind in range(len(self.lists))]
+            old_len = len(nodes)
+            for eachValue in result:
+                if eachValue != []:
+                    nodes.append(eachValue)
+            if len(nodes) == old_len:
+                break
+        nodes.sort()
+        tmp_head = None
+        for eachNodeValue in nodes:
+            if new_head is None:
+                new_head = ListNode(eachNodeValue)
+                tmp_head = new_head
+            elif tmp_head is not None:
+                tmp_head.next = ListNode(eachNodeValue)
+                tmp_head = tmp_head.next
+        return new_head
+
+    # def print_list(self, head: Union[ListNode, None]) -> None:
+    #     while head is not None:
+    #         print(head.val)
+    #         if head.next:
+    #             head = head.next
+    #         else:
+    #             break
+    #     print('Done!')
+
+
+if __name__ == '__main__':
+    first_list = ListNode(0, ListNode(2, ListNode(5)))
+    # second_list = ListNode(1, ListNode(3, ListNode(4)))
+    # third_link = ListNode(2, ListNode(6))
+
+    sol = Solution()
+    new_head = sol.mergeKLists([first_list])
+    sol.print_list(new_head)

pythonProblems/leetcode/swapPairs.py

@@ -0,0 +1,41 @@
+from typing import Optional, Union
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val: int = val
+        self.next: Union[ListNode, None] = next
+
+
+class Solution:
+    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        nodes = []
+        while head is not None:
+            nodes.append(head)
+            head = head.next
+        new_head = None
+        temp_head = None
+        for i in range(0, len(nodes) - 1, 2):
+            nodes[i], nodes[i + 1], = nodes[i + 1], nodes[i]
+        for ind, each_node in enumerate(nodes):
+            if new_head is None:
+                new_head = each_node
+                temp_head = new_head
+            else:
+                temp_head.next = each_node
+                temp_head = temp_head.next
+                if ind == len(nodes) - 1:
+                    temp_head.next = None
+        return new_head
+
+    def printList(self, head: Optional[ListNode]) -> None:
+        while head is not None:
+            print(head.val)
+            head = head.next
+
+
+if __name__ == '__main__':
+    alist = ListNode(1, ListNode(2, ListNode(3, ListNode(4))))
+    sol = Solution()
+    head = sol.swapPairs(alist)
+    sol.printList(head)