# Add Two Numbers – Leetcode Solution

In this post, we are going to solve the 2. Add Two Numbers problem of Leetcode. This problem 2. Add Two Numbers is a Leetcode medium level problem. Let’s see the code, 2. Add Two Numbers – Leetcode Solution.

## 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.

### Example 1 :

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

### Example 2 :

``````
Input: l1 = , l2 = 
Output: 
``````

### 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

Now, let’s see the code of 2. Add Two Numbers – Leetcode Solution.

# Add Two Numbers – Leetcode Solution

### 2. Add Two Numbers – Solution in Java

```/**
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode() {}
*     ListNode(int val) { this.val = val; }
*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

if(l1 == null || l2 == null){
return l1 == null ? l2 : l1;
}

ListNode result = new ListNode();
ListNode ans = result;
int carry=0;
while(l1 != null && l2 != null){

int sum = carry + l1.val + l2.val;
int digit = sum%10;
carry = sum/10;

l1 = l1.next;
l2 = l2.next;

result.next = new ListNode(digit);
result = result.next;
}

while(l1 != null){
int sum = carry + l1.val;
int digit = sum%10;
carry = sum/10;
result.next = new ListNode(digit);
l1 = l1.next;
result = result.next;
}

while(l2 != null){
int sum = carry + l2.val;
int digit = sum%10;
carry = sum/10;
result.next = new ListNode(digit);
l2 = l2.next;
result = result.next;
}

if(carry != 0){
result.next = new ListNode(carry);
}

return ans.next;
}
}```

### 2. Add Two Numbers – Solution in C++

```/**
* 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 {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode *dummy=new ListNode();
ListNode *temp=dummy;

int carry=0;
while(l1!=NULL || l2!=NULL || carry){
int sum=0;
if(l1!=NULL){
sum+=l1->val;
l1=l1->next;
}
if(l2!=NULL){
sum+=l2->val;
l2=l2->next;
}
sum+=carry;
carry=sum/10;
ListNode *Node=new ListNode(sum%10);
temp->next=Node;
temp=temp->next;
}
return dummy->next;
}
};```

### 2. Add Two Numbers– Solution in Python

```# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
if not l1:
return l2
if not l2:
return l1

prev = l1
carry = 0
while l1 or l2:

sum_ = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
carry = sum_//10
sum_ = sum_%10
if l1:
l1.val = sum_
prev = l1
l1 = l1.next
else:
newNode = ListNode(sum_, None)
prev.next = newNode
prev = prev.next

if l2:
l2 = l2.next

if carry == 1:
newNode = ListNode(carry, None)
prev.next = newNode
prev = prev.next