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 functionargs is a valid JSON array1 <= args.length <= 1020 <= t <= 100010 <= cancelTimeMs <= 1000This 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.
C++
Java
Python
C#
JavaScript
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.
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.
C++
Java
Python
C#
JavaScript
Time Complexity and space complexity would depend on the specific threading mechanism and the use of synchronization primitives.
| Approach | Complexity |
|---|---|
| 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. |
Leetcode Interviews • ThePrimeTime • 1,196,238 views views
Watch 9 more video solutions →Practice Timeout Cancellation with our built-in code editor and test cases.
Practice on FleetCode