New updates are coming in

Author: Michael Ho

Easy/0110-BalancedBinaryTree.playground/Contents.swift

@@ -0,0 +1,70 @@
+// Leetcode: https://leetcode.com/problems/balanced-binary-tree/
+
+import XCTest
+
+public class TreeNode {
+    public var val: Int
+    public var left: TreeNode?
+    public var right: TreeNode?
+    public init(_ val: Int) {
+        self.val = val
+        self.left = nil
+        self.right = nil
+    }
+}
+
+class Solution {
+    func isBalanced(_ root: TreeNode?) -> Bool {
+        return false
+    }
+    
+    private func getTreeHeight(_ node: TreeNode?) {
+        
+    }
+}
+
+class Tests: XCTestCase {
+    func testSample1() {
+        let arr = [3, 9, 20, nil, nil, 15, 7]
+        let root = convertArrToTree(arr)
+        inOrderPrint(root)
+    }
+    
+    private func convertArrToTree(_ arr: [Int?]) -> TreeNode? {
+        guard arr.count > 0 else {
+            return nil
+        }
+        let root = TreeNode(arr[0]!)
+        convert(0, root, arr)
+        return root
+    }
+    
+    private func convert(_ index: Int, _ root: TreeNode?, _ arr: [Int?]) {
+        guard let root = root, index*2 + 2 < arr.count else { return }
+        
+        if let leftVal = arr[index*2+1] {
+            root.left = TreeNode(leftVal)
+            convert(index*2+1, root.left, arr)
+        }
+        
+        if let rightVal = arr[index*2+2] {
+            root.right = TreeNode(rightVal)
+            convert(index*2+2, root.right, arr)
+        }
+    }
+    
+    func inOrderPrint(_ root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        if let left = root.left {
+            inOrderPrint(left)
+        }
+        print(root.val)
+        if let right = root.right {
+            inOrderPrint(right)
+        }
+    }
+}
+
+Tests.defaultTestSuite.run()

Easy/0110-BalancedBinaryTree.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='ios' executeOnSourceChanges='false'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Easy/0501-FindModeInBST.playground/Contents.swift

@@ -0,0 +1,47 @@
+// LeetCode: https://leetcode.com/problems/find-mode-in-binary-search-tree/
+
+public class TreeNode {
+    public var val: Int
+    public var left: TreeNode?
+    public var right: TreeNode?
+    public init(_ val: Int) {
+        self.val = val
+        self.left = nil
+        self.right = nil
+    }
+}
+
+class Solution {
+    func findMode(_ root: TreeNode?) -> [Int] {
+        guard let root = root else { return [] }
+        var dict: [Int:Int] = [:]
+        var max = 0
+        findMode(root, &dict, &max)
+        
+        var output = [Int]()
+        for i in dict.keys {
+            if let val = dict[i], val == max {
+                output.append(i)
+            }
+        }
+        return output
+    }
+    
+    private func findMode(_ root: TreeNode, _ dict: inout [Int:Int], _ max: inout Int) {
+        if let val = dict[root.val] {
+            dict[root.val] = val + 1
+            max = val + 1 > max ? val + 1 : max
+        } else {
+            dict[root.val] = 1
+            max = 1 > max ? 1 : max
+        }
+        
+        if let left = root.left {
+            findMode(left, &dict, &max)
+        }
+        
+        if let right = root.right {
+            findMode(right, &dict, &max)
+        }
+    }
+}

Easy/0001-TwoSum.playground/contents.xcplayground renamed to Easy/0501-FindModeInBST.playground/contents.xcplayground

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<playground version='5.0' target-platform='ios'>
+<playground version='5.0' target-platform='macos'>
     <timeline fileName='timeline.xctimeline'/>
 </playground>

Easy/0001-TwoSum.playground/Contents.swift renamed to Easy/EasyProblems.playground/Contents.swift

@@ -1,7 +1,7 @@
 // LeetCode: https://leetcode.com/problems/two-sum/description/
 // Solution: https://github.com/zhubofei/LeetCode-Swift/blob/master/0001-two-sum.playground/Contents.swift
 
