Клеточные автоматы на примере Conway's Game of Life

_Conway's Game of Life_ — классический клеточный автомат, где каждая клетка живёт или умирает по простым правилам:

1. Живая клетка с 2 или 3 живыми соседями остаётся живой, иначе умирает.
2. Мёртвая клетка с ровно 3 живыми соседями становится живой.
3. Во всех остальных случаях состояние клетки не меняется или она остаётся мёртвой.

Ниже приведён простой код на Python, моделирующий данную игру с помощью библиотеки matplotlib для визуализации.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

def update(frame_num, img, grid, N):
    new_grid = grid.copy()

    for i in range(N):
        for j in range(N):
            # Считаем количество живых соседей
            total = int(
                grid[(i - 1) % N, (j - 1) % N] + grid[(i - 1) % N, j] + grid[(i - 1) % N, (j + 1) % N] +
                grid[i, (j - 1) % N] +                                     grid[i, (j + 1) % N] +
                grid[(i + 1) % N, (j - 1) % N] + grid[(i + 1) % N, j] + grid[(i + 1) % N, (j + 1) % N]
            )
            # Применяем правила
            if grid[i, j] == 1:  # Живая
                if total < 2 or total > 3:
                    new_grid[i, j] = 0
            else:  # Мёртвая
                if total == 3:
                    new_grid[i, j] = 1

    img.set_data(new_grid)
    grid[:] = new_grid[:]
    return [img]

def main():
    N = 50  # размер поля NxN
    # Инициализируем сетку случайными 0 и 1
    grid = np.random.choice([0, 1], N*N, p=[0.8, 0.2]).reshape(N, N)

    fig, ax = plt.subplots()
    img = ax.imshow(grid, interpolation='nearest', cmap='binary')
    ani = animation.FuncAnimation(
        fig, update, fargs=(img, grid, N),
        frames=100, interval=100, save_count=50, blit=True
    )
    plt.show()

if __name__ == "__main__":
    main()

### Как это работает

1. Сетка grid — двумерный массив, в каждой ячейке которого 0 (мёртвая клетка) или 1 (живая клетка).
2. На каждом шаге (`update`) для каждой клетки подсчитываются 8 соседей (с учётом периодических краёв через операцию `% N`).
3. Применяются правила (2–3 живых соседа — выживание, ровно 3 соседа — зарождение).
4. matplotlib.animation.FuncAnimation каждую итерацию вызывает update, перерисовывая текущее состояние сетки.

Таким образом, можно наблюдать различные «фигуры» (глайдеры, стационарные структуры и т.д.), которые являются результатом простых локальных взаимодействий клеток.

Подпишись 👉🏻 @KodduuPython 🤖

Сжатие данных на примере алгоритма Хаффмана (Huffman Coding)

Алгоритм Хаффмана — классический метод без потерь, который находит оптимальное префиксное кодирование для набора символов, основываясь на их частотах.


### 1. Основная идея

1. Подсчёт частот: Сколько раз каждый символ встречается во входных данных.
2. Построение дерева: Создаём дерево Хаффмана, соединяя самые редкие символы в листьях с меньшими «весами» (их суммарной частотой).
3. Назначение кодов: Проходя от корня к листьям, формируем бинарные коды (левый переход, например, 0, правый — `1`).
4. Сжатие: Заменяем каждый символ его битовым кодом.

### 2. Пример кода на Python

from heapq import heappush, heappop

# Узел дерева Хаффмана
class Node:
    def __init__(self, char, freq, left=None, right=None):
        self.char = char
        self.freq = freq
        self.left = left
        self.right = right
    
    # Для сравнения в куче
    def __lt__(self, other):
        return self.freq < other.freq

def build_huffman_tree(freqs):
    """
    Создаёт дерево Хаффмана на основе словаря {символ: частота}.
    Возвращает корень дерева.
    """
    heap = []
    for ch, fr in freqs.items():
        heappush(heap, Node(ch, fr))
    
    # Сливаем узлы, пока не останется один
    while len(heap) > 1:
        left = heappop(heap)
        right = heappop(heap)
        merged = Node(None, left.freq + right.freq, left, right)
        heappush(heap, merged)
    
    return heap[0] if heap else None

def build_codes(root):
    """
    Обходит дерево Хаффмана и строит словарь {символ: код}.
    """
    codes = {}
    
    def traverse(node, prefix=""):
        if not node:
            return
        if node.char is not None:
            codes[node.char] = prefix
            return
        traverse(node.left, prefix + "0")
        traverse(node.right, prefix + "1")
    
    traverse(root)
    return codes

def huffman_compress(text):
    # 1) Считаем частоты
    freqs = {}
    for ch in text:
        freqs[ch] = freqs.get(ch, 0) + 1
    
    # 2) Строим дерево
    root = build_huffman_tree(freqs)
    # 3) Генерируем коды
    codes = build_codes(root)
    # 4) Кодируем текст
    encoded = "".join(codes[ch] for ch in text)
    
    return encoded, codes

def huffman_decompress(encoded, codes):
    # Создаём словарь {код: символ}
    reverse_codes = {v: k for k, v in codes.items()}
    decoded = ""
    prefix = ""
    for bit in encoded:
        prefix += bit
        if prefix in reverse_codes:
            decoded += reverse_codes[prefix]
            prefix = ""
    return decoded

# --- Демонстрация ---
if __name__ == "__main__":
    original_text = "hello huffman compression!"
    print("Оригинальный текст:", original_text)

    # Сжимаем
    compressed_data, code_map = huffman_compress(original_text)
    print("Сжатые данные (биты):", compressed_data)

    # Распаковываем
    decompressed_data = huffman_decompress(compressed_data, code_map)
    print("Распакованный текст:", decompressed_data)

### 3. Принцип работы кратко
1. build_huffman_tree: складываем все символы в мин-кучу (heap), затем берём два узла с наименьшей частотой, объединяем их в новый узел, возвращаем в кучу. Повторяем, пока не останется единственный корень.
2. build_codes: рекурсивный обход дерева; левые переходы получают 0, правые — 1. Листу (символу) назначается накопленный префикс.
3. huffman_compress: заменяем каждый символ его бинарным кодом — получаем битовую строку.
4. huffman_decompress: идём по битам, проверяем промежуточные префиксы в reverse_codes, как только совпало, добавляем найденный символ.

Таким образом, алгоритм Хаффмана позволяет эффективно сжимать данные, давая более короткие коды часто встречающимся символам и более длинные — редким.

Подпишись 👉🏻 @KodduuPython 🤖

Пример использования OpenCV для распознавания граней (Edge Detection) с помощью оператора Канни (Canny)

Ниже приведён пример кода на Python, демонстрирующий базовую обработку изображения и выделение граней (контуров) с использованием библиотеки OpenCV.

### 1. Установка необходимых библиотек

pip install opencv-python

### 2. Пример кода

import cv2
import numpy as np

def canny_edge_detection(image_path):
    # Загружаем изображение в оттенках серого
    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
    if image is None:
        raise ValueError("Не удалось загрузить изображение. Проверьте путь.")

    # Шумоподавление с помощью GaussianBlur
    blurred = cv2.GaussianBlur(image, (5, 5), 1.4)

    # Применяем оператор Канни
    edges = cv2.Canny(blurred, threshold1=50, threshold2=150)

    return image, edges

if __name__ == "__main__":
    input_image = "sample.jpg"  # Путь к исходному изображению

    original, edges = canny_edge_detection(input_image)

    # Отображаем результаты
    cv2.imshow("Original", original)
    cv2.imshow("Canny Edges", edges)

    # Нажмите любую клавишу, чтобы закрыть окна
    cv2.waitKey(0)
    cv2.destroyAllWindows()

### 3. Как это работает

1. Чтение изображения: cv2.imread(..., cv2.IMREAD_GRAYSCALE) переводит картинку в градации серого.
2. Размытие (GaussianBlur): уменьшает шум, улучшая результат оператора Канни.
3. Оператор Канни: выделяет границы, вычисляя градиенты яркости. Параметры threshold1 и threshold2 задают нижний и верхний пороги.
4. Отображение: с помощью cv2.imshow можно посмотреть исходное изображение и полученную карту границ.

Таким образом, используя OpenCV и оператор Канни, можно быстро проанализировать изображение и выделить границы объектов, что часто является первым шагом во многих задачах компьютерного зрения.

Подпишись 👉🏻 @KodduuPython 🤖

Почему в феврале иногда 29, а иногда 28 дней?

Дело в високосных годах. По григорианскому календарю год является високосным, если:
1. Делится на 4 без остатка;
2. При этом не делится на 100, кроме случаев, когда делится на 400.

Таким образом:
- Годы, кратные 4, обычно високосные (февраль = 29 дней).
- Но если год делится на 100 (например, 1900), то он не високосный (февраль = 28 дней), если только не делится на 400 (например, 2000 — високосный).

Ниже пример кода на Python, который демонстрирует это правило и выводит количество дней в феврале для нескольких годов.

def is_leap_year(year: int) -> bool:
    """
    Возвращает True, если год 'year' високосный, иначе False.
    """
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

def days_in_february(year: int) -> int:
    """
    Возвращает количество дней в феврале для заданного года.
    """
    return 29 if is_leap_year(year) else 28

if __name__ == "__main__":
    years_to_test = [2020, 2021, 2022, 2023, 2024, 1900, 2000]

    for y in years_to_test:
        print(f"Год {y}: февраль имеет {days_in_february(y)} дней. "
              f"Високосный? {is_leap_year(y)}")

### Объяснение
1. is_leap_year: проверяет правила деления на 4, 100 и 400.
2. days_in_february: если год високосный, возвращаем 29, иначе 28.
3. В конце тестируем на нескольких годах:
- 2020 (делится на 4 и не на 100) → високосный, февраль 29;
- 1900 (делится на 100, но не на 400) → не високосный, февраль 28;
- 2000 (делится на 400) → високосный, февраль 29.

Так мы наглядно видим, почему в феврале может быть как 28, так и 29 дней.

Подпишись 👉🏻 @KodduuPython 🤖

Пример преобразований (Conversions) на Python: перевод чисел между различными системами счисления

В данном примере рассмотрим, как конвертировать целые числа в различные системы счисления (двоичную, восьмеричную и шестнадцатеричную), а также обратно — в десятичную.

### 1. Прямой перевод (из десятичной в другие системы счисления)

Python предоставляет встроенные функции:
- bin(x) — возвращает строку вида '0b...' (двоичное представление).
- oct(x) — возвращает строку вида '0o...' (восьмеричное представление).
- hex(x) — возвращает строку вида '0x...' (шестнадцатеричное представление).

num = 255

binary_repr = bin(num)    # '0b11111111'
octal_repr = oct(num)     # '0o377'
hex_repr = hex(num)       # '0xff'

print("Десятичное:", num)
print("Двоичное:", binary_repr)
print("Восьмеричное:", octal_repr)
print("Шестнадцатеричное:", hex_repr)

> При желании можно убрать префиксы 0b, 0o, 0x, если оставить только часть строки после первых двух символов.

### 2. Обратный перевод (из строки в десятичное число)

Для преобразования строки в число используем функцию int(строка, основание). Второй параметр указывает на основание системы счисления.

binary_str = "11111111"
octal_str = "377"
hex_str = "ff"

dec_from_bin = int(binary_str, 2)  # 255
dec_from_oct = int(octal_str, 😍  # 255
dec_from_hex = int(hex_str, 16)   # 255

print("Из двоичной:", dec_from_bin)
print("Из восьмеричной:", dec_from_oct)
print("Из шестнадцатеричной:", dec_from_hex)

### 3. Пример функции перевода в любую систему счисления

Если нужно явно сконвертировать число в систему счисления с основанием base (2..36) без встроенных префиксов, можно написать свою функцию:

def to_base(num, base=2):
    """Переводит целое число num в систему счисления base (2..36). Возвращает строку."""
    if num == 0:
        return "0"
    
    digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    result = ""
    is_negative = (num < 0)
    num = abs(num)

    while num > 0:
        remainder = num % base
        result = digits[remainder] + result
        num //= base

    if is_negative:
        result = "-" + result

    return result

# Проверка работы:
print(to_base(255, 2))   # '11111111'
print(to_base(255, 8))   # '377'
print(to_base(255, 16))  # 'FF'

### 4. Вывод

Таким образом, в Python легко работать с различными системами счисления:
- Встроенные функции bin, oct, hex и int(..., base) покрывают большинство задач.
- Пользовательская функция позволяет гибко настраивать основание системы счисления и формат вывода.

Это базовый пример конверсий (Conversions) при работе с числами. При необходимости аналогичные подходы могут использоваться для перевода форматов времени, дат, единиц измерения и многого другого.

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример на Python, который в реальном времени отслеживает цены на криптовалюты с помощью API. Пример включает визуальные элементы в виде эмодзи и цветовое форматирование в терминале.

import requests
import time
from datetime import datetime

def get_crypto_prices():
    symbols = {
        'bitcoin': '₿',
        'ethereum': 'Ξ',
        'dogecoin': 'Ð'
    }
    
    try:
        response = requests.get(
            'https://api.coingecko.com/api/v3/simple/price',
            params={
                'ids': ','.join(symbols.keys()),
                'vs_currencies': 'usd',
                'include_market_cap': 'true',
                'include_24hr_change': 'true'
            }
        )
        data = response.json()
        
        print(f"\n{'🚀 Crypto Tracker':^50}")
        print(f"{'='*50}")
        
        for crypto, values in data.items():
            emoji = symbols[crypto]
            price = values['usd']
            change = values['usd_24h_change']
            change_color = '\033[92m' if change >=0 else '\033[91m'
            
            print(f"{emoji} {crypto.capitalize():<12}"
                  f"|\033[94m ${price:>9,.2f}\033[0m "
                  f"| 24h: {change_color}{change:>+6.2f}%\033[0m")
            
        print(f"\nLast update: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        
    except Exception as e:
        print(f"🔴 Error fetching data: {e}")

if __name__ == "__main__":
    while True:
        get_crypto_prices()
        try:
            time.sleep(30)  # Update every 30 seconds
        except KeyboardInterrupt:
            print("\n👋 Exiting crypto tracker...")
            break

Особенности, включённые в этот код:

* Отслеживание цен на криптовалюты в режиме реального времени с помощью API CoinGecko.
* Визуализация различных монет с помощью эмодзи.
* Цветовое кодирование процентных изменений (зелёный/красный).
* Форматирование рыночных данных с использованием запятых.
* Автоматическое обновление каждые 30 секунд.
* Очистка вывода терминала с отметкой времени.
* Обработка ошибок.
* Поддержка прерывания клавиатуры.

Чтобы запустить этот код:
* Установите необходимый пакет: pip install requests.
* Запустите скрипт в терминале/CMD.
* Нажмите Ctrl+C для выхода.

Скрипт отобразит:
* Текущие цены.
* Процентные изменения за 24 часа.
* Рыночную капитализацию.
* Данные будут автоматически обновляться каждые 30 секунд.

Этот скрипт сочетает в себе несколько модных элементов: криптовалюту, интеграцию API, данные в реальном времени и визуальное форматирование в терминале! 🚀

Подпишись 👉🏻 @KodduuPython 🤖

Криптотерминал из кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Пример алгоритма компьютерного зрения на Python с использованием OpenCV и NumPy. Этот код выполняет обнаружение краев на изображении с помощью оператора Кэнни:

import cv2
import numpy as np

def process_image(image_path):
    # Загружаем изображение
    image = cv2.imread(image_path, cv2.IMREAD_COLOR)
    if image is None:
        print("Ошибка: не удалось загрузить изображение.")
        return
    
    # Преобразуем изображение в оттенки серого
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Применяем размытие для снижения шума
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # Выполняем обнаружение краев методом Кэнни
    edges = cv2.Canny(blurred, 50, 150)
    
    # Показываем результат
    cv2.imshow('Original Image', image)
    cv2.imshow('Edge Detection', edges)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

# Укажите путь к изображению
image_path = 'example.jpg'  # Замените на путь к вашему изображению
process_image(image_path)

Этот алгоритм:
1. Загружает изображение.
2. Конвертирует его в градации серого.
3. Применяет размытие для уменьшения шумов.
4. Выполняет обнаружение краев методом Кэнни.
5. Отображает исходное изображение и обработанный результат.

Подпишись 👉🏻 @KodduuPython 🤖

Прикольный алгоритм с использованием структуры данных Очередь (Queue) для управления очередью в ночном клубе! 🎉

Ситуация:
Представьте, что вы управляете входом в популярный ночной клуб. У вас есть ограниченное количество мест, и вам нужно следить за тем, чтобы люди заходили в порядке живой очереди. При этом VIP-гости должны обслуживаться быстрее.

Решение:
Мы используем две очереди (обычную и приоритетную), чтобы справедливо распределять доступ.

Код на Python

from collections import deque
import time

class NightClubQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.regular_queue = deque()  # Очередь для обычных посетителей
        self.vip_queue = deque()  # Очередь для VIP

    def arrive(self, name, is_vip=False):
        if is_vip:
            self.vip_queue.append(name)
            print(f"🔥 VIP {name} добавлен в VIP-очередь!")
        else:
            self.regular_queue.append(name)
            print(f"🕺 {name} встал в обычную очередь!")

    def admit_guest(self):
        if len(self.vip_queue) > 0:
            guest = self.vip_queue.popleft()
            print(f"🚀 Пропускаем VIP {guest}!")
        elif len(self.regular_queue) > 0:
            guest = self.regular_queue.popleft()
            print(f"✅ Пропускаем обычного гостя {guest}!")
        else:
            print("⏳ Очередь пуста, можно отдыхать!")

    def run_night(self):
        print("\n🎶 Начинаем вечер в клубе! 🎶\n")
        while self.vip_queue or self.regular_queue:
            self.admit_guest()
            time.sleep(1)  # Имитация задержки при входе
        print("\n🎉 Вход завершен, клуб заполнен!\n")

# Пример использования
club = NightClubQueue(capacity=5)
club.arrive("Иван")
club.arrive("Алина", is_vip=True)
club.arrive("Дмитрий")
club.arrive("Сергей", is_vip=True)
club.arrive("Мария")

club.run_night()

Как это работает?
1. Добавляем людей в две очереди:
- VIP-гости попадают в vip_queue.
- Обычные посетители – в regular_queue.
2. При входе в клуб приоритет отдается VIP-гостям.
3. Гости заходят по очереди, пока клуб не заполнится.
4. Клуб закрывается, когда все вошли.

### Реальное применение
Этот алгоритм можно использовать в:
- Управлении живыми очередями (концерты, аэропорты 🛫, мероприятия 🎭).
- Разработке онлайн-систем бронирования, где премиум-клиенты получают приоритет.
- Виртуальных очередях (например, при покупке билетов 🎟).

Подпишись 👉🏻 @KodduuPython 🤖

Ну вот нацонец-то выпустили мою статью на habr. Это тот еще челлендж - это не мемы постить на pikabu 😀

Статья про то как мы делаем RAG (Retrieval Augmented Generation) систему на Python для нашей компании. Очень увлекательное занятие, скоро у нас будет возможность спросить вопрос в slack по любым данным компании за 10 лет, и получить точный ответ за 10 сек.

Бота назвали R2D2 🤖 Прикрутили локальные модели + Gemini, OpenAPI, YandexGPT, Gigachat. Тестируем сейчас какая лучше для нас.

Буду писать серию статей по этой теме на habr, если интересно - подпишитесь там на меня.

Планы огромные, например:

👉 Будем пилить AI агента, который может уточнять проблему у клиента, и заводить качественный баг в JIRA (сейчас на это уходят дорогие ресурсы инженеров) 🧐
👉 Будем пилить AI агента для уточнения тербований у PM в slack, и заводить план на wiki, а может даже и набор JIRA tickets + Ghant Chart 🤔

Подпишись 👉🏻 @KodduuPython 🤖