# Count Strictly Increasing Subarrays

• Difficulty Level : Medium
• Last Updated : 10 Aug, 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[0]);   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: O(n2
Auxiliary Space: O(1)

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[0]);   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 contributed 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

Time Complexity: O(n)
Auxiliary Space: O(1)