Restore The Array

Restore The Array - Problem

A program was supposed to print an array of integers. Due to a bug, the program forgot to print whitespaces and the array is printed as a string of digits s.

All we know is that:

All integers in the original array were in the range [1, k]
There are no leading zeros in any of the integers

Given the string s and the integer k, return the number of possible arrays that can be printed as s using the mentioned program.

Note: Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 8

💡 Note: Possible arrays: [1,3,1,7], [1,3,17], [1,31,7], [1,317], [13,1,7], [13,17], [131,7], [1317]. All numbers are ≤ 2000.

Example 2 — Small k

$ Input: s = "2020", k = 30

› Output: 1

💡 Note: Only possible array is [20,20]. Cannot take "2020" or "202" as they exceed k=30.

Example 3 — Leading Zero

$ Input: s = "1012", k = 50

› Output: 2

💡 Note: Possible arrays: [1,0,1,2] is invalid (0 not in range [1,k]), [10,12] and [1,0,12] are invalid, only [10,1,2] and [1,012] but 012 has leading zero, so only [10,1,2] is valid. Actually [1,12] is also valid, so answer is 2: [10,1,2] and [1,12].

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only digits
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 15

The key insight is to use dynamic programming where each position represents a subproblem: "how many ways to restore from this position onwards". We can either use top-down memoization or bottom-up DP. The optimal approach is Bottom-Up DP with time complexity O(n × log k) and space O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n × log k) Space: O(n)

Use a 1D DP array where dp[i] represents the number of ways to restore the array starting from index i. Fill the array from right to left.

Brute Force Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

For each position, try taking numbers of length 1, 2, 3... until we exceed k or reach the end. Recursively count ways for the remaining string.

Memoized Recursion

⏱️ Time: O(n × log k) Space: O(n)

Same recursive approach but store results of subproblems in a hash map to avoid redundant calculations. Each unique starting position is computed only once.

Bottom-Up Dynamic Programming — Algorithm Steps

Create dp array of size n+1
Initialize dp[n] = 1 (base case)
For each position i from right to left, try all valid numbers
dp[i] = sum of dp[j+1] for all valid endings j

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[n] = 1 as base case

Fill Backwards

For each position, try all valid number endings

Result

dp[0] contains the final answer

Code -

solution.c — C

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

const int MOD = 1000000007;

int solution(char* s, int k) {
    int n = strlen(s);
    long long* dp = (long long*)calloc(n + 1, sizeof(long long));
    dp[n] = 1; // Base case
    
    for (int i = n - 1; i >= 0; i--) {
        if (s[i] == '0') { // Cannot start with 0
            continue;
        }
        
        long long currentNum = 0;
        for (int j = i; j < n; j++) {
            currentNum = currentNum * 10 + (s[j] - '0');
            if (currentNum > k) {
                break;
            }
            dp[i] = (dp[i] + dp[j + 1]) % MOD;
        }
    }
    
    int result = dp[0];
    free(dp);
    return result;
}

int main() {
    char s[100001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    int result = solution(s, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log k)

For each of n positions, we try numbers up to k which takes O(log k) digits

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store results for each position

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler