Partition String Into Substrings With Values at Most K

Partition String Into Substrings With Values at Most K - Problem

You are given a string s consisting of digits from 1 to 9 and an integer k.

A partition of a string s is called good if:

Each digit of s is part of exactly one substring.
The value of each substring is less than or equal to k.

Return the minimum number of substrings in a good partition of s. If no good partition of s exists, return -1.

Note that:

The value of a string is its result when interpreted as an integer. For example, the value of "123" is 123 and the value of "1" is 1.
A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Basic Case

$ Input: s = "165312", k = 60

› Output: 4

💡 Note: Optimal partition: ["16", "53", "1", "2"]. Values are [16, 53, 1, 2], all ≤ 60. Total: 4 substrings.

Example 2 — Impossible Case

$ Input: s = "238", k = 4

› Output: -1

💡 Note: Single digits "2", "3" are ≤ 4, but "8" > 4. Since we can't partition "8", no good partition exists.

Example 3 — All Single Digits

$ Input: s = "123", k = 5

› Output: 3

💡 Note: Each digit forms its own partition: ["1", "2", "3"]. Values [1, 2, 3] are all ≤ 5.

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of digits from '1' to '9'
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 25

The key insight is to use a greedy approach: at each position, take the longest possible substring whose value doesn't exceed k. This minimizes the total number of partitions. The greedy algorithm runs in O(n²) time and O(1) space, making it efficient for this problem.

Common Approaches

✓ Brute Force - Try All Partitions

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

Try every possible way to partition the string into substrings, check if each partition is good (all substrings ≤ k), and return the minimum number of substrings among valid partitions.

Dynamic Programming

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

Use dynamic programming where dp[i] represents minimum partitions needed for string[0:i]. For each position, try all possible valid substrings ending at that position and take minimum.

Greedy - Take Longest Valid Substring

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

Use greedy approach: start from the beginning and always take the longest valid substring (value ≤ k). This minimizes the total number of partitions because taking longer substrings reduces partition count.

Brute Force - Try All Partitions — Algorithm Steps

Generate all possible partitions
Check if partition is good
Track minimum partition size

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Try all possible ways to split string

Check Validity

Verify each substring value ≤ k

Find Minimum

Return minimum valid partition size

Code -

solution.c — C

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

int minPartitions = INT_MAX;

void backtrack(const char* s, int k, int start, int partitions, int len) {
    if (start == len) {
        if (partitions < minPartitions) {
            minPartitions = partitions;
        }
        return;
    }
    
    for (int end = start + 1; end <= len; end++) {
        char substring[20];
        strncpy(substring, s + start, end - start);
        substring[end - start] = '\0';
        int value = atoi(substring);
        if (value <= k) {
            backtrack(s, k, end, partitions + 1, len);
        } else {
            break;
        }
    }
}

int solution(const char* s, int k) {
    minPartitions = INT_MAX;
    backtrack(s, k, 0, 0, strlen(s));
    return minPartitions == INT_MAX ? -1 : minPartitions;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

2^n possible ways to partition string of length n, each requiring validation

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to n levels for generating partitions

✓ Linear Space

28.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler