[Swift]LeetCode636. 函数的独占时间 | Exclusive Time of Functions

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

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

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

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

Given the running logs of n functions that are executed in a nonpreemptive single threaded CPU, find the exclusive time of these functions.

Each function has a unique id, start from 0 to n-1. A function may be called recursively or by another function.

A log is a string has this format : function_id:start_or_end:timestamp. For example, "0:start:0" means function 0 starts from the very beginning of time 0. "0:end:0" means function 0 ends to the very end of time 0.

Exclusive time of a function is defined as the time spent within this function, the time spent by calling other functions should not be considered as this function's exclusive time. You should return the exclusive time of each function sorted by their function id.

Example 1:

Input:
n = 2
logs = 
["0:start:0",
 "1:start:2",
 "1:end:5",
 "0:end:6"]
Output:[3, 4]
Explanation:
Function 0 starts at time 0, then it executes 2 units of time and reaches the end of time 1. 
Now function 0 calls function 1, function 1 starts at time 2, executes 4 units of time and end at time 5.
Function 0 is running again at time 6, and also end at the time 6, thus executes 1 unit of time. 
So function 0 totally execute 2 + 1 = 3 units of time, and function 1 totally execute 4 units of time. 

Note:

1. Input logs will be sorted by timestamp, NOT log id.
2. Your output should be sorted by function id, which means the 0th element of your output corresponds to the exclusive time of function 0.
3. Two functions won't start or end at the same time.
4. Functions could be called recursively, and will always end.
5. 1 <= n <= 100

---

给出一个非抢占单线程CPU的 n 个函数运行日志，找到函数的独占时间。

每个函数都有一个唯一的 Id，从 0 到 n-1，函数可能会递归调用或者被其他函数调用。

日志是具有以下格式的字符串：function_id：start_or_end：timestamp。例如："0:start:0" 表示函数 0 从 0 时刻开始运行。"0:end:0" 表示函数 0 在 0 时刻结束。

函数的独占时间定义是在该方法中花费的时间，调用其他函数花费的时间不算该函数的独占时间。你需要根据函数的 Id 有序地返回每个函数的独占时间。

示例 1:

输入:
n = 2
logs = 
["0:start:0",
 "1:start:2",
 "1:end:5",
 "0:end:6"]
输出:[3, 4]
说明：
函数 0 在时刻 0 开始，在执行了  2个时间单位结束于时刻 1。
现在函数 0 调用函数 1，函数 1 在时刻 2 开始，执行 4 个时间单位后结束于时刻 5。
函数 0 再次在时刻 6 开始执行，并在时刻 6 结束运行，从而执行了 1 个时间单位。
所以函数 0 总共的执行了 2 +1 =3 个时间单位，函数 1 总共执行了 4 个时间单位。

说明：

1. 输入的日志会根据时间戳排序，而不是根据日志Id排序。
2. 你的输出会根据函数Id排序，也就意味着你的输出数组中序号为 0 的元素相当于函数 0 的执行时间。
3. 两个函数不会在同时开始或结束。
4. 函数允许被递归调用，直到运行结束。
5. 1 <= n <= 100

---

168ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var ans = [Int](repeating: 0, count: n)
        
        var stack = [Int]()
        var lastEndTime = 0
        for log in logs {
            let components = log.split(separator: ":")
            let id = Int(components[0])!
            let isStart = components[1] == "start"
            let currentTime = Int(components[2])!
            
            if isStart {
                if !stack.isEmpty {
                    ans[stack.last!] += currentTime - lastEndTime
                }
                stack.append(id)
                lastEndTime = currentTime
                continue
            } else {
                // this is a end of some task
                ans[stack.removeLast()] += currentTime - lastEndTime + 1
                lastEndTime = currentTime + 1
            }            
        }
        return ans
    }
}

---

172ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var exclusiveTotals = [Int](repeating: 0, count: n)
        var startedTasks = [(id: Int, startTime: Int)]()

        for (id, status, time) in parsedLogs(logs) {
            if status == "start" {

                // update exclusive time of parent task before this (if any)
                if let parentTask = startedTasks.last {
                    exclusiveTotals[parentTask.id] += time - parentTask.startTime
                }

                // push new task onto stack
                startedTasks.append((id: id, startTime: time))


            } else if let previousTask = startedTasks.popLast() {

                // update current ending task's exclusive time
                exclusiveTotals[previousTask.id] += time - previousTask.startTime + 1

                // update parent task's start time (if any)
                if let parentTask = startedTasks.popLast() {
                    startedTasks.append((id: parentTask.id, startTime: time+1))
                }
            }
        }

        return exclusiveTotals
    }

    private func parsedLogs(_ logs: [String]) -> [(Int, String, Int)] {
        return logs.map {
            let tokens = $0.split(separator: ":")
            return (Int(tokens[0])!, String(tokens[1]), Int(tokens[2])!)
        }
    }
}

---

180ms

class Solution {    
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var result = Array(repeating: 0, count: n)

        let logRecords = logs.compactMap(parseLogString)

        guard logRecords.count > 1 else {
            return []
        }

        var lastRecord = logRecords[0]
        var stack = [LogRecord]()
        for logRecord in logRecords {
            let offset: Int = {
                if lastRecord.type == .end && logRecord.type == .start {
                    return -1
                } else if lastRecord.type == .start && logRecord.type == .end {
                    return 1
                } else {
                    return 0
                }
            }()

            let timeDiff = logRecord.time - lastRecord.time + offset
            if logRecord.type == .start {
                // push on to the stack
                if let topRecord = stack.last {
                    result[topRecord.id] += timeDiff
                }
                stack.append(logRecord)
            } else if logRecord.type == .end {
                if let topRecord = stack.popLast() {
                    if topRecord.id != logRecord.id || topRecord.type != .start {
                        assertionFailure("input not correctly formatted")
                        return []
                    }

                    result[topRecord.id] += timeDiff
                } else {
                    assertionFailure("input not correctly formatted")
                    return []
                }
            }

            lastRecord = logRecord
        }

        return result
    }

    enum LogType: String {
        case start = "start"
        case end = "end"
    }

    struct LogRecord {
        var id: Int
        var type: LogType
        var time: Int
        init(id: Int, type: LogType, time: Int) {
            self.id = id
            self.type = type
            self.time = time
        }
    }

    func parseLogString(_ logString: String) -> LogRecord? {
        guard !logString.isEmpty else {
            return nil
        }

        let components = logString.split(separator: ":")
        guard components.count == 3 else {
            return nil
        }

        guard let id = Int(String(components[0])) else {
            return nil
        }

        guard let type = LogType(rawValue: String(components[1])) else {
            return nil
        }

        guard let time = Int(String(components[2])) else {
            return nil
        }

        return LogRecord(id: id, type: type, time: time)
    }    
}

---

188ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var stack = [Int]()
        var res = Array(repeating: 0, count: n)
        var s = logs[0].split(separator: ":")
        stack.append(Int(s[0])!)
        var i = 1
        var prev = Int(s[2])
        while i < logs.count {
            s = logs[i].split(separator: ":")
            if s[1] == "start" {
                if !stack.isEmpty {
                    let index = stack.last!
                    let val = res[index]
                    res[index] = val + Int(s[2])! - prev!
                }
                stack.append(Int(s[0])!)
                prev = Int(s[2])
            } else {
                let index = stack.last!
                res[index] = res[index] + Int(s[2])! - prev! + 1
                stack.removeLast()
                prev = Int(s[2])! + 1
            }
            i += 1
        }
        return res
    }
}

---

Runtime: 208 ms

Memory Usage: 20 MB

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var stack = [Int]()
        var pre = 0
        var res = Array(repeating: 0, count: n)
        
        for log in logs {
            
            let tokens = log.components(separatedBy: ":")
            
            let id = Int(tokens[0])!
            let act = tokens[1]
            let time = Int(tokens[2])!
            
            if act == "start" {
                
                if !stack.isEmpty {
                    
                    let top = stack[stack.count - 1]
                    res[top] += time - pre
                }
                
                stack.append(id)
                pre = time
                
            } else {
                
                res[stack.removeLast()] += time - pre + 1
                pre = time + 1
            }
        }        
        return res
    }
}

---

232ms

class Solution {
func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
    var result = Array(repeating: 0, count: n)
    
    var funcStack = [Int]()
    var prev = 0
    
    for s in logs {
        let fId = Int(s.prefix(upTo: s.firstIndex(of: ":")!))!
        let time = Int(s.suffix(from: s.index(after: s.lastIndex(of: ":")!)))!
        
        if s.contains("start") {
            if let last = funcStack.last {
                result[last] += time - prev
            }
            
            prev = time
            funcStack.append(fId)
        } else {
            if let last = funcStack.last {
                result[last] += time - prev + 1
                funcStack.removeLast()
                prev = time + 1
            }
        }
    }
    return result
   }
}

---

248ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var stack: [Int] = [] // store the function id
        var res: [Int] = Array(repeating: 0, count: n)
        var pre: Int = 0
        for log in logs {
            let l = log.components(separatedBy: ":")
            let id = Int(l[0])!
            let curr = Int(l[2])!
            if l[1] == "start" {
                if !stack.isEmpty {
                    res[stack.last!] += curr - pre
                }
                stack.append(id)
                pre = curr
            } else {
                res[stack.last!] += (curr - pre + 1)
                stack.removeLast()
                pre = curr + 1
            }
        }        
        return res
    }
}

---

252ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {

        if n == 0 || logs.count == 0 { return [] }
        var tuples = [(Int, Bool, Int)]()
        logs.forEach {
            let vals = $0.components(separatedBy: ":")
            let id = Int(vals[0])!
            let isStart = vals[1] == "start"
            let time = Int(vals[2])!
            tuples.append((id, isStart, time))
        }
        
        var result = [Int](repeating: 0, count: n)
        var stack = [(Int, Bool, Int)]()
        var lastTime = 0
        
        tuples.forEach {
            if $0.1 {
                if !stack.isEmpty {
                    let last = stack.last!
                    let time = $0.2 - lastTime
                    result[last.0] += time
                }
                lastTime = $0.2
                stack.append($0)
            } else {
                let last = stack.removeLast()
                let time = $0.2 - lastTime + 1
                result[last.0] += time
                lastTime = $0.2 + 1
            }
        }        
        return result
    }
}

---

256ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        guard n != 0 && logs.count > 0 else {return []}
        var times = [Int](repeating: 0, count: n)
        
        var st = [(op: Int, runtime: Int)]()
        for log in logs {
            let comp = log.components(separatedBy: ":")
            guard comp.count == 3 else {continue}
            guard let op = Int(comp[0]), let currTime = Int(comp[2]) else {continue}
            
            
            if comp[1] == "start" {
                if st.count > 0 {
                    let currTop = st.last!
                    times[currTop.op] += currTime - st[st.count - 1].runtime
                }
                st.append((op, currTime))
            } else {
                if st.count == 0 || st.last!.op != op {return []}
                let currTop = st.removeLast()
                times[currTop.op] += currTime - currTop.runtime + 1
                if st.count > 0 {
                    st[st.count - 1].runtime = currTime + 1
                }
            }            
        }
        return times
    }
}

---

276ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var stack = [(Int, Int)]()
        var ans = [Int](repeating: 0, count: n)
        for i in 0..<logs.count {
            let components = logs[i].components(separatedBy: ":")
            let timestamp = Int(components[2])!
            let functionID = Int(components[0])!
            let functionState = components[1]
            
            if functionState == "start" {
                if let last = stack.last { // Count the last run
                    ans[last.0] += (timestamp - last.1) // timestamp is not inclusive
                }
                stack.append((functionID, timestamp))
            } else {
                let last = stack.removeLast()
                ans[functionID] += (timestamp - last.1 + 1) // timestamp is inclusive
                if let last = stack.last { // Update the last timestamp
                    stack.removeLast()
                    stack.append((last.0, timestamp + 1))
                }
            }
        }
        return ans
    }
}

---

284ms

class Solution {    
    func parseString(_ log: String) -> (Int, Int, Bool) {
        let start = ":start:"
        let end = ":end:"
        var separator = ""
        if log.contains(start) {
            let nums = log.components(separatedBy: start).compactMap { Int($0) }
            return (nums[0], nums[1], true)
        } else {
            let nums = log.components(separatedBy: end).compactMap { Int($0) }
            return (nums[0], nums[1], false)
        }
    }
    
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var stack = [Int]()
        var exclusiveTime = Array(repeating: 0, count: n)
        var lastTimestamp = 0
        for log in logs {
            let (id, time, isStart) = parseString(log)
            if let lastId = stack.last {
                exclusiveTime[lastId] += time - lastTimestamp
                if !isStart {
                    exclusiveTime[lastId] += 1
                }
            }
            lastTimestamp = time
            if isStart {
                stack.append(id)
            } else {
                stack.removeLast()
                lastTimestamp += 1
            }
        }
        return exclusiveTime
    }
}

---

296ms

class Solution {
    func exclusiveTime(_ n: Int, _ logs: [String]) -> [Int] {
        var res = Array(repeating: 0, count: n)
        var currRunning: Int?
        var currStart: Int=0
        var callStack = [Int]()
        for log in logs {
            let component = log.components(separatedBy: ":")
            let funcID = Int(component[0])!
            let funcTime = Int(component[2])!
            let isStart = (component[1] == "start")
            if isStart {
                
                if currRunning != nil {
                    res[currRunning!]+=funcTime-currStart
                }
                    currRunning = funcID
                    currStart = funcTime
                    callStack.append(funcID)
                //} else {
                    //recursive, dont need to update
                //}
                
                
            } else { //end
                guard funcID == callStack.last! else { return [] }
                if let currRunning = currRunning {
                    res[currRunning]+=funcTime-currStart+1
                }
                callStack = Array(callStack.dropLast())
                currRunning = callStack.last
                currStart = funcTime+1
            }
        }
        return res
    }
}