Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Basic
  • Last Updated : 13 Jul, 2021

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 <bits/stdc++.h>
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




<script>
 
// JavaScript program for the above approach
 
// Function to find the number of
// M-length sorted arrays possible
// using numbers from the range [1, N]
function 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;
     
    var 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
 
// Given Input
var n = 2,
m = 3;
 
// Function Call
document.write(countSortedArrays(1, m, 0, n));
 
// This code is contributed by rdtank
 
</script>
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 <bits/stdc++.h>
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




<script>
 
// JavaScript program for the above approach
 
// Function to find the number of
// M-length sorted arrays possible
// using numbers from the range [1, N]
function 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(var i = st; i <= n; i++)
    {
         
        // Find all sorted arrays
        // starting from i
        ans = countSortedArrays(i, n, m, ans, size + 1);
    }
      return ans;
}
 
// Given Input
    var n = 2, m = 3;
 
    // Store the required result
    var ans = 0;
 
    // Function Call
    ans = countSortedArrays(1, n, m, ans, 0);
 
    // Print the result
   document.write(ans);
    
// This code is contributed by SoumikMondal
 
</script>
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 memoize the results during the function calls.

Below is the implementation of the above approach: 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the number of
// M-length sorted arrays possible
// using numbers from the range [1, N]
int countSortedArrays(vector<vector<int> >& 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<vector<int> > dp(m + 1,
                            vector<int>(n + 1, -1));
 
    // Function Call
    cout << countSortedArrays(dp, m, n);
 
    return 0;
}
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 <bits/stdc++.h>
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;
}

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




<script>
 
    // JavaScript program for the above approach
     
    // Function to find the number of
    // M-length sorted arrays possible
    // using numbers from the range [1, N]
    function countSortedArrays(n, m)
    {
        // Create an array of size M+1
        let dp = new Array(m + 1);
        dp.fill(0);
  
        // Base cases
        dp[0] = 1;
  
        // Fill the dp table
        for (let i = 1; i <= n; i++) {
            for (let 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];
    }
     
    // Given Input
    let n = 2, m = 3;
 
    // Function Call
    document.write(countSortedArrays(n, m));
 
</script>
Output: 
4

 

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

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :