SAVE

Author: changmuk.im

climbing-stairs/EGON.py

@@ -0,0 +1,47 @@
+from unittest import TestCase, main
+
+
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        return self.solveWithDP(n)
+
+    """
+    Runtime: 30 ms (Beats 83.62%)
+    Time Complexity: O(n)
+        > 3에서 n + 1 까지 range를 조회하였으므로 O((n + 1) - 3) ~= O(n)
+
+    Memory: 16.39 MB (Beats 90.15%)
+    Space Complexity: O(n)
+        > 크기가 n + 1인 dp를 선언하여 사용했으므로 O(n + 1) ~= O(n)
+    """
+    def solveWithDP(self, n: int) -> int:
+        if n <= 2:
+            return n
+
+        dp = [0] * (n + 1)
+        dp[0], dp[1], dp[2] = 0, 1, 2
+        for stair in range(3, n + 1):
+            dp[stair] = dp[stair - 1] + dp[stair - 2]
+
+        return dp[n]
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        n = 2
+        output = 2
+        self.assertEqual(Solution.climbStairs(Solution(), n), output)
+
+    def test_2(self):
+        n = 3
+        output = 3
+        self.assertEqual(Solution.climbStairs(Solution(), n), output)
+
+    def test_3(self):
+        n = 1
+        output = 1
+        self.assertEqual(Solution.climbStairs(Solution(), n), output)
+
+
+if __name__ == '__main__':
+    main()

coin-change/EGON.py

@@ -0,0 +1,63 @@
+from typing import List
+from unittest import TestCase, main
+from collections import defaultdict
+
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        return self.solve_with_dfs(coins, amount)
+
+    """
+    Runtime: 2039 ms (Beats 5.01%)
+    Time Complexity: ?
+
+    Memory: 16.81 MB (Beats 11.09%)
+    Space Complexity: ?
+    """
+
+    # TIME LIMIT
+    def solve_with_dfs(self, coins: List[int], amount: int) -> int:
+        if amount == 0:
+            return 0
+
+        result = float('INF')
+        stack = []
+        for coin in coins:
+            stack.append([[coin], coin])
+        while stack:
+            curr_coins, curr_amount = stack.pop()
+
+            if amount < curr_amount:
+                continue
+
+            if curr_amount == amount:
+                result = min(result, len(curr_coins))
+
+            for coin in coins:
+                stack.append([curr_coins + [coin], curr_amount + coin])
+
+        return -1 if result == float('INF') else result
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        coins = [1, 2, 5]
+        amount = 11
+        output = 3
+        self.assertEqual(Solution.coinChange(Solution(), coins, amount), output)
+
+    def test_2(self):
+        coins = [2]
+        amount = 3
+        output = -1
+        self.assertEqual(Solution.coinChange(Solution(), coins, amount), output)
+
+    def test_3(self):
+        coins = [1]
+        amount = 0
+        output = 0
+        self.assertEqual(Solution.coinChange(Solution(), coins, amount), output)
+
+
+if __name__ == '__main__':
+    main()

combination-sum/EGON.py

@@ -0,0 +1,63 @@
+from typing import List
+from unittest import TestCase, main
+from collections import defaultdict
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        return self.solve_with_dfs(candidates, target)
+
+    """
+    Runtime: 2039 ms (Beats 5.01%)
+    Time Complexity: ?
+
+    Memory: 16.81 MB (Beats 11.09%)
+    Space Complexity: ?
+    """
+    def solve_with_dfs(self, candidates: List[int], target: int) -> List[List[int]]:
+        result = []
+        stack = []
+        visited = defaultdict(bool)
+        for candidate in candidates:
+            stack.append([[candidate], candidate])
+
+        while stack:
+            curr_combination, curr_sum = stack.pop()
+            curr_visited_checker = tuple(sorted(curr_combination))
+
+            if curr_sum == target and visited[curr_visited_checker] is False:
+                visited[curr_visited_checker] = True
+                result.append(curr_combination)
+
+            if target < curr_sum:
+                continue
+
+            for candidate in candidates:
+                post_combination, post_sum = curr_combination + [candidate], curr_sum + candidate
+                stack.append([post_combination, post_sum])
+
+        return result
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        candidates = [2, 3, 6, 7]
+        target = 7
+        output = [[2, 2, 3], [7]]
+        self.assertEqual(Solution.combinationSum(Solution(), candidates, target), output)
+
+    def test_2(self):
+        candidates = [2, 3, 5]
+        target = 8
+        output = [[2, 2, 2, 2], [2, 3, 3], [3, 5]]
+        self.assertEqual(Solution.combinationSum(Solution(), candidates, target), output)
+
+    def test_3(self):
+        candidates = [2]
+        target = 1
+        output = []
+        self.assertEqual(Solution.combinationSum(Solution(), candidates, target), output)
+
+
+if __name__ == '__main__':
+    main()

product-of-array-except-self/EGON.py

@@ -0,0 +1,45 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        return self.solve_with_no_extra_space(nums)
+
+    """
+    Runtime: 290 ms (Beats 12.23%)
+    Time Complexity: O(n)
+        - 1부터 n까지 순회했으므로 O(n - 1)
+        - 1부터 n + 1 까지 순회했으므로 O(n)
+        > O(n - 1) + O(n) ~= O(2n) ~= O(n)
+
+    Memory: 25.68 MB (Beats 83.82%)
+    Space Complexity: O(n)
+        > 크기가 n + 2인 배열 2개를 사용했으므로 O(2 * (n + 2)) ~= O(n)
+    """
+    def solve_with_prefix_and_suffix(self, nums: List[int]) -> List[int]:
+        forward_product = nums[:]
+        reverse_product = nums[:]
+        for i in range(1, len(nums)):
+            forward_product[i] *= forward_product[i - 1]
+            reverse_product[len(nums) - i - 1] *= reverse_product[len(nums) - i]
+        forward_product = [1] + forward_product + [1]
+        reverse_product = [1] + reverse_product + [1]
+
+        return [forward_product[i - 1] * reverse_product[i + 1] for i in range(1, len(nums) + 1)]
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        nums = [1, 2, 3, 4]
+        output = [24, 12, 8, 6]
+        self.assertEqual(Solution.productExceptSelf(Solution(), nums), output)
+
+    def test_2(self):
+        nums = [-1, 1, 0, -3, 3]
+        output = [0, 0, 9, 0, 0]
+        self.assertEqual(Solution.productExceptSelf(Solution(), nums), output)
+
+
+if __name__ == '__main__':
+    main()

two-sum/EGON.py

@@ -0,0 +1,87 @@
+from typing import List
+from unittest import TestCase, main
+from collections import defaultdict
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        return self.solveWithMemoization(nums, target)
+
+    """
+    Runtime: 3762 ms (Beats 5.00%)
+    Time Complexity: O(n ** 2)
+        - 크기가 n인 nums 배열을 2중으로 조회하므로 O(n ** 2)
+
+    Memory: 17.42 MB (Beats 61.58%)
+    Space Complexity: ?
+    """
+    def solveWithBruteForce(self, nums: List[int], target: int) -> List[int]:
+        for i in range(len(nums)):
+            for j in range(len(nums)):
+                if i != j and nums[i] + nums[j] == target:
+                    return [i, j]
+
+    """
+    Runtime: 52 ms (Beats 89.73%)
+    Time Complexity: O(n)
+        1. nums 배열을 돌며 idx를 저장하는 dict 생성에 O(n)
+        2. 첫 숫자를 선택하기 위해 len(nums)를 for문으로 조회하는데 O(n)
+        > O(2n) ~= O(n)
+
+    Memory: 19.96 MB (Beats 8.42%)
+    Space Complexity: O(n)
+        - 크기가 n인 defaultdict 변수 사용
+    """
+    def solveWithMemoization(self, nums: List[int], target: int) -> List[int]:
+        num_to_idx_dict = defaultdict(list)
+        for idx, num in enumerate(nums):
+            num_to_idx_dict[num].append(idx)
+
+        for i in range(len(nums)):
+            first_num = nums[i]
+            second_num = target - nums[i]
+
+            if first_num != second_num:
+                if not (len(num_to_idx_dict[first_num]) and len(num_to_idx_dict[second_num])):
+                    continue
+            else:
+                if not (2 <= len(num_to_idx_dict[first_num])):
+                    continue
+
+            first_idx = num_to_idx_dict[first_num].pop()
+            second_idx = num_to_idx_dict[second_num].pop()
+
+            if first_num != second_num:
+                return [first_idx, second_idx]
+            else:
+                return [second_idx, first_idx]
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        nums = [2, 7, 11, 15]
+        target = 9
+        output = [0, 1]
+        self.assertEqual(Solution.twoSum(Solution(), nums, target), output)
+
+    def test_2(self):
+        nums = [3,2,4]
+        target = 6
+        output = [1, 2]
+        self.assertEqual(Solution.twoSum(Solution(), nums, target), output)
+
+    def test_3(self):
+        nums = [3, 3]
+        target = 6
+        output = [0, 1]
+        self.assertEqual(Solution.twoSum(Solution(), nums, target), output)
+
+    def test_4(self):
+        nums = [3, 2, 3]
+        target = 6
+        output = [0, 2]
+        self.assertEqual(Solution.twoSum(Solution(), nums, target), output)
+
+
+if __name__ == '__main__':
+    main()