[parkhojeong] WEEK 06 Solutions

container-with-most-water/parkhojeong.py

@@ -0,0 +1,20 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        i = 0
+        j = len(height) - 1
+        max_amount = 0
+
+        while i < j:
+            left_height = height[i]
+            right_height = height[j]
+
+            amount = min(left_height, right_height) * (j - i)
+            if amount > max_amount:
+                max_amount = amount
+
+            if left_height > right_height:
+                j -= 1
+            else:
+                i += 1
+
+        return max_amount

design-add-and-search-words-data-structure/parkhojeong.py

@@ -0,0 +1,89 @@
+class Node:
+    ch = ""
+    is_end = False
+    child: List[Node] = None
+    child: dict[str, Node] = None
+
+    def __init__(self, ch, is_end):
+        self.ch = ch
+        self.is_end = is_end
+        self.child = {}
+
+    def getIsEnd(self):
+        return self.is_end
+
+    def setIsEndTrue(self):
+        self.is_end = True
+
+    def getChild(self, ch) -> None:
+        if ch in self.child:
+            return self.child[ch]
+
+        return None
+
+    def getAllChild(self) -> List[Node]:
+        return self.child.values()
+
+    def addChild(self, node):
+        self.child[node.ch] = node
+
+class Trie:
+    def __init__(self):
+        self.root = Node("", False)
+
+    def addWord(self, word) -> None:
+        i = 0
+        node = self.root
+        while i < len(word):
+            ch = word[i]
+            child_node = node.getChild(ch)
+            if child_node:
+                node = child_node
+                if i == len(word) - 1:
+                    node.setIsEndTrue()
+            else:
+                is_end = True if i == len(word) - 1 else False
+                child_node = Node(ch, is_end)
+                node.addChild(child_node)
+                node = child_node
+
+            i += 1
+
+    def search(self, word: str, i, node) -> bool:
+        if word[i] == ".":
+            child_nodes = node.getAllChild()
+        else:
+            child_node = node.getChild(word[i])
+            if child_node is None:
+                return False
+            child_nodes = [child_node]
+
+        for child_node in child_nodes:
+            if i == len(word) - 1:
+                if child_node.getIsEnd() is True:
+                    return True
+                else:
+                    continue
+
+            if self.search(word, i + 1, child_node):
+                return True
+
+        return False
+
+
+class WordDictionary:
+    def __init__(self):
+        self.trie = Trie()
+
+    def addWord(self, word: str) -> None:
+        self.trie.addWord(word)
+
+    def search(self, word: str) -> bool:
+
+        return self.trie.search(word, 0, self.trie.root)
+
+
+# Your WordDictionary object will be instantiated and called as such:
+# obj = WordDictionary()
+# obj.addWord(word)
+# param_2 = obj.search(word)

longest-increasing-subsequence/parkhojeong.py

@@ -0,0 +1,14 @@
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        dp = [0] * len(nums)
+        max_count = 0
+
+        for i in range(len(nums)):
+            dp[i] = 1
+            for j in range(i):
+                if nums[j] < nums[i]:
+                    dp[i] = max(dp[j] + 1, dp[i])
+
+            max_count = max(max_count, dp[i])
+
+        return max_count

spiral-matrix/parkhojeong.py

@@ -0,0 +1,49 @@
+VISITED = '#'
+
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        row = 0
+        col = 0
+
+        visit = []
+
+        def canGo(row, col):
+            if row < 0 or row >= len(matrix) or col < 0 or col >= len(matrix[0]):
+                return False
+
+            if matrix[row][col] == VISITED:
+                return False
+
+            return True
+
+        while True:
+            if not (canGo(row, col + 1) or canGo(row + 1, col) or canGo(row, col - 1) or canGo(row - 1, col)):
+                break
+
+            while canGo(row, col + 1):
+                visit.append(matrix[row][col])
+
+                matrix[row][col] = VISITED
+                col += 1
+
+            while canGo(row + 1, col):
+                visit.append(matrix[row][col])
+
+                matrix[row][col] = VISITED
+                row += 1
+
+            while canGo(row, col - 1):
+                visit.append(matrix[row][col])
+
+                matrix[row][col] = VISITED
+                col -= 1
+
+            while canGo(row - 1, col):
+                visit.append(matrix[row][col])
+
+                matrix[row][col] = VISITED
+                row -= 1
+
+        visit.append(matrix[row][col])
+
+        return visit

valid-parentheses/parkhojeong.py

@@ -0,0 +1,26 @@
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = []
+
+        open_parenthesis_set = set({"{", "[", "("})
+        close_parenthesis_map = {
+            "]": "[",
+            ")": "(",
+            "}": "{"
+        }
+
+        for ch in s:
+            if ch in open_parenthesis_set:
+                stack.append(ch)
+            else:
+                if len(stack) == 0:
+                    return False
+
+                top = stack.pop()
+                if close_parenthesis_map[ch] != top:
+                    return False
+
+        if len(stack) > 0:
+            return False
+
+        return True