Longest Continuous Increasing Subsequence

Longest Continuous Increasing Subsequence - Problem

Array Easy

Given an unsorted array of integers nums, return the length of the longest continuous increasing subsequence (i.e. subarray). The subsequence must be strictly increasing.

A continuous increasing subsequence is defined by two indices l and r (l < r) such that it is [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] and for each l <= i < r, nums[i] < nums[i + 1].

Input & Output

Example 1 — Basic Increasing Sequence

$ Input: nums = [1,3,6,7]

› Output: 4

💡 Note: The entire array is continuously increasing: 1 < 3 < 6 < 7, so the length is 4

Example 2 — Mixed Sequence

$ Input: nums = [2,2,2,2,2]

› Output: 1

💡 Note: All elements are equal, no strictly increasing subsequence longer than 1 exists

Example 3 — Multiple Increasing Parts

$ Input: nums = [1,3,6,2,8]

› Output: 3

💡 Note: Longest increasing subsequence is [1,3,6] with length 3. The sequence [2,8] has length 2.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array with mixed increasing and decreasing parts

Find Sequences

Identify all continuous increasing parts

Return Length

Length of the longest increasing part

Key Takeaway

🎯 Key Insight: Track current length while scanning, reset when sequence breaks, keep maximum

Asked in

f Facebook 35 🍎 Apple 28

The key insight is to track the current increasing subsequence length while walking through the array. When the sequence breaks (current ≤ previous), reset the counter. Best approach is the one-pass sliding window method. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Subarrays	O(n²)	O(1)	Check every possible starting position and count increasing elements
One Pass Sliding Window	O(n)	O(1)	Single pass tracking current and maximum subsequence length

Brute Force - Check All Subarrays — Algorithm Steps

For each starting index i
Count consecutive increasing elements from i
Update maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at each index

Try every position as starting point

Count increasing

Count consecutive increasing elements

Track maximum

Keep the longest length found

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int maxLength = 1;
    
    for (int i = 0; i < numsSize; i++) {
        int currentLength = 1;
        int j = i;
        while (j + 1 < numsSize && nums[j] < nums[j + 1]) {
            currentLength++;
            j++;
        }
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop runs n times, inner counting can run up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a few variables for counting

✓ Linear Space

32.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler