Reverse Words in a String - Practice Coding Problems

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

Understanding the Visualization

Input

String with words separated by irregular spaces

Process

Extract words and reverse their order

Output

Words in reverse order with single spaces

Key Takeaway

🎯 Key Insight: Split by whitespace to handle irregular spacing, reverse word array, then join with single spaces

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

Approach	Time	Space	Notes
✓ Optimized - Built-in Split and Join	O(n)	O(n)	Use language built-in functions to split, filter, reverse and join
Brute Force - Character by Character	O(n)	O(n)	Process each character manually to extract words and reverse
Two Pointers - In-Place Reversal	O(n)	O(n)	Convert to char array, reverse entire string, then reverse each word

Optimized - Built-in Split and Join — Algorithm Steps

Split string by whitespace
Filter empty strings
Reverse word order
Join with single space

Visualization

Tap to expand

Step-by-Step Walkthrough

Split & Filter

Split by whitespace, auto-filter empty strings

Reverse Array

Reverse the word array

Join

Join with single spaces

Code -

solution.c — C

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

char* solution(char* s) {
    char* words[1000];
    int wordCount = 0;
    
    // Parse words manually
    char* token = strtok(s, " \t\n");
    while (token != NULL && wordCount < 1000) {
        words[wordCount] = (char*)malloc((strlen(token) + 1) * sizeof(char));
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, " \t\n");
    }
    
    // Calculate result length
    int totalLen = 0;
    for (int i = 0; i < wordCount; i++) {
        totalLen += strlen(words[i]);
        if (i > 0) totalLen++; // space
    }
    
    char* result = (char*)malloc((totalLen + 1) * sizeof(char));
    result[0] = '\0';
    
    // Build result in reverse order
    for (int i = wordCount - 1; i >= 0; i--) {
        strcat(result, words[i]);
        if (i > 0) strcat(result, " ");
        free(words[i]);
    }
    
    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)

Split operation scans string once O(n), reverse is O(w) where w is number of words, join is O(n)

✓ Linear Growth

Space Complexity

O(n)

Array to store words plus final 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

Optimized - Built-in Split and Join — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler