Пример кода для прогнозирования спроса на продукт с использованием временных рядов и модели ARIMA. Этот код поможет предсказать будущий спрос на продукт на основе предыдущих данных о продажах. ARIMA (AutoRegressive Integrated Moving Average) — популярная модель для анализа и прогнозирования временных рядов.

import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error

# Загрузка данных о продажах
# Предположим, у нас есть временной ряд с ежедневными данными о продажах
data = pd.read_csv('sales_data.csv')
data['date'] = pd.to_datetime(data['date'])
data.set_index('date', inplace=True)

# Визуализируем данные
plt.figure(figsize=(10, 6))
plt.plot(data, label='Daily Sales')
plt.title('Sales Data')
plt.xlabel('Date')
plt.ylabel('Sales')
plt.legend()
plt.show()

# Создание модели ARIMA
# (p, d, q) - параметры модели, их можно подбирать автоматически, но здесь поставим примерные значения
p, d, q = 5, 1, 2
model = ARIMA(data['sales'], order=(p, d, q))
fitted_model = model.fit()

# Прогноз на 30 дней вперед
forecast_steps = 30
forecast = fitted_model.forecast(steps=forecast_steps)

# Построение графика прогноза
plt.figure(figsize=(10, 6))
plt.plot(data, label='Historical Sales')
plt.plot(pd.date_range(data.index[-1], periods=forecast_steps+1, closed='right'), forecast, color='red', label='Forecast')
plt.title('Sales Forecast for Next 30 Days')
plt.xlabel('Date')
plt.ylabel('Sales')
plt.legend()
plt.show()

# Оценка точности модели (например, среднеквадратичная ошибка на последних 30 днях)
train_size = int(len(data) * 0.8)
train, test = data['sales'][:train_size], data['sales'][train_size:]
model = ARIMA(train, order=(p, d, q))
fitted_model = model.fit()
forecast_test = fitted_model.forecast(steps=len(test))
mse = mean_squared_error(test, forecast_test)
print(f"Mean Squared Error: {mse}")

### Объяснение:

1. Подготовка данных: Загружаем временной ряд продаж и визуализируем данные.
2. Создание модели: Настраиваем параметры модели ARIMA и обучаем её на исторических данных.
3. Прогноз: Строим прогноз на 30 дней вперед.
4. Оценка модели: Вычисляем среднеквадратичную ошибку (MSE) для тестовой выборки, чтобы оценить точность прогноза.

### Примечания:
- Параметры модели ARIMA (`p`, d, q`) можно подобрать автоматически с помощью библиотек, таких как `pmdarima, которая содержит функцию auto_arima, чтобы выбрать лучшие параметры на основе критериев оценки модели.
- Этот пример подходит для анализа и прогнозирования временных рядов, таких как продажи, спрос, посещаемость и другие временные данные.

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

Вот код для отображения видимого пути Марса на небесной сфере в течение 2024 года. Используем библиотеку Skyfield для расчета астрономических позиций и matplotlib для визуализации.

from skyfield.api import load, Topos
import matplotlib.pyplot as plt

# Загрузка эфемерида
ephemeris = load('de440s.bsp')
earth = ephemeris['earth']               # Центральное тело Земли
mars_barycenter = ephemeris['mars barycenter']  # Барицентр системы Марса

# Создаем местоположение наблюдателя на Земле
location = earth + Topos(latitude_degrees=0.0, longitude_degrees=0.0)

# Выбор временного интервала
timescale = load.timescale()
dates = timescale.utc(2024, range(1, 366))  # Каждый день 2024 года

# Координаты прямого восхождения (RA) и склонения (Dec) для каждого дня
ra_values = []
dec_values = []

for date in dates:
    astrometric = location.at(date).observe(mars_barycenter)
    ra, dec, distance = astrometric.radec()
    ra_values.append(ra.hours)
    dec_values.append(dec.degrees)

# Визуализация движения Марса на звездном небе
plt.figure(figsize=(10, 6))
plt.plot(ra_values, dec_values, label="Mars Path", color='red')
plt.xlabel("Right Ascension (hours)")
plt.ylabel("Declination (degrees)")
plt.title("Apparent Path of Mars on the Celestial Sphere in 2024")
plt.gca().invert_xaxis()  # Инверсия оси для астрономической системы
plt.legend()
plt.grid()
plt.show()

### Краткое объяснение:

1. Эфемеридные данные: Загружаем данные о положении планет из файла de440s.bsp.
2. Местоположение наблюдателя: Создаем объект, представляющий наблюдателя на Земле на экваторе.
3. Расчет траектории: Для каждого дня 2024 года рассчитываем прямое восхождение (RA) и склонение (Dec) Марса.
4. Визуализация: Строим график, показывающий видимое движение Марса на небесной сфере.

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

Отображения видимого пути Марса, код выше 👆👆👆

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

Надо помнить - в Python некоторые вещи могут зависеть от настроек инстанса интерпретатора.

Например вот такой случай, "print(a, b)" может выдавать разный вывод на Stepik и на вашем локальном Python. И не смотря на то, что при сравнении результата кода с expected здесь используется strip(), который должен срезать все пробелы спереди и сзади, вот в этом конкретном случае сравнение идет целиком всех букв сразу, и будет разница и fail при "print(a) print(b)" vs "print(a, b)", поэтому ВАЖНО использовать конструкции, которые не зависят от настроек интерпретатора, например "print(a + b)", вместо "print(a, b)".

Как понять что зависит, а что нет? 🤨 С этим сложнее - например достаточно знать синтаксис языка C, и его аналоги переиспользовать даже в Python, тогда все будет ok.

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

Тем не менее незнание С не особождает от ответственности 🧐 Если столкнулись с ситуацией когда визуально все ok, а оно говорит не совпадает 🤷 Надо прокачивать другой важный скилл разработчика - debugging и root cause analysis. Надо пойти в "любой" online diff checker и сравнить два текста, и увидеть что разница все таки есть. Кстати diff чекеру тоже доверять на 100% не надо, вот как в этом случае он показывает, что посимвольно разницы нет (снизу должен был показать красным добавленые пробелы), но кол-во символов то разное 👆Вот тут мы все и поняли 😀

Курс про который идет тут речь вот тут 🔥

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

Пример кода, который моделирует взаимодействие материи и антивещества. В нем мы создадим простую симуляцию, где частицы вещества и антивещества движутся в пространстве и аннигилируют при столкновении. Этот пример визуализирует, как происходит аннигиляция, что является ключевой концепцией антивещества.

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

# Параметры симуляции
num_particles = 50  # Число частиц вещества и антивещества
box_size = 10       # Размер области

# Начальные позиции и направления для частиц вещества и антивещества
positions_matter = np.random.uniform(0, box_size, (num_particles, 2))
positions_antimatter = np.random.uniform(0, box_size, (num_particles, 2))
velocities_matter = np.random.uniform(-1, 1, (num_particles, 2))
velocities_antimatter = np.random.uniform(-1, 1, (num_particles, 2))

# Создание графика
fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim(0, box_size)
ax.set_ylim(0, box_size)

matter_plot = ax.scatter(positions_matter[:, 0], positions_matter[:, 1], color='blue', label='Matter')
antimatter_plot = ax.scatter(positions_antimatter[:, 0], positions_antimatter[:, 1], color='red', label='Antimatter')
plt.legend()

# Функция обновления для анимации
def update(frame):
    global positions_matter, positions_antimatter

    # Обновляем позиции частиц
    positions_matter += velocities_matter
    positions_antimatter += velocities_antimatter

    # Отражение от стенок
    for pos, vel in [(positions_matter, velocities_matter), (positions_antimatter, velocities_antimatter)]:
        vel[pos < 0] *= -1
        vel[pos > box_size] *= -1

    # Проверка на столкновения и аннигиляцию
    for i, pos_m in enumerate(positions_matter):
        distances = np.linalg.norm(positions_antimatter - pos_m, axis=1)
        collision_indices = np.where(distances < 0.5)[0]  # Радиус аннигиляции

        # Удаление столкнувшихся частиц
        if len(collision_indices) > 0:
            positions_matter[i] = np.nan  # Устанавливаем NaN для "аннигилированных" частиц
            positions_antimatter[collision_indices] = np.nan

    # Обновляем отображение частиц
    matter_plot.set_offsets(positions_matter)
    antimatter_plot.set_offsets(positions_antimatter)

    return matter_plot, antimatter_plot

# Запуск анимации
ani = animation.FuncAnimation(fig, update, frames=200, interval=50, blit=True)
plt.show()

### Объяснение:

1. Начальные позиции и скорости: Создаются случайные позиции и направления для частиц материи и антивещества в заданной области.
2. Отражение от стенок: Частицы отскакивают от стенок, если достигают границы области.
3. Проверка на аннигиляцию: Когда частица материи находится на определенном расстоянии от частицы антивещества, обе частицы "аннигилируют" — их позиции заменяются на NaN, чтобы их не отображать.
4. Анимация: FuncAnimation обновляет позиции и проверяет столкновения, создавая визуализацию аннигиляции.

### Ключевая идея:
Когда частица материи и антивещества сталкиваются, они аннигилируют, исчезая из пространства симуляции, что демонстрирует основную концепцию антивещества.

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

Анигиляция вещества и антивещества. Код выше 👆👆👆

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

Жадный алгоритм (Greedy Algorithm)
Жадный алгоритм — это метод решения оптимизационных задач, который на каждом шаге принимает локально оптимальное решение, надеясь, что оно приведет к глобально оптимальному результату. Он работает по принципу "бери, что лучше прямо сейчас", без учета возможных последствий в будущем.

Для решения задачи оптимального выбора стратегии начисления или списания баллов при каждой покупке можно использовать жадный алгоритм. Вот пример реализации на Python:

def optimize_cashback_strategy(receipts, balance):
    """
    Оптимизировать стратегию начисления/списания баллов для максимизации кэшбэка и минимизации расходов.

    :param receipts: Список чеков (стоимость каждой покупки).
    :param balance: Начальный баланс баллов.
    :return: Список стратегий ('add' для начисления, 'redeem' для списания), итоговый баланс и суммарный кэшбэк.
    """
    strategies = []  # Список стратегий
    total_cashback = 0  # Суммарный кэшбэк

    for receipt in receipts:
        cashback = receipt * 0.10  # 10% кэшбэк от стоимости покупки

        if balance >= receipt:
            # Если баллов достаточно, выгоднее списать
            strategies.append('redeem')
            balance -= receipt  # Списываем баллы
        else:
            # Если баллов недостаточно, начисляем кэшбэк
            strategies.append('add')
            total_cashback += cashback
            balance += cashback  # Начисляем баллы в баланс

    return strategies, balance, total_cashback


# Пример данных
receipts = [200, 150, 300, 100, 250, 50, 400, 120, 80, 60]  # Стоимость каждой покупки
initial_balance = 500  # Начальный баланс баллов

# Оптимизация стратегии
strategies, final_balance, total_cashback = optimize_cashback_strategy(receipts, initial_balance)

# Вывод результатов
print("Чеки:", receipts)
print("Начальный баланс:", initial_balance)
print("Стратегии:", strategies)
print("Итоговый баланс:", final_balance)
print("Суммарный кэшбэк:", total_cashback)

### Пояснение алгоритма:
1. Баллы списываются только если текущего баланса хватает на покрытие стоимости чека. Это позволяет минимизировать расходы.
2. Кэшбэк начисляется, если недостаточно баллов для списания. Начисленные баллы добавляются к балансу.
3. В каждом шаге выбирается наиболее выгодный вариант: либо списание баллов, либо начисление кэшбэка.

### Пример работы:
Для списка чеков [200, 150, 300, 100, 250, 50, 400, 120, 80, 60] и начального баланса 500 программа подберет стратегию, которая максимизирует итоговый кэшбэк и минимизирует расходы.

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

### Задача о рюкзаке (Knapsack Problem)

Задача:
У вас есть рюкзак фиксированного объема W, и множество предметов, каждый из которых имеет вес w_i и ценность v_i. Нужно определить, какие предметы положить в рюкзак, чтобы максимизировать общую ценность, не превышая объема W.

---

### Жадный алгоритм для задачи о рюкзаке (Fractional Knapsack)

Жадный подход подходит для дробного рюкзака, где можно брать часть предмета.

Принцип работы:
1. Считаем "ценность на единицу веса" для каждого предмета ( v_i / w_i ).
2. Сортируем предметы по убыванию этой ценности.
3. Идем по отсортированным предметам, добавляя их в рюкзак, пока есть место:
- Если предмет помещается целиком, кладем его.
- Если предмет не помещается, берем только часть, которая влезет.

---

### Код для жадного алгоритма (дробный рюкзак):

def fractional_knapsack(items, max_weight):
    """
    Жадный алгоритм для задачи о дробном рюкзаке.

    :param items: Список предметов в формате [(ценность, вес), ...].
    :param max_weight: Максимальный вес рюкзака.
    :return: Максимальная ценность и список взятых предметов (включая доли).
    """
    # Считаем ценность на единицу веса для каждого предмета и сортируем по убыванию
    items = sorted(items, key=lambda x: x[0] / x[1], reverse=True)
    
    total_value = 0  # Суммарная ценность
    taken_items = []  # Список взятых предметов (включая доли)
    
    for value, weight in items:
        if max_weight == 0:  # Если рюкзак заполнен
            break
        
        if weight <= max_weight:
            # Берем предмет целиком
            total_value += value
            max_weight -= weight
            taken_items.append((value, weight, 1))  # 1 означает "взято целиком"
        else:
            # Берем часть предмета
            fraction = max_weight / weight
            total_value += value * fraction
            taken_items.append((value, weight, fraction))
            max_weight = 0  # Рюкзак заполнен
    
    return total_value, taken_items


# Пример данных: (ценность, вес)
items = [
    (60, 10),  # Ценность 60, вес 10
    (100, 20),  # Ценность 100, вес 20
    (120, 30)   # Ценность 120, вес 30
]
max_weight = 50  # Максимальный вес рюкзака

# Решение задачи
max_value, selected_items = fractional_knapsack(items, max_weight)

# Вывод результатов
print("Максимальная ценность:", max_value)
print("Выбранные предметы (ценность, вес, доля):")
for item in selected_items:
    print(item)

---

### Пример вывода:

Максимальная ценность: 240.0
Выбранные предметы (ценность, вес, доля):
(100, 20, 1)
(120, 30, 1)
(60, 10, 0.6666666666666666)

---

### Динамическое программирование для задачи целого рюкзака

Если дробить предметы нельзя, применяют метод динамического программирования.

def knapsack_dp(items, max_weight):
    """
    Задача о рюкзаке для целых предметов с использованием динамического программирования.

    :param items: Список предметов в формате [(ценность, вес), ...].
    :param max_weight: Максимальный вес рюкзака.
    :return: Максимальная ценность.
    """
    n = len(items)
    dp = [[0] * (max_weight + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        value, weight = items[i - 1]
        for w in range(max_weight + 1):
            if weight <= w:
                # Либо берем предмет, либо не берем
                dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weight] + value)
            else:
                dp[i][w] = dp[i - 1][w]

    return dp[n][max_weight]


# Пример данных
items = [
    (60, 10),  # Ценность 60, вес 10
    (100, 20),  # Ценность 100, вес 20
    (120, 30)   # Ценность 120, вес 30
]
max_weight = 50  # Максимальный вес рюкзака

# Решение задачи
max_value = knapsack_dp(items, max_weight)

# Вывод результатов
print("Максимальная ценность:", max_value)

---

### Пример вывода для целого рюкзака:

Максимальная ценность: 220

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

Проанализировали сотни собесов по Python. Начали паковать курс "Топ 100 вопросов с реальных собеседований по Python (шпаргалка)" 👍

Странно - но есть вопросы которые прямо в топе, а есть не менее интересные, которые прямо редко задают 🤷 Перед собесом по идее надо учить, те что часто задают 🧐 Но и знать что-то из редких, может быть тоже критично 🤨 На картинке, то что в топе 🤷

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

### Жадный алгоритм Хаффмана (Huffman Coding)

Алгоритм Хаффмана используется для эффективного сжатия данных. Он создает префиксное кодирование, где ни один код не является префиксом другого, что гарантирует декодируемость. Этот метод часто применяется в сжатии данных, таких как ZIP, GZIP и JPEG.

---

### Основные этапы алгоритма Хаффмана:

1. Подготовка данных: Извлечь символы и их частоты из исходных данных.
2. Создание приоритетной очереди: Построить очередь (обычно в виде мин-кучи), где каждый символ представляет собой узел, а его частота определяет приоритет.
3. Построение дерева Хаффмана:
- На каждом шаге извлекаются два узла с наименьшими частотами.
- Создается новый объединенный узел, чья частота равна сумме частот выбранных узлов.
- Новый узел добавляется обратно в очередь.
- Повторяется до тех пор, пока не останется один узел (корень дерева).
4. Назначение кодов:
- Обход дерева (обычно рекурсивный) назначает каждому символу код, основываясь на пути: левый узел = 0, правый узел = 1.

---

### Реализация на Python

import heapq
from collections import Counter, namedtuple

# Узел дерева
class HuffmanNode(namedtuple("HuffmanNode", ["char", "freq", "left", "right"])):
    def __lt__(self, other):
        return self.freq < other.freq

def build_huffman_tree(frequencies):
    # Создаем очередь с приоритетом на основе частот
    heap = [HuffmanNode(char, freq, None, None) for char, freq in frequencies.items()]
    heapq.heapify(heap)

    # Построение дерева
    while len(heap) > 1:
        # Извлекаем два узла с минимальной частотой
        left = heapq.heappop(heap)
        right = heapq.heappop(heap)

        # Создаем объединенный узел
        merged = HuffmanNode(None, left.freq + right.freq, left, right)
        heapq.heappush(heap, merged)

    # Корень дерева
    return heap[0]

def assign_codes(node, prefix="", codebook=None):
    if codebook is None:
        codebook = {}
    if node.char is not None:
        # Если это листовой узел, сохраняем код
        codebook[node.char] = prefix
    else:
        # Рекурсивно обходим дерево
        assign_codes(node.left, prefix + "0", codebook)
        assign_codes(node.right, prefix + "1", codebook)
    return codebook

def huffman_encoding(data):
    # Подсчет частот символов
    frequencies = Counter(data)

    # Построение дерева
    root = build_huffman_tree(frequencies)

    # Назначение кодов
    codebook = assign_codes(root)

    # Кодирование данных
    encoded_data = "".join(codebook[char] for char in data)
    return encoded_data, codebook

def huffman_decoding(encoded_data, codebook):
    # Инвертируем кодовую таблицу
    reverse_codebook = {v: k for k, v in codebook.items()}

    # Декодирование строки
    decoded_data = []
    buffer = ""
    for bit in encoded_data:
        buffer += bit
        if buffer in reverse_codebook:
            decoded_data.append(reverse_codebook[buffer])
            buffer = ""

    return "".join(decoded_data)

# Пример использования
data = "huffman coding is fun"
print("Исходные данные:", data)

# Кодирование
encoded_data, codebook = huffman_encoding(data)
print("Закодированные данные:", encoded_data)
print("Кодовая таблица:", codebook)

# Декодирование
decoded_data = huffman_decoding(encoded_data, codebook)
print("Декодированные данные:", decoded_data)

---

### Пример вывода:

Исходные данные: huffman coding is fun
Закодированные данные: 110101001111100010010011101111100011011011001110110010
Кодовая таблица: {'h': '1101', 'u': '1100', 'f': '100', 'm': '101', 'a': '1111', 'n': '1110', ' ': '010', 'c': '0110', 'o': '0111', 'd': '000', 'i': '001', 'g': '1011', 's': '011'}
Декодированные данные: huffman coding is fun

---

### Объяснение вывода:
1. Частоты символов определяют длину их кодов: более частые символы имеют более короткие коды.
2. Алгоритм успешно сжимает данные, удаляя избыточность, но оставляя возможность точного восстановления.

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

### Алгоритмы маршрутизации

Алгоритмы маршрутизации можно объяснить интуитивно, через шаги и примеры, без сложных формул. Давайте разберем их с простой логикой.

---

### 1. Алгоритм Дейкстры
- Идея: Найти самый короткий путь от одной точки ко всем другим точкам.
- Как работает:
1. Начинаем с точки (например, дома) и отмечаем, что расстояние до нее — 0.
2. Для всех соседних точек рассчитываем их расстояние от дома.
3. Идем в ближайшую точку, фиксируем расстояние до нее и продолжаем проверять ее соседей.
4. Повторяем процесс, пока не пройдем все точки.
- Пример:
- Вы хотите найти самый короткий путь из дома до магазина.
- Вы сначала проверяете все ближайшие улицы, потом переходите к более дальним, выбирая на каждом шаге самую короткую улицу.

Код на Python:

import heapq

def dijkstra(graph, start):
    distances = {node: float('inf') for node in graph}  # Все расстояния бесконечны
    distances[start] = 0  # Расстояние до начальной точки — 0
    priority_queue = [(0, start)]  # Очередь для обработки вершин

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        for neighbor, weight in graph[current_node]:
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Пример графа
graph = {
    'A': [('B', 1), ('C', 4)],
    'B': [('A', 1), ('C', 2), ('D', 6)],
    'C': [('A', 4), ('B', 2), ('D', 3)],
    'D': [('B', 6), ('C', 3)],
}

print(dijkstra(graph, 'A'))

---

### 2. Алгоритм Беллмана-Форда
- Идея: Найти самый короткий путь, даже если есть улицы с "негативными" условиями (например, короткие, но опасные пути).
- Как работает:
1. Начинаем с дома и отмечаем, что расстояние до него — 0.
2. Проходим через каждую улицу, пытаясь улучшить (сделать короче) расстояния до других точек.
3. Повторяем процесс несколько раз, чтобы убедиться, что не осталось непросчитанных улучшений.
- Пример:
- Представьте, что у вас есть маршрут, где некоторые улицы сокращают общее время (например, за счет срезов или сокращения светофоров).
- Беллман-Форд учитывает такие "улучшенные" пути.

Код на Python:

def bellman_ford(graph, start):
    distances = {node: float('inf') for node in {u for u, _, _ in graph}.union({v for _, v, _ in graph})}
    distances[start] = 0

    for _ in range(len(distances) - 1):
        for u, v, weight in graph:
            if distances[u] + weight < distances[v]:
                distances[v] = distances[u] + weight

    return distances

# Пример графа
graph = [
    ('A', 'B', 1),
    ('B', 'C', 2),
    ('A', 'C', 4),
    ('C', 'D', 3),
    ('D', 'B', -6),  # "Негативный" путь
]

print(bellman_ford(graph, 'A'))

---

### 3. Алгоритм Флойда-Уоршалла
- Идея: Найти самые короткие пути между всеми парами точек.
- Как работает:
1. Создаем таблицу, где записаны все известные расстояния между точками.
2. Постепенно проверяем, можно ли улучшить расстояние через промежуточные точки.
3. Обновляем таблицу после каждой проверки.
- Пример:
- У вас есть несколько маршрутов, и вы хотите знать, как быстрее добраться из любой точки в любую другую.
- Алгоритм Флойда-Уоршалла строит карту с минимальными расстояниями между всеми точками.

Код на Python:

def floyd_warshall(graph):
    n = len(graph)
    dist = [[float('inf')] * n for _ in range(n)]
    
    for i in range(n):
        dist[i][i] = 0
        for j in range(n):
            if graph[i][j] is not None:
                dist[i][j] = graph[i][j]

    for k in range(n):
        for i in range(n):
            for j in range(n):
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

    return dist

graph = [
    [0, 3, None, None],
    [None, 0, 1, None],
    [None, None, 0, 7],
    [2, None, None, 0],
]

result = floyd_warshall(graph)
for row in result:
    print(row)

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