Hashmap

# Time complexity: O(n)
# Space complexity: O(n)
def canConstruct(ransomNote: str, magazine: str) -> bool:
    m = {}
    for c in magazine:
        m[c] = m.get(c, 0) + 1

    for c in ransomNote:
        if c not in m or m[c] == 0:
            return False
        m[c] -= 1
    return True

# Time complexity: O(n)
# Space complexity: O(n)
def isIsomorphic(self, s: str, t: str) -> bool:
    s2t, t2s = {}, {}
    for i in range(len(s)):
        # Characters must have the same mapping in both directions
        if s[i] in s2t and s2t[s[i]] != t[i]:
            return False
        if t[i] in t2s and t2s[t[i]] != s[i]:
            return False
        s2t[s[i]] = t[i]
        t2s[t[i]] = s[i]
    return True

NOTE: The solution for "Word Pattern" can also be used to solve this problem.

# Time complexity: O(n)
# Space complexity: O(n)

# Example: "abba" -> (0, 1, 1, 0)
def convertPatternToTuple(string: str) -> tuple:
    m = {}
    count = 0
    result = []

    for c in string:
        if c in m:
            result.append(m[c])
        else:
            m[c] = count
            result.append(count)
            count += 1
    return tuple(result)

# Example: "dog cat cat dog" -> (0, 1, 1, 0)
def convertWordsToTuple(words: str) -> tuple:
    m = {}
    count = 0
    result = []
    words = words.split()

    for word in words:
        if word in m:
            result.append(m[word])
        else:
            m[word] = count
            result.append(count)
            count += 1
    return tuple(result)

def wordPattern(pattern: str, s: str) -> bool:
    return convertPatternToTuple(pattern) == convertWordsToTuple(s)

# Time complexity: O(n)
# Space complexity: O(n)
def isAnagram(s: str, t: str) -> bool:
    if len(s) != len(t):
        return False

    m = {}
    for c in s:
        m[c] = m.get(c, 0) + 1

    for c in t:
        if c not in m or m[c] == 0:
            return False
        m[c] -= 1
    return True

# Time complexity: O(n)
# Space complexity: O(n)
def twoSum(nums: List[int], target: int) -> List[int]:
    m = {}
    for i in range(len(nums)):
        comp = target - nums[i]
        if comp in m:
            return [i, m[comp]]
        m[nums[i]] = i

# Time complexity: O(n)
# Space complexity: O(n)
def isHappy(n: int) -> bool:
    m = set()

    while True:
        if n in m:
            return False
        else:
            m.add(n)

        li = list(str(n))
        sum = 0
        for c in li:
            sum += int(c) ** 2
        if sum == 1:
            return True
        n = sum

# Time complexity: O(n)
# Space complexity: O(n)
def containsNearbyDuplicate(nums: List[int], k: int) -> bool:
    m = {}
    for i in range(len(nums)):
        if nums[i] not in m:
            m[nums[i]] = i
        else:
            if abs(i - m[nums[i]]) <= k:
                return True
            m[nums[i]] = i
    return False

# Time complexity: O(n * m * log(m))
# Space complexity: O(n * m)
def groupAnagrams(strs: List[str]) -> List[List[str]]:
    answer = {}

    for word in strs:
        w = "".join(sorted(word))
        if w in answer:
            answer[w].append(word)
        else:
            answer[w] = [word]
    return list(answer.values())

Alternative solution:

# Time complexity: O(n * m)
# Space complexity: O(n * m)
def groupAnagrams(strs: List[str]) -> List[List[str]]:
    m = {}
    for word in strs:
        # Use list to count char frequency
        chars = [0] * 26
        for char in word:
            chars[ord(char) - 97] += 1
        # Use frequency as map key
        tup = tuple(chars)
        if tup in m:
            m[tup].append(word)
        else:
            m[tup] = [word]

    return [m[tup] for tup in m]

# Time complexity: O(n)
# Space complexity: O(n)
def longestConsecutive(nums: List[int]) -> int:
    s = set(nums)
    answer = 0

    for n in nums:
        # n is lowest value aka start of own sequence
        if n - 1 not in s:
            end = n + 1
            while end in s:
                end += 1
            answer = max(answer, end - n)
    return answer