# Number of M-length sorted arrays that can be formed using first N natural numbers

Given two numbers N and M, the task is to find the number of sorted arrays that can be formed of size M using first N natural numbers, if each number can be taken any number of times.

Examples:

Input: N = 4, M = 2
Output: 10
Explanation: All such possible arrays are {1, 1}, {1, 2}, {1, 2}, {1, 4}, {2, 2}, {2, 3}, {2, 4}, {3, 3}, {3, 4}, {4, 4}.

Input: N = 2, M = 4
Output: 5
Explanation: All such possible arrays are {1, 1, 1, 1}, {1, 1, 1, 2}, {1, 1, 2, 2}, {1, 2, 2, 2}, {2, 2, 2, 2}.

Naive Approach: There are two choices for each number that it can be taken or can be left. Also, a number can be taken multiple times.

• Elements that are taken multiple times should be consecutive in the array as the array should be sorted.
• If an element is left and has moved to another element then that element can not be taken again.

Recursive Approach:

The left branch is indicating that the element is taken and the right branch indicating that the element is left and the pointer moved to the next element.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``int` `countSortedArrays(``int` `start, ``int` `m,``                      ``int` `size, ``int` `n)``{``    ``// If size becomes equal to m,``    ``// that means an array is found``    ``if` `(size == m)``        ``return` `1;` `    ``if` `(start > n)``        ``return` `0;` `    ``int` `notTaken = 0, taken = 0;` `    ``// Include current element, increase``    ``// size by 1 and remain on the same``    ``// element as it can be included again``    ``taken = countSortedArrays(start, m,``                              ``size + 1, n);` `    ``// Exclude current element``    ``notTaken = countSortedArrays(start + 1,``                                 ``m, size, n);` `    ``// Return the sum obtained``    ``// in both the cases``    ``return` `taken + notTaken;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `n = 2, m = 3;` `    ``// Function Call``    ``cout << countSortedArrays(1, m, 0, n);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;` `class` `GFG{` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``static` `int` `countSortedArrays(``int` `start, ``int` `m,``                             ``int` `size, ``int` `n)``{``    ` `    ``// If size becomes equal to m,``    ``// that means an array is found``    ``if` `(size == m)``        ``return` `1``;`` ` `    ``if` `(start > n)``        ``return` `0``;`` ` `    ``int` `notTaken = ``0``, taken = ``0``;`` ` `    ``// Include current element, increase``    ``// size by 1 and remain on the same``    ``// element as it can be included again``    ``taken = countSortedArrays(start, m,``                              ``size + ``1``, n);`` ` `    ``// Exclude current element``    ``notTaken = countSortedArrays(start + ``1``,``                                 ``m, size, n);`` ` `    ``// Return the sum obtained``    ``// in both the cases``    ``return` `taken + notTaken;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given Input``    ``int` `n = ``2``, m = ``3``;``    ` `    ``// Function Call``    ``System.out.println(countSortedArrays(``1``, m, ``0``, n));``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach` `# Function to find the number of``# M-length sorted arrays possible``# using numbers from the range [1, N]``def` `countSortedArrays(start, m, size, n):``    ` `    ``# If size becomes equal to m,``    ``# that means an array is found``    ``if` `(size ``=``=` `m):``        ``return` `1` `    ``if` `(start > n):``        ``return` `0` `    ``notTaken, taken ``=` `0``, ``0` `    ``# Include current element, increase``    ``# size by 1 and remain on the same``    ``# element as it can be included again``    ``taken ``=` `countSortedArrays(start, m, ``                              ``size ``+` `1``, n)` `    ``# Exclude current element``    ``notTaken ``=` `countSortedArrays(start ``+` `1``, ``                                 ``m, size, n)` `    ``# Return the sum obtained``    ``# in both the cases``    ``return` `taken ``+` `notTaken` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given Input``    ``n, m ``=` `2``, ``3` `    ``# Function Call``    ``print` `(countSortedArrays(``1``, m, ``0``, n))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``static` `int` `countSortedArrays(``int` `start, ``int` `m,``                             ``int` `size, ``int` `n)``{``    ` `    ``// If size becomes equal to m,``    ``// that means an array is found``    ``if` `(size == m)``        ``return` `1;`` ` `    ``if` `(start > n)``        ``return` `0;`` ` `    ``int` `notTaken = 0, taken = 0;`` ` `    ``// Include current element, increase``    ``// size by 1 and remain on the same``    ``// element as it can be included again``    ``taken = countSortedArrays(start, m,``                              ``size + 1, n);`` ` `    ``// Exclude current element``    ``notTaken = countSortedArrays(start + 1,``                                 ``m, size, n);`` ` `    ``// Return the sum obtained``    ``// in both the cases``    ``return` `taken + notTaken;``}``    ` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Given Input``    ``int` `n = 2, m = 3;`` ` `    ``// Function Call``    ``Console.WriteLine(countSortedArrays(1, m, 0, n));``}``}` `// This code is contributed by susmitakundugoaldanga`

## Javascript

 ``

Output:
`4`

Time Complexity: O(2N)
Auxiliary Space: O(1)

Recursive Approach with optimization:

• Traverse through each element and try to find all possible arrays starting from that element.
• In the previous approach for the right branch, the element is left first and in the next step, shifted to the next element.
• In this approach, instead of leaving the element first and then moving to the next element, directly go to the next element, so there will be fewer function calls.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``void` `countSortedArrays(``int` `st, ``int` `n,``                       ``int` `m, ``int``& ans, ``int` `size)``{``    ``// If size becomes equal to m``    ``// one sorted array is found``    ``if` `(size == m) {``        ``ans += 1;``        ``return``;``    ``}` `    ``// Traverse over the range [st, N]``    ``for` `(``int` `i = st; i <= n; i++) {` `        ``// Find all sorted arrays``        ``// starting from i``        ``countSortedArrays(i, n, m,``                          ``ans, size + 1);``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `n = 2, m = 3;` `    ``// Store the required result``    ``int` `ans = 0;` `    ``// Function Call``    ``countSortedArrays(1, n, m, ans, 0);` `    ``// Print the result``    ``cout << ans;` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``static` `int` `countSortedArrays(``int` `st, ``int` `n,``                             ``int` `m, ``int` `ans, ``                             ``int` `size)``{``    ` `    ``// If size becomes equal to m``    ``// one sorted array is found``    ``if` `(size == m)``    ``{``        ``ans += ``1``;``      ``System.out.println(ans);``      ``return` `ans;``      ` `    ``}` `    ``// Traverse over the range [st, N]``    ``for``(``int` `i = st; i <= n; i++)``    ``{``        ` `        ``// Find all sorted arrays``        ``// starting from i``        ``ans = countSortedArrays(i, n, m,``                                ``ans, size + ``1``);``    ``}``      ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given Input``    ``int` `n = ``2``, m = ``3``;` `    ``// Store the required result``    ``int` `ans = ``0``;` `    ``// Function Call``    ``ans = countSortedArrays(``1``, n, m, ans, ``0``);` `    ``// Print the result``    ``System.out.println(ans);``}``}` `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python program for the above approach`` ` `# Function to find the number of``# M-length sorted arrays possible``# using numbers from the range [1, N]` `def` `countSortedArrays( st, n, m, ans, size):``    ` `    ``# If size becomes equal to m``    ``# one sorted array is found``    ``if` `(size ``=``=` `m):``        ``ans ``+``=` `1``        ``return` `ans``    ` `    ``# Traverse over the range [st, N]``    ``for` `i ``in` `range``(st,n``+``1``):``        ` `        ``# Find all sorted arrays``        ``# starting from i``        ``ans ``=` `countSortedArrays(i, n, m, ans, size ``+` `1``)``    ``return` `ans` `# Given Input``n ``=` `2``m ``=` `3` `# Store the required result``ans ``=` `0` `# Function Call``ans ``=` `countSortedArrays(``1``, n, m, ans, ``0``)` `# Print the result``print``(ans)` `# This code is contributed by unknown2108.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``static` `int` `countSortedArrays(``int` `st, ``int` `n,``                             ``int` `m, ``int` `ans, ``                             ``int` `size)``{``    ` `    ``// If size becomes equal to m``    ``// one sorted array is found``    ``if` `(size == m)``    ``{``        ``ans += 1;``        ``return` `ans;``    ``}` `    ``// Traverse over the range [st, N]``    ``for``(``int` `i = st; i <= n; i++)``    ``{``        ` `        ``// Find all sorted arrays``        ``// starting from i``        ``ans = countSortedArrays(i, n, m,``                                ``ans, size + 1);``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given Input``    ``int` `n = 2, m = 3;` `    ``// Store the required result``    ``int` `ans = 0;` `    ``// Function Call``    ``ans = countSortedArrays(1, n, m, ans, 0);` `    ``// Print the result``    ``Console.Write(ans);``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:
`4`

Time Complexity: O(2N)
Auxiliary Space: O(1)

Dynamic Programming Approach: It can be observed that this problem has overlapping subproblems and optimal substructure property, i.e, it satisfies both properties of dynamic programming. So, the idea is to use a 2D table to memorize the results during the function calls.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``int` `countSortedArrays(vector >& dp,``                      ``int` `m, ``int` `n)``{``    ``// Base cases``    ``if` `(m == 0) {``        ``return` `1;``    ``}``    ``if` `(n <= 0)``        ``return` `0;` `    ``// If the result is already computed,``    ``// return the result of the state``    ``if` `(dp[m][n] != -1)``        ``return` `dp[m][n];` `    ``int` `taken = 0, notTaken = 0;` `    ``// Include current element, decrease``    ``// required size by 1 and remain on the``    ``// same element, as it can be taken again``    ``taken = countSortedArrays(dp, m - 1, n);` `    ``// If element is not included``    ``notTaken = countSortedArrays(dp, m, n - 1);` `    ``// Store the result and return it``    ``return` `dp[m][n] = taken + notTaken;``}` `// Driver Code``int` `main()``{` `    ``// Given Input``    ``int` `n = 2, m = 3;` `    ``// Create an 2D array for memoization``    ``vector > dp(m + 1,``                            ``vector<``int``>(n + 1, -1));` `    ``// Function Call``    ``cout << countSortedArrays(dp, m, n);` `    ``return` `0;``}`

## Java

 `import` `java.util.*;``import` `java.io.*;` `// Java program for the above approach``class` `GFG{` `  ``// Function to find the number of``  ``// M-length sorted arrays possible``  ``// using numbers from the range [1, N]``  ``static` `int` `countSortedArrays(ArrayList> dp, ``int` `m, ``int` `n)``  ``{``    ``// Base cases``    ``if` `(m == ``0``) {``      ``return` `1``;``    ``}``    ``if` `(n <= ``0``){``      ``return` `0``;``    ``}` `    ``// If the result is already computed,``    ``// return the result of the state``    ``if` `(dp.get(m).get(n) != -``1``){``      ``return` `dp.get(m).get(n);``    ``}` `    ``int` `taken = ``0``, notTaken = ``0``;` `    ``// Include current element, decrease``    ``// required size by 1 and remain on the``    ``// same element, as it can be taken again``    ``taken = countSortedArrays(dp, m - ``1``, n);` `    ``// If element is not included``    ``notTaken = countSortedArrays(dp, m, n - ``1``);` `    ``// Store the result and return it``    ``dp.get(m).set(n, taken + notTaken);``    ``return` `taken + notTaken;``  ``}` `  ``public` `static` `void` `main(String args[])``  ``{``    ``// Given Input``    ``int` `n = ``2``, m = ``3``;` `    ``// Create an 2D array for memoization``    ``ArrayList> dp = ``new` `ArrayList>();``    ``for``(``int` `i = ``0` `; i <= m ; i++){``      ``dp.add(``new` `ArrayList());``      ``for``(``int` `j = ``0` `; j <=n ; j++){``        ``dp.get(i).add(-``1``);``      ``}``    ``}` `    ``// Function Call``    ``System.out.println(countSortedArrays(dp, m, n));``  ``}``}` `// This code is contributed by subhamgoyal2014.`

## Python3

 `# Python3 program for the above approach` `# Function to find the number of``# M-length sorted arrays possible``# using numbers from the range [1, N]``def` `countSortedArrays(dp, m, n):``    ``# Base cases``    ``if``(m ``=``=` `0``):``        ``return` `1``    ``if``(n <``=` `0``):``        ``return` `0``    ` `    ``# If the result is already computed,``    ``# return the result of the state``    ``if``(dp[m][n] !``=` `-``1``):``        ``return` `dp[m][n]``        ` `    ``taken, notTaken ``=` `0``, ``0``    ` `    ``# Include current element, decrease``    ``# required size by 1 and remain on the``    ``# same element, as it can be taken again``    ``taken ``=` `countSortedArrays(dp, m ``-` `1``, n)``    ` `    ``# If element is not included``    ``notTaken ``=` `countSortedArrays(dp, m, n ``-` `1``)``    ` `    ``# Store the result and return it``    ``dp[m][n] ``=` `taken ``+` `notTaken``    ``return` `dp[m][n]``    ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given Input``    ``n, m ``=` `2``, ``3``    ` `    ``# Create an 2D array for memoization``    ``dp``=``[[``-``1` `for` `i ``in` `range``(n``+``1``)] ``for` `j ``in` `range``(m``+``1``)]` `    ``# Function Call``    ``print` `(countSortedArrays(dp, m, n))` `# This code is contributed by Pushpesh Raj`

## C#

 `// C# program to implement above approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `GFG``{` `  ``// Function to find the number of``  ``// M-length sorted arrays possible``  ``// using numbers from the range [1, N]``  ``static` `int` `countSortedArrays(List> dp, ``int` `m, ``int` `n)``  ``{``    ``// Base cases``    ``if` `(m == 0) {``      ``return` `1;``    ``}``    ``if` `(n <= 0){``      ``return` `0;``    ``}` `    ``// If the result is already computed,``    ``// return the result of the state``    ``if` `(dp[m][n] != -1){``      ``return` `dp[m][n];``    ``}` `    ``int` `taken = 0, notTaken = 0;` `    ``// Include current element, decrease``    ``// required size by 1 and remain on the``    ``// same element, as it can be taken again``    ``taken = countSortedArrays(dp, m - 1, n);` `    ``// If element is not included``    ``notTaken = countSortedArrays(dp, m, n - 1);` `    ``// Store the result and return it``    ``dp[m][n] = taken + notTaken;``    ``return` `taken + notTaken;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args){` `    ``// Given Input``    ``int` `n = 2, m = 3;` `    ``// Create an 2D array for memoization``    ``List> dp = ``new` `List>();``    ``for``(``int` `i = 0 ; i <= m ; i++){``      ``dp.Add(``new` `List<``int``>());``      ``for``(``int` `j = 0 ; j <= n ; j++){``        ``dp[i].Add(-1);``      ``}``    ``}` `    ``// Function Call``    ``Console.WriteLine(countSortedArrays(dp, m, n));` `  ``}``}` `// This code is contributed by entertain2022.`

## Javascript

 `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``function` `countSortedArrays( dp,m,  n)``{``    ``// Base cases``    ``if` `(m == 0) {``        ``return` `1;``    ``}``    ``if` `(n <= 0)``        ``return` `0;` `    ``// If the result is already computed,``    ``// return the result of the state``    ``if` `(dp[m][n] != -1)``        ``return` `dp[m][n];` `    ``let taken = 0, notTaken = 0;` `    ``// Include current element, decrease``    ``// required size by 1 and remain on the``    ``// same element, as it can be taken again``    ``taken = countSortedArrays(dp, m - 1, n);` `    ``// If element is not included``    ``notTaken = countSortedArrays(dp, m, n - 1);` `    ``// Store the result and return it``    ``return` `dp[m][n] = taken + notTaken;``}` `// Driver Code`  `    ``// Given Input``    ``let n = 2, m = 3;` `    ``// Create an 2D array for memoization``    ``var` `dp = ``new` `Array(m+1);``    ``for``(let i = 0; i <= m; i++)``            ``dp[i] = ``new` `Array(n+1);``    ``for``(let i = 0; i <= m; i++)``        ``for``(let j = 0; j <= n; j++)``            ``dp[i][j] = -1;` `    ``// Function Call``    ``console.log(countSortedArrays(dp, m, n));` `// This code is contributed by garg28harsh.`

Output:
`4`

Time Complexity: O(N*M)
Auxiliary Space: O(N*M)

Space Optimized Iterative Dynamic Programming Approach:

• As all elements are available as many times as needed, so there is no need to save values for previous rows, the values from the same row can be used.
• So a 1-D array can be used to save previous results.
• Create an array, dp of size M, where dp[i] stores the maximum number of sorted arrays of size i that can be formed from numbers in the range [1, N].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the number of``// M-length sorted arrays possible``// using numbers from the range [1, N]``int` `countSortedArrays(``int` `n, ``int` `m)``{``    ``// Create an array of size M+1``    ``vector<``int``> dp(m + 1, 0);` `    ``// Base cases``    ``dp[0] = 1;` `    ``// Fill the dp table``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``for` `(``int` `j = 1; j <= m; j++) {` `            ``// dp[j] will be equal to maximum``            ``// number of sorted array of size j``            ``// when elements are taken from 1 to i``            ``dp[j] = dp[j - 1] + dp[j];``        ``}` `        ``// Here dp[m] will be equal to the``        ``// maximum number of sorted arrays when``        ``// element are taken from 1 to i``    ``}` `    ``// Return the result``    ``return` `dp[m];``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `n = 2, m = 3;` `    ``// Function Call``    ``cout << countSortedArrays(n, m);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``public` `class` `Main``{``    ``// Function to find the number of``    ``// M-length sorted arrays possible``    ``// using numbers from the range [1, N]``    ``static` `int` `countSortedArrays(``int` `n, ``int` `m)``    ``{``        ``// Create an array of size M+1``        ``int``[] dp = ``new` `int``[(m + ``1``)];`` ` `        ``// Base cases``        ``dp[``0``] = ``1``;`` ` `        ``// Fill the dp table``        ``for` `(``int` `i = ``1``; i <= n; i++) {``            ``for` `(``int` `j = ``1``; j <= m; j++) {`` ` `                ``// dp[j] will be equal to maximum``                ``// number of sorted array of size j``                ``// when elements are taken from 1 to i``                ``dp[j] = dp[j - ``1``] + dp[j];``            ``}`` ` `            ``// Here dp[m] will be equal to the``            ``// maximum number of sorted arrays when``            ``// element are taken from 1 to i``        ``}`` ` `        ``// Return the result``        ``return` `dp[m];``    ``}``    ` `  ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Given Input``        ``int` `n = ``2``, m = ``3``;`` ` `        ``// Function Call``        ``System.out.print(countSortedArrays(n, m));``    ``}``}` `// This code is contributed by suresh07.`

## Python3

 `# Python program for the above approach``# Function to find the number of``# M-length sorted arrays possible``# using numbers from the range [1, N]``def` `countSortedArrays(n, m):``  ` `    ``# Create an array of size M+1``    ``dp ``=` `[``0` `for` `_ ``in` `range``(m ``+` `1``)]``    ` `    ``# Base cases``    ``dp[``0``] ``=` `1` `    ``# Fill the dp table``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``for` `j ``in` `range``(``1``, m ``+` `1``):``          ` `            ``# dp[j] will be equal to maximum``            ``# number of sorted array of size j``            ``# when elements are taken from 1 to i``            ``dp[j] ``=` `dp[j ``-` `1``] ``+` `dp[j]` `        ``# Here dp[m] will be equal to the``        ``# maximum number of sorted arrays when``        ``# element are taken from 1 to i` `    ``# Return the result``    ``return` `dp[m]` `# Driver code``# Given Input``n ``=` `2``m ``=` `3` `# Function Call``print` `(countSortedArrays(n, m))` `# This code is contributed by rdtank.`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG {``    ``// Function to find the number of``    ``// M-length sorted arrays possible``    ``// using numbers from the range [1, N]``    ``static` `int` `countSortedArrays(``int` `n, ``int` `m)``    ``{``        ``// Create an array of size M+1``        ``int``[] dp = ``new` `int``[(m + 1)];` `        ``// Base cases``        ``dp[0] = 1;` `        ``// Fill the dp table``        ``for` `(``int` `i = 1; i <= n; i++) {``            ``for` `(``int` `j = 1; j <= m; j++) {` `                ``// dp[j] will be equal to maximum``                ``// number of sorted array of size j``                ``// when elements are taken from 1 to i``                ``dp[j] = dp[j - 1] + dp[j];``            ``}` `            ``// Here dp[m] will be equal to the``            ``// maximum number of sorted arrays when``            ``// element are taken from 1 to i``        ``}` `        ``// Return the result``        ``return` `dp[m];``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``      ` `        ``// Given Input``        ``int` `n = 2, m = 3;` `        ``// Function Call``        ``Console.WriteLine(countSortedArrays(n, m));``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output:
`4`

Time Complexity: O(N*M)
Auxiliary Space: O(M)

Previous
Next