# Find the count of Strictly decreasing Subarrays

Given an array A[] of integers. The task is to count the total number of strictly decreasing subarrays( with size > 1 ).

Examples:

Input : A[] = { 100, 3, 1, 15 }
Output : 3
Subarrays are -> { 100, 3 }, { 100, 3, 1 }, { 3, 1 }

Input : A[] = { 4, 2, 2, 1 }
Output : 2

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: A simple solution is to run two for loops and check whether the subarray is decreasing or not.
This can be improved by knowing the fact that if subarray arr[i:j] is not strictly decreasing, then subarrays arr[i:j+1], arr[i:j+2], .. arr[i:n-1] cannot be strictly decreasing.

Efficient Approach: In above solution we count many subarrays twice. This can also be improved and the idea is based on fact that a sorted(decreasing) subarray of length ‘len’ adds len*(len-1)/2 to result.

Below is the implementation of above approach:

## C++

 // C++ program to count number of strictly // decreasing subarrays in O(n) time.    #include using namespace std;    // Function to count the number of strictly // decreasing subarrays int countDecreasing(int A[], int n) {     int cnt = 0; // Initialize result        // Initialize length of current     // decreasing subarray     int len = 1;        // Traverse through the array     for (int i = 0; i < n - 1; ++i) {         // If arr[i+1] is less than arr[i],         // then increment length         if (A[i + 1] < A[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 A[] = { 100, 3, 1, 13 };     int n = sizeof(A) / sizeof(A[0]);        cout << countDecreasing(A, n);        return 0; }

## Java

 // Java program to count number of strictly // decreasing subarrays in O(n) time.    import java.io.*;    class GFG {       // Function to count the number of strictly // decreasing subarrays static int countDecreasing(int A[], int n) {     int cnt = 0; // Initialize result        // Initialize length of current     // decreasing subarray     int len = 1;        // Traverse through the array     for (int i = 0; i < n - 1; ++i) {         // If arr[i+1] is less than arr[i],         // then increment length         if (A[i + 1] < A[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     public static void main (String[] args) {     int A[] = { 100, 3, 1, 13 };     int n = A.length;        System.out.println(countDecreasing(A, n));     } } // This code is contributed by anuj_67..

## Python 3

 # Python 3 program to count number  # of strictly decreasing subarrays # in O(n) time.    # Function to count the number of # strictly decreasing subarrays def countDecreasing(A, n):        cnt = 0 # Initialize result        # Initialize length of current     # decreasing subarray     len = 1        # Traverse through the array     for i in range (n - 1) :                    # If arr[i+1] is less than arr[i],         # then increment length         if (A[i + 1] < A[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 Code if __name__=="__main__":        A = [ 100, 3, 1, 13 ]     n = len(A)        print (countDecreasing(A, n))    # This code is contributed by ChitraNayal

## C#

 // C# program to count number of strictly // decreasing subarrays in O(n) time.    using System;    class GFG { // Function to count the number of strictly // decreasing subarrays static int countDecreasing(int []A, int n) { int cnt = 0; // Initialize result    // Initialize length of current // decreasing subarray int len = 1;    // Traverse through the array for (int i = 0; i < n - 1; ++i) { // If arr[i+1] is less than arr[i], // then increment length if (A[i + 1] < A[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 static void Main() { int []A = { 100, 3, 1, 13 }; int n = A.Length ; Console.WriteLine(countDecreasing(A, n)); } // This code is contributed by ANKITRAI1 }

## PHP

 1)         \$cnt += (((\$len - 1) * \$len) / 2);        return \$cnt; }    // Driver Code \$A = array( 100, 3, 1, 13 ); \$n = sizeof(\$A);    echo countDecreasing(\$A, \$n);    // This code is contributed by mits ?>

Output:

3

Time Complexity: O(N)

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.