Problem

Given an asynchronous function fn and a time t in milliseconds, return a new time limited version of the input function. fn takes arguments provided to the **time limited **function.

The time limited function should follow these rules:

  • If the fn completes within the time limit of t milliseconds, the time limited function should resolve with the result.
  • If the execution of the fn exceeds the time limit, the time limited function should reject with the string "Time Limit Exceeded".

Examples

Example 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

Input: 
fn = async (n) => { 
  await new Promise(res => setTimeout(res, 100)); 
  return n * n; 
}
inputs = [5]
t = 50
Output: {"rejected":"Time Limit Exceeded","time":50}
Explanation:
const limited = timeLimit(fn, t)
const start = performance.now()
let result;
try {
   const res = await limited(...inputs)
   result = {"resolved": res, "time": Math.floor(performance.now() - start)};
} catch (err) {
   result = {"rejected": err, "time": Math.floor(performance.now() - start)};
}
console.log(result) // Output

The provided function is set to resolve after 100ms. However, the time limit is set to 50ms. It rejects at t=50ms because the time limit was reached.

Example 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Input: 
fn = async (n) => { 
  await new Promise(res => setTimeout(res, 100)); 
  return n * n; 
}
inputs = [5]
t = 150
Output: {"resolved":25,"time":100}
Explanation:
The function resolved 5 * 5 = 25 at t=100ms. The time limit is never reached.

Example 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Input: 
fn = async (a, b) => { 
  await new Promise(res => setTimeout(res, 120)); 
  return a + b; 
}
inputs = [5,10]
t = 150
Output: {"resolved":15,"time":120}
Explanation:
​​​​The function resolved 5 + 10 = 15 at t=120ms. The time limit is never reached.


#### Example 4

Input: 
fn = async () => { 
  throw "Error";
}
inputs = []
t = 1000
Output: {"rejected":"Error","time":0}
Explanation:
The function immediately throws an error.

Constraints

  • 0 <= inputs.length <= 10
  • 0 <= t <= 1000
  • fn returns a promise

Solution

Method 1 – Promise.race with Timeout

Intuition

We want to run the original async function, but if it takes longer than t milliseconds, we should reject with “Time Limit Exceeded”. This is a classic use case for Promise.race, where we race the original promise against a timeout promise.

Approach

  1. Return a new function that, when called, returns a Promise.
  2. Start the original function and a timeout promise in parallel.
  3. If the original function resolves or rejects before the timeout, propagate its result.
  4. If the timeout fires first, reject with the required message.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/**
 * @param {Function} fn
 * @param {number} t
 * @return {Function}
 */
var timeLimit = function(fn, t) {
    return async function(...args) {
        return Promise.race([
            fn(...args),
            new Promise((_, reject) => setTimeout(() => reject("Time Limit Exceeded"), t))
        ]);
    }
};
1
2
3
4
5
6
7
8

function timeLimit<T extends (...args: any[]) => Promise<any>>(fn: T, t: number): (...args: Parameters<T>) => Promise<ReturnType<T> extends Promise<infer R> ? R : never> {
    return async (...args: Parameters<T>) => {
        return Promise.race([
            fn(...args),
            new Promise((_, reject) => setTimeout(() => reject("Time Limit Exceeded"), t))
        ]) as any;
    };
}

Complexity

  • ⏰ Time complexity: O(1) for the wrapper, plus the time taken by the original function.
  • 🧺 Space complexity: O(1) for the wrapper.