Welcome to Subscribe On Youtube

2393. Count Strictly Increasing Subarrays

Description

You are given an array nums consisting of positive integers.

Return the number of subarrays of nums that are in strictly increasing order.

A subarray is a contiguous part of an array.

 

Example 1:

Input: nums = [1,3,5,4,4,6]
Output: 10
Explanation: The strictly increasing subarrays are the following:
- Subarrays of length 1: [1], [3], [5], [4], [4], [6].
- Subarrays of length 2: [1,3], [3,5], [4,6].
- Subarrays of length 3: [1,3,5].
The total number of subarrays is 6 + 3 + 1 = 10.

Example 2:

Input: nums = [1,2,3,4,5]
Output: 15
Explanation: Every subarray is strictly increasing. There are 15 possible subarrays that we can take.

 

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 106

Solutions

• Java
• C++
• Python
• Go
• TypeScript

• class Solution {
      public long countSubarrays(int[] nums) {
          long ans = 0;
          int i = 0, n = nums.length;
          while (i < n) {
              int j = i + 1;
              while (j < n && nums[j] > nums[j - 1]) {
                  ++j;
              }
              long cnt = j - i;
              ans += (1 + cnt) * cnt / 2;
              i = j;
          }
          return ans;
      }
  }
  

• class Solution {
  public:
      long long countSubarrays(vector<int>& nums) {
          long long ans = 0;
          int i = 0, n = nums.size();
          while (i < n) {
              int j = i + 1;
              while (j < n && nums[j] > nums[j - 1]) {
                  ++j;
              }
              int cnt = j - i;
              ans += 1ll * (1 + cnt) * cnt / 2;
              i = j;
          }
          return ans;
      }
  };
  

• class Solution:
      def countSubarrays(self, nums: List[int]) -> int:
          ans = i = 0
          while i < len(nums):
              j = i + 1
              while j < len(nums) and nums[j] > nums[j - 1]:
                  j += 1
              cnt = j - i
              ans += (1 + cnt) * cnt // 2
              i = j
          return ans
  
  

• func countSubarrays(nums []int) int64 {
  	ans := 0
  	i, n := 0, len(nums)
  	for i < n {
  		j := i + 1
  		for j < n && nums[j] > nums[j-1] {
  			j++
  		}
  		cnt := j - i
  		ans += (1 + cnt) * cnt / 2
  		i = j
  	}
  	return int64(ans)
  }
  

• function countSubarrays(nums: number[]): number {
      let ans = 0;
      let i = 0;
      const n = nums.length;
      while (i < n) {
          let j = i + 1;
          while (j < n && nums[j] > nums[j - 1]) {
              ++j;
          }
          const cnt = j - i;
          ans += ((1 + cnt) * cnt) / 2;
          i = j;
      }
      return ans;
  }
  
  

All Problems

All Solutions