Find Consecutive Integers from a Data Stream

Find Consecutive Integers from a Data Stream - Problem

Hash Table Design Queue Counting Data Stream Medium

For a stream of integers, implement a data structure that checks if the last k integers parsed in the stream are equal to value.

Implement the DataStream class:

DataStream(int value, int k) Initializes the object with an empty integer stream and the two integers value and k.
boolean consec(int num) Adds num to the stream of integers. Returns true if the last k integers are equal to value, and false otherwise. If there are less than k integers, the condition does not hold true, so returns false.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["DataStream", "consec", "consec", "consec", "consec"], params = [[4, 3], [4], [3], [5], [4]]

› Output: [null, false, false, false, false]

💡 Note: Initialize with value=4, k=3. Add 4 (count=1<3, false), add 3 (count=0<3, false), add 5 (count=0<3, false), add 4 (count=1<3, false)

Example 2 — Consecutive Match

$ Input: operations = ["DataStream", "consec", "consec", "consec", "consec"], params = [[4, 3], [4], [4], [4], [3]]

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

💡 Note: After three consecutive 4s, count=3≥k=3 returns true. Adding 3 resets count=0, returns false

Example 3 — Edge Case k=1

$ Input: operations = ["DataStream", "consec", "consec"], params = [[5, 1], [5], [6]]

› Output: [null, true, false]

💡 Note: With k=1, first matching number immediately returns true. Non-matching number returns false

Constraints

1 ≤ value ≤ 10⁹
1 ≤ k ≤ 10⁵
1 ≤ num ≤ 10⁹
At most 10⁵ calls to consec

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is to track consecutive matching count instead of storing all numbers. The optimal counter-based approach uses O(1) time per operation and O(1) space by incrementing a counter for matches and resetting it for non-matches.

Common Approaches

✓ Heap

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

Counter-Based Approach

⏱️ Time: O(1) Space: O(1)

Use a simple counter to track how many consecutive numbers match the target value. Reset counter when a non-matching number arrives.

Sliding Window with Queue

⏱️ Time: O(k) Space: O(k)

Maintain a sliding window of exactly k elements using a queue. When the window is full and all elements match the target, return true.

Store All Numbers

⏱️ Time: O(k) Space: O(n)

Keep a list of all numbers received so far. For each new number, check if the last k numbers all equal the target value.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
    int isMaxHeap;
} Heap;

Heap* createHeap(int capacity, int isMaxHeap) {
    Heap* heap = (Heap*)malloc(sizeof(Heap));
    heap->data = (int*)malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    heap->isMaxHeap = isMaxHeap;
    return heap;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(Heap* heap, int idx) {
    if (idx == 0) return;
    int parent = (idx - 1) / 2;
    
    if (heap->isMaxHeap) {
        if (heap->data[idx] > heap->data[parent]) {
            swap(&heap->data[idx], &heap->data[parent]);
            heapifyUp(heap, parent);
        }
    } else {
        if (heap->data[idx] < heap->data[parent]) {
            swap(&heap->data[idx], &heap->data[parent]);
            heapifyUp(heap, parent);
        }
    }
}

void heapifyDown(Heap* heap, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int target = idx;
    
    if (heap->isMaxHeap) {
        if (left < heap->size && heap->data[left] > heap->data[target])
            target = left;
        if (right < heap->size && heap->data[right] > heap->data[target])
            target = right;
    } else {
        if (left < heap->size && heap->data[left] < heap->data[target])
            target = left;
        if (right < heap->size && heap->data[right] < heap->data[target])
            target = right;
    }
    
    if (target != idx) {
        swap(&heap->data[idx], &heap->data[target]);
        heapifyDown(heap, target);
    }
}

void heapPush(Heap* heap, int val) {
    if (heap->size >= heap->capacity) {
        heap->capacity *= 2;
        heap->data = (int*)realloc(heap->data, heap->capacity * sizeof(int));
    }
    heap->data[heap->size] = val;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int heapPop(Heap* heap) {
    if (heap->size == 0) return 0;
    int result = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    heapifyDown(heap, 0);
    return result;
}

int heapTop(Heap* heap) {
    return heap->size > 0 ? heap->data[0] : 0;
}

typedef struct {
    Heap* small; // max heap
    Heap* large; // min heap
} MedianFinder;

MedianFinder* medianFinderCreate() {
    MedianFinder* mf = (MedianFinder*)malloc(sizeof(MedianFinder));
    mf->small = createHeap(1000, 1); // max heap
    mf->large = createHeap(1000, 0); // min heap
    return mf;
}

void medianFinderAddNum(MedianFinder* obj, int num) {
    heapPush(obj->small, num);
    
    if (obj->small->size > 0 && obj->large->size > 0 && heapTop(obj->small) > heapTop(obj->large)) {
        int val = heapPop(obj->small);
        heapPush(obj->large, val);
    }
    
    if (obj->small->size > obj->large->size + 1) {
        int val = heapPop(obj->small);
        heapPush(obj->large, val);
    }
    if (obj->large->size > obj->small->size + 1) {
        int val = heapPop(obj->large);
        heapPush(obj->small, val);
    }
}

double medianFinderFindMedian(MedianFinder* obj) {
    if (obj->small->size > obj->large->size) {
        return (double)heapTop(obj->small);
    }
    if (obj->large->size > obj->small->size) {
        return (double)heapTop(obj->large);
    }
    return (heapTop(obj->small) + heapTop(obj->large)) / 2.0;
}

void medianFinderFree(MedianFinder* obj) {
    free(obj->small->data);
    free(obj->small);
    free(obj->large->data);
    free(obj->large);
    free(obj);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    MedianFinder* mf = medianFinderCreate();
    
    printf("[");
    int first = 1;
    
    char* token = strtok(line, ",");
    while (token != NULL) {
        if (strstr(token, "MedianFinder")) {
            if (!first) printf(",");
            printf("null");
            first = 0;
        } else if (strstr(token, "addNum")) {
            if (!first) printf(",");
            printf("null");
            first = 0;
        } else if (strstr(token, "findMedian")) {
            if (!first) printf(",");
            double median = medianFinderFindMedian(mf);
            printf("%.1f", median);
            first = 0;
        }
        token = strtok(NULL, ",");
    }
    
    printf("]\n");
    medianFinderFree(mf);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

18.4K Views

Medium Frequency

~15 min Avg. Time

385 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