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

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: