Exclusive Time of Functions

// Accepted solution for LeetCode #636: Exclusive Time of Functions
class Solution {
    public int[] exclusiveTime(int n, List<String> logs) {
        int[] ans = new int[n];
        Deque<Integer> stk = new ArrayDeque<>();
        int pre = 0;
        for (var log : logs) {
            var parts = log.split(":");
            int i = Integer.parseInt(parts[0]);
            int cur = Integer.parseInt(parts[2]);
            if (parts[1].charAt(0) == 's') {
                if (!stk.isEmpty()) {
                    ans[stk.peek()] += cur - pre;
                }
                stk.push(i);
                pre = cur;
            } else {
                ans[stk.pop()] += cur - pre + 1;
                pre = cur + 1;
            }
        }
        return ans;
    }
}

// Accepted solution for LeetCode #636: Exclusive Time of Functions
func exclusiveTime(n int, logs []string) []int {
	ans := make([]int, n)
	stk := []int{}
	pre := 0
	for _, log := range logs {
		parts := strings.Split(log, ":")
		i, _ := strconv.Atoi(parts[0])
		cur, _ := strconv.Atoi(parts[2])
		if parts[1][0] == 's' {
			if len(stk) > 0 {
				ans[stk[len(stk)-1]] += cur - pre
			}
			stk = append(stk, i)
			pre = cur
		} else {
			ans[stk[len(stk)-1]] += cur - pre + 1
			stk = stk[:len(stk)-1]
			pre = cur + 1
		}
	}
	return ans
}

# Accepted solution for LeetCode #636: Exclusive Time of Functions
class Solution:
    def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:
        stk = []
        ans = [0] * n
        pre = 0
        for log in logs:
            i, op, t = log.split(":")
            i, cur = int(i), int(t)
            if op[0] == "s":
                if stk:
                    ans[stk[-1]] += cur - pre
                stk.append(i)
                pre = cur
            else:
                ans[stk.pop()] += cur - pre + 1
                pre = cur + 1
        return ans

// Accepted solution for LeetCode #636: Exclusive Time of Functions
struct Solution;

enum Action {
    Start,
    End,
}

impl Solution {
    fn exclusive_time(n: i32, logs: Vec<String>) -> Vec<i32> {
        let n = n as usize;
        let mut stack: Vec<usize> = vec![];
        let mut res: Vec<i32> = vec![0; n];
        let mut prev = 0;
        for log in logs {
            let mut it = log.split(':');
            let id: usize = it.next().unwrap().parse::<usize>().unwrap();
            let action: Action = if it.next().unwrap() == "start" {
                Action::Start
            } else {
                Action::End
            };
            let val: i32 = it.next().unwrap().parse::<i32>().unwrap();
            match action {
                Action::Start => {
                    if let Some(&top) = stack.last() {
                        res[top] += val - prev;
                    }
                    prev = val;
                    stack.push(id);
                }
                Action::End => {
                    if let Some(top) = stack.pop() {
                        res[top] += val + 1 - prev;
                        prev = val + 1;
                    }
                }
            }
        }
        res
    }
}

#[test]
fn test() {
    let n = 2;
    let logs = vec_string!["0:start:0", "1:start:2", "1:end:5", "0:end:6"];
    let res = vec![3, 4];
    assert_eq!(Solution::exclusive_time(n, logs), res);
}

// Accepted solution for LeetCode #636: Exclusive Time of Functions
function exclusiveTime(n: number, logs: string[]): number[] {
    const ans: number[] = Array(n).fill(0);
    let pre = 0;
    const stk: number[] = [];
    for (const log of logs) {
        const [i, op, cur] = log.split(':');
        if (op[0] === 's') {
            if (stk.length) {
                ans[stk.at(-1)!] += +cur - pre;
            }
            stk.push(+i);
            pre = +cur;
        } else {
            ans[stk.pop()!] += +cur - pre + 1;
            pre = +cur + 1;
        }
    }
    return ans;
}