Merge pull request #433 from lymchgmk/feat/week4

[EGON] Week 4 Solutions

longest-consecutive-sequence/EGON.py

@@ -0,0 +1,66 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+ def longestConsecutive(self, nums: List[int]) -> int:
+ return self.solveWithDict(nums)
+
+ """
+ Runtime: 486 ms (Beats 40.61%)
+ Time Complexity:
+ - nums 배열 조회하며 연산에 O(n)
+ - 크기가 n인 node_dict.items()을 조회, visited에 의해 각 노드당 한 번만 방문,
+ - visited가 set이므로 갱신 및 확인에 O(1)
+ - 2개 항에 대해 max 연산하므로 O(2)로, 총 O(n)
+ > O(n) + O(n) ~= O(n)
+
+ Memory: 44.62 MB (Beats 5.00%)
+ Space Complexity: O(n)
+ - value가 크기 2짜리 배열이고 key가 최대 n인 dict 변수 사용에 O(2n)
+ - 최대 크기가 n인 visited 사용에 O(n)
+ > O(2n) + O(n) ~= O(n)
+ """
+ def solveWithDict(self, nums: List[int]) -> int:
+ node_dict = {}
+ for num in nums:
+ curr_node = [num, num]
+ if num - 1 in node_dict:
+ prev_node = node_dict[num - 1]
+ curr_node[0] = prev_node[0]
+ prev_node[1] = curr_node[1]
+ if num + 1 in node_dict:
+ post_node = node_dict[num + 1]
+ curr_node[1] = post_node[1]
+ post_node[0] = curr_node[0]
+ node_dict[num] = curr_node
+
+ max_length = 0
+ visited = set()
+ for key, (prev_key, post_key) in node_dict.items():
+ while prev_key not in visited and prev_key in node_dict:
+ visited.add(prev_key)
+ prev_key = node_dict[prev_key][0]
+ while post_key not in visited and post_key in node_dict:
+ visited.add(post_key)
+ post_key = node_dict[post_key][1]
+ curr_length = post_key - prev_key + 1
+ max_length = max(max_length, curr_length)
+
+ return max_length
+
+
+class _LeetCodeTestCases(TestCase):
+ def test_1(self):
+ nums = [100, 4, 200, 1, 3, 2]
+ output = 4
+ self.assertEqual(Solution.longestConsecutive(Solution(), nums), output)
+
+ def test_2(self):
+ nums = [0, 3, 7, 2, 5, 8, 4, 6, 0, 1]
+ output = 9
+ self.assertEqual(Solution.longestConsecutive(Solution(), nums), output)
+
+
+if __name__ == '__main__':
+ main()

maximum-subarray/EGON.py

@@ -0,0 +1,67 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+ def maxProduct(self, nums: List[int]) -> int:
+ return self.solveWithDP(nums)
+
+ """
+ Runtime: 71 ms (Beats 61.13%)
+ Time Complexity: O(n)
+ - dp 배열 초기화를 위한 nums.copy()에 O(n)
+ - range(1, L) 조회하며 조건에 따라 연산에 O(n - 1)
+ - range(L) 조회하며 max 계산에 O(n)
+ > O(n) + O(n - 1) + O(n) ~= O(n)
+
+ Memory: 17.75 MB (Beats 11.09%)
+ Space Complexity: O(n)
+ - 크기가 n인 배열 2개 사용했으므로 2 * O(n)
+ > O(2n) ~= O(n)
+ """
+ def solveWithDP(self, nums: List[int]) -> int:
+ L = len(nums)
+ forward_product, backward_product = nums.copy(), nums.copy()
+ for i in range(1, L):
+ if forward_product[i - 1] != 0:
+ forward_product[i] *= forward_product[i - 1]
+
+ if backward_product[L - i] != 0:
+ backward_product[L - i - 1] *= backward_product[L - i]
+
+ result = nums[0]
+ for i in range(L):
+ result = max(result, forward_product[i], backward_product[i])
+
+ return result
+
+
+class _LeetCodeTestCases(TestCase):
+ def test_1(self):
+ nums = [2,3,-2,4]
+ output = 6
+ self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+ def test_2(self):
+ nums = [-2,0,-1]
+ output = 0
+ self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+ def test_3(self):
+ nums = [-2]
+ output = -2
+ self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+ def test_4(self):
+ nums = [0,-3,-2,-3,-2,2,-3,0,1,-1]
+ output = 72
+ self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+ def test_5(self):
+ nums = [7, -2, -4]
+ output = 56
+ self.assertEqual(Solution.maxProduct(Solution(), nums), output)
+
+
+if __name__ == '__main__':
+ main()

missing-number/EGON.py

@@ -0,0 +1,48 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+ def missingNumber(self, nums: List[int]) -> int:
+ return self.solveWithSet(nums)
+
+ """
+ Runtime: 118 ms (Beats 31.19%)
+ Time Complexity:
+ - 크기가 n + 1인 List를 set로 변환에 O(n + 1)
+ - nums 배열 조회하며 set.remove에 O(n) * O(1) ~= O(n)
+ - 마지막 set에서 pop하는데 O(1)
+ > O(n + 1) + O(n) + O(1) ~= O(n)
+
+ Memory: 18.56 MB (Beats 5.%)
+ Space Complexity:
+ - 크기가 n + 1인 set 사용에 O(n + 1)
+ > O(n + 1) ~= O(n)
+ """
+ def solveWithSet(self, nums: List[int]) -> int:
+ range_set = set(range(0, len(nums) + 1))
+ for num in nums:
+ range_set.remove(num)
+
+ return range_set.pop()
+
+
+class _LeetCodeTestCases(TestCase):
+ def test_1(self):
+ nums = [3, 0, 1]
+ output = 2
+ self.assertEqual(Solution.missingNumber(Solution(), nums), output)
+
+ def test_2(self):
+ nums = [0, 1]
+ output = 2
+ self.assertEqual(Solution.missingNumber(Solution(), nums), output)
+
+ def test_3(self):
+ nums = [9, 6, 4, 2, 3, 5, 7, 0, 1]
+ output = 8
+ self.assertEqual(Solution.missingNumber(Solution(), nums), output)
+
+
+if __name__ == '__main__':
+ main()

valid-palindrome/EGON.py

@@ -0,0 +1,52 @@
+from unittest import TestCase, main
+
+
+class Solution:
+ def isPalindrome(self, s: str) -> bool:
+ return self.solveWithTwoPointer(s)
+
+ """
+ Runtime: 43 ms (Beats 68.60%)
+ Time Complexity: O(n)
+ - s 문자열 iterable 조회하며 연산에 O(n)
+ - range(0, length // 2) 조회에 O(n // 2)
+ > O(n) + O(n // 2) ~= O(n)
+
+ Memory: 17.02 MB (Beats 54.30%)
+ Space Complexity: O(n)
+ - 최대 크기가 n인 trimmed_s 변수 할당에 O(n)
+ > O(n)
+ """
+ def solveWithPointer(self, s: str) -> bool:
+ trimmed_s = ""
+ for char in s:
+ if char.isalpha() or char.isnumeric():
+ trimmed_s += char.lower()
+
+ length = len(trimmed_s)
+ for i in range(0, length // 2):
+ if trimmed_s[i] != trimmed_s[length - i - 1]:
+ return False
+ else:
+ return True
+
+
+class _LeetCodeTestCases(TestCase):
+ def test_1(self):
+ s = "A man, a plan, a canal: Panama"
+ output = True
+ self.assertEqual(Solution.isPalindrome(Solution(), s), output)
+
+ def test_2(self):
+ s = "race a car"
+ output = False
+ self.assertEqual(Solution.isPalindrome(Solution(), s), output)
+
+ def test_3(self):
+ s = " "
+ output = True
+ self.assertEqual(Solution.isPalindrome(Solution(), s), output)
+
+
+if __name__ == '__main__':
+ main()

word-search/EGON.py

@@ -0,0 +1,80 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+ def exist(self, board: List[List[str]], word: str) -> bool:
+ return self.solveWithDFS(board, word)
+
+ """
+ Runtime: 5005 ms (Beats 27.48%)
+ Time Complexity: O((MAX_R ** 2) * (MAX_C ** 2)), upper bound
+ - 이중 for문 조회에 O(MAX_R * MAX_C)
+ - node 하나당 조회하는 DIRS의 크기가 4이고, 최대 word의 길이만큼 반복하므로 O(4 * L)
+ - 단 early return하므로 이는 upper bound
+ > O(MAX_R * MAX_C) * O(4L) ~= O(MAX_R * MAX_C * L)
+
+ Memory: 16.59 MB (Beats 69.71%)
+ Space Complexity:
+ - MAX_R * MAX_C 격자의 칸마다 stack이 생성될 수 있으므로 O(MAX_R * MAX_C)
+ - node의 크기는 visited에 지배적이고(curr_word 무시 가정), visited의 크기는 최대 L
+ > O(MAX_R * MAX_C) * O(L) ~= O(MAX_R * MAX_C * L)
+ """
+ def solveWithDFS(self, board: List[List[str]], word: str) -> bool:
+ MAX_R, MAX_C, MAX_IDX = len(board), len(board[0]), len(word)
+ DIRS = ((-1, 0), (1, 0), (0, -1), (0, 1))
+
+ for r in range(MAX_R):
+ for c in range(MAX_C):
+ if board[r][c] == word[0]:
+ stack = [(r, c, 0, board[r][c], set([(r, c)]))]
+ while stack:
+ curr_r, curr_c, curr_idx, curr_word, curr_visited = stack.pop()
+
+ if curr_word == word:
+ return True
+
+ for dir_r, dir_c in DIRS:
+ post_r, post_c, post_idx = curr_r + dir_r, curr_c + dir_c, curr_idx + 1
+ if (post_r, post_c) in curr_visited:
+ continue
+ if not (0 <= post_r < MAX_R and 0 <= post_c < MAX_C):
+ continue
+ if not (post_idx < MAX_IDX and board[post_r][post_c] == word[post_idx]):
+ continue
+
+ post_visited = curr_visited.copy()
+ post_visited.add((post_r, post_c))
+ stack.append((post_r, post_c, post_idx, curr_word + word[post_idx], post_visited))
+
+ return False
+
+
+class _LeetCodeTestCases(TestCase):
+ def test_1(self):
+ board = [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]]
+ word = "ABCCED"
+ output = True
+ self.assertEqual(Solution.exist(Solution(), board, word), output)
+
+ def test_2(self):
+ board = [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]]
+ word = "SEE"
+ output = True
+ self.assertEqual(Solution.exist(Solution(), board, word), output)
+
+ def test_3(self):
+ board = [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]]
+ word = "ABCB"
+ output = False
+ self.assertEqual(Solution.exist(Solution(), board, word), output)
+
+ def test_4(self):
+ board = [["A","B","C","E"],["S","F","E","S"],["A","D","E","E"]]
+ word = "ABCESEEEFS"
+ output = True
+ self.assertEqual(Solution.exist(Solution(), board, word), output)
+
+
+if __name__ == '__main__':
+ main()