Find Pattern in Infinite Stream II - Practice Coding Problems

Find Pattern in Infinite Stream II - Problem

Pattern Matching in an Infinite Bit Stream

You are given a binary array pattern and an InfiniteStream object that represents an infinite stream of bits (0s and 1s). The stream provides a single method:

int next(): Reads and returns the next bit from the stream

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

For example, if pattern = [1, 0] and the stream contains [0, 1, 0, 1, 0, ...], the first match occurs at index 1 (where we see the subsequence [1, 0]).

Challenge: Since the stream is infinite and we can only read bits sequentially, we need an efficient algorithm that doesn't require storing the entire stream in memory.

Input & Output

example_1.py — Basic Pattern Match

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

› Output: 1

💡 Note: The pattern [1, 0] first appears starting at index 1 in the stream [0, 1, 0, 1, 0, ...]

example_2.py — Pattern at Beginning

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

› Output: 0

💡 Note: The pattern [1, 1, 0] appears immediately at the start of the stream

example_3.py — Single Bit Pattern

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

› Output: 2

💡 Note: The first occurrence of bit '1' is at index 2 in the stream

Visualization

Tap to expand

Understanding the Visualization

Setup Pattern Hash

Calculate hash value for the target pattern [1,0]

Initialize Window

Read first pattern.length bits from stream into sliding window

Rolling Hash Check

Compare current window hash with pattern hash

Slide Window

Remove oldest bit, add new bit, update hash in O(1)

Pattern Found

When hashes match and bits verify, return the starting position

Key Takeaway

🎯 Key Insight: Rolling hash allows us to efficiently search infinite streams by updating window hash in O(1) time, avoiding the need to store the entire stream while maintaining optimal performance.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n is the number of bits read until match found and m is pattern length. Each bit requires O(1) hash update.

✓ Linear Growth

Space Complexity

O(m)

Only store the current window of m bits (pattern length)

✓ Linear Space

Constraints

1 ≤ pattern.length ≤ 10⁴
pattern[i] is either 0 or 1
stream.next() returns either 0 or 1
The stream is guaranteed to contain the pattern
Memory constraint: Avoid storing the entire infinite stream

Asked in

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

The optimal solution uses a rolling hash technique to efficiently match patterns in the infinite stream. Instead of storing all stream bits, we maintain a sliding window of pattern length and update its hash in O(1) time as we read new bits. This achieves O(n + m) time complexity and O(m) space complexity, making it perfect for infinite streams where memory efficiency is crucial.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Pattern Matching	O(n*m)	O(n)	Store stream bits and check every possible starting position
Rolling Hash (Optimal)	O(n + m)	O(m)	Use rolling hash with sliding window for efficient pattern matching

Naive Pattern Matching — Algorithm Steps

Initialize an empty buffer to store stream bits
Read bits one by one from the stream
For each position i where we have enough bits, check if pattern matches at position i
Return the first position where complete pattern matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start reading bits into buffer

Check Position 0

Compare pattern with buffer starting at index 0

No Match

Pattern doesn't match, move to next position

Check Position 1

Compare pattern with buffer starting at index 1

Match Found

Pattern matches at position 1, return result

Code -

solution.c — C

int findPattern(InfiniteStream* stream, int* pattern, int patternLen) {
    if (patternLen == 0) return 0;
    
    int* buffer = malloc(1000000 * sizeof(int)); // Large buffer
    int position = 0;
    int bufferSize = 0;
    
    // Read initial bits
    while (bufferSize < patternLen) {
        buffer[bufferSize] = stream->next(stream);
        bufferSize++;
    }
    
    while (1) {
        // Check current window
        int matches = 1;
        for (int i = 0; i < patternLen; i++) {
            if (buffer[position + i] != pattern[i]) {
                matches = 0;
                break;
            }
        }
        
        if (matches) {
            free(buffer);
            return position;
        }
        
        // Read next bit and advance
        buffer[bufferSize] = stream->next(stream);
        bufferSize++;
        position++;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

Where n is the number of bits read and m is pattern length. We potentially check each position.

✓ Linear Growth

Space Complexity

O(n)

We store all bits read from the stream in a buffer

⚡ Linearithmic Space

Constraints

1 ≤ pattern.length ≤ 10⁴
pattern[i] is either 0 or 1
stream.next() returns either 0 or 1
The stream is guaranteed to contain the pattern
Memory constraint: Avoid storing the entire infinite stream

43.2K Views

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

Naive Pattern Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler