Added accepted solutions

Author: Michael-Ho-Bose

Easy/0118+0119-PascalsTriangle.playground/Contents.swift

@@ -0,0 +1,89 @@
+// LeetCode: https://leetcode.com/problems/pascals-triangle/description/
+
+import XCTest
+
+class Solution {
+    func generate(_ numRows: Int) -> [[Int]] {
+        var output: [[Int]] = []
+        if numRows < 1 {
+            return output
+        }
+        output.append([1])
+        if numRows < 2 {
+            return output
+        }
+        output.append([1,1])
+        if numRows < 3 {
+            return output
+        }
+        for i in 2..<numRows {
+            var arr = Array(repeating: 1, count: i+1)
+            for j in 1..<arr.count-1 {
+                arr[j] = output[i-1][j-1] + output[i-1][j]
+            }
+            
+            output.append(arr)
+        }
+        return output
+    }
+    
+    func getRow(_ rowIndex: Int) -> [Int] {
+        var output: [Int] = [1]
+        guard rowIndex > 0 else {
+            return output
+        }
+        for _ in 1...rowIndex {
+            var temp = output
+            for j in 0..<output.count {
+                if j-1 >= 0 {
+                    output[j] = temp[j] + temp[j-1]
+                }
+            }
+            output.append(1)
+        }
+        return output
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = 5
+        let expected = [
+            [1],
+            [1,1],
+            [1,2,1],
+            [1,3,3,1],
+            [1,4,6,4,1]
+        ]
+        XCTAssertEqual(s.generate(input), expected)
+    }
+    
+    func testSample2() {
+        let input = 0
+        let expected: [[Int]] = []
+        XCTAssertEqual(s.generate(input), expected)
+    }
+    
+    func testSample3() {
+        let input = 5
+        let expected = [1,5,10,10,5,1]
+        XCTAssertEqual(s.getRow(input), expected)
+    }
+    
+    func testSample4() {
+        let input = 3
+        let expected = [1,3,3,1]
+        XCTAssertEqual(s.getRow(input), expected)
+    }
+    
+    func testSample5() {
+        let input = 1
+        let expected = [1,1]
+        XCTAssertEqual(s.getRow(input), expected)
+    }
+}
+
+Tests.defaultTestSuite.run()
+

Easy/0118+0119-PascalsTriangle.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>

Hard/0224-BasicCalculator.playground/Contents.swift

