[Swift]LeetCode986. 区间列表的交集 | Interval List Intersections

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10351703.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given two lists of closed intervals, each list of intervals is pairwise disjoint and in sorted order.

Return the intersection of these two interval lists.

(Formally, a closed interval [a, b] (with a <= b) denotes the set of real numbers x with a <= x <= b.  The intersection of two closed intervals is a set of real numbers that is either empty, or can be represented as a closed interval.  For example, the intersection of [1, 3] and [2, 4] is [2, 3].)

Example 1:

Input: A = [[0,2],[5,10],[13,23],[24,25]], B = [[1,5],[8,12],[15,24],[25,26]]
Output: [[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
Reminder: The inputs and the desired output are lists of Interval objects, and not arrays or lists.

Note:

1. 0 <= A.length < 1000
2. 0 <= B.length < 1000
3. 0 <= A[i].start, A[i].end, B[i].start, B[i].end < 10^9

---

给定两个由一些闭区间组成的列表，每个区间列表都是成对不相交的，并且已经排序。

返回这两个区间列表的交集。

（形式上，闭区间 [a, b]（其中 a <= b）表示实数 x 的集合，而 a <= x <= b。两个闭区间的交集是一组实数，要么为空集，要么为闭区间。例如，[1, 3] 和 [2, 4] 的交集为 [2, 3]。）

示例：

输入：A = [[0,2],[5,10],[13,23],[24,25]], B = [[1,5],[8,12],[15,24],[25,26]]
输出：[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
注意：输入和所需的输出都是区间对象组成的列表，而不是数组或列表。

提示：

1. 0 <= A.length < 1000
2. 0 <= B.length < 1000
3. 0 <= A[i].start, A[i].end, B[i].start, B[i].end < 10^9

---

240ms

/**
 * Definition for an interval.
 * public class Interval {
 *   public var start: Int
 *   public var end: Int
 *   public init(_ start: Int, _ end: Int) {
 *     self.start = start
 *     self.end = end
 *   }
 * }
 */
class Solution {
    func intervalIntersection(_ A: [Interval], _ B: [Interval]) -> [Interval] {
        var ans = [Interval]()
        var i = 0, j = 0

        while i < A.count && j < B.count {
            // Let's check if A[i] intersects B[j].
            // lo - the startpoint of the intersection
            // hi - the endpoint of the intersection
            let lo = max(A[i].start, B[j].start)
            let hi = min(A[i].end, B[j].end)
            if lo <= hi {
                ans.append(Interval(lo, hi))
            }
            // Remove the interval with the smallest endpoint
            if A[i].end < B[j].end {
                i += 1
            }
            else {
                j += 1
            }
        }
        return ans        
    }
}

---

248ms

/**
 * Definition for an interval.
 * public class Interval {
 *   public var start: Int
 *   public var end: Int
 *   public init(_ start: Int, _ end: Int) {
 *     self.start = start
 *     self.end = end
 *   }
 * }
 */
class Solution {
    func intervalIntersection(_ A: [Interval], _ B: [Interval]) -> [Interval] {
        var a = 0
        var b = 0
        var res = [Interval]()
        while a < A.count && b < B.count {
            if let interval = intersection(A[a], B[b]) {
                res.append(interval)
            }
            if A[a].end < B[b].end {
                a += 1
            } else if A[a].end > B[b].end {
                b += 1
            } else {
                a += 1
                b += 1
            }
        }
        return res
    }
    
    private func intersection(_ A: Interval, _ B: Interval) -> Interval? {
        if B.start > A.end || A.start > B.end { return nil }
        return Interval(max(A.start, B.start), min(A.end, B.end))
    }
}

---

252ms

/**
 * Definition for an interval.
 * public class Interval {
 *   public var start: Int
 *   public var end: Int
 *   public init(_ start: Int, _ end: Int) {
 *     self.start = start
 *     self.end = end
 *   }
 * }
 */
class Solution {
    func intervalIntersection(_ A: [Interval], _ B: [Interval]) -> [Interval] {
        if A.count == 0 || B.count == 0 { return [Interval]() }
        var a = A
        var b = B
        a.reverse()
        b.reverse()
        var result = [Interval]()
        var remaining = 0
        while a.count > 0 && b.count > 0 {
            var currA = a.removeLast()
            var currB = b.removeLast()
            if ((currB.end <= currA.end && currB.end >= currA.start) || 
                (currA.end <= currB.end && currA.end >= currB.start)) {
                if currA.end < currB.end {
                    b.append(Interval(currA.end, currB.end))
                } else if currA.end > currB.end {
                    a.append(Interval(currB.end, currA.end))
                }
                result.append(Interval(max(currA.start,currB.start), min(currA.end, currB.end)))
            } else if currA.end < currB.start {
                b.append(currB) 
            } else if currB.end < currA.start {
                a.append(currA) 
            }
        }
        return result
    }
}

---

272ms

/**
 * Definition for an interval.
 * public class Interval {
 *   public var start: Int
 *   public var end: Int
 *   public init(_ start: Int, _ end: Int) {
 *     self.start = start
 *     self.end = end
 *   }
 * }
 */
class Solution {
    func intervalIntersection(_ A: [Interval], _ B: [Interval]) -> [Interval] {
        guard A.count > 0 && B.count > 0 else {
            return []
        }
        
        var combo = A
        B.forEach { combo.append($0) }
        combo.sort(by: { $0.start < $1.start })
        var results = [Interval]()
        var end = combo[0].end
        for i in 1..<combo.count {
            if combo[i].end < end {
                results.append(combo[i])
            } else if combo[i].start <= end {
                results.append(Interval(combo[i].start, end))
                end = combo[i].end
            } else {
                end = combo[i].end
            }
        }
        return results
    }
}

---

1472 ms

/**
 * Definition for an interval.
 * public class Interval {
 *   public var start: Int
 *   public var end: Int
 *   public init(_ start: Int, _ end: Int) {
 *     self.start = start
 *     self.end = end
 *   }
 * }
 */
class Solution {
    func intervalIntersection(_ A: [Interval], _ B: [Interval]) -> [Interval] {
        if A.isEmpty || B.isEmpty {return []}
        var C:[Interval] = [Interval](repeating:Interval(0,1),count:A.count*B.count)
        var p:Int = 0
        for x in A
        {
            for y in B
            {
                var l:Int = max(x.start, y.start)
                var r:Int = min(x.end, y.end)
                if l <= r
                {
                    C[p] = Interval(l, r)
                    p += 1
                }
            }
        }
        if (p - 1) < C.count
        {
            var arr = C[0...(p - 1)]
            return [Interval](arr)
        }
        return C
    }
}