Add Strings - Practice Coding Problems

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

Understanding the Visualization

Input

Two number strings num1 and num2

Process

Add digits right-to-left with carry

Output

Sum as string without converting to integer

Key Takeaway

🎯 Key Insight: Simulate elementary school addition digit-by-digit to handle large numbers without integer conversion

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

Approach	Time	Space	Notes
✓ Optimized String Builder	O(max(n, m))	O(max(n, m))	Use StringBuilder/list for efficient string construction
Digit-by-Digit Addition	O(max(n, m))	O(max(n, m))	Simulate manual addition from right to left with carry propagation

Optimized String Builder — Algorithm Steps

Step 1: Use StringBuilder/list to collect result digits
Step 2: Add digits from right to left with carry tracking
Step 3: Reverse the final result to get correct order
Step 4: Convert to string and return

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 digitSum = carry;
        
        if (i >= 0) {
            digitSum += num1[i] - '0';
            i--;
        }
        
        if (j >= 0) {
            digitSum += num2[j] - '0';
            j--;
        }
        
        result[pos++] = (digitSum % 10) + '0';
        carry = digitSum / 10;
    }
    
    result[pos] = '\0';
    
    // Reverse 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, reverse operation is also linear

✓ Linear Growth

Space Complexity

O(max(n, m))

StringBuilder/list stores result digits, size is at most max(n, m) + 1

⚡ 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