0500EasyArraySimulation

Digit Cells for the Ticket Codes

Tracked in this browser only

Trains the technique from

LeetCode 2553Separate the Digits in an Array

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 cloakroom board shows ticket codes on a long strip of cells, one digit per cell.

The board works through codes from the first entry to the last. For each code it fills the next few cells with that code's digits, taken left to right as the code is written, and then carries straight on with the code after it. Nothing separates one code from the next on the strip.

Return the digits in the cells, in the order the board filled them.

Examples

Example 1

Input: codes = [4021, 7, 100000, 605]
Output: [4, 0, 2, 1, 7, 1, 0, 0, 0, 0, 0, 6, 0, 5]

The board fills 4, 0, 2, 1 for the first code, then a single cell with 7, then 1, 0, 0, 0, 0, 0 for the third code, then 6, 0, 5 for the last.

Example 2

Input: codes = [86, 4, 517, 20]
Output: [8, 6, 4, 5, 1, 7, 2, 0]

Reading the strip back gives 8, 6 then 4 then 5, 1, 7 then 2, 0, which is each code's digits in writing order with the codes still in their original order.

Example 3

Input: codes = [1005]
Output: [1, 0, 0, 5]

One code fills four cells, and the two zeros in the middle of the code each take a cell of their own.

Constraints

1 <= codes.length <= 1000
1 <= codes[i] <= 10^5

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 digit_cells(codes: list[int]) -> list[int]:

Java

public int[] digitCells(int[] codes)

The intended approach

Time O(n * d) for n codes of at most d digits: each digit is peeled once.Space O(d) for the run being flipped, beyond the returned strip.

Handle one code at a time with arithmetic only. The remainder on division by ten is the code's last digit, and integer division by ten drops it, so repeating that until nothing is left collects the digits in the reverse of reading order. Flip the run for that one code and append it to the strip, which keeps codes in their original order while fixing the digits inside each one.

Pythonentry point: digit_cells

def digit_cells(codes):
    # peel digits off the low end, then flip that code's run back into reading order
    strip = []
    for code in codes:
        run = []
        left = code
        while left > 0:
            run.append(left % 10)
            left //= 10
        run.reverse()
        strip.extend(run)
    return strip

The obvious version

Write each code out as text, walk its characters in order and turn each one back into a number, appending them to the strip.

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_digit_cells(codes):
    strip = []
    for code in codes:
        for mark in str(code):
            strip.append(int(mark))
    return strip

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