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

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

✓ Brute Force - Check All Subarrays

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

For each position in the array, start a new subsequence and count how many consecutive increasing elements we can find. Keep track of the maximum length found.

One Pass Sliding Window

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

Walk through the array once, maintaining a current increasing subsequence length. When the sequence breaks (current element ≤ previous), reset the current length and update the maximum.

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[100000];
    if (!fgets(line, sizeof(line), stdin)) return 1;
    
    int nums[10000];
    int size = 0;
    
    // Handle empty array
    if (strstr(line, "[]")) {
        printf("0\n");
        return 0;
    }
    
    char* ptr = line;
    while (*ptr && (*ptr == '[' || *ptr == ' ')) ptr++;
    
    char* token = strtok(ptr, ",]\n ");
    while (token != NULL && size < 10000) {
        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

✓ Linear 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