Find Words That Can Be Formed by Characters

Find Words That Can Be Formed by Characters - Problem

Find Words That Can Be Formed by Characters

Imagine you have a collection of letter tiles (like in Scrabble) represented by a string chars, and you want to spell out words from an array words. Each letter tile can only be used once per word, but you can reuse the same tiles for different words.

Your task is to determine which words are "good" - meaning they can be completely formed using the available characters. Return the sum of lengths of all good words.

Example: If chars = "atach" and words = ["cat", "bt", "hat", "tree"], then:
• "cat" ✅ (uses: c-1, a-1, t-1)
• "bt" ❌ (no 'b' available)
• "hat" ✅ (uses: h-1, a-1, t-1)
• "tree" ❌ (needs 2 'e's, but none available)

Good words: "cat" (3) + "hat" (3) = 6

Input & Output

example_1.py — Basic Case

$ Input: words = ["cat","bt","hat","tree"], chars = "atach"

› Output: 6

💡 Note: "cat" can be formed (c-1, a-1, t-1), "hat" can be formed (h-1, a-1, t-1). "bt" cannot be formed (no 'b'), "tree" cannot be formed (needs 2 'e's but none available). Total: len("cat") + len("hat") = 3 + 3 = 6

example_2.py — All Words Valid

$ Input: words = ["hello","world","leetcode"], chars = "welldonehoneyr"

› Output: 10

💡 Note: "hello" can be formed, "world" can be formed. "leetcode" cannot be formed (needs 3 'e's but only 2 available, needs 2 'o's but only 1 available). Total: 5 + 5 = 10

example_3.py — No Valid Words

$ Input: words = ["dyiclysmffuhibgfvapygkorkqllqlvokosagyelotobicwcmebnpznjbirzrzsrtzjxhsfpiwyfhzyonmuabtlwin"], chars = "usdruypficfbpfbivlrhutcgvyjenlxzeovdyjtgvvfdjzcmikjraspdfp"

› Output: 0

💡 Note: The single very long word cannot be formed with the available characters (missing several required characters). Total: 0

Visualization

Tap to expand

Understanding the Visualization

Organize Your Tiles

Count each letter tile you have available

Check Each Word

For each word, see if you have enough tiles to spell it

Add Valid Words

Sum up the lengths of words you can successfully spell

Return Total Length

The answer is the total length of all possible words

Key Takeaway

🎯 Key Insight: By counting character frequencies once and reusing this information for all word validations, we transform an O(n×m×k) brute force solution into an optimal O(n×m + k) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n*m + k)

O(k) to count chars once, then O(n*m) to process all words where n=number of words, m=average word length

✓ Linear Growth

Space Complexity

O(1)

Hash maps use at most 26 entries for lowercase English letters (constant space)

✓ Linear Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length, chars.length ≤ 100
words[i] and chars consist of lowercase English letters only
Each character in chars can be used at most once per word

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses a two-pass hash table approach: first count the frequency of available characters, then for each word, verify if we have enough characters to form it. This achieves O(n×m + k) time complexity where we only count the chars string once, making it much more efficient than the brute force O(n×m×k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Optimal)	O(n*m + k)	O(1)	Count available characters once, then check each word against the frequency map
Brute Force (Character by Character)	O(nmk)	O(1)	For each word, count characters manually by scanning the chars string repeatedly

Two-Pass Hash Table (Optimal) — Algorithm Steps

Build a frequency map of all characters in chars string
For each word in the words array:
- Build a frequency map of characters needed for this word
- Compare word's requirements against available characters
- If all requirements satisfied, add word length to result
Return the total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Character Frequency Map

Count chars 'atach' once: {a:2, t:1, c:1, h:1}

Check Word 1

Word 'cat' needs {c:1, a:1, t:1} - Available ✓

Check Word 2

Word 'hat' needs {h:1, a:1, t:1} - Available ✓

Sum Results

Good words: 'cat'(3) + 'hat'(3) = 6

Code -

solution.c — C

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

int countCharacters(char** words, int wordsSize, char* chars) {
    // First pass: count available characters
    int charCount[26] = {0};
    for (int i = 0; chars[i]; i++) {
        charCount[chars[i] - 'a']++;
    }
    
    int result = 0;
    
    // Second pass: check each word
    for (int i = 0; i < wordsSize; i++) {
        int wordCount[26] = {0};
        char* word = words[i];
        
        for (int j = 0; word[j]; j++) {
            wordCount[word[j] - 'a']++;
        }
        
        bool canForm = true;
        for (int k = 0; k < 26; k++) {
            if (wordCount[k] > charCount[k]) {
                canForm = false;
                break;
            }
        }
        
        if (canForm) {
            result += strlen(word);
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m + k)

O(k) to count chars once, then O(n*m) to process all words where n=number of words, m=average word length

✓ Linear Growth

Space Complexity

O(1)

Hash maps use at most 26 entries for lowercase English letters (constant space)

✓ Linear Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length, chars.length ≤ 100
words[i] and chars consist of lowercase English letters only
Each character in chars can be used at most once per word

89.0K Views

Medium Frequency

~15 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler