gosgia 0.1.0__py3-none-any.whl

gosgia-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: gosgia
+Version: 0.1.0
+Summary: Коллекция решений учебных заданий по программированию
+Author-email: Student <student@example.com>
+License: MIT
+Project-URL: Repository, https://github.com/yourusername/gosgia
+Keywords: решения,учебные,примеры,код
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown

gosgia-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+solutions/__init__.py,sha256=dhnuaitRxLtCgtioMxZnWai97hBYVnsn_OTAJTpLfEA,539
+solutions/zadanie_1.py,sha256=CWqfrfA_jcDfns0JLXK8Zw3UrsEm9aZC2Bp206B3KaE,3122
+solutions/zadanie_17.py,sha256=QBmR63yUtLi4vTu8Qj62yGR11RiAN9Y8SZfldCMdIzE,2441
+solutions/zadanie_18.py,sha256=Rf-TNc6jtOT9cpUucelrfH5bvuyoYTCZ2BrzZVSvP4U,8895
+solutions/zadanie_21.py,sha256=vbwt-3mS7jx3UI6kA2PUDJ3hHRO8NfZEOnOE0h4BWoE,9777
+solutions/zadanie_24.py,sha256=ze_xeU0V2llAxQWPMe4Uhtt2t9HWJzARmeZfeAZBqJ4,3293
+solutions/zadanie_3.py,sha256=fE96dmLgkjNgztEHMxYoaPvCA7VUASvOn5Lfqh_rbmw,3861
+solutions/zadanie_5.py,sha256=znuWyR85_NiYe4ga38dvGs6XpRXueU5egGGjK6_gwb8,3364
+solutions/zadanie_8.py,sha256=OEFIOwnWU7S83TcoL9sVZOEC_VGMWfYyj2BwuDjnT3A,2943
+solutions/zadanie_9.py,sha256=r-v9U3XvaUrB1JvPPzbsrevQe78Og49-uNER6S6XzqI,3702
+gosgia-0.1.0.dist-info/METADATA,sha256=JbUoCvSQARFzcLTFRlzZLlrs303CcWpSC_B6RyJi1G4,647
+gosgia-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gosgia-0.1.0.dist-info/entry_points.txt,sha256=DeTyY4FlNspkXnc-WDTzu3BmxhZ5uQ3iXqt2ty52SV8,44
+gosgia-0.1.0.dist-info/top_level.txt,sha256=uAC7WbgG54gX48Rq6nnJu4C_HO9xypSO737MtlZ3Thk,10
+gosgia-0.1.0.dist-info/RECORD,,

gosgia-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gosgia-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gos-gia = gosgia.cli:main

gosgia-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+solutions

solutions/__init__.py

@@ -0,0 +1,25 @@
+"""
+Решения практических заданий
+"""
+
+from .zadanie_1 import zadanie_1
+from .zadanie_3 import zadanie_3
+from .zadanie_5 import zadanie_5
+from .zadanie_8 import zadanie_8
+from .zadanie_9 import zadanie_9
+from .zadanie_17 import zadanie_17
+from .zadanie_18 import zadanie_18
+from .zadanie_21 import zadanie_21
+from .zadanie_24 import zadanie_24
+
+__all__ = [
+    'zadanie_1',
+    'zadanie_3',
+    'zadanie_5',
+    'zadanie_8',
+    'zadanie_9',
+    'zadanie_17',
+    'zadanie_18',
+    'zadanie_21',
+    'zadanie_24'
+]

solutions/zadanie_1.py

@@ -0,0 +1,46 @@
+# Исходный список словарей с информацией о студентах
+def zadanie_1():
+    students = [
+        {"name": "Анна", "age": 20, "grade": 4.5, "group": "ИВТ-101"},
+        {"name": "Иван", "age": 22, "grade": 3.8, "group": "ИВТ-102"},
+        {"name": "Мария", "age": 21, "grade": 4.9, "group": "ИВТ-101"},
+        {"name": "Петр", "age": 23, "grade": 3.5, "group": "ИВТ-103"},
+        {"name": "Ольга", "age": 20, "grade": 4.2, "group": "ИВТ-102"}
+    ]
+
+
+    # 1. Сортировка студентов по убыванию среднего балла
+    # Используем функцию sorted() с параметром key, который задаёт критерий сортировки
+    # lambda x: x['grade'] — извлекает значение поля 'grade' из каждого словаря (элемента списка)
+    # reverse=True — сортировка в порядке убывания (от большего к меньшему)
+    sorted_students = sorted(students, key=lambda x: x['grade'], reverse=True)
+
+    # Выводим отсортированный список для проверки
+    print("Студенты, отсортированные по убыванию среднего балла:")
+    for student in sorted_students:
+        print(f"Имя: {student['name']}, Средний балл: {student['grade']}, Группа: {student['group']}")
+
+    # 2. Вычисление среднего балла по каждой группе
+    # Создаём пустой словарь для хранения сумм баллов и количества студентов в каждой группе
+    group_stats = {}
+
+    # Проходим по каждому студенту в исходном списке
+    for student in students:
+        group = student['group']  # Получаем название группы текущего студента
+        grade = student['grade']  # Получаем средний балл текущего студента
+
+        # Если группа ещё не добавлена в словарь, инициализируем её
+        if group not in group_stats:
+            group_stats[group] = {'total_grade': 0, 'count': 0}
+
+        # Добавляем балл студента к общей сумме для его группы
+        group_stats[group]['total_grade'] += grade
+        # Увеличиваем счётчик студентов в группе на 1
+        group_stats[group]['count'] += 1
+
+    # Теперь вычисляем средний балл для каждой группы
+    print("\nСредний балл по группам:")
+    for group, stats in group_stats.items():
+        # Средний балл = сумма баллов / количество студентов
+        average_grade = stats['total_grade'] / stats['count']
+        print(f"Группа {group}: средний балл {average_grade:.2f}")

solutions/zadanie_17.py

@@ -0,0 +1,41 @@
+def zadanie_17():
+    '''SELECT
+        Преподаватели.Табельный_номер,
+        Преподаватели.ФИО,
+        Должности.Название AS Должность,
+        Nz(Учёные_степени.Название, "Нет") AS Учёная_степень,
+        Nz(Учёные_звания.Название, "Нет") AS Учёное_звание,
+        Преподаватели.Ставка,
+
+        -- Базовый оклад: 27000 * коэффициент нагрузки
+        27000 * Должности.Коэффициент_нагрузки AS Базовый_оклад,
+
+        -- Надбавка за степень (если есть)
+        Nz(Учёные_степени.Надбавка, 0) AS Надбавка_за_степень,
+
+        -- Надбавка за звание (если есть)
+        Nz(Учёные_звания.Надбавка, 0) AS Надбавка_за_звание,
+
+        -- Сумма до применения ставки и коэффициентов
+        (27000 * Должности.Коэффициент_нагрузки +
+         Nz(Учёные_степени.Надбавка, 0) +
+         Nz(Учёные_звания.Надбавка, 0)) AS Сумма_до_коэффициентов,
+
+        -- Итоговая зарплата:
+        -- (Сумма_до_коэффициентов * Ставка) * Уральский_коэфф (1.15) * (1 - НДФЛ 0.13)
+        ROUND(
+            (27000 * Должности.Коэффициент_нагрузки +
+             Nz(Учёные_степени.Надбавка, 0) +
+             Nz(Учёные_звания.Надбавка, 0)) *
+            Преподаватели.Ставка * 1.15 * 0.87,
+            2
+        ) AS Итоговая_зарплата_руб
+
+    FROM
+        (Преподаватели
+        INNER JOIN Должности ON Преподаватели.ID_должности = Должности.ID_должности)
+        LEFT JOIN Учёные_степени ON Преподаватели.ID_степени = Учёные_степени.ID_степени
+        LEFT JOIN Учёные_звания ON Преподаватели.ID_звания = Учёные_звания.ID_звания
+
+    ORDER BY
+        Преподаватели.Табельный_номер;'''

solutions/zadanie_18.py

@@ -0,0 +1,179 @@
+def zadanie_18():
+    import sqlite3
+    import os
+
+    """
+    Задание 18: расчёт заработной платы преподавателей в SQLite
+    
+    
+    Алгоритм:
+    1. Создаём БД и таблицы для хранения данных о преподавателях, должностях и надбавках.
+    2. Заполняем справочники (должности, степени, звания, коэффициенты).
+    3. Добавляем данные о преподавателях.
+    4. Пишем SQL‑запрос для расчёта зарплаты по заданной формуле.
+    5. Выполняем запрос и выводим результаты.
+    """
+
+    # Удаляем базу, если уже существует (для чистоты эксперимента)
+    if os.path.exists("university_payroll.db"):
+        os.remove("university_payroll.db")
+
+    # Создаём подключение к БД
+    conn = sqlite3.connect("university_payroll.db")
+    cursor = conn.cursor()
+
+    print("1. Создание таблиц базы данных...\n")
+
+    # Таблица должностей с коэффициентами часовой нагрузки
+    cursor.execute("""")
+    CREATE TABLE IF NOT EXISTS positions (
+        position_id INTEGER PRIMARY KEY,
+        position_name TEXT NOT NULL UNIQUE,  -- название должности
+        load_coefficient REAL NOT NULL       -- коэффициент нагрузки (относительно доцента)
+    );
+    """)
+
+    # Таблица учёных степеней и их надбавок
+    cursor.execute("""")
+    CREATE TABLE IF NOT EXISTS degrees (
+        degree_id INTEGER PRIMARY KEY,
+        degree_name TEXT NOT NULL UNIQUE,    -- название степени
+        bonus_amount REAL NOT NULL           -- надбавка за степень (руб. на ставку)
+    );
+    """)
+
+    # Таблица учёных званий и их надбавок
+    cursor.execute("""")
+    CREATE TABLE IF NOT EXISTS titles (
+        title_id INTEGER PRIMARY KEY,
+        title_name TEXT NOT NULL UNIQUE,      -- название звания
+        bonus_amount REAL NOT NULL           -- надбавка за звание (руб. на ставку)
+    );
+    """)
+
+    # Основная таблица преподавателей
+    cursor.execute("""")
+    CREATE TABLE IF NOT EXISTS teachers (
+        teacher_id INTEGER PRIMARY KEY,        -- табельный номер
+        full_name TEXT NOT NULL,              -- ФИО
+        position_id INTEGER NOT NULL,           -- ссылка на должность
+        degree_id INTEGER,                    -- ссылка на учёную степень (может быть NULL)
+        title_id INTEGER,                      -- ссылка на учёное звание (может быть NULL)
+        work_rate REAL NOT NULL,                -- ставка (0.5, 1.0, 1.5)
+        FOREIGN KEY (position_id) REFERENCES positions (position_id),
+        FOREIGN KEY (degree_id) REFERENCES degrees (degree_id),
+        FOREIGN KEY (title_id) REFERENCES titles (title_id)
+    );
+    """)
+
+    print("Таблицы созданы.\n")
+
+    print("2. Заполнение справочников...\n")
+
+
+    # Заполняем должности (коэффициенты относительно доцента)
+    cursor.executemany("INSERT OR REPLACE INTO positions (position_id, position_name, load_coefficient) VALUES (?, ?, ?)", [
+        (1, "Старший преподаватель", 0.9),
+        (2, "Доцент", 1.0),
+        (3, "Профессор", 1.1)
+    ])
+
+    # Заполняем учёные степени и надбавки
+    cursor.executemany("INSERT OR REPLACE INTO degrees (degree_id, degree_name, bonus_amount) VALUES (?, ?, ?)", [
+        (1, "Кандидат наук", 3000.0),
+        (2, "Доктор наук", 6000.0)
+    ])
+
+    # Заполняем учёные звания и надбавки
+    cursor.executemany("INSERT OR REPLACE INTO titles (title_id, title_name, bonus_amount) VALUES (?, ?, ?)", [
+        (1, "Доцент", 1000.0),
+        (2, "Профессор", 2500.0)
+    ])
+
+    print("Справочники заполнены.\n")
+
+
+    print("3. Добавление данных о преподавателях...\n")
+
+    # Добавляем нескольких преподавателей для примера
+    cursor.executemany("INSERT INTO teachers (teacher_id, full_name, position_id, degree_id, title_id, work_rate) VALUES (?, ?, ?, ?, ?, ?)", [
+        (101, "Иванов А.С.", 2, 1, 1, 1.0),   # Доцент, канд. наук, доцент, 1 ставка
+        (102, "Петрова М.И.", 3, 2, 2, 1.5),  # Профессор, д-р наук, профессор, 1.5 ставки
+        (103, "Сидоров В.П.", 1, None, None, 0.5), # Ст. преподаватель, без степени и звания, 0.5 ставки
+        (104, "Кузнецова Е.А.", 2, None, 1, 1.0)  # Доцент, без степени, доцент, 1 ставка
+    ])
+
+    print("Данные о преподавателях добавлены.\n")
+
+
+    print("4. Расчёт заработной платы...\n")
+
+
+    # Формула расчёта:
+    # З/П = (Оклад_доцента * Коэфф_нагрузки + Надбавка_за_степень + Надбавка_за_звание) *
+    #         * Количество_ставок * Уральский_коэфф * (1 - НДФЛ)
+    #
+    # Принимаем:
+    # - Оклад доцента на 1 ставку = 27 000 руб.
+    # - Уральский коэффициент = 1.15 (15 %)
+    # - НДФЛ = 13 % → множитель (1 – 0.13) = 0.87
+
+
+    query = """
+    SELECT
+        t.teacher_id AS "Табельный номер",
+        t.full_name AS "ФИО",
+        p.position_name AS "Должность",
+        COALESCE(d.degree_name, 'Нет') AS "Учёная степень",
+        COALESCE(tl.title_name, 'Нет') AS "Учёное звание",
+        t.work_rate AS "Ставка",
+        -- Расчёт базовой части (оклад доцента × коэффициент нагрузки)
+        ROUND(27000 * p.load_coefficient, 2) AS "Базовый оклад (руб.)",
+        -- Надбавка за степень (если есть)
+        COALESCE(d.bonus_amount, 0) AS "Надбавка за степень (руб.)",
+        -- Надбавка за звание (если есть)
+        COALESCE(tl.bonus_amount, 0) AS "Надбавка за звание (руб.)",
+        -- Сумма до применения ставок и коэффициентов
+        ROUND(
+            27000 * p.load_coefficient +
+            COALESCE(d.bonus_amount, 0) +
+            COALESCE(tl.bonus_amount, 0),
+            2
+        ) AS "Сумма до ставок (руб.)",
+        -- Итоговая зарплата с учётом ставки, уральского коэфф. и НДФЛ
+        ROUND(
+            (27000 * p.load_coefficient +
+             COALESCE(d.bonus_amount, 0) +
+             COALESCE(tl.bonus_amount, 0)) *
+            t.work_rate * 1.15 * 0.87,
+            2
+        ) AS "Итоговая зарплата (руб.)"
+    FROM teachers t
+    JOIN positions p ON t.position_id = p.position_id
+    LEFT JOIN degrees d ON t.degree_id = d.degree_id
+    LEFT JOIN titles tl ON t.title_id = tl.title_id
+    ORDER BY t.teacher_id;
+    """
+
+    # Выполняем запрос
+    cursor.execute(query)
+    results = cursor.fetchall()
+
+    # Выводим результаты
+    print("Результаты расчёта заработной платы:\n")
+    for row in results:
+        print(f"Табельный номер: {row[0]}")
+        print(f"ФИО: {row[1]}")
+        print(f"Должность: {row[2]}")
+        print(f"Учёная степень: {row[3]}")
+        print(f"Учёное звание: {row[4]}")
+        print(f"Ставка: {row[5]}")
+        print(f"Базовый оклад: {row[6]} руб.")
+        print(f"Надбавка за степень: {row[7]} руб.")
+        print(f"Надбавка за звание: {row[8]} руб.")
+        print(f"Сумма до ставок: {row[9]} руб.")
+        print(f"Итоговая зарплата: {row[10]} руб.")
+
+    print("\n5. Закрытие соединения с БД...")
+    conn.close()
+    print("Работа завершена.")

solutions/zadanie_21.py

@@ -0,0 +1,176 @@
+def zadanie_21():
+    """
+    Инфологическая модель БД для учёта дополнительной работы преподавателей
+    (для расчёта надбавок к окладу)
+
+
+    Цель: спроектировать структуру данных, позволяющую:
+    - фиксировать виды дополнительной работы;
+    - учитывать объёмы выполненной работы по каждому преподавателю;
+    - хранить нормативы оплаты;
+    - готовить данные для расчёта надбавок.
+    """
+
+    # Импорт необходимых модулей (для демонстрации структуры)
+    from datetime import date
+    from typing import Optional
+
+
+    """
+    1. Сущность «Преподаватель» (Teacher)
+    Хранит основную информацию о сотруднике.
+    """
+    class Teacher:
+        def __init__(self, teacher_id: int, full_name: str, position: str, base_salary: float):
+            self.teacher_id = teacher_id          # PK: уникальный идентификатор преподавателя
+            self.full_name = full_name        # ФИО
+            self.position = position              # Должность (профессор, доцент, ст. преподаватель и т.п.)
+            self.base_salary = base_salary        # Основной оклад (руб.)
+            # Дополнительные атрибуты по необходимости (кафедра, учёная степень и др.)
+
+    """
+    2. Сущность «Вид дополнительной работы» (ExtraWorkType)
+    Описывает типы работ, за которые положена надбавка.
+    """
+    class ExtraWorkType:
+        def __init__(self, work_type_id: int, name: str, unit: str, rate_per_unit: float, is_active: bool = True):
+            self.work_type_id = work_type_id    # PK: идентификатор типа работы
+            self.name = name                    # Название работы (например, «Руководство ВКР», «Организация олимпиады»)
+            self.unit = unit                    # Единица измерения объёма (часы, штуки, мероприятия)
+            self.rate_per_unit = rate_per_unit # Ставка за единицу (руб.)
+            self.is_active = is_active        # Активен ли тип работы (для архивирования устаревших)
+
+    """
+    3. Сущность «Период учёта» (ReportingPeriod)
+    Определяет временной интервал, за который фиксируется работа.
+    """
+    class ReportingPeriod:
+        def __init__(self, period_id: int, start_date: date, end_date: date, name: str):
+            self.period_id = period_id          # PK: идентификатор периода
+            self.start_date = start_date      # Начало периода
+            self.end_date = end_date          # Конец периода
+            self.name = name                  # Наименование (например, «Семестр 1 2025/2026»)
+
+    """
+    4. Сущность «Запись о выполненной работе» (WorkRecord)
+    Фиксирует факт выполнения работы преподавателем.
+    """
+    class WorkRecord:
+        def __init__(
+            self,
+            record_id: int,
+            teacher_id: int,                  # FK: ссылка на преподавателя
+            work_type_id: int,            # FK: ссылка на тип работы
+            period_id: int,                # FK: ссылка на период учёта
+            volume: float,                   # Объём выполненной работы (в единицах из ExtraWorkType)
+            confirmation_doc: str,           # Номер и дата подтверждающего документа
+            confirmation_date: date,           # Дата подтверждения объёма работы
+            approved: bool = False             # Утверждена ли запись (для согласования)
+        ):
+            self.record_id = record_id
+            self.teacher_id = teacher_id
+            self.work_type_id = work_type_id
+            self.period_id = period_id
+            self.volume = volume
+            self.confirmation_doc = confirmation_doc
+            self.confirmation_date = confirmation_date
+            self.approved = approved
+
+    """
+    5. Сущность «Расчёт надбавки» (BonusCalculation)
+    Хранит итоговые данные по надбавкам за период.
+    (Может формироваться автоматически на основе WorkRecord.)
+    """
+    class BonusCalculation:
+        def __init__(
+            self,
+            calculation_id: int,
+            teacher_id: int,                 # FK: преподаватель
+            period_id: int,               # FK: период учёта
+            total_bonus: float,              # Итоговая сумма надбавки (руб.)
+            calculation_date: date,         # Дата расчёта
+            notes: Optional[str] = None       # Примечания (например, «учтены премии»)
+        ):
+            self.calculation_id = calculation_id
+            self.teacher_id = teacher_id
+            self.period_id = period_id
+            self.total_bonus = total_bonus
+            self.calculation_date = calculation_date
+            self.notes = notes
+
+    """
+    Связи между сущностями:
+    
+    1. Teacher ↔ WorkRecord: один-ко-многим
+       - Один преподаватель может иметь много записей о выполненной работе.
+       - Каждая запись относится к одному преподавателю.
+    
+    2. ExtraWorkType ↔ WorkRecord: один-ко-многим
+       - Один тип работы может встречаться во многих записях.
+       - Каждая запись относится к одному типу работы.
+    
+    3. ReportingPeriod ↔ WorkRecord: один-ко-многим
+       - В одном периоде может быть много записей о работе.
+       - Каждая запись относится к одному периоду учёта.
+    4. Teacher + ReportingPeriod ↔ BonusCalculation: один-ко-одному (на пару)
+       - Для каждого преподавателя и периода формируется один расчёт надбавки.
+    
+    
+    Нормализация:
+    - Все сущности приведены к 3НФ: нет транзитивных зависимостей, каждый атрибут зависит только от PK.
+    - Внешние ключи (FK) обеспечивают ссылочную целостность.
+    
+    
+    Как использовать модель:
+    1. Заполнить справочники: Teacher, ExtraWorkType, ReportingPeriod.
+    2. Вносить записи о выполненной работе в WorkRecord (с подтверждением документов).
+    3. После закрытия периода — сформировать BonusCalculation для каждого преподавателя.
+    4. Использовать total_bonus из BonusCalculation для начисления выплат.
+    """
+
+    # Пример создания объектов (для иллюстрации)
+    if __name__ == "__main__":
+        # Создаём преподавателя
+        teacher = Teacher(teacher_id=1, full_name="Иванов А.С.", position="Доцент", base_salary=60000.00)
+
+
+        # Создаём тип работы
+        work_type = ExtraWorkType(
+            work_type_id=101,
+            name="Руководство ВКР",
+            unit="штука",
+            rate_per_unit=5000.00
+        )
+
+        # Создаём период учёта
+        period = ReportingPeriod(
+            period_id=20251,
+            start_date=date(2025, 9, 1),
+            end_date=date(2025, 12, 31),
+            name="Семестр 1 2025/2026"
+        )
+
+        # Фиксируем выполненную работу
+        record = WorkRecord(
+            record_id=1,
+            teacher_id=1,
+            work_type_id=101,
+            period_id=20251,
+            volume=3.0,
+            confirmation_doc="Акт №123 от 15.11.2025",
+            confirmation_date=date(2025, 11, 15),
+            approved=True
+        )
+
+        # Рассчитываем надбавку (упрощённо: volume × rate_per_unit)
+        total_bonus = record.volume * work_type.rate_per_unit
+        calculation = BonusCalculation(
+            calculation_id=1,
+            teacher_id=1,
+            period_id=20251,
+            total_bonus=total_bonus,
+            calculation_date=date(2025, 12, 20),
+            notes="Рассчитано по 3 ВКР"
+        )
+
+        print(f"Надбавка для {teacher.full_name}: {calculation.total_bonus} руб.")

solutions/zadanie_24.py

@@ -0,0 +1,43 @@
+def zadanie_24():
+    '''
+    -- SQL‑запрос для выбора трёх лучших по выручке товаров
+    -- Поясним каждый этап построения запроса
+
+
+    SELECT
+        product_id,          -- Идентификатор товара (выводим для идентификации)
+        product_name,        -- Название товара (удобно для анализа)
+        total_revenue          -- Рассчитанная выручка по товару
+    FROM (
+        -- Вложенный запрос (подзапрос): считаем выручку по каждому товару
+        SELECT
+            p.product_id,                            -- Берём ID товара
+            p.product_name,                          -- Берём название товара
+            SUM(s.quantity * p.price) AS total_revenue  -- Выручка = сумма(количество × цена)
+        FROM
+            products p                               -- Основная таблица товаров
+            JOIN sales s ON p.product_id = s.product_id  -- Соединяем с таблицей продаж
+        GROUP BY
+            p.product_id, p.product_name          -- Группируем по товару, чтобы посчитать выручку
+    ) AS revenue_calc
+    -- Конец вложенного запроса: теперь у нас есть таблица с выручкой по каждому товару
+
+    -- Основной запрос: сортируем и ограничиваем результат
+    ORDER BY
+        total_revenue DESC  -- Сортируем по выручке по убыванию (самые прибыльные — вверху)
+    LIMIT 3;                 -- Оставляем только 3 записи (три лучших товара)
+
+    -- Пояснение логики:
+    -- 1. Мы соединяем таблицу товаров (products) с таблицей продаж (sales) по полю product_id.
+    -- 2. Для каждого товара считаем общую выручку как сумму произведений количества проданного (quantity)
+    --    на цену товара (price) из таблицы products.
+    -- 3. Группируем результаты по товару (product_id и product_name), чтобы получить итоговую выручку
+    --    для каждого отдельного товара.
+    -- 4. Во внешнем запросе сортируем товары по убыванию выручки и ограничиваем вывод тремя записями.
+    --
+    -- Предполагаемые структуры таблиц:
+    -- products: product_id (PK), product_name, price
+    -- sales: sale_id (PK), product_id (FK), quantity, sale_date
+    --
+    -- Запрос универсален и будет работать в большинстве реляционных СУБД (PostgreSQL, MySQL, SQLite, SQL Server, Oracle),
+    -- при условии соответствия имён таблиц и полей.'''

solutions/zadanie_3.py

@@ -0,0 +1,57 @@
+def zadanie_3():
+    import pandas as pd
+    import numpy as np
+
+    # Устанавливаем случайное зерно для воспроизводимости результатов
+    np.random.seed(42)
+
+    # 1. Создаём первый DataFrame (df_a)
+    # Предположим, что индекс — это названия городов (для наглядности возьмём несколько городов)
+    cities_a = ['Москва', 'Санкт‑Петербург', 'Казань', 'Нижний Новгород', 'Екатеринбург']
+    df_a = pd.DataFrame({
+        'report': np.random.randint(1, 11, size=len(cities_a)),      # случайные целые от 1 до 10
+        'sales': np.random.randint(100, 1001, size=len(cities_a))   # случайные целые от 100 до 1000
+    }, index=cities_a)
+
+    # Назначаем имя индексу (для ясности)
+    df_a.index.name = 'city'
+
+    print("DataFrame df_a:")
+    print(df_a)
+    print()
+
+    # 2. Создаём второй DataFrame (df_b)
+    # Возьмём частично пересекающийся набор городов, чтобы продемонстрировать объединение
+    cities_b = ['Москва', 'Самара', 'Казань', 'Ростов‑на‑Дону', 'Новосибирск']
+    df_b = pd.DataFrame({
+        'report': np.random.randint(1, 11, size=len(cities_b)),
+        'sales': np.random.randint(100, 1001, size=len(cities_b))
+    }, index=cities_b)
+
+    df_b.index.name = 'city'
+
+    print("DataFrame df_b:")
+    print(df_b)
+    print()
+
+    # 3. Объединяем два DataFrame по индексу (городу)
+    # Используем pd.concat для вертикального объединения, затем группируем по индексу
+    df_combined = pd.concat([df_a, df_b])
+
+    # 4. Группируем по городу (index) и суммируем значения в колонках 'report' и 'sales'
+    df_total = df_combined.groupby('city').sum()
+
+
+    # 5. Выводим итоговый DataFrame
+    print("Итоговый DataFrame df_total (суммарные значения по городам):")
+    print(df_total)
+
+    # Пояснение алгоритма:
+    # - Шаг 1–2: создаём два DataFrame с индексами-городами и случайными данными в колонках 'report' (1..10) и 'sales' (100..1000).
+    #   np.random.randint(a, b) генерирует случайные целые числа в диапазоне [a, b-1], поэтому для 1..10 указываем (1, 11).
+    # - Шаг 3: объединяем df_a и df_b с помощью pd.concat(). Это создаёт новый DataFrame, где строки из обоих исходных DataFrame идут подряд.
+    #   Индексы (города) сохраняются, поэтому города, присутствующие в обоих DataFrame, окажутся в объединённой таблице дважды.
+    # - Шаг 4: группируем объединённый DataFrame по индексу 'city' с помощью groupby('city').
+    #   Затем применяем .sum(), чтобы для каждого уникального города сложить значения в колонках 'report' и 'sales'.
+    #   Таким образом, если город есть и в df_a, и в df_b, его показатели будут суммированы.
+    # - Шаг 5: выводим результат — df_total содержит все уникальные города из обоих DataFrame и их суммарные 'report' и 'sales'.

solutions/zadanie_5.py

@@ -0,0 +1,76 @@
+def zadanie_5():
+    def ip_to_binary(ip):
+        """
+        Преобразует IP‑адрес из десятичного формата (строка) в 32‑битную двоичную строку.
+
+        Пример: '172.16.17.30' → '10101100000100000001000100011110'
+        """
+        parts = ip.split('.')
+        binary = ''
+        for part in parts:
+            # Преобразуем каждую часть в 8‑битное двоичное число (с ведущими нулями)
+            binary += format(int(part), '08b')
+        return binary
+
+    def apply_mask(binary_ip, mask_length):
+        """
+        Применяет маску подсети к двоичному IP‑адресу.
+
+        Параметры:
+            binary_ip — двоичная строка (32 бита)
+            mask_length — длина маски (например, 20)
+        Возвращает:
+            адрес сети в двоичном виде (32 бита, где последние (32 − mask_length) бит обнулены)
+        """
+        # Оставляем первые mask_length бит, остальные обнуляем
+        network = binary_ip[:mask_length] + '0' * (32 - mask_length)
+        return network
+
+    def binary_to_ip(binary):
+        """
+        Преобразует 32‑битную двоичную строку в десятичный IP‑адрес (строка).
+
+        Пример: '10101100000100000001000000000000' → '172.16.16.0'
+        """
+        ip_parts = []
+        for i in range(0, 32, 8):
+            # Разбиваем на 4 части по 8 бит, преобразуем в десятичное число
+            part = binary[i:i+8]
+            ip_parts.append(str(int(part, 2)))
+        return '.'.join(ip_parts)
+
+    # Исходные данные
+    pc1_ip = '172.16.17.30'
+    pc2_ip = '172.16.28.15'
+    mask_length = 20  # Маска /2 Newton
+
+
+    print(f"PC1: {pc1_ip}/{mask_length}")
+    print(f"PC2: {pc2_ip}/{mask_length}")
+
+    # Шаг 1. Переводим IP‑адреса в двоичный формат
+    pc1_binary = ip_to_binary(pc1_ip)
+    pc2_binary = ip_to_binary(pc2_ip)
+
+    print(f"\nДвоичный вид:")
+    print(f"PC1: {pc1_binary}")
+    print(f"PC2: {pc2_binary}")
+
+
+    # Шаг 2. Применяем маску к каждому IP
+    pc1_network = apply_mask(pc1_binary, mask_length)
+    pc2_network = apply_mask(pc2_binary, mask_length)
+
+
+    print(f"\nАдрес сети после применения маски /{mask_length}:")
+    print(f"PC1: {pc1_network} ({binary_to_ip(pc1_network)})")
+    print(f"PC2: {pc2_network} ({binary_to_ip(pc2_network)})")
+
+    # Шаг 3. Сравниваем адреса сетей
+    if pc1_network == pc2_network:
+        print("\nВывод: Устройства находятся в одной подсети.")
+        print(f"Общая сеть: {binary_to_ip(pc1_network)}/{mask_length}")
+    else:
+        print("\nВывод: Устройства находятся в разных подсетях.")
+        print(f"Сеть PC1: {binary_to_ip(pc1_network)}/{mask_length}")
+        print(f"Сеть PC2: {binary_to_ip(pc2_network)}/{mask_length}")

solutions/zadanie_8.py

@@ -0,0 +1,56 @@
+def zadanie_8():
+    # Импорт библиотеки для работы с числами
+    import math
+
+    # Функция для расчёта NPV
+    def calculate_npv(initial_investment, cash_flows, discount_rate):
+        """
+        Рассчитывает чистый приведённый доход (NPV).
+
+        Параметры:
+        - initial_investment: начальные инвестиции (отрицательное значение, так как это затраты).
+        - cash_flows: список денежных потоков по годам.
+        - discount_rate: ставка дисконтирования (в десятичном виде, например, 0.1 для 10%).
+
+        Возвращает:
+        - NPV проекта.
+        """
+        npv = initial_investment  # Начинаем с начальных инвестиций
+        for t, cf in enumerate(cash_flows, start=1):
+            # Дисконтирование денежного потока за период t
+            discounted_cf = cf / (1 + discount_rate) ** t
+            npv += discounted_cf
+        return npv
+
+    # Данные для Проекта А
+    project_a = {
+        "initial_investment": -2_000_000,  # Инвестиции в млн руб. (знак минус, так как это затраты)
+        "cash_flows": [1_000_000, 1_000_000, 1_000_000],  # Денежные потоки по годам в млн руб.
+        "name": "Проект А (мобильное приложение)"
+    }
+
+    # Данные для Проекта Б
+    project_b = {
+        "initial_investment": -1_500_000,  # Инвестиции в млн руб.
+        "cash_flows": [700_000, 700_000, 700_000],  # Денежные потоки по годам в млн руб.
+        "name": "Проект Б (апгрейд серверов)"
+    }
+
+    # Ставка дисконтирования (10% в десятичном виде)
+    discount_rate = 0.1
+
+    # Расчёт NPV для каждого проекта
+    npv_a = calculate_npv(project_a["initial_investment"], project_a["cash_flows"], discount_rate)
+    npv_b = calculate_npv(project_b["initial_investment"], project_b["cash_flows"], discount_rate)
+
+    # Вывод результатов
+    print(f"NPV {project_a['name']}: {npv_a:.2f} млн руб.")
+    print(f"NPV {project_b['name']}: {npv_b:.2f} млн руб.")
+
+    # Сравнение проектов
+    if npv_a > npv_b:
+        print(f"{project_a['name']} экономически выгоднее, так как имеет больший NPV.")
+    elif npv_b > npv_a:
+        print(f"{project_b['name']} экономически выгоднее, так как имеет больший NPV.")
+    else:
+        print("Оба проекта имеют одинаковый NPV.")

solutions/zadanie_9.py

@@ -0,0 +1,53 @@
+def zadanie_9():
+    '''CREATE TABLE customers (
+        id INT AUTO_INCREMENT PRIMARY KEY,  -- Уникальный ID заказчика (автозаполнение)
+        name VARCHAR(255) NOT NULL,         -- Название заказчика (обязательно)
+        phone VARCHAR(20)                   -- Телефон заказчика (может быть пустым)
+    );
+
+    CREATE TABLE contracts (
+        id INT AUTO_INCREMENT PRIMARY KEY,  -- Уникальный ID договора (автозаполнение)
+        contract_date DATE NOT NULL,          -- Дата договора (обязательно)
+        amount DECIMAL(10, 2) NOT NULL,   -- Сумма договора (обязательно, до 2 знаков после запятой)
+        customer_id INT NOT NULL,             -- ID заказчика (внешний ключ)
+
+        -- Внешний ключ: связывает customer_id с id из таблицы customers
+        FOREIGN KEY (customer_id) REFERENCES customers(id)
+            ON DELETE RESTRICT                -- Запретить удаление заказчика, если у него есть договоры
+            ON UPDATE CASCADE                 -- При обновлении id заказчика автоматически обновить customer_id в договорах
+    );
+
+    SELECT
+        c.id AS customer_id,                    -- ID заказчика
+        c.name AS customer_name,               -- Название заказчика
+        IFNULL(SUM(co.amount), 0.00) AS total_amount  -- Общая сумма договоров за 2025 год (0.00, если договоров нет)
+    FROM
+        customers c
+    LEFT JOIN                                 -- LEFT JOIN: включаем всех заказчиков, даже если у них нет договоров
+        contracts co
+        ON c.id = co.customer_id
+        AND YEAR(co.contract_date) = 2025        -- Фильтрация по году прямо в JOIN (эффективнее, чем в WHERE)
+    GROUP BY
+        c.id, c.name                       -- Группируем по заказчику
+    ORDER BY
+        total_amount DESC;                   -- Сортируем по сумме (убывание)
+
+
+    -- Пояснения к ключевым моментам:
+    -- LEFT JOIN vs INNER JOIN:
+    --    - LEFT JOIN гарантирует, что в результате будут все заказчики, даже если у них нет договоров за 2025 год.
+    --    - INNER JOIN исключил бы таких заказчиков.
+    --
+    -- Фильтрация по году:
+    --    - YEAR(co.contract_date) = 2025 — извлекает год из даты и сравнивает с 2025.
+    --    - Условие добавлено в ON LEFT JOIN, чтобы не отфильтровать заказчиков без договоров.
+    --
+    -- IFNULL(SUM(...), 0.00):
+    --    - Если у заказчика нет договоров, SUM(amount) вернёт NULL.
+    --    - IFNULL заменяет NULL на 0.00 для наглядности.
+    --
+    -- GROUP BY c.id, c.name:
+    --    - Группируем по уникальному ID и имени заказчика, чтобы агрегировать суммы.
+    --
+    -- ORDER BY total_amount DESC:
+    --    - Сортируем результат по убыванию суммы, чтобы сначала шли заказчики с наибольшими оборотами.'''