[Swift]LeetCode949. 给定数字能组成的最大时间 | Largest Time for Given Digits

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

Given an array of 4 digits, return the largest 24 hour time that can be made.

The smallest 24 hour time is 00:00, and the largest is 23:59.  Starting from 00:00, a time is larger if more time has elapsed since midnight.

Return the answer as a string of length 5.  If no valid time can be made, return an empty string. 

Example 1:

Input: [1,2,3,4]
Output: "23:41"

Example 2:

Input: [5,5,5,5]
Output: "" 

Note:

1. A.length == 4
2. 0 <= A[i] <= 9

---

给定一个由 4 位数字组成的数组，返回可以设置的符合 24 小时制的最大时间。

最小的 24 小时制时间是 00:00，而最大的是 23:59。从 00:00 （午夜）开始算起，过得越久，时间越大。

以长度为 5 的字符串返回答案。如果不能确定有效时间，则返回空字符串。

示例 1：

输入：[1,2,3,4]
输出："23:41"

示例 2：

输入：[5,5,5,5]
输出：""

提示：

1. A.length == 4
2. 0 <= A[i] <= 9

---

12ms

class Solution {
    func largestTimeFromDigits(_ A: [Int]) -> String {
        let a = [
            [0, 1, 2, 3],
            [0, 1, 3, 2],
            [1, 0, 2, 3],
            [1, 0, 3, 2],
            [0, 2, 1, 3],
            [0, 2, 3, 1],
            [2, 0, 1, 3],
            [2, 0, 3, 1],
            [0, 3, 1, 2],
            [0, 3, 2, 1],
            [3, 0, 1, 2],
            [3, 0, 2, 1],
            [1, 2, 0, 3],
            [1, 2, 3, 0],
            [2, 1, 0, 3],
            [2, 1, 3, 0],
            [1, 3, 0, 2],
            [1, 3, 2, 0],
            [3, 1, 0, 2],
            [3, 1, 2, 0],
            [2, 3, 0, 1],
            [2, 3, 1, 0],
            [3, 2, 0, 1],
            [3, 2, 1, 0]
        ].compactMap { r -> String? in
            let a = A[r[0]]
            let b = A[r[1]]
            let c = A[r[2]]
            let d = A[r[3]]
            
            let f1 = a * 10 + b
            let f2 = c * 10 + d
            
            if f1 < 24 && f2 < 60 {
                return "(a)(b):(c)(d)"
            } else {
                return nil
            }
        }

        
        return a.max() ?? ""
    }
}

---

16ms

class Solution {
    func largestTimeFromDigits(_ A: [Int]) -> String {
       var ans = -1
        
        // Choose different indices i, j, k, l as a permutation of 0, 1, 2, 3
        for i in 0..<4 {
            for j in 0..<4 {
                if j != i {
                    for k in 0..<4 {
                        if k != i && k != j {
                            let l = 6 - i - j - k
                            let hour = 10 * A[i] + A[j]
                            let min = 10 * A[k] + A[l]
                            if hour < 24 && min < 60 {
                                ans = max(ans, hour * 60 + min)
                            }
                        }
                    }
                }
            }
        }
       
        return  ans >= 0 ? String.init(format: "%02d:%02d", ans / 60, ans % 60) : ""
    }
}

---

24ms

class Solution {
    var result = -1
    func largestTimeFromDigits(_ A: [Int]) -> String {
        var isVisited = [Bool](repeating: false, count: 4)
        var value = 0
        dfs(A, &value, &isVisited)
        return result == -1 ? "" : convertResultToString(result)
    }
    
    func dfs(_ A: [Int], _ value: inout Int, _ isVisited: inout [Bool]) {
    
        if (isVisited.filter { $0 == true }.count == 4) {
            if isValidTime(value)  {
                result = max(result, value)
            }
            return 
        }
        

        for i in 0..<A.count {
            guard !isVisited[i] else {
                continue
            }
            
            value = value * 10 + A[i]
            isVisited[i] = true
            dfs(A, &value, &isVisited)
            isVisited[i] = false
            value = value / 10
        }
    } 
    func isValidTime(_ input: Int) -> Bool {
        var input = input
        guard input <= 2359 else {
            return false
        }
        
        guard input % 100 <= 59 else {
            return false
        }
        return true
    }
    
    func convertResultToString(_ input: Int) -> String {
        var input = input
        var convertedString = ""
        for i in 0...3 {
            if i == 2 {
                convertedString = ":" + convertedString
            }
            convertedString = String(input % 10) + convertedString
            input = input / 10
        }
        return convertedString
    }
}

---

28ms

class Solution {
    func largestTimeFromDigits(_ A: [Int]) -> String {
    
    // 1) Permutate digits and get largest valid time
    var answer = permuteDigitsToStrings(A, "", "-1")
    
    // 2) Convert to time format
    if answer == "-1" {
        return ""
    }
    
    answer.insert(":", at: answer.index(answer.startIndex, offsetBy: 2))
    return answer
}

func permuteDigitsToStrings(_ A: [Int], _ currentDigits: String, _ max: String) -> String {
    
    var currMax = max
    guard A.count > 0 else {
        currMax = max
        if validateTime(currentDigits) && Int(max)! < Int(currentDigits)! {
            currMax = currentDigits
        }
        return currMax
    }
    
    // Permutate
    for num in A {
        var remaining = A
        // Choose
        let digit = remaining.remove(at: remaining.firstIndex(of: num)!)
        let curDigits = currentDigits + String(digit)
        
        // Explore
        currMax = permuteDigitsToStrings(remaining, curDigits, currMax)
        
    }
    
    return currMax
}

func validateTime(_ digits: String) -> Bool {
    // Validate hours and minutes
    let minuteStartIndex = digits.index(digits.startIndex, offsetBy: 2)
    let minuteEndIndex = digits.index(digits.startIndex, offsetBy: 3)
    guard
        let hour = Int(String(digits[digits.startIndex...digits.index(digits.startIndex, offsetBy: 1)])),
        let min = Int(String(digits[minuteStartIndex...minuteEndIndex]))
        else { return false }
    
    if hour >= 24 || min >= 60 {
        return false
    }
    
    return true
}
}

---

48ms

class Solution {
    func permute<C: Collection>(items: C) -> [[C.Iterator.Element]] {
    var scratch = Array(items) // This is a scratch space for Heap's algorithm
    var result: [[C.Iterator.Element]] = [] // This will accumulate our result

    // Heap's algorithm
    func heap(_ n: Int) {
        if n == 1 {
            result.append(scratch)
            return
        }

        for i in 0..<n-1 {
            heap(n-1)
            let j = (n%2 == 1) ? 0 : i
            scratch.swapAt(j, n-1)
        }
        heap(n-1)
    }

    // Let's get started
    heap(scratch.count)

    // And return the result we built up
    return result
}

func v(c: Character, i : Int) -> Bool {
    return Int(String(c))! <= i
}

func largestTimeFromDigits(_ A: [Int]) -> String {

   var options: [[Int]] = []

    options = permute(items: A)


    let nums = options.compactMap({String("($0[0])($0[1])($0[2])($0[3])")})

    let num = nums.compactMap({Int($0)})


    var valid: [String] = []

    var max = -1
    for n in nums {

        let itms = Array(n)

        let s = String("(itms[0])(itms[1])")
        let it = Int(s)!

        if it >= 24 {
            continue
        } else {

            let oth = Int(String("(itms[2])(itms[3])"))!

            if oth >= 60 {
                continue
            } else {
                valid.append(n)
            }

        }

    }

    if valid.count == 0 {
        return ""
    }

    let ss = valid.sorted(by: { (s1, s2) -> Bool in
        s1 > s2
    }).first!

    let ssa = Array(ss)

    return String("(ssa[0])(ssa[1]):(ssa[2])(ssa[3])")



    return ""

}

}

---

96ms 

class Solution {
    func largestTimeFromDigits(_ A: [Int]) -> String {
        var f:[Int] = [Int](repeating:0,count:10)
        for x in A
        {
            f[x] += 1
        }
        for h in (0...23).reversed()
        {
            for m in (0...59).reversed()
            {
                var g:[Int] = [Int](repeating:0,count:10)
                var i:Int = h
                for j in 0..<2
                {
                    g[i%10] += 1
                    i /= 10
                }
                i = m
                for j in 0..<2
                {
                    g[i%10] += 1
                    i /= 10
                }
                if f == g
                {
                    return String(format:"%02d:%02d", h, m)
                }
            }
        }
        return String()
    }
}

---

180ms 

class Solution {
    func largestTimeFromDigits(_ A: [Int]) -> String {
        var sortA = A.sorted()
        
        var time: [Int] = [2, 3, 5, 9]
        
        
        while true {
            if sortA == time.sorted() {
                return "(time[0])(time[1]):(time[2])(time[3])"
            }
           
            if time[3] > 0 {
                time[3] -= 1
            } else if time[2] > 0 {
                 time[2] -= 1
                 time[3] = 9
            } else if time[1] > 0 {
                time[1] -= 1
                time[3] = 9
                time[2] = 5
            } else if time[0] > 0 {
                time[0] -= 1
                time[1] = 9
                time[3] = 9
                time[2] = 5
            } else {
                return ""
            }
         }
        
        return ""
    }
}