Merge pull request #300 from BEMELON/main

[BEMELON][WEEK 01](Python) 리트코드 문제 풀이

Author: leokim0922

contains-duplicate/bemelon.py

@@ -0,0 +1,10 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        # Time Complexity: O(n)
+        # Space Complexity: O(n)
+        seen = set()
+        for num in nums:
+            if num in seen:
+                return True 
+            seen.add(num)
+        return False

kth-smallest-element-in-a-bst/bemelon.py

@@ -0,0 +1,26 @@
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    """
+    Time Complexity: O(n)
+    Space Complexity: O(k)
+    """
+
+    def inOrder(self, root: TreeNode, asc_sorted_list: list[int], k: int) -> None:
+        if root.left: 
+            self.inOrder(root.left, asc_sorted_list, k)
+        
+        asc_sorted_list.append(root.val)
+
+        if len(asc_sorted_list) < k and root.right: 
+            self.inOrder(root.right, asc_sorted_list, k)
+
+    def kthSmallest(self, root: TreeNode, k: int) -> int:
+        asc_sorted_list = [] 
+        self.inOrder(root, asc_sorted_list, k)
+
+        return asc_sorted_list[k - 1]

number-of-1-bits/bemelon.py

@@ -0,0 +1,18 @@
+class Solution:
+    def hammingWeight_v1(self, n: int) -> int:
+        # Recursive solution 
+        # Time complexity: O(log n)
+        # Space complexity: O(log n) 
+        if n == 0: return 0 
+        elif n % 2 == 0: return self.hammingWeight(n // 2)
+        else: return self.hammingWeight(n // 2) + 1 
+
+    def hammingWeight(self, n: int) -> int:
+        # Iterative solution
+        # Time complexity: O(log n)
+        # Space complexity: O(1)
+        set_bit_cnt = 0 
+        while n > 0: 
+            set_bit_cnt += n & 1
+            n >>= 1
+        return set_bit_cnt

palindromic-substrings/bemelon.py

@@ -0,0 +1,49 @@
+class Solution:
+    def countSubstrings_v1(self, s: str) -> int:
+        def isPalindrome(self, substr: str) -> bool:
+            return len(substr) <= 1 or (substr[0] == substr[-1] and self.isPalindrome(substr[1:-1]))
+
+        # Brute-Force Solution - TLE 
+        count = 0
+        for l in range(1, len(s) + 1):
+            for start in range(0, len(s)):
+                if start + l > len(s): continue 
+
+                substr = s[start: start + l]
+                if (self.isPalindrome(substr)):
+                    count += 1
+        return count
+
+    def countSubstrings(self, s: str) -> int:
+        """
+        Dynamic Programming Solution
+        Time Complexity: O(N^2)
+        Space Complexity: O(N^2)
+        """
+        n = len(s)
+
+        # isPalindrome[i][j] => Palindrome at s[i:j]?
+        isPalindrome = [[False] * n for _ in range(n)] 
+        answer = 0
+        # 1. "a", "b", "c" are all Palindrome 
+        for i in range(n):
+            isPalindrome[i][i] = True 
+            answer += 1
+
+        # 2. "a{x}" are Palindrome if a == {x} 
+        for i in range(n - 1):
+            if s[i] == s[i + 1]:
+                isPalindrome[i][i + 1] = True 
+                answer += 1
+        
+        # 3. else) str[i:j] is Palindrome if str[i + 1: j - 1] ... is Palinedrome 
+        for size in range(3, n + 1):
+            for start in range(n - size + 1): 
+                end = start + size - 1
+
+                if s[start] == s[end] and isPalindrome[start + 1][end - 1]: 
+                    isPalindrome[start][end] = True
+                    answer += 1
+
+        return answer
+

top-k-frequent-elements/bemelon.py

@@ -0,0 +1,22 @@
+from collections import defaultdict
+
+class Solution:
+    def topKFrequent(self, nums: list[int], k: int) -> list[int]:
+        """
+        Time complexity: O(nlogn)
+        Space complexity: O(n)
+        """
+        if len(nums) == k:
+            return list(set(nums))
+
+        num_cnt = defaultdict(int)
+        for num in nums:
+            num_cnt[num] += 1
+
+        return list(
+            sorted(
+                num_cnt, 
+                key=lambda x: num_cnt[x], 
+                reverse=True
+            )
+        )[:k]