leedcode-单词规律

自己写的，好像有点复杂：

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        # 将字符串 s 按空格切分成单词列表
        mystr = s.split()
        
        # 创建一个空字典，用于存储字符和其出现位置的映射
        mydic = dict()
        
        # 将单词列表转换为集合，以便检查单词是否唯一
        mystr_set = set(mystr)
        
        # 检查模式字符串和单词列表的长度是否相同，如果不同，则返回 False
        if len(mystr) != len(pattern):
            return False
        
        # 遍历模式字符串的每个字符
        for index, char in enumerate(pattern):
            # 如果当前字符不在字典中，将其添加到字典并将其位置作为值
            if char not in mydic:
                mydic.update({char: [index]})
            else:
                # 如果当前字符已经在字典中，将其位置添加到对应字符的值列表中
                mydic[char].append(index)
        
        # 检查字典中不同值的数量是否与单词集合的长度相同，如果不同，则返回 False
        if len(mydic) != len(mystr_set):
            return False
        
        # 检查每个字符在单词列表中的位置是否一致
        for k, value_list in mydic.items():
            for i in value_list:
                # 如果当前位置的单词与该字符的第一个位置的单词不同，则返回 False
                if mystr[i] == mystr[value_list[0]]:
                    continue
                else:
                    return False
        
        # 如果所有检查都通过，则返回 True
        return True

 gpt优化：检查双向的映射关系

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        # 将字符串 s 按空格切分成单词列表
        words = s.split()
        
        # 如果单词数量与模式字符数量不一致，则返回 False
        if len(words) != len(pattern):
            return False
        
        # 创建两个空字典，用于存储模式字符到单词和单词到模式字符的映射关系
        pattern_to_word = {}
        word_to_pattern = {}
        
        # 遍历模式字符串和单词列表
        for char, word in zip(pattern, words):
            # 检查模式字符到单词的映射关系
            if char not in pattern_to_word:
                pattern_to_word[char] = word
            else:
                # 如果模式字符已经存在于映射中，检查是否对应相同的单词，若不同则返回 False
                if pattern_to_word[char] != word:
                    return False
            
            # 检查单词到模式字符的映射关系
            if word not in word_to_pattern:
                word_to_pattern[word] = char
            else:
                # 如果单词已经存在于映射中，检查是否对应相同的模式字符，若不同则返回 False
                if word_to_pattern[word] != char:
                    return False
        
        # 如果所有映射关系都一致，则返回 True
        return True