Reverse Words in a String II - Practice Coding Problems

Reverse Words in a String II - Problem

You're given a character array representing a sentence, and your task is to reverse the order of the words while keeping each word intact.

For example, if you have the sentence "the sky is blue", you need to transform it to "blue is sky the".

Key constraints:

A word is defined as a sequence of non-space characters
Words are separated by exactly one space
You must solve this in-place without allocating extra space
The input is guaranteed to not have leading or trailing spaces

This problem tests your ability to manipulate strings efficiently using two-pointers technique and understanding of in-place array operations.

Input & Output

example_1.py — Basic Word Reversal

$ Input: s = ['t','h','e',' ','s','k','y',' ','i','s',' ','b','l','u','e']

› Output: ['b','l','u','e',' ','i','s',' ','s','k','y',' ','t','h','e']

💡 Note: The words are reversed in order: 'the sky is blue' becomes 'blue is sky the', but each individual word maintains its internal character order.

example_2.py — Two Words

$ Input: s = ['a',' ','g','o','o','d',' ','e','x','a','m','p','l','e']

› Output: ['e','x','a','m','p','l','e',' ','g','o','o','d',' ','a']

💡 Note: Three words 'a good example' become 'example good a'. Notice how single characters and longer words are handled the same way.

example_3.py — Single Word

$ Input: s = ['h','e','l','l','o']

› Output: ['h','e','l','l','o']

💡 Note: With only one word and no spaces, the array remains unchanged since there's only one word to reverse the order of.

Constraints

1 ≤ s.length ≤ 10⁴
s[i] is an English letter (lowercase or uppercase) or space ' '
There is at least one word in s
s does not contain leading or trailing spaces
All words are separated by exactly one space

Visualization

Tap to expand

Understanding the Visualization

Initial State

We have words in original order: 'the sky is blue'

Reverse Everything

Flip the entire array: 'eulb si yks eht'

Fix Each Word

Reverse each word individually: 'blue is sky the'

Mission Accomplished

Words are now in reverse order, each properly oriented!

Key Takeaway

🎯 Key Insight: The magic happens because reversing twice (entire array, then each word) efficiently achieves word-order reversal while maintaining each word's integrity - all in O(n) time with O(1) space!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 10 f Meta 8

The optimal solution uses a two-step reversal technique: first reverse the entire character array, then reverse each individual word. This achieves O(n) time complexity with O(1) space complexity, perfectly satisfying the in-place constraint while being highly efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal In-Place)	O(n)	O(1)	Reverse entire array, then reverse each word individually using two pointers
Brute Force (Word Extraction and Reconstruction)	O(n)	O(n)	Extract words into temporary storage, then reconstruct in reverse order

Two Pointers (Optimal In-Place) — Algorithm Steps

Reverse the entire character array using two pointers from both ends
Identify word boundaries by scanning for spaces
For each word, reverse it individually using two pointers
The result is words in reverse order, each properly oriented

Visualization

Tap to expand

Step-by-Step Walkthrough

Reverse Entire Array

Use two pointers from both ends to reverse the complete array

Identify Words

Scan for spaces to find word boundaries

Reverse Each Word

Apply two-pointer reversal to each word individually

Code -

solution.c — C

void reverse(char* arr, int left, int right) {
    while (left < right) {
        char temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

void reverseWords(char* s, int sSize) {
    // Reverse entire array
    reverse(s, 0, sSize - 1);
    
    // Reverse each word
    int start = 0;
    for (int i = 0; i <= sSize; i++) {
        if (i == sSize || s[i] == ' ') {
            reverse(s, start, i - 1);
            start = i + 1;
        }
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is visited at most twice - once for full reversal, once for word reversal

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables for indices, no additional data structures

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 In-Place) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler