Number of Matching Subsequences - Practice Coding Problems

Number of Matching Subsequences - Problem

Array Hash Table String Binary Search Dynamic Programming Trie Sorting Medium

Given a string s and an array of strings words, your task is to determine how many words in the array are subsequences of the main string s.

A subsequence is formed by deleting some (possibly zero) characters from the original string while maintaining the relative order of the remaining characters. For example, "ace" is a subsequence of "abcde" because we can obtain it by removing characters 'b' and 'd'.

Goal: Count how many words from the given array are subsequences of the main string.

Example: If s = "abcde" and words = ["a", "bb", "acd", "ace"], then "a", "acd", and "ace" are subsequences of s, so the answer is 3.

Input & Output

example_1.py — Basic Example

$ Input: s = "abcde", words = ["a", "bb", "acd", "ace"]

› Output: 3

💡 Note: The subsequences are "a" (matches s[0]), "acd" (matches s[0], s[2], s[3]), and "ace" (matches s[0], s[2], s[4]). The word "bb" is not a subsequence because there's only one 'b' in s.

example_2.py — All Match

$ Input: s = "dsahjpjauf", words = ["ahjpjau", "ja", "ahbwzgqnuk", "tnmlanowax"]

› Output: 2

💡 Note: "ahjpjau" is a subsequence (matches positions 2,3,4,5,6,7,8), and "ja" is a subsequence (matches positions 3,8). The other words cannot be formed as subsequences.

example_3.py — Edge Cases

$ Input: s = "wordgoodgoodgoodbestword", words = ["word", "good", "best", "good"]

› Output: 3

💡 Note: "word" appears at the beginning, "good" can be formed multiple times (but we count each occurrence in words array), and "best" appears in the middle. Note that "good" appears twice in the words array, so it contributes 2 to the count.

Visualization

Tap to expand

Understanding the Visualization

Setup Platforms

Create 26 platforms (a-z) and assign each word to the platform of its first character

Train Arrives

When character 'a' appears in string, all words on platform 'a' board the train

Next Destination

Words advance to their next character's platform, or exit if journey complete

Count Completions

Count how many words successfully completed their journey through the string

Key Takeaway

🎯 Key Insight: By grouping words by their expected character and processing them together, we eliminate redundant string scans and achieve optimal O(n + m) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

O(n) to scan through string s once, O(m) to process all characters in all words exactly once

✓ Linear Growth

Space Complexity

O(m)

Space to store word iterators in buckets, proportional to total length of all words

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
1 ≤ words.length ≤ 5000
1 ≤ words[i].length ≤ 50
s and words[i] consist of only lowercase English letters

Asked in

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

The optimal approach uses a bucket-based technique where words are grouped by their current expected character. As we scan through the main string once, we process all words waiting for each character simultaneously, achieving O(n + m) time complexity where n is the string length and m is the total length of all words.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Word Separately)	O(n * m)	O(1)	For each word, scan through the main string to check if it's a subsequence
Bucket-Based Optimization (Optimal)	O(n + m)	O(m)	Group words by their next expected character and process them together in one pass
Preprocessing + Binary Search	O(n + m * k * log n)	O(n)	Preprocess string to create character position maps, then use binary search for efficient subsequence checking

Brute Force (Check Each Word Separately) — Algorithm Steps

Iterate through each word in the words array
For each word, use two pointers to check if it's a subsequence of s
Increment counter if word is found as subsequence
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Check First Word

Start with first word and scan through main string

Match Characters

Use two pointers to match characters in order

Repeat Process

Repeat for each word in the array

Code -

solution.c — C

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

int isSubsequence(char* word, char* s) {
    int i = 0; // pointer for word
    int j = 0; // pointer for s
    int wordLen = strlen(word);
    int sLen = strlen(s);
    
    while (i < wordLen && j < sLen) {
        if (word[i] == s[j]) {
            i++;
        }
        j++;
    }
    
    return i == wordLen;
}

int numMatchingSubseq(char* s, char** words, int wordsSize) {
    int count = 0;
    for (int i = 0; i < wordsSize; i++) {
        if (isSubsequence(words[i], s)) {
            count++;
        }
    }
    return count;
}

int main() {
    char s[] = "abcde";
    char* words[] = {"a", "bb", "acd", "ace"};
    printf("%d\n", numMatchingSubseq(s, words, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the length of string s and m is the total length of all words. We scan s for each word.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for tracking positions and count

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
1 ≤ words.length ≤ 5000
1 ≤ words[i].length ≤ 50
s and words[i] consist of only lowercase English letters

68.3K Views

High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Each Word Separately) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler