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:
Facebook

Related Topics:
Array

Similar Questions:

• Number of Longest Increasing Subsequence (Medium)
• Minimum Window Subsequence (Hard)

Solution 1.

• Java
• C++
• Python
• Go
• TypeScript
• Php
• RenderScript

• 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 {
      #[allow(dead_code)]
      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
      }
  }
  

All Problems

All Solutions