Count the Number of Consistent Strings

Count the Number of Consistent Strings - Problem

You are given a string allowed consisting of distinct characters and an array of strings words.

A string is consistent if all characters in the string appear in the string allowed.

Return the number of consistent strings in the array words.

Input & Output

Example 1 — Basic Case

$ Input: allowed = "ab", words = ["ad","bd","aaab","baa","badab"]

› Output: 2

💡 Note: Strings "aaab" and "baa" are consistent since they only contain characters 'a' and 'b'.

Example 2 — All Valid

$ Input: allowed = "abc", words = ["a","b","c","ab","ac","bc","abc"]

› Output: 7

💡 Note: All strings are consistent since they only use allowed characters a, b, c.

Example 3 — None Valid

$ Input: allowed = "cad", words = ["cc","acd","b","ba","bac","bad","ac","d"]

› Output: 4

💡 Note: Strings "cc", "acd", "ac", and "d" are consistent. Others contain characters not in "cad".

Constraints

1 ≤ words.length ≤ 10⁴
1 ≤ allowed.length ≤ 26
1 ≤ words[i].length ≤ 10
The characters in allowed are distinct
words[i] and allowed contain only lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The optimal approach uses a hash set to store allowed characters for O(1) lookups. For each word, check if all characters exist in the set. The bit manipulation approach is even more efficient, using bitmasks for ultra-fast character verification. Time: O(k + n×m), Space: O(k) for hash set or O(1) for bit manipulation.

Common Approaches

✓ Bit Manipulation

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

Convert allowed characters to a bitmask where each bit represents a character. For each word, create its bitmask and check if it's a subset of the allowed bitmask using bitwise operations.

Brute Force

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

For each word, iterate through all its characters and check if each character exists in the allowed string. Count words where all characters are found.

Hash Set Optimization

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

Convert the allowed string into a hash set for constant-time lookups. Then iterate through each word and check if all characters exist in the hash set.

Bit Manipulation — Algorithm Steps

Create bitmask for allowed characters
For each word, create its character bitmask
Use bitwise AND to check if word's characters are subset of allowed

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Mask

Convert allowed characters to bitmask

Word Masks

Create bitmask for each word

Subset Check

Use bitwise AND to check if word ⊆ allowed

Code -

solution.c — C

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

int solution(char* allowed, char** words, int wordsSize) {
    // Create bitmask for allowed characters
    int allowedMask = 0;
    for (int i = 0; allowed[i] != '\0'; i++) {
        allowedMask |= 1 << (allowed[i] - 'a');
    }
    
    int count = 0;
    for (int i = 0; i < wordsSize; i++) {
        // Create bitmask for current word
        int wordMask = 0;
        for (int j = 0; words[i][j] != '\0'; j++) {
            wordMask |= 1 << (words[i][j] - 'a');
        }
        
        // Check if word's characters are subset of allowed
        if ((wordMask & allowedMask) == wordMask) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char allowed[1000];
    fgets(allowed, sizeof(allowed), stdin);
    allowed[strcspn(allowed, "\n")] = 0;
    
    char wordsLine[10000];
    fgets(wordsLine, sizeof(wordsLine), stdin);
    wordsLine[strcspn(wordsLine, "\n")] = 0;
    
    // Parse JSON array properly
    char** words = malloc(1000 * sizeof(char*));
    int wordsSize = 0;
    
    // Simple JSON parsing for arrays of strings
    int len = strlen(wordsLine);
    int i = 1; // Skip opening bracket
    
    while (i < len - 1) { // Skip closing bracket
        // Skip whitespace and commas
        while (i < len && (wordsLine[i] == ' ' || wordsLine[i] == ',')) i++;
        if (i >= len - 1) break;
        
        // Expect opening quote
        if (wordsLine[i] == '"') {
            i++; // Skip opening quote
            int start = i;
            // Find closing quote
            while (i < len && wordsLine[i] != '"') i++;
            if (i < len) {
                int wordLen = i - start;
                words[wordsSize] = malloc((wordLen + 1) * sizeof(char));
                strncpy(words[wordsSize], wordsLine + start, wordLen);
                words[wordsSize][wordLen] = '\0';
                wordsSize++;
                i++; // Skip closing quote
            }
        } else {
            i++;
        }
    }
    
    int result = solution(allowed, words, wordsSize);
    printf("%d\n", result);
    
    // Cleanup
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k + n × m)

k to build allowed mask, then n words with average m characters for bit operations

✓ Linear Growth

Space Complexity

O(1)

Only storing integer bitmasks, constant space regardless of input size

✓ Linear Space

23.5K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler