Related Articles

# Count ways to partition a number into increasing sequences of digits

• Difficulty Level : Expert
• Last Updated : 21 Jul, 2021

Given a numeric string S, the task is to find the number of ways to partition a string into substrings consisting of digits in increasing order.

Examples:

Input: S = “1345”
Output: 5
Explanation: Possible partitions are as follows:

1. 
2. [13, 45], [1, 345]
3. [1, 3, 45]
4. [1, 3, 4, 5]

Input: S = “12”
Output: 2

Approach: This problem can be solved by observing that between each digit either it will be a part of the previous number or it will be a new number so to solve the problem recursion can be used. Follow the steps below to solve the problem:

• Initialize an integer variable, say count as 0, to store the number of ways to partition a string into increasing subsets.
• Declare a function print() with index(storing current position), string S(given string in the question), and string ans( as parameters.
• Now, following two cases are required to be considered:
• If S[index] is inserted in the previous number, then append S[index] at the end of ans and recall the function print() with parameters index + 1, S, and ans.
• If S[index] is not a part of the previous number, then append ” “(space) at the end of ans and then insert S[index] and recall the function print() with parameters index + 1, S, ans.
• If index = S.length(), then check if the the digits in the sequences formed are in increasing order or not. If the sequences formed are increasing, increase count by 1.
• Print count as the answer after performing the above steps.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include``using` `namespace` `std;` `// Stores the number of ways``// to partition a string``int` `count1 = 0;``vector splt(string str)``{``    ``vector ans;``    ``string word = ``""``;``    ``for``(``auto` `x : str)``    ``{``        ``if` `(x == ``' '``)``        ``{``            ``ans.push_back(word);``            ``word = ``""``;``        ``}``        ``else``        ``{``            ``word = word + x;``        ``}``    ``}``    ``ans.push_back(word);``    ``return` `ans;``}` `// Function to check if a sequence``// is strictly increasing or not``bool` `check(string m)``{``    ` `    ``// If there is only one number``    ``if` `(m.length() == 1)``    ``{``        ``return` `true``;``    ``}``    ` `    ``// Split the string m when there is space``    ``vector temp = splt(m);``    ``int` `number[temp.size()];``    ` `    ``// Insert all the splits into the array``    ``for``(``int` `i = 0; i < temp.size(); ++i)``    ``{``        ``number[i] = stoi(temp[i]);``    ``}``    ` `    ``int` `first = number;``    ``for``(``int` `i = 1; i < temp.size(); ++i)``    ``{``        ``if` `(number[i] > first)``        ``{``            ``first = number[i];``        ``}``        ``else``        ``{``            ` `            ``// If number is not increasing``            ``return` `false``;``        ``}``    ``}``    ` `    ``// If the sequence is increasing``    ``return` `true``;``}` `// Recursive function to partition``// a string in every possible substrings``void` `print1(string m, ``int` `index, string ans)``{``    ` `    ``// If index = m.length, check if ans``    ``// forms an increasing sequence or not``    ``if` `(index == m.length())``    ``{``    ` `        ``if` `(check(ans))``        ``{``        ` `            ``// Increment count by 1,``            ``// if sequence is increasing``            ``count1++;``        ``}``        ``return``;``    ``}  ` `    ``// If S[index] is appended to previous number``    ``print1(m, index + 1, ans + m[index]);``    ` `    ``if` `(index != 0)``    ` `        ``// If S[index] is starting a new number``        ``print1(m, index + 1,``              ``ans + ``" "` `+ m[index]);``}` `// Driver Code``int` `main()``{``    ` `    ``// Given Input``    ``string k = ``"1345"``;``    ` `    ``// Function Call``    ``print1(k, 0, ``""``);``    ` `    ``// Print the answer.``    ``cout << count1;``}` `// This code is contributed by ipg2016107`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;``class` `GFG {` `    ``// Stores the number of ways``    ``// to partition a string``    ``static` `int` `count = ``0``;` `    ``// Function to check if a sequence``    ``// is strictly increasing or not``    ``static` `boolean` `check(String m)``    ``{``        ``// If there is only one number``        ``if` `(m.length() == ``1``) {``            ``return` `true``;``        ``}` `        ``// Split the string m when there is space``        ``String temp[] = m.split(``" "``);``        ``int` `number[] = ``new` `int``[temp.length];` `        ``// Insert all the splits into the array``        ``for` `(``int` `i = ``0``; i < temp.length; ++i) {` `            ``number[i] = Integer.parseInt(temp[i]);``        ``}` `        ``int` `first = number[``0``];``        ``for` `(``int` `i = ``1``; i < number.length; ++i) {` `            ``if` `(number[i] > first) {``                ``first = number[i];``            ``}``            ``else` `{` `                ``// If number is not increasing``                ``return` `false``;``            ``}``        ``}` `        ``// If the sequence is increasing``        ``return` `true``;``    ``}` `    ``// Recursive function to partition``    ``// a string in every possible substrings``    ``static` `void` `print(String m,``                      ``int` `index, String ans)``    ``{``        ``// If index = m.length, check if ans``        ``// forms an increasing sequence or not``        ``if` `(index == m.length()) {` `            ``if` `(check(ans)) {` `                ``// Increment count by 1,``                ``// if sequence is increasing``                ``++count;``            ``}``            ``return``;``        ``}` `        ``// If S[index] is appended to previous number``        ``print(m, index + ``1``, ans + m.charAt(index));``        ``if` `(index != ``0``)``            ``// If S[index] is starting a new number``            ``print(m, index + ``1``,``                  ``ans + ``" "` `+ m.charAt(index));``    ``}` `    ``// DriverCode``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given Input``        ``String k = Integer.toString(``1345``);` `        ``// Function Call``        ``print(k, ``0``, ``""``);` `        ``// Print the answer.``        ``System.out.println(count);``    ``}``}`

## Javascript

 ``
Output:
`5`

Time Complexity: O(N*2N) where N is the length of string S
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up