Rearrange Words in a Sentence - Practice Coding Problems

Rearrange Words in a Sentence - Problem

String Sorting Medium

You are given a sentence containing multiple words separated by single spaces, where the first letter is capitalized. Your task is to rearrange the words by their length in ascending order.

Rules:

Words should be arranged from shortest to longest
If two words have the same length, maintain their original relative order (stable sort)
The result should have the first letter capitalized and all other letters lowercase

Example: "Leetcode makes me happy" becomes "Me makes happy leetcode" because:

"me" (length 2) comes first
"makes" and "happy" (both length 5) maintain their original order
"leetcode" (length 8) comes last

Input & Output

example_1.py — Basic Example

$ Input: "Leetcode makes me happy"

› Output: "Me makes happy leetcode"

💡 Note: Words sorted by length: "me"(2), "makes"(5), "happy"(5), "leetcode"(8). Words with same length ("makes" and "happy") maintain their original order.

example_2.py — Same Length Words

$ Input: "Keep calm and carry on"

› Output: "On and keep calm carry"

💡 Note: Sorted by length: "on"(2), "and"(3), "keep"(4), "calm"(4), "carry"(5). Same-length words "keep" and "calm" maintain their original relative positions.

example_3.py — Single Word

$ Input: "To"

› Output: "To"

💡 Note: Edge case with only one word - return the same word with proper capitalization.

Constraints

text begins with a capital letter and then contains lowercase letters
1 ≤ text.length ≤ 10⁵
All the words in text are separated by a single space
Important: Words of the same length must maintain their original relative order

Visualization

Tap to expand

Understanding the Visualization

Split and Normalize

Break sentence into words and make first word lowercase

Create Index Pairs

Track each word with its original position to maintain stability

Stable Sort

Sort by word length first, then by original index for ties

Reconstruct

Join sorted words and capitalize the first letter

Key Takeaway

🎯 Key Insight: Use stable sort with word length as primary key and original index as secondary key to maintain relative order of same-length words while sorting by length.

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 Apple 15

The optimal solution uses a stable sorting algorithm with a custom comparator that sorts words by length while preserving the original order of same-length words. The key insight is to track original indices and use them as a secondary sort key. Time complexity is O(n log n) where n is the number of words.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Bubble Sort)	O(n²)	O(1)	Compare adjacent words and swap if needed, repeat until sorted
Stable Sort with Custom Comparator	O(n log n)	O(n)	Use built-in stable sort with custom comparison function

Brute Force (Bubble Sort) — Algorithm Steps

Split sentence into words and convert to lowercase
Use nested loops to compare adjacent words
Swap words if left word is longer than right word
Repeat until no more swaps needed
Join words and capitalize first letter

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Split sentence into words: ["Leetcode", "makes", "me", "happy"]

First Pass

Compare adjacent pairs, swap if left word is longer

Continue Passes

Repeat until no more swaps needed

Final Result

Words sorted by length: ["me", "makes", "happy", "leetcode"]

Code -

solution.c — C

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

char* arrangeWords(char* text) {
    char* result = malloc(strlen(text) + 1);
    strcpy(result, text);
    
    char words[1000][101];
    int count = 0;
    
    char* token = strtok(result, " ");
    while (token) {
        strcpy(words[count], token);
        if (count == 0) words[0][0] = tolower(words[0][0]);
        count++;
        token = strtok(NULL, " ");
    }
    
    // Bubble sort
    for (int i = 0; i < count; i++) {
        for (int j = 0; j < count - i - 1; j++) {
            if (strlen(words[j]) > strlen(words[j + 1])) {
                char temp[101];
                strcpy(temp, words[j]);
                strcpy(words[j], words[j + 1]);
                strcpy(words[j + 1], temp);
            }
        }
    }
    
    words[0][0] = toupper(words[0][0]);
    
    strcpy(result, words[0]);
    for (int i = 1; i < count; i++) {
        strcat(result, " ");
        strcat(result, words[i]);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops with n words, each comparison takes O(1) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for swapping

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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 (Bubble Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler