Parallel Execution of Promises for Individual Results Retrieval

Parallel Execution of Promises for Individual Results Retrieval - Problem

JavaScript Medium

Parallel Execution of Promises for Individual Results Retrieval

You're given an array of functions that return promises. Your task is to execute all these promises in parallel and collect their results, regardless of whether they succeed or fail.

For each promise:
• If it resolves: Create an object { status: "fulfilled", value: resolved_value }
• If it rejects: Create an object { status: "rejected", reason: error_message }

Return a promise that resolves with an array of these result objects, maintaining the same order as the original functions array.

Challenge: Implement this without using the built-in Promise.allSettled() method!

Example:
functions = [() => Promise.resolve(42), () => Promise.reject("Error!")]
Should return: [{status: "fulfilled", value: 42}, {status: "rejected", reason: "Error!"}]

Input & Output

example_1.js — Mixed Success and Failure

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

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

💡 Note: First and third promises resolve successfully, middle one rejects. All results are captured in order with appropriate status indicators.

example_2.js — 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: When all promises resolve successfully, each result object has status 'fulfilled' with the corresponding resolved value.

example_3.js — Empty Array Edge Case

$ Input: functions = []

› Output: []

💡 Note: Edge case: when given an empty array of functions, return an empty array immediately since there are no promises to execute.

Visualization

Tap to expand

Understanding the Visualization

Start All Dishes

All chefs begin cooking their assigned dishes at the same time - this is parallel execution

Track Each Dish

As each dish completes (successfully or fails), record the result and increment completion counter

Serve Complete Order

When all dishes are done (counter equals total), serve the complete order with status of each dish

Key Takeaway

🎯 Key Insight: Like coordinating multiple chefs in a kitchen, we execute all promises in parallel and track their completion status, ensuring we wait for ALL to finish before returning the complete result set.

Time & Space Complexity

Time Complexity

⏱️

O(max(t1, t2, ..., tn))

Time is determined by the slowest promise since all run in parallel

✓ Linear Growth

Space Complexity

O(n)

Space for results array and promise references

⚡ Linearithmic Space

Constraints

1 ≤ functions.length ≤ 10⁴
Each function returns a valid Promise
Promise values can be of any type
Error messages are strings
Must maintain original array order

Asked in

G Google 45 f Meta 38 a Amazon 32 N Netflix 28 ⊞ Microsoft 25

The optimal approach uses Promise.all with wrapped promises that never reject. Each original promise is wrapped in a handler that converts both success and failure cases into resolved objects with status and value/reason fields. This enables true parallel execution while maintaining order and handling all outcomes gracefully.

Common Approaches

Approach	Time	Space	Notes
✓ Sequential Execution (Brute Force)	O(n × t)	O(n)	Execute promises one by one, waiting for each to complete before starting the next
Manual Promise Resolution Tracking (Optimal)	O(max(t1, t2, ..., tn))	O(n)	Create a single promise that resolves when all functions complete, tracking results manually
Promise.all with Error Wrapping	O(max(t1, t2, ..., tn))	O(n)	Wrap each promise to never reject, then use Promise.all to wait for all completions

Sequential Execution (Brute Force) — Algorithm Steps

Initialize empty results array
Loop through each function sequentially
For each function, await its promise with try/catch
Store success/failure result in the results array
Return completed results array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start First Promise

Execute first function and wait for completion

Handle Result

Store success/failure result and move to next

Continue Sequential

Repeat for each remaining promise

Code -

solution.c — C

// C equivalent using pthread
#include <pthread.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char status[10];
    void* value;
    char* reason;
} Result;

Result* promiseAllSettledSequential(void* (*functions[])(void*), int count) {
    Result* results = malloc(count * sizeof(Result));
    
    for (int i = 0; i < count; i++) {
        void* value = functions[i](NULL);
        if (value != NULL) {
            strcpy(results[i].status, "fulfilled");
            results[i].value = value;
            results[i].reason = NULL;
        } else {
            strcpy(results[i].status, "rejected");
            results[i].value = NULL;
            results[i].reason = "Function returned NULL";
        }
    }
    
    return results;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × t)

Where n is number of promises and t is average promise execution time. Promises execute sequentially, so times add up.

✓ Linear Growth

Space Complexity

O(n)

Space for storing n result objects in the output array.

⚡ Linearithmic Space

Constraints

1 ≤ functions.length ≤ 10⁴
Each function returns a valid Promise
Promise values can be of any type
Error messages are strings
Must maintain original array order

42.4K Views

High Frequency

~25 min Avg. Time

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

Sequential Execution (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler