[Swift]LeetCode539. 最小时间差 | Minimum Time Difference

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

Given a list of 24-hour clock time points in "Hour:Minutes" format, find the minimum minutes difference between any two time points in the list.

Example 1:

Input: ["23:59","00:00"]
Output: 1 

Note:

1. The number of time points in the given list is at least 2 and won't exceed 20000.
2. The input time is legal and ranges from 00:00 to 23:59.

---

给定一个 24 小时制（小时:分钟）的时间列表，找出列表中任意两个时间的最小时间差并已分钟数表示。

示例 1：

输入: ["23:59","00:00"]
输出: 1

备注:

　　1.列表中时间数在 2~20000 之间。

 

　　2.

每个时间取值在 00:00~23:59 之间。

---

Runtime: 104 ms

Memory Usage: 20 MB

class Solution {
    func findMinDifference(_ timePoints: [String]) -> Int {
        var res:Int = Int.max
        var pre:Int = 0
        var first:Int = Int.max
        var last:Int = Int.min
        var mask:[Int] = [Int](repeating:0,count:1440)
        for str in timePoints
        {
            var h:Int = Int(str.subString(0, 2))!
            var m:Int = Int(str.subString(3))!
            if mask[h * 60 + m] == 1 {return 0}
            mask[h * 60 + m] = 1
        }
        for i in 0..<1440
        {
            if mask[i] == 1
            {
                if first != Int.max
                {
                    res = min(res, i - pre)
                }
                first = min(first, i)
                last = max(last, i)
                pre = i
            }
        }
        return min(res, 1440 + first - last)
    }
}

extension String 
{
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
    
    // 截取字符串：从index到结束处
    // - Parameter index: 开始索引
    // - Returns: 子字符串
    func subString(_ index: Int) -> String {
        let theIndex = self.index(self.endIndex, offsetBy: index - self.count)
        return String(self[theIndex..<endIndex])
    }
}

---

104ms

class Solution {
    
    private let twentyFourHoursInMinutes = 24*60
    
    func findMinDifference(_ timePoints: [String]) -> Int {
        
        // constant space
        var minuteBuckets = [Bool](repeating: false, count: twentyFourHoursInMinutes)
        
        // O(N) time
        for timeString in timePoints {
            
            // O(1) time
            let minutes = convertTimeStringToMinutes(timeString)
            
            // if we already contain the `minutes`, that means the time difference will be 0
            if minuteBuckets[minutes] {
                return 0
            }
            
            minuteBuckets[minutes] = true
        }
        
        var minDifference = twentyFourHoursInMinutes
        var firstMinute = 0
        var lastMinute = -1
        
        // O(1) time
        for minute in 0..<minuteBuckets.count {
            guard minuteBuckets[minute] else {
                continue
            }
            
            if lastMinute == -1 {
                firstMinute = minute
            } else {
                minDifference = min(minDifference, minute - lastMinute)
            }
            
            lastMinute = minute
        }
        
        minDifference = min(minDifference, firstMinute + (twentyFourHoursInMinutes - lastMinute))
        
        return minDifference
    }
    
    func convertTimeStringToMinutes(_ timeString: String) -> Int {
        let hoursAndMinutes = timeString.split(separator: ":")
        guard let hours = Int(hoursAndMinutes[0]), let minutes = Int(hoursAndMinutes[1]) else {
            assertionFailure("...")
            return 0
        }
        return (hours * 60) + minutes
    }
}

---

108ms

class Solution {
    func findMinDifference(_ timePoints: [String]) -> Int {
        let timePointsSet = Set<String>(timePoints)
        
        if (timePoints.count !=  timePointsSet.count) {
            return 0
        }

        let timePoints = [String](timePointsSet).sorted()
        
        
        var minResult = timeDifference(timePoints[0], timePoints[timePoints.count - 1])
        
        let maxIndex = timePoints.count - 2
        for index in 0...maxIndex {
            minResult = min(minResult, timeDifference(timePoints[index], timePoints[index+1]))
        }
     
        return minResult
    }
    
    private func timeDifference(_ time0 : String, _ time1 : String) -> Int {
        var minutes0 = minutesFromTimeString(time0)
        var minutes1 = minutesFromTimeString(time1)
        
        if (minutes0 > minutes1) {
            swap(&minutes0, &minutes1)
        }

        return min(minutes1 - minutes0, minutes0 + 24*60 - minutes1)
    }
    
    private func minutesFromTimeString(_ timeStr : String) -> Int {
        let foundIndex = timeStr.firstIndex(of: ":") ?? timeStr.startIndex
        let hourStr = timeStr[..<foundIndex]
        let nextIndex = timeStr.index(after: foundIndex)
        let minuteStr = timeStr[nextIndex...]
        
        let hour = Int(hourStr)!
        let minute = Int(minuteStr)!

        return hour * 60 + minute
    }
}

---

148ms

class Solution {
    func getMinute(_ timePoint: String) -> Int {
        var times = timePoint.split(separator: ":")
        return Int(times[0])!*60 + Int(times[1])!
    }
    
    func findMinDifference(_ timePoints: [String]) -> Int {
        if timePoints.count <= 1 {
            return 0
        }

        var points: [Int] = timePoints.map { getMinute($0) }
        points.sort()
        
        var minn = 24*60 + points.first! - points.last!
        
        for i in 1..<points.count {
            minn = min(minn, points[i]-points[i-1])
        }
        return minn
    }
}

---

156ms

struct Time {
    let hours: Int
    let minutes: Int
}

extension Time: Comparable {
    static func <(lhs: Time, rhs: Time) -> Bool {
        return lhs.hours < rhs.hours || (lhs.hours == rhs.hours && lhs.minutes < rhs.minutes)
    }
}

class Solution {
    func findMinDifference(_ timePoints: [String]) -> Int {
        
        let timePoints = timePoints
            .map { convertToTime($0) }
            .sorted()
        
        var minDifference = Int.max
        for i in 1..<timePoints.count {
            minDifference = min(
                minDifference,
                calculateDifference(timePoints[i-1], timePoints[i]))
        }
        minDifference = min(
                minDifference,
                calculateDifference(timePoints[0], timePoints[timePoints.count-1]))
        
        return minDifference
    }
    
    func calculateDifference(_ time1: Time, _ time2: Time) -> Int {

        return min(
            calculateDifference_helper(time1, time2),
            calculateDifference_helper(time2, Time(hours: time1.hours+24, minutes: time1.minutes))
        )
    }
    
    func calculateDifference_helper(_ time1: Time, _ time2: Time) -> Int {
        return ((time2.hours - time1.hours) * 60) + (time2.minutes - time1.minutes)
    }
    
    func convertToTime(_ timeString: String) -> Time {
        let timeUnits = timeString.split(separator: ":")
        guard let hours = Int(timeUnits[0]), let minutes = Int(timeUnits[1]) else {
            assertionFailure("...")
            return Time(hours: 0, minutes: 0)
        }
        return Time(hours: hours, minutes: minutes)
    }
}

---

164ms

typealias Time = (hours: Int, minutes: Int)

class Solution {
    func findMinDifference(_ timePoints: [String]) -> Int {
        
        var buckets = [[Int]](repeating: [Int](repeating: 0, count: 60), count: 24)
        
        for timeString in timePoints {
            let time = convertTimeString(timeString)
            buckets[time.hours][time.minutes] += 1
        }
        
        var times: [Time] = []
        for hour in 0..<buckets.count  {
            for minutes in 0..<buckets[hour].count {
                for _ in 0..<buckets[hour][minutes] {
                    times.append(Time(hour,minutes))
                }
            }
        }
        
        var minDifference = Int.max
        for i in 1..<times.count {
            let difference = timeDifference(times[i-1], times[i])
            minDifference = min(minDifference, difference)
        }
        minDifference = min(minDifference, timeDifference(times[0], times[times.count-1]))
        
        return minDifference
    }
    
    func timeDifference(_ time1: Time, _ time2: Time) -> Int {
        let diff1 = timeDifference_helper(time1, time2)
        let diff2 = timeDifference_helper(time2, (time1.hours+24, time1.minutes))
        return min(diff1, diff2)
    }
    
    func timeDifference_helper(_ time1: Time, _ time2: Time) -> Int {
        return (time2.hours - time1.hours)*60 + (time2.minutes - time1.minutes)
    }
    
    func convertTimeString(_ timeString: String) -> Time {
        let timeStringSplit = timeString.split(separator: ":")
        guard let hours = Int(timeStringSplit[0]), let minutes = Int(timeStringSplit[1]) else {
            return (0,0)
        }
        return (hours,minutes)
    }
}

---

188ms

class Solution {
func getTime(_ time: String) -> Int {
    let array = time.split(separator: ":")
    guard array.count == 2 else {
        return 0
    }
    
    let hours = Int(array[0])!
    let minute = Int(array[1])!
    
    return hours * 60 + minute
}

func findMinDifference(_ timePoints: [String]) -> Int {
    let sorted = timePoints.sorted()
    
    var minDiff = Int.max
    let n = timePoints.count
    
    for i in 0..<n {
        var diff = getTime(sorted[(i - 1 + n) % n]) - getTime(sorted[i])
        diff = abs(diff)
        diff = min(diff, 60 * 24 - diff)
        minDiff = min(diff, minDiff)
    }
    
    return minDiff
  }
}

---

208ms

class Solution {
    
    func findMinDifference(_ timePoints: [String]) -> Int {
        var sorted = timePoints.sorted()
        var previous: String?
        var diff = Int.max
        for point in sorted {
            guard let prev = previous else {
                if let last = sorted.last {
                    let curDiff = timeDiff(point, last)
                    diff = min(diff, curDiff, 24 * 60 - curDiff)
                }
                previous = point
                continue
            }
            let curDiff = timeDiff(point, prev)
            diff = min(diff, curDiff, 24 * 60 - curDiff)
            previous = point
        }
        return diff
    }
    
    func timeDiff(_ a: String, _ b: String) -> Int {
        return abs(absTime(string: a) - absTime(string: b))
    }
    
    func absTime(string: String) -> Int {
        let split = string.split(separator: ":").map { Int($0)! }
        return split[0] * 60 + split[1]
    }       
}