ltc basecode updated

Author: geekprodev

src/app/codility/arrays/cyclic_rotation.py

@@ -5,11 +5,7 @@
 
 The goal is to rotate array A K times; that is, each element of A will be shifted to the right K times.
 
-Write a function:
-
-class Solution { public int[] solution(int[] A, int K); }
-
-that, given an array A consisting of N integers and an integer K, returns the array A rotated K times.
+Write a function that, given an array A consisting of N integers and an integer K, returns the array A rotated K times.
 
 For example, given
 
@@ -39,7 +35,6 @@ class Solution { public int[] solution(int[] A, int K); }
 In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
 
 """
-
 class CyclicRotation:
     def rotate(self, a: list[int], k: int) -> list[int]:
         """

src/app/common/interval.py

@@ -0,0 +1,4 @@
+class Interval:
+    def __init__(self, s=0, e=0):
+        self.start = s
+        self.end = e

src/app/common/list_node.py

@@ -7,3 +7,9 @@ class ListNode(object):
     def __init__(self, x):
         self.val = x
         self.next = None
+
+class RandomListNode:
+    def __init__(self, x):
+        self.label = x
+        self.next = None
+        self.random = None

src/app/leetcode/degree_of_an_array.py

@@ -0,0 +1,17 @@
+"""
+Reverse Integer | https://leetcode.com/problems/reverse-integer/
+"""
+class RevereseInteger:
+
+    def reverse(self, x: int) -> int:
+        # Note that in Python -1 / 10 = -1
+        res, is_pos = 0, 1
+        if x < 0:
+            is_pos = -1
+            x = -1 * x
+        while x != 0:
+            res = res * 10 + x % 10
+            if res > 2147483647:
+                return 0
+            x /= 10
+        return res * is_pos

src/app/leetcode/ltc_0007_reverse_integer.py

@@ -1,16 +1,15 @@
 """
-
+Regular Expression Matching | https://leetcode.com/problems/regular-expression-matching/
 """
-
 class RegularExpressionMatching:
-    def isMatch(self, s, p):
+
+    def is_match(self, s: str, p: str) -> bool:
         """
         :type s: str
         :type p: str
         :rtype: bool
         """
         # bottom up o(m*n)
-        # https://leetcode.com/discuss/93024/easy-dp-java-solution-with-detailed-explanation
         if s == p:
             return True
         m, n = len(s), len(p)
@@ -30,6 +29,3 @@ def isMatch(self, s, p):
                     else:
                         dp[i + 1][j + 1] = dp[i + 1][j] or dp[i][j + 1] or dp[i + 1][j - 1]
         return dp[m][n]
-
-    # s = Solution()
-    # print(s.isMatch("", ".*"))

…/leetcode/regular_expression_matching.py …/ltc_0010_regular_expression_matching.pysrc/app/leetcode/regular_expression_matching.py renamed to src/app/leetcode/ltc_0010_regular_expression_matching.py src/app/leetcode/regular_expression_matching.py renamed to src/app/leetcode/ltc_0010_regular_expression_matching.py

@@ -1,5 +1,6 @@
 """
-https://leetcode.com/problems/3sum/description/
+Three Sum | https://leetcode.com/problems/3sum/description/
+problem #
 
 Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
 Notice that the solution set must not contain duplicate triplets.
@@ -39,59 +40,9 @@
 
 """
 
-class ThreeSum
-    # def threeSum(self, nums):
-    #     # skip duplicate
-    #     # O(n^3)
-    #     if len(nums) < 3:
-    #         return []
-    #     nums.sort()
-    #     ls = len(nums)
-    #     result = []
-    #     for i in range(0, ls - 2):
-    #         if nums[i] > 0:
-    #             break
-    #         if i > 0 and nums[i] == nums[i - 1]:
-    #             continue
-    #         j = i + 1
-    #         k = ls - 1
-    #         while(j < k):
-    #             temp = [nums[i], nums[j], nums[k]]
-    #             s = sum(temp)
-    #             jtemp = nums[j]
-    #             ktemp = nums[k]
-    #             if s <= 0:
-    #                 j += 1
-    #                 while(j < k and jtemp == nums[j]):
-    #                     j += 1
-    #                 if s == 0:
-    #                     result.append(temp)
-    #             else:
-    #                 k -= 1
-    #                 while(j < k and ktemp == nums[k]):
-    #                     k -= 1
-    #     return result
+class ThreeSum:
 
-    # def threeSum(self, nums):
-    #     """
-    #         :type nums: List[int]
-    #         :rtype: List[List[int]]
-    #     """
-    #     # using multiple 2 sum
-    #     nums.sort()
-    #     result, visited = set(), {}
-    #     for i in range(len(nums) - 2):
-    #         table, target = {}, -nums[i]
-    #         if nums[i] not in visited:
-    #             for j in range(i + 1, len(nums)):
-    #                 if nums[j] not in table:
-    #                     table[target - nums[j]] = j
-    #                 else:
-    #                     result.add((nums[i], target - nums[j], nums[j]))
-    #             visited[nums[i]] = 1
-    #     return list(result)
-
-    def solution_one(self, nums):
+    def solution_one(self, nums: list[int]) -> list[list[int]]:
         res = []
         nums.sort()
         ls = len(nums)
@@ -138,4 +89,4 @@ def solution_two(self, nums: list[int]) -> list[list[int]]:
                     while nums[ptrL] == nums[ptrL - 1] and ptrL < ptrR:
                         ptrL += 1
 
-        return triplets
+        return triplets

src/app/leetcode/three_sum.py src/app/leetcode/ltc_0015_three_sum.pysrc/app/leetcode/three_sum.py renamed to src/app/leetcode/ltc_0015_three_sum.py

@@ -0,0 +1,42 @@
+from common.list_node import ListNode
+
+"""
+Merge k sorted linked lists | https://leetcode.com/problems/merge-k-sorted-lists/
+"""
+class MergeKSortedLists(object):
+
+    def merge_k_lists(self, lists):
+        # recursive
+        if lists is None:
+            return None
+        elif len(lists) == 0:
+            return None
+        return self.merge_k(lists, 0, len(lists) - 1)
+
+    def merge_k(self, lists, low, high):
+        if low == high:
+            return lists[low]
+        elif low + 1 == high:
+            return self.merge_two_lists(lists[low], lists[high])
+        mid = (low + high) / 2
+        return self.merge_two_lists(self.mergeK(lists, low, mid), self.mergeK(lists, mid + 1, high))
+
+    def merge_two_lists(self, l1, l2):
+        if l1 is None:
+            return l2
+        if l2 is None:
+            return l1
+        head = curr = ListNode(-1)
+        while l1 is not None and l2 is not None:
+            if l1.val <= l2.val:
+                curr.next = l1
+                l1 = l1.next
+            else:
+                curr.next = l2
+                l2 = l2.next
+            curr = curr.next
+        if l1 is not None:
+            curr.next = l1
+        if l2 is not None:
+            curr.next = l2
+        return head.next

src/app/leetcode/ltc_0023_merge_k_sorted_lists.py

@@ -1,5 +1,9 @@
-class Solution:
-    def trap(self, height):
+"""
+Trapping Rain Water | https://leetcode.com/problems/trapping-rain-water/description/
+"""
+class TrappingRainWater(object):
+
+    def trap(self, height: list) -> int:
         """
         :type height: List[int]
         :rtype: int
@@ -42,35 +46,3 @@ def rain_water(self, height, start, end):
             if height[index] > 0:
                 step += height[index]
         return res - step
-
-    # def trap(self, height):
-    #     ls = len(height)
-    #     if ls == 0:
-    #         return 0
-    #     height.append(0)
-    #     height.insert(0, 0)
-    #     left = [0] * ls
-    #     right = [0] * ls
-    #     cur_left, cur_right = 0, 0
-    #     for i in range(1, ls + 1):
-    #         cur_left = max(cur_left, height[i - 1])
-    #         # left[i] store max bar from left
-    #         left[i - 1] = cur_left
-    #     for i in reversed(range(ls)):
-    #         cur_right = max(cur_right, height[i + 1])
-    #         # right[i] store max bar from right
-    #         right[i] = cur_right
-    #     res = 0
-    #     for i in range(ls):
-    #         curr = min(left[i], right[i])
-    #         if curr > height[i]:
-    #             res += curr - height[i]
-    #     return res
-
-
-if __name__ == '__main__':
-    # begin
-    s = Solution()
-    print s.trap([2,6,3,8,2,7,2,5,0])
-
-

src/app/leetcode/trapping_rain_water.py …leetcode/ltc_0042_trapping_rain_water.pysrc/app/leetcode/trapping_rain_water.py renamed to src/app/leetcode/ltc_0042_trapping_rain_water.py src/app/leetcode/trapping_rain_water.py renamed to src/app/leetcode/ltc_0042_trapping_rain_water.py

@@ -0,0 +1,22 @@
+"""
+Permutations | https://leetcode.com/problems/permutations/
+"""
+class Permutations(object):
+
+    def permute(self, nums):
+        # DPS with swapping
+        res = []
+        if len(nums) == 0:
+            return res
+        self.get_permute(res, nums, 0)
+        return res
+
+    def get_permute(self, res, nums, index):
+        if index == len(nums):
+            res.append(list(nums))
+            return
+        for i in range(index, len(nums)):
+            nums[i], nums[index] = nums[index], nums[i]
+            # s(n) = 1 + s(n-1)
+            self.get_permute(res, nums, index + 1)
+            nums[i], nums[index] = nums[index], nums[i]