Number of Matching Subsequences

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, return the number of words[i] that is a subsequence of s.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

For example, "ace" is a subsequence of "abcde".

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: "a" is a subsequence of "abcde" (take character at index 0). "bb" is not a subsequence since we only have one 'b'. "acd" is a subsequence (take characters at indices 0, 2, 3).

Example 2 — No Matches

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

› Output: 2

💡 Note: "ahjpjau" is a subsequence of "dsahjpjauf". "ja" is a subsequence. "ahbwzgqnuk" and "tnmlanowax" are not subsequences.

Example 3 — Single Character

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

› Output: 4

💡 Note: All words can be found as subsequences in the string s.

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is to avoid checking each word independently against string s. Instead, process all words simultaneously using a hash map to group words by their next expected character. This reduces the time complexity from O(n×m) to O(m + n×k×log m) with binary search preprocessing. Best approach depends on input size: hash map for many short words, binary search for fewer long words.

Common Approaches

✓ Binary Search with Preprocessing

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

Build an index mapping each character to all its positions in s, then use binary search to quickly find if each word can be formed as a subsequence.

Brute Force - Check Each Word

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

Check each word individually by using two pointers to see if all characters of the word can be found in order in string s. This requires scanning s multiple times.

Hash Map Optimization

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

Instead of checking each word separately, maintain a mapping of characters to words waiting for that character. Process all words simultaneously as we scan through s.

Binary Search with Preprocessing — Algorithm Steps

Build index: map each character to list of positions in s
For each word, use binary search to find valid character positions
Ensure positions are in increasing order for subsequence property
Count successfully matched words

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Character Index

Map each character to all its positions in s

Binary Search Positions

For each word character, find next valid position

Validate Sequence

Ensure positions are in increasing order

Code -

solution.c — C

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

#define MAX_CHARS 256
#define MAX_POSITIONS 50000

int charPositions[MAX_CHARS][MAX_POSITIONS];
int charCounts[MAX_CHARS];

int binarySearch(int arr[], int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int isSubsequence(const char* word, int wordLen) {
    int pos = -1;
    for (int i = 0; i < wordLen; i++) {
        unsigned char c = (unsigned char)word[i];
        if (charCounts[c] == 0) {
            return 0;
        }
        
        int idx = binarySearch(charPositions[c], charCounts[c], pos);
        if (idx >= charCounts[c]) {
            return 0;
        }
        pos = charPositions[c][idx];
    }
    return 1;
}

int solution(const char* s, char words[][100], int wordCount) {
    // Initialize
    memset(charCounts, 0, sizeof(charCounts));
    
    // Build index
    int sLen = strlen(s);
    for (int i = 0; i < sLen; i++) {
        unsigned char c = (unsigned char)s[i];
        charPositions[c][charCounts[c]++] = i;
    }
    
    int count = 0;
    for (int i = 0; i < wordCount; i++) {
        if (isSubsequence(words[i], strlen(words[i]))) {
            count++;
        }
    }
    return count;
}

int main() {
    char s[50001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char line[100001];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char words[1000][100];
    int wordCount = 0;
    
    char* start = strchr(line, '[') + 1;
    char* end = strrchr(line, ']');
    *end = '\0';
    
    char* token = strtok(start, ",");
    while (token != NULL && wordCount < 1000) {
        while (*token == ' ' || *token == '"') token++;
        char* tokenEnd = token + strlen(token) - 1;
        while (tokenEnd > token && (*tokenEnd == ' ' || *tokenEnd == '"')) {
            *tokenEnd = '\0';
            tokenEnd--;
        }
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, ",");
    }
    
    printf("%d\n", solution(s, words, wordCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + n × k × log m)

Preprocessing takes O(m), then for each word we do k binary searches of O(log m) each

✓ Linear Growth

Space Complexity

O(m)

Index maps store all positions of characters in string s

✓ Linear Space

89.4K Views

Medium Frequency

~25 min Avg. Time

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

Binary Search with Preprocessing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler