Related Articles
Differences between number of increasing subarrays and decreasing subarrays in k sized windows
• Difficulty Level : Medium
• Last Updated : 10 Jan, 2020

Given an array of integers and k, find the difference between the number of the strictly increasing number of subarrays (of size more than one) and the number of the strictly decreasing subarray in the window of size k.

Examples:

```Input : nums = {10, 20, 30, 15, 15};
k = 3;
Output : 3, 0, -1
Explanation
For the first window of [10, 20, 30], there are
3 increasing subranges ([10, 20, 30], [10, 20],
and [20, 30]) and 0 decreasing, so the answer
is 3. For the second window of [20, 30, 15],
there is 1 increasing subrange and 1 decreasing,
so the answer is 0. For the third window of
[20, 15, 15], there is 1 decreasing subrange
and 0 increasing, so the answer is -1.
```

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

We need to calculate the difference between increasing and decreasing subarrays for each of the window of size K. We iterate through the array and for each of the window of size k, we calculate the number of increasing and decreasing subarrays and insert the difference of them in the output array.

1. Create two arrays of size N and initialize them by zero and create the output array.
2. Iterate through array
3. Calculate the numbers of increasing subarrays
4. Calculate the decreasing subarrays
5. Insert the difference between increasing and decreasing subarrays in output array.

Time Complexity of the solution- O(n*k)
n = Size of the array
k = Window size

## C++

 `// CPP program to count the differenes ``#include ``#include ``using` `namespace` `std;`` ` `// function to calculate the diffrence``vector<``int``> Diffs(vector<``int``> ``const``& a, ``int` `k)``{``    ``vector<``int``> out;``    ``vector<``int``> inc, dec;`` ` `    ``// initializing inc and dec with 0 and resizing``    ``// equal to the size of main array``    ``inc.resize(a.size(), 0);``    ``dec.resize(a.size(), 0);`` ` `    ``int` `inc_sum = 0;``    ``int` `dec_sum = 0;`` ` `    ``// iterate through the array``    ``for` `(``int` `i = 0; i < a.size(); ++i) {`` ` `        ``// finding number of increasing ``        ``// subarrays in a window size k``        ``for` `(``int` `j = i - 1; j >= 0 && j > i - k &&``                           ``a[j + 1] > a[j]; --j) {``            ``++inc[j];``            ``++inc_sum;``        ``}`` ` `        ``// Finding number of decreasing subarrays ``        ``// in a window size k``        ``for` `(``int` `j = i - 1; j >= 0 && j > i - k && ``                            ``a[j + 1] < a[j]; --j) {``            ``++dec[j];``            ``++dec_sum;``        ``}`` ` `        ``// calculate the difference``        ``if` `(i >= k - 1) {`` ` `            ``// if this is not the first window then ``            ``// calculate inc_sum and dec_sum``            ``if` `(i >= k) {``                ``inc_sum -= inc[i - k];``                ``dec_sum -= dec[i - k];``            ``}`` ` `            ``// insert the difference in k size window``            ``// in the output vector``            ``out.push_back(inc_sum - dec_sum);``        ``}``    ``}``    ``return` `out;``}`` ` `// driver program``int` `main()``{``    ``vector<``int``> out = Diffs({ 10, 20, 30, 15, 15}, 3);``    ``for` `(``int` `n : out) ``        ``cout << n << ``", "``;``     ` `    ``return` `0;``}`

## Java

 `// JAVA program to count the differenes ``import` `java.util.*;`` ` `class` `GFG``{`` ` `// function to calculate the diffrence``static` `Vector Diffs(``int` `[]a, ``int` `k)``{``    ``Vector out = ``new` `Vector();``    ``int` `[] inc, dec;`` ` `    ``// initializing inc and dec with 0 and resizing``    ``// equal to the size of main array``    ``inc = ``new` `int``[a.length];``    ``dec = ``new` `int``[a.length];`` ` `    ``int` `inc_sum = ``0``;``    ``int` `dec_sum = ``0``;`` ` `    ``// iterate through the array``    ``for` `(``int` `i = ``0``; i < a.length; ++i)``    ``{`` ` `        ``// finding number of increasing ``        ``// subarrays in a window size k``        ``for` `(``int` `j = i - ``1``; j >= ``0` `&& j > i - k &&``                        ``a[j + ``1``] > a[j]; --j)``        ``{``            ``++inc[j];``            ``++inc_sum;``        ``}`` ` `        ``// Finding number of decreasing subarrays ``        ``// in a window size k``        ``for` `(``int` `j = i - ``1``; j >= ``0` `&& j > i - k && ``                            ``a[j + ``1``] < a[j]; --j)``        ``{``            ``++dec[j];``            ``++dec_sum;``        ``}`` ` `        ``// calculate the difference``        ``if` `(i >= k - ``1``) ``        ``{`` ` `            ``// if this is not the first window then ``            ``// calculate inc_sum and dec_sum``            ``if` `(i >= k) ``            ``{``                ``inc_sum -= inc[i - k];``                ``dec_sum -= dec[i - k];``            ``}`` ` `            ``// insert the difference in k size window``            ``// in the output vector``            ``out.add(inc_sum - dec_sum);``        ``}``    ``}``    ``return` `out;``}`` ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `[]arr = { ``10``, ``20``, ``30``, ``15``, ``15``};``    ``Vectorout = Diffs(arr, ``3``);``    ``for` `(``int` `n : out) ``        ``System.out.print(n + ``", "``);``}``}`` ` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 program to count the differences `` ` `# Function to calculate the diffrence ``def` `Diffs(a, k): `` ` `    ``out, inc, dec ``=` `[], [``0``] ``*` `len``(a), [``0``] ``*` `len``(a) `` ` `    ``# Initializing inc and dec with 0 and ``    ``# resizing equal to the size of main array ``    ``inc_sum, dec_sum ``=` `0``, ``0`` ` `    ``# Iterate through the array ``    ``for` `i ``in` `range``(``0``, ``len``(a)): `` ` `        ``# Finding number of increasing ``        ``# subarrays in a window size k``        ``j ``=` `i ``-` `1``        ``while` `(j >``=` `0` `and` `j > i ``-` `k ``and` `                        ``a[j ``+` `1``] > a[j]): ``            ``inc[j] ``+``=` `1``            ``inc_sum ``+``=` `1``            ``j ``-``=` `1`` ` `        ``# Finding number of decreasing ``        ``# subarrays in a window size k ``        ``j ``=` `i ``-` `1``        ``while` `(j >``=` `0` `and` `j > i ``-` `k ``and` `                        ``a[j ``+` `1``] < a[j]): ``            ``dec[j] ``+``=` `1``            ``dec_sum ``+``=` `1``            ``j ``-``=` `1`` ` `        ``# calculate the difference ``        ``if` `i >``=` `k ``-` `1``: `` ` `            ``# if this is not the first window then ``            ``# calculate inc_sum and dec_sum ``            ``if` `i >``=` `k: ``                ``inc_sum ``-``=` `inc[i ``-` `k] ``                ``dec_sum ``-``=` `dec[i ``-` `k] ``             ` `            ``# insert the difference in k size window ``            ``# in the output vector ``            ``out.append(inc_sum ``-` `dec_sum) ``         ` `    ``return` `out `` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``: `` ` `    ``out ``=` `Diffs([``10``, ``20``, ``30``, ``15``, ``15``], ``3``) ``    ``for` `n ``in` `out:``        ``print``(n, end ``=` `", "``) ``     ` `# This code is contributed by Rituraj Jain`

## C#

 `// C# program to count the differenes ``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG``{`` ` `// function to calculate the diffrence``static` `List<``int``> Diffs(``int` `[]a, ``int` `k)``{``    ``List<``int``> Out = ``new` `List<``int``>();``    ``int` `[] inc, dec;`` ` `    ``// initializing inc and dec with 0 and resizing``    ``// equal to the size of main array``    ``inc = ``new` `int``[a.Length];``    ``dec = ``new` `int``[a.Length];`` ` `    ``int` `inc_sum = 0;``    ``int` `dec_sum = 0;`` ` `    ``// iterate through the array``    ``for` `(``int` `i = 0; i < a.Length; ++i)``    ``{`` ` `        ``// finding number of increasing ``        ``// subarrays in a window size k``        ``for` `(``int` `j = i - 1; j >= 0 && j > i - k &&``                        ``a[j + 1] > a[j]; --j)``        ``{``            ``++inc[j];``            ``++inc_sum;``        ``}`` ` `        ``// Finding number of decreasing subarrays ``        ``// in a window size k``        ``for` `(``int` `j = i - 1; j >= 0 && j > i - k && ``                            ``a[j + 1] < a[j]; --j)``        ``{``            ``++dec[j];``            ``++dec_sum;``        ``}`` ` `        ``// calculate the difference``        ``if` `(i >= k - 1) ``        ``{`` ` `            ``// if this is not the first window then ``            ``// calculate inc_sum and dec_sum``            ``if` `(i >= k) ``            ``{``                ``inc_sum -= inc[i - k];``                ``dec_sum -= dec[i - k];``            ``}`` ` `            ``// insert the difference in k size window``            ``// in the output vector``            ``Out.Add(inc_sum - dec_sum);``        ``}``    ``}``    ``return` `Out;``}`` ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 10, 20, 30, 15, 15};``    ``List<``int``>Out = Diffs(arr, 3);``    ``foreach` `(``int` `n ``in` `Out) ``        ``Console.Write(n + ``", "``);``}``}`` ` `// This code is contributed by Rajput-Ji`

Output:

```3, 0, -1,
```

My Personal Notes arrow_drop_up