290. Word Pattern

Easy


Given a pattern and a string s, find if s follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in s.

 

Example 1:

Input: pattern = "abba", s = "dog cat cat dog"
Output: true

Example 2:

Input: pattern = "abba", s = "dog cat cat fish"
Output: false

Example 3:

Input: pattern = "aaaa", s = "dog cat cat dog"
Output: false

 

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.




 class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:

#         pattern_dict = {}
#         pat = ""
#         for char in pattern:
#             if char in pattern_dict:
#                 pat += pattern_dict[char]
#             else:
#                 pattern_dict[char] = str(len(pattern_dict)+1)
#                 pat += pattern_dict[char]


#         s_dict = {}
#         ss = ""
#         for char in s.split():
#             if char in s_dict:
#                 ss += s_dict[char]
#             else:
#                 s_dict[char] = str(len(s_dict)+1)
#                 ss += s_dict[char]

#         return pat == ss

        s, pattern = s.split(), list(pattern)
        return list(map(s.index, s)) == list(map(pattern.index, pattern))

Random Note


Amortized time is the way to express the time complexity when an algorithm has the very bad time complexity only once in a while besides the time complexity that happens most of time. Good example would be an ArrayList which is a data structure that contains an array and can be extended.