Longest Continuous Increasing Subsequence

Longest Continuous Increasing Subsequence - Problem

Array Easy

You're given an unsorted array of integers nums, and your task is to find the length of the longest continuous increasing subsequence (also known as a subarray).

A continuous increasing subsequence is a contiguous portion of the array where each element is strictly greater than the previous element. For example, in the array [1, 3, 2, 4, 5, 6], the longest continuous increasing subsequence is [2, 4, 5, 6] with length 4.

Key Points:

The subsequence must be continuous (adjacent elements in the original array)
Each element must be strictly greater than the previous one
Return the length, not the actual subsequence

This problem tests your ability to efficiently traverse an array while tracking streaks of increasing values.

Input & Output

example_1.py — Basic Increasing Sequence

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

› Output: 4

💡 Note: The entire array forms one continuous increasing subsequence: 1 < 3 < 6 < 7. Length = 4.

example_2.py — Mixed Sequence

$ Input: [2,2,2,2,2]

› Output: 1

💡 Note: All elements are equal, so no increasing subsequence of length > 1 exists. Each element forms a subsequence of length 1.

example_3.py — Multiple Increasing Segments

$ Input: [1,3,2,4,5,6]

› Output: 4

💡 Note: We have two increasing subsequences: [1,3] (length 2) and [2,4,5,6] (length 4). The longest has length 4.

Visualization

Tap to expand

Understanding the Visualization

Start tracking

Begin with day 1, current streak = 1 day

Price increases

When price goes up, extend the streak

Price decreases

When price drops, start a new streak

Keep best record

Always remember the longest streak found

Key Takeaway

🎯 Key Insight: We don't need to check all possible combinations - just track the current increasing streak and remember the longest one we've seen!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking each element once

✓ Linear Growth

Space Complexity

O(1)

Only using two integer variables to track lengths

✓ Linear Space

Constraints

0 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The subsequence must be strictly increasing (no equal elements)

Asked in

f Facebook 25 G Google 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses a single-pass linear scan with O(n) time complexity. We maintain two counters: current_length for the ongoing increasing streak and max_length for the best result found so far. As we iterate through the array, we increment the current length when elements increase and reset it when they don't, always updating our maximum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray to find the longest increasing one
One-Pass Linear Scan (Optimal)	O(n)	O(1)	Single pass through array tracking current and maximum streak lengths

Brute Force (Check All Subarrays) — Algorithm Steps

Start from each index i as a potential beginning of an increasing subsequence
From each starting point, expand rightward while elements are strictly increasing
Track the length of each valid increasing subsequence
Return the maximum length found across all starting positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from index 0

Check how far we can extend an increasing subsequence from position 0

Start from index 1

Check how far we can extend an increasing subsequence from position 1

Continue for all positions

Repeat for each starting position and track the maximum length

Code -

solution.c — C

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

int findLengthOfLCIS(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int maxLength = 1;
    
    // Try each starting position
    for (int i = 0; i < numsSize; i++) {
        int currentLength = 1;
        // Extend as far as possible from position i
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[j] > nums[j - 1]) {
                currentLength++;
            } else {
                break;
            }
        }
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums[count++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", findLengthOfLCIS(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting positions, we might check up to n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum lengths

✓ Linear Space

Constraints

0 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The subsequence must be strictly increasing (no equal elements)

28.5K Views

Medium Frequency

~12 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler