0672EasyTwo PointersString

Flip Each Word on the Banner

Tracked in this browser only

Trains the technique from

LeetCode 557Reverse Words in a String III

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 sign shop is setting a banner from the text line. The text holds one or more words written left to right, each pair of neighbouring words separated by exactly one space, with no space before the first word or after the last. A word is a run of characters that contains no space, and its characters may be letters, digits or punctuation.

The shop wants a mirrored banner: every word keeps its place in the line, but the characters inside each word are set in the opposite order.

Return the text of the mirrored banner, with the words still separated by a single space.

Examples

Example 1

Input: line = "stamp the wide banner"
Output: "pmats eht ediw rennab"

Each of the four words is set backwards, and the four words stay in the order they were given, still one space apart.

Example 2

Input: line = "lot-42 c3po hi!"
Output: "24-tol op3c !ih"

Digits and punctuation are characters of their word like any other, so they move with the rest of the word.

Example 3

Input: line = "mirror rotor level"
Output: "rorrim rotor level"

Two of these words read the same backwards, so only the first word changes.

Constraints

1 <= line.length <= 5 * 10^4
line holds printable ASCII characters.
line has no leading or trailing space, and words are separated by exactly one space.

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 flip_each_word(line: str) -> str:

Java

public String flipEachWord(String line)

The intended approach

Time O(n): each character is visited once by the walk and moved at most once by a swap.Space O(n) for the character list, which becomes the returned text.

Copy the text into a list of characters and remember where the current word started. Walk the positions once; when a space or the end of the text is reached, that word spans from the remembered start to the position just before, so swap its first and last characters, then the next pair inwards, until the two pointers meet. Then set the start to the position after the space. Spaces never move, so joining the list back up gives the mirrored banner.

Pythonentry point: flip_each_word

def flip_each_word(line):
    # walk once, and at every word boundary swap that word's characters inwards
    chars = list(line)
    n = len(chars)
    start = 0
    for i in range(n + 1):
        if i == n or chars[i] == " ":
            left, right = start, i - 1
            while left < right:
                chars[left], chars[right] = chars[right], chars[left]
                left += 1
                right -= 1
            start = i + 1
    return "".join(chars)

The obvious version

Split the text on single spaces. Push the characters of each word onto a stack and pop them off into a fresh word, which yields that word backwards, then join the rebuilt words with single spaces.

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_flip_each_word(line):
    out = []
    for word in line.split(" "):
        stack = []
        for ch in word:
            stack.append(ch)
        flipped = ""
        while stack:
            flipped += stack.pop()
        out.append(flipped)
    return " ".join(out)

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