##### Welcome to Subscribe On Youtube

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

# 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

• 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;
}