Reverse Words vs Reverse Characters

Split the string on whitespace, reverse the list of pieces, and join them back with single spaces. Python's split with no argument handles runs of whitespace and ignores leading and trailing spaces, so you do not need to strip or normalise the input yourself.

def reverse_words(text):
    return " ".join(text.split()[::-1])

print(reverse_words("the sky is blue"))
print(reverse_words("  hello   world  "))

The outputs are blue is sky the and world hello. The second call shows the whitespace handling: the extra spaces at both ends and the run of spaces in the middle are all removed, and the result uses single spaces between words.

The mechanism is that split produces a list of words, reversing that list is a constant-time pointer operation on the list, and join reassembles the string. The whole thing is linear in the length of the input, because splitting and joining each touch every character once.

The trade-off to name is that split collapses all whitespace, which changes the output when the input had meaningful spacing. If you need to preserve the original separators exactly, you have to walk the string and reverse the order of the word spans while keeping the separators where they are, which is more work. You also lose information about trailing spaces. Most interview versions of this question specify single spaces between words, and saying that you are assuming that is the right move.

Split the string into words, reverse each word with a slice of minus one, and join them back in the original order. The key difference from reversing the word order is that the list of words is never reversed, only the contents of each word.

def reverse_each_word(text):
    return " ".join(word[::-1] for word in text.split())

print(reverse_each_word("the sky is blue"))
print(reverse_each_word("hello world"))

The outputs are eht sy si eulb and olleh dlrow. The word order is preserved while every word reads backwards.

The mechanism is a generator expression that transforms each piece of the split list before the join. The split and the join are still linear, and each word reversal is linear in the length of that word, so the total is linear in the length of the string.

The trade-off to name is the intermediate list. Splitting allocates a list of words and joining allocates the final string, so the peak memory is proportional to the input size. If the input is enormous and you only need to stream the result, you would process the words one at a time and write them out as they arrive, keeping the memory use bounded by the longest word rather than by the whole string.

There is also a puzzle variant worth recognising: if every word must be reversed and the word order reversed at the same time, you can do it in one pass by reversing the whole character string and then reversing each word back, which turns an O of n squared implementation into a linear one. Mentioning that trick shows you understand where the cost lives.