0061MediumString

Engraved Track Transcript

Tracked in this browser only

Trains the technique from

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 plate engraver cuts the characters of message into rows parallel horizontal tracks, numbered 0 at the top through rows - 1 at the bottom. It stamps the characters one at a time in the order they appear.

The head starts on track 0 and drops one track after each stamp until it stamps into the bottom track; it then climbs one track after each stamp until it stamps into the top track, and it keeps swinging that way until the message runs out. Each stamp lands to the right of anything already cut into that track, so within a track the characters stay in the order they were stamped. When rows is 1 the head never leaves the top track.

The inspector reads the plate one track at a time, top track first, taking each track from left to right. Return the string that reading produces.

Examples

Example 1

Input: message = "QuietHum", rows = 2
Output: "QituueHm"

With two tracks the head alternates on every stamp, so the top track collects the characters at positions 0, 2, 4 and 6 while the bottom track collects those at 1, 3, 5 and 7. Reading the top track and then the bottom track gives QituueHm.

Example 2

Input: message = "ENGRAVETHISLABEL", rows = 4
Output: "EEANVTLBGAHSERIL"

A full swing across four tracks takes six stamps, so the head is back on the top track at positions 0, 6 and 12, giving it E, E and A. Track 1 gathers positions 1, 5, 7, 11 and 13, and the two lower tracks follow beneath.

Example 3

Input: message = "zzzz", rows = 1
Output: "zzzz"

With a single track the head never moves off it, so the plate reads exactly like the message.

Constraints

1 <= message.length <= 1000
message consists of English letters (lower-case and upper-case), ',' and '.'.
1 <= rows <= 1000

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 engrave_transcript(message: str, rows: int) -> str:

Java

public String engraveTranscript(String message, int rows)

The intended approach

Time O(n)Space O(n)

The column a character lands in never matters to the reading order, only its track does, so keep one buffer per track and append each character to the buffer of the track the head is on. A single step variable holds the head's direction: it turns to downward on the top track and to upward on the bottom track. Joining the buffers top to bottom is the transcript, and a single track is returned untouched because the head never turns.

Pythonentry point: engrave_transcript

def engrave_transcript(message, rows):
    if rows == 1:
        return message
    tracks = [[] for _ in range(rows)]
    track = 0
    step = 1
    for ch in message:
        tracks[track].append(ch)
        if track == 0:
            step = 1
        elif track == rows - 1:
            step = -1
        track += step
    pieces = []
    for group in tracks:
        pieces.append("".join(group))
    return "".join(pieces)

The obvious version

Lay out an actual grid of blank cells, walk the head down a column and then diagonally up and to the right while dropping characters into cells, and finally sweep the grid row by row collecting the non-blank cells.

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_engrave_transcript(message, rows):
    n = len(message)
    grid = [[""] * (n + 2) for _ in range(rows)]
    row = 0
    col = 0
    going_down = True
    for ch in message:
        grid[row][col] = ch
        if rows == 1:
            col += 1
            continue
        if going_down:
            if row == rows - 1:
                going_down = False
                row -= 1
                col += 1
            else:
                row += 1
        else:
            if row == 0:
                going_down = True
                row += 1
            else:
                row -= 1
                col += 1
    out = []
    for line in grid:
        for cell in line:
            if cell != "":
                out.append(cell)
    return "".join(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