Mutating counts without cleanup
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.
Move from brute-force thinking to an efficient approach using hash map strategy.
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.Example 1:
Input
["DataStream", "consec", "consec", "consec", "consec"]
[[4, 3], [4], [4], [4], [3]]
Output
[null, false, false, true, false]
Explanation
DataStream dataStream = new DataStream(4, 3); //value = 4, k = 3
dataStream.consec(4); // Only 1 integer is parsed, so returns False.
dataStream.consec(4); // Only 2 integers are parsed.
// Since 2 is less than k, returns False.
dataStream.consec(4); // The 3 integers parsed are all equal to value, so returns True.
dataStream.consec(3); // The last k integers parsed in the stream are [4,4,3].
// Since 3 is not equal to value, it returns False.
Constraints:
1 <= value, num <= 1091 <= k <= 105105 calls will be made to consec.Problem summary: 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.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Hash Map · Design
["DataStream","consec","consec","consec","consec"] [[4,3],[4],[4],[4],[3]]
number-of-zero-filled-subarrays)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2526: Find Consecutive Integers from a Data Stream
class DataStream {
private int cnt;
private int val;
private int k;
public DataStream(int value, int k) {
val = value;
this.k = k;
}
public boolean consec(int num) {
cnt = num == val ? cnt + 1 : 0;
return cnt >= k;
}
}
/**
* Your DataStream object will be instantiated and called as such:
* DataStream obj = new DataStream(value, k);
* boolean param_1 = obj.consec(num);
*/
// Accepted solution for LeetCode #2526: Find Consecutive Integers from a Data Stream
type DataStream struct {
val, k, cnt int
}
func Constructor(value int, k int) DataStream {
return DataStream{value, k, 0}
}
func (this *DataStream) Consec(num int) bool {
if num == this.val {
this.cnt++
} else {
this.cnt = 0
}
return this.cnt >= this.k
}
/**
* Your DataStream object will be instantiated and called as such:
* obj := Constructor(value, k);
* param_1 := obj.Consec(num);
*/
# Accepted solution for LeetCode #2526: Find Consecutive Integers from a Data Stream
class DataStream:
def __init__(self, value: int, k: int):
self.val, self.k = value, k
self.cnt = 0
def consec(self, num: int) -> bool:
self.cnt = 0 if num != self.val else self.cnt + 1
return self.cnt >= self.k
# Your DataStream object will be instantiated and called as such:
# obj = DataStream(value, k)
# param_1 = obj.consec(num)
// Accepted solution for LeetCode #2526: Find Consecutive Integers from a Data Stream
// Rust example auto-generated from java reference.
// Replace the signature and local types with the exact LeetCode harness for this problem.
impl Solution {
pub fn rust_example() {
// Port the logic from the reference block below.
}
}
// Reference (java):
// // Accepted solution for LeetCode #2526: Find Consecutive Integers from a Data Stream
// class DataStream {
// private int cnt;
// private int val;
// private int k;
//
// public DataStream(int value, int k) {
// val = value;
// this.k = k;
// }
//
// public boolean consec(int num) {
// cnt = num == val ? cnt + 1 : 0;
// return cnt >= k;
// }
// }
//
// /**
// * Your DataStream object will be instantiated and called as such:
// * DataStream obj = new DataStream(value, k);
// * boolean param_1 = obj.consec(num);
// */
// Accepted solution for LeetCode #2526: Find Consecutive Integers from a Data Stream
class DataStream {
private val: number;
private k: number;
private cnt: number;
constructor(value: number, k: number) {
this.val = value;
this.k = k;
this.cnt = 0;
}
consec(num: number): boolean {
this.cnt = this.val === num ? this.cnt + 1 : 0;
return this.cnt >= this.k;
}
}
/**
* Your DataStream object will be instantiated and called as such:
* var obj = new DataStream(value, k)
* var param_1 = obj.consec(num)
*/
Use this to step through a reusable interview workflow for this problem.
Use a simple list or array for storage. Each operation (get, put, remove) requires a linear scan to find the target element — O(n) per operation. Space is O(n) to store the data. The linear search makes this impractical for frequent operations.
Design problems target O(1) amortized per operation by combining data structures (hash map + doubly-linked list for LRU, stack + min-tracking for MinStack). Space is always at least O(n) to store the data. The challenge is achieving constant-time operations through clever structure composition.
Review these before coding to avoid predictable interview regressions.
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.