Match Substring After Replacement - Practice Coding Problems

Match Substring After Replacement - Problem

🎯 Match Substring After Replacement

You're given a string s and a substring pattern sub that you want to find within s. However, there's a twist! You have a set of character replacement rules in the form of a 2D array mappings, where each mappings[i] = [old_char, new_char] allows you to replace any occurrence of old_char in sub with new_char.

The Challenge: Can you transform sub using these replacement rules to make it appear as a contiguous substring somewhere in s?

Important Rules:

Each character in sub can be replaced at most once
You can use each replacement rule multiple times
You want to find if sub can become a contiguous substring of s

Example: If s = "fool3e7bar", sub = "leet", and mappings = [['e','3'], ['t','7'], ['t','8']], you can transform "leet" → "le37" by replacing the first 'e' with '3' and 't' with '7', making it match the substring "le37" in s.

Input & Output

example_1.py — Basic Transformation

$ Input: s = "fool3e7bar", sub = "leet", mappings = [['e','3'], ['t','7'], ['t','8']]

› Output: true

💡 Note: We can transform 'leet' to 'le37' by replacing the first 'e' with '3' and 't' with '7'. The string 'le37' appears as a substring in 'fool3e7bar' at position 3.

example_2.py — No Valid Transformation

$ Input: s = "fooleetbar", sub = "f00", mappings = [['o','0']]

› Output: false

💡 Note: We can transform 'f00' to 'f0o' by replacing one 'o' with '0', but we cannot replace both 'o's since each character can only be replaced once. No transformation of 'f00' appears in 'fooleetbar'.

example_3.py — Direct Match

$ Input: s = "Fool33tboR", sub = "leetb", mappings = [['e','3'], ['t','R'], ['O','b']]

› Output: false

💡 Note: Even with the available mappings, no transformation of 'leetb' can match any substring in 'Fool33tboR'. The closest would be transforming to 'l33tR' but this doesn't appear as a contiguous substring.

Visualization

Tap to expand

Understanding the Visualization

Prepare Tools

Build a lookup table of all available character transformations from the mappings

Slide Template

Position the template at each possible location in the document

Character Match

For each template position, compare characters one by one

Apply Rules

If characters don't match directly, check if transformation rules allow the match

Success Check

If all characters in template can be matched, return success

Key Takeaway

🎯 Key Insight: Instead of generating all possible transformations (exponential), we check each position in the target string and see if we can match the pattern using available transformations on-the-fly (linear).

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

For each of n starting positions in s, we check at most m characters of sub

✓ Linear Growth

Space Complexity

O(k)

Space for storing k mapping rules in hash map

✓ Linear Space

Constraints

1 ≤ sub.length ≤ s.length ≤ 5000
0 ≤ mappings.length ≤ 1000
mappings[i].length == 2
old_i ≠ new_i
s and sub consist of uppercase and lowercase English letters and digits
old_i and new_i are uppercase and lowercase English letters and digits

Asked in

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

The optimal solution uses a one-pass pattern matching approach with O(n×m) time complexity. We build a hash map of character mappings, then for each position in string s, we attempt to match substring sub character by character, using direct matches or valid transformations as needed. This avoids the exponential complexity of generating all possible transformations upfront.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^m * n * k)	O(2^m * m)	Generate all possible transformations of sub and check each against s
One-Pass Pattern Matching (Optimal)	O(n * m)	O(k)	Check each position in s and try to match sub with on-the-fly transformations

Brute Force (Try All Combinations) — Algorithm Steps

Create a mapping dictionary from the mappings array
Use backtracking to generate all possible transformations of sub
For each character, try keeping it unchanged or replacing it with any valid mapping
Ensure each character is only transformed once
For each generated transformation, check if it exists as substring in s
Return true if any transformation is found in s

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Mapping

Create lookup table for character replacements

Generate Tree

Use backtracking to create all possible transformations

Check Each

Test each transformation as substring in original string

Code -

solution.c — C

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

typedef struct {
    char from;
    char to[26];
    int count;
} Mapping;

bool matchReplacement(char* s, char* sub, char** mappings, int mappingsSize, int* mappingsColSize) {
    Mapping charMappings[26];
    for (int i = 0; i < 26; i++) {
        charMappings[i].count = 0;
    }
    
    // Build mapping structure
    for (int i = 0; i < mappingsSize; i++) {
        int idx = mappings[i][0] - 'a';
        charMappings[idx].from = mappings[i][0];
        charMappings[idx].to[charMappings[idx].count++] = mappings[i][1];
    }
    
    int subLen = strlen(sub);
    char* transformations[1000];  // Assume max 1000 transformations
    int transformCount = 0;
    
    // Generate all transformations (simplified version)
    char current[101];
    generateTransforms(sub, 0, current, charMappings, transformations, &transformCount);
    
    // Check each transformation
    for (int i = 0; i < transformCount; i++) {
        if (strstr(s, transformations[i]) != NULL) {
            return true;
        }
        free(transformations[i]);
    }
    
    return false;
}

void generateTransforms(char* sub, int index, char* current,
                       Mapping* mappings, char** transformations, int* count) {
    int len = strlen(sub);
    if (index == len) {
        transformations[*count] = malloc((len + 1) * sizeof(char));
        strcpy(transformations[*count], current);
        (*count)++;
        return;
    }
    
    char ch = sub[index];
    int pos = strlen(current);
    
    // Keep unchanged
    current[pos] = ch;
    current[pos + 1] = '\0';
    generateTransforms(sub, index + 1, current, mappings, transformations, count);
    current[pos] = '\0';
    
    // Try replacements
    int mappingIdx = ch - 'a';
    for (int i = 0; i < mappings[mappingIdx].count; i++) {
        current[pos] = mappings[mappingIdx].to[i];
        current[pos + 1] = '\0';
        generateTransforms(sub, index + 1, current, mappings, transformations, count);
        current[pos] = '\0';
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m * n * k)

2^m possible transformations (m = length of sub), checking each in string s (n = length of s), with k character comparisons

✓ Linear Growth

Space Complexity

O(2^m * m)

Storing all possible transformations, each of length m

✓ Linear Space

Constraints

1 ≤ sub.length ≤ s.length ≤ 5000
0 ≤ mappings.length ≤ 1000
mappings[i].length == 2
old_i ≠ new_i
s and sub consist of uppercase and lowercase English letters and digits
old_i and new_i are uppercase and lowercase English letters and digits

24.5K Views

Medium Frequency

~25 min Avg. Time

943 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

🎯 Match Substring After Replacement

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler