3105. Longest Strictly Increasing or Strictly Decreasing Subarray

You are given an array of integers nums. Return the length of the longest subarray of nums which is either strictly increasing or strictly decreasing.

 Example 1:

Input: nums = [1,4,3,3,2]

Output: 2

Explanation:

The strictly increasing subarrays of nums are [1], [2], [3], [3], [4], and [1,4].

The strictly decreasing subarrays of nums are [1], [2], [3], [3], [4], [3,2], and [4,3].

Hence, we return 2.

Example 2:

Input: nums = [3,3,3,3]

Output: 1

Explanation:

The strictly increasing subarrays of nums are [3], [3], [3], and [3].

The strictly decreasing subarrays of nums are [3], [3], [3], and [3].

Hence, we return 1.

Example 3:

Input: nums = [3,2,1]

Output: 3

Explanation:

The strictly increasing subarrays of nums are [3], [2], and [1].

The strictly decreasing subarrays of nums are [3], [2], [1], [3,2], [2,1], and [3,2,1].

Hence, we return 3.

 Constraints:

• 1 <= nums.length <= 50
• 1 <= nums[i] <= 50

JAVA

• class Solution {
      public int longestMonotonicSubarray(int[] nums) {
          int ans = 1;
          for (int i = 1, t = 1; i < nums.length; ++i) {
              if (nums[i - 1] < nums[i]) {
                  ans = Math.max(ans, ++t);
              } else {
                  t = 1;
              }
          }
          for (int i = 1, t = 1; i < nums.length; ++i) {
              if (nums[i - 1] > nums[i]) {
                  ans = Math.max(ans, ++t);
              } else {
                  t = 1;
              }
          }
          return ans;
      }
  }

C++

• class Solution {
  public:
      int longestMonotonicSubarray(vector<int>& nums) {
          int ans = 1;
          for (int i = 1, t = 1; i < nums.size(); ++i) {
              if (nums[i - 1] < nums[i]) {
                  ans = max(ans, ++t);
              } else {
                  t = 1;
              }
          }
          for (int i = 1, t = 1; i < nums.size(); ++i) {
              if (nums[i - 1] > nums[i]) {
                  ans = max(ans, ++t);
              } else {
                  t = 1;
              }
          }
          return ans;
      }
  };

PYTHON

• class Solution:
      def longestMonotonicSubarray(self, nums):
          ans = 1
          increasing, decreasing = 1, 1
  
          for i in range(1, len(nums)):
              if nums[i - 1] < nums[i]:
                  increasing += 1
                  ans = max(ans, increasing)
              else:
                  increasing = 1  # Reset if monotonicity breaks
  
          for i in range(1, len(nums)):
              if nums[i - 1] > nums[i]:
                  decreasing += 1
                  ans = max(ans, decreasing)
              else:
                  decreasing = 1  # Reset if monotonicity breaks
  
          return ans