Number of Valid Words for Each Puzzle - Practice Coding Problems

Number of Valid Words for Each Puzzle - Problem

Imagine you're creating a word game where players need to match words against puzzle strings! Given a list of words and a list of puzzles, you need to determine how many words are valid for each puzzle.

A word is considered valid for a puzzle if:

The word must contain the first letter of the puzzle
Every letter in the word must appear somewhere in the puzzle

Example: If puzzle = "abcdefg", then:

✅ "faced" is valid (contains 'a' and all letters f,a,c,e,d are in puzzle)
✅ "cabbage" is valid (contains 'a' and all letters are in puzzle)
❌ "beefed" is invalid (missing required first letter 'a')
❌ "based" is invalid (contains 's' which isn't in puzzle)

Return an array where answer[i] represents the count of valid words for puzzles[i].

Input & Output

example_1.py — Basic Example

$ Input: words = ["aaaa","asas","able","ability","actt","actor","access"], puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]

› Output: [1,1,3,2,4,0]

💡 Note: For puzzle "aboveyz": only "aaaa" is valid (contains 'a', all letters in puzzle). For "actresz": "asas", "actt", "access", "actor" are valid.

example_2.py — Edge Case

$ Input: words = ["apple","pleas","please"], puzzles = ["aelwxyz","aelpxyz","aelpsxy","saelpxy","xaelpsy"]

› Output: [0,1,3,2,0]

💡 Note: Most words don't contain required first letters. "aelpsxy" matches all 3 words since they all contain 'a' and use only letters from the puzzle.

example_3.py — Single Character

$ Input: words = ["a","aa","aaa"], puzzles = ["aabcxyz","babcxyz"]

› Output: [3,0]

💡 Note: First puzzle starts with 'a' so all words match. Second puzzle starts with 'b' but words don't contain 'b', so no matches.

Visualization

Tap to expand

Understanding the Visualization

Convert to Binary

Transform each word and puzzle into a binary pattern representing letter presence

Check Master Key

Verify the word contains the puzzle's required first letter

Validate Subset

Ensure word's letter pattern is a subset of puzzle's pattern

Count Matches

Accumulate valid words for each puzzle efficiently

Key Takeaway

🎯 Key Insight: By converting letters to bits and words to bitmasks, we transform expensive string operations into blazingly fast bitwise AND operations, reducing complexity from O(words × puzzles × length) to O(words + puzzles × 2^7).

Time & Space Complexity

Time Complexity

⏱️

O(W × L + P × 2^min(L,7))

W×L for building Trie + P puzzles × exploring valid subsets (limited by puzzle length)

✓ Linear Growth

Space Complexity

O(W × L)

Trie space proportional to total character count in words

✓ Linear Space

Constraints

1 ≤ words.length ≤ 10⁵
4 ≤ words[i].length ≤ 50
1 ≤ puzzles.length ≤ 10⁴
puzzles[i].length == 7
words[i] and puzzles[i] consist of lowercase English letters
Each puzzles[i] doesn't contain repeated characters

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 24

The optimal approach uses bitmask representation with subset enumeration. Convert words to bitmasks representing their character sets, then for each puzzle, generate all valid subsets containing the first character. This reduces the problem from string matching to efficient bitwise operations, achieving O(W + P × 2^7) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table with Bitmask Preprocessing	O(W + P × 2^7)	O(W)	Convert words to bitmasks first, then check each puzzle efficiently
Optimized Trie with Bitmask (Optimal)	O(W × L + P × 2^min(L,7))	O(W × L)	Use Trie structure with bitmask optimization for maximum efficiency
Brute Force (Check Each Word)	O(W × P × L)	O(1)	For each puzzle, check every word character by character

Hash Table with Bitmask Preprocessing — Algorithm Steps

Convert each word to a bitmask representing its unique characters
Store word bitmasks in a frequency map
For each puzzle, convert to bitmask
Generate all possible subsets of puzzle that include first character
Count matching word bitmasks for each valid subset

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert Words to Bitmasks

Each word becomes a bitmask representing its character set

Create Puzzle Bitmask

Convert puzzle string to bitmask

Generate Valid Subsets

Find all subsets containing first character

Count Matching Words

Look up each valid subset in word frequency map

Code -

solution.c — C

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

#define MAX_MASK 1024

int* findNumOfValidWords(char** words, int wordsSize, char** puzzles, int puzzlesSize, int* returnSize) {
    *returnSize = puzzlesSize;
    int* result = (int*)malloc(puzzlesSize * sizeof(int));
    int wordMasks[MAX_MASK] = {0};
    
    // Preprocess words
    for (int i = 0; i < wordsSize; i++) {
        int mask = 0;
        for (int j = 0; words[i][j]; j++) {
            mask |= 1 << (words[i][j] - 'a');
        }
        wordMasks[mask]++;
    }
    
    for (int i = 0; i < puzzlesSize; i++) {
        int puzzleMask = 0;
        for (int j = 0; puzzles[i][j]; j++) {
            puzzleMask |= 1 << (puzzles[i][j] - 'a');
        }
        
        int firstBit = 1 << (puzzles[i][0] - 'a');
        int count = 0;
        
        for (int subset = puzzleMask; subset > 0; subset = (subset - 1) & puzzleMask) {
            if (subset & firstBit) {
                count += wordMasks[subset];
            }
        }
        
        result[i] = count;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(W + P × 2^7)

W for preprocessing words + P puzzles × 2^7 possible subsets (max 7 unique chars in puzzle)

✓ Linear Growth

Space Complexity

O(W)

HashMap to store word bitmask frequencies

✓ Linear Space

Constraints

1 ≤ words.length ≤ 10⁵
4 ≤ words[i].length ≤ 50
1 ≤ puzzles.length ≤ 10⁴
puzzles[i].length == 7
words[i] and puzzles[i] consist of lowercase English letters
Each puzzles[i] doesn't contain repeated characters

52.0K Views

Medium-High Frequency

~25 min Avg. Time

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

Hash Table with Bitmask Preprocessing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler