Add Strings

Add Strings looks easy at first. Just turn the strings into numbers and add them, right? But that is exactly the trap. The interviewer wants you to add them as text, digit by digit. Why? Because real numbers can be longer than any built-in integer can hold. So this question is really about doing addition by hand, the way you learned in school.

🎯 The Problem

You get two numbers given as strings, and you must return their sum, also as a string.

• The inputs are strings of digits, like "456" and "77".
• Return the sum as a string too.
• You cannot convert the whole string to an integer in one shot. You add them yourself.
• The numbers can be very long, longer than any built-in int or long.

Think about how you add on paper. You line the numbers up on the right. Then you add the last digits first. If the sum is ten or more, you keep a carry for the next column. The carry is the extra one you push to the next column when two digits add up past nine.

Input:  num1 = "456", num2 = "77"
Output: "533"

Explanation:
  4 5 6
+   7 7
-------
  5 3 3   (6+7=13 write 3 carry 1, 5+7+1=13 write 3 carry 1, 4+1=5)

Here is the addition lined up the way you would write it on paper, with the carry moving left.

🐢 Approach 1: Convert To Numbers (Brute Force)

Call something like int(num1) + int(num2) and turn the result back into a string.

The idea:

• Parse each whole string into an integer.
• Add the two integers.
• Turn the sum back into a string.

Why it is weak:

• It breaks the moment a number is bigger than the language’s integer can hold.
• In C, C++ and Java the value overflows and you get a garbage answer. Overflow means the number got too big for its box, so it wraps around to a wrong value.
• Python would not overflow, but the interviewer is testing the manual method on purpose.
• So this idea misses the point of the question.

Here is the conversion code for that idea:

def add_strings(num1, num2):
    return str(int(num1) + int(num2))

⚡ Approach 2: Add Digit By Digit With A Carry (Best)

The idea in one line: add the two strings the way you do on paper, from the right, carrying when a column passes nine.

The idea:

• A pointer is just an index saying which digit you are looking at.
• Use two pointers, one per string. Both start at the last digit and move left.

How it works:

• Add the two current digits plus any carry from before.
• The last digit of that sum is the digit you write.
• The carry for the next column is the sum divided by ten.
• When one string runs out, treat its missing digit as zero.
• Keep going until both strings are done and there is no carry left.
• Build the answer from right to left, then reverse once at the end.

Why it is safe:

• It never converts the whole number, so it never overflows.
• It handles numbers of any length.
• It touches each digit exactly once.

Steps to Solve

1. Set one pointer at the last character of num1 and another at the last character of num2.
2. Start the carry at zero.
3. While either pointer is still valid or the carry is not zero, do the next steps.
4. Read the current digit from each string, or use zero if that pointer ran past the start.
5. Add both digits and the carry. The written digit is the sum modulo ten. The new carry is the sum divided by ten.
6. Append the written digit, move both pointers left, and repeat.
7. Reverse the collected digits to get the final string.

Here is the loop in action on "456" and "77". Watch the carry move left at each step until both strings and the carry are done.

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

void addStrings(const char *num1, const char *num2, char *out) {
    int i = (int)strlen(num1) - 1;  // last digit of num1
    int j = (int)strlen(num2) - 1;  // last digit of num2
    int carry = 0;
    int k = 0;
    char buf[1024];

    while (i >= 0 || j >= 0 || carry > 0) {
        int d1 = (i >= 0) ? num1[i] - '0' : 0;  // 0 if num1 ran out
        int d2 = (j >= 0) ? num2[j] - '0' : 0;  // 0 if num2 ran out
        int sum = d1 + d2 + carry;
        buf[k++] = (char)('0' + sum % 10);       // write last digit
        carry = sum / 10;                        // keep the carry
        i--;
        j--;
    }

    for (int p = 0; p < k; p++) {  // reverse into out
        out[p] = buf[k - 1 - p];
    }
    out[k] = '\0';
}

int main(void) {
    char out[1025];
    addStrings("456", "77", out);
    printf("%s\n", out);
    return 0;
}

533

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

string addStrings(string num1, string num2) {
    int i = (int)num1.size() - 1;  // last digit of num1
    int j = (int)num2.size() - 1;  // last digit of num2
    int carry = 0;
    string result;

    while (i >= 0 || j >= 0 || carry > 0) {
        int d1 = (i >= 0) ? num1[i] - '0' : 0;  // 0 if num1 ran out
        int d2 = (j >= 0) ? num2[j] - '0' : 0;  // 0 if num2 ran out
        int sum = d1 + d2 + carry;
        result += (char)('0' + sum % 10);        // write last digit
        carry = sum / 10;                        // keep the carry
        i--;
        j--;
    }

    reverse(result.begin(), result.end());  // we built it backwards
    return result;
}

int main() {
    cout << addStrings("456", "77") << endl;
    return 0;
}

533

public class AddStrings {
    public static String addStrings(String num1, String num2) {
        int i = num1.length() - 1;  // last digit of num1
        int j = num2.length() - 1;  // last digit of num2
        int carry = 0;
        StringBuilder sb = new StringBuilder();

        while (i >= 0 || j >= 0 || carry > 0) {
            int d1 = (i >= 0) ? num1.charAt(i) - '0' : 0;  // 0 if ran out
            int d2 = (j >= 0) ? num2.charAt(j) - '0' : 0;  // 0 if ran out
            int sum = d1 + d2 + carry;
            sb.append((char) ('0' + sum % 10));            // write last digit
            carry = sum / 10;                              // keep the carry
            i--;
            j--;
        }

        return sb.reverse().toString();  // we built it backwards
    }

    public static void main(String[] args) {
        System.out.println(addStrings("456", "77"));
    }
}

533

def add_strings(num1, num2):
    i = len(num1) - 1            # last digit of num1
    j = len(num2) - 1            # last digit of num2
    carry = 0
    result = []

    while i >= 0 or j >= 0 or carry > 0:
        d1 = int(num1[i]) if i >= 0 else 0   # 0 if num1 ran out
        d2 = int(num2[j]) if j >= 0 else 0   # 0 if num2 ran out
        total = d1 + d2 + carry
        result.append(str(total % 10))       # write last digit
        carry = total // 10                  # keep the carry
        i -= 1
        j -= 1

    return "".join(reversed(result))         # we built it backwards


print(add_strings("456", "77"))

533

function addStrings(num1, num2) {
  let i = num1.length - 1; // last digit of num1
  let j = num2.length - 1; // last digit of num2
  let carry = 0;
  const result = [];

  while (i >= 0 || j >= 0 || carry > 0) {
    const d1 = i >= 0 ? num1.charCodeAt(i) - 48 : 0; // 0 if num1 ran out
    const d2 = j >= 0 ? num2.charCodeAt(j) - 48 : 0; // 0 if num2 ran out
    const sum = d1 + d2 + carry;
    result.push(sum % 10); // write last digit
    carry = Math.floor(sum / 10); // keep the carry
    i--;
    j--;
  }

  return result.reverse().join(""); // we built it backwards
}

console.log(addStrings("456", "77"));

533

Let us walk through the Python version line by line. The two pointers i and j start at the last index of each string. We add from the right, so the last character is where the math begins. The carry starts at zero because nothing has overflowed yet.

The while loop keeps running while either pointer is still valid or the carry is not zero. That last part matters. If the final addition makes a carry, like "5" + "5" giving "10", the loop runs one extra time to write that leading 1.

Inside, d1 = int(num1[i]) if i >= 0 else 0 reads the current digit. But if that pointer already went past the start, we use 0 instead. This is how we handle two strings of different lengths without padding them by hand.

Then total = d1 + d2 + carry is the column sum. total % 10 is the last digit of that sum, which is the digit we keep. carry = total // 10 is the part that moves left. For 13, the modulo gives 3 and the floor division gives 1. We append the digit and step both pointers left. At the end we reverse, because we built the answer from right to left.

⏱️ Time and Space Complexity

We touch each digit of each string exactly once. So the time is O(max(m, n)), where m and n are the lengths of the two strings. We need space to hold the answer, which is also about the length of the longer string. So the space is O(max(m, n)) too. There is no faster way, because you must look at every digit at least once to add it.

🧩 Key Takeaways

• ✅ Add the strings the way you do on paper, from the rightmost digit to the left.
• ✅ Keep a carry. The written digit is the sum modulo ten, and the carry is the sum divided by ten.
• ✅ When one string is shorter, treat its missing digits as zero.
• ✅ Keep looping while the carry is not zero, so you never drop the final leading digit.
• ✅ Converting to a number can overflow in C, C++, and Java, which is why the manual method is the safe answer.

🚀 What’s Next?

• Multiply Strings
• Merge Strings Alternately