Update solutions from 1 to 50

Author: Michael Ho

Problems/1-100/Hard/0044-WildcardMatching.playground/Contents.swift

@@ -0,0 +1,116 @@
+// LeetCode: https://leetcode.com/problems/wildcard-matching/
+// Difficulty: hard
+
+import XCTest
+
+// TODO: solve the problem, this solution exceeds the time limit.
+class Solution {
+    func isMatch(_ s: String, _ p: String) -> Bool {
+        // Handle edge cases
+        if s.count == 0 && p.count == 0 {
+            return true
+        } else if s.count == 0 {
+            ifContainsAsterishOnly(p)
+        } else if p.count == 0 {
+            return false
+        }
+        
+        var withStar = false
+        var idxP = 0
+        var idxS = 0
+        let sArr = Array(s)
+        let pArr = Array(p)
+        
+        while idxP < p.count, idxS < s.count {
+            if sArr[idxS] == pArr[idxP] || pArr[idxP] == "?" {
+                idxS += 1
+                idxP += 1
+            } else if pArr[idxP] == "*" {
+                while idxP + 1 < p.count, pArr[idxP+1] == "*" {
+                    idxP += 1
+                }
+                if idxP+1 >= p.count {
+                    return true
+                }
+                for i in idxS..<sArr.count {
+                    if pArr[idxP+1] == sArr[i] || pArr[idxP+1] == "?" {
+                        if isMatch(String(sArr[i..<s.count]), String(pArr[idxP + 1..<p.count])) {
+                            return true
+                        }
+                    }
+                }
+                return false
+            } else {
+                return false
+            }
+        }
+        
+        if idxP == p.count && idxS == s.count {
+            return true
+        } else if idxP < p.count {
+            return ifContainsAsterishOnly(String(pArr[idxP..<p.count]))
+        } else {
+            return false
+        }
+    }
+    
+    private func ifContainsAsterishOnly(_ str: String) -> Bool {
+        for ch in str {
+            if ch != "*" {
+                return false
+            }
+        }
+        return true
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSampl1() {
+        let input = ("aa", "a")
+        XCTAssertFalse(s.isMatch(input.0, input.1))
+    }
+
+    func testSampl2() {
+        let input = ("aa", "*")
+        XCTAssertTrue(s.isMatch(input.0, input.1))
+    }
+
+    func testSampl3() {
+        let input = ("cb", "?a")
+        XCTAssertFalse(s.isMatch(input.0, input.1))
+    }
+
+    func testSampl4() {
+        let input = ("adceb", "*a*b")
+        XCTAssertTrue(s.isMatch(input.0, input.1))
+    }
+
+    func testSampl5() {
+        let input = ("abefcdgiescdfimde", "ab*cd?i*de")
+        XCTAssertTrue(s.isMatch(input.0, input.1))
+    }
+
+    func testSampl6() {
+        let input = ("aaaa", "***a")
+        XCTAssertTrue(s.isMatch(input.0, input.1))
+    }
+    
+    func testSampl7() {
+        let input = ("", "*")
+        XCTAssertTrue(s.isMatch(input.0, input.1))
+    }
+    
+    func testSampl8() {
+        let input = ("a", "a*")
+        XCTAssertTrue(s.isMatch(input.0, input.1))
+    }
+    
+    func testSampl9() {
+        let input = ("c", "*?*")
+        XCTAssertTrue(s.isMatch(input.0, input.1))
+    }
+}
+
+Tests.defaultTestSuite.run()

Problems/1-100/Hard/0044-WildcardMatching.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>

Problems/1-100/Medium/0040-CombinationSumII.playground/Contents.swift

@@ -4,39 +4,29 @@ import XCTest
 
 class Solution {
     func combinationSum2(_ candidates: [Int], _ target: Int) -> [[Int]] {
-        var output: [[Int]] = []
-        let current: [Int] = []
         let sorted = candidates.sorted()
-        helper(sorted, target, current, &output)
+        var output = [[Int]]()
+        let current = [Int]()
+        helper(sorted, 0, current, target, &output)
         return output
     }
 
-    func helper(_ candidates: [Int], _ target: Int, _ current: [Int], _ output: inout [[Int]]) {
-        if target <= 0 {
-            if target == 0 {
-                output.append(current)
-            }
+    private func helper(_ candidates: [Int], _ startIdx: Int, _ current: [Int], _ target: Int, _ output: inout [[Int]]) {
+        if target == 0 {
+            output.append(current)
             return
         }
 
-        if candidates.count == 0 {
+        if target <= 0 || startIdx >= candidates.count {
             return
         }
-        
-        var prev: Int?
-        for (index, num) in candidates.enumerated() {
-            if num > target {
-                continue
-            }
-            
-            if let prev = prev, prev == num {
+        for i in startIdx..<candidates.count {
+            if i > startIdx, i-1 >= 0, candidates[i-1] == candidates[i] {
                 continue
             }
-            var temp = Array(candidates[index..<candidates.count])
-            var new = current
-            new.append(temp.remove(at: 0))
-            helper(temp, target - num, new, &output)
-            prev = num
+            var temp = current
+            temp.append(candidates[i])
+            helper(candidates, i+1, temp, target-candidates[i], &output)
         }
     }
 }
@@ -67,7 +57,7 @@ class Tests: XCTestCase {
             [5]
         ]
         let output = s.combinationSum2(input.0, input.1)
-        
+
         XCTAssertEqual(output.count, expected.count)
         for arr in output {
             XCTAssertTrue(expected.contains(arr))

Problems/1-100/Medium/0056-MergeIntervals.playground/Contents.swift

@@ -2,84 +2,90 @@
 
 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 merge(_ intervals: [Interval]) -> [Interval] {
-        var output: [Interval] = []
-        var sorted = intervals.sorted(by: { $0.start < $1.start })
+    func merge(_ intervals: [[Int]]) -> [[Int]] {
+        guard intervals.count > 0 else { return [] }
+        var output: [[Int]] = []
+        var sorted = mergeSort(intervals, 0, intervals.count-1)
         var i = 0
         while i < sorted.count {
             var j = i + 1
-            while j < sorted.count, sorted[i].end >= sorted[j].start {
-                sorted[i].end = max(sorted[j].end, sorted[i].end)
+            while j < sorted.count, sorted[i][1] >= sorted[j][0] {
+                sorted[i][1] = max(sorted[j][1], sorted[i][1])
                 j += 1
             }
             output.append(sorted[i])
             i = j
         }
         return output
     }
+    
+    private func mergeSort(_ intervals: [[Int]], _ start: Int, _ end: Int) -> [[Int]] {
+        guard end - start > 0 else { return [intervals[start]] }
+        
+        let mid = start + (end-start)/2
+        let leftArr = mergeSort(intervals, start, mid)
+        let rightArr = mergeSort(intervals, mid+1, end)
+        
+        var output = [[Int]]()
+        var leftStart = 0
+        var rightStart = 0
+        while leftStart < leftArr.count || rightStart < rightArr.count {
+            if leftStart < leftArr.count, rightStart < rightArr.count {
+                if leftArr[leftStart][0] < rightArr[rightStart][0] {
+                    output.append(leftArr[leftStart])
+                    leftStart += 1
+                } else {
+                    output.append(rightArr[rightStart])
+                    rightStart += 1
+                }
+            } else if leftStart < leftArr.count {
+                for i in leftStart..<leftArr.count {
+                    output.append(leftArr[i])
+                }
+                leftStart = leftArr.count
+            } else {
+                for i in rightStart..<rightArr.count {
+                    output.append(rightArr[i])
+                }
+                rightStart = rightArr.count
+            }
+        }
+        return output
+    }
 }
 
 class Tests: XCTestCase {
     let s = Solution()
 
     func testSample1() {
-        let input = [Interval(1,3), Interval(2,6), Interval(8,10), Interval(15,18)]
+        let input = [[1,3], [2,6], [8,10], [15,18]]
         let expected = [[1,6],[8,10],[15,18]]
-        var output: [[Int]] = []
-        for i in s.merge(input) {
-            output.append(i.toArray())
-        }
-        XCTAssertEqual(output, expected)
+        XCTAssertEqual(expected, s.merge(input))
     }
 
     func testSample2() {
-        let input = [Interval(1,4), Interval(4,5)]
+        let input = [[1,4], [4,5]]
         let expected = [[1,5]]
-        var output: [[Int]] = []
-        for i in s.merge(input) {
-            output.append(i.toArray())
-        }
-        XCTAssertEqual(output, expected)
+        XCTAssertEqual(expected, s.merge(input))
     }
 
     func testSample3() {
-        let input = [Interval(1,4), Interval(2,3)]
+        let input = [[1,4], [2,3]]
         let expected = [[1,4]]
-        var output: [[Int]] = []
-        for i in s.merge(input) {
-            output.append(i.toArray())
-        }
-        XCTAssertEqual(output, expected)
+        XCTAssertEqual(expected, s.merge(input))
     }
 
     func testSample4() {
-        let input = [Interval(1,4), Interval(0,2), Interval(3,5)]
+        let input = [[1,4], [0,2], [3,5]]
         let expected = [[0,5]]
-        var output: [[Int]] = []
-        for i in s.merge(input) {
-            output.append(i.toArray())
-        }
-        XCTAssertEqual(output, expected)
+        XCTAssertEqual(expected, s.merge(input))
+    }
+    
+    func testSample5() {
+        let input = [[Int]]()
+        let expected = [[Int]]()
+        XCTAssertEqual(expected, s.merge(input))
     }
 }
 

Problems/1-100/Medium/0056-MergeIntervals.playground/contents.xcplayground

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

Problems/1-100/Medium/0060-PermutationSequence.playground/Contents.swift

@@ -5,30 +5,24 @@ import XCTest
 class Solution {
     func getPermutation(_ n: Int, _ k: Int) -> String {
         guard n > 0, k > 0 else { return "" }
-        if n-1 < 1 {
-            return "\(n)"
-        }
-        var arr: [Int] = []
-        for i in 1...n {
-            arr.append(i)
-        }
-        
-        var factList: [Int] = []
-        var current = 1
+        var ref = [Int]()
+        var count = 1
         for i in 1...n {
-            current = current * i
-            factList.append(current)
+            ref.append(i)
+            count = count * i
         }
 
         var output = ""
-        for i in 1...n-1 {
-            var idx = Int((Double((k % factList[n-i])*arr.count)/Double(factList[n-i])).rounded(.up))-1
-            if idx < 0 {
-                idx += arr.count
-            }
-            output.append("\(arr.remove(at: idx))")
+        var newN = n
+        var newK = k
+        while ref.count > 0, count > 0 {
+            
+            let idx = Int((Double(ref.count*newK)/Double(count)).rounded(.up)) - 1
+            output += "\(ref.remove(at: idx))"
+            count = count/newN
+            newK = newK - idx*count
+            newN -= 1
         }
-        output.append("\(arr.removeLast())")
         return output
     }
 }

Problems/1-100/Medium/0060-PermutationSequence.playground/contents.xcplayground

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