Find Consecutive Integers from a Data Stream

Find Consecutive Integers from a Data Stream - Problem

Hash Table Design Queue Counting Data Stream Medium

Data Stream Consecutive Checker

Imagine you're monitoring a data stream in real-time and need to detect when a specific pattern occurs. Your task is to implement a DataStream class that tracks whether the last k integers in the stream are all equal to a target value.

The class should support:
• DataStream(int value, int k) - Initialize with target value and window size k
• boolean consec(int num) - Add num to stream and return true if the last k numbers all equal the target value

Key Point: If fewer than k numbers have been processed, always return false.

Example:
DataStream ds = new DataStream(4, 3);
ds.consec(4); // false (only 1 number, need 3)
ds.consec(4); // false (only 2 numbers, need 3)
ds.consec(4); // true (last 3 numbers are all 4)
ds.consec(3); // false (last 3 numbers: 4,4,3)

Input & Output

example_1.py — Basic Usage

$ Input: DataStream(4, 3) consec(4) → consec(4) → consec(4) → consec(3)

› Output: [false, false, true, false]

💡 Note: First two calls return false (need 3 numbers). Third call returns true (last 3 are all 4). Fourth call returns false (last 3 are 4,4,3).

example_2.py — Reset Pattern

$ Input: DataStream(1, 4) consec(1) → consec(1) → consec(1) → consec(2) → consec(1) → consec(1) → consec(1) → consec(1)

› Output: [false, false, false, false, false, false, false, true]

💡 Note: Counter resets to 0 when 2 appears, then rebuilds. Need 4 consecutive 1's to return true.

example_3.py — k=1 Edge Case

$ Input: DataStream(5, 1) consec(5) → consec(3) → consec(5)

› Output: [true, false, true]

💡 Note: With k=1, every number that matches the target immediately returns true.

Visualization

Tap to expand

Understanding the Visualization

Package Arrives

New number enters the data stream

Quality Check

Compare with target value - match or not?

Update Counter

Increment streak counter or reset to 0

Alert Decision

Trigger alert if consecutive count reaches k

Key Takeaway

🎯 Key Insight: We don't need to store the entire stream history - just count consecutive matches!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each consec() call does constant work - just update counter

✓ Linear Growth

Space Complexity

O(1)

Only store target value, k, and consecutive count

✓ Linear Space

Constraints

1 ≤ value, num ≤ 10⁹
1 ≤ k ≤ 10⁵
At most 10⁵ calls to consec
Time limit: 1000ms per test case

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 25 f Meta 22

The optimal solution uses a simple counter to track consecutive matches in O(1) time per operation. Instead of storing all stream elements, we maintain only the target value, window size k, and a count of consecutive matches. When a new number matches the target, increment the counter; otherwise reset to 0. Return true when counter ≥ k. This approach is perfect for streaming data with O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Store All Elements)	O(k)	O(n)	Store all stream elements and check last k every time
Sliding Window with Counter (Optimal)	O(1)	O(1)	Use a counter to track consecutive matches in O(1) time per operation

Brute Force (Store All Elements) — Algorithm Steps

Maintain a list to store all received numbers
On each consec() call, append the new number
Check if we have at least k numbers
If yes, examine the last k numbers to see if they all equal target value

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Number

Append new number to the growing list

Check Length

Verify we have at least k numbers

Scan Last K

Check if last k numbers match target value

Code -

solution.c — C

typedef struct {
    int value;
    int k;
    int* stream;
    int size;
    int capacity;
} DataStream;

DataStream* dataStreamCreate(int value, int k) {
    DataStream* ds = (DataStream*)malloc(sizeof(DataStream));
    ds->value = value;
    ds->k = k;
    ds->capacity = 1000;
    ds->stream = (int*)malloc(ds->capacity * sizeof(int));
    ds->size = 0;
    return ds;
}

bool dataStreamConsec(DataStream* ds, int num) {
    ds->stream[ds->size++] = num;
    
    if (ds->size < ds->k) {
        return false;
    }
    
    // Check last k elements
    for (int i = ds->size - ds->k; i < ds->size; i++) {
        if (ds->stream[i] != ds->value) {
            return false;
        }
    }
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

Each consec() call requires checking the last k elements

✓ Linear Growth

Space Complexity

O(n)

Store all n numbers received in the stream

⚡ Linearithmic Space

Constraints

1 ≤ value, num ≤ 10⁹
1 ≤ k ≤ 10⁵
At most 10⁵ calls to consec
Time limit: 1000ms per test case

42.4K Views

Medium-High Frequency

~12 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 (Store All Elements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler