update 4.3.2023

Author: ngocquanai

170. Two Sum III - Data structure design.py

@@ -0,0 +1,49 @@
+class TwoSum(object):
+
+    def __init__(self):
+        self.hashmap = dict()
+
+    def add(self, number):
+        """
+        :type number: int
+        :rtype: None
+        """
+        if number in self.hashmap :
+            self.hashmap[number] += 1
+            return
+        # ELSE
+        self.hashmap[number] = 1
+        
+
+    def find(self, value):
+        """
+        :type value: int
+        :rtype: bool
+        """
+
+        for num in self.hashmap :
+            
+            # BASE CASE : target = 2 * num
+            if value == 2 * num :
+                if self.hashmap[num] >= 2 :
+                    return True
+                continue
+            
+            if value - num in self.hashmap :
+                return True
+            
+        return False
+
+    
+
+        
+
+
+# Your TwoSum object will be instantiated and called as such:
+obj = TwoSum()
+number = 0
+obj.add(number)
+obj.add(0)
+param_2 = obj.find(0)
+    
+    

202. Happy Number.py

@@ -0,0 +1,60 @@
+class Solution(object):
+    def isHappy(self, n):
+        """
+        :type n: int
+        :rtype: bool
+        """
+
+        history_set = set() # map x -> f(x) = sum of square of digit of x
+        
+        while n != 1 :
+
+            fn = self.f(n)
+
+            if fn == 1 :
+                return True
+
+            if fn in history_set :
+                return False
+            else :
+                history_set.add(fn)
+                n = fn
+        
+        return True # when n = 1, but for some reason it was not returned in while loop
+
+    def f(self, n) :
+        digit_square = [int(i)**2 for i in list(str(n))]
+
+        return sum(digit_square)
+        
+
+## SECOND SOLUTION: USING SLOW/FAST POINTER APPROACH
+class Solution1(object):
+    def isHappy(self, n):
+        """
+        :type n: int
+        :rtype: bool
+        """
+        if n == 1 :
+            return True
+        slow = self.f(n)
+        fast = self.f(self.f(n))
+        while True :
+            if slow == 1 or fast == 1 :
+                return True
+            if slow == fast : # Therefore, exists a cycle
+                return False
+            slow = self.f(slow)
+            fast = self.f(self.f(fast))
+
+
+    def f(self, n) :
+        sum_quare = 0
+        while n > 0: 
+            sum_quare += (n % 10)** 2
+            n = n // 10
+        return sum_quare
+    
+
+obj = Solution1()
+print(obj.isHappy(n= 2))

205. Isomorphic Strings.py

@@ -23,3 +23,49 @@ def isIsomorphic(self, s, t):
 
         return True
 
+# 26.2.2024, code lại ý tưởng dùng domain-image
+class Solution1:
+    def isIsomorphic(self, s, t):
+        set_s = set(s)
+        set_t = set(t)
+
+        map_dict = dict()
+
+        for i, letter in enumerate(s) :
+            if letter not in map_dict :
+                map_dict[letter] = t[i] # map s[i] to t[i]
+        
+        # then create image of s using function map_dict, then compare with t
+        image_string = ""
+        for letter in s :
+            image_string += map_dict[letter]
+        
+        # TO ENSURE THAT THERE ARE NO 2 LETTER MAP TO THE SAME IMAGE LETTER
+        if len(map_dict.values()) > len(set(map_dict.values())) :
+            return False
+        
+        return image_string == t
+    
+obj = Solution1()
+s = "badc"
+t = "baba"
+print(obj.isIsomorphic(s, t))
+
+        
+class Solution2:
+    # IDEA: From set A and set B with the same length ==> always find a bijective function from A to B
+
+    def isIsomorphic(self, s, t):
+        set_s = set(s)
+        set_t = set(t)
+        zipped_set = set(zip(s, t))
+
+        # when len zipped_set = len set_s, it is ensure that zipped_set is a valid function
+        # (not exist x such that f(x) have 2 values)
+
+        # when len zipped_set = len set_s, it is ensure that there is no two letter map to the same letter
+
+        # when 3 length equals, zipped_set create a bijective function from s to t
+        return len(set_s) == len(set_t) == len(zipped_set)
+
+

219. Contains Duplicate II.py

