Added new solutions

Author: Michael-Ho-Bose

Easy/0088-MergeSortedArray.playground/Contents.swift

@@ -0,0 +1,25 @@
+// LeetCode: https://leetcode.com/problems/merge-sorted-array/description/
+
+import XCTest
+
+class Solution {
+    func merge(_ nums1: inout [Int], _ m: Int, _ nums2: [Int], _ n: Int) {
+        nums1 = (Array(nums1[0..<m]) + Array(nums2[0..<n])).sorted()
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample() {
+        var nums1 = [1,2,3,0,0,0]
+        let nums2 = [2,5,6]
+        let m = 3
+        let n = 3
+        let expected = [1,2,2,3,5,6]
+        s.merge(&nums1, m, nums2, n)
+        XCTAssertEqual(nums1, expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Easy/0088-MergeSortedArray.playground/contents.xcplayground

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

Easy/0892-SurfaceAreaOf3DShapes.playground/Contents.swift

@@ -0,0 +1,66 @@
+// LeetCode: https://leetcode.com/problems/surface-area-of-3d-shapes/description/
+
+import XCTest
+
+class Solution {
+    func surfaceArea(_ grid: [[Int]]) -> Int {
+        var output = 0
+        for i in 0..<grid.count {
+            for j in 0..<grid[i].count {
+                if grid[i][j] == 0 {
+                    continue
+                }
+                output += grid[i][j] * 4 + 2
+                if i-1 >= 0 {
+                    output -= min(grid[i][j], grid[i-1][j])
+                }
+                if i+1 < grid.count {
+                    output -= min(grid[i][j], grid[i+1][j])
+                }
+                if j-1 >= 0 {
+                    output -= min(grid[i][j], grid[i][j-1])
+                }
+                if j+1 < grid[i].count {
+                    output -= min(grid[i][j], grid[i][j+1])
+                }
+            }
+        }
+        return output
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = [[2]]
+        let expected = 10
+        XCTAssertEqual(s.surfaceArea(input), expected)
+    }
+    
+    func testSample2() {
+        let input = [[1,2],[3,4]]
+        let expected = 34
+        XCTAssertEqual(s.surfaceArea(input), expected)
+    }
+    
+    func testSample3() {
+        let input = [[1,0],[0,2]]
+        let expected = 16
+        XCTAssertEqual(s.surfaceArea(input), expected)
+    }
+    
+    func testSample4() {
+        let input = [[1,1,1],[1,0,1],[1,1,1]]
+        let expected = 32
+        XCTAssertEqual(s.surfaceArea(input), expected)
+    }
+    
+    func testSample5() {
+        let input = [[2,2,2],[2,1,2],[2,2,2]]
+        let expected = 46
+        XCTAssertEqual(s.surfaceArea(input), expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Easy/0892-SurfaceAreaOf3DShapes.playground/contents.xcplayground

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

Hard/0057-InsertInterval.playground/Contents.swift

@@ -0,0 +1,96 @@
+// LeetCode: https://leetcode.com/problems/insert-interval/description/
+
+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] = []
+        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
+            }
+            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 })
+        }
+        return output
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = ([Interval(1,3), Interval(6,9)], Interval(2,5))
+        let expected = [[1,5],[6,9]]
+        var output: [[Int]] = []
+        for i in s.insert(input.0, input.1) {
+            output.append(i.toArray())
+        }
+        XCTAssertEqual(output, expected)
+    }
+    
+    func testSample2() {
+        let input = ([Interval(1,2), Interval(3,5), Interval(6,7), Interval(8,10), Interval(12,16)], Interval(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())
+        }
+        XCTAssertEqual(output, expected)
+    }
+    
+    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())
+        }
+        XCTAssertEqual(output, expected)
+    }
+    
+    func testSample4() {
+        
+    }
+}
+
+Tests.defaultTestSuite.run()
+

Hard/0057-InsertInterval.playground/contents.xcplayground

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

Medium/0056-MergeIntervals.playground/Contents.swift

@@ -0,0 +1,86 @@
+// LeetCode: https://leetcode.com/problems/merge-intervals/description/
+
+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 })
+        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)
+                j += 1
+            }
+            output.append(sorted[i])
+            i = j
+        }
+        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 expected = [[1,6],[8,10],[15,18]]
+        var output: [[Int]] = []
+        for i in s.merge(input) {
+            output.append(i.toArray())
+        }
+        XCTAssertEqual(output, expected)
+    }
+    
+    func testSample2() {
+        let input = [Interval(1,4), Interval(4,5)]
+        let expected = [[1,5]]
+        var output: [[Int]] = []
+        for i in s.merge(input) {
+            output.append(i.toArray())
+        }
+        XCTAssertEqual(output, expected)
+    }
+    
+    func testSample3() {
+        let input = [Interval(1,4), Interval(2,3)]
+        let expected = [[1,4]]
+        var output: [[Int]] = []
+        for i in s.merge(input) {
+            output.append(i.toArray())
+        }
+        XCTAssertEqual(output, expected)
+    }
+    
+    func testSample4() {
+        let input = [Interval(1,4), Interval(0,2), Interval(3,5)]
+        let expected = [[0,5]]
+        var output: [[Int]] = []
+        for i in s.merge(input) {
+            output.append(i.toArray())
+        }
+        XCTAssertEqual(output, expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Medium/0056-MergeIntervals.playground/contents.xcplayground

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