Plus One

Reverse and carry

Addition wants to move from the least-significant digit—the digit in the ones place—toward the front. Reversing a copy puts that digit at index 0, so the carry can move forward through the copy.

def plus_one(digits: list[int]) -> list[int]:
    reversed_digits = digits[::-1]
    carry = 1
 
    for i in range(len(reversed_digits)):
        total = reversed_digits[i] + carry
        reversed_digits[i] = total % 10
        carry = total // 10
        if carry == 0:
            break
 
    if carry:
        reversed_digits.append(carry)
    return reversed_digits[::-1]

This version keeps the direction easy to see, but both reversals allocate new lists.

Time O(n) because each digit is copied or visited a constant number of times. Space O(n) for the reversed copies.

Walk from the end

You can follow the natural right-to-left direction without reversing anything. A digit below 9 absorbs the extra one, so you can return immediately. Only a suffix of nines forces the carry farther left.

def plus_one(digits: list[int]) -> list[int]:
    for i in range(len(digits) - 1, -1, -1):
        if digits[i] < 9:
            digits[i] += 1
            return digits
        digits[i] = 0
 
    return [1] + digits

If the loop ends, every digit was 9 and has become 0; the new leading 1 is the final carry. Otherwise the first non-nine digit ends the work early.

Time O(n) in the all-nines case and less when the carry stops early. Space O(1) beyond the returned array.