Word Pattern II - Practice Coding Problems

Word Pattern II - Problem

Word Pattern II is a fascinating pattern matching problem that challenges you to determine if a string can be split and mapped to match a given pattern.

You are given:

pattern - A string of lowercase letters (e.g., "abab")
s - A target string to match (e.g., "redblueredblue")

Goal: Return true if s matches the pattern through a bijective mapping.

What is a bijective mapping?

Each pattern character maps to exactly one non-empty substring
No two pattern characters can map to the same substring
Each pattern character must consistently map to the same substring

Example: Pattern "abab" and string "redblueredblue"

'a' → "red" and 'b' → "blue"
This creates: "red" + "blue" + "red" + "blue" = "redblueredblue" ✓

Input & Output

example_1.py — Python

$ Input: pattern = "abab", s = "redblueredblue"

› Output: true

💡 Note: We can map 'a' to 'red' and 'b' to 'blue'. This gives us: 'red' + 'blue' + 'red' + 'blue' = 'redblueredblue', which matches the input string perfectly.

example_2.py — Python

$ Input: pattern = "aaaa", s = "asdasdasdasd"

› Output: true

💡 Note: We can map 'a' to 'asd'. This gives us: 'asd' + 'asd' + 'asd' + 'asd' = 'asdasdasdasd', which matches the input string.

example_3.py — Python

$ Input: pattern = "abab", s = "asdasdasdasd"

› Output: false

💡 Note: There's no way to create a bijective mapping. If we try 'a' → 'asd' and 'b' → 'asd', this violates the bijective constraint (two different characters cannot map to the same substring).

Visualization

Tap to expand

Understanding the Visualization

Start Decoding

Begin with pattern 'abab' and encrypted text 'redblueredblue'

First Mapping

Try mapping first 'a' to different substrings: 'r', 're', 'red'...

Consistent Check

When 'a' appears again, verify it maps to the same substring

Bijective Validation

Ensure no two different symbols map to the same word

Complete Match

Success when all symbols are consistently mapped and string is fully consumed

Key Takeaway

🎯 Key Insight: Use backtracking with bidirectional hash maps to maintain bijective constraints while exploring all possible substring mappings efficiently

Time & Space Complexity

Time Complexity

⏱️

O(s^p) worst case, much better in practice

Worst case is still exponential, but pruning and optimizations make it much faster for practical inputs

✓ Linear Growth

Space Complexity

O(p + m)

Space for recursion stack (p) plus hash maps storing at most m unique mappings

✓ Linear Space

Constraints

1 ≤ pattern.length ≤ 20
1 ≤ s.length ≤ 50
pattern contains only lowercase English letters
s contains only lowercase English letters
Each pattern character must map to a non-empty substring

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses backtracking with hash tables to explore all possible mappings while maintaining bijective constraints. Key optimizations include early pruning based on length constraints and O(1) lookups for existing mappings. The algorithm efficiently explores the search space by maintaining both character-to-word and word-to-character mappings to ensure no conflicts occur.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Basic Validation	O(s^p)	O(p)	Try all possible substring mappings using recursive backtracking
Optimized Backtracking (Optimal)	O(s^p) worst case, much better in practice	O(p + m)	Enhanced backtracking with early pruning and optimizations

Backtracking with Basic Validation — Algorithm Steps

Start from the beginning of both pattern and string
For each pattern character, try all possible substring lengths
Check if the mapping conflicts with existing assignments
Recursively process the remaining pattern and string
Backtrack if no valid mapping is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with pattern 'abab' and string 'redblueredblue'

Try 'a' mappings

Try mapping 'a' to 'r', 're', 'red', etc.

Recursive exploration

For each valid 'a' mapping, recursively try 'b' mappings

Check consistency

When we see 'a' again, verify it maps to the same substring

Backtrack if needed

If no valid mapping found, backtrack and try different splits

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_MAPPINGS 26

typedef struct {
    char key;
    char value[MAX_LEN];
    bool used;
} CharMapping;

typedef struct {
    char key[MAX_LEN];
    char value;
    bool used;
} WordMapping;

bool backtrack(const char* pattern, int pIdx, const char* s, int sIdx, 
               CharMapping* charToWord, WordMapping* wordToChar, int patternLen, int sLen) {
    if (pIdx == patternLen && sIdx == sLen) {
        return true;
    }
    if (pIdx == patternLen || sIdx == sLen) {
        return false;
    }
    
    char c = pattern[pIdx];
    int charIdx = c - 'a';
    
    if (charToWord[charIdx].used) {
        char* word = charToWord[charIdx].value;
        int wordLen = strlen(word);
        if (sIdx + wordLen <= sLen && strncmp(s + sIdx, word, wordLen) == 0) {
            return backtrack(pattern, pIdx + 1, s, sIdx + wordLen, charToWord, wordToChar, patternLen, sLen);
        }
        return false;
    }
    
    for (int end = sIdx + 1; end <= sLen; end++) {
        char word[MAX_LEN];
        strncpy(word, s + sIdx, end - sIdx);
        word[end - sIdx] = '\0';
        
        bool wordExists = false;
        for (int i = 0; i < MAX_MAPPINGS; i++) {
            if (wordToChar[i].used && strcmp(wordToChar[i].key, word) == 0) {
                wordExists = true;
                break;
            }
        }
        if (wordExists) continue;
        
        charToWord[charIdx].key = c;
        strcpy(charToWord[charIdx].value, word);
        charToWord[charIdx].used = true;
        
        int freeSlot = -1;
        for (int i = 0; i < MAX_MAPPINGS; i++) {
            if (!wordToChar[i].used) {
                freeSlot = i;
                break;
            }
        }
        
        strcpy(wordToChar[freeSlot].key, word);
        wordToChar[freeSlot].value = c;
        wordToChar[freeSlot].used = true;
        
        if (backtrack(pattern, pIdx + 1, s, end, charToWord, wordToChar, patternLen, sLen)) {
            return true;
        }
        
        charToWord[charIdx].used = false;
        wordToChar[freeSlot].used = false;
    }
    
    return false;
}

bool wordPatternMatch(const char* pattern, const char* s) {
    CharMapping charToWord[MAX_MAPPINGS] = {0};
    WordMapping wordToChar[MAX_MAPPINGS] = {0};
    return backtrack(pattern, 0, s, 0, charToWord, wordToChar, strlen(pattern), strlen(s));
}

int main() {
    char pattern[MAX_LEN], s[MAX_LEN];
    fgets(pattern, sizeof(pattern), stdin);
    fgets(s, sizeof(s), stdin);
    
    // Remove newlines and quotes
    pattern[strcspn(pattern, "\n")] = 0;
    s[strcspn(s, "\n")] = 0;
    if (pattern[0] == '"') {
        memmove(pattern, pattern + 1, strlen(pattern));
        pattern[strlen(pattern) - 1] = 0;
    }
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = 0;
    }
    
    printf("%s\n", wordPatternMatch(pattern, s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(s^p)

In worst case, we try all possible ways to split string s into p parts, where each split can have exponential combinations

✓ Linear Growth

Space Complexity

O(p)

Recursion depth is bounded by pattern length p, plus space for storing mappings

✓ Linear Space

Constraints

1 ≤ pattern.length ≤ 20
1 ≤ s.length ≤ 50
pattern contains only lowercase English letters
s contains only lowercase English letters
Each pattern character must map to a non-empty substring

28.8K Views

Medium Frequency

~25 min Avg. Time

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

Backtracking with Basic Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler