Codestin Search App

Text Justification - Problem

Ever wondered how word processors like Microsoft Word or Google Docs create those perfectly aligned paragraphs? Welcome to the world of text justification!

Given an array of words and a maximum line width maxWidth, your task is to format the text so that each line has exactly maxWidth characters and is fully justified (aligned on both left and right sides).

Key Rules:

Greedy packing: Fit as many words as possible on each line
Even space distribution: Extra spaces between words should be distributed as evenly as possible
Left bias: If spaces don't divide evenly, give extra spaces to the left gaps first
Special last line: The final line should be left-justified only (no extra spaces between words)

Example: words = ["This", "is", "an", "example"], maxWidth = 16
Output: ["This is an", "example "]

Input & Output

example_1.py — Basic Justification

$ 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 + 2 gaps = need 8 extra spaces, distributed as 4+4. Line 2: "example", "of", "text" need 3 extra spaces distributed as 2+1. Line 3: Last line is left-justified.

example_2.py — Single Word Line

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

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

💡 Note: "acknowledgment" takes up a full line by itself (14 chars + 2 padding spaces). Other lines are justified normally.

example_3.py — Edge Case

$ Input: words = ["Science","is","what","we","understand","well","enough","to","explain","to","a","computer."], maxWidth = 20

› Output: ["Science is what we","understand well","enough to explain to","a computer. "]

💡 Note: Multiple lines with different space distributions. Last line is left-justified with 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

Understanding the Visualization

Greedy Packing

Pack as many words as possible in each line, like fitting books on a shelf

Space Calculation

Calculate how much extra space needs to be distributed

Even Distribution

Distribute spaces evenly, with extras going to the left gaps first

Last Line Special Case

Left-justify the final line only, like the last partially filled shelf

Key Takeaway

🎯 Key Insight: Text justification is just math - divide extra spaces by gaps, distribute remainder to leftmost gaps first!

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 Ai Adobe 18

The optimal approach uses a greedy line-packing strategy combined with mathematical space distribution. Key insights: (1) Pack words greedily into each line, (2) Use division and modulo to distribute extra spaces evenly, (3) Handle the last line as a special case with left-justification only. Time complexity: O(n×m) where n is the number of words and m is average word length.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n * m)	O(k * maxWidth)	Process each line by fitting words greedily, then distribute spaces evenly

Simulation Approach — Algorithm Steps

Start with an empty current line and process words one by one
For each word, check if it fits in the current line (including minimum spaces)
If it fits, add it to current line; if not, justify the current line and start a new one
To justify a line: calculate total extra spaces and distribute evenly between word gaps
Handle the last line specially by left-justifying it

Visualization

Tap to expand

Step-by-Step Walkthrough

Pack Words Greedily

Add words to current line until no more fit

Calculate Spaces

Determine how many extra spaces to distribute

Distribute Evenly

Add extra spaces to gaps, starting from the left

Handle Last Line

Left-justify the final line only

Code -

solution.c — C

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

char* justifyLine(char** words, int wordCount, int maxWidth, int isLastLine) {
    char* result = (char*)malloc((maxWidth + 1) * sizeof(char));
    memset(result, ' ', maxWidth);
    result[maxWidth] = '\0';
    
    if (wordCount == 1 || isLastLine) {
        int pos = 0;
        for (int i = 0; i < wordCount; i++) {
            int len = strlen(words[i]);
            memcpy(result + pos, words[i], len);
            pos += len;
            if (i < wordCount - 1) {
                result[pos++] = ' ';
            }
        }
        return result;
    }
    
    int totalWordLength = 0;
    for (int i = 0; i < wordCount; i++) {
        totalWordLength += strlen(words[i]);
    }
    
    int totalSpaces = maxWidth - totalWordLength;
    int gaps = wordCount - 1;
    int spacesPerGap = totalSpaces / gaps;
    int extraSpaces = totalSpaces % gaps;
    
    int pos = 0;
    for (int i = 0; i < wordCount; i++) {
        int len = strlen(words[i]);
        memcpy(result + pos, words[i], len);
        pos += len;
        
        if (i < gaps) {
            int spaces = spacesPerGap + (i < extraSpaces ? 1 : 0);
            pos += spaces;
        }
    }
    
    return result;
}

char** fullJustify(char** words, int wordCount, int maxWidth, int* returnSize) {
    char** result = (char**)malloc(wordCount * sizeof(char*));
    *returnSize = 0;
    
    char** currentLine = (char**)malloc(wordCount * sizeof(char*));
    int currentLineSize = 0;
    int currentLength = 0;
    
    for (int i = 0; i < wordCount; i++) {
        int wordLen = strlen(words[i]);
        if (currentLength + wordLen + currentLineSize > maxWidth) {
            result[(*returnSize)++] = justifyLine(currentLine, currentLineSize, maxWidth, 0);
            currentLine[0] = words[i];
            currentLineSize = 1;
            currentLength = wordLen;
        } else {
            currentLine[currentLineSize++] = words[i];
            currentLength += wordLen;
        }
    }
    
    if (currentLineSize > 0) {
        result[(*returnSize)++] = justifyLine(currentLine, currentLineSize, maxWidth, 1);
    }
    
    free(currentLine);
    return result;
}

int main() {
    char** words = (char**)malloc(100 * sizeof(char*));
    int wordCount = 0;
    int maxWidth;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " \n");
    while (token != NULL) {
        words[wordCount] = (char*)malloc((strlen(token) + 1) * sizeof(char));
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, " \n");
    }
    
    scanf("%d", &maxWidth);
    
    int returnSize;
    char** result = fullJustify(words, wordCount, maxWidth, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%s\n", result[i]);
        free(result[i]);
    }
    
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    free(words);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is number of words and m is average word length. We process each word once and potentially concatenate strings multiple times.

✓ Linear Growth

Space Complexity

O(k * maxWidth)

Where k is the number of lines in output. Each line takes O(maxWidth) space.

✓ Linear Space

28.4K Views

Medium Frequency

~25 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler