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

Understanding the Visualization

Input

Array of async functions that return promises

Execute

Start all promises simultaneously

Collect

Gather results in original order when all complete

Key Takeaway

🎯 Key Insight: Execute all promises immediately but coordinate their completion using manual tracking

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

Approach	Time	Space	Notes
✓ Sequential Execution	O(sum of all promise durations)	O(n)	Execute promises one after another using await
Manual Promise Tracking	O(max promise duration)	O(n)	Execute all promises immediately and track completion manually

Sequential Execution — Algorithm Steps

Iterate through functions array
Await each promise sequentially
Collect results in order

Visualization

Tap to expand

Step-by-Step Walkthrough

Execute First

Start and wait for first promise

Execute Second

Start second only after first completes

Continue

Repeat until all are done

Code -

solution.c — C

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

void solution() {
    // JavaScript specific problem - C implementation for educational purposes
    printf("Sequential approach implemented\n");
}

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

Time & Space Complexity

Time Complexity

⏱️

O(sum of all promise durations)

Promises execute sequentially, so total time is sum of individual times

✓ Linear Growth

Space Complexity

O(n)

Store results array of size n

⚡ 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

Sequential Execution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler