2. Add Two Numbers

---

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 = [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.

 # Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
#     def reverseLL(self, head):
#         prev = None
#         node = head
#         while node:
#             temp = node.next 
#             node.next = prev
#             prev = node
#             node = temp
#         return prev

#     def nodeToNumber(self, head):
#         number = 0
#         node = head
#         while node:
#             number = number*10 + node.val
#             node = node.next 

#         return number

#     def numberToNode(self, number):

#         head = ListNode(0)
#         node = head
#         if number == 0:
#             return head

#         while number!=0:
#             digit = number%10
#             new_node = ListNode(digit)
#             node.next = new_node
#             node = new_node
#             number = number// 10

#         return head.next


    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        carry = 0
        dummy = ListNode(0)
        node = dummy

        p1 = l1
        p2 = l2

        while p1 or p2:
            n1 = p1.val if p1 else 0
            n2 = p2.val if p2 else 0

            ans = n1+n2+carry
            carry = ans // 10
            node.next = ListNode(ans%10)
            node = node.next

            if p1:
                p1 = p1.next 
            if p2:
                p2 = p2.next 

        if carry > 0:
            node.next = ListNode(carry)


        return dummy.next

#         l1_rev = self.reverseLL(l1)
#         num1 = self.nodeToNumber(l1_rev)

#         l2_rev = self.reverseLL(l2)
#         num2 = self.nodeToNumber(l2_rev)

#         answer =  num1+num2 
#         return self.numberToNode(num1 + num2)