---
title: Add Strings
difficulty: Easy
category: String
leetcode_id: 415
revision_count: 1
last_revision: 2026-09-12
---

# Add Strings

> **LeetCode:** [#415](https://leetcode.com/problems/add-strings/)
> **Сложность:** Easy
> **Категория:** String

## Условие

Даны два неотрицательных целых числа в виде строк `num1` и `num2`. Вернуть их сумму в виде строки. Нельзя преобразовывать строки в Integer напрямую (могут быть длиной до 10^4 символов). Сложение столбиком справа налево с переносом (carry), как в десятичной арифметике.

```
Input: num1 = "11", num2 = "123"  →  Output: "134"
Input: num1 = "456", num2 = "77"  →  Output: "533"
Input: num1 = "0", num2 = "0"     →  Output: "0"
```

## Ключевая идея

Идём двумя указателями с конца обеих строк в начало, на каждом шаге складываем две цифры + перенос, вычисляем новый перенос делением на 10, а цифру результата — остатком от деления на 10. Результат собираем в обратном порядке и разворачиваем в конце.

## Оценка сложности

- **Время:** O(max(n, m)), где n, m — длины строк
- **Память:** O(max(n, m)) — на строку результата (без учёта входа)

## Решение (Ruby)

```ruby
# @param {String} num1
# @param {String} num2
# @return {String}
def add_strings(num1, num2)
  i = num1.size - 1
  j = num2.size - 1
  carry = 0
  result = []

  while i >= 0 || j >= 0 || carry > 0
    sum = carry
    sum += num1[i].to_i if i >= 0
    sum += num2[j].to_i if j >= 0
    result << (sum % 10).to_s
    carry = sum / 10
    i -= 1
    j -= 1
  end

  result.reverse.join
end
```

## Разбор на примере

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

i=2, j=1, carry=0:
  sum = 0 + 6 + 7 = 13  →  result="3", carry=1
i=1, j=0, carry=1:
  sum = 1 + 5 + 7 = 13  →  result="33", carry=1
i=0, j=-1, carry=1:
  sum = 1 + 4 + 0 = 5   →  result="533", carry=0

Result: "533"
```

## Edge Cases

- Одна из строк короче другой → указатель уходит в -1, добавляем только 0
- Переполнение разряда в конце (например, `"9" + "1"` → `"10"`) → условие `|| carry > 0` добавляет старший разряд
- Обе строки `"0"` → результат `"0"`
- Строки длиной до 10^4 символов — нельзя конвертировать в Integer (переполнение стандартного Integer или медленно для BigInt)
- Ведущие нули: по условию их нет, кроме самого числа `"0"`

## Типичные ошибки

- Забывают `|| carry > 0` в условии цикла — теряется финальный перенос (старший разряд)
- Собирают результат в прямом порядке и не делают `reverse`
- Пытаются через `num1.to_i + num2.to_i` — для коротких строк работает, но при 10^4 символах переполнение
- Не обрабатывают разную длину строк — выход за границы
- Путают `sum / 10` (перенос) и `sum % 10` (цифра результата) — в двоичном сложении `/ 2` и `% 2`, здесь `/ 10` и `% 10`

## Альтернативные подходы

| Подход | Время | Память | Комментарий |
|--------|-------|--------|-------------|
| **Сложение столбиком с carry** | **O(max(n, m))** | **O(max(n, m))** | **финальное решение, стандарт для интервью** |
| Через Integer: `(num1.to_i + num2.to_i).to_s` | O(n + m) | O(n) | работает на малых данных, переполняется на 10^4 цифрах |
| Предварительное выравнивание нулями слева | O(max(n, m)) | O(max(n, m)) | эквивалентно, чуть больше кода |

### Ruby built-in (не для интервью)

```ruby
(num1.to_i + num2.to_i).to_s
```

> **Важно:** на интервью пишут руками. `to_i` годен только как быстрая проверка результата.

## Заметки после повторения

_Что забыл? Что пошло не так? На чём застрял? Заполни после каждой тренировки._