Find and Replace Pattern - Practice Coding Problems

Find and Replace Pattern - Problem

Imagine you're a code-breaking detective! 🕵️‍♀️ You have a secret pattern and a list of words, and you need to find which words could be the result of applying a secret cipher to your pattern.

Here's the twist: the cipher is a bijection - each letter in the pattern maps to exactly one letter in the word, and no two pattern letters can map to the same word letter. It's like a perfect one-to-one substitution cipher!

For example:
• Pattern: "abb"
• Word: "mee"
• Mapping: a→m, b→e ✅ Valid!
• Word: "mff"
• Mapping: a→m, b→f ✅ Valid!
• Word: "mef"
• Would need: a→m, b→e, b→f ❌ Invalid! (b can't map to both e and f)

Your mission: Return all words from the input list that match the given pattern according to these cipher rules.

Input & Output

example_1.py — Basic Pattern Matching

$ Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"

› Output: ["mee","aqq"]

💡 Note: "mee" matches pattern "abb" with mapping a→m, b→e. "aqq" matches with mapping a→a, b→q. Other words fail because they would require invalid mappings (like "abc" needing a→a, b→b, b→c which violates bijection).

example_2.py — Single Character Pattern

$ Input: words = ["a","aa","aaa"], pattern = "a"

› Output: ["a"]

💡 Note: Only "a" matches the single character pattern "a". The other words have different lengths and cannot match.

example_3.py — Complex Pattern

$ Input: words = ["badc","abcd","efgh","abab"], pattern = "abba"

› Output: ["abab"]

💡 Note: Only "abab" matches pattern "abba" with mapping a→a, b→b. "badc" would need a→b, b→a, b→d, a→c which creates conflicts.

Visualization

Tap to expand

Understanding the Visualization

Receive Coded Message

A new intercepted message arrives for pattern matching

Initialize Decoder Maps

Set up two cipher books: pattern→message and message→pattern

Character-by-Character Decode

Process each position, updating both cipher books

Conflict Detection

If any mapping conflicts with existing entries, reject the message

Success or Failure

Message is valid if all characters decode consistently

Key Takeaway

🎯 Key Insight: The bijection property requires validation in BOTH directions - pattern→word AND word→pattern mappings must be consistent to ensure a valid one-to-one cipher relationship.

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the number of words and m is the length of each word. We process each character exactly once.

✓ Linear Growth

Space Complexity

O(m)

We need space for two hash maps, each storing at most m key-value pairs (the length of the pattern).

✓ Linear Space

Constraints

1 ≤ words.length ≤ 50
1 ≤ words[i].length ≤ 20
words[i] and pattern consist of lowercase English letters
words[i].length == pattern.length

Asked in

G Google 25 f Facebook 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses bidirectional hash mapping to validate pattern matching in O(n*m) time. For each word, we maintain two hash maps: pattern→word and word→pattern. This ensures the bijection property by detecting conflicts in both directions simultaneously during a single pass through each word.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n * m)	O(m)	Use bidirectional hash maps to validate mapping in a single pass
Brute Force Character Matching	O(n * m)	O(m)	For each word, manually build the mapping and check for conflicts

One-Pass Hash Table (Optimal) — Algorithm Steps

For each word, create two hash maps: pattern→word and word→pattern
Iterate through each character position once
For each position, check if current mappings are consistent
If pattern char already mapped, verify it maps to current word char
If word char already mapped, verify it maps to current pattern char
If all positions pass validation, add word to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create pattern→word and word→pattern hash maps

Single Pass

Process each character position once

Dual Validation

Check both mapping directions simultaneously

Instant Detection

Immediately detect conflicts and reject invalid words

Code -

solution.c — C

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

bool matches(char* word, char* pattern) {
    int len = strlen(pattern);
    if (strlen(word) != len) return false;
    
    // Use arrays as simple hash tables for ASCII characters
    char pToW[256] = {0};
    char wToP[256] = {0};
    bool pUsed[256] = {false};
    bool wUsed[256] = {false};
    
    for (int i = 0; i < len; i++) {
        unsigned char pChar = (unsigned char)pattern[i];
        unsigned char wChar = (unsigned char)word[i];
        
        if (pUsed[pChar]) {
            if (pToW[pChar] != wChar) return false;
        } else {
            pToW[pChar] = wChar;
            pUsed[pChar] = true;
        }
        
        if (wUsed[wChar]) {
            if (wToP[wChar] != pChar) return false;
        } else {
            wToP[wChar] = pChar;
            wUsed[wChar] = true;
        }
    }
    return true;
}

char** findAndReplacePattern(char** words, int wordsSize, char* pattern, int* returnSize) {
    char** result = (char**)malloc(wordsSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        if (matches(words[i], pattern)) {
            result[*returnSize] = words[i];
            (*returnSize)++;
        }
    }
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the number of words and m is the length of each word. We process each character exactly once.

✓ Linear Growth

Space Complexity

O(m)

We need space for two hash maps, each storing at most m key-value pairs (the length of the pattern).

✓ Linear Space

Constraints

1 ≤ words.length ≤ 50
1 ≤ words[i].length ≤ 20
words[i] and pattern consist of lowercase English letters
words[i].length == pattern.length

89.5K Views

Medium Frequency

~12 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler