Find Pattern in Infinite Stream I - Practice Coding Problems

Find Pattern in Infinite Stream I - Problem

Find Pattern in Infinite Stream I

You're tasked with finding a specific binary pattern in an infinite stream of bits! 🔍

Given:
• A pattern array of 0s and 1s
• An InfiniteStream object with a next() method that reads one bit at a time

Goal: Return the first starting index where the pattern matches the bits read from the stream.

Example: If pattern = [1, 0] and the stream produces [0, 1, 0, 1, ...], the first match starts at index 1 (highlighting [1, 0]).

⚠️ Challenge: You can only read the stream forward - no going back! Once you call next(), that bit is consumed.

Input & Output

example_1.py — Basic Pattern Match

$ Input: pattern = [1, 0], stream = [0, 1, 0, 1, ...]

› Output: 1

💡 Note: The pattern [1, 0] first appears at index 1 in the stream [0, 1, 0, 1, ...]. The highlighted match is at positions 1-2.

example_2.py — Pattern at Start

$ Input: pattern = [0, 1], stream = [0, 1, 1, 0, ...]

› Output: 0

💡 Note: The pattern [0, 1] appears immediately at the start of the stream, so the answer is index 0.

example_3.py — Repeating Pattern

$ Input: pattern = [1, 1, 0], stream = [0, 1, 1, 1, 0, ...]

› Output: 2

💡 Note: The pattern [1, 1, 0] first matches starting at index 2: stream[2:5] = [1, 1, 0].

Visualization

Tap to expand

Understanding the Visualization

Listen to Stream

Receive signals one by one from the telegraph line

Smart Matching

Use pattern knowledge to avoid re-checking unnecessary signals

Handle Mismatches

When a mismatch occurs, jump back intelligently using the failure function

Find Pattern

Return the position when the complete pattern is detected

Key Takeaway

🎯 Key Insight: The KMP algorithm's failure function allows us to 'remember' partial matches and avoid redundant comparisons, making pattern matching in streams highly efficient even for complex patterns with repetitive elements.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

O(m) to build failure function, O(n) to process stream where n is stream position of first match

✓ Linear Growth

Space Complexity

O(m)

Space for failure function array of size m (pattern length)

✓ Linear Space

Constraints

1 ≤ pattern.length ≤ 2000
pattern[i] is either 0 or 1
The stream consists of infinite 0s and 1s
Important: You can only read the stream forward using next()

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses the KMP (Knuth-Morris-Pratt) algorithm with a preprocessing step to build a failure function. This allows us to efficiently match patterns in the infinite stream with O(n + m) time complexity, where n is the stream position and m is pattern length. The key insight is using the LPS array to avoid redundant comparisons when mismatches occur.

Common Approaches

Approach	Time	Space	Notes
✓ Rolling Hash + KMP (Optimal)	O(n + m)	O(m)	Use KMP algorithm with failure function for efficient pattern matching
Brute Force (Restart on Mismatch)	O(n * m)	O(m)	Check pattern at each position, restart completely on mismatch

Rolling Hash + KMP (Optimal) — Algorithm Steps

Build failure function (LPS array) for the pattern
Read bits from stream one by one
Use failure function to determine how far to backtrack on mismatch
When full pattern is matched, return the starting index
Continue until pattern is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build LPS Array

Create failure function for pattern [1,1,0]

Match Process

Use LPS to skip redundant comparisons

Smart Backtrack

On mismatch, jump back using LPS values

Find Match

Continue until full pattern is matched

Code -

solution.c — C

int* buildFailureFunction(int* pattern, int patternSize) {
    int* lps = (int*)calloc(patternSize, sizeof(int));
    int length = 0;
    int i = 1;
    
    while (i < patternSize) {
        if (pattern[i] == pattern[length]) {
            length++;
            lps[i] = length;
            i++;
        } else {
            if (length != 0) {
                length = lps[length - 1];
            } else {
                lps[i] = 0;
                i++;
            }
        }
    }
    return lps;
}

int findPattern(InfiniteStream* stream, int* pattern, int patternSize) {
    if (patternSize == 0) return 0;
    
    int* lps = buildFailureFunction(pattern, patternSize);
    int streamPos = 0;
    int patternPos = 0;
    
    while (1) {
        int bit = stream->next(stream);
        
        if (pattern[patternPos] == bit) {
            patternPos++;
            
            if (patternPos == patternSize) {
                free(lps);
                return streamPos - patternSize + 1;
            }
        } else if (patternPos > 0) {
            patternPos = lps[patternPos - 1];
            continue;
        }
        
        streamPos++;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

O(m) to build failure function, O(n) to process stream where n is stream position of first match

✓ Linear Growth

Space Complexity

O(m)

Space for failure function array of size m (pattern length)

✓ Linear Space

Constraints

1 ≤ pattern.length ≤ 2000
pattern[i] is either 0 or 1
The stream consists of infinite 0s and 1s
Important: You can only read the stream forward using next()

34.2K Views

Medium Frequency

~25 min Avg. Time

956 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

Rolling Hash + KMP (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler