[sonjh1217] WEEK 06 solutions

container-with-most-water/sonjh1217.swift

@@ -0,0 +1,27 @@
+class Solution {
+    func maxArea(_ height: [Int]) -> Int {
+        var heights = height
+        var start = 0
+        var end = heights.count - 1
+        var maxAmount = 0
+
+        while start < end {
+            let startHeight = heights[start]
+            let endHeight = heights[end]
+            let amount = min(startHeight, endHeight) * (end - start)
+            maxAmount = max(amount, maxAmount)
+
+            if startHeight < endHeight {
+                start += 1
+            } else {
+                end -= 1
+            }
+        }
+
+        return maxAmount
+
+        //시간 O(n)
+        //공간 O(1)
+    }
+}
+

design-add-and-search-words-data-structure/sonjh1217.swift

@@ -0,0 +1,55 @@
+class WordDictionary {
+    class TrieNode {
+        var children: [Character: TrieNode] = [:]
+        var isEndOfWord = false
+    }
+
+    private var root: TrieNode
+
+    init() {
+        root = TrieNode()
+    }
+
+    // O(n) time / O(n) space
+    func addWord(_ word: String) {
+        var node = root
+
+        for character in word {
+            if node.children[character] == nil {
+                node.children[character] = TrieNode()
+            }
+
+            node = node.children[character]!
+        }
+
+        node.isEndOfWord = true
+    }
+
+    // O(m) ~ O(26^m) time / O(1) space
+    func search(_ word: String) -> Bool {
+        return dfs(word: Array(word), index: 0, node: root)
+    }
+
+    private func dfs(word: [Character], index: Int, node: TrieNode) -> Bool {
+        if index == word.count {
+            return node.isEndOfWord
+        }
+
+        let character = word[index]
+
+        if character == "." {
+            for child in node.children.values {
+                if dfs(word: word, index: index + 1, node: child) {
+                    return true
+                }
+            }
+            return false
+        } else {
+            guard let child = node.children[character] else {
+                return false
+            }
+            return dfs(word: word, index: index + 1, node: child)
+        }
+    }
+}
+

group-anagrams/sonjh1217.swift

@@ -2,7 +2,7 @@ class Solution {
     func groupAnagrams(_ strs: [String]) -> [[String]] {
         var stringsByCount = [[Int]: [String]]()
 
-        strs.map { str in
+        strs.forEach { str in
             var countsByAlphabet = Array(repeating: 0, count: 26)
             for char in str.unicodeScalars {
                 countsByAlphabet[Int(char.value) - 97] += 1

valid-parentheses/sonjh1217.swift

@@ -0,0 +1,22 @@
+class Solution {
+    func isValid (_ s: String) -> Bool {
+        var brackets: [Character: Character] = ["(": ")", "[": "]", "{": "}"]
+        var closers = [Character]()
+
+        for character in s {
+            if let closer = brackets[character] {
+                closers.append(closer)
+            } else if character == closers.last {
+                closers.removeLast()
+            } else {
+                return false
+            }
+        }
+
+        return closers.isEmpty
+
+        //시간 O(n) (string의 길이)
+        //공간 O(n)
+    }
+}
+