0049HardArrayStringSimulation

Notice Board Justification

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 platform notice board prints one announcement at a time on a character cell display that is width cells across. The announcement arrives already chopped into pieces as tokens, in the order they must appear. No token contains a blank, and no token is longer than width.

Lay the tokens out row by row and return the rows as a list of strings, each string exactly width characters long, built by these rules.

Filling. Walk the tokens in order and keep adding the next one to the row you are building for as long as it still fits, counting at least one blank cell between neighbouring tokens on that row. When it no longer fits, close the row and start the next one with that token.
Stretching a closed row that holds two or more tokens. The row must reach exactly width, so widen the blank runs between its tokens. Every gap gets the same number of blanks where that is possible. If the blanks do not divide evenly over the gaps, the surplus goes to the gaps nearest the left edge, one extra blank each, until the surplus is used up. So the leftmost gap is never narrower than a gap to its right.
A closed row holding one token. There is no gap to widen, so the token starts at the left edge and every remaining cell to its right is blank.
The final row. It is never stretched. Its tokens are separated by exactly one blank, and the cells after the last token are blank out to width. That holds even if the final row happens to carry several tokens.

Examples

Example 1

Input: tokens = ["depart", "gate", "nine", "boarding", "now"], width = 12
Output: ["depart gate", "nine ", "boarding now"]

Row one holds two tokens and one gap, so both surplus blanks land in it. Row two carries a single token padded on the right. The final row fills the display exactly, so no padding is needed.

Example 2

Input: tokens = ["red", "amber", "green", "flash"], width = 16
Output: ["red amber green", "flash "]

Row one has three blanks to spread over two gaps, so the left gap takes two and the right gap takes one. The final row is a lone token padded to the right edge.

Example 3

Input: tokens = ["cancelled", "delay", "sixty"], width = 9
Output: ["cancelled", "delay ", "sixty "]

The first token is as wide as the display, so nothing can share its row and it needs no padding at all.

Constraints

1 <= tokens.length <= 300
1 <= tokens[i].length <= 20
tokens[i] is made of English letters and punctuation, and contains no blank
1 <= width <= 100
tokens[i].length <= width

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 render_board(tokens: list[str], width: int) -> list[str]:

Java

public List<String> renderBoard(String[] tokens, int width)

The intended approach

Time O(total characters)Space O(total characters) for the rendered rows

Carry the tokens of the row under construction plus the count of characters they use. The next token fits when its length, the characters already used and one blank per existing gap still stay within `width`; otherwise close the row first. Closing splits into three shapes: a single token padded right, or blanks divided over the gaps with divmod so the first remainder gaps take one extra each. The row left over when the tokens run out is emitted under the final-row rule instead.

Pythonentry point: render_board

def render_board(tokens, width):
    lines = []
    line = []
    letters = 0
    for token in tokens:
        if line and letters + len(token) + len(line) > width:
            if len(line) == 1:
                lines.append(line[0] + " " * (width - letters))
            else:
                gaps = len(line) - 1
                blanks = width - letters
                base, extra = divmod(blanks, gaps)
                out = ""
                for i, word in enumerate(line[:-1]):
                    out += word + " " * (base + (1 if i < extra else 0))
                out += line[-1]
                lines.append(out)
            line = []
            letters = 0
        line.append(token)
        letters += len(token)
    tail = " ".join(line)
    lines.append(tail + " " * (width - len(tail)))
    return lines

The obvious version

Two separate passes with different machinery. First slice the tokens into rows by testing candidate row contents with a joined-string length instead of running counters. Then pad each row by starting every gap at one blank and handing out one extra blank at a time, cycling from the left gap rightwards, until the row measures `width`.

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_render_board(tokens, width):
    groups = []
    start = 0
    total = len(tokens)
    while start < total:
        end = start
        while end + 1 < total and len(" ".join(tokens[start:end + 2])) <= width:
            end += 1
        groups.append(tokens[start:end + 1])
        start = end + 1
    rows = []
    for index, group in enumerate(groups):
        if index == len(groups) - 1 or len(group) == 1:
            text = " ".join(group)
            while len(text) < width:
                text += " "
            rows.append(text)
            continue
        gaps = [1] * (len(group) - 1)
        used = sum(len(word) for word in group) + sum(gaps)
        cursor = 0
        while used < width:
            gaps[cursor] += 1
            used += 1
            cursor = (cursor + 1) % len(gaps)
        pieces = []
        for i, word in enumerate(group[:-1]):
            pieces.append(word)
            pieces.append(" " * gaps[i])
        pieces.append(group[-1])
        rows.append("".join(pieces))
    return rows

How this problem was checked

Reference solution executed against 9 test cases — 9 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