Check if String Is Decomposable Into Value-Equal Substrings

Check if String Is Decomposable Into Value-Equal Substrings - Problem

String Easy

🧩 Check if String Is Decomposable Into Value-Equal Substrings

Imagine you're a pattern recognition expert tasked with breaking down a digit string into specific chunks. You need to determine if a given digit string can be decomposed into consecutive value-equal substrings following very specific rules.

📋 What are Value-Equal Strings?

A value-equal string is a substring where all characters are identical:

✅ "1111" - all 1's
✅ "33" - all 3's
❌ "123" - mixed characters

🎯 The Challenge

Given a digit string s, you must check if it can be decomposed into consecutive value-equal substrings where:

Exactly one substring has length 2
All remaining substrings have length 3

Example: "00011" → ["000", "11"] ✅ (one length-3, one length-2)

Example: "111222" → Cannot be decomposed ❌ (would need two length-3 substrings)

Return true if such decomposition is possible, false otherwise.

Input & Output

example_1.py — Basic Valid Case

$ Input: s = "00011"

› Output: true

💡 Note: Can be decomposed as ["000", "11"] where "000" has length 3 and "11" has length 2. Exactly one substring has length 2.

example_2.py — Invalid Case

$ Input: s = "111222"

› Output: false

💡 Note: Groups are "111" (length 3) and "222" (length 3). Both can only be split into length-3 substrings, so we get zero length-2 substrings instead of exactly one.

example_3.py — Impossible Split

$ Input: s = "1"

› Output: false

💡 Note: Single character cannot be split into substrings of length 2 or 3. Group length 1 has remainder 1 when divided by 3, making it impossible to decompose.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of digits 0-9 only
Important: String must be decomposable into consecutive value-equal substrings

Visualization

Tap to expand

Understanding the Visualization

Identify Consecutive Groups

Scan through the string to find runs of identical characters, like grouping same-colored blocks together

Apply Modular Math

For each group, check if length % 3 gives remainder 0 (divisible by 3) or remainder 2 (leaves one pair)

Validate Constraints

Ensure exactly one group has remainder 2 (provides the length-2 substring) and no group has remainder 1 (impossible)

Return Result

True if exactly one remainder-2 group exists, false otherwise

Key Takeaway

🎯 Key Insight: The mathematical property that groups of length ≡ 2 (mod 3) provide exactly one length-2 substring plus some length-3 substrings, while groups of length ≡ 0 (mod 3) provide only length-3 substrings, allows us to solve this in O(n) time by simply counting remainder-2 groups.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses modular arithmetic to solve this problem in O(n) time. The key insight is that each consecutive group of identical characters must have length ≡ 0 (mod 3) or length ≡ 2 (mod 3). Groups with remainder 1 are impossible to split into valid substrings. We need exactly one group with remainder 2 to provide the single required length-2 substring, while all other groups (remainder 0) contribute only length-3 substrings.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible ways to split each consecutive group and check validity
Single Pass Counting (Optimal)	O(n)	O(1)	Count consecutive groups in one pass and check remainder conditions

Brute Force (Try All Combinations) — Algorithm Steps

Find all consecutive groups of identical characters
For each group, generate all possible splits into length-2 and length-3 substrings
Try every combination of splits across all groups
Check if any combination has exactly one length-2 substring
Return true if such combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Groups

Find consecutive identical characters: '000' (3), '11' (2)

Generate Splits

For group of 3: try [3] or [2,1]. For group of 2: try [2]

Check Combinations

Try all combinations and count length-2 substrings

Validate Solution

Accept only combinations with exactly one length-2 substring

Code -

solution.c — C

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

int groups[1000];
int groupCount;

bool tryGroup(int index, int remaining, bool usedTwo);
bool backtrack(int index, bool usedTwo);

bool backtrack(int index, bool usedTwo) {
    if (index == groupCount) {
        return usedTwo;
    }
    return tryGroup(index, groups[index], usedTwo);
}

bool tryGroup(int index, int remaining, bool usedTwo) {
    if (remaining == 0) {
        return backtrack(index + 1, usedTwo);
    }
    if (remaining == 2) {
        if (usedTwo) return false;
        return backtrack(index + 1, true);
    }
    if (remaining == 3) {
        return backtrack(index + 1, usedTwo);
    }
    if (remaining < 2) {
        return false;
    }
    
    // Try length-2
    if (!usedTwo && remaining >= 2) {
        if (tryGroup(index, remaining - 2, true)) {
            return true;
        }
    }
    
    // Try length-3
    if (remaining >= 3) {
        if (tryGroup(index, remaining - 3, usedTwo)) {
            return true;
        }
    }
    
    return false;
}

bool isDecomposable(char* s) {
    int len = strlen(s);
    groupCount = 0;
    
    int i = 0;
    while (i < len) {
        int j = i;
        while (j < len && s[j] == s[i]) {
            j++;
        }
        groups[groupCount++] = j - i;
        i = j;
    }
    
    return backtrack(0, false);
}

int main() {
    char s[1001];
    scanf("%s", s);
    printf("%s\n", isDecomposable(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each group can be split in multiple ways, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing group information

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~15 min Avg. Time

890 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

🧩 Check if String Is Decomposable Into Value-Equal Substrings

📋 What are Value-Equal Strings?

🎯 The Challenge

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler