Splitting a String Into Descending Consecutive Values

Splitting a String Into Descending Consecutive Values - Problem

You are given a string s that consists of only digits.

Check if we can split s into two or more non-empty substrings such that the numerical values of the substrings are in descending order and the difference between numerical values of every two adjacent substrings is equal to 1.

Examples:

The string s = "0090089" can be split into ["0090", "089"] with numerical values [90, 89]. The values are in descending order and adjacent values differ by 1, so this is valid.
The string s = "001" can be split into ["0", "01"], ["00", "1"], or ["0", "0", "1"]. However, all ways are invalid because they have numerical values [0,1], [0,1], and [0,0,1] respectively, all of which are not in descending order.

Return true if it is possible to split s as described above, or false otherwise.

A substring is a contiguous sequence of characters in a string.

Input & Output

Example 1 — Valid Split with Leading Zeros

$ Input: s = "0090089"

› Output: true

💡 Note: Can split into ["0090", "089"] with numerical values [90, 89]. Values are descending (90 > 89) and differ by 1 (90 - 89 = 1).

Example 2 — No Valid Split

$ Input: s = "001"

› Output: false

💡 Note: Possible splits: ["0","01"], ["00","1"], ["0","0","1"] give values [0,1], [0,1], [0,0,1]. None are descending consecutive.

Example 3 — Simple Descending

$ Input: s = "4321"

› Output: true

💡 Note: Can split into ["4","3","2","1"] with values [4,3,2,1]. Values are descending and each differs by exactly 1: 4-3=1, 3-2=1, 2-1=1.

Constraints

1 ≤ s.length ≤ 20
s consists only of digits

Visualization

Tap to expand

Asked in

G Google 23 f Facebook 18 a Amazon 15

The key insight is to use backtracking to try different lengths for the first number, then recursively check if the remaining string can form a valid descending consecutive sequence. The optimized backtracking approach handles leading zeros correctly and provides early termination. Time: O(n²), Space: O(n)

Common Approaches

✓ Backtracking - Smart Exploration

⏱️ Time: O(n²) Space: O(n)

For each possible length of the first number, extract it and recursively try to split the remaining string such that each subsequent number is exactly 1 less than the previous. This prunes invalid paths early.

Brute Force - Try All Splits

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

Generate all possible ways to split the string into substrings, then check if each split forms a valid descending consecutive sequence. This involves trying all combinations of split positions.

Optimized Backtracking with Leading Zeros

⏱️ Time: O(n²) Space: O(n)

Improved version that handles leading zeros correctly by comparing string representations rather than numeric values. Also includes optimizations like early termination when remaining string is too short.

Backtracking - Smart Exploration — Algorithm Steps

Try different lengths for first number
For each first number, recursively check if remaining string can form decreasing sequence
Prune early when impossible to continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Try First Number

Try different lengths for first number

Check Next

For each first number, check if next number is firstNum-1

Recurse

Continue recursively or backtrack if invalid

Code -

solution.c — C

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

bool backtrack(char* s, int index, long long prevNum) {
    if (index == strlen(s)) {
        return true;
    }
    
    long long target = prevNum - 1;
    int sLen = strlen(s);
    
    // Try all possible lengths for the next substring
    for (int length = 1; length <= sLen - index; length++) {
        char substring[100];
        strncpy(substring, s + index, length);
        substring[length] = '\0';
        
        if (atoll(substring) == target) {
            if (backtrack(s, index + length, target)) {
                return true;
            }
        }
    }
    
    return false;
}

bool solution(char* s) {
    int len = strlen(s);
    for (int i = 1; i < len; i++) {
        char firstStr[100];
        strncpy(firstStr, s, i);
        firstStr[i] = '\0';
        
        long long firstNum = atoll(firstStr);
        if (backtrack(s, i, firstNum)) {
            return true;
        }
    }
    return false;
}

int main() {
    char s[100];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    bool result = solution(s);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Try O(n) lengths for first number, each recursive check takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to n levels

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 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

Backtracking - Smart Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler