Skip to main content
Talentd

Timeout Cancellation - Solution & Explanation

Easy13 min readAsked at: Meta, Google
Practice this problem

Problem Statement

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.

 

Example 1:

Input: fn = (x) => x * 5, args = [2], t = 20
Output: [{"time": 20, "returned": 10}]
Explanation: 
const cancelTimeMs = 50;
const cancelFn = cancellable((x) => x * 5, [2], 20);
setTimeout(cancelFn, cancelTimeMs);

The cancellation was scheduled to occur after a delay of cancelTimeMs (50ms), which happened after the execution of fn(2) at 20ms.

Example 2:

Input: fn = (x) => x**2, args = [2], t = 100
Output: []
Explanation: 
const cancelTimeMs = 50;
const cancelFn = cancellable((x) => x**2, [2], 100);
setTimeout(cancelFn, cancelTimeMs);

The cancellation was scheduled to occur after a delay of cancelTimeMs (50ms), which happened before the execution of fn(2) at 100ms, resulting in fn(2) never being called.

Example 3:

Input: fn = (x1, x2) => x1 * x2, args = [2,4], t = 30
Output: [{"time": 30, "returned": 8}]
Explanation: 
const cancelTimeMs = 100;
const cancelFn = cancellable((x1, x2) => x1 * x2, [2,4], 30);
setTimeout(cancelFn, cancelTimeMs);

The cancellation was scheduled to occur after a delay of cancelTimeMs (100ms), which happened after the execution of fn(2,4) at 30ms.

 

Constraints:

  • fn is a function
  • args is a valid JSON array
  • 1 <= args.length <= 10
  • 20 <= t <= 1000
  • 10 <= cancelTimeMs <= 1000

Approach Overview

Problem Overview: You need to schedule a function fn to run after t milliseconds and return another function that cancels the scheduled execution. If the cancel function runs before the timer fires, fn must never execute. This problem checks your understanding of timer APIs and basic asynchronous programming.

Approach 1: Using setTimeout and clearTimeout (O(1) time, O(1) space)

The direct solution schedules the callback using setTimeout and stores the returned timer identifier. JavaScript timers return an ID that uniquely represents the scheduled task. The cancellation function simply calls clearTimeout(timerId), which removes the scheduled callback from the event loop queue before it executes.

The key insight is that timer scheduling and cancellation are constant‑time operations managed by the runtime. No iteration or extra data structures are required. When the cancel function executes before the delay expires, the timer is invalidated and the callback never runs. If the timer already fired, calling clearTimeout has no effect.

This approach mirrors how real systems manage scheduled tasks. Most interviewers expect you to know the relationship between setTimeout and clearTimeout and how the event loop handles deferred execution in JavaScript.

Approach 2: Using Promises for Asynchronous Control (O(1) time, O(1) space)

Another implementation wraps the delayed execution inside a Promise. A timer triggers the promise resolution after t milliseconds, which then executes the callback. The cancellation function prevents the resolution by clearing the timer or toggling a flag that stops the callback from running.

This design is useful when your codebase already relies heavily on promises or async workflows. For example, a promise-based wrapper can integrate with async/await, cancellation tokens, or higher-level task management systems. The runtime cost remains constant because only one timer and one promise object are created.

While slightly more abstract, this version demonstrates how timers can coordinate with Promises to control asynchronous flow. The core mechanism still relies on canceling the scheduled timeout before execution.

Recommended for interviews: The setTimeout + clearTimeout approach is the expected solution. It shows you understand how timers work in the event loop and how scheduled callbacks can be canceled. The promise-based version is useful for system design discussions or async-heavy applications, but the direct timer cancellation approach is clearer and closer to how the runtime APIs are designed.

Approach 1: Using setTimeout and clearTimeout

This approach leverages JavaScript's built-in setTimeout and clearTimeout functions. We schedule a timeout to execute the function fn after t milliseconds, and we return a cancelFn that, when called, cancels this scheduled timeout.

C does not have direct support for asynchronous delay management similar to setTimeout in JavaScript, particularly in standard libraries. Such functionality generally requires external libraries or platform-specific code for thread and timer management.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

In C, without a standard set of functions for asynchronous timeouts, it's less about algorithmic complexity and more about the overhead of managing threads, which varies based on the implementation details.

Try this approach in the editor →

Approach 2: Using Promises for Asynchronous Control

This alternative approach involves using Promises to manage asynchronous execution and potential cancelation. By wrapping the setTimeout within a Promise, we can have more control over its execution and cancelation by managing the Promise lifecycle.

Similar to the first approach, C would require a significant amount of helper code to achieve a Promise-like system, often using threads and synchronization primitives, unavailable directly in the standard library.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity and space complexity would depend on the specific threading mechanism and the use of synchronization primitives.

Try this approach in the editor →

Approach 3: Default Approach

Code

TypeScriptJavaScript

TypeScript

JavaScript

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Using setTimeout and clearTimeout

In C, without a standard set of functions for asynchronous timeouts, it's less about algorithmic complexity and more about the overhead of managing threads, which varies based on the implementation details.

Using Promises for Asynchronous Control

Time Complexity and space complexity would depend on the specific threading mechanism and the use of synchronization primitives.

Default Approach—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Using setTimeout and clearTimeoutO(1)O(1)Standard solution when working directly with timers or event loop scheduling
Using Promises for Asynchronous ControlO(1)O(1)When integrating timer logic into promise-based or async/await workflows

Video Solution

Timeout Cancellation | Leetcode 2715 | Promises and Time | 30 Days of JavaScript #javascript • Learn With Chirag • 3,795 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Timeout Cancellation easy or hard?
Timeout Cancellation is considered an Easy problem. The main concept is understanding how scheduled callbacks work and how to cancel them before execution using a timer identifier.
Timeout Cancellation Python/Java solution
In JavaScript the solution uses setTimeout and clearTimeout directly. In languages like Python or Java, similar behavior can be implemented using scheduling utilities such as threading timers, scheduled executors, or async task handlers that support cancellation.
How to solve Timeout Cancellation in O(1)?
Store the timer ID returned from setTimeout when scheduling the callback. Return a function that calls clearTimeout(timerId). Because timer operations are handled internally by the runtime event loop, both scheduling and cancellation execute in constant time.
What is the best approach for Timeout Cancellation?
The most straightforward approach uses setTimeout to schedule the callback and clearTimeout to cancel it. The timer ID returned by setTimeout is stored and passed to clearTimeout inside the cancel function. Both scheduling and cancellation run in O(1) time and require O(1) space.
Is Timeout Cancellation asked at Google/Amazon/Meta?
Timeout and asynchronous control questions appear in frontend and JavaScript-focused interviews at companies like Google, Amazon, and Meta. While this exact problem may vary, understanding timers, event loops, and cancellation patterns is commonly tested.
What data structure is used in Timeout Cancellation?
No explicit data structure is required. The solution relies on the runtime timer system where setTimeout returns a numeric or object-based timer ID that can be passed to clearTimeout for cancellation.
What is the time complexity of Timeout Cancellation?
Timeout scheduling and cancellation both run in constant time. Creating the timer with setTimeout is O(1), and canceling it using clearTimeout is also O(1). The solution does not depend on input size and uses constant memory.

Ready to solve this problem?

Practice Timeout Cancellation with our built-in code editor and test cases.

Practice on FleetCode