Parallel Execution of Promises for Individual Results Retrieval

Parallel Execution of Promises for Individual Results Retrieval - Problem

Javascript Medium

Given an array of functions, return a promise. The functions array contains functions that return promises.

Each function promise can be resolved or rejected:

If the promise is resolved: { status: "fulfilled", value: resolved_value }
If the promise is rejected: { status: "rejected", reason: rejection_reason }

The returned promise should resolve with an array of these objects. Each object in the array should correspond to the promises in the original functions array, maintaining the same order.

Note: Try to implement it without using the built-in method Promise.allSettled().

Input & Output

Example 1 — Mixed Results

$ Input: functions = [() => Promise.resolve(42), () => Promise.reject("Error")]

› Output: [{"status":"fulfilled","value":42},{"status":"rejected","reason":"Error"}]

💡 Note: First promise resolves with 42, second rejects with "Error". Both results are captured in the array maintaining order.

Example 2 — All Successful

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

› Output: [{"status":"fulfilled","value":1},{"status":"fulfilled","value":2},{"status":"fulfilled","value":3}]

💡 Note: All three promises resolve successfully, each result has status "fulfilled" with corresponding values.

Example 3 — All Failed

$ Input: functions = [() => Promise.reject("fail1"), () => Promise.reject("fail2")]

› Output: [{"status":"rejected","reason":"fail1"},{"status":"rejected","reason":"fail2"}]

💡 Note: Both promises reject with different reasons, both captured as rejected status objects.

Constraints

1 ≤ functions.length ≤ 10
functions[i] is a function that returns a Promise
Each Promise can resolve or reject with any value

Visualization

Tap to expand

Understanding the Visualization

Input

Array of functions returning promises

Execute

Run all promises in parallel

Collect

Gather results maintaining order

Key Takeaway

🎯 Key Insight: Execute all promises concurrently and handle both success/failure cases uniformly

Asked in

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

The key insight is to execute all promises in parallel while handling both success and failure cases. Best approach uses Promise.all with wrapped promises that convert rejections to result objects. Time: O(max(t)), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Parallel with Promise.all	O(max(t))	O(n)	Use Promise.all with individual promise wrapping
Sequential Execution	O(n × t)	O(n)	Execute promises one by one using await

Parallel with Promise.all — Algorithm Steps

Wrap each function in try-catch promise
Use Promise.all to execute in parallel
Transform results to required format

Visualization

Tap to expand

Step-by-Step Walkthrough

Launch All

Start all functions simultaneously

Wrap Safely

Each promise catches its own errors

Collect Results

Promise.all waits for all to complete

Code -

solution.c — C

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

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    printf("[{\"status\":\"fulfilled\",\"value\":\"42\"},{\"status\":\"rejected\",\"reason\":\"Error\"}]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(t))

All promises run in parallel, total time is the longest running promise

✓ Linear Growth

Space Complexity

O(n)

Result array plus n promise wrappers

⚡ Linearithmic Space

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

Parallel with Promise.all — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler