Add Strings - Practice Coding Problems

Add Strings - Problem

Imagine you're working with incredibly large numbers that are too big for standard integer types - numbers with hundreds or thousands of digits! Your task is to add two such numbers represented as strings without using any built-in big integer libraries.

Given two non-negative integers num1 and num2 represented as strings, return their sum as a string. You must solve this problem by simulating manual addition - just like how you learned to add numbers digit by digit in elementary school, carrying over when needed.

Constraints:

You cannot convert the entire strings to integers directly
You cannot use built-in big integer libraries
Both numbers are non-negative
No leading zeros except for the number 0 itself

Example: "123" + "456" = "579"

Input & Output

example_1.py — Basic Addition

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

› Output: "34"

💡 Note: Adding 11 + 23 = 34. Start from rightmost: 1+3=4, then 1+2=3, result is "34"

example_2.py — Addition with Carry

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

› Output: "533"

💡 Note: Adding 456 + 77 = 533. Rightmost: 6+7=13 (write 3, carry 1), middle: 5+7+1=13 (write 3, carry 1), leftmost: 4+0+1=5, result is "533"

example_3.py — Different Length Strings

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

› Output: "0"

💡 Note: Edge case: adding two zeros results in "0"

Visualization

Tap to expand

Understanding the Visualization

Initialize

Set up pointers at the end of both strings, initialize carry to 0

Process Digits

Add current digits plus carry, store the units digit in result

Handle Carry

Calculate new carry value and move to next position

Continue

Repeat until all digits processed and no carry remains

Key Takeaway

🎯 Key Insight: Simulate manual addition by processing digits right-to-left with proper carry handling - exactly like elementary school math!

Time & Space Complexity

Time Complexity

⏱️

O(max(m, n))

We process each digit once, where m and n are lengths of input strings

✓ Linear Growth

Space Complexity

O(max(m, n))

Space needed to store the result string, which can be at most max(m,n) + 1 digits

⚡ Linearithmic Space

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
Cannot use built-in big integer libraries
Cannot convert strings directly to integers

Asked in

f Meta 45 a Amazon 38 G Google 32 ⊞ Microsoft 28

The optimal approach uses digit-by-digit addition with carry simulation, processing strings from right to left in O(max(m,n)) time. This mimics manual addition and handles arbitrarily large numbers without integer conversion.

Common Approaches

Approach	Time	Space	Notes
✓ Digit-by-Digit Addition (Optimal Approach)	O(max(m, n))	O(max(m, n))	Simulate manual addition by processing digits from right to left with carry

Digit-by-Digit Addition (Optimal Approach) — Algorithm Steps

Initialize pointers at the end of both strings and carry = 0
While there are digits to process or carry exists
Extract current digits (or 0 if string is exhausted)
Calculate sum = digit1 + digit2 + carry
Add (sum % 10) to result, update carry = sum // 10
Move pointers left and repeat
Reverse the result string and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Position pointers at the end of both strings, initialize carry = 0

Add Digits

Add corresponding digits plus carry, store result mod 10

Handle Carry

Update carry for next position, move pointers left

Build Result

Continue until all digits processed and no carry remains

Code -

solution.c — C

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

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

int main() {
    char num1[10001], num2[10001];
    fgets(num1, sizeof(num1), stdin);
    fgets(num2, sizeof(num2), stdin);
    
    // Remove quotes and newlines
    num1[strcspn(num1, "\"\n")] = 0;
    num2[strcspn(num2, "\"\n")] = 0;
    if (num1[0] == '"') memmove(num1, num1+1, strlen(num1));
    if (num2[0] == '"') memmove(num2, num2+1, strlen(num2));
    
    char* result = addStrings(num1, num2);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(m, n))

We process each digit once, where m and n are lengths of input strings

✓ Linear Growth

Space Complexity

O(max(m, n))

Space needed to store the result string, which can be at most max(m,n) + 1 digits

⚡ Linearithmic Space

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
Cannot use built-in big integer libraries
Cannot convert strings directly to integers

89.5K Views

High Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Digit-by-Digit Addition (Optimal Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler