Promise Time Limit - Practice Coding Problems

Promise Time Limit - Problem

JavaScript Medium

You're a performance optimization engineer at a tech company dealing with unreliable external API services. Your task is to create a time-limited wrapper for asynchronous functions to prevent your application from hanging indefinitely.

Given an asynchronous function fn and a time limit t in milliseconds, you need to return a new function that enforces this time constraint:

✅ If fn completes within the time limit, return its result
❌ If fn exceeds the time limit, reject with "Time Limit Exceeded"

The time-limited function should accept the same arguments as the original function and maintain proper error handling for both timeout scenarios and regular function failures.

Example: If you have an API call that should complete within 1000ms, but sometimes takes 3000ms due to network issues, your wrapper should automatically timeout and reject after 1000ms.

Input & Output

example_1.js — Fast API Call

$ Input: fn = async () => { await new Promise(resolve => setTimeout(resolve, 50)); return "Success!"; }, t = 100

› Output: "Success!"

💡 Note: The function completes in 50ms, which is well within the 100ms time limit, so it returns the successful result.

example_2.js — Slow API Call

$ Input: fn = async () => { await new Promise(resolve => setTimeout(resolve, 200)); return "Success!"; }, t = 100

› Output: "Time Limit Exceeded" (rejected)

💡 Note: The function takes 200ms but the time limit is only 100ms, so the timeout promise wins the race and rejects with the timeout message.

example_3.js — Function with Error

$ Input: fn = async () => { await new Promise(resolve => setTimeout(resolve, 50)); throw new Error("API Error"); }, t = 100

› Output: Error("API Error") (rejected)

💡 Note: The function completes within the time limit but throws an error, so that error is properly propagated rather than being masked by a timeout.

Visualization

Tap to expand

Understanding the Visualization

Starting Line

Both the original function and timeout promise start executing simultaneously

The Race

Function processes data while timeout counts down - no interference between them

First to Finish

Promise.race() automatically resolves with whichever promise completes first

Victory & Cleanup

Winner's result is returned, loser is automatically cleaned up by JavaScript engine

Key Takeaway

🎯 Key Insight: Promise.race() leverages JavaScript's event loop to efficiently manage concurrent operations without polling, making it the optimal solution for timeout scenarios.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time setup, actual time depends on which promise resolves first

✓ Linear Growth

Space Complexity

O(1)

Only creates two promises and a timer reference

✓ Linear Space

Constraints

1 ≤ t ≤ 10⁴ (timeout in milliseconds)
The function fn returns a Promise
The returned function should maintain the same signature as fn
Time limit should be enforced precisely

Asked in

N Netflix 35 U Uber 28 A Airbnb 22 ♪ Spotify 18

The optimal solution uses Promise.race() to create a competition between the original function and a timeout promise. This approach provides O(1) setup complexity with no polling overhead, making it highly efficient for concurrent operations. The key insight is letting JavaScript's event loop handle the racing mechanism rather than manually checking completion status.

Common Approaches

Approach	Time	Space	Notes
✓ Promise.race() (Optimal)	O(1)	O(1)	Use Promise.race between original function and timeout promise
Polling with setTimeout (Naive)	O(t/i)	O(1)	Repeatedly check if function completed using polling intervals

Promise.race() (Optimal) — Algorithm Steps

Create a timeout promise that rejects after t milliseconds
Use Promise.race() between original function and timeout promise
Return the result of whichever promise settles first
Ensure proper cleanup of timeout when function completes early

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Race

Both original function and timeout promise begin

Concurrent Execution

Both promises run simultaneously

First to Finish

Whichever completes first determines the outcome

Cleanup

Losing promise is automatically cleaned up

Code -

solution.c — C

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

typedef struct {
    int (*fn)(void*);
    void* args;
    int result;
    int has_result;
    int has_timeout;
    sem_t semaphore;
} race_args;

void* run_function(void* arg) {
    race_args* ra = (race_args*)arg;
    ra->result = ra->fn(ra->args);
    ra->has_result = 1;
    sem_post(&ra->semaphore);  // Signal completion
    return NULL;
}

void* run_timeout(void* arg) {
    race_args* ra = (race_args*)arg;
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    ts.tv_sec += ra->result / 1000;  // reusing result field for timeout
    ts.tv_nsec += (ra->result % 1000) * 1000000;
    
    if (ts.tv_nsec >= 1000000000) {
        ts.tv_sec++;
        ts.tv_nsec -= 1000000000;
    }
    
    if (sem_timedwait(&ra->semaphore, &ts) != 0) {
        ra->has_timeout = 1;
        sem_post(&ra->semaphore);  // Signal timeout
    }
    return NULL;
}

int timeLimit(int (*fn)(void*), void* args, int timeout_ms) {
    race_args ra = {fn, args, 0, 0, 0};
    ra.result = timeout_ms;  // Store timeout in result initially
    sem_init(&ra.semaphore, 0, 0);
    
    pthread_t fn_thread, timeout_thread;
    pthread_create(&fn_thread, NULL, run_function, &ra);
    pthread_create(&timeout_thread, NULL, run_timeout, &ra);
    
    // Wait for either to complete
    sem_wait(&ra.semaphore);
    
    pthread_cancel(fn_thread);
    pthread_cancel(timeout_thread);
    
    sem_destroy(&ra.semaphore);
    
    if (ra.has_timeout) {
        printf("Time Limit Exceeded\n");
        return -1;
    }
    
    return ra.result;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time setup, actual time depends on which promise resolves first

✓ Linear Growth

Space Complexity

O(1)

Only creates two promises and a timer reference

✓ Linear Space

Constraints

1 ≤ t ≤ 10⁴ (timeout in milliseconds)
The function fn returns a Promise
The returned function should maintain the same signature as fn
Time limit should be enforced precisely

34.7K Views

High Frequency

~15 min Avg. Time

892 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

Promise.race() (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler