update 18.3.2024

Author: ngocquanai

1. Two Sum.py

@@ -25,7 +25,7 @@ def twoSum(self, nums, target):
                 return [hash_map[target - num], i]
             else : # not found target - num yet, then continue to discover, hope to see target - num in the future :)
                 hash_map[num] = i
-     
+    
 nums = [3,2,4]
 target = 6
 obj = Solution()

133. Clone Graph.py

@@ -0,0 +1,36 @@
+"""
+# Definition for a Node.
+class Node(object):
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+class Node(object):
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+
+class Solution(object):
+    def __init__(self) :
+        self.visited = {}
+
+    def cloneGraph(self, node):
+        """
+        :type node: Node
+        :rtype: Node
+        """
+        if not node :
+            return node
+        
+        if node in self.visited :
+            return self.visited[node]
+
+        clone_root = Node(node.val, [])
+        self.visited[node] = clone_root
+        neighbors = node.neighbors
+
+        clone_root.neighbors = [self.cloneGraph(i) for i in neighbors]
+        return clone_root
+        
+        

150. Evaluate Reverse Polish Notation.py

@@ -1,35 +1,103 @@
-class Solution:
-    def add(self, a, b):
-        return a + b
 
-    def subtract(self, a, b):
-        return a - b
+# class Solution:
+#     def add(self, a, b):
+#         return a + b
+
+#     def subtract(self, a, b):
+#         return a - b
+
+#     def multiple(self, a, b):
+#         return a * b
+
+#     def divide(self, a, b):
+#         return int(a / b)
+
+#     def evalRPN(self, tokens):
+#         operator = {
+#             "+": self.add,
+#             "-": self.subtract,
+#             "*": self.multiple,
+#             "/": self.divide,
+#         }
+#         stack = []
+#         for token in tokens:
+#             if token not in operator:
+#                 stack.append(int(token))
+#                 continue
+
+#             # Here token is a operator
+#             second_num = stack[-1]
+#             stack.pop()
+#             first_num = stack[-1]
+#             stack.pop()
+#             ans = operator[token](first_num, second_num)
+#             stack.append(ans)
+
+#         return stack[0]
+
 
-    def multiple(self, a, b):
-        return a * b
 
-    def divide(self, a, b):
-        return int(a / b)
 
-    def evalRPN(self, tokens):
-        operator = {
-            "+": self.add,
-            "-": self.subtract,
-            "*": self.multiple,
-            "/": self.divide,
-        }
+
+
+
+
+
+
+# UPDATE Pi Day 2024
+import math
+class Solution:
+    def evalRPN(self, tokens) :
+
+        def add(a, b) :
+            return int(a) + int(b)
+        
+        def subtract(a, b) :
+            return int(a) - int(b)
+        
+        def mul(a, b) :
+
+            return int(a) * int(b)
+        
+        def divide(a, b) :
+            if b == 0 :
+                print("ERROR")
+                return
+            
+            return math.trunc(int(a) / int(b))
+        
         stack = []
-        for token in tokens:
-            if token not in operator:
-                stack.append(int(token))
+
+        map_func = {"+": add, "-": subtract, "*": mul, "/": divide}
+
+        for token in tokens :
+            if token not in map_func :
+                stack.append(token)
                 continue
 
-            # Here token is a operator
-            second_num = stack[-1]
-            stack.pop()
-            first_num = stack[-1]
-            stack.pop()
-            ans = operator[token](first_num, second_num)
-            stack.append(ans)
+            # ELSE 
+            # Then calculate, append to the end of stack
+            second = stack.pop()
+            first = stack.pop()
+
+            ans = map_func[token](first, second)
+
+            stack.append(str(ans))
+
+        return int(stack[0])
+
+
+            
+
+
+        
+
+    
+tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
+obj = Solution()
+print(obj.evalRPN(tokens))
+
+            
+
 
-        return stack[0]
+        

155. Min Stack.py

@@ -0,0 +1,56 @@
+class MinStack(object):
+
+    def __init__(self):
+        self.min_stack = []
+        self.nums = []
+        
+
+    def push(self, val):
+        """
+        :type val: int
+        :rtype: None
+        """
+        if self.nums == [] :
+            self.min_stack.append(val)
+        else :
+            if val > self.min_stack[-1] :
+                self.min_stack.append(self.min_stack[-1])
+            else :
+                self.min_stack.append(val)
+
+        # Update nums
+        self.nums.append(val)
+
+
+        
+
+    def pop(self):
+        """
+        :rtype: None
+        """
+        remover = self.nums.pop()
+        _ = self.min_stack.pop()
+        pass
+        
+
+    def top(self):
+        """
+        :rtype: int
+        """
+        return self.nums[-1]
+        
+
+    def getMin(self):
+        """
+        :rtype: int
+        """
+        return self.min_stack[-1]
+        
+
+
+# Your MinStack object will be instantiated and called as such:
+# obj = MinStack()
+# obj.push(val)
+# obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.getMin()

20. Valid Parentheses.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def isValid(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+        marks = list(s)
+        pair = {"[": ']', "(": ')', "{": '}'}
+        open_mark = ('[', '{', '(')
+        close_mark = (']', '}', ')')
+        
+        stack = []
+
+        for mark in marks :
+            if mark in open_mark :
+                stack.append(mark)
+                continue
+
+            # ELSE mark in close
+            if stack == [] :
+                return False
+            
+            last_open = stack.pop()
+
+            if mark != pair[last_open] :
+                return False
+            # else continue
+
+        return stack == []
+            

279. Perfect Squares.py

@@ -0,0 +1,46 @@
+import math
+class Solution(object):
+    def numSquares(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        
+
+        queue = []
+        visited = set()
+        step = 0
+
+        queue.append(n)
+        visited.add(n)
+        target = 0
+
+
+        def adjacent(n) :
+            max_sqrt = int(math.sqrt(n))
+            return [n - i**2 for i in range(max_sqrt, 0, -1)]
+
+        while len(queue) > 0 :
+            for i in range(len(queue)) :
+                current = queue.pop(0)
+                visited.add(current)
+
+                if current == target :
+                    return step
+                
+                adj_list = adjacent(current)
+                for num in adj_list :
+                    if num not in visited :
+                        queue.append(num)
+                        visited.add(num)
+
+            step += 1                
+
+
+obj = Solution()
+n = int(input())
+print(obj.numSquares(n))
+
+
+
+

394. Decode String.py

@@ -0,0 +1,51 @@
+class Solution(object):
+    def decodeString(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+        stack = []
+        digits = {"0","1", "2", "3", "4", "5", "6", "7", "8", "9"}
+
+        for char in s :
+
+            if char != "]" :
+                stack.append(char)
+                continue
+
+            # ELSE when char= "]"
+            letters = ''
+            while stack[-1] != "[" :
+                letter = stack.pop()
+                letters = letter + letters
+
+
+            _ = stack.pop() # _ = "["
+
+            # begin to iterate over nums
+
+            nums = ''
+            while stack and stack[-1] in digits :
+                num = stack.pop()
+                nums = num + nums
+
+            stack.append(int(num) * letters)
+
+            print(int("".join(nums)))
+
+        return "".join(stack)
+
+
+
+s = "10[leetcode]"
+
+obj = Solution()
+print(obj.decodeString(s))
+
+
+
+
+
+            
+            
+

494. Target Sum.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def __init__(self) :
+        self.visited = {}
+    def findTargetSumWays(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        n = len(nums)
+        def find(i, target) :
+            if i == n-1 :
+                return int(nums[i] == target) + int(-nums[i] == target)
+            
+            if (i, target) in self.visited :
+                return self.visited[(i, target)]
+            
+            # ELSE
+            ans = find(i+1, target + nums[i]) + find(i+1, target - nums[i])
+            self.visited[(i, target)] = ans
+
+            return ans
+        
+        ans = find(0, target)
+        return ans
+
+nums = [1,1,1,1,1]
+obj = Solution()
+print(obj.findTargetSumWays(nums= nums, target= 3))
+