# Count of non decreasing arrays of length N formed with values in range L to R

• Difficulty Level : Hard
• Last Updated : 25 May, 2021

Given are integers N, L and R, the task is to count the number of non decreasing arrays of length N formed with values in range [L, R] with repetition allowed.
Examples:

Input: N = 4, L = 4, R = 6
Output:
All possible arrays are {4, 4, 4, 6}, {4, 4, 5, 6}, {4, 5, 5, 6}, {4, 5, 6, 6} and {4, 6, 6, 6}.
Input: N = 2, L = 5, R = 2
Output:
No such combinations exist as L > R.

Approach:

• Since it is known that the minimum number is L and maximum number is R in the array.
• If the remaining (N – 2) indices are filled with L, the minimum possible sum is obtained and if the remaining (N-2) indices are filled with R, the maximum possible sum is obtained.
• It can be concluded that there exists a combination of numbers which results in a sum in between the minimum possible and maximum possible sum.
• Therefore, total different number of sums can be computed by:
[(N â€“ 2) * R â€“ (N â€“ 2) * L] + 1 = (N â€“ 2) * (R â€“ L) + 1

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ``using` `namespace` `std;` `// Function to return the count``// of different arrays``int` `countSum(``int` `N, ``int` `L, ``int` `R)``{` `    ``// No such combination exists``    ``if` `(L > R) {``        ``return` `0;``    ``}` `    ``// Arrays formed with single elements``    ``if` `(N == 1) {``        ``return` `R - L + 1;``    ``}` `    ``if` `(N > 1) {``        ``return` `(N - 2) * (R - L) + 1;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `N = 4, L = 4, R = 6;` `    ``cout << countSum(N, L, R);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `// Function to return the count``// of different arrays``static` `int` `countSum(``int` `N, ``int` `L, ``int` `R)``{` `    ``// No such combination exists``    ``if` `(L > R)``    ``{``        ``return` `0``;``    ``}` `    ``// Arrays formed with single elements``    ``if` `(N == ``1``)``    ``{``        ``return` `R - L + ``1``;``    ``}` `    ``if` `(N > ``1``)``    ``{``        ``return` `(N - ``2``) * (R - L) + ``1``;``    ``}``    ``return` `0``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``4``, L = ``4``, R = ``6``;` `    ``System.out.print(countSum(N, L, R));``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach` `# Function to return the count``# of different arrays``def` `countSum(N, L, R):` `    ``# No such combination exists``    ``if` `(L > R):``        ``return` `0``;` `    ``# Arrays formed with single elements``    ``if` `(N ``=``=` `1``):``        ``return` `R ``-` `L ``+` `1``;``    ``if` `(N > ``1``):``        ``return` `(N ``-` `2``) ``*` `(R ``-` `L) ``+` `1``;``    ` `    ``return` `0``;` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``N, L, R ``=` `4``, ``4``, ``6``;` `    ``print``(countSum(N, L, R));` `# This code is contributed by 29AjayKumar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `// Function to return the count``// of different arrays``static` `int` `countSum(``int` `N, ``int` `L, ``int` `R)``{` `    ``// No such combination exists``    ``if` `(L > R)``    ``{``        ``return` `0;``    ``}` `    ``// Arrays formed with single elements``    ``if` `(N == 1)``    ``{``        ``return` `R - L + 1;``    ``}` `    ``if` `(N > 1)``    ``{``        ``return` `(N - 2) * (R - L) + 1;``    ``}``    ``return` `0;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `N = 4, L = 4, R = 6;` `    ``Console.Write(countSum(N, L, R));``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``
Output:
`5`

Time Complexity: O(1)

My Personal Notes arrow_drop_up