0642EasyArrayMath

Advancing A Digit Strip Counter

Tracked in this browser only

Trains the technique from

LeetCode 989Add to Array-Form of Integer

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A mechanical counter shows its reading as digits, one decimal digit per wheel, listed from the most significant wheel to the least significant one. The reading carries no leading zero unless it is the single digit 0.

The counter is now advanced by step units. Return the new reading in the same form, most significant digit first and with no leading zero. The strip gains a wheel at the front when the reading needs one.

Examples

Example 1

Input: digits = [9, 9, 9], step = 1
Output: [1, 0, 0, 0]

The reading 999 advanced by 1 unit becomes 1000, which needs a fourth wheel, so the strip is [1, 0, 0, 0].

Example 2

Input: digits = [1, 4, 0, 7], step = 93
Output: [1, 5, 0, 0]

The reading 1407 advanced by 93 units becomes 1500, so the strip is [1, 5, 0, 0].

Example 3

Input: digits = [0], step = 10000
Output: [1, 0, 0, 0, 0]

The reading 0 advanced by 10000 units becomes 10000, so four wheels are added at the front.

Constraints

1 <= digits.length <= 10^4
0 <= digits[i] <= 9
digits has no leading zero unless it is the single digit 0.
1 <= step <= 10^4

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def add_to_array_form(digits: list[int], step: int) -> list[int]:

Java

public List<Integer> addToArrayForm(int[] digits, int step)

The intended approach

Time O(max(n, log step)) — one step per wheel plus the wheels the carry adds.Space O(n) for the returned reading.

Treat the whole of step as a carry arriving at the least significant wheel. Move leftwards along the strip: add the current wheel into the carry, emit the carry's last decimal digit as the new wheel, and drop that digit from the carry. Keep looping once the wheels are exhausted while the carry is still non-zero, which produces the extra leading wheels. Digits are emitted least significant first, so the collected list is reversed before it is returned. The reading is never turned into a single number, so a strip of ten thousand wheels costs no more per wheel than a short one.

Pythonentry point: add_to_array_form

def add_to_array_form(digits, step):
    # O(max(n, log step)) time and O(n) space for the list returned. Walk the
    # reading from its least significant digit, treating the whole of step as an
    # incoming carry that is spent ten units at a time, and keep going after the
    # digits run out while any carry remains, which is how the reading grows.
    out = []
    carry = step
    i = len(digits) - 1
    while i >= 0 or carry > 0:
        if i >= 0:
            carry += digits[i]
            i -= 1
        out.append(carry % 10)
        carry //= 10
    out.reverse()
    return out

The obvious version

Fold the digit strip into one exact integer by repeated multiply and add, add step to it, then peel the result apart again with remainders by ten and reverse the collected digits.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_add_to_array_form(digits, step):
    total = 0
    for d in digits:
        total = total * 10 + d
    total += step
    if total == 0:
        return [0]
    out = []
    while total > 0:
        out.append(total % 10)
        total //= 10
    out.reverse()
    return out

How this problem was checked

Reference solution executed against 11 test cases — 11 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in