-func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+public func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
     var dict: [Int: Int] = [:] // [number : indexPosition]
     for (index, num) in nums.enumerated() {
         let complement = target - num

Easy/EasyProblems.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='macos'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Medium/0003-LongestSubstringWithoutRepeatingCharacters.playground/Contents.swift

@@ -4,27 +4,51 @@
 import XCTest
 
 class Solution {
+//    func lengthOfLongestSubstring(_ s: String) -> Int {
+//        guard s.count > 0 else {
+//            return 0
+//        }
+//
+//        var maxCount = 1
+//        if s.count == 1 {
+//            return maxCount
+//        }
+//        let strArr = Array(s) // Key: convert string to array
+//        for (index, char) in strArr.enumerated() {
+//            var dict: [Character : Int] = [:]
+//            var count = 1
+//            dict[char] = 1
+//            var movingIdx = index + 1
+//            while movingIdx < strArr.count, dict[strArr[movingIdx]] ?? 0 < 1 {
+//                dict[strArr[movingIdx]] = 1
+//                count += 1
+//                movingIdx += 1
+//            }
+//            maxCount = count > maxCount ? count : maxCount
+//        }
+//        return maxCount
+//    }
+    // 14
     func lengthOfLongestSubstring(_ s: String) -> Int {
-        guard s.count > 0 else {
-            return 0
-        }
-        
-        var maxCount = 1
-        if s.count == 1 {
-            return maxCount
-        }
-        let strArr = Array(s) // Key: convert string to array
-        for (index, char) in strArr.enumerated() {
-            var dict: [Character : Int] = [:]
-            var count = 1
-            dict[char] = 1
-            var movingIdx = index + 1
-            while movingIdx < strArr.count, dict[strArr[movingIdx]] ?? 0 < 1 {
-                dict[strArr[movingIdx]] = 1
+        let arr = Array(s)
+        var dict = [Character : Int]() // [char : idx]
+        var maxCount = 0
+        var count = 0
+        for idx in 0..<arr.count {
+            if dict[arr[idx]] == nil {
                 count += 1
-                movingIdx += 1
+                dict[arr[idx]] = idx
+            } else {
+                let startIdx = dict[arr[idx]]! + 1
+                dict[arr[idx]] = idx
+                for key in dict.keys {
+                    if dict[key]! < startIdx {
+                        dict[key] = nil
+                    }
+                }
+                count = idx - startIdx + 1
             }
-            maxCount = count > maxCount ? count : maxCount
+            maxCount = max(count, maxCount)
         }
         return maxCount
     }
@@ -38,12 +62,18 @@ class Tests: XCTestCase {
         let expected = 3
         XCTAssertEqual(solution.lengthOfLongestSubstring(sample), expected)
     }
-    
+
     func testSample2() {
         let sample = "abcabcbb"
         let expected = 3
         XCTAssertEqual(solution.lengthOfLongestSubstring(sample), expected)
     }
+    
+    func testSample3() {
+        let sample = "pwwkew"
+        let expected = 3
+        XCTAssertEqual(solution.lengthOfLongestSubstring(sample), expected)
+    }
 }
 
 Tests.defaultTestSuite.run()

Medium/0005-LongestPalindromicSubstring.playground/Contents.swift

@@ -11,32 +11,26 @@ class Solution {
         var strArr = Array(s)
 
         while length > 0 {
-            for i in 0...s.count-length {
-                var left = i
-                var right = i+length-1
-                
-                if right >= strArr.count {
-                    break
-                }
-                
+            for i in 0...strArr.count-length {
                 var isPalindrome = true
-                while left < right {
-                    if strArr[left] != strArr[right] {
+                var left = i
+                var right = left + length - 1
+                while right > left {
+                    if strArr[left] == strArr[right] {
+                        left += 1
+                        right -= 1
+                    } else {
                         isPalindrome = false
                         break
                     }
-                    
-                    left += 1
-                    right -= 1
                 }
-
                 if isPalindrome {
                     return String(strArr[i..<i+length])
                 }
             }
             length -= 1
         }
-        return String(strArr[0])
+        return ""
     }
 }
 
@@ -60,7 +54,7 @@ class Tests: XCTestCase {
         let expected = "a"
         XCTAssertEqual(s.longestPalindrome(input), expected)
     }
-    
+
     func testSample4() {
         let input = "abcda"
         let expected = "a"

Medium/0114-FlattenBinaryTreeToLinkedList.playground/Contents.swift

@@ -0,0 +1,53 @@
+// Leetcode: https://leetcode.com/problems/flatten-binary-tree-to-linked-list/
+
+import XCTest
+
+public class TreeNode {
+    public var val: Int
+    public var left: TreeNode?
+    public var right: TreeNode?
+    public init(_ val: Int) {
+        self.val = val
+        self.left = nil
+        self.right = nil
+    }
+}
+
+class Solution {
+    func flatten(_ root: TreeNode?) {
+        
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = convertArrToTree([1, 2, 5, 3, 4, nil, 6])
+    }
+    
+    private func convertArrToTree(_ arr: [Int?]) -> TreeNode? {
+        guard arr.count > 0 else {
+            return nil
+        }
+        let root = TreeNode(arr[0]!)
+        convert(0, root, arr)
+        return root
+    }
+    
+    private func convert(_ index: Int, _ root: TreeNode?, _ arr: [Int?]) {
+        guard let root = root, index*2 + 2 < arr.count else { return }
+        
+        if let leftVal = arr[index*2+1] {
+            root.left = TreeNode(leftVal)
+            convert(index*2+1, root.left, arr)
+        }
+        
+        if let rightVal = arr[index*2+2] {
+            root.right = TreeNode(rightVal)
+            convert(index*2+2, root.right, arr)
+        }
+    }
+}
+
+Tests.defaultTestSuite.run()

Medium/0114-FlattenBinaryTreeToLinkedList.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='tvos' executeOnSourceChanges='false'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>