Merge pull request DaleStudy#376 from HaJunYoo/main

[HaJunYoo] Week 2

Author: HaJunYoo

construct-binary-tree-from-preorder-and-inorder-traversal/hajunyoo.py

@@ -0,0 +1,23 @@
+# Definition for a binary tree node.
+from typing import List
+
+
+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(n)
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        if not preorder or not inorder:
+            return None
+
+        val = preorder.pop(0)
+        mid = inorder.index(val)
+        left = self.buildTree(preorder, inorder[:mid])
+        right = self.buildTree(preorder, inorder[mid + 1:])
+
+        return TreeNode(val, left, right)

counting-bits/hajunyoo.py

@@ -0,0 +1,34 @@
+class Solution1:
+    # time complexity: O(n)
+    # space complexity: O(1)
+    def countBits(self, n: int) -> List[int]:
+        list = [i for i in range(n + 1)]
+        result = [bin(num).count('1') for num in list]
+        return result
+
+class Solution2:
+    # time complexity: O(n * logn)
+    # space complexity: O(1)
+    def countBits(self, n: int) -> List[int]:
+
+        def count(num):
+            cnt = 0
+            while num:
+                cnt += num % 2
+                num //= 2
+            return cnt
+
+        res = [count(i) for i in range(n+1)]
+        return res
+
+class Solution3:
+    # time complexity: O(n)
+    # space complexity: O(1)
+    def countBits(self, n: int) -> List[int]:
+        res = [0] * (n + 1)
+        msb = 1
+        for i in range(1, n + 1):
+            if i == msb * 2:
+                msb *= 2
+            res[i] = res[i - msb] + 1
+        return res

decode-ways/hajunyoo.py

@@ -0,0 +1,21 @@
+class Solution:
+    # time complexity: O(n)
+    # space complexity: O(n)
+    def numDecodings(self, s: str) -> int:
+        if not s or s.startswith('0'):
+            return 0
+
+        n = len(s)
+        dp = [0] * (n + 1)
+        dp[0] = 1
+        dp[1] = 1 if s[0] != '0' else 0
+
+        for i in range(2, n + 1):
+            if s[i - 1] != '0':
+                dp[i] += dp[i - 1]
+
+            two_digit = int(s[i - 2:i])
+            if 10 <= two_digit <= 26:
+                dp[i] += dp[i - 2]
+
+        return dp[n]

encode-and-decode-strings/hajunyoo.py

@@ -0,0 +1,31 @@
+class Solution1:
+    # time complexity: O(n)
+    # space complexity: O(1)
+    def encode(self, strs):
+        return ":;".join(strs)
+
+    # time complexity: O(n)
+    # space complexity: O(1)
+    def decode(self, str):
+        return str.split(":;")
+
+class Solution2:
+    # time complexity: O(n)
+    # space complexity: O(1)
+    def encode(self, strs):
+        txt = ""
+        for s in strs:
+            txt += str(len(s)) + ":" + s
+        return txt
+
+    # time complexity: O(n)
+    # space complexity: O(1)
+    def decode(self, str):
+        res = []
+        i = 0
+        while i < len(str):
+            colon = str.find(":", i)
+            length = int(str[i:colon])
+            res.append(str[colon + 1:colon + 1 + length])
+            i = colon + 1 + length
+        return res

valid-anagram/hajunyoo.py

@@ -0,0 +1,27 @@
+from collections import defaultdict
+
+
+class Solution:
+    # Time complexity: O(n)
+    # Space complexity: O(n)
+    def isAnagram(self, s: str, t: str) -> bool:
+        char_map = defaultdict(int)
+        for s1 in s:
+            char_map[s1] += 1
+
+        contrast_map = defaultdict(int)
+        for t1 in t:
+            contrast_map[t1] += 1
+
+        for key, val in char_map.items():
+            contrast_val = contrast_map[key]
+            if contrast_val != val:
+                return False
+
+        for key, val in contrast_map.items():
+            char_val = char_map[key]
+            if char_val != val:
+                return False
+
+        return True
+