Update solutions

Author: Michael Ho

Udacity Practices/Graphs.playground/Contents.swift renamed to Data Structures and Algorithms/Graphs.playground/Contents.swift

@@ -0,0 +1,31 @@
+// LeetCode: https://leetcode.com/problems/sqrtx/
+
+import XCTest
+
+class Solution {
+    func mySqrt(_ x: Int) -> Int {
+        var output = 0
+        while output*output <= x {
+            output += 1
+        }
+        return output - 1
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = 8
+        let expected = 2
+        XCTAssertEqual(expected, s.mySqrt(input))
+    }
+    
+    func testSample2() {
+        let input = 4
+        let expected = 2
+        XCTAssertEqual(expected, s.mySqrt(input))
+    }
+}
+
+Tests.defaultTestSuite.run()

Udacity Practices/Closures.playground/contents.xcplayground renamed to Data Structures and Algorithms/Graphs.playground/contents.xcplayground

@@ -5,13 +5,22 @@ import XCTest
 
 class Solution {
     func climbStairs(_ n: Int) -> Int {
+        guard n > 0 else { return 0 }
         var arr = Array(repeating: 0, count: n)
         arr[0] = 1
-        guard n > 1 else { return arr[n-1] }
-        arr[1] = 2
-        guard n > 2 else { return arr[n-1] }
-        for i in 2..<n {
-            arr[i] = arr[i-1] + arr[i-2]
+        if n > 1 {
+            arr[1] = 2
+        }
+        
+        var idx = 2
+        while idx < n {
+            if idx - 1 >= 0 {
+                arr[idx] += arr[idx-1]
+            }
+            if idx - 2 >= 0 {
+                arr[idx] += arr[idx-2]
+            }
+            idx += 1
         }
         return arr[n-1]
     }

Data Structures/Heap.playground/Contents.swift renamed to Data Structures and Algorithms/Heap.playground/Contents.swift

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

Data Structures/Heap.playground/contents.xcplayground renamed to Data Structures and Algorithms/Heap.playground/contents.xcplayground

@@ -2,93 +2,61 @@
 
 import XCTest
 
-public class Interval {
-    public var start: Int
-    public var end: Int
-    
-    public init(_ start: Int, _ end: Int) {
-        self.start = start
-        self.end = end
-    }
-    
-    public init(_ array: [Int]) {
-        self.start = array[0]
-        self.end = array[1]
-    }
-    
-    public func toArray() -> [Int] {
-        return [self.start, self.end]
-    }
-}
-
 class Solution {
-    func insert(_ intervals: [Interval], _ newInterval: Interval) -> [Interval] {
-        guard intervals.count > 0 else {
-            return [newInterval]
-        }
-        var i = 0
-        var output: [Interval] = []
+    func insert(_ intervals: [[Int]], _ newInterval: [Int]) -> [[Int]] {
+        guard intervals.count > 0 else { return [newInterval] }
+        
+        var output = [[Int]]()
+        var idx = 0
+        var insertIdx = 0
         var newInterval = newInterval
-        var appendNew = true
-        while i < intervals.count {
-            if (intervals[i].end < newInterval.start) || (intervals[i].start > newInterval.end) {
-                output.append(intervals[i])
-                i += 1
-                continue
+        while idx < intervals.count {
+            let start = intervals[idx][0]
+            let end = intervals[idx][1]
+            if (end >= newInterval[0] && end <= newInterval[1]) || (start >= newInterval[0] && start <= newInterval[1]) {
+                newInterval = [min(start, newInterval[0]), max(end, newInterval[1])]
+            } else {
+                insertIdx += 1
+                output.append(intervals[idx])
             }
-            var j = i
-            while j < intervals.count, !((intervals[j].end < newInterval.start) || (intervals[j].start > newInterval.end)) {
-                appendNew = false
-                i = j
-                newInterval = Interval(min(intervals[j].start, newInterval.start), max(intervals[j].end, newInterval.end))
-                j += 1
-            }
-            i += 1
-            output.append(newInterval)
-        }
-        if appendNew {
-            output.append(newInterval)
-            output.sort(by: { $0.start < $1.start })
+            idx += 1
         }
-        return output
+        output.append(newInterval)
+        return output.sorted(by: { $0[0] < $1[0] })
     }
 }
 
 class Tests: XCTestCase {
     let s = Solution()
 
     func testSample1() {
-        let input = ([Interval(1,3), Interval(6,9)], Interval(2,5))
+        let input = ([[1,3], [6,9]], [2,5])
         let expected = [[1,5],[6,9]]
-        var output: [[Int]] = []
-        for i in s.insert(input.0, input.1) {
-            output.append(i.toArray())
+        let output = s.insert(input.0, input.1)
+        for o in output {
+            expected.contains(o)
         }
-        XCTAssertEqual(output, expected)
+        XCTAssertEqual(output.count, expected.count)
     }
 
     func testSample2() {
-        let input = ([Interval(1,2), Interval(3,5), Interval(6,7), Interval(8,10), Interval(12,16)], Interval(4,8))
+        let input = ([[1,2], [3,5], [6,7], [8,10], [12,16]], [4,8])
         let expected = [[1,2],[3,10],[12,16]]
-        var output: [[Int]] = []
-        for i in s.insert(input.0, input.1) {
-            output.append(i.toArray())
+        let output = s.insert(input.0, input.1)
+        for o in output {
+            expected.contains(o)
         }
-        XCTAssertEqual(output, expected)
+        XCTAssertEqual(output.count, expected.count)
     }
 
     func testSample3() {
-        let input = ([Interval(1,5)], Interval(6,8))
-        let expected = [[1,5],[6,8]]
-        var output: [[Int]] = []
-        for i in s.insert(input.0, input.1) {
-            output.append(i.toArray())
+        let input = ([[1,5]], [6,8])
+        let expected = [[1,5], [6,8]]
+        let output = s.insert(input.0, input.1)
+        for o in output {
+            expected.contains(o)
         }
-        XCTAssertEqual(output, expected)
-    }
-    
-    func testSample4() {
-        
+        XCTAssertEqual(output.count, expected.count)
     }
 }
 

Data Structures/ImplementTrie-PrefixTree.playground/Contents.swift renamed to Data Structures and Algorithms/ImplementTrie-PrefixTree.playground/Contents.swift

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

Data Structures/ImplementTrie-PrefixTree.playground/contents.xcplayground renamed to Data Structures and Algorithms/ImplementTrie-PrefixTree.playground/contents.xcplayground

@@ -0,0 +1,54 @@
+// LeetCode: https://leetcode.com/problems/minimum-window-substring/
+
+import XCTest
+
+class Solution {
+    func minWindow(_ s: String, _ t: String) -> String {
+        guard s.count >= t.count else { return "" }
+        
+        var tDict = [Character: Int]()
+        for ch in t {
+            tDict[ch] = tDict[ch] == nil ? 1 : tDict[ch]! + 1
+        }
+        
+        var sDict = [Character: Int]()
+        for ch in s {
+            if tDict[ch] == nil {
+                continue
+            }
+            sDict[ch] = sDict[ch] == nil ? 1 : sDict[ch]! + 1
+        }
+        
+        let sArr = Array(s)
+        var start = 0
+        var end = sArr.count-1
+        while start < end {
+            if tDict[sArr[start]] == nil {
+                start += 1
+            } else if (tDict[sArr[start]] != nil && sDict[sArr[start]]! - 1 >= tDict[sArr[start]]!) {
+                sDict[sArr[start]]! -= 1
+                start += 1
+            } else if tDict[sArr[end]] == nil {
+                end -= 1
+            } else if (tDict[sArr[end]] != nil && sDict[sArr[end]]! - 1 >= tDict[sArr[end]]!) {
+                sDict[sArr[end]]! -= 1
+                end -= 1
+            } else {
+                break
+            }
+        }
+        return String(sArr[start...end])
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = ("ADOBECODEBANC", "ABC")
+        let expected = "BANC"
+        XCTAssertEqual(expected, s.minWindow(input.0, input.1))
+    }
+}
+
+Tests.defaultTestSuite.run()

Data Structures/LRUCache.playground/Contents.swift renamed to Data Structures and Algorithms/LRUCache.playground/Contents.swift

@@ -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>

Data Structures/LRUCache.playground/contents.xcplayground renamed to Data Structures and Algorithms/LRUCache.playground/contents.xcplayground

@@ -0,0 +1,26 @@
+// LeetCode: https://leetcode.com/problems/maximal-rectangle/
+
+import XCTest
+
+class Solution {
+    func maximalRectangle(_ matrix: [[Character]]) -> Int {
+        return 0
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = [
+            [Character("1"),Character("0"),Character("1"),Character("0"),Character("0")],
+            [Character("1"),Character("0"),Character("1"),Character("1"),Character("1")],
+            [Character("1"),Character("1"),Character("1"),Character("1"),Character("1")],
+            [Character("1"),Character("0"),Character("0"),Character("1"),Character("0")]
+        ]
+        let expected = 6
+        XCTAssertEqual(expected, s.maximalRectangle(input))
+    }
+}
+
+Tests.defaultTestSuite.run()

Udacity Practices/SortingAlgorithms.playground/Contents.swift renamed to Data Structures and Algorithms/SortingAlgorithms.playground/Contents.swift

@@ -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>