Merge pull request #1930 from delight010/main

[SeongA] WEEK 11 Solutions

Author: TonyKim9401

merge-intervals/delight010.swift

@@ -0,0 +1,31 @@
+class Solution {
+    // Time O(n log n)
+    // Space O(n)
+    func merge(_ intervals: [[Int]]) -> [[Int]] {
+        if intervals.count <= 1 {
+            return intervals
+        }
+        
+        let intervals = intervals.sorted { $0[0] <= $1[0] }
+        var answer: [[Int]] = []
+        var currentInterval: [Int] = []
+        
+        for i in 0..<intervals.count {
+            if currentInterval.isEmpty {
+                currentInterval = intervals[i]
+            }
+            
+            if intervals[i][0] >= currentInterval[0] && intervals[i][0] <= currentInterval[1] {
+                currentInterval = [currentInterval[0], max(currentInterval[1], intervals[i][1])]
+            } else {
+                answer.append(currentInterval)
+                currentInterval = intervals[i]
+            }
+        }
+        
+        answer.append(currentInterval)
+        
+        return answer
+    }
+}
+ 

missing-number/delight010.swift

@@ -0,0 +1,14 @@
+class Solution {
+    // Time O(n)
+    // Space O(1)
+    func missingNumber(_ nums: [Int]) -> Int {
+        var sum = 0
+        for i in 0..<nums.count {
+            sum += i
+            sum -= nums[i]
+        }
+        
+        return sum + nums.count
+    }
+}
+ 

reorder-list/delight010.swift

@@ -0,0 +1,63 @@
+public class ListNode {
+    public var val: Int
+    public var next: ListNode?
+    public init() { self.val = 0; self.next = nil; }
+    public init(_ val: Int) { self.val = val; self.next = nil; }
+    public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+}
+
+class Solution {
+    // Time O(n)
+    // Space O(1)
+    func reorderList(_ head: ListNode?) {
+        guard let head = head, head.next != nil, head.next?.next != nil else {
+            return
+        }
+        
+        var slow = head
+        var fast = head
+        
+        while fast.next != nil && fast.next?.next != nil {
+            slow = slow.next!
+            fast = fast.next!.next!
+        }
+        
+        let secondHalf = slow.next
+        slow.next = nil
+        
+        let reversedSecondHalf = reverseList(secondHalf)
+        
+        mergeLists(head, reversedSecondHalf)
+    }
+    
+    private func reverseList(_ head: ListNode?) -> ListNode? {
+        var prev: ListNode? = nil
+        var current = head
+        
+        while current != nil {
+            let nextTemp = current?.next
+            current?.next = prev
+            prev = current
+            current = nextTemp
+        }
+        
+        return prev
+    }
+    
+    private func mergeLists(_ list1: ListNode?, _ list2: ListNode?) {
+        var first = list1
+        var second = list2
+        
+        while first != nil && second != nil {
+            let firstNext = first?.next
+            let secondNext = second?.next
+            
+            first?.next = second
+            second?.next = firstNext
+            
+            first = firstNext
+            second = secondNext
+        }
+    }
+}
+