Add Two Promises - Practice Coding Problems

Add Two Promises - Problem

JavaScript Easy

Given two promises 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.

Input & Output

Example 1 — Basic Addition

$ Input: promise1 resolves to 2, promise2 resolves to 5

› Output: 7

💡 Note: Both promises resolve with numbers, and 2 + 5 = 7

Example 2 — Negative Numbers

$ Input: promise1 resolves to -4, promise2 resolves to 9

› Output: 5

💡 Note: Adding negative and positive: -4 + 9 = 5

Example 3 — Both Negative

$ Input: promise1 resolves to -3, promise2 resolves to -7

› Output: -10

💡 Note: Both negative numbers: -3 + (-7) = -10

Constraints

promise1 and promise2 will always resolve with numbers
Numbers can be positive, negative, or zero
The promises will not reject

Visualization

Tap to expand

Understanding the Visualization

Input

Two promises that resolve to numbers

Process

Await both promises and get their values

Output

Return sum of the two resolved values

Key Takeaway

🎯 Key Insight: Use Promise.all for concurrent execution to optimize performance

Asked in

G Google 25 M Microsoft 20 a Amazon 18 f Facebook 15

The key insight is to use Promise.all for concurrent execution instead of sequential await. Best approach uses Promise.all([promise1, promise2]) to wait for both promises simultaneously. Time: O(max(t1, t2)), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Sequential Await	O(t1 + t2)	O(1)	Await each promise one by one sequentially
Promise.all Concurrent	O(max(t1, t2))	O(1)	Use Promise.all to await both promises concurrently

Sequential Await — Algorithm Steps

Step 1: Await first promise to get its value
Step 2: Await second promise to get its value
Step 3: Return sum of both values

Visualization

Tap to expand

Step-by-Step Walkthrough

Await First

Wait for promise1 to resolve

Await Second

Then wait for promise2 to resolve

Sum

Add the two resolved values

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

typedef struct {
    int value;
    int resolved;
} Promise;

int solution(Promise* promise1, Promise* promise2) {
    while (!promise1->resolved || !promise2->resolved) {
        // Wait for promises to resolve
    }
    return promise1->value + promise2->value;
}

int main() {
    int val1, val2;
    scanf("%d", &val1);
    scanf("%d", &val2);
    
    Promise promise1 = {val1, 1};
    Promise promise2 = {val2, 1};
    
    int result = solution(&promise1, &promise2);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(t1 + t2)

Total time is sum of both promise resolution times since they run sequentially

✓ Linear Growth

Space Complexity

O(1)

Only stores two number values, no additional data structures

✓ Linear Space

12.5K Views

Medium Frequency

~10 min Avg. Time

485 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

Sequential Await — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler