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(n³).

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

# 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

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

PHP

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

Output :

Count of strictly increasing subarrays is 2

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

My Personal Notes

Suggest a Topic

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

C++

Java

Python3

C#

PHP

C++

Java

Python3

C#

PHP

Recommended Posts: