Solution Approach

Let's walk through the implementation step by step:

1. Create a wrapper promise:

return new Promise<T[]>((resolve, reject) => {  // Implementation here });

We wrap everything in a new promise that we can control - deciding when to resolve with all results or reject with an error.

2. Initialize tracking variables:

let cnt = 0; const ans = new Array(functions.length);

• cnt tracks how many promises have successfully resolved
• ans is a pre-allocated array with the same length as the input functions array to store results at their correct positions

3. Execute all functions in parallel:

for (let i = 0; i < functions.length; ++i) {  const f = functions[i];  f()  .then(res => {  // Handle success  })  .catch(err => {  // Handle failure  }); }

The loop immediately invokes all functions without waiting for any to complete. Each function call returns a promise that we attach handlers to.

4. Handle successful resolution:

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

When a promise resolves:

• Store the result at index i in the ans array (preserving order)
• Increment the counter
• Check if all promises are done (cnt === functions.length)
• If all are complete, resolve the main promise with the complete results array

5. Handle rejection:

.catch(err => {  reject(err); })

If any promise rejects, immediately reject the main promise with the same error. This implements the "fail-fast" behavior where the first rejection causes the entire operation to fail.

Key implementation details:

• The closure in the loop captures the value of i for each iteration, ensuring each result goes to the correct index
• All functions are invoked immediately in the loop, achieving parallel execution
• The counter approach avoids needing to check the array for completion on every resolution
• No additional error tracking is needed since we reject on the first error

This implementation efficiently handles both the happy path (all succeed) and error cases (any failure) while maintaining the correct order of results.

Example Walkthrough

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

Input functions:

• fn1: resolves with value 10 after 100ms
• fn2: resolves with value 20 after 50ms
• fn3: resolves with value 30 after 150ms

Step-by-step execution:

1. Initialization (t=0ms):

   • Create wrapper promise
   • Set cnt = 0
   • Create ans = [undefined, undefined, undefined] (array of length 3)

2. Start all functions (t=0ms):

   • Loop executes immediately:
     • i=0: Call fn1(), attach .then() and .catch() handlers
     • i=1: Call fn2(), attach .then() and .catch() handlers
     • i=2: Call fn3(), attach .then() and .catch() handlers
   • All three functions are now running in parallel

3. First resolution (t=50ms):

   • fn2 resolves with 20 (it's the fastest)
   • Its .then() handler executes with i=1:
     • ans[1] = 20 → ans = [undefined, 20, undefined]
     • cnt = 1
     • Check: cnt (1) !== functions.length (3), so continue waiting

4. Second resolution (t=100ms):

   • fn1 resolves with 10
   • Its .then() handler executes with i=0:
     • ans[0] = 10 → ans = [10, 20, undefined]
     • cnt = 2
     • Check: cnt (2) !== functions.length (3), so continue waiting

5. Final resolution (t=150ms):

   • fn3 resolves with 30
   • Its .then() handler executes with i=2:
     • ans[2] = 30 → ans = [10, 20, 30]
     • cnt = 3
     • Check: cnt (3) === functions.length (3) ✓
     • Call resolve(ans) with [10, 20, 30]

Result: The wrapper promise resolves with [10, 20, 30] - values are in the original order despite fn2 finishing first.

Alternative scenario with rejection:

If fn2 had rejected with error "Network error" at t=50ms:

• Its .catch() handler would execute immediately
• Call reject("Network error")
• The wrapper promise rejects with "Network error"
• fn1 and fn3 continue running but their results are ignored

This demonstrates how the solution maintains order through indexed assignment and implements fail-fast behavior on errors.

Time and Space Complexity

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

The code iterates through the array of functions once with a for loop, and for each function, it invokes it and attaches .then() and .catch() handlers. The iteration itself takes O(n) time. Each promise is executed asynchronously and in parallel, so the actual execution time depends on the slowest promise to resolve, but the setup and handling of promises is O(n).

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

The space complexity includes:

• The ans array which stores the results of all promises: O(n)
• The closure variables (cnt, resolve, reject) which are constant: O(1)
• Each promise's .then() and .catch() handlers create closures that capture the index i and reference to ans, cnt, resolve, and reject: O(n) total for all handlers

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

Common Pitfalls

1. Using the Loop Variable Directly in Callbacks (JavaScript/TypeScript)

Pitfall: A classic mistake is capturing the loop variable incorrectly in the promise handlers:

// WRONG - This will not preserve the correct order for (var i = 0; i < functions.length; i++) {  functions[i]()  .then(res => {  ans[i] = res; // Bug: 'i' will be functions.length for all callbacks  cnt++;  if (cnt === functions.length) {  resolve(ans);  }  })  .catch(reject); }

Why it fails: When using var, the variable i is function-scoped, not block-scoped. By the time the promises resolve, the loop has completed and i equals functions.length for all callbacks, causing all results to be stored at an invalid index.

Solution: Use let for block scoping or create a closure:

// Solution 1: Use 'let' for block scoping for (let i = 0; i < functions.length; i++) {  // 'i' is now block-scoped and captured correctly }  // Solution 2: Create an IIFE closure for (var i = 0; i < functions.length; i++) {  (function(index) {  functions[index]()  .then(res => {  ans[index] = res;  // ...  })  })(i); }

2. Not Handling Empty Arrays

Pitfall: Forgetting to handle the edge case when the input array is empty:

// This works but could be more explicit if (cnt === functions.length) { // When length is 0, this never triggers  resolve(ans); }

Solution: Add explicit handling for empty arrays:

if (functions.length === 0) {  resolve([]);  return; }

3. Sequential Execution Instead of Parallel (Python)

Pitfall: Accidentally awaiting each coroutine in sequence:

# WRONG - This executes sequentially results = [] for func in functions:  result = await func() # Waits for each one to complete before starting the next  results.append(result)

Solution: Create all coroutines first, then await them together:

# Correct - Executes in parallel coroutines = [func() for func in functions] results = await asyncio.gather(*coroutines)

4. Not Preserving Order When Using Manual Tracking

Pitfall: Appending results as they arrive instead of placing them at their original index:

// WRONG - Order is not preserved functions[i]()  .then(res => {  ans.push(res); // Results will be in completion order, not original order  cnt++;  if (cnt === functions.length) {  resolve(ans);  }  })

Solution: Always use the index to place results:

// Correct - Preserves original order ans[i] = res; // Place at specific index

5. Memory Leaks with Unhandled Rejections

Pitfall: When implementing manual cancellation in Python, forgetting to properly clean up tasks:

# Potential issue - tasks might not be properly cancelled for index, task in tasks:  try:  result = await task  except Exception as error:  # Other tasks continue running in the background  raise error

Solution: Ensure all pending tasks are cancelled on failure:

except Exception as error:  # Cancel all remaining tasks  for _, remaining_task in tasks:  if not remaining_task.done():  remaining_task.cancel()  raise error