Reverse Words in a String III

Reverse Words in a String III - Problem

Word Reversal Challenge: Given a string s containing multiple words separated by spaces, your task is to reverse the characters within each individual word while keeping the words in their original positions and preserving all whitespace.

Think of it as flipping each word like a pancake - the word order stays the same, but each word gets flipped individually. For example, "Hello World" becomes "olleH dlroW".

Goal: Transform each word by reversing its character order
Input: A string with words separated by single spaces
Output: The same string with each word's characters reversed

Input & Output

example_1.py — Basic word reversal

$ Input: s = "Let's take LeetCode contest"

› Output: "s'teL ekat edoCteeL tsetnoc"

💡 Note: Each word is reversed individually: 'Let's' becomes 's'teL', 'take' becomes 'ekat', 'LeetCode' becomes 'edoCteeL', and 'contest' becomes 'tsetnoc'. The spaces between words are preserved.

example_2.py — Single word

$ Input: s = "God"

› Output: "doG"

💡 Note: With only one word, we simply reverse its characters: 'G' and 'd' swap positions while 'o' stays in the middle, resulting in 'doG'.

example_3.py — Mixed length words

$ Input: s = "I love programming"

› Output: "I evol gnimmargor"

💡 Note: Single character 'I' remains unchanged, 'love' becomes 'evol', and 'programming' becomes 'gnimmargor'. Each word boundary is preserved by the spaces.

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s contains printable ASCII characters
s does not contain any leading or trailing spaces
There is at least one word in s
All the words in s are separated by a single space

Visualization

Tap to expand

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 Apple 6

The optimal solution uses the two pointers technique to reverse each word in-place. By converting the string to a character array and using left/right pointers for each word, we achieve O(n) time complexity with O(1) extra space. This approach avoids the overhead of string concatenation and temporary object creation, making it both time and space efficient.

Common Approaches

✓ Brute Force (String Building)

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

This approach splits the string into words, then for each word creates a reversed version by building a new string character by character from right to left. Finally, it joins all reversed words back with spaces.

Two Pointers (Optimal)

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

This approach converts the string to a mutable character array, then uses two pointers for each word - one starting from the beginning and one from the end. The pointers swap characters and move toward each other until they meet, effectively reversing each word in-place.

Brute Force (String Building) — Algorithm Steps

Split the input string into individual words using space as delimiter
For each word, create a new reversed string by concatenating characters from end to beginning
Store each reversed word in a result array
Join all reversed words back together with spaces

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Input

Split 'Let's take LeetCode contest' into individual words

Reverse Each Word

Build reversed strings: 'Let's' → 's'teL', 'take' → 'ekat'

Join Result

Combine reversed words back with spaces

Code -

solution.c — C

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

char* reverseWords(char* s) {
    int len = strlen(s);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    strcpy(result, s);
    
    int start = 0;
    for (int i = 0; i <= len; i++) {
        if (result[i] == ' ' || result[i] == '\0') {
            int end = i - 1;
            while (start < end) {
                char temp = result[start];
                result[start] = result[end];
                result[end] = temp;
                start++;
                end--;
            }
            start = i + 1;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, string concatenation creates new strings each time, leading to O(n²) time where n is total length

✓ Linear Growth

Space Complexity

O(n)

Extra space needed for split array and temporary strings during concatenation

✓ Linear Space

85.0K Views

Medium Frequency

~15 min Avg. Time

3.2K 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 (String Building) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler