LeetCode 2. Add Two Numbers

Question

The task is taken from LeetCode. I would appreciate an assessment of whether my coding style follows good practices, and if there are any habits or patterns you would find concerning when working together on a codebase.

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 contain a single digit. Add the two numbers and return it as a linked list.

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

Example:

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)

Output: 7 -> 0 -> 8

Explanation: 342 + 465 = 807.

My solution (Python3):

# Definition for singly-linked list provided by the platform.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# My solution 
# (Leetcode doesn't really let you put things in an __init__ method in a defined way 
# (we don't know if a new instance of Solution will be created for each test case), 
# so I didn't have one).
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        self.sumHead: ListNode = ListNode(0)
        self.sumLinkedList: ListNode = self.sumHead

        self.carry: int = 0
        while l1 and l2:
            # both numbers still have digits

            # Sanity Check
            assert self.carry in [0, 1]

            self.addDigitAndProcessCarry(l1.val + l2.val + self.carry)
            
            # move to the next node for both numbers
            l1 = l1.next
            l2 = l2.next

            # move to the next node for the sum
            if l1 or l2 or self.carry:
                self.sumLinkedList.next = ListNode(0)
                self.sumLinkedList = self.sumLinkedList.next

        for linkedListNotConsumed in [l1, l2]:
            # only one linked list has more digits to be processed
            while linkedListNotConsumed:
                # Sanity Check
                assert self.carry in [0, 1]

                self.addDigitAndProcessCarry(linkedListNotConsumed.val + self.carry)
                
                # move to the next node
                linkedListNotConsumed = linkedListNotConsumed.next

                if linkedListNotConsumed or self.carry:
                    self.sumLinkedList.next = ListNode(0)
                    self.sumLinkedList = self.sumLinkedList.next
            
        if self.carry:
            # Sanity Check
            assert self.carry in [0, 1]

            self.sumLinkedList.val = 1

        return self.sumHead
    
    def addDigitAndProcessCarry(self, value: int) -> None:
        if value >= 10:
            self.sumLinkedList.val = value - 10
            self.carry = 1
        else:
            self.sumLinkedList.val = value
            self.carry = 0

toolic · Accepted Answer · 2025-12-12 14:40:00Z

Naming

The PEP 8 style guide recommends snake_case for function and variable names. I realize the LeetCode site requires you to give the primary function those names, but you would otherwise name the function as add_two_numbers.

Also, addDigitAndProcessCarry would be add_digit_and_process_carry

For variables, sumHead would be sum_head, etc.

Comments

Many of your comments are helpful. However, this comment is not needed:

# My solution 
# (Leetcode doesn't really let you put things in an __init__ method in a defined way 
# (we don't know if a new instance of Solution will be created for each test case), 
# so I didn't have one).

Again, I realize you added this to explain the LeetCode restrictions.

Documentation

PEP 8 recommends adding docstrings for functions. The docstring would decscribe what the function does and how it does it, similar to the description of the problem in the question:

def add_two_numbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
    """
    Given two non-empty linked lists representing two non-negative integers...
    """

DRY

I see this code repeated 3 times:

assert self.carry in [0, 1]

I'm not sure you need to do that check in that many places, but if you do, you could create a helper function for the check to reduce the repetition.

Chris · Accepted Answer · 2025-12-13 00:29:48Z

Within the confines of Leetcode's requirements, this is about as straightforward a solution as can be hoped for. A few style suggestions have been pointed out by toolic.

The following code can be simplified a bit:

    def addDigitAndProcessCarry(self, value: int) -> None:
        if value >= 10:
            self.sumLinkedList.val = value - 10
            self.carry = 1
        else:
            self.sumLinkedList.val = value
            self.carry = 0

If we modulo value by 10, we can assume that is the next digit, and the carry is simply value divided (ensure integer division!) by 10.

    def addDigitAndProcessCarry(self, value: int) -> None:
        self.sumLinkedList.val = value % 10
        self.carry = value // 10

If writing within the confines of Leetcode's Solution class doesn't make sense, you are free to write your own functions and classes outside of it, and then simply wrap your solution in Solution.addTwoNumbers.

LeetCode's data structures

LeetCode's linked list data structure is dumb. It doesn't do nice things like let you iterate over it using built-in functionality in Python. But you don't have to live with that restriction.

You can implement that behavior yourself!

As an example, converting to and from iterators for LeetCode's ListNode:

def list_to_iter(lst):
    while lst:
        yield lst.val
        lst = lst.next

def iter_to_list(i):
    try:
        cur = head = ListNode(next(i))
    except StopIteration:
        return
    
    try:
        while x := next(i):
            cur.next = ListNode(x)
            cur = cur.next
    except StopIteration:
        return head

Note that you might also monkey patch this behavior into ListNode.

You can get the quotient and remainder in a single operation using the built-in divmod() function. self.carry, self.sumLinkedList.val = divmod(value, 10) — Barmar
– Barmar, Commented 5 hours ago

Stack Exchange Network

LeetCode 2. Add Two Numbers

2 Answers 2

Naming

Comments

Documentation

DRY

LeetCode's data structures

You must log in to answer this question.

Hot Network Questions

2 Answers 2

Naming

Comments

Documentation

LeetCode's data structures

You must log in to answer this question.

Related