@@ -0,0 +1,41 @@
+class Solution(object):
+    def containsNearbyDuplicate(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: bool
+        """
+        # NOTE: Ensure that all element in window is different
+        current_window = set(nums[:k])
+
+        n = len(nums)
+
+        # FIRST BASE CASE
+        if k >=n :
+            return len(nums) > len(set(nums))
+        
+
+        if len(set(current_window)) < k :
+            return True
+        
+        # When n >= k+1
+
+        for i in range(k, n) :
+            if nums[i] in current_window :
+                return True
+            # ELSE
+
+            current_window.add(nums[i])
+            current_window.remove(nums[i-k])
+
+
+        return False
+
+
+
+nums = [1,2,3,4,5,4,6]
+k = 10
+
+
+obj = Solution()
+print(obj.containsNearbyDuplicate(nums, k))

249. Group Shifted Strings.py

@@ -0,0 +1,41 @@
+class Solution(object):
+    def groupStrings(self, strings):
+        """
+        :type strings: List[str]
+        :rtype: List[List[str]]
+        """
+        mapping = dict()
+        mapping["a"] = []
+        for string in strings :
+
+            # BASE CASE
+            if len(string) == 1 :
+                mapping["a"].append(string)
+                continue
+
+
+            # WHEN STRING MORE THAN 1 LETTER
+
+            ord_value = self.ord_tuple(string)
+            if ord_value not in mapping :
+                mapping[ord_value] = [string]
+                continue
+
+            #ELSE
+            mapping[ord_value].append(string)
+
+        # DEAL WITH BASE CASE
+        if mapping["a"] == [] :
+            del mapping["a"]
+
+        return list(mapping.values()) 
+
+    def ord_tuple(self, string) :
+        ord_list = []
+        first_letter = string[0]
+        for letter in string :
+
+            ord_list.append( (ord(letter) - ord(first_letter)) % 26 ) # due to contraint only lowercase
+        return tuple(ord_list)
+
+        

350. Intersection of Two Arrays II.py

@@ -0,0 +1,34 @@
+class Solution(object):
+    def intersect(self, nums1, nums2):
+        """
+        :type nums1: List[int]
+        :type nums2: List[int]
+        :rtype: List[int]
+        """
+        dict1 = self.create_occur_dict(nums1)
+        dict2 = self.create_occur_dict(nums2)
+        output_dict = dict()
+        for key in dict1 :
+            if key not in dict2 :
+                continue
+            
+            output_dict[key] = min(dict1[key], dict2[key])
+
+
+        return_list = []
+        for key in output_dict :
+            return_list += [key] * output_dict[key]
+        return return_list
+            
+
+    def create_occur_dict(self, nums) :
+        my_dict = dict()
+        for num in nums :
+            if num not in my_dict :
+                my_dict[num] = 1
+            else :
+                my_dict[num] += 1
+
+
+        return my_dict
+        

359. Logger Rate Limiter.py

@@ -0,0 +1,33 @@
+class Logger(object):
+
+    def __init__(self):
+        self.time_dict = dict()
+
+        
+
+    def shouldPrintMessage(self, timestamp, message):
+        """
+        :type timestamp: int
+        :type message: str
+        :rtype: bool
+        """
+        if message not in self.time_dict :
+            self.time_dict[message] = timestamp
+            return True
+        # If exist
+        if timestamp < self.time_dict[message] + 10 : # PREVENT
+            return False
+        else :
+            # IT'S OKAYYY, update timestamp
+            self.time_dict[message] = timestamp
+            return True
+
+        
+
+
+        
+        
+        
+# Your Logger object will be instantiated and called as such:
+# obj = Logger()
+# param_1 = obj.shouldPrintMessage(timestamp,message)

36. Valid Sudoku.py

@@ -0,0 +1,46 @@
+
+class Solution(object):
+    def isValidSudoku(self, board):
+        """
+        :type board: List[List[str]]
+        :rtype: bool
+        """
+
+        row_sets = [set() for i in range(9)]
+        column_sets = [set() for i in range(9)]
+        grid_sets = [set() for i in range(9)]
+
+        for row in range(9) :
+            for column in range(9) :
+                ele = board[row][column]
+
+                if ele == "." :
+                    continue
+                # ELSE
+
+                # check for unique in row, column, grid
+
+                if ele in row_sets[row] :
+                    return False
+                else :
+                    row_sets[row].add(ele)
+
+                if ele in column_sets[column] :
+                    return False
+                else :
+                    column_sets[column].add(ele)
+                
+                grid_index =  3 * (row // 3 ) + column // 3
+
+
+                if ele in grid_sets[grid_index] :
+                    return False
+                else :
+                    grid_sets[grid_index].add(ele)
+
+                
+        return True
+
+
+
+