Reverse Words in a String

Reverse Words in a String - Problem

Given an input string s, reverse the order of the words.

A word is defined as a sequence of non-space characters. The words in s will be separated by at least one space.

Return a string of the words in reverse order concatenated by a single space.

Note: s may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.

Input & Output

Example 1 — Basic Case with Extra Spaces

$ Input: s = "the sky is blue"

› Output: "blue is sky the"

💡 Note: Words are ["the", "sky", "is", "blue"], reversed gives ["blue", "is", "sky", "the"], joined with spaces: "blue is sky the"

Example 2 — Leading and Trailing Spaces

$ Input: s = " hello world "

› Output: "world hello"

💡 Note: After trimming spaces, words are ["hello", "world"], reversed gives ["world", "hello"], result: "world hello"

Example 3 — Multiple Spaces Between Words

$ Input: s = "a good example"

› Output: "example good a"

💡 Note: Multiple spaces are treated as single delimiters, words ["a", "good", "example"] become ["example", "good", "a"]

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

Visualization

Tap to expand

Asked in

M Microsoft 45 a Amazon 38 G Google 32 🍎 Apple 28

The key insight is to extract words by splitting on whitespace (handling multiple spaces), then reverse the word order and join with single spaces. The optimized approach uses built-in string functions for clean, readable code. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Character by Character

⏱️ Time: O(n) Space: O(n)

Iterate through the string character by character, manually building words and storing them. Then reverse the word list and join with single spaces.

Optimized - Built-in Split and Join

⏱️ Time: O(n) Space: O(n)

Leverage built-in string methods to split by spaces (automatically handling multiple spaces), filter out empty strings, reverse the word list, and join with single spaces.

Two Pointers - In-Place Reversal

⏱️ Time: O(n) Space: O(n)

First reverse the entire string, then use two pointers to identify and reverse each individual word back to correct spelling while maintaining reversed word order.

Brute Force - Character by Character — Algorithm Steps

Iterate through each character
Build words by collecting non-space characters
Store words in a list
Reverse the list and join with spaces

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Scan

Iterate through each character

Word Building

Collect non-space characters into words

Reverse & Join

Reverse word order and join with spaces

Code -

solution.c — C

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

char* solution(char* s) {
    int len = strlen(s);
    char** words = (char**)malloc(1000 * sizeof(char*));
    int wordCount = 0;
    
    char* currentWord = (char*)malloc(1000 * sizeof(char));
    int wordLen = 0;
    
    for (int i = 0; i < len; i++) {
        if (s[i] != ' ') {
            currentWord[wordLen++] = s[i];
        } else {
            if (wordLen > 0) {
                currentWord[wordLen] = '\0';
                words[wordCount] = (char*)malloc((wordLen + 1) * sizeof(char));
                strcpy(words[wordCount], currentWord);
                wordCount++;
                wordLen = 0;
            }
        }
    }
    
    if (wordLen > 0) {
        currentWord[wordLen] = '\0';
        words[wordCount] = (char*)malloc((wordLen + 1) * sizeof(char));
        strcpy(words[wordCount], currentWord);
        wordCount++;
    }
    
    // Build result in reverse order
    char* result = (char*)malloc(10000 * sizeof(char));
    result[0] = '\0';
    
    for (int i = wordCount - 1; i >= 0; i--) {
        strcat(result, words[i]);
        if (i > 0) strcat(result, " ");
        free(words[i]);
    }
    
    free(words);
    free(currentWord);
    return result;
}

int main() {
    char s[10000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to build words, plus O(n) to join

✓ Linear Growth

Space Complexity

O(n)

Store all words in a list, plus result string

⚡ Linearithmic Space

125.0K Views

High Frequency

~15 min Avg. Time

3.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Character by Character — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler