Scramble String - Practice Coding Problems

Scramble String - Problem

Imagine you have a string and you want to scramble it using a specific recursive algorithm. The scrambling process works like this:

If the string has only 1 character, stop (base case)
If the string has more than 1 character:
- Split the string into two non-empty parts at any position
- Randomly decide whether to swap these two parts or keep them in order
- Apply this scrambling process recursively to each part

For example, starting with "great":

Split into "gr" + "eat", then swap → "eatgr"
Recursively scramble "eat" → might become "tea"
Recursively scramble "gr" → might become "rg"
Final result: "tearg"

Your task: Given two strings s1 and s2 of the same length, determine if s2 is a scrambled version of s1.

Input & Output

example_1.py — Basic Scramble

$ Input: {"s1": "great", "s2": "rgeat"}

› Output: true

💡 Note: We can scramble 'great' to get 'rgeat': Split 'great' into 'gr' + 'eat', swap to get 'eat' + 'gr' = 'eatgr', then scramble 'eat' to 'rge' and 'gr' to 'at', resulting in 'rgeat'.

example_2.py — No Valid Scramble

$ Input: {"s1": "abcdef", "s2": "fecadb"}

› Output: false

💡 Note: Although both strings have the same characters, there's no way to scramble 'abcdef' following the algorithm rules to get 'fecadb'.

example_3.py — Single Character

$ Input: {"s1": "a", "s2": "a"}

› Output: true

💡 Note: Single character strings are scrambled versions of themselves if they are identical.

Constraints

1 ≤ s1.length, s2.length ≤ 30
s1 and s2 consist of lowercase English letters only
Both strings have the same length

Visualization

Tap to expand

Understanding the Visualization

Start with Original

Begin with the original string 'great'

Choose Split Point

Split at any position, e.g., 'gr' | 'eat'

Decide Swap or Keep

Either keep as 'gr' + 'eat' or swap to 'eat' + 'gr'

Recurse on Parts

Apply the same process to each substring

Build Result

Combine results: 'rg' + 'eat' = 'rgeat'

Key Takeaway

🎯 Key Insight: At each level, we have two choices: keep the order of split parts or swap them. The optimal DP solution systematically checks all possibilities without redundant calculations.

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses 3D Dynamic Programming with O(n⁴) time complexity. Build a DP table where dp[i][j][len] represents whether substring s1[i:i+len] can be scrambled to s2[j:j+len]. Start with base cases (single characters) and build up solutions for longer substrings by trying all possible split positions and both normal/swapped combinations.

Common Approaches

Approach	Time	Space	Notes
✓ 3D Dynamic Programming (Optimal)	O(n^4)	O(n^3)	Bottom-up DP approach building solutions from smaller substrings
Recursive Brute Force	O(4^n)	O(n)	Try all possible ways to split and scramble recursively
Memoized Recursion (Dynamic Programming)	O(n^4)	O(n^3)	Cache results of subproblems to avoid redundant calculations

3D Dynamic Programming (Optimal) — Algorithm Steps

Create 3D DP table dp[i][j][len] for all possible substrings
Initialize base case: dp[i][j][1] = (s1[i] == s2[j])
For each length from 2 to n, fill the DP table
For each position try all possible splits
Check both normal and swapped combinations
Return dp[0][0][n] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Cases

Set dp[i][j][1] = true if s1[i] == s2[j]

Build Length 2

For each substring of length 2, try split at position 1

Build Length 3+

For each length, try all possible split positions

Final Answer

dp[0][0][n] contains whether full strings can be scrambled

Code -

solution.c — C

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

bool isScramble(char* s1, char* s2) {
    int n1 = strlen(s1), n2 = strlen(s2);
    if (n1 != n2) return false;
    
    int n = n1;
    if (n == 0) return true;
    
    // Allocate 3D DP array
    bool*** dp = (bool***)malloc(n * sizeof(bool**));
    for (int i = 0; i < n; i++) {
        dp[i] = (bool**)malloc(n * sizeof(bool*));
        for (int j = 0; j < n; j++) {
            dp[i][j] = (bool*)calloc(n + 1, sizeof(bool));
        }
    }
    
    // Base case: single characters
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dp[i][j][1] = (s1[i] == s2[j]);
        }
    }
    
    // Fill DP table for lengths 2 to n
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            for (int j = 0; j <= n - length; j++) {
                // Try all possible split positions
                for (int k = 1; k < length; k++) {
                    // Case 1: no swap
                    if (dp[i][j][k] && dp[i + k][j + k][length - k]) {
                        dp[i][j][length] = true;
                        break;
                    }
                    
                    // Case 2: swap
                    if (dp[i][j + length - k][k] && dp[i + k][j][length - k]) {
                        dp[i][j][length] = true;
                        break;
                    }
                }
            }
        }
    }
    
    bool result = dp[0][0][n];
    
    // Free memory
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            free(dp[i][j]);
        }
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n^4)

Three nested loops for i,j,len (O(n³)) and inner loop for split position (O(n))

✓ Linear Growth

Space Complexity

O(n^3)

3D DP table storing boolean values for all substring combinations

⚠ Quadratic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

987 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

3D Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler