Maximum Number of Words You Can Type - Practice Coding Problems

Maximum Number of Words You Can Type - Problem

Imagine you're working on an old computer with a faulty keyboard where some keys just won't respond when you press them! Your task is to determine how many complete words from a given text you can actually type.

You're given:

A text string containing words separated by single spaces (no leading or trailing spaces)
A brokenLetters string containing all the distinct letter keys that don't work

Your goal is to return the number of words in the text that you can fully type using this malfunctioning keyboard.

Example: If your text is "hello world" and the broken letters are "ad", you can type "hello" completely (no 'a' or 'd' needed), but you cannot type "world" because it contains the broken letter 'd'. So the answer would be 1.

Input & Output

example_1.py — Basic Case

$ Input: text = "hello world", brokenLetters = "ad"

› Output: 1

💡 Note: We can type "hello" completely since it doesn't contain 'a' or 'd'. However, "world" contains 'd' which is broken, so we can't type it. Total: 1 word.

example_2.py — Multiple Broken Letters

$ Input: text = "leet code", brokenLetters = "lt"

› Output: 1

💡 Note: "leet" contains both 'l' and 't' which are broken, so it cannot be typed. "code" doesn't contain 'l' or 't', so it can be typed. Total: 1 word.

example_3.py — No Broken Letters

$ Input: text = "leet code", brokenLetters = ""

› Output: 2

💡 Note: No letters are broken, so we can type all words: "leet" and "code". Total: 2 words.

Constraints

1 ≤ text.length ≤ 10⁴
0 ≤ brokenLetters.length ≤ 26
text consists of words separated by single spaces, no leading or trailing spaces
Each word consists only of lowercase English letters
brokenLetters consists of distinct lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Build Broken Keys Set

Create a fast lookup table of all the broken keyboard keys

Examine Each Word

Go through each word in the text one by one

Check Every Letter

For each word, verify that none of its letters are in the broken keys set

Count Typeable Words

Only count words that can be completely typed without any broken letters

Key Takeaway

🎯 Key Insight: Use a hash set to convert the broken letters into a fast O(1) lookup table, then check each word's letters against this set. This transforms an O(n×m×k) brute force solution into an optimal O(n+m) solution.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses a hash set to store broken letters for O(1) lookup time, then processes each word by checking its letters against the set. This achieves O(n + m) time complexity where n is the total text length and m is the number of broken letters, significantly better than the brute force O(n × m × k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Optimization (Optimal)	O(n + m)	O(m)	Use hash set for O(1) broken letter lookup, process words in single pass
Brute Force (Nested Loops)	O(n × m × k)	O(1)	For each word, check every letter against every broken letter

Hash Set Optimization (Optimal) — Algorithm Steps

Convert brokenLetters string into a hash set for O(1) lookup
Split text into words
For each word, check each letter against the hash set
If any letter exists in broken set, skip the word
Count words with no broken letters

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Hash Set

Build hash set from broken letters for O(1) lookup

Process Words

Check each word's letters against hash set

Fast Lookup

Each letter check is now O(1) instead of O(k)

Count Results

Efficiently count words with no broken letters

Code -

solution.c — C

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

int canBeTyped(char* text, char* brokenLetters) {
    bool broken[256] = {false}; // ASCII lookup table
    
    // Mark broken letters
    for (int i = 0; brokenLetters[i] != '\0'; i++) {
        broken[(unsigned char)brokenLetters[i]] = true;
    }
    
    char* words[1000];
    int wordCount = 0;
    
    char* token = strtok(text, " ");
    while (token != NULL) {
        words[wordCount++] = token;
        token = strtok(NULL, " ");
    }
    
    int count = 0;
    for (int i = 0; i < wordCount; i++) {
        bool canType = true;
        for (int j = 0; words[i][j] != '\0'; j++) {
            if (broken[(unsigned char)words[i][j]]) {
                canType = false;
                break;
            }
        }
        if (canType) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char text[10000], brokenLetters[100];
    fgets(text, sizeof(text), stdin);
    fgets(brokenLetters, sizeof(brokenLetters), stdin);
    
    // Remove quotes and newlines
    text[strlen(text) - 1] = '\0';
    brokenLetters[strlen(brokenLetters) - 1] = '\0';
    
    printf("%d\n", canBeTyped(text + 1, brokenLetters + 1));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n is the total number of characters in text and m is the number of broken letters. We process each character once and each broken letter once.

✓ Linear Growth

Space Complexity

O(m)

Space needed to store the hash set of broken letters, where m is the number of broken letters.

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Hash Set Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler