Promise Time Limit

Promise Time Limit - Problem

JavaScript Medium

Given an asynchronous function fn and a time t in milliseconds, return a new time limited version of the input function. The 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".

Input & Output

Example 1 — Function Completes in Time

$ Input: fn = async () => { await new Promise(res => setTimeout(res, 50)); return 'result'; }, t = 100

› Output: 'result'

💡 Note: Function takes 50ms to complete, which is within the 100ms limit, so it resolves with 'result'

Example 2 — Function Times Out

$ Input: fn = async () => { await new Promise(res => setTimeout(res, 200)); return 'result'; }, t = 100

› Output: Time Limit Exceeded

💡 Note: Function takes 200ms but timeout is 100ms, so the timeout promise rejects first with 'Time Limit Exceeded'

Example 3 — Immediate Resolution

$ Input: fn = async () => 42, t = 50

› Output: 42

💡 Note: Function resolves immediately with 42, well within the 50ms timeout

Constraints

0 ≤ t ≤ 1000
fn returns a promise

Visualization

Tap to expand

Asked in

M Meta 25 G Google 20

The key insight is to use Promise.race to compete a timeout promise against the function execution. The optimal approach uses Promise.race for clean timeout handling. Time: O(1), Space: O(1)

Common Approaches

✓ Basic Timeout Implementation

⏱️ Time: O(1) Space: O(1)

Create a timeout promise that rejects after t milliseconds, then use Promise.race to compete the original function against the timeout. Handle the result based on which promise resolves first.

Promise.race Implementation

⏱️ Time: O(1) Space: O(1)

Leverage Promise.race to elegantly handle the competition between the function execution and timeout. This approach is more concise and follows JavaScript best practices for promise-based timeout handling.

Basic Timeout Implementation — Algorithm Steps

Step 1: Create a timeout promise that rejects after t milliseconds
Step 2: Execute the original function
Step 3: Use Promise.race to see which completes first

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Create timeout promise and execute function

Race

Both promises run simultaneously

Winner

First to complete determines the result

Code -

solution.c — C

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

char* solution(char* fnCode, int t) {
    // In C, we would return a wrapper that implements timeout logic
    // This is a conceptual implementation for the problem
    static char result[] = "timeLimit";
    return result;
}

int main() {
    char fnCode[1000];
    fgets(fnCode, sizeof(fnCode), stdin);
    fnCode[strcspn(fnCode, "\n")] = 0;
    
    int t;
    scanf("%d", &t);
    
    char* result = solution(fnCode, t);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time to set up promises, actual execution depends on function

✓ Linear Growth

Space Complexity

O(1)

Only stores references to promises and timeout

✓ Linear Space

23.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 Timeout Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler