Codestin Search App

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
✓ Brute Force (Nested Loops)	O(nmk)	O(1)	For each word, check every character against all allowed characters
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) — Algorithm Steps

Initialize counter to 0
For each word in the words array
For each character in the current word
Search through the allowed string to find this character
If any character is not found, mark word as inconsistent and break
If all characters are found, increment counter
Return the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first word

Begin checking characters in the first word

Check each character

For each character, search through all allowed characters

Linear search

Perform linear search through allowed string

Count if consistent

If all characters pass, increment counter

Code -

solution.c — C

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

int countConsistentStrings(char* allowed, char** words, int wordsSize) {
    int count = 0;
    int allowedLen = strlen(allowed);
    
    for (int i = 0; i < wordsSize; i++) {
        bool isConsistent = true;
        int wordLen = strlen(words[i]);
        
        for (int j = 0; j < wordLen; j++) {
            bool found = false;
            for (int k = 0; k < allowedLen; k++) {
                if (words[i][j] == allowed[k]) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                isConsistent = false;
                break;
            }
        }
        
        if (isConsistent) {
            count++;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m*k)

n words × m average characters per word × k allowed characters to search through

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler