Reverse Words in a String III - Practice Coding Problems

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

Understanding the Visualization

Identify the Stack

Find where each word (pancake stack) begins and ends

Position Spatulas

Place left spatula at bottom pancake, right spatula at top pancake

Flip Process

Swap pancakes at spatula positions and move spatulas toward center

Stack Complete

When spatulas meet, the stack is perfectly flipped - move to next plate

Key Takeaway

🎯 Key Insight: The two-pointer technique transforms an O(n²) string manipulation problem into an elegant O(n) solution by working directly with the character array, avoiding expensive string operations and temporary objects.

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

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers to reverse each word in-place for optimal performance
Brute Force (String Building)	O(n²)	O(n)	Split words, reverse each using string concatenation, then join back

Two Pointers (Optimal) — Algorithm Steps

Convert the string to a mutable character array
Iterate through the array to identify word boundaries (spaces)
For each word, place left pointer at start and right pointer at end
Swap characters at both pointers and move them toward center
Continue until pointers meet, then move to next word
Convert character array back to string

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Word Boundary

Scan until space or end to identify complete word

Place Pointers

Set left pointer at word start, right pointer at word end

Swap and Move

Swap characters and move pointers toward center

Next Word

Move to next word and repeat the process

Code -

solution.c — C

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

char* reverseWords(char* s) {
    int n = strlen(s);
    int start = 0;
    
    for (int i = 0; i <= n; i++) {
        // When we hit a space or end of string, reverse the current word
        if (i == n || s[i] == ' ') {
            int left = start, right = i - 1;
            
            // Two pointers approach to reverse the word
            while (left < right) {
                char temp = s[left];
                s[left] = s[right];
                s[right] = temp;
                left++;
                right--;
            }
            
            start = i + 1;
        }
    }
    
    return s;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = '\0';
    
    // Remove quotes
    int len = strlen(s);
    for (int i = 1; i < len - 1; i++) {
        s[i-1] = s[i];
    }
    s[len-2] = '\0';
    
    char* result = reverseWords(s);
    printf("\"%s\"\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character is processed exactly once

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for pointers (excluding input/output space)

✓ 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler