Number of Strings That Appear as Substrings in Word

Number of Strings That Appear as Substrings in Word - Problem

Array String Easy

You're given an array of pattern strings and a target word. Your task is to count how many of these patterns actually appear as substrings within the target word.

A substring is a contiguous sequence of characters within a string. For example, "cat" is a substring of "concatenate", but "cta" is not (since the characters aren't contiguous).

Goal: Return the total count of pattern strings that exist as substrings in the target word.

Input: An array of strings patterns and a string word

Output: An integer representing the count of matching patterns

Input & Output

example_1.py — Basic Case

$ Input: patterns = ["a", "aa", "aaa"], word = "aaaaaaa"

› Output: 3

💡 Note: All three patterns exist as substrings: 'a' appears multiple times, 'aa' appears multiple times, and 'aaa' also appears multiple times in the word 'aaaaaaa'.

example_2.py — Mixed Case

$ Input: patterns = ["a", "b", "c"], word = "aaaaabbbbb"

› Output: 2

💡 Note: Only 'a' and 'b' exist as substrings in 'aaaaabbbbb'. The pattern 'c' does not appear anywhere in the word.

example_3.py — No Matches

$ Input: patterns = ["a", "aa", "aaa"], word = "bbbbbbbb"

› Output: 0

💡 Note: None of the patterns containing 'a' characters appear in the word 'bbbbbbbb', so the count is 0.

Visualization

Tap to expand

Understanding the Visualization

Load Patterns

Start with array of patterns to search for: ['a', 'aa', 'aaa']

Check Each Pattern

For each pattern, use optimized search to find if it exists in target word

Count Matches

Increment counter for each pattern found as substring

Return Result

Return total count of patterns that exist as substrings

Key Takeaway

🎯 Key Insight: Use built-in string search methods instead of manual character comparison - they're optimized, handle edge cases, and result in much cleaner code!

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the number of patterns and m is the length of the word. Built-in methods are optimized and average much better than brute force.

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ patterns.length ≤ 100
1 ≤ patterns[i].length ≤ 100
1 ≤ word.length ≤ 100
patterns[i] and word consist of lowercase English letters only

Asked in

a Amazon 25 G Google 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses built-in string search methods to efficiently check if each pattern exists as a substring in the target word. Simply iterate through each pattern and use methods like Python's 'in' operator or JavaScript's includes() to count matches. This leverages optimized algorithms and results in clean, readable code with O(n*m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Manual Substring Check)	O(n * m * k)	O(1)	Manually check each pattern against every possible substring position in the word
Built-in String Methods (Optimal)	O(n * m)	O(1)	Use language built-in substring search methods for optimal performance

Brute Force (Manual Substring Check) — Algorithm Steps

Iterate through each pattern in the patterns array
For each pattern, try every possible starting position in the word
At each position, compare characters one by one to see if pattern matches
If a complete match is found, increment counter and move to next pattern
Return the total count of matching patterns

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first pattern

Begin checking pattern 'a' against word 'aaaaaaa'

Try each position

Check if pattern matches starting at position 0, then 1, then 2, etc.

Character comparison

Compare each character of pattern with corresponding characters in word

Match found

When match is found, increment counter and move to next pattern

Code -

solution.c — C

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

int numOfStrings(char patterns[][100], int patternCount, char* word) {
    int count = 0;
    int wordLen = strlen(word);
    
    for (int p = 0; p < patternCount; p++) {
        char* pattern = patterns[p];
        int patternLen = strlen(pattern);
        bool found = false;
        
        // Check every possible starting position
        for (int i = 0; i <= wordLen - patternLen; i++) {
            bool match = true;
            
            // Check if pattern matches at position i
            for (int j = 0; j < patternLen; j++) {
                if (word[i + j] != pattern[j]) {
                    match = false;
                    break;
                }
            }
            
            if (match) {
                found = true;
                break;
            }
        }
        
        if (found) count++;
    }
    
    return count;
}

int main() {
    char patterns[3][100] = {"a", "aa", "aaa"};
    char word[] = "aaaaaaa";
    printf("%d\n", numOfStrings(patterns, 3, word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

Where n is the number of patterns, m is the length of the word, and k is the average length of patterns

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and indexing

✓ Linear Space

Constraints

1 ≤ patterns.length ≤ 100
1 ≤ patterns[i].length ≤ 100
1 ≤ word.length ≤ 100
patterns[i] and word consist of lowercase English letters only

42.0K Views

Medium Frequency

~8 min Avg. Time

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

Brute Force (Manual Substring Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler