Codestin Search App

Rearrange Spaces Between Words - Problem

String Easy

You're working with a messy text string that contains words separated by various numbers of spaces. Your task is to redistribute the spaces evenly between all words to create a clean, uniformly formatted string.

The Challenge: Given a string with words and spaces, rearrange the spaces so that there's an equal number of spaces between every pair of adjacent words, and this number should be maximized. If you can't distribute all spaces equally, place any leftover spaces at the end.

Example: " this is a sentence " becomes "this is a sentence"

Goal: Return a string of the same length where spaces are optimally redistributed between words.

Input & Output

example_1.py — Basic Case

$ Input: text = " this is a sentence "

› Output: "this is a sentence"

💡 Note: There are 9 total spaces and 3 gaps between 4 words. 9 ÷ 3 = 3 spaces per gap with 0 remainder, so each gap gets exactly 3 spaces.

example_2.py — Remainder Spaces

$ Input: text = " practice makes perfect"

› Output: "practice makes perfect "

💡 Note: There are 7 spaces and 2 gaps. 7 ÷ 2 = 3 spaces per gap with 1 remainder. Each gap gets 3 spaces, and the 1 extra space goes at the end.

example_3.py — Single Word

$ Input: text = " hello "

› Output: "hello "

💡 Note: With only one word, there are no gaps between words, so all 4 spaces are placed at the end after the single word.

Constraints

1 ≤ text.length ≤ 100
text consists of lowercase English letters and spaces ' '
text contains at least one word
Words are separated by at least one space

Visualization

Tap to expand

Understanding the Visualization

Inventory

Count total bookends (spaces) and identify all books (words)

Calculate

Determine optimal spacing: total_bookends ÷ (books - 1)

Distribute

Place books with calculated spacing, put extra bookends at the end

Key Takeaway

🎯 Key Insight: The problem is essentially a division problem - distribute total spaces evenly across gaps, with remainder going to the end

Asked in

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

The optimal solution uses built-in string methods to count spaces and split words, then calculates optimal spacing using division and modulo operations. Key insight: distribute spaces evenly across (n-1) gaps between n words, placing any remainder at the end.

Common Approaches

Approach	Time	Space	Notes
✓ String Splitting Approach (Optimal)	O(n)	O(n)	Use built-in string splitting to extract words efficiently in one pass

String Splitting Approach (Optimal) — Algorithm Steps

Count total spaces by iterating through characters
Split string into words using built-in split method
Handle edge case of single word
Calculate spaces per gap and remainder spaces
Join words with calculated spacing and add remainder at end

Visualization

Tap to expand

Step-by-Step Walkthrough

Count & Split

Count spaces and split string into words simultaneously

Calculate Distribution

Determine spaces per gap and remainder

Join & Append

Join words with spacing and add remainder

Code -

solution.c — C

char* rearrangeSpaces(char* text) {
    int len = strlen(text);
    int spaceCount = 0;
    
    // Count spaces
    for (int i = 0; i < len; i++) {
        if (text[i] == ' ') spaceCount++;
    }
    
    // Extract words
    char* textCopy = malloc((len + 1) * sizeof(char));
    strcpy(textCopy, text);
    
    char* words[1000];
    int wordCount = 0;
    char* token = strtok(textCopy, " ");
    while (token != NULL) {
        words[wordCount++] = token;
        token = strtok(NULL, " ");
    }
    
    char* result = malloc((len + 1) * sizeof(char));
    result[0] = '\0';
    
    // Handle single word case
    if (wordCount == 1) {
        strcpy(result, words[0]);
        for (int i = 0; i < spaceCount; i++) {
            strcat(result, " ");
        }
        return result;
    }
    
    // Calculate spacing
    int gaps = wordCount - 1;
    int spacesPerGap = spaceCount / gaps;
    int extraSpaces = spaceCount % gaps;
    
    // Build result
    for (int i = 0; i < wordCount; i++) {
        strcat(result, words[i]);
        if (i < wordCount - 1) {
            for (int j = 0; j < spacesPerGap; j++) {
                strcat(result, " ");
            }
        }
    }
    for (int i = 0; i < extraSpaces; i++) {
        strcat(result, " ");
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count spaces plus O(n) for split operation

✓ Linear Growth

Space Complexity

O(n)

Space for storing words array and result string

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~8 min Avg. Time

842 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

String Splitting Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler