В ходе обсуждения с товарищем docent2007 статьи о сортировке «Милосердный Сталин» у нас сами собой родились дополнительные, весьма полезные методы сортировки. Эти методы определённо могут пригодиться каждому.

Либеральная сортировка

Либеральная сортировка уважает каждое значение и его "право" на место.

def liberal_sort(arr):
    # Каждый элемент остается на своём месте, потому что все равны
    return arr

То есть массив возвращается таким, какой он есть, без изменений, поскольку "у каждого элемента своё уникальное место, которое нельзя нарушить".

Есть еще вариант Либеральной сортировки, где все элементы группируются по какому-то общему признаку, чтобы "никто не чувствовал себя изолированным". Внутри каждой группы порядок сохраняется.

from collections import defaultdict

def liberal_sort_with_groups(arr, key_func=lambda x: x):
    # Группируем элементы по ключу, но внутри групп порядок сохраняется
    groups = defaultdict(list)
    for item in arr:
        groups[key_func(item)].append(item)

    result = []
    for group in groups.values():
        result.extend(group)
    return result

arr = [5, 3, 8, 3, 1, 8, 5]
sorted_arr = liberal_sort_with_groups(arr, key_func=lambda x: x % 2)
print(sorted_arr)
# нечетные и затем четные, но порядок в группах сохранен
# -> [5, 3, 3, 1, 5, 8, 8]

Сортировка "Бакунин"

Это явно анархическая концепция! Исходя из анархистских принципов Михаила Бакунина, такая сортировка полностью отвергает любые правила и порядки. Она выглядит как функция, которая не сортирует вовсе, а, наоборот, делает всё максимально хаотичным.

import random

def bakunin_sort(arr):
    # Разрушаем любой порядок и возвращаем массив в случайном порядке
    random.shuffle(arr)
    return arr

arr = [1, 2, 3, 4, 5]
sorted_arr = bakunin_sort(arr)
print(sorted_arr)
# -> [4, 1, 3, 5, 2] — каждый раз что-то новое!

Идеология:

• Все элементы равны, и никто не должен занимать "правильное" или "привилегированное" место;
• Любая попытка установить порядок — это подавление свободы элементов;
• Результат непредсказуем, потому что хаос — естественное состояние системы.

Продвинутая "революционная" версия сортировки "Бакунина" включает в себя так же уничтожение структуры массива:

def bakunin_sort_extreme(arr):
    # Полностью освобождаем элементы от порядка... и самого массива
    return list(set(bakunin_sort(arr)))
# -> [8, 1, 3, 5] — дубликаты как форма угнетения были удалены

Капиталистические сортировки

Отражают принцип накопления богатства, где "сильные становятся сильнее". В этих алгоритмах элементы с большими значениями получают преимущество за счёт "эксплуатации" меньших элементов.

Простая капиталистическая сортировка

Классический подход: сортировка по убыванию, где "богатство" — это значение элемента.

def capitalist_sort(arr):
    # Большие элементы доминируют над меньшими
    return sorted(arr, reverse=True)
# [1, 5, 2, 9, 3] -> [9, 5, 3, 2, 1]

Капиталистическая сортировка с эксплуатацией меньших элементов

Крупные элементы "забирают часть богатства" у меньших:

def capitalist_sort_with_redistribution(arr):
    # Каждый элемент отдаёт часть своего значения ближайшему большему
    arr = sorted(arr, reverse=True)
    for i in range(len(arr) - 1):
        arr[i] += arr[i + 1] // 2  # Большие элементы "забирают" у меньших
        arr[i + 1] //= 2
    return arr
# [1, 5, 2, 9, 3] -> [11, 3, 2, 1, 0]

Сортировка с элементами капиталистической иерархии

Массив делится на "классы", где элита (топ-10%) занимает первые позиции, а значения среднего класса перераспределяются к элите и бедному классу.

def capitalist_sort_hierarchy(arr: List[int]) -> List[int]:
    arr.sort(reverse=True)

    n = len(arr)
    top_size = ceil(0.1 * n)  # 10% элита
    middle_size = ceil(0.3 * n)  # 30% средний класс

    top = arr[:top_size]  # Топ 10%
    middle = arr[top_size:top_size + middle_size]
    bottom = arr[top_size + middle_size:]  # Остальные

    # Перераспределение из средних в элиту
    for i in range(len(middle)):
        middle[i] -= 5
        top[i % len(top)] += 5

    # Перераспределение из средних в бедных
    for i in range(len(middle)):
        middle[i] -= 1
        bottom[i % len(bottom)] += 1

    result = top + middle + bottom
    result.sort(reverse=True)

    return result

# [30, 1, 500, 5, 2, 3, 1, 40, 50] -> [515, 44, 34, 24, 6, 4, 3, 1, 1]

Идеология:

• "Богатые" элементы всегда на вершине (по значению);
• Меньшие элементы могут быть перераспределены, игнорированы или даже исчезнуть;
• Неравенство встроено в сам принцип сортировки.

В капиталистическом обществе и сортировке победитель получает всё!

Ленинская сортировка

«Лучше меньше, да лучше» — одна из последних работ В. И. Ленина, отсюда Ленинская сортировка не только уравнивает или перераспределяет, но и оставляет только "лучшие" элементы.

Алгоритм отбирает только верхнюю часть массива — те элементы, которые "наиболее достойны", а остальные игнорирует.

def lenin_sort_reduce(arr, threshold=3):
    # Сохраняем только лучшие элементы, превышающие заданный порог
    return sorted([x for x in arr if x > threshold])
# [1, 5, 2, 9, 3] -> [5, 9]

Коммунистическая сортировка

Отражает принцип "каждому по потребностям, от каждого по возможностям". Это означает, что все элементы становятся равными, распределяя ресурсы (значения) справедливо.

Все элементы "экспроприируются" и получают одинаковое значение (среднее).

def communist_sort(arr):
    # Уравниваем значения всех элементов
    avg = sum(arr) // len(arr)
    return [avg] * len(arr)
# [1, 5, 2, 9, 3] -> [4, 4, 4, 4, 4]

Социалистическая сортировка

Социализм менее радикален, чем коммунизм. Принципы: помощь слабым, но сохранение иерархии. В результате больший акцент на справедливость, а не абсолютное равенство.

В сортировке используется прогрессивное перераспределение, то есть более крупные элементы "делятся" с меньшими, но сохраняется общий порядок.

def socialist_sort(arr):
    # Большие элементы отдают часть своим соседям
    arr = sorted(arr)
    for i in range(len(arr) - 1, 0, -1):
        diff = (arr[i] - arr[i - 1]) // 2
        arr[i] -= diff
        arr[i - 1] += diff
    return arr

# [1, 5, 2, 9, 3] -> [2, 2, 4, 5, 7]

Ельцинская сортировка

Ельцинская сортировка отражает эпоху 1990-х в России: хаос, нестабильность, но с попытками "реформ" и установления нового порядка. Она сочетает элементы случайности, "либерализации" и популизма.

import random

def yeltsin_sort(arr):
    # Смешиваем элементы, затем делаем "попытку" сортировки на части массива
    random.shuffle(arr)
    reform_start = len(arr) // 3  # С середины массива начинаются реформы
    arr[reform_start:] = sorted(arr[reform_start:])
    return arr

# [1, 5, 2, 9, 3, 7, 6] -> [7, 5, 1, 2, 3, 6, 9]

Сортировка по Гитлеру

Отобирется часть элементов массива по странному признаку, их значения перераспределяются между остальными, а сами обнуленные элементы выпиливаются из массива.

def hitler_sort(arr):
    A = [x for x in arr if x % 4 != 0 and x % 7 != 0]
    B = [x for x in arr if x % 4 == 0 or x % 7 == 0] 

    if B:
        sum_B = sum(B)
        if A:
            distribution = sum_B / len(A)
            A = [x + distribution for x in A] # добавляем отобранное у B

    A.sort()
    return A

# [4, 1, 5, 4, 9, 3, 7, 6] -> [4, 6, 8, 9, 12]

Сортировка Робеспьером

Отражает принцип жесткой дисциплины и революционного террора. Алгоритм безжалостно устраняет через "гильотину" неугодные элементы, оставляя только те, которые соответствуют строгим критериям. В итоге массив оказывался "очищенным" и упорядоченным.

from collections import Counter

def robespierre_sort_rare(arr):
    counter = Counter(arr)
    threshold = 2  # Минимальное количество вхождений
    survivors = [x for x in arr if counter[x] >= threshold]
    return sorted(survivors)

# [1, 2, 5, 1, 9, 5, 2, 6] -> [1, 1, 2, 2, 5, 5]