update 11.3.2024

Author: ngocquanai

167. Two Sum II - Input Array Is Sorted.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    # BY MY SELF
+    def twoSum(self, numbers, target):
+        """
+        :type numbers: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        
+        n = len(numbers)
+        first = 0
+        second = n - 1
+        while True :
+            current = numbers[first] + numbers[second]
+
+            if current == target :
+                return [first + 1, second + 1]
+            
+            if current < target :
+                first += 1
+            
+            else : # current > target
+                second -= 1

209. Minimum Size Subarray Sum.py

@@ -0,0 +1,59 @@
+class Solution(object):
+    def minSubArrayLen(self, target, nums):
+        """
+        :type target: int
+        :type nums: List[int]
+        :rtype: int
+        """
+        n = len(nums)
+        min_len = n
+        first = 0
+        second = 0
+        current_sum = nums[0]
+        if sum(nums) < target :
+            return 0
+        while first <= n-1 :
+            # Now current_sum is the minimun possible sum start from first pointer
+            
+            # loop through second
+            while True :
+                if current_sum >= target :
+                    # satisfy the problem
+                    current_len = second - first + 1
+                    if current_sum < min_len :
+                        min_len = current_len
+                    
+                    # now break the while loop
+                    break
+
+                # ELSE current_sum < target, need more element in subarray
+                if second <= n-2 :
+                    second += 1
+                    current_sum += nums[second]
+                    current_len = second - first + 1
+                    continue
+                
+                # ELSE :
+                break
+            
+            # Check last time 
+            if current_sum >= target and current_len < min_len :
+                min_len = second - first + 1
+            
+            # move to the next index
+            current_sum -= nums[first]
+            first += 1
+
+        return min_len
+
+
+
+
+            
+
+target = 11
+nums = [1,2,3,4,5]
+obj = Solution()
+print(obj.minSubArrayLen(target, nums))
+
+

27. Remove Element.py

@@ -0,0 +1,38 @@
+class Solution(object):
+    def minSubArrayLen(self, target, nums):
+        """
+        :type target: int
+        :type nums: List[int]
+        :rtype: int
+        """
+        first = 0
+        second = len(nums) - 1
+        current_sum = sum(nums)
+        if current_sum < target :
+            return 0
+        while True :
+            if current_sum - nums[first] - nums[second] >= target :
+                current_sum = current_sum - nums[first] - nums[second]
+                first += 1
+                second -= 1
+            
+            elif current_sum - nums[first] >= target :
+                current_sum = current_sum - nums[first]
+                first += 1
+            
+            elif current_sum - nums[second] >= target :
+                current_sum = current_sum - nums[second]
+                second -= 1
+            
+            else :
+                return second - first + 1
+
+
+
+            
+nums = [2,3,1,2,4,3]
+target = 7
+
+obj = Solution()
+
+print(obj.minSubArrayLen(target, nums))

498. Diagonal Traverse.py

@@ -0,0 +1,37 @@
+class Solution(object):
+    def findDiagonalOrder(self, mat):
+        """
+        :type mat: List[List[int]]
+        :rtype: List[int]
+        """
+        m = len(mat)
+        n = len(mat[0])
+        max_diagonal = m - 1 + n - 1
+        travel_order = []
+
+
+
+        for line in range(max_diagonal + 1) :
+            
+            # ODD LINE, then column decrease
+            if line % 2 == 1 :
+                # PROVE: 
+                # 0 <= row <= m - 1
+                # 0 >= -row >= - (m - 1)
+                # line >= line - row = column >= line - (m-1)
+                # Then we iterate column from min(line, n - 1) to max(0, line - (m - 1) )
+                for column in range(min(line, n - 1), max(0, line - (m-1)) - 1, -1) :
+                    row = line - column
+                    ele = mat[row][column]
+
+                    travel_order.append(ele)
+
+            else :
+            # EVEN LINE, then row decrease
+                for row in range(min(line, m - 1), max(0, line - (n-1)) - 1, -1) :
+                    column = line - row
+                    ele = mat[row][column]
+                    travel_order.append(ele)
+
+        return travel_order
+           

54. Spiral Matrix.py

@@ -0,0 +1,42 @@
+class Solution(object):
+    def spiralOrder(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: List[int]
+        """
+        # IDEA: When travel 1 round with 4 edge of matrix, the remaining way is the same as the full way of the (m-2) * (n-2) matrix
+
+        # Then we have 4 base case: 1 row, n-m + 1 column; 2 row, n-m+2 column; m-n+1 row, 1 column; m-n+2 row, 2 column
+        m = len(matrix)
+        n = len(matrix[0])
+
+        if m == 1 :
+            return matrix[0]
+        elif m == 2 :
+            return matrix[0] + list(reversed(matrix[1]))
+        
+        elif n == 1 : # 1 column
+            element = [i[0] for i in matrix]
+            return element
+        
+        elif n == 2 : # and m > 2 
+            first_row = [i[0] for i in matrix]
+            second_row = [i[1] for i in matrix]
+
+            return [first_row[0], second_row[0]] + second_row[1: -1] + [second_row[-1], first_row[-1]] + list(reversed(first_row[1: -1]) )
+
+        else :
+            last_row = [i[-1] for i in matrix]
+            first_row = [i[0] for i in matrix]
+
+            outer_element = matrix[0] + last_row[1: -1] + list(reversed(matrix[-1]) )+ list(reversed(first_row[1: -1]) )
+
+            del matrix[0]
+            del matrix[-1]
+
+            for r in matrix :
+                del r[0]
+                del r[-1]
+            
+            return outer_element + self.spiralOrder(matrix)
+        

561. Array Partition.py

@@ -0,0 +1,15 @@
+class Solution(object):
+    def arrayPairSum(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        sorted_num = sorted(nums)
+        
+        return sum(sorted_num[0: len(nums) : 2])
+    
+# PROVE:
+# 2n number (a1,b1),...,(an, bn), such that ai <= bi
+# So maximize sum(ai) means minimize sum (bi-ai) due to sum of 2n nums is constant, then
+# 2 sum(ai) = sum (ai + ai) = sum (ai + bi - (bi - ai) ) = const - sum(bi -ai)
+# Then we can prove that the optimal sum is as code above

622. Design Circular Queue.py

@@ -0,0 +1,87 @@
+class MyCircularQueue(object):
+
+    def __init__(self, k):
+        """
+        :type k: int
+        """
+        self.data = [None]* k # k-element list
+        self.k = k
+        self.head = -1
+        self.tail = -1
+        # When both head and tail = -1, mean empty Queue
+        
+
+    def enQueue(self, value):
+        """
+        :type value: int
+        :rtype: bool
+        """
+        if self.isFull() :
+            return False
+        if self.isEmpty() :
+            self.tail = 0
+            self.head = 0
+            self.data[0] = value
+            return True        
+        #ELSE
+        self.tail = (self.tail + 1) % self.k
+        self.data[self.tail] = value
+
+        return True
+        
+
+    def deQueue(self):
+        """
+        :rtype: bool
+        """
+        if self.isEmpty() :
+            return False
+        
+        #ELSE
+
+        if self.head == self.tail :
+            # After removing, become empty queue
+            self.tail = -1
+            self.head = -1
+            return True
+
+        self.head = (self.head + 1) % self.k
+        return True
+        
+        
+            
+        
+
+    def Front(self):
+        """
+        :rtype: int
+        """
+        if self.isEmpty() :
+            return -1
+        return self.data[self.head]
+        
+
+    def Rear(self):
+        """
+        :rtype: int
+        """
+        if self.isEmpty() :
+            return -1
+        return self.data[self.tail]
+        
+
+    def isEmpty(self):
+        """
+        :rtype: bool
+        """
+        return (self.head == -1 and self.tail == -1)
+        
+
+    def isFull(self):
+        """
+        :rtype: bool
+        """
+        return (self.head == (self.tail + 1) % self.k) 
+        
+
+

66. Plus One.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def plusOne(self, digits):
+        """
+        :type digits: List[int]
+        :rtype: List[int]
+        """
+        n = len(digits)
+        if len(digits) == 1 :
+            if digits[0] == 9 :
+                return [1, 0]
+            else :
+                return [digits[0] + 1]
+        
+        if digits[-1] != 9 :
+            
+            digits[-1] = digits[-1] + 1
+            return digits
+        else :
+            return self.plusOne(digits[:-1]) + [0]
+