Splitting a String Into Descending Consecutive Values

Splitting a String Into Descending Consecutive Values - Problem

You're given a string s consisting of only digits. Your task is to determine if you can split this string into two or more non-empty substrings such that:

The numerical values of the substrings form a descending sequence
Each adjacent pair differs by exactly 1

Example: The string "0090089" can be split into ["0090", "089"] with values [90, 89] - a valid descending sequence where each number is 1 less than the previous.

Note: Leading zeros are allowed in substrings, but they don't affect the numerical value (e.g., "089" = 89).

Input & Output

example_1.py — Basic Valid Split

$ Input: s = "1234321"

› Output: false

💡 Note: No way to split this into a descending sequence where adjacent numbers differ by 1. Even trying [1234, 321] gives us numbers that don't differ by 1.

example_2.py — Valid with Leading Zeros

$ Input: s = "0090089"

› Output: true

💡 Note: Can be split as ["0090", "089"] which gives numerical values [90, 89]. These form a descending sequence with difference of 1.

example_3.py — Simple Descending

$ Input: s = "10009998"

› Output: true

💡 Note: Can be split as ["1000", "999", "998"] giving values [1000, 999, 998] - a perfect descending sequence with differences of 1.

Visualization

Tap to expand

Key: Try each possible first number length, then validate the pattern

Understanding the Visualization

Choose Starting Number

Pick how many digits form the first number (like deciding where the first separator goes)

Determine Sequence

Once first number is chosen, we know exactly what the rest should be (countdown by 1)

Pattern Matching

Check if remaining digits match the expected countdown pattern

Handle Variations

Account for leading zeros in the display representation

Key Takeaway

🎯 Key Insight: This problem transforms from exponential search space to polynomial time by recognizing that fixing the first number completely determines the expected sequence, allowing us to validate deterministically rather than exploring all possibilities.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each starting position, we make at most O(n) recursive calls

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth is at most O(n)

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 20
s consists of only digits
Each substring must be non-empty
Need at least 2 substrings for valid split
Leading zeros are allowed in substrings

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses backtracking with early termination. Key insight: once we choose the first number, the entire sequence is determined. We try each possible first number length, then check if the remaining string can be split to match the expected descending pattern. Time complexity is O(n²) with O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking	O(n²)	O(n)	Use early termination and pruning to reduce unnecessary computations
Brute Force Backtracking	O(2^n)	O(n)	Try all possible ways to split the string and check each combination

Optimized Backtracking — Algorithm Steps

Try each possible length for the first number
Once first number is chosen, determine what the second number should be
Check if the expected second number exists at the current position
Continue this pattern instead of exploring all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix first number

Try each possible length for first number

Determine sequence

Once first number is chosen, entire sequence is determined

Match pattern

Check if remaining string matches expected descending pattern

Handle leading zeros

Consider leading zeros for each expected number

Code -

solution.c — C

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

bool canSplit(char* s, int index, long long target, int count, int len);

bool splitIntoDescendingValues(char* s) {
    int len = strlen(s);
    
    // Try different lengths for the first number
    for (int i = 0; i < len / 2; i++) {
        char firstNumStr[20];
        strncpy(firstNumStr, s, i + 1);
        firstNumStr[i + 1] = '\0';
        
        if (strlen(firstNumStr) > 1 && firstNumStr[0] == '0') {
            continue;
        }
        
        long long firstNum = atoll(firstNumStr);
        if (canSplit(s, i + 1, firstNum - 1, 1, len)) {
            return true;
        }
    }
    
    return false;
}

bool canSplit(char* s, int index, long long target, int count, int len) {
    if (index == len) {
        return count >= 2;
    }
    
    // Try to match the target number starting at index
    char targetStr[20];
    sprintf(targetStr, "%lld", target);
    int targetLen = strlen(targetStr);
    
    if (index + targetLen <= len && strncmp(s + index, targetStr, targetLen) == 0) {
        if (canSplit(s, index + targetLen, target - 1, count + 1, len)) {
            return true;
        }
    }
    
    // Also try with leading zeros
    int zeroCount = 0;
    while (index + zeroCount < len && s[index + zeroCount] == '0') {
        zeroCount++;
        char extendedTarget[40];
        memset(extendedTarget, '0', zeroCount);
        strcpy(extendedTarget + zeroCount, targetStr);
        
        int extendedLen = strlen(extendedTarget);
        if (index + extendedLen <= len && strncmp(s + index, extendedTarget, extendedLen) == 0) {
            if (canSplit(s, index + extendedLen, target - 1, count + 1, len)) {
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    char s[20];
    scanf("%s", s);
    
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    
    printf("%s\n", splitIntoDescendingValues(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each starting position, we make at most O(n) recursive calls

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth is at most O(n)

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 20
s consists of only digits
Each substring must be non-empty
Need at least 2 substrings for valid split
Leading zeros are allowed in substrings

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler