solve : week 2 with python

Author: changmuk.im

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

@@ -0,0 +1,84 @@
+from typing import List, Optional
+from unittest import TestCase, main
+
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        return self.solve_1(preorder, inorder)
+
+    """
+    Runtime: 112 ms (Beats 66.16%)
+    Time Complexity: O(n ** 2)
+    Space Complexity: O(n)
+    Memory: 52.83 MB (Beats 63.14%)
+    """
+    def solve_1(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        index = 0
+
+        def build_tree(preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+            nonlocal index
+
+            if not inorder:
+                return None
+
+            if not 0 <= index < len(preorder):
+                return None
+
+            root = TreeNode(preorder[index])
+            index += 1
+            split_index = inorder.index(root.val)
+            root.left = build_tree(preorder, inorder[:split_index])
+            root.right = build_tree(preorder, inorder[split_index + 1:])
+
+            return root
+
+        return build_tree(preorder, inorder)
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        preorder = [3, 9, 20, 15, 7]
+        inorder = [9, 3, 15, 20, 7]
+        output = TreeNode(
+            val=3,
+            left=TreeNode(
+                val=9
+            ),
+            right=TreeNode(
+                val=20,
+                left=TreeNode(val=15),
+                right=TreeNode(val=7)
+            )
+        )
+        self.assertEqual(Solution.buildTree(Solution(), preorder, inorder), output)
+
+    def test_2(self):
+        preorder = [-1]
+        inorder = [-1]
+        output = TreeNode(
+            val=-1
+        )
+        self.assertEqual(Solution.buildTree(Solution(), preorder, inorder), output)
+
+    def test_3(self):
+        preorder = [1, 2]
+        inorder = [1, 2]
+        output = TreeNode(
+            val=1,
+            right=TreeNode(
+                val=2
+            )
+        )
+        self.assertEqual(Solution.buildTree(Solution(), preorder, inorder), output)
+
+
+if __name__ == '__main__':
+    main()

counting-bits/EGON.py

@@ -0,0 +1,39 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        return self.solve_1(n)
+
+    """
+    Runtime: 78 ms (Beats 31.22%)
+    Time Complexity: O(n * log n), 크기가 n인 배열의 원소들에 대해 시행마다 크기가 2로 나누어지는 비트연산을 수행하므로
+    Space Complexity: O(1), 변수 저장 없이 바로 결과 반환
+    Memory: 23.26 MB (Beats 39.52%)
+    """
+    def solve_1(self, n: int) -> List[int]:
+        def count_number_of_1(n: int):
+            count = 0
+            while n:
+                n &= (n - 1)
+                count += 1
+            return count
+
+        return [count_number_of_1(num) for num in range(n + 1)]
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        n = 2
+        output = [0, 1, 1]
+        self.assertEqual(Solution.countBits(Solution(), n), output)
+
+    def test_2(self):
+        n = 5
+        output = [0, 1, 1, 2, 1, 2]
+        self.assertEqual(Solution.countBits(Solution(), n), output)
+
+
+if __name__ == '__main__':
+    main()

decode-ways/EGON.py

@@ -0,0 +1,65 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        return self.solve_1(s)
+
+    """
+    Runtime: 32 ms (Beats 80.36%)
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+    Memory: 16.59 MB (Beats 51.72%)
+    """
+    def solve_1(self, s: str) -> int:
+        if len(s) == 0:
+            return 0
+
+        if len(s) == 1:
+            return 0 if int(s) == 0 else 1
+
+        if len(s) == 2:
+            last_one_digit, last_two_digits = int(s[1]), int(s)
+            if last_one_digit == 0:
+                return 1 if 10 <= last_two_digits <= 26 else 0
+            else:
+                if 0 <= last_two_digits < 10:
+                    return 0
+                elif 10 <= last_two_digits <= 26:
+                    return 2
+                else:
+                    return 1
+
+        dp = [0] * (len(s) + 1)
+        dp[0], dp[1], dp[2] = self.solve_1(s[:0]), self.solve_1(s[:1]), self.solve_1(s[:2])
+        for i in range(3, len(s) + 1):
+            last_one_digit, last_two_digits = int(s[i - 1]), int(s[i - 2: i])
+            last_two_digits = int(s[i - 2: i])
+            if last_one_digit == 0:
+                dp[i] += dp[i - 2] if 10 <= last_two_digits <= 26 else 0
+            else:
+                dp[i] += dp[i - 1] + (dp[i - 2] if 10 <= last_two_digits <= 26 else 0)
+
+        return dp[-1]
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        s = "226"
+        output = 3
+        self.assertEqual(Solution.numDecodings(Solution(), s), output)
+
+    def test_2(self):
+        s = "2101"
+        output = 1
+        self.assertEqual(Solution.numDecodings(Solution(), s), output)
+
+    def test_3(self):
+        s = "06"
+        output = 0
+        self.assertEqual(Solution.numDecodings(Solution(), s), output)
+
+
+if __name__ == '__main__':
+    main()

encode-and-decode-strings/EGON.py

@@ -0,0 +1,116 @@
+from functools import reduce
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def encode(self, strs):
+        return self.encode_with_base64(strs)
+
+    def decode(self, str):
+        return self.decode_with_base64(str)
+
+    CSV_DELIMITER = ','
+
+    # solve_1. ASCII
+    """
+    Runtime: -
+    Time Complexity: O(n * m), n은 strs 배열의 길이, m은 strs 배열의 각 문자열들의 평균 길이
+    Space Complexity: O(n * m), n은 strs 배열의 길이, m은 encode/decode된 문자열의 평균 길이
+    Memory: -
+    """
+    def encode_with_ascii(self, strs: List[str]) -> str:
+        result = []
+        for str in strs:
+            encoded_str = reduce(
+                lambda acc, cur: acc + cur,
+                map(lambda char: f'{ord(char)}'.zfill(3), str)
+            )
+            result.append(encoded_str)
+
+        return Solution.CSV_DELIMITER.join(result)
+
+    def decode_with_ascii(self, str: str) -> List[str]:
+        encoded_strs = str.split(Solution.CSV_DELIMITER)
+        result = []
+        for encoded_str in encoded_strs:
+            decoded_str = ''
+            for i in range(0, len(encoded_str), 3):
+                chunk = encoded_str[i: i + 3]
+                decoded_str += chr(int(chunk))
+            result.append(decoded_str)
+
+        return result
+
+    # solve_2. Base64
+    """
+    Runtime: -
+    Time Complexity: O(n * m), n은 strs 배열의 길이, m은 strs 배열의 각 문자열들의 평균 길이
+    Space Complexity: O(n * m), n은 strs 배열의 길이, m은 encode/decode된 문자열의 평균 길이
+    Memory: -
+    """
+    BASE64_CHAR_TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+    def encode_with_base64(self, strs: List[str]) -> str:
+        result = []
+
+        for str in strs:
+            bin_converted_str = reduce(
+                lambda acc, cur: acc + cur,
+                map(lambda char: bin(ord(char))[2:].zfill(8), str)
+            )
+
+            encoded_str = ''
+            for i in range(0, len(bin_converted_str), 6):
+                chunk = bin_converted_str[i: i + 6].ljust(6, '0')
+                base64_char = Solution.BASE64_CHAR_TABLE[int(chunk, 2)]
+                encoded_str += base64_char
+            encoded_str.ljust(4 - (len(encoded_str) % 4), '=')
+
+            result.append(encoded_str)
+
+        return Solution.CSV_DELIMITER.join(result)
+
+    def decode_with_base64(self, str: str) -> List[str]:
+        result = []
+
+        encoded_strs = str.split(Solution.CSV_DELIMITER)
+        for encoded_str in encoded_strs:
+            encoded_str = encoded_str.rstrip('=')
+            bin_converted_str = reduce(
+                lambda acc, cur: acc + cur,
+                map(lambda char: bin(Solution.BASE64_CHAR_TABLE.index(char))[2:].zfill(6), encoded_str)
+            )
+
+            decoded_str = ''
+            for i in range(0, len(bin_converted_str), 8):
+                chunk = bin_converted_str[i: i + 8].rjust(8, '0')
+                decimal_value = int(chunk, 2)
+                if decimal_value != 0:
+                    decoded_str += chr(decimal_value)
+
+            result.append(decoded_str)
+
+        return result
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        input = ["lint", "code", "love", "you"]
+        output = ["lint", "code", "love", "you"]
+        solution = Solution()
+        encoded = Solution.encode(solution, input)
+        decoded = Solution.decode(solution, encoded)
+        self.assertEqual(decoded, output)
+
+    def test_2(self):
+        input = ["we", "say", ":", "yes"]
+        output = ["we", "say", ":", "yes"]
+        solution = Solution()
+        encoded = Solution.encode(solution, input)
+        decoded = Solution.decode(solution, encoded)
+        self.assertEqual(decoded, output)
+
+
+if __name__ == '__main__':
+    main()

valid-anagram/EGON.py

@@ -0,0 +1,53 @@
+from unittest import TestCase, main
+from collections import Counter
+
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return self.solve_1(s, t)
+
+    """
+    Runtime: 46 ms (Beats 71.98%)
+    Time Complexity: O(n)
+        - 길이가 n인 str s, str t, dict counter를 순회하므로 O(3n) ~= O(n)
+    Space Complexity: O(n)
+        - 크기가 최대 n인 dict를 변수로 저장하여 사용하므로 O(n) 
+    Memory: 16.88 MB (Beats 88.63%)
+    """
+    def solve_1(self, s: str, t: str) -> bool:
+        counter = {}
+        for char in s:
+            counter[char] = counter.get(char, 0) + 1
+        for char in t:
+            counter[char] = counter.get(char, 0) - 1
+
+        return any(counter.values()) is False
+
+    """
+    Runtime: 47 ms (Beats 67.45%)
+    Time Complexity: O(n)
+        - 크기가 n인 Counter 2개를 생성하므로 O(2n) ~= O(n)
+    Space Complexity: O(n)
+        - 크기가 n인 Counter 2개를 생성하므로 O(2n) ~= O(n)
+    Memory: 16.94 MB (Beats 46.26%)
+    """
+    def solve_2(self, s: str, t: str) -> bool:
+        return Counter(s) is Counter(t)
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        s = "anagram"
+        t = "nagaram"
+        output = True
+        self.assertEqual(Solution.isAnagram(Solution(), s, t), output)
+
+    def test_2(self):
+        s = "rat"
+        t = "car"
+        output = True
+        self.assertEqual(Solution.isAnagram(Solution(), s, t), output)
+
+
+if __name__ == '__main__':
+    main()