On a **single-threaded** CPU, we execute a program containing `n` functions. Each function has a unique ID between `0` and `n-1`.

Function calls are **stored in a [call stack](https://en.wikipedia.org/wiki/Call_stack)**: when a function call starts, its ID is pushed onto the stack, and when a function call ends, its ID is popped off the stack. The function whose ID is at the top of the stack is **the current function being executed**. Each time a function starts or ends, we write a log with the ID, whether it started or ended, and the timestamp.

You are given a list `logs`, where `logs[i]` represents the `ith` log message formatted as a string `"{function_id}:{ "start " | "end "}:{timestamp} "`. For example, `"0:start:3 "` means a function call with function ID `0` **started at the beginning** of timestamp `3`, and `"1:end:2 "` means a function call with function ID `1` **ended at the end** of timestamp `2`. Note that a function can be called **multiple times, possibly recursively**.

A function's **exclusive time** is the sum of execution times for all function calls in the program. For example, if a function is called twice, one call executing for `2` time units and another call executing for `1` time unit, the **exclusive time** is `2 + 1 = 3`.

Return _the **exclusive time** of each function in an array, where the value at the_ `ith` _index represents the exclusive time for the function with ID_ `i`.

**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 the beginning of time 0, then it executes 2 for units of time and reaches the end of time 1.
Function 1 starts at the beginning of time 2, executes for 4 units of time, and ends at the end of time 5.
Function 0 resumes execution at the beginning of time 6 and executes for 1 unit of time.
So function 0 spends 2 + 1 = 3 units of total time executing, and function 1 spends 4 units of total time executing.

**Example 2:**

**Input:** n = 1, logs = \[ "0:start:0 ", "0:start:2 ", "0:end:5 ", "0:start:6 ", "0:end:6 ", "0:end:7 "\]
**Output:** \[8\]
**Explanation:**
Function 0 starts at the beginning of time 0, executes for 2 units of time, and recursively calls itself.
Function 0 (recursive call) starts at the beginning of time 2 and executes for 4 units of time.
Function 0 (initial call) resumes execution then immediately calls itself again.
Function 0 (2nd recursive call) starts at the beginning of time 6 and executes for 1 unit of time.
Function 0 (initial call) resumes execution at the beginning of time 7 and executes for 1 unit of time.
So function 0 spends 2 + 4 + 1 + 1 = 8 units of total time executing.

**Example 3:**

**Input:** n = 2, logs = \[ "0:start:0 ", "0:start:2 ", "0:end:5 ", "1:start:6 ", "1:end:6 ", "0:end:7 "\]
**Output:** \[7,1\]
**Explanation:**
Function 0 starts at the beginning of time 0, executes for 2 units of time, and recursively calls itself.
Function 0 (recursive call) starts at the beginning of time 2 and executes for 4 units of time.
Function 0 (initial call) resumes execution then immediately calls function 1.
Function 1 starts at the beginning of time 6, executes 1 unit of time, and ends at the end of time 6.
Function 0 resumes execution at the beginning of time 6 and executes for 2 units of time.
So function 0 spends 2 + 4 + 1 = 7 units of total time executing, and function 1 spends 1 unit of total time executing.

**Constraints:**

*   `1 <= n <= 100`
*   `1 <= logs.length <= 500`
*   `0 <= function_id < n`
*   `0 <= timestamp <= 109`
*   No two start events will happen at the same timestamp.
*   No two end events will happen at the same timestamp.
*   Each function has an `"end "` log for each `"start "` log.

단일 스레드** CPU에서 `n`개의 함수가 포함된 프로그램을 실행합니다. 각 함수는 `0`에서 `n-1` 사이의 고유 ID를 갖습니다.

함수 호출은 [호출 스택](https://en.wikipedia.org/wiki/Call_stack)에 **저장됩니다. 함수 호출이 시작되면 해당 ID가 스택으로 밀려 들어가고, 함수 호출이 종료되면 해당 ID가 스택에서 튀어나옵니다. 스택의 맨 위에 있는 함수의 ID는 **현재 실행 중인 함수**입니다. 함수가 시작되거나 종료될 때마다 ID, 시작 또는 종료 여부, 타임스탬프가 포함된 로그를 기록합니다.

로그` 리스트가 주어지며, 여기서 `logs[i]`는 문자열 `"{function_id}:{ "start" | "end"}:{timestamp} "`. 예를 들어, `"0:start:3"`은 타임스탬프 `3`의 시작 부분에서 **시작**한 함수 ID `0`의 함수 호출을 의미하고, `"1:end:2"`은 타임스탬프 `2`의 끝 부분에서 **종료**한 함수 ID `1`의 함수 호출을 의미합니다. 함수는 재귀적으로 **여러 번 호출될 수 있습니다**.

함수의 **배타적 시간**은 프로그램 내 모든 함수 호출의 실행 시간을 합한 것입니다. 예를 들어, 함수가 두 번 호출되고 한 번은 `2` 시간 단위로 실행되고 다른 호출은 `1` 시간 단위로 실행되는 경우, **배타적 시간**은 `2 + 1 = 3`입니다.

각 함수의 **배타적 시간**을 배열로 반환하며, 여기서 `ith` _인덱스의 값은 ID가 `i`인 함수의 배타적 시간을 나타냅니다.

**예제 1:**

**Input:** n = 2, logs = \["0:start:0 ","1:start:2 ","1:end:5 ","0:end:6"\]
**출력:** \[3,4\]
**설명:**
함수 0은 시간 0의 시작에서 시작하여 시간 단위로 2를 실행하고 시간 1의 끝에 도달합니다.
함수 1은 시간 2의 시작에서 시작하여 4 단위 시간 동안 실행되고 시간 5의 끝에서 종료됩니다.
함수 0은 시간 6이 시작될 때 실행을 재개하고 1 단위 시간 동안 실행됩니다.
따라서 함수 0은 2 + 1 = 3 단위의 총 시간을 실행하는 데 소비하고 함수 1은 4 단위의 총 시간을 실행하는 데 소비합니다.

**예제 2:**

**입력:** n = 1, logs = \["0:start:0 ","0:start:2 ","0:end:5 ","0:start:6 ","0:end:6 ","0:end:7"\]
**출력:** \[8\]
**설명:**
함수 0은 시간 0의 시작에서 시작하여 2 단위 시간 동안 실행되며 재귀적으로 자신을 호출합니다.
함수 0(재귀 호출)은 시간 2의 시작에서 시작하여 4 단위 시간 동안 실행됩니다.
함수 0(초기 호출)은 실행을 재개한 후 즉시 자신을 다시 호출합니다.
함수 0(두 번째 재귀 호출)은 시간 6의 시작에서 시작하여 1 단위 시간 동안 실행됩니다.
함수 0(초기 호출)은 시간 7이 시작될 때 실행을 재개하고 1 단위 시간 동안 실행됩니다.
따라서 함수 0은 2 + 4 + 1 + 1 = 총 8 단위의 시간을 실행하는 데 소비합니다.

**예제 3:**

**입력:** n = 2, logs = \["0:start:0 ","0:start:2 ","0:end:5 ","1:start:6 ","1:end:6 ","0:end:7"\]
**Output:** \[7,1\]
**설명:**
함수 0은 시간 0의 시작에서 시작하여 2 단위 시간 동안 실행되며 재귀적으로 자신을 호출합니다.
함수 0(재귀 호출)은 시간 2의 시작에서 시작하여 4 단위 시간 동안 실행됩니다.
함수 0(초기 호출)은 실행을 재개한 후 즉시 함수 1을 호출합니다.
함수 1은 시간 6의 시작에서 시작하여 1단위 시간을 실행한 후 시간 6의 끝에서 종료됩니다.
함수 0은 시간 6이 시작될 때 실행을 재개하고 2 단위 시간 동안 실행합니다.
따라서 함수 0은 2 + 4 + 1 = 7 단위의 총 시간을 실행하는 데 소비하고 함수 1은 1 단위의 총 시간을 실행하는 데 소비합니다.

**제약 조건:**

* `1 <= n <= 100`
* `1 <= logs.length <= 500`
* `0 <= function_id < n`
* `0 <= timestamp <= 109`
* 두 개의 시작 이벤트가 같은 타임스탬프에서 발생하지 않습니다.
* 동일한 타임스탬프에 두 개의 종료 이벤트가 발생하지 않습니다.
* 각 함수에는 `"시작"` 로그마다 `"종료"` 로그가 있습니다.
