Rearrange Spaces Between Words - Practice Coding Problems

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 goes at end

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

Understanding the Visualization

Input Analysis

Identify words and count total spaces in the string

Space Distribution

Calculate spaces per gap and handle remainder

Output Construction

Rebuild string with evenly distributed spaces

Key Takeaway

🎯 Key Insight: Extract words, count total spaces, then redistribute evenly with remainder at the end

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

Approach	Time	Space	Notes
✓ Brute Force - Character by Character Processing	O(n)	O(n)	Process each character individually to identify words and spaces
Optimized - Built-in String Functions	O(n)	O(n)	Use built-in split function to extract words and count spaces efficiently

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Character by Character Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler