Exclusive Time of Functions - Practice Coding Problems

Exclusive Time of Functions - Problem

Array Stack Medium

Imagine you're monitoring a single-threaded CPU that executes a program containing n functions. Each function has a unique ID from 0 to n-1, and function calls follow a stack-based execution model - when a function starts, it's pushed onto the call stack, and when it ends, it's popped off.

You're given execution logs in the format "function_id:start:timestamp" or "function_id:end:timestamp". For example:

"0:start:3" means function 0 started at the beginning of timestamp 3
"1:end:2" means function 1 ended at the end of timestamp 2

Your task: Calculate the exclusive execution time for each function. This means the total time each function spent actually executing (not waiting for other functions to complete).

Key insight: When a function calls another function, the caller's execution is paused until the callee returns. You need to track which function is actively running at each moment.

Input & Output

example_1.py — Basic Function Calls

$ Input: n = 2, logs = ["0:start:0","1:start:2","1:end:5","0:end:6"]

› Output: [3,4]

💡 Note: Function 0 starts at 0, runs until 2 (2 units), then waits while function 1 runs from 2-5 (4 units), then resumes from 6-6 (1 unit). Total for F0: 2+1=3. Function 1 runs exclusively from 2-5, total: 4 units.

example_2.py — Single Function

$ Input: n = 1, logs = ["0:start:0","0:end:0"]

› Output: [1]

💡 Note: Function 0 starts at timestamp 0 and ends at timestamp 0, running for exactly 1 unit of time (from beginning of 0 to end of 0).

example_3.py — Nested Recursive Calls

$ Input: n = 2, logs = ["0:start:0","0:start:2","0:end:5","0:start:6","0:end:6","0:end:7"]

› Output: [8,0]

💡 Note: Function 0 has multiple recursive calls. First instance runs 0-1 (2 units), second instance runs 2-5 (4 units), third instance runs 6-6 (1 unit), then first instance resumes 7-7 (1 unit). Total: 2+4+1+1=8. Function 1 never executes.

Constraints

1 ≤ n ≤ 100
1 ≤ logs.length ≤ 500
0 ≤ function_id < n
All function calls are properly nested and matched
0 ≤ timestamp ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Function 0 Starts

Push F0 to stack, start timer at timestamp 0

Function 1 Starts

Pause F0 timer (2 units elapsed), push F1 to stack at timestamp 2

Function 1 Ends

F1 executed for 4 units (timestamp 2-5), pop F1, resume F0 timer

Function 0 Ends

F0 executed for 1 more unit (timestamp 6), total F0: 3 units

Key Takeaway

🎯 Key Insight: Only the function on top of the stack is actively executing - all others are waiting for nested calls to complete!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a stack-based approach to track active function calls. As we process each log entry, we maintain the function call stack and calculate exclusive execution time by tracking time differences between events. When a function starts, we pause the current function's timer. When it ends, we calculate its execution time and resume the previous function. This approach runs in O(n) time and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Simulation (Optimal)	O(n)	O(n)	Use stack to track active functions and calculate exclusive time incrementally
Brute Force (Timeline Simulation)	O(T)	O(T + n)	Simulate each timestamp and track which function is executing

Stack-Based Simulation (Optimal) — Algorithm Steps

Initialize stack to track active functions and result array
Process each log entry in chronological order
For 'start' events: pause current function, push new function to stack
For 'end' events: calculate execution time, pop from stack, resume previous function
Update exclusive time by tracking time differences between events

Visualization

Tap to expand

Step-by-Step Walkthrough

Function Starts

Push to stack, pause previous function timer

Nested Call

Another function starts, previous paused again

Function Ends

Pop from stack, add execution time, resume previous

Final Result

All functions completed, exclusive times calculated

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* exclusiveTime(int n, char** logs, int logsSize, int* returnSize) {
    *returnSize = n;
    int* result = (int*)calloc(n, sizeof(int));
    int stack[n];
    int stackTop = -1;
    int prevTime = 0;
    
    for (int i = 0; i < logsSize; i++) {
        char* log = strdup(logs[i]);
        char* token = strtok(log, ":");
        int funcId = atoi(token);
        token = strtok(NULL, ":");
        int isStart = strcmp(token, "start") == 0;
        token = strtok(NULL, ":");
        int timestamp = atoi(token);
        
        if (isStart) {
            // If there's a function currently running, add its execution time
            if (stackTop >= 0) {
                result[stack[stackTop]] += timestamp - prevTime;
            }
            // Push new function to stack
            stack[++stackTop] = funcId;
            prevTime = timestamp;
        } else { // end
            // Add execution time for the ending function
            result[stack[stackTop]] += timestamp - prevTime + 1;
            // Pop the function from stack
            stackTop--;
            // Update prevTime for next function
            prevTime = timestamp + 1;
        }
        
        free(log);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all log entries, each operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n functions in worst case (all nested calls)

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Stack-Based Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler