Count Strictly Increasing Subarrays

04 Jun, 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:
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
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}
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++
Java
Python3
C#
PHP
Javascript
// C++ program to count number of strictly// increasing subarrays#include<bits/stdc++.h>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<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 programint 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 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<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 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 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 codearr = [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# program to count number of// strictly increasing subarraysusing 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// PHP program to count number of// strictly increasing subarrays function countIncreasing( $arr, $n){         // Initialize count of subarrays    // as 0    $cnt = 0;     // Pick starting point    for ( $i = 0; $i < $n; $i++)    {        // Pick ending point        for ( $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 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.?>
<script> // Javascript program to count number of strictly// increasing subarraysfunction countIncreasing(arr, n){         // Initialize count of subarrays as 0    let cnt = 0;     // Pick starting point    for(let i = 0; i < n; i++)    {                 // Pick ending point        for (let 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 codelet arr = [ 1, 2, 2, 4 ];let n = arr.length;document.write("Count of strictly " +               "increasing subarrays is " +               countIncreasing(arr, n));                // This code is contributed by divyesh072019 </script>
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 outputThis 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++
Java
Python3
C#
PHP
Javascript
// C++ program to count number of strictly// increasing subarrays in O(n) time.#include<bits/stdc++.h>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 programint 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 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 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 programarr = [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# program to count number of strictly// increasing subarraysusing 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// PHP program to count number of strictly// increasing subarrays in O(n) time. function countIncreasing( $arr, $n){         // Initialize result    $cnt = 0;     // Initialize length of    // current increasing    // subarray    $len = 1;     // Traverse through the array    for($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 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?>
<script>     // Javascript program to count number of strictly    // increasing subarrays         let arr = [1, 2, 2, 4];          function countIncreasing(n)    {        let cnt = 0; // Initialize result                  // Initialize length of current        // increasing subarray        let len = 1;              // Traverse through the array        for (let 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;    }         document.write("Count of strictly "                  + "increasing subarrays is "               + countIncreasing(arr.length));                </script>
Output : 
Count of strictly increasing subarrays is 2
Time Complexity: O(n) Auxiliary Space: O(1) 
Count Strictly Increasing Subarrays | GeeksforGeeks - YouTubeGeeksforGeeks532K subscribersCount Strictly Increasing Subarrays | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 10:00•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=eMuC2LCoMvU" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
parashar
vt_m
divyesh072019
mukesh07
surinderdawra388
_shinchancode
Arrays
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.