Add Strings

Add Strings - Problem

Given two non-negative integers num1 and num2 represented as strings, return the sum of num1 and num2 as a string.

Important constraints:

You must solve the problem without using any built-in library for handling large integers (such as BigInteger)
You must also not convert the inputs to integers directly

The strings only contain digits and no leading zeros except the number 0 itself.

Input & Output

Example 1 — Basic Addition

$ Input: num1 = "11", num2 = "123"

› Output: "134"

💡 Note: Step-by-step: 1+3=4 (rightmost), 1+2=3 (middle), 0+1=1 (leftmost), result is "134"

Example 2 — With Carry

$ Input: num1 = "456", num2 = "77"

› Output: "533"

💡 Note: 6+7=13 (write 3, carry 1), 5+7+1=13 (write 3, carry 1), 4+0+1=5, result is "533"

Example 3 — Single Digits

$ Input: num1 = "0", num2 = "0"

› Output: "0"

💡 Note: Edge case: 0 + 0 = 0, simplest possible addition

Constraints

1 ≤ num1.length, num2.length ≤ 10⁴
num1 and num2 consist of only digits
num1 and num2 don't have any leading zeros except for the zero itself

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22 M Microsoft 18

The key insight is to simulate manual addition by processing digits from right to left with carry propagation. Best approach uses efficient string building with O(max(n,m)) time and space complexity.

Common Approaches

✓ Digit-by-Digit Addition

⏱️ Time: O(max(n, m)) Space: O(max(n, m))

Process both strings from right to left, adding corresponding digits and handling carry. This mimics how we manually add numbers on paper.

Optimized String Builder

⏱️ Time: O(max(n, m)) Space: O(max(n, m))

Same algorithm but using StringBuilder (Java) or list (Python) to avoid repeated string concatenation overhead. Build result in reverse then reverse once at the end.

Digit-by-Digit Addition — Algorithm Steps

Step 1: Start from the rightmost digits of both strings
Step 2: Add digits plus any carry from previous step
Step 3: Update carry and build result string
Step 4: Continue until all digits processed and no carry remains

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Position pointers at rightmost digits of both strings

Add

Add current digits plus carry, update result and carry

Move

Move pointers left and repeat until done

Code -

solution.c — C

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

char* solution(char* num1, char* num2) {
    int len1 = strlen(num1);
    int len2 = strlen(num2);
    int maxLen = len1 > len2 ? len1 : len2;
    char* result = (char*)malloc((maxLen + 2) * sizeof(char));
    
    int i = len1 - 1;
    int j = len2 - 1;
    int carry = 0;
    int pos = 0;
    
    while (i >= 0 || j >= 0 || carry) {
        int digit1 = i >= 0 ? num1[i] - '0' : 0;
        int digit2 = j >= 0 ? num2[j] - '0' : 0;
        
        int total = digit1 + digit2 + carry;
        result[pos++] = (total % 10) + '0';
        carry = total / 10;
        
        i--;
        j--;
    }
    
    result[pos] = '\0';
    
    // Reverse the result
    for (int k = 0; k < pos / 2; k++) {
        char temp = result[k];
        result[k] = result[pos - 1 - k];
        result[pos - 1 - k] = temp;
    }
    
    return result;
}

int main() {
    char num1[10001], num2[10001];
    fgets(num1, sizeof(num1), stdin);
    fgets(num2, sizeof(num2), stdin);
    
    // Remove newlines
    num1[strcspn(num1, "\n")] = 0;
    num2[strcspn(num2, "\n")] = 0;
    
    char* result = solution(num1, num2);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(n, m))

Single pass through both strings where n and m are lengths of num1 and num2

✓ Linear Growth

Space Complexity

O(max(n, m))

Result string length is at most max(n, m) + 1 for potential carry

⚡ Linearithmic Space

185.0K Views

Medium Frequency

~15 min Avg. Time

3.2K 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

Digit-by-Digit Addition — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler