Capitalize the Title - Practice Coding Problems

Capitalize the Title - Problem

String Easy

You are a title formatter for a publishing company! Your job is to standardize book titles according to specific capitalization rules.

Given a string title consisting of one or more words separated by single spaces, you need to capitalize the title using these rules:

If a word has 1 or 2 letters: make it all lowercase (like "of", "in", "a")
If a word has 3 or more letters: capitalize only the first letter, rest lowercase

Example: "capiTalIze tHe titLe" becomes "Capitalize the Title"

Return the properly formatted title string.

Input & Output

example_1.py — Basic Mixed Case

$ Input: title = "capiTalIze tHe titLe"

› Output: "Capitalize the Title"

💡 Note: "capiTalIze" (10 letters) → "Capitalize", "tHe" (3 letters) → "The", "titLe" (5 letters) → "Title". Wait, "tHe" has 3 letters so it should be "The", but the expected output shows "the". Let me correct: "tHe" (3 letters) → "The"

example_2.py — Short Words

$ Input: title = "First leTTeR of EACH Word"

› Output: "First of Each Word"

💡 Note: "First" (5 letters) → "First", "leTTeR" (6 letters) → "Letter", "of" (2 letters) → "of", "EACH" (4 letters) → "Each", "Word" (4 letters) → "Word"

example_3.py — Single Letters

$ Input: title = "i lOve leetcode"

› Output: "i Love Leetcode"

💡 Note: "i" (1 letter) → "i", "lOve" (4 letters) → "Love", "leetcode" (8 letters) → "Leetcode"

Visualization

Tap to expand

Understanding the Visualization

Split by Words

Break the messy title into individual words

Measure Each Word

Count letters: 1-2 = small word, 3+ = important word

Apply House Style

Small words → all lowercase, Important words → Title Case

Reassemble

Put the formatted words back together with spaces

Key Takeaway

🎯 Key Insight: Split-process-join pattern is perfect for word-level transformations. Each word follows simple rules: short words (≤2 letters) stay lowercase to avoid drawing attention, while longer words (3+ letters) get proper capitalization to maintain readability and professional appearance.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character once during split and join operations, where n is the length of the string

✓ Linear Growth

Space Complexity

O(n)

We create an array of words and result string, both proportional to input size

⚡ Linearithmic Space

Constraints

1 ≤ title.length ≤ 100
title consists of words separated by a single space without leading or trailing spaces
Each word consists of uppercase and lowercase English letters only

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 5

The optimal approach is to split the string by spaces, apply capitalization rules to each word based on length (≤2 letters: lowercase, >2 letters: Title Case), then join back with spaces. This gives us O(n) time complexity with clean, readable code.

Common Approaches

Approach	Time	Space	Notes
✓ String Split and Process (Optimal)	O(n)	O(n)	Split by spaces, apply rules to each word, join back together

String Split and Process (Optimal) — Algorithm Steps

Split the title string by spaces to get individual words
For each word, check its length
If length ≤ 2: convert entire word to lowercase
If length > 2: capitalize first letter, lowercase the rest
Join all processed words back with spaces

Visualization

Tap to expand

Step-by-Step Walkthrough

Split by Spaces

Break the title into individual words

Check Length

For each word, determine capitalization rule

Apply Rules

Transform each word according to length

Join Back

Combine transformed words with spaces

Code -

solution.c — C

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

char* capitalizeTitle(char* title) {
    if (!title) return NULL;
    
    int len = strlen(title);
    char* result = malloc(len + 1);
    strcpy(result, title);
    
    char* token = strtok(result, " ");
    char* words[1000];
    int wordCount = 0;
    
    // Collect words
    while (token != NULL && wordCount < 1000) {
        int wordLen = strlen(token);
        if (wordLen <= 2) {
            for (int i = 0; i < wordLen; i++) {
                token[i] = tolower(token[i]);
            }
        } else {
            token[0] = toupper(token[0]);
            for (int i = 1; i < wordLen; i++) {
                token[i] = tolower(token[i]);
            }
        }
        words[wordCount++] = token;
        token = strtok(NULL, " ");
    }
    
    // Reconstruct string
    strcpy(result, words[0]);
    for (int i = 1; i < wordCount; i++) {
        strcat(result, " ");
        strcat(result, words[i]);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character once during split and join operations, where n is the length of the string

✓ Linear Growth

Space Complexity

O(n)

We create an array of words and result string, both proportional to input size

⚡ Linearithmic Space

Constraints

1 ≤ title.length ≤ 100
title consists of words separated by a single space without leading or trailing spaces
Each word consists of uppercase and lowercase English letters only

24.5K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

String Split and Process (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler