Number of Beautiful Partitions - Practice Coding Problems

Number of Beautiful Partitions - Problem

Imagine you're a cryptographer tasked with breaking down a secret message into beautiful segments. You have a string s consisting of digits '1' through '9', and you need to partition it into exactly k non-overlapping substrings following strict rules.

A partition is considered beautiful if:

The string is divided into exactly k non-intersecting substrings
Each substring has a length of at least minLength
Each substring starts with a prime digit ('2', '3', '5', '7') and ends with a non-prime digit ('1', '4', '6', '8', '9')

Your mission: Count all possible beautiful partitions of the given string. Since the answer can be astronomically large, return it modulo 10⁹ + 7.

Example: For string "23542" with k=2 and minLength=2, one beautiful partition could be ["235", "42"] - the first part starts with '2' (prime) and ends with '5' (prime), wait... that won't work! Let's try ["234", "52"] - first starts with '2' (prime) and ends with '4' (non-prime), second starts with '5' (prime) and ends with '2' (prime)... still wrong! This problem requires careful validation of each segment.

Input & Output

example_1.py — Basic Beautiful Partition

$ Input: s = "23542", k = 2, minLength = 2

› Output: 2

💡 Note: The beautiful partitions are ["235", "42"] and ["2354", "2"]. Wait, "235" ends with prime '5', so it's invalid. Let me recalculate: actually ["23", "542"] where "23" ends with '3' (prime) - invalid. ["234", "52"] where "52" starts with '5' and ends with '2' (prime) - invalid. The valid ones are where each part starts with prime and ends with non-prime.

example_2.py — Impossible Partition

$ Input: s = "3312958", k = 3, minLength = 2

› Output: 3

💡 Note: Multiple valid ways to create 3 beautiful partitions with minimum length 2, where each starts with prime digit and ends with non-prime digit.

example_3.py — Edge Case

$ Input: s = "1", k = 1, minLength = 1

› Output: 0

💡 Note: Cannot create a beautiful partition because '1' is not prime, so the string cannot start with a prime digit as required.

Constraints

1 ≤ k ≤ s.length ≤ 200
1 ≤ minLength ≤ s.length
s consists of digits '1' to '9'
Prime digits are '2', '3', '5', '7'
Answer is returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Start/End Points

Mark positions that can start (prime) or end (non-prime) partitions

Build DP Table

Count ways to partition prefixes into different numbers of segments

Consider All Last Partitions

For each state, try all valid positions for the final segment

Sum Valid Combinations

Add up all ways that satisfy the beautiful partition criteria

Key Takeaway

🎯 Key Insight: Use dynamic programming to build up solutions by considering all valid ways to place the last partition, ensuring each segment starts with prime and ends with non-prime digits.

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 18

This is a classic dynamic programming problem where we need to count valid string partitions. The optimal approach uses a 2D DP table where dp[i][j] represents the number of ways to partition the first i characters into j beautiful substrings. The key insight is to iterate through all possible positions for the last partition and sum up valid combinations. Time complexity is O(n²k) with O(nk) space.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²k)	O(nk)	Use memoized DP to avoid recalculating the same subproblems

Dynamic Programming (Optimal) — Algorithm Steps

Create a DP table where dp[i][j] = ways to partition first i chars into j parts
Initialize base case: dp[0][0] = 1 (empty string, zero parts)
For each position i and partition count j, try all valid previous positions
Check if substring from previous position to i-1 forms a beautiful part
Sum up all valid ways and return dp[n][k]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP table

Create table dp[i][j] for i characters and j partitions

Base case

Set dp[0][0] = 1 (empty string, zero partitions)

Fill table row by row

For each position, consider all valid previous splits

Return final answer

dp[n][k] contains the total number of beautiful partitions

Code -

solution.c — C

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

#define MOD 1000000007

bool isPrime(char c) {
    return c == '2' || c == '3' || c == '5' || c == '7';
}

int beautifulPartitions(const char* s, int k, int minLength) {
    int n = strlen(s);
    
    // Early exit conditions
    if (n < k * minLength || !isPrime(s[0]) || isPrime(s[n-1])) {
        return 0;
    }
    
    // dp[i][j] = ways to partition first i chars into j parts
    long long dp[201][101] = {0};
    dp[0][0] = 1;
    
    for (int i = 1; i <= n; i++) {
        int maxJ = (i / minLength < k) ? i / minLength : k;
        for (int j = 1; j <= maxJ; j++) {
            for (int prev = j - 1; prev <= i - minLength; prev++) {
                // Check if we can start partition at prev
                if (prev == 0 || !isPrime(s[prev - 1])) {
                    if (isPrime(s[prev]) && !isPrime(s[i - 1])) {
                        dp[i][j] = (dp[i][j] + dp[prev][j - 1]) % MOD;
                    }
                }
            }
        }
    }
    
    return (int)dp[n][k];
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, ",");
    char s[201];
    strcpy(s, token + 1);
    s[strlen(s) - 1] = '\0';
    
    token = strtok(NULL, ",");
    int k = atoi(token);
    
    token = strtok(NULL, ",");
    int minLength = atoi(token);
    
    printf("%d\n", beautifulPartitions(s, k, minLength));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²k)

For each of n*k states, we try up to n previous positions to form the last partition

⚠ Quadratic Growth

Space Complexity

O(nk)

DP table storing n*k states

⚡ Linearithmic Space

34.2K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler