15 Jun 2024•C++ / Python / TypeScript•Easy

Word Pattern

Collected C++, Python, TypeScript solutions for word pattern. Add a dedicated write-up later if you want deeper notes.

auto-generated entry for Word Pattern. the solution files are available below.

solution files

C++ word-pattern/synced-solution.cpp
Python word-pattern/synced-solution.py
TypeScript word-pattern/synced-solution.ts

Solution files

Python•word-pattern/synced-solution.py

def wordPattern(pattern: str, s: str) -> bool:
    words = s.split()
    if len(pattern) != len(words):
        return False

    char_to_word = {}
    word_to_char = {}

    for char, word in zip(pattern, words):
        if char in char_to_word:
            if char_to_word[char] != word:
                return False
        else:
            char_to_word[char] = word

        if word in word_to_char:
            if word_to_char[word] != char:
                return False
        else:
            word_to_char[word] = char

    return True

C++•word-pattern/synced-solution.cpp

class Solution {
public:
    bool wordPattern(string pattern, string s) {
        vector<string> words;
        stringstream ss(s);
        string word;
        while (ss >> word) {
            words.push_back(word);
        }

        if (pattern.length() != words.size()) return false;

        unordered_map<char, string> charToWord;
        unordered_map<string, char> wordToChar;

        for (int i = class="syntax-number">0; i < pattern.length(); i++) {
            char ch = pattern[i];
            string w = words[i];

            if (charToWord.count(ch)) {
                if (charToWord[ch] != w) return false;
            } else {
                charToWord[ch] = w;
            }

            if (wordToChar.count(w)) {
                if (wordToChar[w] != ch) return false;
            } else {
                wordToChar[w] = ch;
            }
        }

        return true;
    }
};

TypeScript•word-pattern/synced-solution.ts

function wordPattern(pattern: string, s: string): boolean {
    const words = s.split(class="syntax-string">' ');
    if (pattern.length !== words.length) return false;

    const charToWord = new Map<string, string>();
    const wordToChar = new Map<string, string>();

    for (let i = class="syntax-number">0; i < pattern.length; i++) {
        const char = pattern[i];
        const word = words[i];

        if (charToWord.has(char)) {
            if (charToWord.get(char) !== word) return false;
        } else {
            charToWord.set(char, word);
        }

        if (wordToChar.has(word)) {
            if (wordToChar.get(word) !== char) return false;
        } else {
            wordToChar.set(word, char);
        }
    }

    return true;
}