The "streak problem" in Data Structures and Algorithms (DSA) generally refers to
coding challenges that require finding the longest sequence of consecutive
occurrences of a specific element or pattern within a given dataset, such as an array, a
string, or a series of user activities.
Common variations of the "streak problem" encountered in DAA include:
Max Consecutive Ones: Given a binary array, find the maximum number of
consecutive 1 s in the array. This is one of the most basic and common forms of the
problem.
Longest Consecutive Sequence: Given an unsorted array of integers, find the length
of the longest consecutive elements sequence (e.g., [1, 2, 3, 4] is a sequence of
length 4). This problem often uses hash sets for optimal performance.
Longest Square Streak in an Array: Find the length of the longest subsequence
where each element (after sorting) is the square of the previous number.
User Activity Streaks: Problems (like those on HackerEarth) that require calculating
the maximum number of continuous correct submissions by a user, potentially with
constraints like counting multiple correct submissions to the same problem only once.
General Approach to Solving Streak Problems
A common approach, especially for simple linear data like arrays or activity logs,
involves a single pass (iteration) using two variables:
1. current_streak : Tracks the length of the current ongoing streak.
2. max_streak : Stores the maximum streak length found so far.
Algorithm Outline:
Initialize both current_streak and max_streak to 0.
Iterate through the data (e.g., an array or list of submissions).
If the current element matches the streak condition:
o Increment current_streak .
o Update max_streak if current_streak is greater.
If the current element does not match the condition:
o Reset current_streak to 0.
After the loop completes, return max_streak .
More complex "streak problems", such as finding longest subsequences (not
necessarily consecutive in the original input), often require more advanced techniques
like dynamic programming or recursion with memoization.
A summary of a common kind of “streaks” problem, along with what “streak” means, when and
how to use DSA / DP / simple loops to solve it. If you meant a different problem, you can share
the exact statement — I can tailor accordingly.
✅ What is a “streak” (in this context)
Often by “streak” we refer to a subarray / subsequence where certain condition holds
consecutively. Examples:
A strictly increasing consecutive sub array: each element is strictly greater than the
previous one.
A “consecutive subsequence” of integers: a subsequence (not necessarily in sorted order)
whose elements form a consecutive integer sequence when sorted.
More generally, a “streak” may mean “maximal run” of something — e.g. in string
problems, the maximum number of identical characters in a row (for example LeetCode
1446: Consecutive Characters).
In your class, “streaks problem” likely refers to finding longest such “streak” (increasing,
consecutive, or identical-run) in a sequence/array/string.
📄 Common Variants of “Streak” Problems
Variant What you want to find Typical approach /
Complexity
Longest continuous increasing Length of longest strictly Single pass, maintain counter
subarray — e.g. subarray where increasing contiguous — O(n) time, O(1) space
each a[i] < a[i+1] subarray AlgoMonster+1
Longest strictly increasing Same as above — Same as above; just scan and
consecutive subsequence contiguous and increasing reset when break Chegg+1
(adjacent in array)
Longest “consecutive integer” Length of longest Use hash-set + scan / hash +
subsequence (any order) — find subsequence whose checking neighbors — typical
longest set of numbers that form values can be rearranged O(n) time. GeeksforGeeks+1
e.g. 4,5,6,7 even if scattered to consecutive ints
Longest increasing subsequence Max length of DP O(n²) or optimized O(n log
(not necessarily consecutive subsequence (not n) using patience-sorting /
indices or integers) — classic necessarily contiguous) binary search. CP
Longest Increasing Subsequence with strictly increasing Algorithms+1
(LIS) values
🧮 Coding Template: Longest Continuous Increasing Subarray
Here’s a simple pseudocode (or in Python) for finding longest “streak” of strictly increasing
contiguous subarray (common streak problem).
def longest_increasing_streak(arr):
if not arr:
return 0
max_len = 1
curr_len = 1
for i in range(1, len(arr)):
if arr[i] > arr[i-1]:
curr_len += 1
if curr_len > max_len:
max_len = curr_len
else:
curr_len = 1
return max_len
Explanation:
Traverse from start to end once — O(n).
Maintain curr_len: current increasing streak length; reset when streak breaks.
Maintain max_len: maximum streak seen so far.
This solves the “longest continuous strictly increasing subsequence (subarray)” problem. This is
described as “longest continuous increasing subsequence” in common algorithm resources.
⚠️Common Pitfalls / What to Clarify in Problem Statement
When your teacher or assignment says “streak / consecutive / subsequence”, you need to check:
1. Is it contiguous (subarray) or not (subsequence)?
o If contiguous, you use the “single pass / reset” approach.
o If not, problem becomes harder (e.g. classic LIS).
2. What does “increasing” mean? Strictly increasing? Or “consecutive integer
o “Strictly increasing” ⇒ a[i] < a[i+1].
values”?
o “Consecutive integers” ⇒ values differ by exactly 1 (or form a continuous integer
range). That is a different problem — e.g. “longest consecutive sequence”.
3. Should duplicates be considered / filtered out?
o Duplicate values can break “strictly increasing”.
o For “consecutive integer” subsequence, duplicates may need special handling.
4. Subarray vs Subsequence vs Set-based consecutive-value set.
Because of these ambiguities, many “streak” problems in DAA/DSA courses test your ability to
interpret and implement carefully.
🎯 Answer Outline (for a “typical streak problem”)
If I were to formalize a streak problem statement and solve it:
Problem Statement (example):
Given an array of integers arr[], find the length of the longest strictly increasing contiguous
subarray (i.e. longest streak where arr[i] < arr[i+1] < arr[i+2] …).
Solution Idea: Use one-pass scan, maintain current streak length and maximum streak length.
Reset streak when break encountered. Time complexity O(n), space O(1).
Why this works: Because we only need to check adjacent pairs → no need for heavy DP or
subsequence selection. It’s greedy / scan-based.
If you want — I can give 3–4 sample “streak problems” (with input & expected output) + their
solutions (code in C++ / Java / Python) that cover different variants (continuous increasing,
consecutive integer subsequence, LIS) — this helps for exam / assignment preparation. Do you
want me to prepare that for you now?
