Вышла новая статья на pikabu "Как стать АйТишником в 2025 году (пошаговый план)". Суммировал опыт многих, кто пришел в ИТ из других сфер.

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

Ниже приведён прикладной пример использования библиотеки NetworkX для решения простой задачи на графах: представим, что у нас есть небольшая сеть дорог в городе, и мы хотим найти самый быстрый маршрут от склада до магазина с учётом скоростей на участках дорог.

- Узлы графа (nodes) — это перекрёстки.
- Рёбра графа (edges) — это дороги между перекрёстками.
- У каждого ребра есть:
- длина дороги (в километрах),
- скорость (км/ч), с которой можно проехать этот участок.

Целевая метрика: время в пути (в часах). Мы хотим найти кратчайший (по времени) путь, а не по географическому расстоянию.

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

import networkx as nx

def build_city_graph():
    """
    Создаёт и возвращает ориентированный граф (DiGraph) с атрибутами:
    - distance (км)
    - speed (км/ч)
    """
    G = nx.DiGraph()

    # Добавим несколько перекрёстков (можно просто добавлять рёбра, 
    # тогда вершины создадутся автоматически)
    intersections = ["Warehouse", "A", "B", "C", "Store"]
    G.add_nodes_from(intersections)

    # Добавим дороги (рёбра) с атрибутами:
    # G.add_edge(откуда, куда, distance=..., speed=...)
    G.add_edge("Warehouse", "A", distance=3.0, speed=30.0)  
    G.add_edge("Warehouse", "B", distance=5.0, speed=40.0)
    G.add_edge("A", "C", distance=2.0, speed=20.0)
    G.add_edge("B", "C", distance=2.5, speed=35.0)
    G.add_edge("C", "Store", distance=4.0, speed=40.0)
    G.add_edge("A", "Store", distance=8.0, speed=60.0)  

    # Можно добавить и обратные направления, если дороги двусторонние
    G.add_edge("A", "Warehouse", distance=3.0, speed=30.0)  
    G.add_edge("B", "Warehouse", distance=5.0, speed=40.0)
    # И так далее...

    return G

def compute_travel_time(u, v, data):
    """
    Вычисляем время (часы) проезда по участку (u->v) на основе атрибутов distance и speed.
    data — словарь атрибутов ребра.
    """
    dist = data.get("distance", 1.0)
    spd = data.get("speed", 1.0)
    return dist / spd  # время = расстояние/скорость

def main():
    # 1. Строим граф
    G = build_city_graph()

    # 2. Считаем «вес» каждого ребра как время
    #    Для поиска кратчайшего пути по времени используем атрибуты distance и speed.
    #    NetworkX позволяет указать коллбэк (функцию), которая вычисляет вес «на лету»,
    #    но здесь, для наглядности, прямо создадим новый атрибут "time".
    for u, v, data in G.edges(data=True):
        data["time"] = compute_travel_time(u, v, data)

    # 3. Ищем кратчайший маршрут по атрибуту "time"
    start = "Warehouse"
    end = "Store"

    # Используем алгоритм Дейкстры (dijkstra_path) или любой другой
    path = nx.dijkstra_path(G, source=start, target=end, weight="time")
    total_time = nx.dijkstra_path_length(G, source=start, target=end, weight="time")

    print("Самый быстрый маршрут:", " -> ".join(path))
    print(f"Общее время в пути (часы): {total_time:.2f}")

if __name__ == "__main__":
    main()

### Что происходит в коде?

1. build_city_graph() — создаёт ориентированный граф (DiGraph). Каждая дорога (ребро) имеет:
- distance: длина участка (км),
- speed: доступная скорость движения (км/ч).

2. compute_travel_time() — функция для расчёта времени в пути (в часах) = \(\text{distance} / \text{speed}\).

3. Мы в цикле по всем рёбрам графа (G.edges(data=True)) создаём новый атрибут time, который потом используется в алгоритме Дейкстры.

4. nx.dijkstra_path и nx.dijkstra_path_length — стандартные методы NetworkX для нахождения кратчайшего пути и его «стоимости» (суммы весов) в взвешенном графе:
- source=start, target=end, weight="time" указывает, что в качестве веса ребра следует использовать именно атрибут time.

5. На выходе — маршрут (список перекрёстков) и итоговое время.

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

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

Этот код демонстрирует основную концепцию квантовой запутанности, где изменение состояния одного кубита мгновенно влияет на состояние другого, даже если они находятся на большом расстоянии друг от друга.

import pennylane as qml
from pennylane import numpy as np

# Создаем устройство с двумя кубитами
dev = qml.device("default.qubit", wires=2)

# Определяем квантовую схему
@qml.qnode(dev)
def circuit(param):
    # Применяем поворот к первому кубиту
    qml.RX(param, wires=0)
    # Запутываем кубиты с помощью операции CNOT
    qml.CNOT(wires=[0, 1])
    # Возвращаем ожидаемые значения операторов Паули Z для обоих кубитов
    return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))

# Значение параметра, определяющее степень запутанности
param_value = np.pi / 2

# Выполняем квантовую схему и выводим результаты измерений
result = circuit(param_value)
print(result)

### Объяснение кода

1. Импорт библиотек: Импортируем необходимые модули из библиотеки PennyLane для работы с квантовыми схемами.
2. Создание устройства: Определяем квантовое устройство с двумя кубитами.
3. Определение квантовой схемы:
- Используется декоратор @qml.qnode(dev), чтобы создать квантовую схему.
- Применяется операция поворота к первому кубиту, что изменяет его состояние.
- Затем применяется операция CNOT, которая запутывает два кубита.
- Возвращаются ожидаемые значения операторов Паули Z для каждого кубита, что позволяет оценить их состояния после измерения.
4. Выполнение схемы: Устанавливаем значение параметра для максимизации запутанности и выводим результаты измерений.

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

Вот пример кода на Python, который показывает основные частицы Стандартной модели, их категории и основные различия:

class Particle:
    def __init__(self, name, type_, charge, mass, spin):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass
        self.spin = spin

    def __str__(self):
        return f"{self.name}: {self.type_}, Charge: {self.charge}, Mass: {self.mass} GeV/c², Spin: {self.spin}"


# Создаем частицы
particles = [
    # Кварки
    Particle("Up", "Quark", "+2/3", 0.0022, "1/2"),
    Particle("Down", "Quark", "-1/3", 0.0047, "1/2"),
    Particle("Charm", "Quark", "+2/3", 1.27, "1/2"),
    Particle("Strange", "Quark", "-1/3", 0.096, "1/2"),
    Particle("Top", "Quark", "+2/3", 173.1, "1/2"),
    Particle("Bottom", "Quark", "-1/3", 4.18, "1/2"),
    
    # Лептоны
    Particle("Electron", "Lepton", "-1", 0.000511, "1/2"),
    Particle("Electron Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    Particle("Muon", "Lepton", "-1", 0.105, "1/2"),
    Particle("Muon Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    Particle("Tau", "Lepton", "-1", 1.777, "1/2"),
    Particle("Tau Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    
    # Бозоны
    Particle("Photon", "Boson", "0", "0", "1"),
    Particle("W+", "Boson", "+1", 80.379, "1"),
    Particle("W-", "Boson", "-1", 80.379, "1"),
    Particle("Z", "Boson", "0", 91.1876, "1"),
    Particle("Gluon", "Boson", "0", "0", "1"),
    Particle("Higgs", "Boson", "0", 125.1, "0"),
]

# Группируем частицы по типу
grouped_particles = {}
for particle in particles:
    grouped_particles.setdefault(particle.type_, []).append(particle)

# Выводим информацию о частицах
for type_, particles_list in grouped_particles.items():
    print(f"{type_}s:")
    for particle in particles_list:
        print(f"  - {particle}")
    print()

### Вывод программы
Этот код создает объект Particle, который содержит свойства, такие как название, тип, заряд, масса и спин частицы. Затем он группирует частицы по категориям (кварки, лептоны, бозоны) и выводит их список.

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

Quarks:
  - Up: Quark, Charge: +2/3, Mass: 0.0022 GeV/c², Spin: 1/2
  - Down: Quark, Charge: -1/3, Mass: 0.0047 GeV/c², Spin: 1/2
  ...

Leptons:
  - Electron: Lepton, Charge: -1, Mass: 0.000511 GeV/c², Spin: 1/2
  - Electron Neutrino: Lepton, Charge: 0, Mass: <0.000001 GeV/c², Spin: 1/2
  ...

Bosons:
  - Photon: Boson, Charge: 0, Mass: 0 GeV/c², Spin: 1
  - W+: Boson, Charge: +1, Mass: 80.379 GeV/c², Spin: 1
  ...

Этот подход позволяет не только увидеть все частицы Стандартной модели, но и понять различия между ними по заряду, массе и спину.

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

Вот пример кода на Python, который показывает, как из частиц Стандартной модели формируются атомы и молекулы.

class Particle:
    def __init__(self, name, type_, charge, mass):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass

class Proton:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "+1"

class Neutron:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "0"

class Atom:
    def __init__(self, protons, neutrons, electrons):
        self.protons = protons
        self.neutrons = neutrons
        self.electrons = electrons

    def atomic_number(self):
        return len(self.protons)

    def mass_number(self):
        return len(self.protons) + len(self.neutrons)

    def is_neutral(self):
        return len(self.protons) == len(self.electrons)

    def __str__(self):
        return (f"Atom: Atomic Number = {self.atomic_number()}, Mass Number = {self.mass_number()}, "
                f"Neutral = {self.is_neutral()}")

class Molecule:
    def __init__(self, atoms):
        self.atoms = atoms

    def molecular_formula(self):
        element_count = {}
        for atom in self.atoms:
            symbol = f"Element-{atom.atomic_number()}"
            element_count[symbol] = element_count.get(symbol, 0) + 1
        return "".join(f"{symbol}{count if count > 1 else ''}" for symbol, count in element_count.items())

    def __str__(self):
        return f"Molecule: {self.molecular_formula()}"

# Пример: Создание атомов водорода и кислорода
hydrogen = Atom(protons=[Proton()], neutrons=[Neutron()], electrons=[Particle("Electron", "Lepton", "-1", 0.000511)])
oxygen = Atom(protons=[Proton() for _ in range(8)],
              neutrons=[Neutron() for _ in range(8)],
              electrons=[Particle("Electron", "Lepton", "-1", 0.000511) for _ in range(8)])

# Пример: Создание молекулы воды (H2O)
water = Molecule(atoms=[hydrogen, hydrogen, oxygen])

# Вывод информации
print(hydrogen)
print(oxygen)
print(water)

Этот код создает атомы, используя протоны, нейтроны и электроны, а затем объединяет атомы в молекулы.

Пример:

1. Атомы водорода и кислорода строятся из протонов, нейтронов и электронов.
2. Молекула воды (H₂O) создается из двух атомов водорода и одного атома кислорода.

Когда вы запустите этот код, вы получите вывод, показывающий структуру атомов и молекул. Например:

Atom: Atomic Number = 1, Mass Number = 2, Neutral = True
Atom: Atomic Number = 8, Mass Number = 16, Neutral = True
Molecule: Element-1H2Element-8O

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

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

class Particle:
    def __init__(self, name, type_, charge, mass):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass

class Proton:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "+1"

class Neutron:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "0"

class Atom:
    def __init__(self, protons, neutrons, electrons):
        self.protons = protons
        self.neutrons = neutrons
        self.electrons = electrons

    def atomic_number(self):
        return len(self.protons)

    def mass_number(self):
        return len(self.protons) + len(self.neutrons)

    def is_neutral(self):
        return len(self.protons) == len(self.electrons)

    def __str__(self):
        return (f"Atom: Atomic Number = {self.atomic_number()}, Mass Number = {self.mass_number()}, "
                f"Neutral = {self.is_neutral()}")

class Element:
    def __init__(self, symbol, name, atomic_number, atomic_mass):
        self.symbol = symbol
        self.name = name
        self.atomic_number = atomic_number
        self.atomic_mass = atomic_mass

    def __str__(self):
        return f"{self.symbol} ({self.name}): Atomic Number = {self.atomic_number}, Atomic Mass = {self.atomic_mass}"

class PeriodicTable:
    def __init__(self):
        self.elements = []

    def add_element(self, element):
        self.elements.append(element)

    def display(self):
        for element in sorted(self.elements, key=lambda e: e.atomic_number):
            print(element)

# Создание элементов
hydrogen = Element("H", "Hydrogen", 1, 1.008)
helium = Element("He", "Helium", 2, 4.0026)
lithium = Element("Li", "Lithium", 3, 6.94)
beryllium = Element("Be", "Beryllium", 4, 9.0122)
boron = Element("B", "Boron", 5, 10.81)
carbon = Element("C", "Carbon", 6, 12.011)
nitrogen = Element("N", "Nitrogen", 7, 14.007)
oxygen = Element("O", "Oxygen", 8, 15.999)
fluorine = Element("F", "Fluorine", 9, 18.998)
neon = Element("Ne", "Neon", 10, 20.180)

# Создание таблицы Менделеева
periodic_table = PeriodicTable()
periodic_table.add_element(hydrogen)
periodic_table.add_element(helium)
periodic_table.add_element(lithium)
periodic_table.add_element(beryllium)
periodic_table.add_element(boron)
periodic_table.add_element(carbon)
periodic_table.add_element(nitrogen)
periodic_table.add_element(oxygen)
periodic_table.add_element(fluorine)
periodic_table.add_element(neon)

# Вывод таблицы
periodic_table.display()

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

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

import random

# Базовые элементы языка
nouns = ["человек", "кошка", "собака", "дерево", "река", "птица"]
verbs = ["идёт", "бежит", "летит", "плавает", "прыгает", "поёт"]
adjectives = ["красивый", "быстрый", "медленный", "зелёный", "громкий", "маленький"]
prepositions = ["на", "в", "под", "за", "перед", "около"]

# Функция для создания случайного предложения
def generate_sentence():
    noun1 = random.choice(nouns)
    noun2 = random.choice(nouns)
    verb = random.choice(verbs)
    adjective = random.choice(adjectives)
    preposition = random.choice(prepositions)

    # Создание структуры предложения
    sentence = f"{noun1.capitalize()} {verb} {preposition} {adjective} {noun2}."
    return sentence

# Генерация нескольких предложений
for _ in range(5):
    print(generate_sentence())

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

Кошка летит перед красивый человек.
Птица прыгает на громкий собака.
Человек идёт за зелёный река.
Собака поёт под маленький дерево.
Дерево плавает в быстрый птица.

Этот код демонстрирует основу синтаксиса языка: существительные, глаголы, прилагательные и предлоги объединяются в осмысленные структуры. Конечно, он использует случайность и не обладает глубиной реального языка, но показывает принципы.

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

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

- Языки изолирующего типа (например, китайский) имеют минимальные изменения словоформ.
- Агглютинативные языки (например, турецкий) создают длинные слова, соединяя морфемы.
- Некоторые языки не имеют временных форм глаголов или даже разделения на части речи.

Пример необычного языка можно смоделировать так:

import random

# Элементы для необычного языка
root_words = ["ba", "ka", "ta", "zi", "lo", "mu"]
modifiers = ["-li", "-ta", "-ku", "-zo", "-na"]  # Префиксы или суффиксы
actions = ["повтор", "ударение", "смена тона"]  # В языке смысл передаётся через интонации или повторения

# Генерация случайного слова
def generate_word():
    root = random.choice(root_words)
    modifier = random.choice(modifiers)
    word = root + modifier
    return word

# Генерация "предложения"
def generate_sentence_unusual():
    sentence = []
    for _ in range(random.randint(3, 6)):  # Количество слов в "предложении"
        word = generate_word()
        if random.choice([True, False]):
            word = word * 2  # Повторение для усиления смысла
        if random.choice([True, False]):
            word += "!"  # Интонация: добавление эмоционального контекста
        sentence.append(word)
    return " ".join(sentence)

# Генерация и вывод примеров
print("Пример языка с необычной структурой:")
for _ in range(5):
    print(generate_sentence_unusual())

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

Пример языка с необычной структурой:
balita balita! kazona kazona ziku!
muza! kalili kalili! lozoku!
kali kali! lozoku! tazona!
zili zili muza! zoku!
balita kazona muza muza!

### Особенности этого подхода:
1. Отсутствие грамматических категорий: здесь нет различий между существительными, глаголами и прилагательными.
2. Повторения: в некоторых языках повторение звуков усиливает значение.
3. Интонация: добавление "!" симулирует использование тона для изменения смысла.
4. Агглютинация: морфемы (например, -li, `-na`) используются для модификации корней.

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

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

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

1. Одновременная передача нескольких значений в одном "слове" (каждое "слово" кодирует объект, действие и состояние).
2. Цветовая ассоциация слов: "значение" зависит от цвета, который "представляется" слову.
3. Динамика звучания: слово меняет смысл в зависимости от изменения его структуры во времени (например, удлинение или сокращение).

### Код моделирования:

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Генерация "предложения"
def generate_alien_sentence():
    sentence = []
    for _ in range(random.randint(3, 5)):  # Количество "слов"
        word = generate_base_word()
        word = apply_color(word)
        word = apply_modification(word)
        sentence.append(word)
    return " | ".join(sentence)

# Генерация примеров
print("Пример инопланетного языка:")
for _ in range(5):
    print(generate_alien_sentence())

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

Пример инопланетного языка:
красный @#$% | синий %&@* растяжение: %&@*-- | чёрный $*#$ импульс: $*#$~ | зелёный @@@ сжатие: @@
жёлтый @$%* сжатие: @$% | синий #$%& растяжение: #$%&- | красный &@*$ эхо: &@*$*$@&
чёрный *%# растяжение: *%#- | зелёный @#$% импульс: @#$%~ | жёлтый @# эхо: @##@
зелёный *&$ импульс: *&$~ | красный #%& растяжение: #%&-- | чёрный @# сжатие: @
красный %&@ сжатие: %& | синий @#$ растяжение: @#$- | жёлтый $% эхо: $%$%

### Особенности инопланетного языка:
1. Слова как многомерные структуры: каждое слово кодирует базовую форму, цвет, динамическую модификацию, что добавляет слои значения.
2. Цветовые значения: цвет добавляет семантику (например, "зелёный" может означать вопрос, "красный" — действие).
3. Динамика времени: модификации, такие как растяжение или эхо, добавляют эмоциональные или контекстуальные оттенки.
4. Нелинейная структура: слово может включать отражение (эхо) или импульсы, что невозможно в линейной речи.

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

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

Вот код, который кодирует сообщение в созданном ранее инопланетном языке, но я не скажу, какое именно сообщение закодировано.

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Кодирование сообщения
message = "С Новым 2025 годом!"
encoded_message = []
for char in message:
    if char.strip():  # Пропускаем пробелы и пустые символы
        base_word = generate_base_word()
        colored_word = apply_color(base_word)
        modified_word = apply_modification(colored_word)
        encoded_message.append(modified_word)
    else:
        encoded_message.append("пробел")

# Вывод закодированного сообщения
print("Закодированное сообщение:")
for encoded_word in encoded_message:
    print(encoded_word)

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

Я добавил функцию для декодирования сообщения. Теперь код может раскодировать сообщение, используя упрощённые правила. Запусти обновлённый скрипт, чтобы проверить результат! 🚀

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Кодирование сообщения
message = "С Новым 2025 годом!"
encoded_message = []
coding_map = {}  # Карта соответствия символов

for char in message:
    if char.strip():  # Пропускаем пробелы и пустые символы
        base_word = generate_base_word()
        colored_word = apply_color(base_word)
        modified_word = apply_modification(colored_word)
        encoded_message.append(modified_word)
        coding_map[modified_word] = char  # Сохраняем соответствие символа и кодировки
    else:
        encoded_message.append("пробел")
        coding_map["пробел"] = " "

# Вывод закодированного сообщения
print("Закодированное сообщение:")
for encoded_word in encoded_message:
    print(encoded_word)

# Раскодирование сообщения
def decode_message(encoded_message, coding_map):
    decoded_message = []
    for encoded_word in encoded_message:
        decoded_message.append(coding_map.get(encoded_word, "?"))  # Используем карту для точного восстановления
    return "".join(decoded_message)

# Пример декодирования
print("\nДекодированное сообщение:")
decoded_message = decode_message(encoded_message, coding_map)
print(decoded_message)

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