Delay the Resolution of Each Promise

Delay the Resolution of Each Promise - Problem

Database Medium

Imagine you're building a system that needs to add artificial delays to promise-returning functions for rate limiting or throttling purposes. You have an array of functions that return promises, and you want to create a new array where each function introduces an additional delay before resolving or rejecting.

Your Task: Given an array functions and a delay duration ms, return a new array of functions. Each function in the new array should:

Execute the corresponding original function
Wait for the original promise to resolve or reject
Add an additional delay of ms milliseconds
Then resolve or reject with the same value/error

Think of it like adding a "cooldown period" to each promise, similar to how video games add cooldowns to abilities!

Input: An array of functions that return promises, and a delay duration in milliseconds

Output: A new array of functions that return delayed promises

Input & Output

example_1.js — JavaScript Basic Delay

$ Input: functions = [() => Promise.resolve(1), () => Promise.resolve(2)], ms = 100

› Output: Array of 2 functions that resolve to [1, 2] after 100ms additional delay each

💡 Note: Each function in the returned array will execute the original function, wait for its result, then add 100ms delay before resolving with the same value

example_2.js — JavaScript With Rejection

$ Input: functions = [() => Promise.resolve("success"), () => Promise.reject("error")], ms = 200

› Output: First function resolves to "success" after 200ms delay, second rejects with "error" after 200ms delay

💡 Note: Both successful and failed promises get the same delay treatment - the delay is added regardless of the outcome

example_3.js — JavaScript Empty Array

$ Input: functions = [], ms = 500

› Output: []

💡 Note: Edge case: when given an empty array of functions, return an empty array of delayed functions

Constraints

1 ≤ functions.length ≤ 1000
0 ≤ ms ≤ 10⁴
Each function in the input array returns a Promise
The delay should be added after the original promise settles
Preserve the original promise's resolution/rejection value and reason

Visualization

Tap to expand

Understanding the Visualization

Original Promise Executes

The original function runs and returns a promise

Wait for Settlement

Wait for the promise to either resolve or reject

Add Artificial Delay

After settlement, start the additional delay timer

Return Same Outcome

After delay completes, resolve/reject with original value

Key Takeaway

🎯 Key Insight: Use promise chaining to add delays after the original promise settles, preserving both successful results and error states while adding consistent timing delays.

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution creates wrapper functions that execute the original promise, wait for it to settle, then add the specified delay using setTimeout or equivalent timing mechanisms. The key insight is to use promise chaining with .then() and .catch() to handle both success and failure cases while preserving the original outcome.

Common Approaches

Approach	Time	Space	Notes
✓ Basic Promise Delay Implementation	O(n)	O(n)	Create wrapper functions that wait for original promises then add explicit delays

Basic Promise Delay Implementation — Algorithm Steps

Iterate through each function in the input array
For each function, create a wrapper function
In the wrapper, call the original function to get its promise
Use .then() and .catch() to handle both success and failure cases
Add setTimeout delay in both cases before resolving/rejecting
Return the new array of delayed functions

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Function Array

Start with array of promise-returning functions

Create Wrappers

For each function, create a wrapper that adds delay

Execute & Delay

Wrapper executes original, waits for result, then adds delay

Return Delayed Result

After delay, resolve/reject with original value

Code -

solution.c — C

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

// C doesn't have native promises, so we simulate with function pointers
typedef struct {
    int (*func)(void);
    int delay_ms;
} DelayedFunction;

DelayedFunction* delayAll(int (*functions[])(void), int func_count, int ms) {
    DelayedFunction* delayed = malloc(func_count * sizeof(DelayedFunction));
    
    for (int i = 0; i < func_count; i++) {
        delayed[i].func = functions[i];
        delayed[i].delay_ms = ms;
    }
    
    return delayed;
}

int executeDelayed(DelayedFunction* df) {
    int result = df->func();
    usleep(df->delay_ms * 1000); // Convert ms to microseconds
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array once to create n wrapper functions

✓ Linear Growth

Space Complexity

O(n)

We create a new array with n delayed functions

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

847 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