@@ -0,0 +1,84 @@
+// LeetCode: https://leetcode.com/problems/basic-calculator/description/
+
+import XCTest
+
+class Solution {
+    func calculate(_ s: String) -> Int {
+        var output: [Int] = []
+        let strArr = Array(s + "+")
+        var open: [[Int]] = []
+        var num = 0
+        var sign: Character = "+"
+        
+        for ch in strArr {
+            if ch >= "0" && ch <= "9" {
+                num = num*10 + Int(String(ch))!
+            } else if ch == "+" || ch == "-" {
+                if open.count > 0 {
+                    open[0].append(sign == "+" ? num : -num)
+                } else {
+                    output.append(sign == "+" ? num : -num)
+                }
+                num = 0
+                sign = ch
+            } else if ch == "(" {
+                var newSign = sign == "+" ? 1 : -1
+                if open.count > 0 {
+                    newSign *= open[0][0]
+                }
+                var arr: [Int] = [newSign]
+                open.insert(arr, at: 0)
+                sign = "+"
+            } else if ch == ")" {
+                if num != 0 {
+                    open[0].append(sign == "+" ? num : -num)
+                    num = 0
+                }
+                let sign = open[0].removeFirst()
+                output.append(sign * open[0].reduce(0, {x,y in
+                    x+y
+                }))
+                open.removeFirst()
+            }
+        }
+        return output.reduce(0, {x,y in
+            x+y
+        })
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = "1 + 1"
+        let expected = 2
+        XCTAssertEqual(s.calculate(input), expected)
+    }
+    
+    func testSample2() {
+        let input = "(3-(2-(5-(9-(4)))))"
+        let expected = 1
+        XCTAssertEqual(s.calculate(input), expected)
+    }
+
+    func testSample3() {
+        let input = "(1+(4+5+2)-3)+(6+8)"
+        let expected = 23
+        XCTAssertEqual(s.calculate(input), expected)
+    }
+
+    func testSample4() {
+        let input = "1-(5)"
+        let expected = -4
+        XCTAssertEqual(s.calculate(input), expected)
+    }
+
+    func testSample5() {
+        let input = "(5-(1+(5)))"
+        let expected = -1
+        XCTAssertEqual(s.calculate(input), expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Hard/0224-BasicCalculator.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>

Medium/0047-PermutationsII.playground/Contents.swift

@@ -0,0 +1,54 @@
+// LeetCode: https://leetcode.com/problems/permutations-ii/description/
+// Mind time complexity
+
+import XCTest
+
+class Solution {
+    func permuteUnique(_ nums: [Int]) -> [[Int]] {
+        var output: [[Int]] = []
+        let current: [Int] = []
+        let sorted = nums.sorted()
+        permuteUnique(sorted, current, &output)
+        return output
+    }
+    
+    private func permuteUnique(_ nums: [Int], _ current: [Int], _ output: inout [[Int]]) {
+        if nums.count == 0, !output.contains(current) {
+            output.append(current)
+            return
+        }
+        var idx = 0
+        while idx < nums.count {
+            if idx - 1 >= 0, nums[idx] == nums[idx-1] {
+                idx += 1
+                continue
+            }
+            var temp = current
+            temp.append(nums[idx])
+            var tempNum = nums
+            tempNum.remove(at: idx)
+            permuteUnique(tempNum, temp, &output)
+            idx += 1
+        }
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = [1,1,2]
+        let expected = [
+            [1,1,2],
+            [1,2,1],
+            [2,1,1]
+        ]
+        let output = s.permuteUnique(input)
+        XCTAssertEqual(output.count, expected.count)
+        for o in output {
+            XCTAssertTrue(expected.contains(o))
+        }
+    }
+}
+
+Tests.defaultTestSuite.run()

Medium/0047-PermutationsII.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>

Medium/0060-PermutationSequence.playground/Contents.swift

@@ -0,0 +1,64 @@
+// LeetCode: https://leetcode.com/problems/permutation-sequence/description/
+
+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
+        for i in 1...n {
+            current = current * i
+            factList.append(current)
+        }
+        
+        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))")
+        }
+        output.append("\(arr.removeLast())")
+        return output
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = (3, 3)
+        let expected = "213"
+        XCTAssertEqual(s.getPermutation(input.0, input.1), expected)
+    }
+    
+    func testSample2() {
+        let input = (4, 9)
+        let expected = "2314"
+        XCTAssertEqual(s.getPermutation(input.0, input.1), expected)
+    }
+    
+    func testSample3() {
+        let input = (3, 2)
+        let expected = "132"
+        XCTAssertEqual(s.getPermutation(input.0, input.1), expected)
+    }
+    
+    func testSample4() {
+        let input = (1, 1)
+        let expected = "1"
+        XCTAssertEqual(s.getPermutation(input.0, input.1), expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Medium/0060-PermutationSequence.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>

Medium/0074-Search2DMatrix.playground/Contents.swift

@@ -0,0 +1,70 @@
+// LeetCode:
+
+import XCTest
+
+class Solution {
+    func searchMatrix(_ matrix: [[Int]], _ target: Int) -> Bool {
+        guard !matrix.isEmpty else { return false }
+        if matrix.count < 2 {
+            return matrix[0].contains(target)
+        }
+        var i = matrix.count/2
+        var j = 0
+        var upper: Int?
+        while i < matrix.count, j < matrix[i].count {
+            if target == matrix[i][j] {
+                return true
+            } else if target < matrix[i][j] {
+                guard i > 0 else { return false }
+                upper = i
+                i = i/2
+            } else {
+                if j + 1 >= matrix[i].count, (upper == nil || i+1 < upper!) {
+                    i += 1
+                    j = 0
+                } else {
+                    j += 1
+                }
+            }
+        }
+        return false
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = ([
+            [1,   3,  5,  7],
+            [10, 11, 16, 20],
+            [23, 30, 34, 50]
+            ], 3)
+        let expected = true
+        XCTAssertEqual(s.searchMatrix(input.0, input.1), expected)
+    }
+
+    func testSample2() {
+        let input = ([
+            [1,   3,  5,  7],
+            [10, 11, 16, 20],
+            [23, 30, 34, 50]
+            ], 13)
+        let expected = false
+        XCTAssertEqual(s.searchMatrix(input.0, input.1), expected)
+    }
+
+    func testSample3() {
+        let input = ([[1], [3]], 0)
+        let expected = false
+        XCTAssertEqual(s.searchMatrix(input.0, input.1), expected)
+    }
+    
+    func testSample4() {
+        let input = ([[1], [3], [5]], 5)
+        let expected = true
+        XCTAssertEqual(s.searchMatrix(input.0, input.1), expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Medium/0074-Search2DMatrix.playground/contents.xcplayground

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