How do you approach Plus One?

Start from the rightmost digit and add 1.

What is the time complexity of Plus One?

Time complexity: O(n). Space complexity: O(1) or O(n) if we need to prepend.

What are common mistakes on Plus One?

Overflowing at an intermediate step even though the final answer fits. Assuming a modulo is non-negative. In most languages -1 % n is negative, which breaks cyclic indexing. Testing floating-point values for exact equality where integer arithmetic would have been exact.

gitGood.dev

← Back to problems

Plus One

EasyAlgorithms

Description

You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the `i`th digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s. Increment the large integer by one and return the resulting array of digits.

Example 1

Input: digits = [1,2,3]

Output: [1,2,4]

Explanation: The array represents the integer 123. 123 + 1 = 124.

Example 2

Input: digits = [4,3,2,1]

Output: [4,3,2,2]

Explanation: The array represents the integer 4321. 4321 + 1 = 4322.

Example 3

Input: digits = [9]

Output: [1,0]

Explanation: The array represents the integer 9. 9 + 1 = 10.

Constraints

- 1 <= digits.length <= 100 - 0 <= digits[i] <= 9 - digits does not contain any leading 0's.

Plus One: approach, complexity and pitfalls

An easy math problem, graded against 7 test cases (4 of them hidden).

The pattern: Math

Number theory, digit manipulation, and closed-form reasoning.

Reach for it when you see: Primes, digits, base conversion, or a problem with a formula hiding behind it.

More Mathproblems →

If you are stuck

Show the 3-step hint ladder

Start from the rightmost digit and add 1.
Handle the carry: if a digit becomes 10, set it to 0 and carry 1 to the next digit.
If there's still a carry after processing all digits, prepend 1 to the array.

The optimal approach

Show the approach: Carry Propagation

Start from the least significant digit (rightmost). Add 1 and propagate the carry. If carry remains after all digits, prepend 1.

Time: O(n)
Space: O(1) or O(n) if we need to prepend

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.
Zero. Zero appears in the input, which is the value most likely to break a truthiness check used in place of an explicit comparison.

Common Math mistakes

These apply to the pattern as a whole, not just this problem.

Overflowing at an intermediate step even though the final answer fits.
Assuming a modulo is non-negative. In most languages `-1 % n` is negative, which breaks cyclic indexing.
Testing floating-point values for exact equality where integer arithmetic would have been exact.