Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Find the count of Strictly decreasing Subarrays

  • Difficulty Level : Basic
  • Last Updated : 18 May, 2021

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 
 

 

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 the 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 the result.
Below is the implementation of above approach: 
 

C++




// C++ program to count number of strictly
// decreasing subarrays in O(n) time.
 
#include <bits/stdc++.h>
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



<?php
// PHP program to count number of strictly
// decreasing subarrays in O(n) time.
 
// Function to count the number of
// strictly decreasing subarrays
function countDecreasing($A, $n)
{
    $cnt = 0; // Initialize result
 
    // Initialize length of current
    // decreasing subarray
    $len = 1;
 
    // Traverse through the array
    for ($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
$A = array( 100, 3, 1, 13 );
$n = sizeof($A);
 
echo countDecreasing($A, $n);
 
// This code is contributed by mits
?>
Javascript



<script>
 
// JavaScript program to count number of strictly
// decreasing subarrays in O(n) time.
 
 
// Function to count the number of strictly
// decreasing subarrays
function countDecreasing(A, n)
{
    var cnt = 0; // Initialize result
 
    // Initialize length of current
    // decreasing subarray
    var len = 1;
 
    // Traverse through the array
    for (var 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 += parseInt(((len - 1) * len) / 2);
            len = 1;
        }
    }
 
    // If last length is more than 1
    if (len > 1)
        cnt += parseInt(((len - 1) * len) / 2);
 
    return cnt;
}
 
 
    var A = [ 100, 3, 1, 13 ];
    var n = A.length;
    document.write( countDecreasing(A, n));
 
 
// This code is contributed by SoumikMondal
 
</script>
Output: 
3
 
Time Complexity: O(N)
 

My Personal Notes
arrow_drop_up
Previous
Find optimal weights which can be used to weigh all the weights in the range [1, X]
Next

Maximize number of 0s by flipping a subarray
Recommended Articles
Page :
Count Subarrays with strictly decreasing consecutive elements
27, Dec 21
Count elements in Array having strictly smaller and strictly greater element present
26, Jan 22
Minimum increments of Non-Decreasing Subarrays required to make Array Non-Decreasing
19, Aug 20
Find an element in an array such that elements form a strictly decreasing and increasing sequence
15, Oct 18
Differences between number of increasing subarrays and decreasing subarrays in k sized windows
16, Nov 17
Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0
13, Dec 21
Check whether an array can be made strictly decreasing by modifying at most one element
14, Jun 19
Split the array elements into strictly increasing and decreasing sequence
09, Apr 19
Maximize product of a strictly increasing or decreasing subarray
12, Jan 21
Count Strictly Increasing Subarrays
11, Feb 16
Partition array into two subarrays with every element in the right subarray strictly greater than every element in left subarray
01, Mar 21
Count non decreasing subarrays of size N from N Natural numbers
04, Feb 20
Queries to check if count of increasing and decreasing subarrays is same in given range
09, Nov 20
Count subarrays with elements in alternate increasing-decreasing order or vice-versa
29, Jan 22
Split an array into minimum number of non-increasing or non-decreasing subarrays
13, Jan 21
Queries to check if subarrays over given range of indices is non-decreasing or not
12, Feb 21
Generate an N-length array having length of non-decreasing subarrays maximized and minimum difference between first and last array elements
23, Jul 21
Count the subarray with sum strictly greater than the sum of remaining elements
26, Jan 20
Count ways to divide C in two parts and add to A and B to make A strictly greater than B
10, Apr 20
Maximise count of elements that are strictly greater in a subsequence than their average
10, Dec 21
Count of strictly increasing N-digit numbers
09, Jul 21
Count of players who need training and have strictly less power and endurance than any other player
10, Nov 21
Find Maximum Sum Strictly Increasing Subarray
07, Dec 16
Find the largest composite number that divides N but is strictly lesser than N
18, Mar 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sanjit_Prasad
@Sanjit_Prasad
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!