# Count Strictly Increasing Subarrays

• Difficulty Level : Medium
• Last Updated : 08 Apr, 2022

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 contributed 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 contributed by anuj_67.``?>`

## Javascript

 ``

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``?>`

## Javascript

 ``

Output :

`Count of strictly increasing subarrays is 2`