Find Pattern in Infinite Stream II

Find Pattern in Infinite Stream II - Problem

You are given a binary array pattern and an object stream of class InfiniteStream representing a 0-indexed infinite stream of bits.

The class InfiniteStream contains the following function:

int next(): Reads a single bit (which is either 0 or 1) from the stream and returns it.

Return the first starting index where the pattern matches the bits read from the stream. For example, if the pattern is [1, 0], the first match is the highlighted part in the stream [0, 1, 0, 1, ...].

Note: You can only read each bit from the stream once, and you cannot go back to re-read previous bits.

Input & Output

Example 1 — Basic Pattern Match

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

› Output: 1

💡 Note: Pattern [1,0] first appears at index 1 in the stream: [0,1,0,1,...]. The bits at positions 1 and 2 are [1,0].

Example 2 — Pattern at Start

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

› Output: 0

💡 Note: Pattern [1,1] appears immediately at the beginning of the stream at index 0.

Example 3 — Longer Pattern

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

› Output: 1

💡 Note: Pattern [0,0,1] first appears at index 1: stream positions 1,2,3 contain [0,0,1].

Constraints

1 ≤ pattern.length ≤ 10⁴
pattern[i] is either 0 or 1
stream consists only of 0s and 1s
stream is guaranteed to contain the pattern

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to use efficient string matching algorithms like KMP or rolling hash since we can only read each bit once. The optimal approach uses KMP algorithm for O(n + m) time complexity where n is the number of bits read and m is pattern length. Time: O(n + m), Space: O(m).

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Sort First

⏱️ Time: N/A Space: N/A

Bit Manipulation

⏱️ Time: N/A Space: N/A

Brute Force with Buffer

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

Maintain a sliding buffer of the last pattern.length bits from the stream. At each new bit read, check if the current buffer matches the pattern exactly.

Rolling Hash

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

Compute a rolling hash of the current window and compare it with the pattern's hash. Use polynomial rolling hash to update the hash in constant time as new bits arrive.

Sliding Window with KMP

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

Implement the KMP (Knuth-Morris-Pratt) pattern matching algorithm. When a mismatch occurs, use the failure function to skip ahead intelligently instead of restarting pattern comparison from the beginning.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler