Maximum Font to Fit a Sentence in a Screen - Problem

You are given a string text. We want to display text on a screen of width w and height h. You can choose any font size from array fonts, which contains the available font sizes in ascending order.

You can use the FontInfo interface to get the width and height of any character at any available font size. The FontInfo interface is defined as such:

interface FontInfo { // Returns the width of character ch on the screen using font size fontSize. O(1) per call public int getWidth(int fontSize, char ch); // Returns the height of any character on the screen using font size fontSize. O(1) per call public int getHeight(int fontSize); }

The calculated width of text for some fontSize is the sum of every getWidth(fontSize, text[i]) call for each 0 <= i < text.length (0-indexed).

The calculated height of text for some fontSize is getHeight(fontSize).

Note that text is displayed on a single line.

It is guaranteed that FontInfo will return the same value if you call getHeight or getWidth with the same parameters.

It is also guaranteed that for any font size fontSize and any character ch:

getHeight(fontSize) <= getHeight(fontSize+1)
getWidth(fontSize, ch) <= getWidth(fontSize+1, ch)

Return the maximum font size you can use to display text on the screen. If text cannot fit on the display with any font size, return -1.

Input & Output

Example 1 — Basic Case

$ Input: text = "helloworld", w = 80, h = 20, fonts = [6,8,10,12,14,16,18,24,36]

› Output: 6

💡 Note: Font size 6 is the largest that fits within width 80 and height 20 for text 'helloworld'

Example 2 — No Font Fits

$ Input: text = "leetcode", w = 10, h = 5, fonts = [10,12,14,16,18,20]

› Output: -1

💡 Note: Even the smallest font (10) is too big for the tiny screen dimensions

Example 3 — Large Screen

$ Input: text = "a", w = 1000, h = 1000, fonts = [1,2,4,8,16,32,64]

› Output: 64

💡 Note: Single character 'a' can use the largest available font size on this large screen

Constraints

1 ≤ text.length ≤ 50000
text contains only lowercase English letters
1 ≤ w ≤ 10⁷
1 ≤ h ≤ 10⁴
1 ≤ fonts.length ≤ 10⁵
1 ≤ fonts[i] ≤ 10⁵
fonts is sorted in ascending order and does not contain duplicates

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 5

The key insight is that font sizes are sorted, so we can use binary search to find the maximum font size that fits. The optimal approach uses binary search on the answer space to check font sizes efficiently. Time: O(log n × m), Space: O(1).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(log n × m) Space: O(1)

Since font sizes are sorted and larger fonts need more space, we can binary search on the font array to find the largest font size that fits within the screen dimensions.

Linear Search (Brute Force)

⏱️ Time: O(n × m) Space: O(1)

Check every font size starting from the largest, calculating the text width and height for each font size until we find one that fits within the screen dimensions.

Binary Search on Answer — Algorithm Steps

Set left = 0, right = fonts.length - 1
Binary search: check if middle font size fits
If it fits, try larger fonts (left = mid + 1)
If it doesn't fit, try smaller fonts (right = mid - 1)
Return the largest font size that worked

Visualization

Tap to expand

Step-by-Step Walkthrough

Divide

Split font range in half

Test

Check if middle font fits

Narrow

Search left or right half based on result

Code -

solution.c — C

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

typedef struct {
    int dummy;
} FontInfo;

int getWidth(FontInfo* fontInfo, int fontSize, char ch) {
    // Mock implementation - each character takes roughly 60% of fontSize in width
    // Using integer ceil equivalent: (fontSize * 6 + 9) / 10
    return (fontSize * 6 + 9) / 10;
}

int getHeight(FontInfo* fontInfo, int fontSize) {
    // Mock implementation - in actual problem this would be provided
    return fontSize;
}

int canFit(const char* text, int w, int h, int fontSize, FontInfo* fontInfo) {
    // Check height constraint
    if (getHeight(fontInfo, fontSize) > h) {
        return 0;
    }
    
    // Check width constraint
    int totalWidth = 0;
    int len = strlen(text);
    for (int i = 0; i < len; i++) {
        totalWidth += getWidth(fontInfo, fontSize, text[i]);
        if (totalWidth > w) {
            return 0;
        }
    }
    
    return 1;
}

int solution(const char* text, int w, int h, int* fonts, int fontsLen, FontInfo* fontInfo) {
    // Binary search on fonts array
    int left = 0, right = fontsLen - 1;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        int fontSize = fonts[mid];
        
        if (canFit(text, w, h, fontSize, fontInfo)) {
            result = fontSize;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

static int fonts[100005];

int main() {
    char text[50005];
    char fontsStr[1000005];
    int w, h;
    
    fgets(text, sizeof(text), stdin);
    text[strcspn(text, "\n")] = 0; // Remove newline
    
    scanf("%d", &w);
    scanf("%d", &h);
    getchar(); // consume newline
    
    fgets(fontsStr, sizeof(fontsStr), stdin);
    fontsStr[strcspn(fontsStr, "\n")] = 0; // Remove newline
    
    // Parse fonts array
    int fontsLen = 0;
    if (strcmp(fontsStr, "[]") != 0) {
        char* ptr = fontsStr + 1; // Skip '['
        char* end = ptr + strlen(ptr) - 1; // Point to ']'
        *end = '\0'; // Remove ']'
        
        char* token = ptr;
        while (token && *token) {
            while (*token && isspace(*token)) token++; // Skip spaces
            if (!*token) break;
            
            fonts[fontsLen++] = (int)strtol(token, &token, 10);
            
            while (*token && (*token == ',' || isspace(*token))) token++; // Skip comma and spaces
        }
    }
    
    FontInfo fontInfo;
    printf("%d\n", solution(text, w, h, fonts, fontsLen, &fontInfo));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n × m)

log n binary search iterations × m characters to calculate width

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Maximum Font to Fit a Sentence in a Screen - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler