# Count Strictly Increasing Subarrays

Given an array of integers, count number of subarrays (of size more than one) that are strictly increasing.
Expected Time Complexity : O(n)
Expected Extra Space: O(1)

Examples:

```Input: arr[] = {1, 4, 3}
Output: 1
There is only one subarray {1, 4}

Input: arr[] = {1, 2, 3, 4}
Output: 6
There are 6 subarrays {1, 2}, {1, 2, 3}, {1, 2, 3, 4}
{2, 3}, {2, 3, 4} and {3, 4}

Input: arr[] = {1, 2, 2, 4}
Output: 2
There are 2 subarrays {1, 2} and {2, 4}
```

## We strongly recommend that you click here and practice it, before moving on to the solution.

A Simple Solution is to generate all possible subarrays, and for every subarray check if subarray is strictly increasing or not. Worst case time complexity of this solution would be O(n3).

A Better Solution is to use the fact that if subarray arr[i:j] is not strictly increasing, then subarrays arr[i:j+1], arr[i:j+2], .. arr[i:n-1] cannot be strictly increasing. Below is the program based on above idea.

## C++

 `// C++ program to count number of strictly ` `// increasing subarrays ` `#include ` `using` `namespace` `std; ` ` `  `int` `countIncreasing(``int` `arr[], ``int` `n) ` `{ ` `    ``// Initialize count of subarrays as 0 ` `    ``int` `cnt = 0; ` ` `  `    ``// Pick starting point ` `    ``for` `(``int` `i=0; i arr[j-1]) ` `                ``cnt++; ` ` `  `            ``// If subarray arr[i..j] is not strictly  ` `            ``// increasing, then subarrays after it , i.e.,  ` `            ``// arr[i..j+1], arr[i..j+2], .... cannot ` `            ``// be strictly increasing ` `            ``else` `                ``break``; ` `        ``} ` `    ``} ` `    ``return` `cnt; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `  ``int` `arr[] = {1, 2, 2, 4}; ` `  ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `  ``cout << ``"Count of strictly increasing subarrays is "` `       ``<< countIncreasing(arr, n); ` `  ``return` `0; ` `} `

## Java

 `// Java program to count number of strictly ` `// increasing subarrays ` ` `  ` `  `class` `Test ` `{ ` `    ``static` `int` `arr[] = ``new` `int``[]{``1``, ``2``, ``2``, ``4``}; ` `     `  `    ``static` `int` `countIncreasing(``int` `n) ` `    ``{ ` `        ``// Initialize count of subarrays as 0 ` `        ``int` `cnt = ``0``; ` `      `  `        ``// Pick starting point ` `        ``for` `(``int` `i=``0``; i arr[j-``1``]) ` `                    ``cnt++; ` `      `  `                ``// If subarray arr[i..j] is not strictly  ` `                ``// increasing, then subarrays after it , i.e.,  ` `                ``// arr[i..j+1], arr[i..j+2], .... cannot ` `                ``// be strictly increasing ` `                ``else` `                    ``break``; ` `            ``} ` `        ``} ` `        ``return` `cnt; ` `    ``} ` `    ``// Driver method to test the above function ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``System.out.println(``"Count of strictly increasing subarrays is "` `+  ` `                                               ``countIncreasing(arr.length)); ` `    ``} ` `} `

## Python3

 `# Python3 program to count number ` `# of strictly increasing subarrays ` ` `  `def` `countIncreasing(arr, n): ` `     `  `    ``# Initialize count of subarrays as 0 ` `    ``cnt ``=` `0` ` `  `    ``# Pick starting point ` `    ``for` `i ``in` `range``(``0``, n) : ` `         `  `        ``# Pick ending point ` `        ``for` `j ``in` `range``(i ``+` `1``, n) : ` `            ``if` `arr[j] > arr[j ``-` `1``] : ` `                ``cnt ``+``=` `1` ` `  `            ``# If subarray arr[i..j] is not strictly  ` `            ``# increasing, then subarrays after it , i.e.,  ` `            ``# arr[i..j+1], arr[i..j+2], .... cannot ` `            ``# be strictly increasing ` `            ``else``: ` `                ``break` `    ``return` `cnt ` ` `  ` `  `# Driver code ` `arr ``=` `[``1``, ``2``, ``2``, ``4``] ` `n ``=` `len``(arr) ` `print` `(``"Count of strictly increasing subarrays is"``, ` `                            ``countIncreasing(arr, n)) ` ` `  `# This code is contributed by Shreyanshi Arun. `

## C#

 `// C# program to count number of  ` `// strictly increasing subarrays ` `using` `System; ` ` `  `class` `Test ` `{ ` `    ``static` `int` `[]arr = ``new` `int``[]{1, 2, 2, 4}; ` `     `  `    ``static` `int` `countIncreasing(``int` `n) ` `    ``{ ` `        ``// Initialize count of subarrays as 0 ` `        ``int` `cnt = 0; ` `     `  `        ``// Pick starting point ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``// Pick ending point ` `            ``for` `(``int` `j = i + 1; j < n; j++) ` `            ``{ ` `                ``if` `(arr[j] > arr[j - 1]) ` `                    ``cnt++; ` `     `  `                ``// If subarray arr[i..j] is not strictly  ` `                ``// increasing, then subarrays after it ,  ` `                ``// i.e.,  arr[i..j+1], arr[i..j+2], ....  ` `                ``// cannot be strictly increasing ` `                ``else` `                    ``break``; ` `            ``} ` `        ``} ` `        ``return` `cnt; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``Console.Write(``"Count of strictly increasing"` `+  ` `            ``"subarrays is "` `+ countIncreasing(arr.Length)); ` `    ``} ` `} ` ` `  `// This code is contribute by parashar. `

## PHP

 ` ``\$arr``[``\$j``-1]) ` `                ``\$cnt``++; ` ` `  `            ``// If subarray arr[i..j] is ` `            ``// not strictly increasing, ` `            ``// then subarrays after it, ` `            ``// i.e., arr[i..j+1],  ` `            ``// arr[i..j+2], .... cannot ` `            ``// be strictly increasing ` `            ``else` `                ``break``; ` `        ``} ` `    ``} ` `    ``return` `\$cnt``; ` `} ` ` `  `// Driver program ` ` `  `\$arr` `= ``array``(1, 2, 2, 4); ` `\$n` `= ``count``(``\$arr``); ` `echo` `"Count of strictly increasing "``, ` `                     ``"subarrays is "``, ` `            ``countIncreasing(``\$arr``, ``\$n``); ` ` `  `// This code is contribute by anuj_67. ` `?> `

Output :

```Count of strictly increasing subarrays is 2
```

Time complexity of the above solution is O(m) where m is number of subarrays in output

This problem and solution are contributed by Rahul Agrawal.

An Efficient Solution can count subarrays in O(n) time. The idea is based on fact that a sorted subarray of length ‘len’ adds len*(len-1)/2 to result. For example, {10, 20, 30, 40} adds 6 to the result.

## C++

 `// C++ program to count number of strictly ` `// increasing subarrays in O(n) time. ` `#include ` `using` `namespace` `std; ` ` `  `int` `countIncreasing(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `cnt = 0;  ``// Initialize result ` ` `  `    ``// Initialize length of current increasing ` `    ``// subarray ` `    ``int` `len = 1; ` ` `  `    ``// Traverse through the array ` `    ``for` `(``int` `i=0; i < n-1; ++i) ` `    ``{ ` `        ``// If arr[i+1] is greater than arr[i], ` `        ``// then increment length ` `        ``if` `(arr[i + 1] > arr[i]) ` `            ``len++; ` `             `  `        ``// Else Update count and reset length ` `        ``else` `        ``{ ` `            ``cnt += (((len - 1) * len) / 2); ` `            ``len = 1; ` `        ``} ` `    ``} ` `     `  `    ``// If last length is more than 1 ` `    ``if` `(len > 1) ` `        ``cnt += (((len - 1) * len) / 2); ` ` `  `    ``return` `cnt; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `  ``int` `arr[] = {1, 2, 2, 4}; ` `  ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `  ``cout << ``"Count of strictly increasing subarrays is "` `       ``<< countIncreasing(arr, n); ` `  ``return` `0; ` `} `

## Java

 `// Java program to count number of strictly ` `// increasing subarrays ` ` `  ` `  `class` `Test ` `{ ` `    ``static` `int` `arr[] = ``new` `int``[]{``1``, ``2``, ``2``, ``4``}; ` `     `  `    ``static` `int` `countIncreasing(``int` `n) ` `    ``{ ` `        ``int` `cnt = ``0``;  ``// Initialize result ` `          `  `        ``// Initialize length of current increasing ` `        ``// subarray ` `        ``int` `len = ``1``; ` `      `  `        ``// Traverse through the array ` `        ``for` `(``int` `i=``0``; i < n-``1``; ++i) ` `        ``{ ` `            ``// If arr[i+1] is greater than arr[i], ` `            ``// then increment length ` `            ``if` `(arr[i + ``1``] > arr[i]) ` `                ``len++; ` `                  `  `            ``// Else Update count and reset length ` `            ``else` `            ``{ ` `                ``cnt += (((len - ``1``) * len) / ``2``); ` `                ``len = ``1``; ` `            ``} ` `        ``} ` `          `  `        ``// If last length is more than 1 ` `        ``if` `(len > ``1``) ` `            ``cnt += (((len - ``1``) * len) / ``2``); ` `      `  `        ``return` `cnt; ` `    ``} ` `    ``// Driver method to test the above function ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``System.out.println(``"Count of strictly increasing subarrays is "` `+  ` `                                               ``countIncreasing(arr.length)); ` `    ``} ` `} `

## Python3

 `# Python3 program to count number of  ` `# strictlyincreasing subarrays in O(n) time. ` ` `  `def` `countIncreasing(arr, n): ` `    ``cnt ``=` `0` `# Initialize result ` ` `  `    ``# Initialize length of current  ` `    ``# increasing subarray ` `    ``len` `=` `1` ` `  `    ``# Traverse through the array ` `    ``for` `i ``in` `range``(``0``, n ``-` `1``) : ` `         `  `        ``# If arr[i+1] is greater than arr[i], ` `        ``# then increment length ` `        ``if` `arr[i ``+` `1``] > arr[i] : ` `            ``len` `+``=` `1` `             `  `        ``# Else Update count and reset length ` `        ``else``: ` `            ``cnt ``+``=` `(((``len` `-` `1``) ``*` `len``) ``/` `2``) ` `            ``len` `=` `1` `     `  `    ``# If last length is more than 1 ` `    ``if` `len` `> ``1``: ` `        ``cnt ``+``=` `(((``len` `-` `1``) ``*` `len``) ``/` `2``) ` ` `  `    ``return` `cnt ` ` `  ` `  `# Driver program ` `arr ``=` `[``1``, ``2``, ``2``, ``4``] ` `n ``=` `len``(arr) ` ` `  `print` `(``"Count of strictly increasing subarrays is"``, ` `                        ``int``(countIncreasing(arr, n))) ` ` `  ` `  `# This code is contributed by Shreyanshi Arun. `

## C#

 `// C# program to count number of strictly ` `// increasing subarrays ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``static` `int` `[]arr = ``new` `int``[]{1, 2, 2, 4}; ` `     `  `    ``static` `int` `countIncreasing(``int` `n) ` `    ``{ ` `        ``int` `cnt = 0; ``// Initialize result ` `         `  `        ``// Initialize length of current  ` `        ``// increasing subarray ` `        ``int` `len = 1; ` `     `  `        ``// Traverse through the array ` `        ``for` `(``int` `i = 0; i < n-1; ++i) ` `        ``{ ` `             `  `            ``// If arr[i+1] is greater than ` `            ``// arr[i], then increment length ` `            ``if` `(arr[i + 1] > arr[i]) ` `                ``len++; ` `                 `  `            ``// Else Update count and reset ` `            ``// length ` `            ``else` `            ``{ ` `                ``cnt += (((len - 1) * len) / 2); ` `                ``len = 1; ` `            ``} ` `        ``} ` `         `  `        ``// If last length is more than 1 ` `        ``if` `(len > 1) ` `            ``cnt += (((len - 1) * len) / 2); ` `     `  `        ``return` `cnt; ` `    ``} ` `     `  `    ``// Driver method to test the ` `    ``// above function ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``Console.WriteLine(``"Count of strictly "` `                  ``+ ``"increasing subarrays is "` `               ``+ countIncreasing(arr.Length)); ` `    ``} ` `} ` ` `  `// This code is contribute by anuj_67. `

## PHP

 ` ``\$arr``[``\$i``]) ` `            ``\$len``++; ` `             `  `        ``// Else Update count and ` `        ``// reset length ` `        ``else` `        ``{ ` `            ``\$cnt` `+= (((``\$len` `- 1) * ``\$len``) / 2); ` `            ``\$len` `= 1; ` `        ``} ` `    ``} ` `     `  `    ``// If last length is ` `    ``// more than 1 ` `    ``if` `(``\$len` `> 1) ` `        ``\$cnt` `+= (((``\$len` `- 1) * ``\$len``) / 2); ` ` `  `    ``return` `\$cnt``; ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(1, 2, 2, 4); ` `\$n` `= ``count``(``\$arr``); ` `echo` `"Count of strictly increasing subarrays is "` `                     ``, countIncreasing(``\$arr``, ``\$n``); ` ` `  `// This code is contribute by anuj_67 ` `?> `

Output :

```Count of strictly increasing subarrays is 2
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Improved By : parashar, vt_m

Article Tags :
Practice Tags :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.