Limited Time Offer:Up to 25% off Hello Interview Premium

⌘K

Tutor

Get Premium

Leetcode 415. Add Strings

Asked at:

DESCRIPTION

Given two non-negative integers represented as decimal strings, return their sum as a string by simulating digit-by-digit addition from right to left with carry propagation. You cannot convert the entire strings to integers or use big-integer libraries. For example, adding "123" and "456" should return "579" by processing digits 3+6=9, 2+5=7, 1+4=5.

Input:

num1 = "123"
num2 = "456"

Output:

"579"

Explanation: Add digit-by-digit: 3+6=9, 2+5=7, 1+4=5

Constraints:

String lengths up to 10^4 (must handle arbitrary-length inputs)
Strings contain only digits 0-9
No leading zeros except for the number 0 itself
Cannot convert entire strings to integers or use big-integer libraries

Understanding the Problem

The challenge is simulating elementary school addition programmatically: process digits from least significant (rightmost) to most significant (leftmost), maintaining a carry that propagates forward. Strings may have different lengths, requiring careful index management. The result must be built efficiently without unnecessary string concatenations, and a final carry may add an extra digit.

Building Intuition

A naive approach might try converting strings to integers, but this fails for large inputs exceeding integer limits. The optimal approach mimics manual addition: iterate from the rightmost digits, sum corresponding digits plus any carry, store the result digit, and propagate the carry forward. For example, adding "99" and "1": start with 9+1=10 (write 0, carry 1), then 9+0+1=10 (write 0, carry 1), finally write the remaining carry 1 to get "100".

This technique is fundamental for arbitrary-precision arithmetic used in cryptography, financial calculations, and scientific computing where numbers exceed native integer sizes. Understanding carry propagation and string manipulation without type conversion is essential for low-level numeric processing.

Common Pitfalls

Forgetting final carry: After processing all digits, if carry=1, it must become the leading digit (e.g., 99+1=100) — always append remaining carry

Inefficient string building: Repeatedly concatenating to strings is O(n²) — use an array/list and reverse once at the end

Index misalignment: Strings may differ in length — use separate pointers for each string or pad conceptually with zeros

Leading zeros: Result should never have leading zeros unless the answer is "0" — though this problem's constraints prevent it naturally

Implementation

Digit-by-Digit Addition with Carry

Implement the core addition loop that processes digits from right to left using two pointers (one for each string). At each step, extract digits at current positions (or 0 if out of bounds), compute sum = digit1 + digit2 + carry, store sum % 10 as the result digit, and update carry = sum // 10. Continue until both strings are exhausted and no carry remains. For example, adding "456" and "77": process 6+7=13 (write 3, carry 1), 5+7+1=13 (write 3, carry 1), 4+0+1=5 (write 5), yielding "533".

Solution

def add_strings(num1: str, num2: str) -> str:
    i, j = len(num1) - 1, len(num2) - 1
    carry = 0
    result = []
    
    while i >= 0 or j >= 0 or carry:
        digit1 = int(num1[i]) if i >= 0 else 0
        digit2 = int(num2[j]) if j >= 0 else 0
        
        total = digit1 + digit2 + carry
        result.append(str(total % 10))
        carry = total // 10
        
        i -= 1
        j -= 1
    
    return ''.join(reversed(result))

Efficient Result Construction

Build the result efficiently by appending digits to a list/array during the addition loop (since we process right-to-left but build left-to-right in memory). After the loop completes, reverse the list to get the correct digit order, then join into a string. This avoids O(n²) string concatenation overhead. For example, processing "99"+"1" appends [0, 0, 1] to the list, then reverses to [1, 0, 0] and joins to "100".

Solution

# Efficient Result Construction is already implemented in Section 1
# The add_strings function uses:
# 1. result = [] - list to collect digits
# 2. result.append(str(total % 10)) - append each digit
# 3. ''.join(reversed(result)) - reverse and join
# Example usage of the existing function:
# add_strings("99", "1") returns "100"
# Internally: result=[0,0,1] -> reversed=[1,0,0] -> "100"

What We've Learned

Pattern: Simulate manual arithmetic with two-pointer traversal from least to most significant digits, maintaining carry state
Use Case: Foundation for arbitrary-precision arithmetic in cryptography, financial systems, and any domain requiring calculations beyond native integer limits
Optimization: Use array/list building with final reversal instead of string concatenation to achieve O(n) time complexity
Edge Handling: Always check for remaining carry after main loop and handle different-length inputs gracefully with implicit zero-padding

Problems to Practice

Palindrome Linked List

easy

Linked List

This problem requires comparing values from both ends of a data structure moving inward, similar to how Add Strings processes digits from right to left. Both problems involve careful pointer/index management and handling elements in reverse order without converting to native types.

Practice

Decode String

medium

Stack

Like Add Strings, this problem involves building a result string character-by-character through careful state management and processing characters in a specific order. Both require handling nested operations (carry propagation vs nested brackets) and constructing output strings incrementally.

Practice

Longest Substring Without Repeating Characters

medium

Sliding Window

Both problems involve careful string traversal with index management and character-level processing. Add Strings uses two pointers moving from right to left with carry state, while this problem uses a sliding window approach, teaching complementary string manipulation techniques.

Practice

Question Timeline

See when this question was last asked and where, including any notes left by other candidates.

Company

Level

Region

Early November, 2025

Comments

Your account is free and you can post anonymously if you choose.

Hello Interview Premium

Recent interview questions

System Design Guided Practice

Exclusive content

Learn More

Leetcode 415. Add Strings

DESCRIPTION

Understanding the Problem

Building Intuition

Common Pitfalls

Implementation

Digit-by-Digit Addition with Carry

Efficient Result Construction

What We've Learned

Problems to Practice

Question Timeline

Comments

Questions

Learn

Links

Legal

Contact