Sentence Screen Fitting - Practice Coding Problems

Sentence Screen Fitting - Problem

Sentence Screen Fitting - Imagine you're building a text editor that needs to display text on a fixed-size screen!

Given a screen with rows × cols dimensions and a sentence represented as an array of words, your task is to determine how many complete sentences can fit on the screen.

Rules:

Words must appear in their original order
Words cannot be split across lines
Single spaces must separate consecutive words
If a word is too long for a line, move it to the next line

Goal: Return the total number of times the complete sentence can be displayed on the screen.

Example: With sentence ["hello", "world"] and a 2×8 screen, you might fit: "hello wo" on row 1, "rld hell" on row 2, completing 1 full sentence.

Input & Output

example_1.py — Basic Case

$ Input: sentence = ["hello", "world"], rows = 2, cols = 8

› Output: 1

💡 Note: Row 1: 'hello wo' (8 chars), Row 2: 'rld hell' (8 chars). We fit 'hello world' once completely, with 'hell' starting the next sentence.

example_2.py — Multiple Sentences

$ Input: sentence = ["a", "bcd", "e"], rows = 3, cols = 6

› Output: 2

💡 Note: Row 1: 'a bcd ' (6 chars), Row 2: 'e a bc' (6 chars), Row 3: 'd e a ' (6 chars). We complete 'a bcd e' twice.

example_3.py — Word Too Long

$ Input: sentence = ["hello", "leetcode"], rows = 1, cols = 7

› Output: 0

💡 Note: The word 'leetcode' has 8 characters but each row only has 7 columns, so it cannot fit and no complete sentences are possible.

Constraints

1 ≤ rows, cols ≤ 2 × 10⁴
1 ≤ sentence.length ≤ 100
1 ≤ sentence[i].length ≤ 10
sentence[i] consists of only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Prepare Text Stream

Convert sentence into repeating character stream: 'hello world hello world...'

Fill Screen Capacity

Calculate total characters that can fit: rows × cols

Respect Word Boundaries

Adjust position to avoid breaking words across lines

Count Complete Cycles

Divide total valid characters by sentence length

Key Takeaway

🎯 Key Insight: Instead of simulating each word placement, treat the problem as filling a character buffer from an infinite text stream, then adjusting for word boundaries. This mathematical approach scales beautifully!

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a clever character counting approach. Instead of simulating word placement, we treat the sentence as an infinite repeating string and calculate how many characters can fit across all rows. The key insight is to adjust backward when we land in the middle of a word, ensuring we only count complete word boundaries. Time complexity: O(rows + sentence_length), making it highly efficient even for large screens.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized String Manipulation (Optimal)	O(rows + sentence_length)	O(sentence_length)	Pre-process sentence into continuous string and use mathematical approach
Brute Force (Word-by-Word Simulation)	O(rows × cols × sentence_length)	O(1)	Simulate placing each word individually on the screen

Optimized String Manipulation (Optimal) — Algorithm Steps

Join the sentence words with spaces and add trailing space
For each row, add the column count to total character count
Adjust backwards if we land in middle of a word (find nearest space)
Calculate complete sentences by dividing total chars by sentence length
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Full String

Join sentence: 'hello world '

Count Total Chars

Add column capacity for each row

Adjust Boundaries

Back up from middle of words to spaces

Calculate Result

Divide total chars by sentence length

Code -

solution.c — C

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

int wordsTyping(char** sentence, int sentenceSize, int rows, int cols) {
    if (sentenceSize == 0 || rows <= 0 || cols <= 0) {
        return 0;
    }
    
    // Check if any word is too long
    for (int i = 0; i < sentenceSize; i++) {
        if (strlen(sentence[i]) > cols) {
            return 0;
        }
    }
    
    // Calculate total length needed
    int totalLen = 0;
    for (int i = 0; i < sentenceSize; i++) {
        totalLen += strlen(sentence[i]);
        if (i < sentenceSize - 1) totalLen++; // space
    }
    totalLen++; // final space
    
    // Build full sentence
    char* fullSentence = malloc(totalLen + 1);
    strcpy(fullSentence, "");
    for (int i = 0; i < sentenceSize; i++) {
        strcat(fullSentence, sentence[i]);
        if (i < sentenceSize - 1) strcat(fullSentence, " ");
    }
    strcat(fullSentence, " ");
    
    int totalChars = 0;
    
    for (int row = 0; row < rows; row++) {
        totalChars += cols;
        
        while (totalChars > 0 && fullSentence[totalChars % totalLen] != ' ') {
            totalChars--;
        }
    }
    
    int result = totalChars / totalLen;
    free(fullSentence);
    return result;
}

int main() {
    char* sentence[] = {"hello", "world"};
    printf("%d\n", wordsTyping(sentence, 2, 2, 8));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(rows + sentence_length)

We iterate through rows once, with potential backtracking bounded by longest word length

✓ Linear Growth

Space Complexity

O(sentence_length)

We store the concatenated sentence string

⚡ Linearithmic Space

36.3K Views

Medium Frequency

~25 min Avg. Time

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

Optimized String Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler