##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/674.html

# 674. Longest Continuous Increasing Subsequence (Easy)

Given an unsorted array of integers, find the length of longest continuous increasing subsequence (subarray).

Example 1:

Input: [1,3,5,4,7]
Output: 3
Explanation: The longest continuous increasing subsequence is [1,3,5], its length is 3.
Even though [1,3,5,7] is also an increasing subsequence, it's not a continuous one where 5 and 7 are separated by 4.


Example 2:

Input: [2,2,2,2,2]
Output: 1
Explanation: The longest continuous increasing subsequence is [2], its length is 1.


Note: Length of the array will not exceed 10,000.

Companies:

Related Topics:
Array

Similar Questions:

## Solution 1.

• class Solution {
public int findLengthOfLCIS(int[] nums) {
if (nums == null || nums.length == 0)
return 0;
int maxLength = 1;
int increaseLength = 1;
int length = nums.length;
for (int i = 1; i < length; i++) {
if (nums[i] > nums[i - 1])
increaseLength++;
else {
maxLength = Math.max(maxLength, increaseLength);
increaseLength = 1;
}
}
maxLength = Math.max(maxLength, increaseLength);
return maxLength;
}
}

############

class Solution {
public int findLengthOfLCIS(int[] nums) {
int res = 1;
for (int i = 1, f = 1; i < nums.length; ++i) {
f = 1 + (nums[i - 1] < nums[i] ? f : 0);
res = Math.max(res, f);
}
return res;
}
}

• // OJ: https://leetcode.com/problems/longest-continuous-increasing-subsequence/
// Time: O(N)
// Space: O(1)
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
int ans = 0, len = 0, prev = INT_MAX;
for (int n : nums) {
if (n > prev) ++len;
else len = 1;
prev = n;
ans = max(ans, len);
}
return ans;
}
};

• class Solution:
def findLengthOfLCIS(self, nums: List[int]) -> int:
n = len(nums)
res = f = 1
for i in range(1, n):
f = 1 + (f if nums[i - 1] < nums[i] else 0)
res = max(res, f)
return res

############

class Solution(object):
def findLengthOfLCIS(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if not nums: return 0
N = len(nums)
dp = [1] * N
for i in range(1, N):
if nums[i] > nums[i - 1]:
dp[i] = dp[i - 1] + 1
return max(dp)

• func findLengthOfLCIS(nums []int) int {
res, f := 1, 1
for i := 1; i < len(nums); i++ {
if nums[i-1] < nums[i] {
f += 1
res = max(res, f)
} else {
f = 1
}
}
return res
}

func max(a, b int) int {
if a > b {
return a
}
return b
}

• function findLengthOfLCIS(nums: number[]): number {
const n = nums.length;
let res = 1;
let i = 0;
for (let j = 1; j < n; j++) {
if (nums[j - 1] >= nums[j]) {
res = Math.max(res, j - i);
i = j;
}
}
return Math.max(res, n - i);
}


• class Solution {
/**
* @param Integer[] $nums * @return Integer */ function findLengthOfLCIS($nums) {
$tmp =$max = 1;
for ($i = 0;$i < count($nums) - 1;$i++) {
if ($nums[$i] < $nums[$i + 1]) {
$tmp++;$max = max($max,$tmp);
} else $tmp = 1; } return$max;
}
}

• impl Solution {
pub fn find_length_of_lcis(nums: Vec<i32>) -> i32 {
let n = nums.len();
// Here dp[i] represents the longest lcis that ends with nums[i], should be 1 by default
let mut dp: Vec<i32> = vec![1; n];
let mut ret = dp[0];

// Let's dp
for i in 1..n {
dp[i] = if nums[i] > nums[i - 1] {
dp[i - 1] + 1
} else {
1
};
ret = std::cmp::max(ret, dp[i]);
}

ret
}
}