Interleaving String - Practice Coding Problems

Interleaving String - Problem

Given three strings s1, s2, and s3, determine whether s3 can be formed by interleaving the characters of s1 and s2.

An interleaving means we can split s1 and s2 into substrings and combine them while preserving the relative order of characters within each original string. Think of it like merging two sequences where you can pick from either sequence at each step, but you must maintain the order within each sequence.

For example, if s1 = "abc" and s2 = "def", then valid interleavings include: "adbecf", "defabc", "adbefc", etc.

Goal: Return true if s3 is a valid interleaving of s1 and s2, false otherwise.

Input & Output

example_1.py — Valid Interleaving

$ Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"

› Output: true

💡 Note: s3 can be formed by interleaving s1 and s2. One possible way: a(s1) + a(s1) + d(s2) + b(s1) + b(s2) + c(s1) + b(s2) + c(s1) + a(s2) + c(s2)

example_2.py — Invalid Interleaving

$ Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"

› Output: false

💡 Note: s3 cannot be formed by any valid interleaving of s1 and s2 while maintaining the relative order of characters within each string

example_3.py — Empty String Case

$ Input: s1 = "", s2 = "", s3 = ""

› Output: true

💡 Note: Three empty strings form a valid interleaving (trivial case)

Constraints

0 ≤ s1.length, s2.length ≤ 100
0 ≤ s3.length ≤ 200
s1, s2, and s3 consist of only lowercase English letters
Follow up: Could you solve it using only O(s2.length) extra space?

Visualization

Tap to expand

Understanding the Visualization

Setup Decks

s1 and s2 are two ordered decks, s3 is the target shuffled deck

Build Path Table

Create a grid tracking all possible ways to reach each position

Fill Possibilities

For each cell, check if we can arrive from taking the previous card from either deck

Trace Result

The bottom-right cell tells us if a valid shuffling exists

Key Takeaway

🎯 Key Insight: Dynamic programming transforms an exponential problem into polynomial time by remembering which positions are reachable, avoiding redundant calculations.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The optimal approach uses dynamic programming with O(m×n) time and space complexity. Create a 2D table where dp[i][j] represents whether the first i+j characters of s3 can be formed by interleaving the first i characters of s1 and first j characters of s2. The key insight is that at each position, we can reach it from either the cell above (taking from s1) or the cell to the left (taking from s2), provided the characters match.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (2D Table)	O(m×n)	O(m×n)	Build a 2D table to store results of subproblems and avoid recomputation

Dynamic Programming (2D Table) — Algorithm Steps

Create a (m+1) × (n+1) DP table where m=len(s1), n=len(s2)
Initialize dp[0][0] = true (empty strings can form empty string)
Fill first row: dp[0][j] = dp[0][j-1] && s2[j-1] == s3[j-1]
Fill first column: dp[i][0] = dp[i-1][0] && s1[i-1] == s3[i-1]
Fill remaining cells: dp[i][j] = (dp[i-1][j] && s1[i-1] == s3[i+j-1]) || (dp[i][j-1] && s2[j-1] == s3[i+j-1])

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = true, fill borders

Fill Row

For each cell, check if reachable from left or top

Check Match

Verify character matches with current position in s3

Update Cell

Set cell to true if either path is valid

Code -

solution.c — C

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

bool isInterleave(const char* s1, const char* s2, const char* s3) {
    int m = strlen(s1), n = strlen(s2), l = strlen(s3);
    
    if (m + n != l) return false;
    
    // Allocate DP table
    bool** dp = (bool**)malloc((m + 1) * sizeof(bool*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (bool*)calloc(n + 1, sizeof(bool));
    }
    
    dp[0][0] = true;
    
    // Fill first column
    for (int i = 1; i <= m; i++) {
        dp[i][0] = dp[i-1][0] && s1[i-1] == s3[i-1];
    }
    
    // Fill first row
    for (int j = 1; j <= n; j++) {
        dp[0][j] = dp[0][j-1] && s2[j-1] == s3[j-1];
    }
    
    // Fill DP table
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            int k = i + j - 1;
            dp[i][j] = (dp[i-1][j] && s1[i-1] == s3[k]) ||
                       (dp[i][j-1] && s2[j-1] == s3[k]);
        }
    }
    
    bool result = dp[m][n];
    
    // Free memory
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We fill each cell in the (m+1)×(n+1) table exactly once

✓ Linear Growth

Space Complexity

O(m×n)

We need a 2D table of size (m+1)×(n+1) to store subproblem results

⚡ Linearithmic Space

98.3K Views

Medium-High Frequency

~25 min Avg. Time

2.8K 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 (2D Table) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler