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

// 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

// 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.

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<ArrayList<Integer>> 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<ArrayList<Integer>> dp = new ArrayList<ArrayList<Integer>>();
    for(int i = 0 ; i <= m ; i++){
      dp.add(new ArrayList<Integer>());
      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.

// 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.