Word Pattern - Practice Coding Problems

Word Pattern - Problem

Imagine you're a cryptographer trying to decode a secret message! You have a pattern (like a cipher key) and a string of words, and you need to determine if the words follow the exact same pattern as your key.

Given a pattern string and a string s of words separated by spaces, determine if s follows the same pattern. This means there must be a one-to-one correspondence (bijection) between each letter in the pattern and each word in the string.

Rules:

Each letter in pattern maps to exactly one unique word in s
Each unique word in s maps to exactly one letter in pattern
No two letters can map to the same word
No two words can map to the same letter

Example: Pattern "abba" with string "dog cat cat dog" should return true because 'a' maps to 'dog', 'b' maps to 'cat', and the pattern matches perfectly!

Input & Output

example_1.py — Basic Pattern Match

$ Input: pattern = "abba", s = "dog cat cat dog"

› Output: true

💡 Note: The pattern matches perfectly: 'a' maps to 'dog', 'b' maps to 'cat', and the sequence follows the same pattern in both directions.

example_2.py — Pattern Mismatch

$ Input: pattern = "abba", s = "dog cat cat fish"

› Output: false

💡 Note: The pattern fails because 'a' would need to map to both 'dog' and 'fish', violating the one-to-one correspondence rule.

example_3.py — Length Mismatch

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

› Output: false

💡 Note: The pattern has 4 characters but there are only 3 words, so it's impossible for them to match.

Visualization

Tap to expand

Understanding the Visualization

Initialize Cipher Books

Create two lookup tables: char→word and word→char

Process First Pair (a, dog)

No existing mapping, so establish: a→dog and dog→a

Process Second Pair (b, cat)

No existing mapping, so establish: b→cat and cat→b

Validate Third Pair (b, cat)

Check: b should map to cat ✓, cat should map to b ✓

Validate Fourth Pair (a, dog)

Check: a should map to dog ✓, dog should map to a ✓

Cipher Validated

All pairs consistent - the secret message follows the pattern!

Key Takeaway

🎯 Key Insight: The bidirectional hash table approach ensures perfect cipher validation by maintaining both char→word AND word→char mappings, catching any violation of the one-to-one correspondence immediately in O(1) time per element.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through pattern and words, with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Two hash maps storing at most n character-word pairs each

⚡ Linearithmic Space

Constraints

1 ≤ pattern.length ≤ 300
pattern contains only lower-case English letters
1 ≤ s.length ≤ 3000
s contains only lowercase English letters and spaces ' '
s does not contain any leading or trailing spaces
All the words in s are separated by a single space

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22 Apple 15

The optimal solution uses a one-pass hash table approach with bidirectional mapping. We maintain two hash maps: char_to_word and word_to_char, ensuring the bijection property by checking both directions simultaneously. This achieves O(n) time complexity and O(n) space complexity, providing immediate conflict detection and efficient pattern validation.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build bidirectional mapping while iterating once through the input
Brute Force (Character-by-Character Validation)	O(n²)	O(1)	Check each character-word pair against all previous mappings

One-Pass Hash Table (Optimal) — Algorithm Steps

Split the input string into words array
Check if pattern length equals number of words
Initialize two hash maps: char_to_word and word_to_char
Iterate through pattern and words simultaneously
For each pair, check if mapping exists and is consistent
If no mapping exists, create bidirectional mapping
If mapping exists but conflicts, return false
Return true if all pairs are processed successfully

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Maps

Create char_to_word and word_to_char hash maps

Process Each Pair

For each (char, word) pair, check or create mappings

Verify Bijection

Ensure both directions of mapping are consistent

Early Termination

Return false immediately on first conflict

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 100

typedef struct {
    char key;
    char value[MAX_WORD_LEN];
} CharToWord;

typedef struct {
    char key[MAX_WORD_LEN];
    char value;
} WordToChar;

int wordPattern(char* pattern, char* s) {
    char words[MAX_WORDS][MAX_WORD_LEN];
    int wordCount = 0;
    
    // Split string into words
    char* sCopy = malloc(strlen(s) + 1);
    strcpy(sCopy, s);
    char* token = strtok(sCopy, " ");
    while (token != NULL && wordCount < MAX_WORDS) {
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    int patternLen = strlen(pattern);
    
    // Check if lengths match
    if (patternLen != wordCount) {
        free(sCopy);
        return 0;
    }
    
    CharToWord charMap[26] = {0};
    WordToChar wordMap[MAX_WORDS] = {0};
    int charMapSize = 0, wordMapSize = 0;
    
    // Single pass with bidirectional mapping
    for (int i = 0; i < patternLen; i++) {
        char ch = pattern[i];
        char* word = words[i];
        
        // Check character to word mapping
        int foundChar = -1;
        for (int j = 0; j < charMapSize; j++) {
            if (charMap[j].key == ch) {
                foundChar = j;
                break;
            }
        }
        
        if (foundChar >= 0) {
            if (strcmp(charMap[foundChar].value, word) != 0) {
                free(sCopy);
                return 0;
            }
        } else {
            charMap[charMapSize].key = ch;
            strcpy(charMap[charMapSize].value, word);
            charMapSize++;
        }
        
        // Check word to character mapping
        int foundWord = -1;
        for (int j = 0; j < wordMapSize; j++) {
            if (strcmp(wordMap[j].key, word) == 0) {
                foundWord = j;
                break;
            }
        }
        
        if (foundWord >= 0) {
            if (wordMap[foundWord].value != ch) {
                free(sCopy);
                return 0;
            }
        } else {
            strcpy(wordMap[wordMapSize].key, word);
            wordMap[wordMapSize].value = ch;
            wordMapSize++;
        }
    }
    
    free(sCopy);
    return 1;
}

int main() {
    char pattern[] = "abba";
    char s[] = "dog cat cat dog";
    printf("%s\n", wordPattern(pattern, s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through pattern and words, with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Two hash maps storing at most n character-word pairs each

⚡ Linearithmic Space

Constraints

1 ≤ pattern.length ≤ 300
pattern contains only lower-case English letters
1 ≤ s.length ≤ 3000
s contains only lowercase English letters and spaces ' '
s does not contain any leading or trailing spaces
All the words in s are separated by a single space

52.0K Views

High Frequency

~15 min Avg. Time

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