Add Two Promises - Solution & Explanation
Problem Statement
promise1 and promise2, return a new promise. promise1 and promise2 will both resolve with a number. The returned promise should resolve with the sum of the two numbers.
Example 1:
Input: promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20)), promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60)) Output: 7 Explanation: The two input promises resolve with the values of 2 and 5 respectively. The returned promise should resolve with a value of 2 + 5 = 7. The time the returned promise resolves is not judged for this problem.
Example 2:
Input: promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50)), promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30)) Output: -2 Explanation: The two input promises resolve with the values of 10 and -12 respectively. The returned promise should resolve with a value of 10 + -12 = -2.
Constraints:
promise1andpromise2are promises that resolve with a number
Approach Overview
Problem Overview: You receive two JavaScript promises, promise1 and promise2, each resolving to a number. The task is to return a new promise that resolves to the sum of their resolved values. The main challenge is coordinating asynchronous resolution correctly.
Approach 1: Chaining Promises (Sequential Resolution) (Time: O(1), Space: O(1))
This approach resolves the first promise and then resolves the second inside the .then() callback. After both values are available, return their sum. The logic uses promise chaining to control execution order. While straightforward, it waits for the first promise before starting to process the second, which can introduce unnecessary delay if both promises could resolve independently. This pattern is common when learning promises but is not the most efficient when tasks are independent.
Approach 2: Using Promise.all (Parallel Resolution) (Time: O(1), Space: O(1))
Promise.all() runs both promises concurrently and resolves once both are complete. It returns an array of resolved values in the same order as the input promises. You can destructure the results and return their sum. This approach avoids sequential waiting and is the most idiomatic way to combine multiple independent promises in JavaScript. Since both promises resolve simultaneously, total wait time equals the slower of the two operations.
Approach 3: Promise.all with Explicit Resolution Logic (Time: O(1), Space: O(1))
This variation still uses Promise.all(), but explicitly returns a new promise that resolves after computing the sum. Internally, it waits for both promises, then performs a simple arithmetic addition. The extra wrapping can be useful if additional asynchronous processing or validation is required before resolving the final result. Functionally it behaves the same as the standard Promise.all() approach but demonstrates how to build composed promise workflows.
Approach 4: Using async/await (Time: O(1), Space: O(1))
An async function allows promises to be written with synchronous-style code. Use await Promise.all([promise1, promise2]) to resolve both values, then return their sum. This approach keeps asynchronous logic easy to read and reduces nested callbacks. Many modern JavaScript codebases prefer async/await because it integrates cleanly with error handling and async control flow in async programming.
Recommended for interviews: Using Promise.all() is the expected solution. It resolves both promises concurrently and keeps the implementation concise. Chaining promises demonstrates understanding of asynchronous execution, but parallel resolution shows stronger familiarity with real-world JavaScript patterns.
Approach 1: Using Promise.all
In this code, we first call `Promise.all` with an array of the two input promises promise1 and promise2. This returns a promise that resolves when both input promises resolve. We then use the `then` method to specify that when the promise resolves, it should sum the two resolved values and return the result.
Code
JavaScript
Complexity
Time Complexity: O(1) since promise creation and resolution are constant time operations.
Space Complexity: O(1) as we only store a fixed number of numbers.
Approach 2: Chaining Promises
This code captures each promise's resolution value one after the other by chaining the then method, first resolving promise1, storing its value, and then resolving promise2, accumulating the sum and returning it.
Code
JavaScript
Complexity
Time Complexity: O(1) as each step essentially involves constant-time resolution.
Space Complexity: O(1) since we're working with a fixed number of variables.
Approach 3: Using Promise.all to resolve both promises simultaneously
This approach utilizes the Promise.all() method, which takes an array of promises and returns a new promise that resolves when all of the promises in the array have resolved.
In this method, you pass both promise1 and promise2 to Promise.all(). It waits for both promises to resolve, then combines their resolved values using array destructuring to sum them up within the then() method.
The function addTwoPromises takes two promises and returns a new promise that resolves to the sum of the values resolved by the input promises. The Promise.all method is used to wait for both promises to resolve, and the resolved values are extracted as an array within the then method.
Code
JavaScript
Complexity
Time Complexity: O(1), as all operations inside the promises are essentially constant time operations.
Space Complexity: O(1), space usage is constant regardless of input sizes.
Approach 4: Using async/await for handling promise resolution
This approach employs async/await, a cleaner syntax for handling promises in JavaScript. By using an async function, you can await the resolution of both promise1 and promise2 to get their values before summing them up.
addTwoPromises is defined as an async function, meaning it returns a Promise and its execution can be paused using await. By awaiting both promise1 and promise2, the function captures their resolved values into value1 and value2. These are summed and the result is returned, thus promise chaining is implicit in every call.
Code
JavaScript
Complexity
Time Complexity: O(1), as the time taken by promise resolution does not scale with input data.
Space Complexity: O(1), as the function only stores a few values regardless of input.
Approach 5: Default Approach
Code
TypeScript
JavaScript
Complexity Comparison
| Approach | Complexity |
|---|---|
| Using Promise.all | Time Complexity: O(1) since promise creation and resolution are constant time operations. |
| Chaining Promises | Time Complexity: O(1) as each step essentially involves constant-time resolution. |
| Using Promise.all to resolve both promises simultaneously | Time Complexity: O(1), as all operations inside the promises are essentially constant time operations. |
| Using async/await for handling promise resolution | Time Complexity: O(1), as the time taken by promise resolution does not scale with input data. |
| Default Approach | — |
Detailed Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Chaining Promises | O(1) | O(1) | When demonstrating basic promise chaining or sequential async execution |
| Promise.all (Parallel) | O(1) | O(1) | Best choice when promises are independent and can resolve concurrently |
| Promise.all with Wrapper Promise | O(1) | O(1) | Useful when adding extra async processing before resolving the final result |
| Async/Await with Promise.all | O(1) | O(1) | Preferred in modern JavaScript for readability and structured async control flow |
Video Solution
Add Two Promises | Leetcode 2723 | Promises and Time | 30 Days of JavaScript #leetcode #javascript • Learn With Chirag • 3,709 views views
Watch 9 more video solutions →Frequently Asked Questions
Is Add Two Promises easy or hard?
Add Two Promises Python/Java solution
How to solve Add Two Promises in O(1)?
What is the best approach for Add Two Promises?
Is Add Two Promises asked at Google/Amazon/Meta?
What data structure is used in Add Two Promises?
What is the time complexity of Add Two Promises?
Ready to solve this problem?
Practice Add Two Promises with our built-in code editor and test cases.
Practice on FleetCode