Restore The Array - Practice Coding Problems

Restore The Array - Problem

Imagine you're a forensic data analyst working with a corrupted program output! 🕵️‍♀️

A program was supposed to print an array of integers, but it forgot to include spaces between the numbers. Now you have a continuous string of digits, and you need to figure out how many different ways the original array could have been structured.

The Rules:

All integers in the original array were between 1 and k (inclusive)
No number had leading zeros (so no 01, 007, etc.)
The string s represents all numbers concatenated together

Your Mission: Count how many different valid arrays could produce the given string s.

Example: If s = "1000" and k = 10000, this could be:
• [1, 0, 0, 0] ❌ (contains 0, which is not in range [1,k])
• [10, 0, 0] ❌ (contains 0)
• [100, 0] ❌ (contains 0)
• [1000] ✅ (valid!)

Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: s = "1000", k = 10000

› Output: 1

💡 Note: Only one valid way: [1000]. Other attempts like [1,0,0,0], [10,0,0], [100,0] fail because 0 is not in range [1,k].

example_2.py — Multiple Partitions

$ Input: s = "1000", k = 10

› Output: 0

💡 Note: No valid way to partition. We need numbers ≤ 10, but we can't use 0, and 1000 > 10, 100 > 10, 00 has leading zeros.

example_3.py — Complex Case

$ Input: s = "1317", k = 2000

› Output: 8

💡 Note: Valid partitions: [1,3,1,7], [1,3,17], [1,31,7], [1,317], [13,1,7], [13,17], [131,7], [1317]. All numbers are ≤ 2000 and have no leading zeros.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only digits
1 ≤ k ≤ 10⁹
No leading zeros in any number of the array

Visualization

Tap to expand

Understanding the Visualization

Identify the Challenge

We have a string of digits with missing spaces, like a telegram

Set the Rules

Each number must be between 1 and k, with no leading zeros

Build Solutions Incrementally

Use DP to count valid ways to split progressively longer prefixes

Consider All Possibilities

At each position, try all valid numbers that could end there

Combine Results

Sum up ways from previous positions to get total count

Key Takeaway

🎯 Key Insight: This is a classic DP problem where we build the solution incrementally. Each position's answer depends on previous positions, and we can avoid recalculation by storing intermediate results. The constraint about leading zeros and the upper bound k add complexity to the validation, but the core DP pattern remains elegant and efficient.

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

This problem is solved optimally using Dynamic Programming. The key insight is that the number of ways to partition a string depends on the number of ways to partition its prefixes. We use dp[i] to represent the number of ways to partition s[0...i-1], and for each position, we consider all valid numbers ending at that position. The time complexity is O(n² × log k) and space complexity is O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up Dynamic Programming (Optimal)	O(n² * log k)	O(n)	Build solution iteratively from left to right using DP table

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Create DP array where dp[i] = number of ways to split s[0...i-1]
Initialize dp[0] = 1 (empty string has one way to split)
For each position i, try all possible starting positions j < i
Check if substring s[j...i-1] forms a valid number (≤ k, no leading zeros)
If valid, add dp[j] to dp[i]
Return dp[n] where n is the string length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

dp[0] = 1 (empty string), others = 0

Fill table left to right

For each position i, consider all valid numbers ending at i

Check valid substrings

For each j < i, check if s[j:i] forms a valid number

Update DP value

If valid, add dp[j] to dp[i]

Final result

dp[n] contains the answer

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 1001

int dp[MAX_N];

int isValidNumber(char* s, int start, int end, int k) {
    if (s[start] == '0' && end > start) return 0; // Leading zero
    
    long long num = 0;
    for (int i = start; i < end; i++) {
        num = num * 10 + (s[i] - '0');
        if (num > k) return 0;
    }
    return 1;
}

int main() {
    char s[MAX_N];
    int k;
    scanf("%s %d", s, &k);
    
    int n = strlen(s);
    if (s[0] == '"') {
        memmove(s, s + 1, n - 1);
        s[n - 2] = '\0';
        n -= 2;
    }
    
    memset(dp, 0, sizeof(dp));
    dp[0] = 1;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < i; j++) {
            if (isValidNumber(s, j, i, k)) {
                dp[i] = (dp[i] + dp[j]) % MOD;
            }
        }
    }
    
    printf("%d\n", dp[n]);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * log k)

For each of n positions, we check up to n previous positions, and each number comparison takes log k time

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n+1 to store intermediate results

⚡ Linearithmic Space

34.4K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler