Add Two Promises

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

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

✓ Promise.all Concurrent

⏱️ Time: O(max(t1, t2)) Space: O(1)

This approach uses Promise.all to wait for both promises simultaneously, taking advantage of concurrent execution. This is more efficient as both promises can resolve at the same time rather than waiting sequentially.

Sequential Await

⏱️ Time: O(t1 + t2) Space: O(1)

This approach waits for the first promise to resolve, then waits for the second promise to resolve, and finally returns their sum. While simple, it's inefficient because it doesn't take advantage of concurrent execution.

Promise.all Concurrent — Algorithm Steps

Step 1: Use Promise.all to await both promises concurrently
Step 2: Destructure the results array
Step 3: Return sum of both values

Visualization

Tap to expand

Step-by-Step Walkthrough

Promise.all

Start waiting for both promises at once

Concurrent Wait

Both promises resolve simultaneously

Sum Results

Add the resolved values together

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) {
    // In C, we simulate concurrent waiting by checking both promises
    while (!promise1->resolved || !promise2->resolved) {
        // Both promises resolve immediately in our simulation
    }
    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(max(t1, t2))

Total time is the maximum of both promise resolution times since they run concurrently

✓ Linear Growth

Space Complexity

O(1)

Only stores the results array and sum, 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

Promise.all Concurrent — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler