Add Linked Lists - Amazon Top Interview Questions

                        Solution in C++ :

/**
 * class LLNode {
 *     public:
 *         int val;
 *         LLNode *next;
 * };
 */
LLNode* solve(LLNode* l0, LLNode* l1) {
    int carry = 0;
    LLNode *head = new LLNode(0), *res = head;
    // now normal addition :D
    // add the numbers, then send over the carry

    while (l0 or l1 or carry) {
        res->next = new LLNode();
        res = res->next;
        int a, b;

        if (!l0)
            a = 0;
        else
            a = l0->val, l0 = l0->next;

        if (!l1)
            b = 0;
        else
            b = l1->val, l1 = l1->next;

        // now just add these two to each other!
        int digit = (a + b + carry) % 10;
        carry = (a + b + carry) / 10;

        res->val = digit;
        // cout << " added " << digit << " to the list " << endl;
    }

    return head->next;
}
                    

                        Solution in Python : 
                            
# class LLNode:
#     def __init__(self, val, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def solve(self, l0, l1):
        def finish_remaining(l, c):
            s, head, tail = 0, None, None
            while l is not None:  # Need to do extra addition only if there is a leftover carry
                entry = l.val + c
                s = entry % 10
                c = entry // 10
                l.val = s
                if head is None:
                    head = tail = l
                else:
                    tail.next = l
                    tail = l
                prev, l = l, l.next
            if c == 1:  # Try l =[9,9] and c=1 what should happen?
                prev.next = LLNode(1)
            return head

        if l0 is None and l1 is not None:
            return l1
        elif l1 is None and l0 is not None:
            return l0
        elif l0 is None and l1 is None:
            return None

        s, c, prev, head = 0, 0, None, l0
        while l0 is not None and l1 is not None:
            entry = l0.val + l1.val + c
            s, c = entry % 10, entry // 10
            l0.val = s
            prev, l0, l1 = l0, l0.next, l1.next

        prev.next = None
        if l0 is None and l1 is not None:
            prev.next = finish_remaining(l1, c)
        elif l1 is None and l0 is not None:
            prev.next = finish_remaining(l0, c)
        elif c == 1:  # l1 and l0 are both None But there is a leftover carry. Try for Example 1
            prev.next = LLNode(1)
        return head