Rearrange Spaces Between Words

Rearrange Spaces Between Words - Problem

String Easy

You are given a string text of words that are placed among some number of spaces. Each word consists of one or more lowercase English letters and are separated by at least one space. It's guaranteed that text contains at least one word.

Rearrange the spaces so that there is an equal number of spaces between every pair of adjacent words and that number is maximized. If you cannot redistribute all the spaces equally, place the extra spaces at the end, meaning the returned string should be the same length as text.

Return the string after rearranging the spaces.

Input & Output

Example 1 — Multiple Words with Extra Spaces

$ Input: text = " this is a sentence "

› Output: "this is a sentence"

💡 Note: 9 total spaces distributed among 3 gaps = 3 spaces per gap with 0 remainder

Example 2 — Uneven Distribution

$ Input: text = " hello world "

› Output: "hello world"

💡 Note: 5 total spaces with 1 gap = 5 spaces between words, no remainder

Example 3 — Single Word

$ Input: text = " hello "

› Output: "hello "

💡 Note: Single word case: all 4 spaces go at the end after the word

Constraints

1 ≤ text.length ≤ 100
text consists of lowercase English letters and spaces ' '
text contains at least one word

Visualization

Tap to expand

Asked in

F Facebook 15 M Microsoft 12

The key insight is to extract words using split, count total spaces, then distribute them evenly between word gaps with remainder at the end. The optimized approach uses built-in string functions for efficiency. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Character by Character Processing

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

Iterate through each character to manually identify words and count spaces, then rebuild the string character by character with proper spacing distribution.

Optimized - Built-in String Functions

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

Leverage the language's built-in string splitting functionality to extract words in one operation, then count total spaces and redistribute them optimally.

Brute Force - Character by Character Processing — Algorithm Steps

Step 1: Iterate through each character to find words and count spaces
Step 2: Calculate spaces per gap and remainder spaces
Step 3: Rebuild string character by character with distributed spacing

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Characters

Process each character to identify words and count spaces

Calculate Distribution

Determine spaces per gap and remainder

Rebuild String

Construct result with evenly distributed spaces

Code -

solution.c — C

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

char* solution(char* text) {
    int len = strlen(text);
    char** words = malloc(1000 * sizeof(char*));
    int wordCount = 0;
    int spaces = 0;
    
    // Count spaces and extract words
    char* word = malloc(1000);
    int wordPos = 0;
    
    for (int i = 0; i < len; i++) {
        if (text[i] == ' ') {
            if (wordPos > 0) {
                word[wordPos] = '\0';
                words[wordCount] = malloc(strlen(word) + 1);
                strcpy(words[wordCount], word);
                wordCount++;
                wordPos = 0;
            }
            spaces++;
        } else {
            word[wordPos++] = text[i];
        }
    }
    
    if (wordPos > 0) {
        word[wordPos] = '\0';
        words[wordCount] = malloc(strlen(word) + 1);
        strcpy(words[wordCount], word);
        wordCount++;
    }
    
    char* result = malloc(len + 1);
    result[0] = '\0';
    
    // Handle single word case
    if (wordCount == 1) {
        strcat(result, words[0]);
        for (int i = 0; i < spaces; i++) {
            strcat(result, " ");
        }
        return result;
    }
    
    // Calculate distribution
    int gaps = wordCount - 1;
    int spacesPerGap = spaces / gaps;
    int extraSpaces = spaces % gaps;
    
    // Build result
    for (int i = 0; i < wordCount; i++) {
        strcat(result, words[i]);
        if (i < gaps) {
            for (int j = 0; j < spacesPerGap; j++) {
                strcat(result, " ");
            }
        }
    }
    
    // Add extra spaces at the end
    for (int i = 0; i < extraSpaces; i++) {
        strcat(result, " ");
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string of length n, plus rebuilding

✓ Linear Growth

Space Complexity

O(n)

Store result string and temporary character arrays

⚡ Linearithmic Space

28.0K 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

Algorithm Visualization

Pinch to zoom • Tap outside to close

Test Cases

0 passed

0 failed

3 pending

Select Compiler

Choose a programming language

Compiler list would appear here...

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Character by Character Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler