Stream of Characters - Practice Coding Problems

Stream of Characters - Problem

Array String Design Trie Data Stream Hard

Stream of Characters is a fascinating real-time pattern matching problem that simulates processing live data streams.

You need to design a data structure that can efficiently detect if any suffix of a character stream matches words from a given dictionary. Think of it like a smart text editor that highlights matching patterns as you type!

Your Task:

Initialize a StreamChecker with an array of target words
Process characters one by one from a stream
Return true if any suffix of the current stream matches any word in your dictionary

Example: If your dictionary contains ["abc", "xyz"] and you receive characters 'a', 'x', 'y', 'z' in sequence:

After 'a': stream = "a" → no match → return false
After 'x': stream = "ax" → no match → return false
After 'y': stream = "axy" → no match → return false
After 'z': stream = "axyz" → suffix "xyz" matches! → return true

The key insight is that you only care about suffixes - you don't need the entire stream to match, just the ending portion.

Input & Output

example_1.py — Basic Example

$ Input: words = ["cd", "f", "kl"] Queries: 'a', 'b', 'c', 'd'

› Output: false, false, false, true

💡 Note: Stream builds as: "a" → "ab" → "abc" → "abcd". After 'd', the suffix "cd" matches word "cd" in dictionary.

example_2.py — Multiple Matches

$ Input: words = ["ab", "ba", "aaab", "abab", "baa"] Queries: 'a', 'a', 'a', 'b'

› Output: false, false, false, true

💡 Note: Stream: "a" → "aa" → "aaa" → "aaab". After final 'b', suffix "aaab" matches the word "aaab".

example_3.py — Single Character Match

$ Input: words = ["f"] Queries: 'x', 'y', 'f'

› Output: false, false, true

💡 Note: Stream: "x" → "xy" → "xyf". After 'f', the suffix "f" matches the single-character word "f".

Visualization

Tap to expand

Understanding the Visualization

Setup Scanner

Build reverse lookup system from suspicious patterns

Monitor Stream

Keep track of recent visitors in sliding window

Pattern Detection

Check if recent visitor sequence matches any pattern

Alert System

Trigger alert when suspicious pattern detected

Key Takeaway

🎯 Key Insight: Reverse Trie enables O(k) suffix matching by storing patterns backwards and traversing recent characters in reverse order, making real-time stream processing highly efficient!

Time & Space Complexity

Time Complexity

⏱️

O(k) per query

k is the maximum word length. We only traverse the trie up to k levels deep

✓ Linear Growth

Space Complexity

O(ALPHABET_SIZE × total_chars_in_all_words)

Space for trie nodes plus O(k) for the sliding window buffer

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 2000
1 ≤ words[i].length ≤ 200
words[i] consists of lowercase English letters
At most 4 × 10⁴ calls will be made to query
query consists of lowercase English letters
Memory optimization: Use sliding window to avoid storing entire stream

Asked in

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

The optimal solution uses a Reverse Trie data structure. Store all dictionary words backwards in the trie, maintain a sliding window buffer of recent characters, and for each query, traverse the trie backwards through the buffer to efficiently detect suffix matches in O(k) time per query.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Matching)	O(n²·m·k)	O(n + m·k)	Store stream and check every suffix against all words
Reverse Trie (Optimal)	O(k) per query	O(ALPHABET_SIZE × total_chars_in_all_words)	Build a reverse trie and efficiently match suffixes

Brute Force (String Matching) — Algorithm Steps

Store each incoming character in a stream buffer
For each new character, generate all suffixes of current stream
Check each suffix against every word in the dictionary
Return true if any suffix matches any word

Visualization

Tap to expand

Step-by-Step Walkthrough

Stream grows

Add new character to stream

Generate suffixes

Create all possible suffixes

Check each suffix

Compare against dictionary words

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 2000
#define MAX_STREAM_LEN 40000

typedef struct {
    char words[MAX_WORDS][MAX_WORD_LEN];
    int wordCount;
    char stream[MAX_STREAM_LEN];
    int streamLen;
} StreamChecker;

StreamChecker* streamCheckerCreate(char** words, int wordsSize) {
    StreamChecker* sc = (StreamChecker*)malloc(sizeof(StreamChecker));
    sc->wordCount = wordsSize;
    sc->streamLen = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        strcpy(sc->words[i], words[i]);
    }
    return sc;
}

bool streamCheckerQuery(StreamChecker* obj, char letter) {
    obj->stream[obj->streamLen++] = letter;
    obj->stream[obj->streamLen] = '\0';
    
    // Check all suffixes
    for (int i = 0; i < obj->streamLen; i++) {
        char* suffix = obj->stream + i;
        for (int j = 0; j < obj->wordCount; j++) {
            if (strcmp(suffix, obj->words[j]) == 0) {
                return true;
            }
        }
    }
    return false;
}

void streamCheckerFree(StreamChecker* obj) {
    free(obj);
}

int main() {
    char* words[] = {"cd", "f", "kl"};
    StreamChecker* sc = streamCheckerCreate(words, 3);
    printf("%d\n", streamCheckerQuery(sc, 'a')); // 0
    printf("%d\n", streamCheckerQuery(sc, 'b')); // 0
    printf("%d\n", streamCheckerQuery(sc, 'c')); // 0
    printf("%d\n", streamCheckerQuery(sc, 'd')); // 1
    streamCheckerFree(sc);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²·m·k)

For each query: O(n) suffixes × O(n) average suffix length × O(m) words × O(k) average word length

⚠ Quadratic Growth

Space Complexity

O(n + m·k)

O(n) for stream storage + O(m·k) for storing dictionary words

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 2000
1 ≤ words[i].length ≤ 200
words[i] consists of lowercase English letters
At most 4 × 10⁴ calls will be made to query
query consists of lowercase English letters
Memory optimization: Use sliding window to avoid storing entire stream

68.3K Views

Medium-High Frequency

~25 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 (String Matching) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler