Timeout Cancellation - Practice Coding Problems

Timeout Cancellation - Problem

JavaScript Easy

Timeout Cancellation is a fundamental JavaScript concurrency problem that tests your understanding of asynchronous operations and timing control.

You need to create a cancellable timeout system. Given a function fn, an array of arguments args, and a timeout delay t in milliseconds, your task is to:

1. Return a cancel function that can stop the execution
2. Schedule fn to execute after t milliseconds
3. If the cancel function is called before t milliseconds, prevent fn from executing
4. If the cancel function is not called, execute fn with the provided args

This pattern is commonly used in debouncing, request cancellation, and cleanup operations in real-world applications.

Input & Output

example_1.js — Function Executes (Not Cancelled)

$ Input: fn = (x) => x * 2, args = [5], t = 1000, cancelTimeMs = 2000

› Output: Function executes after 1000ms, outputs: 10

💡 Note: Since the cancel function is called after 2000ms but the function is scheduled to execute after 1000ms, the function executes normally and returns 10.

example_2.js — Function Cancelled Before Execution

$ Input: fn = () => console.log('Hello World'), args = [], t = 1000, cancelTimeMs = 500

› Output: Function never executes, no output

💡 Note: The cancel function is called after 500ms, which is before the scheduled execution time of 1000ms. Therefore, the function is cancelled and never executes.

example_3.js — Immediate Cancellation Edge Case

$ Input: fn = (a, b) => a + b, args = [3, 4], t = 100, cancelTimeMs = 0

› Output: Function cancelled immediately, no output

💡 Note: The cancel function is called immediately (0ms), preventing the function from executing even though it has a very short 100ms timeout.

Visualization

Tap to expand

Understanding the Visualization

Set Timer

setTimeout schedules function execution and returns a timer ID

Store ID

Keep the timer ID as a reference for potential cancellation

Wait or Cancel

Either the timer expires naturally or clearTimeout stops it early

Outcome

Function executes if timer completes, or gets cancelled if clearTimeout is called

Key Takeaway

🎯 Key Insight: JavaScript's setTimeout/clearTimeout provides O(1) timer management - the browser's event loop handles all the timing complexity for us efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Both setTimeout and clearTimeout are constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only stores a single timeout ID

✓ Linear Space

Constraints

1 ≤ t ≤ 10⁴ (timeout between 1ms and 10 seconds)
0 ≤ cancelTimeMs ≤ 10⁴ (cancellation can be immediate or delayed)
args is a valid array that matches fn's parameter signature
fn is guaranteed to be a valid function
The environment supports setTimeout and clearTimeout

Asked in

f Meta 45 G Google 38 N Netflix 32 a Amazon 28

The optimal solution uses JavaScript's native setTimeout and clearTimeout functions. We schedule the function execution with setTimeout, store the returned timer ID, and return a cancel function that calls clearTimeout with that ID. This approach is O(1) time and space complexity and leverages the browser's optimized timer system for precise timing control.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal setTimeout/clearTimeout	O(1)	O(1)	Use JavaScript's built-in setTimeout and clearTimeout for efficient cancellation
Manual Polling Approach	O(t)	O(1)	Use intervals to manually check if cancellation was requested

Optimal setTimeout/clearTimeout — Algorithm Steps

Call setTimeout with the function and delay
Store the returned timeout ID
Return a cancel function that calls clearTimeout with the stored ID
The browser's timer system handles the rest efficiently

Visualization

Tap to expand

Step-by-Step Walkthrough

Schedule Timeout

setTimeout returns an ID and schedules execution

Store ID

Keep the timeout ID for potential cancellation

Return Cancel Function

Provide clearTimeout wrapper function

Execute or Cancel

Browser handles timing and cancellation efficiently

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>
#include <signal.h>

typedef struct {
    void (*fn)(void);
    int timeout_ms;
    pthread_t thread_id;
    volatile int cancelled;
} cancellable_timeout_t;

void* timeout_worker(void* arg) {
    cancellable_timeout_t* ct = (cancellable_timeout_t*)arg;
    
    // Sleep for the specified timeout
    usleep(ct->timeout_ms * 1000);
    
    // Check if cancelled during sleep
    if (!ct->cancelled) {
        ct->fn();
    }
    
    return NULL;
}

cancellable_timeout_t* cancellable(void (*fn)(void), int t) {
    cancellable_timeout_t* ct = malloc(sizeof(cancellable_timeout_t));
    ct->fn = fn;
    ct->timeout_ms = t;
    ct->cancelled = 0;
    
    // Create thread to handle timeout
    pthread_create(&ct->thread_id, NULL, timeout_worker, ct);
    
    return ct;
}

void cancel_timeout(cancellable_timeout_t* ct) {
    ct->cancelled = 1;
    pthread_cancel(ct->thread_id);
}

void cleanup_timeout(cancellable_timeout_t* ct) {
    pthread_join(ct->thread_id, NULL);
    free(ct);
}

// Example usage
void test_function() {
    printf("Function executed!\n");
}

int main() {
    cancellable_timeout_t* ct = cancellable(test_function, 1000);
    
    // To test cancellation:
    // sleep(0.5);
    // cancel_timeout(ct);
    
    sleep(2);
    cleanup_timeout(ct);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Both setTimeout and clearTimeout are constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only stores a single timeout ID

✓ Linear Space

Constraints

1 ≤ t ≤ 10⁴ (timeout between 1ms and 10 seconds)
0 ≤ cancelTimeMs ≤ 10⁴ (cancellation can be immediate or delayed)
args is a valid array that matches fn's parameter signature
fn is guaranteed to be a valid function
The environment supports setTimeout and clearTimeout

48.3K Views

High Frequency

~15 min Avg. Time

2.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal setTimeout/clearTimeout — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler