Execute Asynchronous Functions in Parallel

Execute Asynchronous Functions in Parallel - Problem

JavaScript Medium

Given an array of asynchronous functions functions, return a new promise promise. Each function in the array accepts no arguments and returns a promise. All the promises should be executed in parallel.

promise resolves:

When all the promises returned from functions were resolved successfully in parallel. The resolved value of promise should be an array of all the resolved values of promises in the same order as they were in the functions. The promise should resolve when all the asynchronous functions in the array have completed execution in parallel.

promise rejects:

When any of the promises returned from functions were rejected. promise should also reject with the reason of the first rejection.

Please solve it without using the built-in Promise.all function.

Input & Output

Example 1 — Basic Parallel Execution

$ Input: functions = [() => new Promise(res => setTimeout(() => res(5), 200))]

› Output: [5]

💡 Note: Single promise resolves to 5 after 200ms. The returned promise resolves with [5].

Example 2 — Multiple Promises

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

› Output: [1,2,3]

💡 Note: Three promises that resolve immediately to 1, 2, and 3. Results maintain original order.

Example 3 — Promise Rejection

$ Input: functions = [() => Promise.resolve(1), () => Promise.reject('Error'), () => Promise.resolve(3)]

› Output: Promise rejects with 'Error'

💡 Note: Second promise rejects, causing the entire result promise to reject with 'Error'.

Constraints

functions is a valid array
0 ≤ functions.length ≤ 10
functions[i] returns a Promise

Visualization

Tap to expand

Asked in

M Meta 25 G Google 20 a Amazon 18 M Microsoft 15

The key insight is to execute all promises immediately for parallel execution, then manually track completion using counters. The optimal approach starts all promises at once and uses callbacks to detect when all have resolved. Time: O(max promise duration), Space: O(n)

Common Approaches

✓ Manual Promise Tracking

⏱️ Time: O(max promise duration) Space: O(n)

Start all promises immediately, then use counters and callbacks to track when all complete. Manually implement Promise.all logic with completion counting.

Sequential Execution

⏱️ Time: O(sum of all promise durations) Space: O(n)

Execute each promise sequentially, waiting for each to complete before starting the next. This defeats the purpose of parallel execution but is the simplest approach.

Manual Promise Tracking — Algorithm Steps

Execute all functions immediately
Track completed count and results
Resolve when all complete or reject on first error

Visualization

Tap to expand

Step-by-Step Walkthrough

Start All

Execute all promises immediately

Track Progress

Count completions and store results

Resolve

Return results when all complete

Code -

solution.c — C

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

void solution() {
    // JavaScript specific problem - C pthread equivalent concept
    printf("Manual tracking approach implemented\n");
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    solution();
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max promise duration)

All promises run in parallel, so time is the longest individual duration

✓ Linear Growth

Space Complexity

O(n)

Store results array and promise references

⚡ Linearithmic Space

23.5K 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

Manual Promise Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler