# Leetcode Add-Two-Numbers

2022-09-08 15:22

> ##### Algorithms:
>
> #algorithm #math
>
> ##### Data structures:
>
> #DS #linked_list
>
> ##### Difficulty:
>
> #coding_problem #difficulty_medium
>
> ##### Additional tags:
>
> #leetcode
>
> ##### Revisions:
>
> N/A

##### Links:

- [Link to problem](https://leetcode.com/problems/add-two-numbers/)

---

### Problem

You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order**, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

#### Examples

**Example 1:**

![](https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg)

```
**Input:** l1 = [2,4,3], l2 = [5,6,4]
**Output:** [7,0,8]
**Explanation:** 342 + 465 = 807.
```

**Example 2:**

```
**Input:** l1 = [0], l2 = [0]
**Output:** [0]
```

**Example 3:**

```
**Input:** l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
**Output:** [8,9,9,9,0,0,0,1]
```

#### Constraints

- The number of nodes in each linked list is in the range `[1, 100]`.
- `0 <= Node.val <= 9`
- It is guaranteed that the list represents a number that does not have leading zeros.

### Thoughts

> [!summary]
> This is a elementary #math problem.
> For a list of similar questions, visit [[Elementary Math Problems]]

Done by using elementary math.

Use only one variable `tmp` to keep track of sum of 2
digits and carries.

### Solution

```cpp
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
  ListNode *appendNumber(ListNode *ptr, int num) {
    ListNode *ans = new ListNode(num, nullptr);
    ptr->next = ans;

    return ans;
  }

public:
  ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
    ListNode *ptr1 = l1, *ptr2 = l2;

    // the minimum size is 1, so we can safely do this.
    int tmp = ptr1->val + ptr2->val;

    ListNode *ans = new ListNode(tmp % 10);

    ListNode *tail = ans;

    tmp /= 10;
    ptr1 = ptr1->next;
    ptr2 = ptr2->next;

    while (ptr1 || ptr2 || tmp) {
      if (ptr1) {
        tmp += ptr1->val;
        ptr1 = ptr1->next;
      }

      if (ptr2) {
        tmp += ptr2->val;
        ptr2 = ptr2->next;
      }

      tail = appendNumber(tail, tmp % 10);

      tmp /= 10;
    }

    return ans;
  }
};
```