0713EasyString

Rook Talk

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.

Children at a playground trade messages in a word game called Rook Talk. A sentence is rewritten one word at a time, and the rewritten words stay in their original order, separated by single spaces.

Take the word sitting in position i, counting the first word as position 1, and apply these steps in order:

if its first letter is a vowel, meaning one of the letters in aeiou in either case, leave its letters where they are; otherwise take that first letter off the front and put it on the end;
append ok to the word;
append the letter k a further i times.

Letter case is never altered: a letter that arrives uppercase stays uppercase wherever it ends up.

Return the rewritten sentence.

Examples

Example 1

Input: sentence = "wren and heron"
Output: "renwokk andokkk eronhokkkk"

`wren` does not start with a vowel, so it becomes `renw`, then `ok`, then one k: `renwokk`. `and` starts with a vowel and keeps its letters, then `ok` and two k's: `andokkk`. `heron` becomes `eronh`, then `ok` and three k's: `eronhokkkk`.

Example 2

Input: sentence = "Zebra crossing"
Output: "ebraZokk rossingcokkk"

`Zebra` does not start with a vowel, so the capital `Z` moves to the end and stays capital, giving `ebraZ`, then `ok` and one k. `crossing` becomes `rossingc`, then `ok` and two k's.

Example 3

Input: sentence = "Otter"
Output: "Otterokk"

`Otter` begins with an uppercase vowel, so its letters stay put, and `ok` plus one k is appended.

Constraints

1 <= sentence.length <= 150
sentence consists of English letters and spaces only.
sentence has no leading or trailing space, and consecutive words are separated by a single 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 to_rook_talk(sentence: str) -> str:

Java

public String toRookTalk(String sentence)

The intended approach

Time O(L) where L is the length of the returned sentence, which is the input length plus two per word plus the triangular total of the k runs.Space O(L) for the rebuilt words and the returned sentence.

Split the sentence on single spaces and rebuild each word independently, keeping a running position that starts at one. A word whose first letter is one of the ten vowel characters keeps its letters as they are; any other word is rebuilt as everything after its first letter followed by that letter. Then `ok` and a run of k's as long as the word's position are appended, and the rebuilt words are joined back with single spaces.

Pythonentry point: to_rook_talk

def to_rook_talk(sentence):
    # O(L) where L is the length of the returned sentence: each word is rebuilt
    # once and its run of trailing k's is as long as its position.
    vowels = "aeiouAEIOU"
    pieces = []
    for position, word in enumerate(sentence.split(" "), start=1):
        core = word if word[0] in vowels else word[1:] + word[0]
        pieces.append(core + "ok" + "k" * position)
    return " ".join(pieces)

The obvious version

Scan the sentence character by character to cut it into words without using any string splitting, rebuild each word as a list of single characters with the letter moves and appends done one character at a time, and glue the pieces back together with an explicit separator.

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_to_rook_talk(sentence):
    vowels = "aeiouAEIOU"
    words = []
    current = ""
    for ch in sentence:
        if ch == " ":
            words.append(current)
            current = ""
        else:
            current += ch
    words.append(current)

    result = ""
    position = 0
    for word in words:
        position += 1
        letters = list(word)
        if letters[0] not in vowels:
            head = letters.pop(0)
            letters.append(head)
        letters.append("o")
        letters.append("k")
        for _ in range(position):
            letters.append("k")
        if result:
            result += " "
        result += "".join(letters)
    return result

How this problem was checked

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