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 &lt; r) such that it is [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] and for each l &lt;= i &lt; r, nums[i] &lt; nums[i + 1].

&nbsp;
Example 1:

Input: nums = [1,3,5,4,7]
Output: 3
Explanation: The longest continuous increasing subsequence is [1,3,5] with length 3.
Even though [1,3,5,7] is an increasing subsequence, it is not continuous as elements 5 and 7 are separated by element
4.


Example 2:

Input: nums = [2,2,2,2,2]
Output: 1
Explanation: The longest continuous increasing subsequence is [2] with length 1. Note that it must be strictly
increasing.


&nbsp;
Constraints:


	1 &lt;= nums.length &lt;= 104
	-109 &lt;= nums[i] &lt;= 109


class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        count=0
        for i in range(len(nums)):
            a=nums[i]
            c=1
            for j in range(i+1, len(nums)):
                if nums[j]>a:
                    a=nums[j]
                    c+=1
                else:
                    break
            count=max(count, c)
        return count
class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int count = 1;
        int maxCount = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                count++;
            } else {
                maxCount = Math.max(count, maxCount);
                count = 1;
            }
        }
        maxCount = Math.max(count, maxCount);
        return maxCount;
    }
}
class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int maxLength = 1;
        int currLength = 1;
        int i = 0;
        int j = 1;
        
        while(j<nums.size()){
            if(nums[j] > nums[i]){
                currLength++;
                i++;
                j++;
                if(currLength > maxLength) maxLength = currLength;
            } else{
                currLength = 1;
                i = j;
                j++;
            }
        }
        return maxLength;
    }
};
var findLengthOfLCIS = function(nums) {
    let res = 0;
    let curr = 1;
    
    nums.forEach((num, idx) => {
        if (num < nums[idx + 1]) {
            curr++;
        }
        else curr = 1;
        
        res = Math.max(res, curr);
    })
    
    return res;
};
Longest Continuous Increasing Subsequence