Add Two Promises - Practice Coding Problems

Add Two Promises - Problem

JavaScript Easy

Welcome to the world of asynchronous JavaScript! In this problem, you'll work with Promises - one of JavaScript's most powerful features for handling asynchronous operations.

You are given two promises: promise1 and promise2. Both promises will eventually resolve with numeric values. Your task is to create and return a new promise that resolves with the sum of these two numbers.

Goal: Create a promise that waits for both input promises to resolve, then returns their sum.

Input: Two Promise objects that resolve to numbers

Output: A Promise that resolves to the sum of the two input numbers

This problem teaches fundamental concepts of promise handling, async/await syntax, and error management in modern JavaScript applications.

Input & Output

example_1.js — Basic Promise Addition

$ Input: promise1 = Promise.resolve(2), promise2 = Promise.resolve(5)

› Output: Promise that resolves to 7

💡 Note: Both promises resolve immediately with their respective values (2 and 5), and our function returns a promise that resolves to their sum (2 + 5 = 7).

example_2.js — Delayed Promises

$ Input: promise1 = new Promise(resolve => setTimeout(() => resolve(10), 1000)), promise2 = new Promise(resolve => setTimeout(() => resolve(15), 500))

› Output: Promise that resolves to 25 after 1 second

💡 Note: The first promise resolves after 1 second with value 10, the second resolves after 0.5 seconds with value 15. The result promise waits for both and resolves to 25.

example_3.js — Negative Numbers

$ Input: promise1 = Promise.resolve(-3), promise2 = Promise.resolve(8)

› Output: Promise that resolves to 5

💡 Note: Even with negative numbers, the addition works correctly: -3 + 8 = 5. This demonstrates the function handles all numeric values.

Constraints

Both promise1 and promise2 will resolve with number values
The promises may resolve immediately or after some delay
Numbers can be positive, negative, or zero
Numbers are within JavaScript's safe integer range (-2⁵³ to 2⁵³)
The returned value must be a Promise that resolves to the sum

Visualization

Tap to expand

Understanding the Visualization

Place Two Orders

Start both promises - they begin executing independently

Wait for Delivery

Use Promise.all() or await to wait for both results

Combine the Meal

Add the two numbers together

Serve the Result

Return a new Promise containing the sum

Key Takeaway

🎯 Key Insight: Promises allow asynchronous operations to be composed elegantly. Use Promise.all() for concurrent execution when operations are independent, or async/await for more readable sequential or concurrent code.

Asked in

G Google 28 f Meta 22 a Amazon 18 ⊞ Microsoft 15

The optimal solution uses async/await syntax with Promise.all() for concurrent execution. This approach is clean, readable, and efficiently waits for both promises simultaneously before returning their sum wrapped in a Promise.

Common Approaches

Approach	Time	Space	Notes
✓ Promise.all() Method	O(1)	O(1)	Use Promise.all() to wait for both promises simultaneously
Async/Await Syntax (Optimal)	O(1)	O(1)	Use modern async/await syntax for clean, readable promise handling
Promise.then() Chaining	O(1)	O(1)	Chain promises sequentially using .then() methods

Promise.all() Method — Algorithm Steps

Pass both promises to Promise.all()
Promise.all() waits for both promises to resolve concurrently
Extract values from the resolved array
Return the sum of both values

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Both Promises

Both promises begin execution simultaneously

Promise.all() Waits

Waits for both promises to complete

Combine Results

Adds the resolved values together

Code -

solution.c — C

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

typedef struct {
    int values[2];
    pthread_barrier_t barrier;
    int result;
} PromiseAll;

void* resolvePromise(void* args) {
    int* data = (int*)args;
    // Simulate async work
    return NULL;
}

int addTwoPromises(int promise1, int promise2) {
    return promise1 + promise2;
}

int main() {
    printf("%d\n", addTwoPromises(5, 3)); // Output: 8
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time complexity for the addition operation, promises execute concurrently

✓ Linear Growth

Space Complexity

O(1)

Only stores the resolved values array temporarily

✓ Linear Space

23.4K Views

Medium Frequency

~8 min Avg. Time

892 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

Promise.all() Method — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler