Number of Ways to Separate Numbers - Practice Coding Problems

Number of Ways to Separate Numbers - Problem

You wrote down many positive integers in a string called num. However, you realized that you forgot to add commas to separate the different numbers. You remember that the list of integers was non-decreasing and that no integer had leading zeros.

For example, if you had the string "327", it could have been originally:
• [3, 27] - valid (3 ≤ 27)
• [32, 7] - invalid (32 > 7)
• [3, 2, 7] - invalid (3 > 2)

Return the number of possible lists of integers that you could have written down to get the string num. Since the answer may be large, return it modulo 10⁹ + 7.

This is a challenging dynamic programming problem that requires careful handling of string comparisons and number formations.

Input & Output

example_1.py — Basic Case

$ Input: num = "327"

› Output: 2

💡 Note: The two possible lists are [3, 27] and [327]. We cannot have [32, 7] because 32 > 7, and we cannot have [3, 2, 7] because 3 > 2.

example_2.py — Leading Zero Case

$ Input: num = "094"

› Output: 0

💡 Note: No valid lists can be formed because any partition would start with "0" which represents a number with leading zero (except single digit 0, but "094" cannot be just "0").

example_3.py — Multiple Valid Partitions

$ Input: num = "1234"

› Output: 8

💡 Note: Valid partitions are: [1, 2, 3, 4], [1, 2, 34], [1, 23, 4] (invalid: 23 > 4), [1, 234], [12, 34], [123, 4] (invalid: 123 > 4), [1234]. After filtering invalid ones, we get 8 valid partitions.

Constraints

1 ≤ num.length ≤ 3500
num consists of digits '0' through '9'
No leading zeros are allowed in any number
The sequence must be non-decreasing
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify Constraints

Numbers must be non-decreasing and have no leading zeros

Use Dynamic Programming

Build solutions incrementally, tracking last number length

Efficient Comparison

Use LCP preprocessing for fast string comparisons

Count All Valid Ways

Sum all possible valid partitions

Key Takeaway

🎯 Key Insight: Dynamic programming with efficient string comparison using LCP preprocessing allows us to solve this complex constraint satisfaction problem in polynomial time.

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22

The optimal approach uses Dynamic Programming with efficient string comparison. We maintain dp[i][j] representing the number of ways to partition the first i characters ending with a number of length j. The key insight is using Longest Common Prefix (LCP) preprocessing for O(1) string comparisons, achieving O(n³) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³)	O(n²)	Use DP with efficient string comparison to count valid partitions

Dynamic Programming (Optimal) — Algorithm Steps

Create DP table where dp[i][j] = ways to partition first i chars ending with number of length j
For each position, try all possible lengths for the current number
Use efficient string comparison to check if current number ≥ previous number
Handle leading zeros constraint
Sum all valid ways

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Table

dp[i][j] = ways to partition first i chars ending with length j

Fill Base Cases

Single numbers from start position

Build Solutions

For each position, try all valid previous partitions

Sum Results

Add all ways ending at position n

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MOD 1000000007

int compare(char* num, int** lcp, int i1, int len1, int i2, int len2) {
    if (len1 != len2) return len1 - len2;
    int common = lcp[i1][i2];
    if (common >= len1) return 0;
    return num[i1 + common] - num[i2 + common];
}

int numberOfCombinations(char* num) {
    int n = strlen(num);
    if (num[0] == '0') return 0;
    
    // Allocate LCP array
    int** lcp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        lcp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Precompute LCP
    for (int i = n - 1; i >= 0; i--) {
        for (int j = n - 1; j >= 0; j--) {
            if (num[i] == num[j]) {
                if (i == n - 1 || j == n - 1) {
                    lcp[i][j] = 1;
                } else {
                    lcp[i][j] = lcp[i + 1][j + 1] + 1;
                }
            }
        }
    }
    
    // Allocate DP array
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)calloc(n + 1, sizeof(long long));
    }
    
    // Base case
    for (int i = 1; i <= n; i++) {
        if (num[0] != '0' || i == 1) {
            dp[i][i] = 1;
        }
    }
    
    for (int i = 2; i <= n; i++) {
        for (int j = 1; j < i; j++) {
            if (num[i - j] == '0' && j > 1) continue;
            
            for (int k = 1; k <= i - j; k++) {
                int prevStart = i - j - k;
                int currStart = i - j;
                
                if (num[prevStart] == '0' && k > 1) continue;
                
                if (compare(num, lcp, prevStart, k, currStart, j) <= 0) {
                    dp[i][j] = (dp[i][j] + dp[i - j][k]) % MOD;
                }
            }
        }
    }
    
    long long result = 0;
    for (int j = 1; j <= n; j++) {
        result = (result + dp[n][j]) % MOD;
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(lcp[i]);
    }
    free(lcp);
    
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return (int)result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) states in DP table, O(n) for string comparison in worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size O(n²) plus space for LCP preprocessing

⚠ Quadratic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

967 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler