Find Pattern in Infinite Stream I

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].

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()

Visualization

Tap to expand

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

✓ Math

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

Optimized

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

Brute Force (Restart on Mismatch)

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

The naive approach reads from the stream and attempts to match the pattern at each starting position. When a mismatch occurs, we restart the pattern matching from the beginning. However, since we can't rewind the stream, we need to keep a buffer of recent bits.

Rolling Hash + KMP (Optimal)

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

The optimal approach uses the KMP (Knuth-Morris-Pratt) algorithm which preprocesses the pattern to create a failure function. This allows us to avoid redundant comparisons when a mismatch occurs by utilizing information about the pattern's structure.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int l, int r) {
    // Find all primes up to sqrt(r) using Sieve of Eratosthenes
    int maxPrime = 1;
    while (maxPrime * maxPrime <= r) {
        maxPrime++;
    }
    maxPrime--; // Now maxPrime is floor(sqrt(r))
    
    if (maxPrime < 2) {
        // No primes to check
        return r - l + 1;
    }
    
    bool* isPrime = (bool*)malloc((maxPrime + 1) * sizeof(bool));
    for (int i = 0; i <= maxPrime; i++) {
        isPrime[i] = true;
    }
    isPrime[0] = isPrime[1] = false;
    
    for (int i = 2; i * i <= maxPrime; i++) {
        if (isPrime[i]) {
            for (int j = i * i; j <= maxPrime; j += i) {
                isPrime[j] = false;
            }
        }
    }
    
    // Count special numbers (squares of primes) in range [l, r]
    int specialCount = 0;
    for (int p = 2; p <= maxPrime; p++) {
        if (isPrime[p]) {
            long long square = (long long)p * p;
            if (l <= square && square <= r) {
                specialCount++;
            }
        }
    }
    
    free(isPrime);
    // Return count of non-special numbers
    return (r - l + 1) - specialCount;
}

int main() {
    int l, r;
    scanf("%d", &l);
    scanf("%d", &r);
    printf("%d\n", solution(l, r));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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