Number of Valid Words for Each Puzzle - Problem

Given an array of words and an array of puzzles, return an array answer where answer[i] is the number of words that are valid with respect to the puzzle puzzles[i].

With respect to a given puzzle string, a word is valid if both the following conditions are satisfied:

word contains the first letter of puzzle.
For each letter in word, that letter is in puzzle.

For example, if the puzzle is "abcdefg", then valid words are "faced", "cabbage", and "baggage", while invalid words are "beefed" (does not include 'a') and "based" (includes 's' which is not in the puzzle).

Input & Output

Example 1 — Basic Case

$ 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": word "aaaa" contains 'a' and all letters are in puzzle, so count=1. For "abslute": words "able", "ability", "actt" are valid, so count=3.

Example 2 — Single Letters

$ Input: words = ["apple","pleas","please"], puzzles = ["aelpxy","aelpxy","aelpsxy"]

› Output: [0,1,3]

💡 Note: "apple" doesn't contain first letter 'a' from puzzle letters only. "pleas" is valid for second puzzle. All three words valid for third puzzle.

Example 3 — No Valid Words

$ Input: words = ["word","test"], puzzles = ["abcdef"]

› Output: [0]

💡 Note: Neither "word" nor "test" contains 'a' (first letter of puzzle), so no valid words.

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] contains unique characters

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 a Amazon 28

The key insight is using bit manipulation to represent character sets as bitmasks for efficient subset checking. Convert each word to a bitmask, then for each puzzle generate all submasks and count matching words that contain the first character. Best approach uses bit manipulation with Time: O(n × 2^7 + m), Space: O(m).

Common Approaches

✓ Bit Manipulation with Bitmasks

⏱️ Time: O(n × 2^7 + m) Space: O(m)

Represent each word and puzzle as a bitmask where each bit represents a letter. Use bitwise operations to check if a word is a subset of a puzzle and contains the required first character.

Brute Force Character Matching

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

For each puzzle, iterate through all words and check if the word contains only characters from the puzzle and includes the first character of the puzzle.

Bit Manipulation with Bitmasks — Algorithm Steps

Convert each word to a bitmask
For each puzzle, generate all possible submasks
Count words matching submasks that include first character

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Bitmasks

Convert words and puzzles to binary representations

Generate Submasks

Find all possible character combinations in puzzle

Match & Count

Count word bitmasks that match submasks with first char

Code -

solution.c — C

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

#define MAX_WORDS 10000
#define MAX_LEN 50

// Function to check if word is valid for puzzle
int is_valid(char *word, char *puzzle) {
    int word_mask = 0, puzzle_mask = 0;

    // Create bitmask for puzzle letters
    for (int i = 0; puzzle[i]; i++) {
        puzzle_mask |= 1 << (puzzle[i] - 'a');
    }

    // Create bitmask for word letters
    for (int i = 0; word[i]; i++) {
        word_mask |= 1 << (word[i] - 'a');
    }

    // Check if word contains first character
    if (!(word_mask & (1 << (puzzle[0] - 'a'))))
        return 0;

    // Check if all word letters are inside puzzle
    if ((word_mask | puzzle_mask) != puzzle_mask)
        return 0;

    return 1;
}

// Simple parser for JSON-like string array
int parse_input(char *line, char arr[][MAX_LEN]) {
    int count = 0;
    int i = 0, j = 0;
    int in_string = 0;

    while (line[i]) {
        if (line[i] == '"') {
            if (!in_string) {
                in_string = 1;
                j = 0;
            } else {
                arr[count][j] = '\0';
                count++;
                in_string = 0;
            }
        } else if (in_string) {
            arr[count][j++] = line[i];
        }
        i++;
    }
    return count;
}

int main() {
    char line1[100000], line2[100000];
    char words[MAX_WORDS][MAX_LEN];
    char puzzles[MAX_WORDS][MAX_LEN];

    // Read input lines
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);

    // Parse input
    int word_count = parse_input(line1, words);
    int puzzle_count = parse_input(line2, puzzles);

    // Solve
    printf("[");
    for (int i = 0; i < puzzle_count; i++) {
        int count = 0;
        for (int j = 0; j < word_count; j++) {
            if (is_valid(words[j], puzzles[i])) {
                count++;
            }
        }
        printf("%d", count);
        if (i < puzzle_count - 1)
            printf(",");
    }
    printf("]\n");

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^7 + m)

n puzzles × 2^7 submasks (max 7 unique chars in puzzle) + m words preprocessing

✓ Linear Growth

Space Complexity

O(m)

Hash map storing word bitmasks and their frequencies

✓ Linear Space

28.5K Views

Medium Frequency

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

Number of Valid Words for Each Puzzle - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation with Bitmasks — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler