Timeout Cancellation - Practice Coding Problems

Timeout Cancellation - Problem

JavaScript Easy

Given a function fn, an array of arguments args, and a timeout t in milliseconds, return a cancel function cancelFn.

After a delay of cancelTimeMs, the returned cancel function cancelFn will be invoked.

setTimeout(cancelFn, cancelTimeMs)

Initially, the execution of the function fn should be delayed by t milliseconds.

If, before the delay of t milliseconds, the function cancelFn is invoked, it should cancel the delayed execution of fn. Otherwise, if cancelFn is not invoked within the specified delay t, fn should be executed with the provided args as arguments.

Input & Output

Example 1 — Function Gets Cancelled

$ Input: fn = "sum", args = [1,2,3], t = 100ms, cancelTimeMs = 50ms

› Output: "Function was cancelled"

💡 Note: Cancel function is called after 50ms, before the 100ms timeout, so the function never executes

Example 2 — Function Executes

$ Input: fn = "mult", args = [2,4], t = 50ms, cancelTimeMs = 100ms

› Output: Function executes and returns 8

💡 Note: Function executes after 50ms because cancel isn't called until 100ms

Example 3 — Immediate Cancellation

$ Input: fn = "sum", args = [5], t = 1000ms, cancelTimeMs = 0ms

› Output: "Function was cancelled"

💡 Note: Cancel is called immediately (0ms), preventing execution

Constraints

fn is a function that takes arguments args
0 ≤ args.length ≤ 10
10 ≤ t ≤ 1000
0 ≤ cancelTimeMs ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input

Function, arguments, and timeout delay

Process

Schedule function execution and provide cancel mechanism

Output

Either function executes or cancellation message

Key Takeaway

🎯 Key Insight: JavaScript's setTimeout/clearTimeout provides precise control over scheduled function execution with proper cancellation mechanism

Asked in

G Google 25 M Microsoft 20 F Facebook 15

The key insight is to use JavaScript's setTimeout and clearTimeout mechanism for proper timer management. Best approach is the clearTimeout method which completely removes the scheduled timer. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Basic setTimeout with Flag	O(1)	O(1)	Use a boolean flag to track if function should execute
clearTimeout Approach	O(1)	O(1)	Use clearTimeout to actually cancel the scheduled execution

Basic setTimeout with Flag — Algorithm Steps

Set a boolean flag to true
Create setTimeout to execute function after delay
Return cancel function that sets flag to false
Check flag before executing function in timeout

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Timer

Create setTimeout and set cancelled flag to false

Cancel Called

Cancel function sets flag to true

Timer Fires

Function checks flag and skips execution

Code -

solution.c — C

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

typedef struct {
    char fn[20];
    int* args;
    int args_len;
    int t;
    int* cancelled;
} ThreadData;

void* delayed_execution(void* data) {
    ThreadData* td = (ThreadData*)data;
    usleep(td->t * 1000); // Convert ms to microseconds
    
    if (!*(td->cancelled)) {
        if (strcmp(td->fn, "sum") == 0) {
            int sum = 0;
            for (int i = 0; i < td->args_len; i++) {
                sum += td->args[i];
            }
            printf("Function executed: %d\n", sum);
        } else if (strcmp(td->fn, "mult") == 0) {
            int product = 1;
            for (int i = 0; i < td->args_len; i++) {
                product *= td->args[i];
            }
            printf("Function executed: %d\n", product);
        }
    }
    
    return NULL;
}

char* solution(char* fn, int* args, int args_len, int t) {
    static int cancelled = 0;
    
    ThreadData* td = malloc(sizeof(ThreadData));
    strcpy(td->fn, fn);
    td->args = args;
    td->args_len = args_len;
    td->t = t;
    td->cancelled = &cancelled;
    
    pthread_t thread;
    pthread_create(&thread, NULL, delayed_execution, td);
    pthread_detach(thread);
    
    cancelled = 1; // Cancel immediately for demo
    return "Function was cancelled";
}

int main() {
    char fn[100];
    fgets(fn, sizeof(fn), stdin);
    fn[strcspn(fn, "\n")] = 0;
    // Remove quotes
    if (fn[0] == '"') {
        memmove(fn, fn + 1, strlen(fn));
        fn[strlen(fn) - 1] = '\0';
    }
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array [1,2,3] manually
    int args[100];
    int args_len = 0;
    char* token = strtok(line + 1, ",]"); // Skip opening bracket
    while (token != NULL) {
        args[args_len++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int t;
    scanf("%d", &t);
    
    char* result = solution(fn, args, args_len, t);
    printf("\"%s\"\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations are constant time - setting variables and creating timeout

✓ Linear Growth

Space Complexity

O(1)

Only stores a boolean flag and timeout reference

✓ Linear Space

24.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Basic setTimeout with Flag — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler