Text Justification

Text Justification - Problem

Given an array of strings words and a width maxWidth, format the text such that each line has exactly maxWidth characters and is fully justified (both left and right aligned).

Requirements:

Pack words in a greedy approach: pack as many words as possible in each line
Pad extra spaces when necessary so each line has exactly maxWidth characters
Distribute extra spaces as evenly as possible between words
If spaces don't divide evenly, give more spaces to left slots
The last line should be left-justified with no extra spaces between words

Each word contains only non-space characters and has length ≤ maxWidth.

Input & Output

Example 1 — Basic Multiple Lines

$ Input: words = ["This", "is", "an", "example", "of", "text", "justification."], maxWidth = 16

› Output: ["This is an", "example of text", "justification. "]

💡 Note: Line 1: "This", "is", "an" fit with 8 chars + 8 spaces = 16. Line 2: "example", "of", "text" with 11 chars + 5 spaces = 16. Line 3: Last line left-justified.

Example 2 — Single Word Line

$ Input: words = ["What", "must", "be", "acknowledgment", "shall", "be"], maxWidth = 16

› Output: ["What must be", "acknowledgment ", "shall be "]

💡 Note: "acknowledgment" alone fills 14 chars, needs 2 trailing spaces. Last line "shall be" is left-justified with trailing spaces.

Example 3 — Minimum Width

$ Input: words = ["a", "b", "c", "d", "e"], maxWidth = 3

› Output: ["a b", "c d", "e "]

💡 Note: Each line fits 2 single-letter words with 1 space between (3 chars total). Last line "e" gets 2 trailing spaces.

Constraints

1 ≤ words.length ≤ 300
1 ≤ words[i].length ≤ 20
words[i] consists of only English letters and symbols
1 ≤ maxWidth ≤ 100
words[i].length ≤ maxWidth

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 35 f Facebook 28 M Microsoft 22

The key insight is to use greedy packing for words and mathematical calculation for space distribution. Pack as many words as possible per line, then use division and modulo operations to distribute spaces evenly. Best approach is Optimized Greedy. Time: O(n × w), Space: O(n × w)

Common Approaches

✓ Brute Force Simulation

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

For each line, greedily pack words until no more fit, then calculate and distribute spaces manually by iterating through each position.

Optimized Greedy

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

Pack words greedily into lines, then use division and modulo to calculate exact space distribution without iteration.

Brute Force Simulation — Algorithm Steps

Step 1: Group words into lines by checking if adding next word exceeds maxWidth
Step 2: For each line, calculate total spaces needed and distribute evenly
Step 3: Handle last line specially with left justification only

Visualization

Tap to expand

Step-by-Step Walkthrough

Pack Words

Greedily add words until line would exceed maxWidth

Calculate Spaces

Count total spaces needed and gaps between words

Distribute

Add extra spaces evenly, favoring left gaps

Code -

solution.c — C

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

static char* words[1000];
static char* result[1000];
static char* currentLine[1000];

char** solution(char** words, int wordsSize, int maxWidth, int* returnSize) {
    *returnSize = 0;
    int i = 0;
    
    while (i < wordsSize) {
        // Greedily pack words into current line
        int lineSize = 0;
        currentLine[lineSize++] = words[i];
        int currentLength = strlen(words[i]);
        i++;
        
        // Try to add more words to current line
        while (i < wordsSize) {
            // Check if we can add the next word (with at least 1 space)
            if (currentLength + 1 + strlen(words[i]) <= maxWidth) {
                currentLine[lineSize++] = words[i];
                currentLength += 1 + strlen(words[i]); // +1 for space
                i++;
            } else {
                break;
            }
        }
        
        // Justify current line
        char* line = (char*)malloc((maxWidth + 1) * sizeof(char));
        int pos = 0;
        
        if (i == wordsSize) { // Last line - left justify
            for (int j = 0; j < lineSize; j++) {
                strcpy(line + pos, currentLine[j]);
                pos += strlen(currentLine[j]);
                if (j < lineSize - 1) {
                    line[pos++] = ' ';
                }
            }
            while (pos < maxWidth) {
                line[pos++] = ' ';
            }
        } else {
            if (lineSize == 1) { // Single word line
                strcpy(line, currentLine[0]);
                pos = strlen(currentLine[0]);
                while (pos < maxWidth) {
                    line[pos++] = ' ';
                }
            } else {
                // Calculate spaces to distribute
                int totalChars = 0;
                for (int j = 0; j < lineSize; j++) {
                    totalChars += strlen(currentLine[j]);
                }
                int totalSpaces = maxWidth - totalChars;
                int gaps = lineSize - 1;
                int spacesPerGap = totalSpaces / gaps;
                int extraSpaces = totalSpaces % gaps;
                
                for (int j = 0; j < lineSize; j++) {
                    strcpy(line + pos, currentLine[j]);
                    pos += strlen(currentLine[j]);
                    if (j < lineSize - 1) { // Not the last word
                        for (int k = 0; k < spacesPerGap; k++) {
                            line[pos++] = ' ';
                        }
                        if (j < extraSpaces) { // Add extra space to left gaps
                            line[pos++] = ' ';
                        }
                    }
                }
            }
        }
        
        line[maxWidth] = '\0';
        result[(*returnSize)++] = line;
    }
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse JSON array
    int wordsSize = 0;
    
    // Find start of array
    char* p = strchr(input, '[');
    if (p) p++;
    
    while (p && *p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\r') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Found start of string
        if (*p == '"') {
            p++; // Skip opening quote
            char* start = p;
            
            // Find closing quote
            while (*p && *p != '"') p++;
            
            if (*p == '"') {
                int len = p - start;
                words[wordsSize] = (char*)malloc(len + 1);
                strncpy(words[wordsSize], start, len);
                words[wordsSize][len] = '\0';
                wordsSize++;
                p++; // Skip closing quote
            }
        } else {
            p++;
        }
    }
    
    int maxWidth;
    scanf("%d", &maxWidth);
    
    int returnSize;
    char** res = solution(words, wordsSize, maxWidth, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", res[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    for (int i = 0; i < returnSize; i++) {
        free(res[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × w)

n words processed, w average characters per line for space distribution

✓ Linear Growth

Space Complexity

O(n × w)

Store all justified lines, each up to maxWidth characters

⚡ Linearithmic Space

285.0K Views

Medium Frequency

~25 min Avg. Time

1.8K 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler