🎉 feat: initial commit for leetcode 94/96/98/804/832

Author: liuchuo

Swift/804. Unique Morse Code Words.swift

@@ -0,0 +1,9 @@
+// 804. Unique Morse Code Words
+// 20 ms
+let morseCode = ["a": "01", "b": "1000", "c": "1010", "d": "100", "e": "0", "f": "0010", "g": "110", "h": "0000", "i": "00", "j": "0111", "k": "101", "l": "0100", "m": "11", "n": "10", "o": "111", "p": "0110", "q": "1101", "r": "010", "s": "000", "t": "1", "u": "001", "v": "0001", "w": "011", "x": "1001", "y": "1011", "z": "1100"]
+return Set(
+        words.map { w in
+            w.reduce("") { s, c in
+                s + morseCode[String(c)]!
+            }
+        }).count

Swift/832. Flipping an Image.swift

@@ -0,0 +1,3 @@
+// 832. Flipping an Image
+// 16 ms
+return A.map({$0.map({1-$0}).reversed()})

Swift/94. Binary Tree Inorder Traversal.swift

@@ -0,0 +1,19 @@
+// 94. Binary Tree Inorder Traversal
+// 8 ms, 100%
+
+func inorderTraversal(_ root: TreeNode?) -> [Int] {
+    var list = [Int](), stack = [TreeNode](), p = root
+
+    while p != nil || !stack.isEmpty {
+        if let t = p {
+            stack.append(t)
+            p = t.left
+        } else {
+            let t = stack.popLast()!
+            list.append(t.val)
+            p = t.right
+        }
+    }
+
+    return list
+}

Swift/96. Unique Binary Search Trees.swift

@@ -0,0 +1,20 @@
+// 96. Unique Binary Search Trees
+// 8 ms
+
+func numTrees(_ n: Int) -> Int {
+    list = Array(repeating: 1, count: n+1)
+    if n >= 2 { list[2] = 2 }
+    return g(n)
+}
+
+private var list: [Int]!
+private func g(_ n: Int) -> Int {
+    if  n > 2 && list[n] == 1 {
+        list[n] = (1...n).reduce(0) { $0 + f($1, n) }
+    }
+    return list[n]
+}
+
+private func f(_ i: Int, _ n: Int) -> Int {
+    return g(i-1) * g(n-i)
+}

Swift/98. Validate Binary Search Tree.swift

@@ -0,0 +1,12 @@
+// 98. Validate Binary Search Tree
+// 28 ms, 100%
+
+func isValidBST(_ root: TreeNode?) -> Bool {
+    return isValidNode(root, Int.min, Int.max)
+}
+
+private func isValidNode(_ root: TreeNode?, _ min: Int, _ max: Int) -> Bool {
+    guard let p = root else { return true }
+    if p.val >= max || p.val <= min { return false }
+    return isValidNode(p.left, min, p.val) && isValidNode(p.right, p.val, max)
+}