0149EasyTwo PointersString

Marquee Vowel Sockets

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 theatre spells the evening listing on its marquee out of character tiles clamped along one rail. A tile sits in a loose socket when its character is a, e, i, o or u, written either as a capital or in lower case. Every other tile on the rail is riveted down and cannot be moved, whatever character it shows.

The stagehand lifts all of the loose tiles off the rail, holds them, and drops them back into exactly the same sockets, but working from the far end of the rail towards the near end. The upshot is that the loose tiles occupy the same positions as before with their order along the rail turned around, while every riveted tile is untouched. Tiles are never re-cut, so a capital tile stays a capital wherever it lands.

You are given the current marquee text as the string board, made of printable ASCII characters. Return the text the marquee shows once the stagehand steps back.

Examples

Example 1

Input: board = "TOP hat"
Output: "TaP hOt"

Two tiles are loose, the capital in position 1 and the lower-case one in position 5. They trade sockets, and each keeps the case it was cut with.

Example 2

Input: board = "Grand Opening"
Output: "Grind epOnang"

The four loose tiles sit in positions 2, 6, 8 and 10; reading them back to front gives the tiles that land in those same four positions. The space and every riveted tile stay put.

Example 3

Input: board = "myrtle"
Output: "myrtle"

Only one tile here is loose, so lifting it and dropping it back changes nothing. A tile showing the letter y is riveted like any other consonant tile.

Constraints

1 <= board.length <= 3 * 10^5
board consists of printable ASCII characters.
A tile is loose only for the ten characters a, e, i, o, u, A, E, I, O, U.

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 marquee_vowel_sockets(board: str) -> str:

Java

public String marqueeVowelSockets(String board)

The intended approach

Time O(n)Space O(n)

Turning a sequence around while leaving fixed positions alone is a job for two markers closing in on each other. Hold one marker at the near end of the rail and one at the far end. Slide whichever marker is parked on a riveted tile, and when both markers sit on loose tiles swap those two tiles and step both markers inward. Each marker only ever moves one way, so the rail is covered once.

Pythonentry point: marquee_vowel_sockets

def marquee_vowel_sockets(board):
    # Time: O(n) -- the two markers together cover the rail once.
    # Space: O(n) -- the mutable buffer that becomes the returned text.
    loose = set("aeiouAEIOU")
    tiles = list(board)
    near = 0
    far = len(tiles) - 1
    while near < far:
        if tiles[near] not in loose:
            near += 1
        elif tiles[far] not in loose:
            far -= 1
        else:
            tiles[near], tiles[far] = tiles[far], tiles[near]
            near += 1
            far -= 1
    return "".join(tiles)

The obvious version

Record which sockets are loose and which tiles they hold, reverse that list of tiles outright, then write the reversed tiles back into the recorded sockets in order.

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_marquee_vowel_sockets(board):
    loose = "aeiouAEIOU"
    sockets = []
    for i in range(len(board)):
        if board[i] in loose:
            sockets.append(i)
    lifted = []
    for i in reversed(sockets):
        lifted.append(board[i])
    rail = list(board)
    for k in range(len(sockets)):
        rail[sockets[k]] = lifted[k]
    return "".join(rail)

How this problem was checked

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