Longest Continuous Increasing Subsequence
We need to keep track of two variables: the current length of the increasing subsequence and the maximum length of such a subsequence found so far. We iterate through the array and for each number, we check if it’s greater than the previous number. If it is, we increase the current length. If it’s not, we reset the current length to 1. We update the maximum length each time we increase the current length.
Let’s implement this approach in Python:


We start by initializing max_length
and current_length
to 1. We then iterate over the array starting from the second element. If the current element is greater than the previous one, we increment current_length
and update max_length
if necessary. If the current element is not greater than the previous one, we reset current_length
to 1.
The time complexity of this solution is O(n), where n is the number of elements in the array, because we perform a single pass through the array. The space complexity is O(1), because we use a constant amount of space to store the current and maximum lengths.
“Longest Continuous Increasing Subsequence” can be mapped to “Maximum Length of Pair Chain”.
In “Longest Continuous Increasing Subsequence”, you’re given an unsorted array of integers and need to find the length of the longest continuous increasing subsequence (subarray).
In the “Maximum Length of Pair Chain”, you’re given n pairs where each pair in the form of (a, b) could be chained together to form a chain. You need to find the maximum number of pairs you can chain together, where ‘b’ of one pair is less than ‘a’ of the next pair.
The isomorphism in these problems is about identifying the longest chain or sequence. While the first problem deals with an increasing sequence of numbers, the second one works with pairs, where the second element of a pair is less than the first element of the next pair.
“Longest Continuous Increasing Subsequence” is simpler since it involves working with individual numbers, while “Maximum Length of Pair Chain” involves dealing with pairs and understanding the relationship between them, which adds a layer of complexity.


Problem Classification
This problem belongs to the area of Array Processing and Subsequence Problems.
Here are the ‘What’ components of the problem:
An unsorted array of integers, which is the primary input.
The concept of a continuous increasing subsequence which is defined by two indices
l
andr
(l
<r
) such that it is[nums[l], nums[l + 1], ..., nums[r  1], nums[r]]
and for eachl <= i < r
,nums[i] < nums[i + 1]
. This essentially means a subset of numbers in the array that are in strictly increasing order.The output required is the length of the longest continuous increasing subsequence. This means we are not interested in the subsequence itself, but only in its length.
Based on these components, this problem can be further classified as an Optimization Problem, as we are trying to maximize the length of the increasing subsequence. It also falls under Combinatorial Search Problem because we are examining possible combinations of elements in the array to identify the longest increasing subsequence.
Given its constraints and requirements, solutions to this problem would likely involve techniques related to Iterative Search, Dynamic Programming, or Sliding Window.
Language Agnostic Coding Drills
 Dissect the Code
This piece of code involves several distinct programming concepts:
Function definition: The code defines a function
findLengthOfLCIS
with a single parameter (nums
).List/Data Structure Manipulation: The function processes a list of integers (
nums
).Conditional Statements: The code includes an
if
statement to check a condition (ifnums[i]
is greater thannums[i1]
) and anelse
statement for when the condition is not met.Loops: The code uses a
for
loop to iterate over the elements in the list.Variable assignment and updating: The code creates and updates variables (
cur_len
,max_len
) to keep track of the current and maximum lengths of the continuous increasing subsequences.Return statement: The function ends with a return statement that outputs the result.
 List of Concepts (in order of increasing difficulty)
a) Variable Assignment and Updating: This is a fundamental concept in almost all programming languages. It involves creating variables and updating their values.
b) Function Definition: This involves understanding how to encapsulate a piece of code into a reusable function. This concept is slightly more advanced than variable assignment but is still a foundational programming concept.
c) Conditional Statements: This involves understanding how to use if
and else
statements to control the flow of a program based on certain conditions.
d) Loops: This is a slightly more advanced concept and involves understanding how to use loops to repeatedly execute a block of code.
e) List/Data Structure Manipulation: This requires understanding how to interact with and manipulate data in structured formats like lists or arrays.
f) Return Statement: Understanding when and how to use the return statement in a function can be considered a more intermediate level concept, as it requires understanding the flow of data in and out of functions.
 Problemsolving Approach
The overall approach to solving this problem involves iterating through the given array, tracking the length of the current increasing subsequence and the maximum length found so far, and adjusting these values based on the comparison of consecutive elements in the array.
The Variable Assignment and Updating concept is used to initialize and update cur_len
and max_len
.
The Function Definition concept allows the creation of the findLengthOfLCIS
function to encapsulate the solution.
Conditional Statements are used to check if the current element in the array is greater than the previous one, in which case cur_len
is increased, else cur_len
is reset to 1 and max_len
is updated if necessary.
The Loops concept is used to iterate through the array.
The List/Data Structure Manipulation concept is utilized to access elements in the array.
Finally, the Return Statement is used to return the maximum length of the continuous increasing subsequence found during the process.
Targeted Drills in Python
 Coding Drills for General Concepts
Let’s create drills for each of the general concepts we identified:
a) Variable Assignment and Updating


b) Function Definition


c) Conditional Statements


d) Loops


e) List/Data Structure Manipulation


f) Return Statement


 Coding Drills for ProblemSpecific Concepts
For this problem, the specific concept we need to understand is how to keep track of the longest increasing subsequence in an array. Let’s create a drill for this:


 Integrating the Drills
To solve the initial problem, we can integrate these drills as follows:
 Begin by defining the function
findLengthOfLCIS(nums)
.  Within this function, initialize variables
cur_len
andmax_len
to 1.  Use a for loop to iterate over the elements in
nums
.  Within the loop, use an ifelse statement to check if the current element is greater than the previous one.
 If it is, increase
cur_len
by 1 and updatemax_len
to be the maximum ofmax_len
andcur_len
.  If it isn’t, reset
cur_len
to 1.  After the loop, return
max_len
, which is the length of the longest continuous increasing subsequence.