Count the Number of Consistent Strings - Practice Coding Problems

Count the Number of Consistent Strings - Problem

You are a content moderator for a social media platform, and you need to validate user posts based on allowed characters. You have been given a string of allowed characters and an array of user-generated strings that need to be checked.

A string is considered consistent if all characters in the string appear in the allowed characters string. Your task is to count how many strings in the array are consistent.

Goal: Return the number of consistent strings in the array.

Example: If allowed characters are "abc" and we have words ["a", "b", "c", "ab", "ac", "bc", "abc", "xyz"], then 7 strings are consistent (all except "xyz" which contains characters not in the allowed set).

Input & Output

example_1.py — 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'. The other strings contain 'd' which is not allowed.

example_2.py — All consistent

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

› Output: 7

💡 Note: All strings are consistent as they only use characters from the allowed set {a, b, c}.

example_3.py — None consistent

$ 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 'b' which is not in allowed characters.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Create Approval List

Convert allowed characters string into a fast lookup table (hash set)

Check Each Post

For each user post (word), examine every character

Validate Characters

Use hash set to instantly check if each character is approved

Count Approved Posts

Increment counter only if all characters in the post are approved

Key Takeaway

🎯 Key Insight: Converting the allowed characters to a hash set transforms expensive O(k) character searches into O(1) lookups, dramatically improving performance for large inputs while maintaining simple, readable code.

Asked in

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

The optimal solution uses a hash set to store allowed characters, enabling O(1) character lookups. This reduces time complexity from O(n×m×k) brute force to O(k + n×m), where k ≤ 26 for lowercase letters. The approach is simple: build a set of allowed characters, then for each word, check if all its characters exist in the set.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Lookup (Optimal)	O(k + n*m)	O(k)	Convert allowed characters to a set for O(1) lookups, then check each word
Brute Force (Nested Loops)	O(nmk)	O(1)	For each word, check every character against all allowed characters

Hash Set Lookup (Optimal) — Algorithm Steps

Create a hash set from the allowed characters string
Initialize counter to 0
For each word in the words array
For each character in the current word
Check if character exists in the hash set (O(1) operation)
If any character is not in set, mark word as inconsistent and break
If all characters are in set, increment counter
Return the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Build hash set

Convert allowed string to hash set for fast lookups

Process each word

Check each character against the hash set

O(1) lookup

Hash set provides instant character validation

Count consistent words

Increment counter for words with all allowed characters

Code -

solution.c — C

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

int countConsistentStrings(char* allowed, char** words, int wordsSize) {
    bool allowedSet[256] = {false}; // ASCII character set
    
    // Build allowed set
    for (int i = 0; allowed[i]; i++) {
        allowedSet[(int)allowed[i]] = true;
    }
    
    int count = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        bool isConsistent = true;
        for (int j = 0; words[i][j]; j++) {
            if (!allowedSet[(int)words[i][j]]) {
                isConsistent = false;
                break;
            }
        }
        
        if (isConsistent) {
            count++;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(k + n*m)

k to build the set + n words × m average characters per word for lookups

✓ Linear Growth

Space Complexity

O(k)

Hash set stores k allowed characters (k ≤ 26 for lowercase letters)

✓ Linear Space

52.3K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Hash Set Lookup (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler