Count digit groupings of a number with given constraints

// Java program to count number 
// of ways to group digits of  
// a number such that sum of  
// digits in every subgroup is 
// less than or equal to its 
// immediate right subgroup.
import java.io.*;

class GFG 
{

// Function to find
// the subgroups
static int countGroups(int position, 
                       int previous_sum, 
                       int length, 
                       String num)
{
    // Terminating Condition
    if (position == length)
        return 1;

    int res = 0;
    
    // sum of digits
    int sum = 0; 

    // Traverse all digits from
    // current position to rest
    // of the length of string
    for (int i = position; i < length; i++)
    {
        sum += (num.charAt(i) - '0');

        // If forward_sum is greater
        // than the previous sum,
        // then call the method again
        if (sum >= previous_sum)

        // Note : We pass current 
        // sum as previous sum
        res += countGroups(i + 1, sum, 
                         length, num);
    }

    // Total number of subgroups
    // till current position
    return res;
}

// Driver Code
public static void main (String[] args)
{
    String num = "1119";
    int len =num .length();
    System.out.println(countGroups(0, 0, 
                                   len, num));
}
}

// This code is contributed by anuj_67.

    
// Java program to count the number of 
// ways to group digits of a number
// such that sum of digits in every 
// subgroup is less than or equal
// to its immediate right subgroup.
class GFG 
{

// Maximum length of 
// input number string
static int MAX = 40;

// A memoization table to store 
// results of subproblems length
// of string is 40 and maximum 
// sum will be 9 * 40 = 360.
static int dp[][] = new int[MAX][9 * MAX + 1];

// Function to find the count
// of splits with given condition
static int countGroups(int position, 
                int previous_sum, 
                int length, char []num)
{
    // Terminating Condition
    if (position == length)
        return 1;

    // If already evaluated for 
    // a given sub problem then
    // return the value
    if (dp[position][previous_sum] != -1)
        return dp[position][previous_sum];

    // countGroups for current 
    // sub-group is 0
    dp[position][previous_sum] = 0;

    int res = 0;
    
    // sum of digits
    int sum = 0; 

    // Traverse all digits from
    // current position to rest
    // of the length of string
    for (int i = position; i < length; i++)
    {
        sum += (num[i] - '0');

        // If forward_sum is greater 
        // than the previous sum,
        // then call the method again
        if (sum >= previous_sum)

        // Note : We pass current
        // sum as previous sum
        res += countGroups(i + 1, sum, 
                        length, num);
    }

    dp[position][previous_sum] = res;

    // total number of subgroups 
    // till current position
    return res;
}

// Driver Code
public static void main(String[] args)
{
    char num[] = "1119".toCharArray();
    int len = num.length;

    // Initialize dp table
    for(int i = 0; i < dp.length; i++)
    {
        for(int j = 0;j < 9 * MAX + 1; j++){
            dp[i][j] = -1;
        }
    }
    System.out.println(countGroups(0, 0, len, num));
    }
} 

// This code is contributed by PrinciRaj1992

// Java program to count number of
// ways to group digits of a number
// such that sum of digits in every
// subgroup is less than or equal to
// its immediate right subgroup.
import java.util.*;

public class Main {

    public static int countGroups(String num) {
        // Compute the sum of digits in the input string
        int length = num.length();
        int x = 0;
        for (int i = 0; i < length; i++) {
            x += num.charAt(i) - '0';
        }

        // Initialize a 2D table of size (length+1)x(x+1)
        int[][] dp = new int[length + 1][x + 1];

        // Base case: set all values in the last row to 1
        for (int s = 0; s <= x; s++) {
            dp[length][s] = 1;
        }

        // Fill the table in bottom-up manner
        for (int position = length - 1; position >= 0; position--) {
            for (int previous_sum = 0; previous_sum <= x; previous_sum++) {
                int sum = 0;
                int res = 0;

                // Compute the number of sub-strings with sum >=
                // previous_sum
                for (int i = position; i < length; i++) {
                    sum += (num.charAt(i) - '0');
                    if (sum >= previous_sum) {
                        res += dp[i + 1][sum];
                    }
                }

                // Store the result in the current position of
                // the table
                dp[position][previous_sum] = res;
            }
        }

        // Return the value in the top-left corner of the table
        return dp[0][0];
    }

    // Driver Code
    public static void main(String[] args) {
        String str = "1119";
        System.out.println("number of groupings : " + countGroups(str));
    }
}
//this is contributed by RAVI SINGH