Reverse Words in a String - Practice Coding Problems

Reverse Words in a String - Problem

Imagine you're a text editor developer tasked with implementing a "reverse word order" feature. Given an input string s, you need to reverse the order of the words while cleaning up the formatting.

What constitutes a word? A word is any sequence of non-space characters. Words are separated by one or more spaces.

The Challenge:

Reverse the order of words (last word becomes first)
Remove extra spaces (leading, trailing, and multiple spaces between words)
Return a clean string with single spaces between words

Example: " hello world " becomes "world hello"

Input & Output

example_1.py — Basic Case

$ Input: "the sky is blue"

› Output: "blue is sky the"

💡 Note: Simple case with single spaces between words. The order is reversed: 'the' becomes last, 'blue' becomes first.

example_2.py — Extra Spaces

$ Input: " hello world "

› Output: "world hello"

💡 Note: Leading and trailing spaces are removed, and the word order is reversed. Only single spaces remain between words.

example_3.py — Multiple Spaces

$ Input: "a good example"

› Output: "example good a"

💡 Note: Multiple consecutive spaces between words are collapsed to single spaces, and word order is reversed.

Visualization

Tap to expand

Understanding the Visualization

Identify Books

Scan the shelf and identify where each book (word) is located

Skip Empty Spaces

Ignore gaps and extra spaces between books

Collect in Reverse

Starting from the right, collect books one by one

Place with Proper Spacing

Arrange collected books with exactly one space between each

Key Takeaway

🎯 Key Insight: Whether using split/reverse or two-pointers, the key is to identify word boundaries while ignoring extra spaces, then arrange words in reverse order with clean formatting.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to split string, O(k) to reverse words where k is number of words, and O(n) to join back

✓ Linear Growth

Space Complexity

O(n)

Space needed for split array and result string

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁴
s contains English letters (upper-case and lower-case), digits, and spaces ' '
There is at least one word in s
Follow-up: If the string data type is mutable in your language, can you solve it in-place with O(1) extra space?

Asked in

⊞ Microsoft 45 a Amazon 38 G Google 31 f Facebook 27

The optimal approach uses either built-in split functions with reverse, or a two-pointer technique scanning right-to-left. Both achieve O(n) time complexity. The split method is simpler but uses more memory, while the two-pointer approach is more space-efficient and demonstrates better algorithmic thinking for interviews.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n)	O(n)	Split by spaces, filter empty strings, reverse, and join
Two Pointers (In-Place Simulation)	O(n)	O(n)	Manually parse words and build result by scanning from right to left

Brute Force (Multiple Passes) — Algorithm Steps

Split string by space character
Filter out empty strings from the split result
Reverse the filtered word list
Join words with single spaces

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Input string with extra spaces

Split by Spaces

Create array including empty strings

Filter Empty

Remove empty strings from array

Reverse Array

Reverse the order of words

Join Result

Combine with single spaces

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* reverseWords(char* s) {
    int n = strlen(s);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    char* words[1000];
    int wordCount = 0;
    
    // Extract words
    char* token = strtok(s, " ");
    while (token != NULL) {
        words[wordCount++] = token;
        token = strtok(NULL, " ");
    }
    
    // Build result in reverse order
    strcpy(result, "");
    for (int i = wordCount - 1; i >= 0; i--) {
        strcat(result, words[i]);
        if (i > 0) strcat(result, " ");
    }
    
    return result;
}

int main() {
    char s[10001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    
    // Remove quotes
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    
    printf("\"%s\"\n", reverseWords(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to split string, O(k) to reverse words where k is number of words, and O(n) to join back

✓ Linear Growth

Space Complexity

O(n)

Space needed for split array and result string

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁴
s contains English letters (upper-case and lower-case), digits, and spaces ' '
There is at least one word in s
Follow-up: If the string data type is mutable in your language, can you solve it in-place with O(1) extra space?

67.0K Views

High Frequency

~15 min Avg. Time

1.6K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler