Solution Approach

The implementation uses a promise wrapper pattern combined with manual tracking to simulate Promise.allSettled() behavior.

Step 1: Create the outer Promise wrapper

return new Promise(resolve => { ... })

We wrap everything in a new Promise that will eventually resolve with our array of results. Note that we only need the resolve parameter since this promise never rejects.

Step 2: Initialize tracking variables

const res: Obj[] = []; let count = 0;

• res: An array to store our result objects, pre-sized implicitly through index assignment
• count: A counter to track how many promises have settled

Step 3: Iterate through functions with index preservation

for (let i in functions) { ... }

Using for...in loop gives us access to indices, which is crucial for maintaining order in our results array.

Step 4: Execute each function and handle both outcomes

functions[i]()  .then(value => ({ status: 'fulfilled', value }))  .catch(reason => ({ status: 'rejected', reason }))

For each function:

• Call it to get the promise
• If it resolves, .then() transforms the value into { status: 'fulfilled', value }
• If it rejects, .catch() transforms the reason into { status: 'rejected', reason }

The key pattern here is that .catch() after .then() ensures we always get a resolved promise with our formatted object, regardless of the original promise's outcome.

Step 5: Store result and check completion

.then(obj => {  res[i] = obj;  if (++count === functions.length) {  resolve(res);  } });

This final .then() receives our formatted object (from either the success or failure path):

• Store the object at the correct index i to maintain order
• Increment the counter using ++count
• Check if all promises have settled by comparing counter with array length
• If complete, resolve the outer promise with the results array

Why this approach works:

1. Order preservation: By using res[i] = obj instead of res.push(obj), results always appear in the same order as the input functions, even if they complete out of order.

2. Guaranteed settlement: The .catch() handler ensures that rejected promises don't break the flow - they're converted to result objects just like successful ones.

3. Completion detection: The counter pattern is simple but effective - we don't need complex state management, just a number that tells us when we've processed everything.

4. Type safety: The TypeScript types (FulfilledObj, RejectedObj, Obj) ensure our result objects have the correct structure.

Example Walkthrough

Let's walk through a concrete example with 3 functions to see how the solution works:

const functions = [  () => new Promise(resolve => setTimeout(() => resolve(5), 200)), // Resolves after 200ms  () => new Promise((_, reject) => setTimeout(() => reject("Error"), 100)), // Rejects after 100ms  () => new Promise(resolve => setTimeout(() => resolve(1), 150)) // Resolves after 150ms ]

Initial State:

• res = [] (empty array to store results)
• count = 0 (no promises settled yet)
• Outer promise created, waiting to resolve

Execution Timeline:

At t=0ms: All three functions are called

• Function 0: Promise pending (will resolve with 5 at 200ms)
• Function 1: Promise pending (will reject with "Error" at 100ms)
• Function 2: Promise pending (will resolve with 1 at 150ms)

At t=100ms: Function 1's promise rejects

• The .catch() handler transforms this into { status: 'rejected', reason: "Error" }
• res[1] = { status: 'rejected', reason: "Error" }
• count = 1 (1 out of 3 settled)
• Current res: [undefined, { status: 'rejected', reason: "Error" }, undefined]

At t=150ms: Function 2's promise resolves

• The .then() handler transforms this into { status: 'fulfilled', value: 1 }
• res[2] = { status: 'fulfilled', value: 1 }
• count = 2 (2 out of 3 settled)
• Current res: [undefined, { status: 'rejected', reason: "Error" }, { status: 'fulfilled', value: 1 }]

At t=200ms: Function 0's promise resolves

• The .then() handler transforms this into { status: 'fulfilled', value: 5 }
• res[0] = { status: 'fulfilled', value: 5 }
• count = 3 (3 out of 3 settled)
• Since count === functions.length, we call resolve(res)

Final Result:

[  { status: 'fulfilled', value: 5 },  { status: 'rejected', reason: "Error" },  { status: 'fulfilled', value: 1 } ]

Notice how:

1. Despite completing in order 1→2→0, the results maintain the original array order 0→1→2
2. The rejected promise (Function 1) didn't cause the overall operation to fail
3. We waited for all promises to settle before resolving the outer promise

Time and Space Complexity

Time Complexity: O(n) where n is the number of functions in the input array.

The algorithm iterates through the array of functions once using a for-in loop, executing each function exactly once. Each function execution, promise resolution/rejection handling, and array assignment operation takes O(1) time. Therefore, the overall time complexity is O(n).

Note that the actual wall-clock time depends on the slowest promise to settle (since promises may execute asynchronously), but from an algorithmic perspective, each function is only processed once.

Space Complexity: O(n) where n is the number of functions in the input array.

The space complexity breakdown:

• The res array stores n result objects, requiring O(n) space
• The count variable uses O(1) space
• Each promise chain creates temporary objects for status and value/reason, but these are stored in the res array, already accounted for
• The closure created by the Promise constructor maintains references to res and count, but this doesn't add to the asymptotic complexity

Therefore, the total space complexity is O(n).

Common Pitfalls

1. Race Condition with Result Storage

A critical pitfall occurs when developers try to use array.push() or list.append() instead of index-based assignment. This breaks the ordering guarantee:

Incorrect approach:

// JavaScript - WRONG! functions[i]()  .then(value => {  res.push({ status: 'fulfilled', value }); // Order not preserved!  if (++count === functions.length) resolve(res);  })

Why it fails: Promises settle in unpredictable order. If promise #2 completes before promise #0, using push() would place promise #2's result at index 0, breaking the expected order.

Solution: Always use index-based assignment:

res[i] = { status: 'fulfilled', value }; // Preserves original order

2. Forgetting to Handle Both Success and Failure Paths

Another common mistake is handling only the success case, causing the function to hang indefinitely when any promise rejects:

Incorrect approach:

// This will never resolve if any promise rejects! functions[i]().then(value => {  res[i] = { status: 'fulfilled', value };  if (++count === functions.length) resolve(res); }); // Missing .catch() - rejected promises won't increment counter

Solution: Chain .catch() to handle rejections and ensure the counter always increments:

functions[i]()  .then(value => ({ status: 'fulfilled', value }))  .catch(reason => ({ status: 'rejected', reason }))  .then(obj => {  res[i] = obj;  if (++count === functions.length) resolve(res);  });

3. Using Array Length Instead of Counter

Attempting to check completion by examining the results array can fail due to sparse arrays:

Incorrect approach:

// WRONG - sparse arrays don't report accurate length res[i] = obj; if (res.filter(x => x !== undefined).length === functions.length) {  resolve(res); }

Why it fails: JavaScript arrays with gaps (e.g., [undefined, obj, undefined]) may not accurately reflect completion status, especially if promises complete out of order.

Solution: Use a dedicated counter variable that increments atomically:

if (++count === functions.length) {  resolve(res); }

4. Python-Specific: Closure Variable Capture

In the Python implementation, a subtle bug occurs with variable capture in nested functions:

Incorrect approach:

for index in range(len(functions)):  async def handle_promise(): # No parameter!  try:  result = functions[index]() # 'index' captured from outer scope  # ... rest of code

Why it fails: All nested functions capture the same index variable, which will have the value of the last iteration when the functions execute.

Solution: Pass the index as a parameter to create a new scope:

async def handle_promise(idx): # Accept index as parameter  try:  result = functions[idx]() # Use the parameter, not outer variable

5. Not Pre-sizing the Results Array

Creating an empty array and trying to assign to arbitrary indices can cause issues:

Problematic approach:

const res = []; // Empty array // Later... res[5] = obj; // Creates sparse array: [empty × 5, obj]

Better approach for Python:

results = [None] * len(functions) # Pre-size the array

For JavaScript: The sparse array approach works but be aware of the implications when iterating or checking length.