Word Pattern

                                            
class Solution {
public:
    bool wordPattern(string pattern, string s) {
        unordered_map<char, string> charToWord;
        unordered_map<string, char> wordToChar;
        istringstream iss(s);
        string word;
        int i = 0;
        while (iss >> word) {
            if (i == pattern.length() || charToWord.count(pattern[i]) && charToWord[pattern[i]] != word || wordToChar.count(word) && wordToChar[word] != pattern[i]) {
                return false;
            }
            charToWord[pattern[i]] = word;
            wordToChar[word] = pattern[i];
            i++;
        }
        return i == pattern.length();
    }
};

                                            
class Solution {
    public boolean wordPattern(String pattern, String s) {
        String[] words = s.split(" ");
        if (pattern.length() != words.length) {
            return false;
        }

        Map<Character, String> map = new HashMap<>();
        Set<String> wordSet = new HashSet<>();
        
        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            String word = words[i];
            
            if (map.containsKey(c)) {
                if (!map.get(c).equals(word)) {
                    return false;
                }
            } else {
                if (wordSet.contains(word)) {
                    return false;
                }
                
                map.put(c, word);
                wordSet.add(word);
            }
        }
        
        return true;
    }
}

                                            
class Solution(object):
    def wordPattern(self, pattern, s):
        words = s.split()
        if len(pattern) != len(words):
            return False
        
        char_word_map = {}
        word_char_map = {}
        
        for char, word in zip(pattern, words):
            if char in char_word_map:
                if char_word_map[char] != word:
                    return False
            else:
                char_word_map[char] = word
            
            if word in word_char_map:
                if word_char_map[word] != char:
                    return False
            else:
                word_char_map[word] = char
        
        return True

                                            
public class Solution {
    public bool WordPattern(string pattern, string s) {
        string[] words = s.Split(' ');
        if (pattern.Length != words.Length)
            return false;
        
        Dictionary<char, string> patternMap = new Dictionary<char, string>();
        HashSet<string> wordSet = new HashSet<string>();
        
        for (int i = 0; i < pattern.Length; i++) {
            char ch = pattern[i];
            string word = words[i];
            
            if (!patternMap.ContainsKey(ch)) {
                if (wordSet.Contains(word))
                    return false;
                
                patternMap[ch] = word;
                wordSet.Add(word);
            } else {
                if (patternMap[ch] != word)
                    return false;
            }
        }
        
        return true;
    }
}

                                            
/**
 * @param {string} pattern
 * @param {string} s
 * @return {boolean}
 */
var wordPattern = function(pattern, s) {
    const patternArr = pattern.split('');
    const sArr = s.split(' ');

    if (patternArr.length !== sArr.length) {
        return false;
    }

    const map = new Map();
    const set = new Set();

    for (let i = 0; i < patternArr.length; i++) {
        const char = patternArr[i];
        const word = sArr[i];

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

    return true;
};

                                            
function wordPattern(pattern: string, s: string): boolean {
    const patternArr = pattern.split('');
    const sArr = s.split(' ');

    if (patternArr.length !== sArr.length) {
        return false;
    }

    const patternMap = new Map<string, string>();
    const wordMap = new Map<string, string>();

    for (let i = 0; i < patternArr.length; i++) {
        const patternChar = patternArr[i];
        const word = sArr[i];

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

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

    return true;
};

                                            
class Solution {
    /**
     * @param String $pattern
     * @param String $s
     * @return Boolean
     */
    function wordPattern($pattern, $s) {
        $patternArr = str_split($pattern);
        $words = explode(' ', $s);
        
        if (count($patternArr) !== count($words)) {
            return false;
        }
        
        $map = [];
        $reverseMap = [];
        
        for ($i = 0; $i < count($patternArr); $i++) {
            $char = $patternArr[$i];
            $word = $words[$i];
            
            if (isset($map[$char])) {
                if ($map[$char] !== $word) {
                    return false;
                }
            } else {
                $map[$char] = $word;
            }
            
            if (isset($reverseMap[$word])) {
                if ($reverseMap[$word] !== $char) {
                    return false;
                }
            } else {
                $reverseMap[$word] = $char;
            }
        }
        
        return true;
    }
}

                                            
class Solution {
    func wordPattern(_ pattern: String, _ s: String) -> Bool {
        let words = s.components(separatedBy: " ")
        if pattern.count != words.count {
            return false
        }
        
        var charToStringMap: [Character: String] = [:]
        var stringToCharMap: [String: Character] = [:]
        
        for (index, char) in pattern.enumerated() {
            let word = words[index]
            if let mappedWord = charToStringMap[char], mappedWord != word {
                return false
            }
            
            if let mappedChar = stringToCharMap[word], mappedChar != char {
                return false
            }
            
            charToStringMap[char] = word
            stringToCharMap[word] = char
        }
        
        return true
    }
}

                                            
class Solution {
    fun wordPattern(pattern: String, s: String): Boolean {
        val words = s.split(" ")
        if (pattern.length != words.size) return false
        
        val mapCharToWord = HashMap<Char, String>()
        val mapWordToChar = HashMap<String, Char>()
        
        for (i in pattern.indices) {
            val char = pattern[i]
            val word = words[i]
            if (mapCharToWord.containsKey(char)) {
                if (mapCharToWord[char] != word) return false
            } else {
                if (mapWordToChar.containsKey(word)) return false
                mapCharToWord[char] = word
                mapWordToChar[word] = char
            }
        }
        
        return true
    }
}

                                            
class Solution {
  bool wordPattern(String pattern, String s) {
    List<String> words = s.split(' ');
    if (pattern.length != words.length) {
      return false;
    }
    
    Map<String, String> patternMap = {};
    Map<String, String> wordMap = {};
    
    for (int i = 0; i < pattern.length; i++) {
      String letter = pattern[i];
      String word = words[i];
      
      if (!patternMap.containsKey(letter) && !wordMap.containsKey(word)) {
        patternMap[letter] = word;
        wordMap[word] = letter;
      } else {
        if (patternMap[letter] != word || wordMap[word] != letter) {
          return false;
        }
      }
    }
    
    return true;
  }
}

                                            
func wordPattern(pattern string, s string) bool {
    words := strings.Split(s, " ")

    if len(pattern) != len(words) {
        return false
    }

    patternMap := make(map[byte]string)
    wordMap := make(map[string]byte)

    for i := 0; i < len(pattern); i++ {
        p := pattern[i]
        w := words[i]

        if _, ok := patternMap[p]; !ok {
            patternMap[p] = w
        } else {
            if patternMap[p] != w {
                return false
            }
        }

        if _, ok := wordMap[w]; !ok {
            wordMap[w] = p
        } else {
            if wordMap[w] != p {
                return false
            }
        }
    }

    return true
}

                                            
# @param {String} pattern
# @param {String} s
# @return {Boolean}
def word_pattern(pattern, s)
    pattern = pattern.split('')
    words = s.split(' ')
    
    return false if pattern.length != words.length
    
    pattern_map = {}
    word_map = {}
    
    pattern.each_with_index do |char, index|
        if pattern_map[char]
            return false if pattern_map[char] != words[index]
        else
            pattern_map[char] = words[index]
        end
        
        if word_map[words[index]]
            return false if word_map[words[index]] != char
        else
            word_map[words[index]] = char
        end
    end
    
    return true
end

                                            
use std::collections::HashMap;

impl Solution {
    pub fn word_pattern(pattern: String, s: String) -> bool {
        let pattern_chars: Vec<char> = pattern.chars().collect();
        let words: Vec<&str> = s.split_whitespace().collect();
        
        if pattern_chars.len() != words.len() {
            return false;
        }
        
        let mut pattern_map: HashMap<char, &str> = HashMap::new();
        let mut word_map: HashMap<&str, char> = HashMap::new();
        
        for i in 0..pattern_chars.len() {
            if let Some(&mapped_word) = pattern_map.get(&pattern_chars[i]) {
                if mapped_word != words[i] {
                    return false;
                }
            }
            if let Some(&mapped_char) = word_map.get(&words[i]) {
                if mapped_char != pattern_chars[i] {
                    return false;
                }
            }
            pattern_map.insert(pattern_chars[i], words[i]);
            word_map.insert(words[i], pattern_chars[i]);
        }
        
        true
    }
}

To solve this coding challenge, we need to determine if a given string adheres to a provided pattern. This requires ensuring there's a one-to-one correspondence (bijection) between each character in the pattern and each word in the string. Here's how we can achieve this:

Explanation

Initial Check :

First, we should verify if the number of characters in the pattern matches the number of words in the string. If they don't match, it's impossible for there to be a one-to-one correspondence, and we can immediately return
False

.

Splitting the String :

Convert the string
s

into a list of words.

Create Mappings :

We'll use two dictionaries:
char_to_word

to map characters from the pattern to words in the string, and
word_to_char

to map words in the string back to characters in the pattern. This helps ensure that the mapping is bijective (one-to-one and onto).

Iterate and Validate :

Iterate through pairs of characters from the pattern and words from the string.
For each pair, check:

If the character has been seen before but maps to a different word, return
False

.
If the word has been seen before but maps to a different character, return
False

.

If the character and word have not been seen before, update the mappings.

Conclusion :

If we successfully iterate through all pairs without finding inconsistencies, then the string follows the pattern and we return
True

.

Step-by-Step Explanation/Detailed Steps in Pseudocode

Input:

pattern

("abba")
s

("dog cat cat dog")
Initialize Structures :

Create empty dictionaries
char_to_word

and
word_to_char

.

Split String :

Split the string
s

into a list of words:
words = ["dog", "cat", "cat", "dog"]

.

Check Length :

If the length of
pattern

is not equal to the length of
words

, return
False

.

Iterate Through Paired Items :

For each character (from
pattern

) and word (from
words

):

Check if the character is already in
char_to_word

:

If yes, but the mapped word differs from the current word, return
False

.

Check if the word is already in
word_to_char

:

If yes, but the mapped character differs from the current character, return
False

.

If neither is found, update both dictionaries with the new mapping.

Final Check :

After iterating, if no inconsistencies were found, return
True

.

Pseudocode

                                            
// Initialize dictionaries to hold mappings
char_to_word = {}
word_to_char = {}

// Split the string into a list of words
words = split_string_on_spaces(s)

if length_of(pattern) != length_of(words)
    return False

// Iterate through each character and corresponding word
for char, word in paired_elements(pattern, words)
    // Check if character is in char_to_word
    if char in char_to_word
        if char_to_word[char] != word
            return False
    else
        // Add new mapping to char_to_word
        char_to_word[char] = word

    // Check if word is in word_to_char
    if word in word_to_char
        if word_to_char[word] != char
            return False
    else
        // Add new mapping to word_to_char
        word_to_char[word] = char

// If all checks passed, return True
return True

In this pseudocode, the

split_string_on_spaces(s)

function splits the input string

s

into individual words. The

paired_elements(pattern, words)

function pairs each character in

pattern

with each corresponding word in

words

for iteration. This approach ensures a clear, detailed, and step-by-step methodology for solving the problem, providing a comprehensive understanding of the process.