common = set(a).intersection(set(b))  # найдём общие элементы
for el in common:
    occurs = min(a.count(el), b.count(el))  # и посчитаем, сколько они встречаются

def common_elements(a, b):
  b_dict = defaultdict(int)  # defaultdict выжил :)
  for el in b:
      b_dict[el] += 1  # я считаю все элементы из b, т.е. типа collections.Counter
  result = []
  for el in a:
      count = b_dict[el]
      if count > 0:  # если какой-то элемент из a встречается в b
          result.append(a)  # то это успех
          b_dict[a] -= 1  # и я "вынимаю" его из b, т.е. уменьшаю его количество на 1
  return result

def convert(s: str) -> str:
  result: List[str] = []
  last_sym = None  # последний символ, что мы видели
  count = 0  # и сколько мы его видели
  # мы будем идти по строке и записывать в result при смене символа
  for sym in (list(s) + [None]):  # последний None искусственно триггерит посленюю смену символа
      if last_sym and sym != last_sym:  # если случилась смена символа
          if count == 1:
              result.append(last_sym)
          else:
              result.append(last_sym + str(count))
          # начнаем запоминать новый символ
          count = 1
          last_sym = sym
      else:  # символ просто повторился
          count += 1  # ну ок, запомнили что символ видели на 1 раз больше
  return ''.join(result)

def repr(group_start, group_end) -> str:
    # это просто правильно печатает группу
    if last_group_start == last_group_end:
        return str(last_group_end)
    return f'{last_group_start}-{last_group_end}'
def squeeze(numbers) -> str:
    if not numbers:  # граничный случай
        return ''
    numbers_ = sorted(numbers)  # сначала располагаем по порядку
    groups = []  # тут будем хранить группы
    last_group_start = None
    last_group_end = None
    for n in numbers_:
        # это первая итерация, просто говорим, что группа началась и закончилась
        if last_group_end is None:
            last_group_start = n
            last_group_end = n
        # если предыдущая группа отличается от текущего числа на 1,
        # то это число входит в группу, то есть становится концом группы
        elif last_group_end == n-1:
            last_group_end = n
        # иначе мы понимаем, что группа закончилась,
        # мы её запоминаем и начинаем новую
        else:
            groups.append(repr(last_group_start, last_group_end))
            last_group_start = n
            last_group_end = n
    else:
        # посленюю группу придётся обработать вручную
        groups.append(repr(last_group_start, last_group_end))
    return ','.join(groups)

# пример: [0, 0, 1, 1, 0, 1, 1, 0]
def max_ones_length(lst: List[int]) -> int:
    max_ones_length = 0
    # тут мы хотим получить сгруппированные 0 или 1 и их количество:
    subranges = []  # [(0, 2), (1, 2), (0, 1), (1, 2), (0, 1)]
    last_el = None  # последний элемент, который мы просмотрели
    # идём по элементам списка
    for el in lst + [0]:  # [0] - это ручной триггер для обработки последнего элемента
        if last_el != el:  # если произошла смена 0 на 1 или наоборот
            if el == 0:  # если это была смена 1 на 0
                # пример: subranges == [(0, 2), (1, 2), (0, 1), (1, 2)]
                # у нас произошла смена 1 на 0, до смены единица шла 2 раза
                # (см последний элемент subranges) - проверяем, вдруг это
                # максимальная длина
                try:
                    last_ones_length = subranges[-1][1]
                    max_ones_length = max(last_ones_length, max_ones_length)
                except IndexError:
                    pass
                # а может если мы удалим один ноль между элементами 1 и 3,
                # то получится более длинная последовательность единиц?
                try:
                    gap_length = subranges[-2][1]
                    if gap_length == 1:
                        combined_ones_length = subranges[-1][1] + subranges[-3][1]
                        max_ones_length = max(combined_ones_length, max_ones_length)
                except IndexError:
                    pass
            # добавляем новый счётчик последовательности в subranges
            subranges.append((el, 1))
        else:
            # увеличиваем счётчик последней последовательности на 1
            subranges[-1] = (el, subranges[-1][1]+1])
        last_el = el
    # костыль, граничное условие
    if len(subranges) == 2 and subranges[1][1] == 1:
        return subranges[0][1] - 1
    return max_ones_length

from collections import defaultdict
def max_num_guests(guests: List[tuple]) -> int:
    res = 0
    # для каждого дня посчитаем, сколько приехало и сколько отъехало
    arriving = defaultdict(int)
    leaving = defaultdict(int)
    for guest in guests:  # O(n)
        arriving[guest[0]] += 1
        leaving[guest[1]] += 1
    current = 0
    # едем по дням в порядке увеличения, добавлем приехавших и убавляем уехавших,
    # считаем сколько стало
    for day in sorted(set(arriving.keys()).union(set(leaving.keys()))):  # O(n*log(n)) + O(n)
        current -= leaving[day]
        current += arriving[day]
        if current > res:
            res = current
    return res

def group_words(words: List[str]) -> List[List[str]]:
    groups = defaultdict(list)
    for word in words:  # O(n)
        key = sorted(word)
        groups[key].append(word)
    return [sorted(words) for words in groups.values()]  # O(n*log(n))

def merge(ranges: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
    if not ranges:
        return []
    result_ranges = []
    last_range = None  # последний отрезок, что мы видели
    for rng in sorted(ranges):  # обязательно сортируем
        if not last_range:
            last_range = rng
            continue
        # если начало текущего отрезка меньше конца предыдущего
        if rng[0] <= last_range[1]:
            # расширяем предыдущий отрезок на текущий
            last_range = (last_range[0], max(rng[1], last_range[1])
        # старый отрезок всё, начинаем новый
        else:
            result_ranges.append(last_range)
            last_range = rng
    else:
        # граничный случай для последнего элемента
        result_ranges.append(last_range)
    return result_ranges

from statistics import mean
def is_vertical_symmetry(points: List[Point]) -> bool:
    # сначала найдём вертикальную прямую в середине всех точек
    x_center = mean(p.x for p in points)
    # тут будем хранить точки, для которых пока не нашли пары:
    unmatched_points = defaultdict(int)
    for point in points:
        if point.x == x_center:  # если точка на прямой, то она сама себе пара
            continue
        # создадим "брата" - точку, которая симметрична текущей относительно вертикальной прямой
        brother = Point(
            x = x_center * 2 - point.x,
            y = point.y,
        )
        # если этот брат есть в unmatched_points, то достаём его оттуда и говорим, что текущая точка сматчилась
        if unmatched_points[brother]:
            unmatched_points[brother] -= 1
        # иначе добавляем эту точку в не-сматченные
        else:
            unmatched_points[point] += 1
    return not any(unmatched_points.values())

def no_more_than_one_change(string1: str, string2: str) -> bool:
    # string1: a b c d
    # string2: a b c
    max_length = max(len(string1), len(string2))  # наибольшая длина строк
    diff = abs(len(string1) - len(string2))  # разница в длине строк
    # дополняем строки до максимальной длины при помощи zip_longest,
    # то есть на место "недостающих" элементов ставим None, и строки
    # теперь одинаковой длины;
    #          ---->
    # string1: a b c d
    # string2: a b c None
    # идём слева направо по обеим строкам и сравниваем символы,
    # находим индекс, при котором строки начинают отличаться:
    change_left = None
    for i, (char1, char2) in enumerate(zip_longest(string1, string2)):  # O(n)
        if char1 != char2:
            change_left = i  # в нашем примере будет 3
            break
    else:
        # если мы такой индекс не нашли, то строки просто совпадают
        return True
    # теперь делаем то же, но идём справа налево:
    # string1:    a b c d
    # string2: None a b c
    #               <----
    change_right = None
    for j, (char1, char2) in enumerate(zip_longest(reversed(string1), reversed(string2))):  # O(n)
        if char1 != char2:
            # тут строки прям сразу отличаются, т.е. в индексе j=0;
            # но это у нас индекс в системе "справа налево",
            # а мы его переводим в индекс в системе "слева направо":
            i = max_length - j - 1 + diff
            break
    else:
        assert False, 'Я дебил и что-то не учёл'
    # ну а теперь смотрим, если строки отличаются в одном и том же месте
    # при сканировании слева направо и справа налево, то это нам подходит
    return change_left == change_right

[1, -3, 5, 6, 2, 3, 5]
^____[range(0,1)=1]
[1, -3, 5, 6, 2, 3, 5]
     ^___[range(0,2)=range(0,1)-3=-2, range(1,2)=-3]
[1, -3, 5, 6, 2, 3, 5]
        ^___[range(0,3)=range(0,2)+5=3, range(1,3)=range(1,2)+5=2, range(2,3)=5]