practik - master - klinich/nn

practik
392 строки17 KB
klinich
update practik
02 ноя 2025, 12:40
02 ноя 2025, 12:40aca34e6
*№1*
def caesar_cipher(text, shift): 
    """
    Шифрует или дешифрует текст с использованием шифра Цезаря.

    Поддерживает русские и английские буквы (верхний и нижний регистр).
    Неалфавитные символы остаются без изменений.

    Args:
        text (str): Исходный текст для обработки.
        shift (int): Сдвиг для шифрования (положительный) или дешифрования (отрицательный).

    Returns:
        str: Обработанный текст.
    """
    ru_lower = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'                   # Русский алфавит
    ru_upper = ru_lower.upper()                                      # Заглавные буквы
    en_lower = 'abcdefghijklmnopqrstuvwxyz'                          # Английский алфавит
    en_upper = en_lower.upper()                                      # Заглавные английские

    result = []                                                      # Список для результата

    for char in text:                                                # Перебираем каждый символ
        if char in ru_lower:                                         # Если строчная русская
            idx = (ru_lower.index(char) + shift) % len(ru_lower)     # Новый индекс с учётом сдвига
            result.append(ru_lower[idx])                             # Добавляем зашифрованную букву
        elif char in ru_upper:                                       # Если заглавная русская
            idx = (ru_upper.index(char) + shift) % len(ru_upper)     # Сдвиг с модулем
            result.append(ru_upper[idx])                             # Добавляем в результат
        elif char in en_lower:                                       # Если строчная английская
            idx = (en_lower.index(char) + shift) % len(en_lower)     # Циклический сдвиг
            result.append(en_lower[idx])                             # Добавляем букву
        elif char in en_upper:                                       # Если заглавная английская
            idx = (en_upper.index(char) + shift) % len(en_upper)     # Сдвиг по алфавиту
            result.append(en_upper[idx])                             # Сохраняем регистр
        else:                                                        # Если не буква (цифра, знак и т.д.)
            result.append(char)                                      # Оставляем без изменений

    return ''.join(result)                                           # Собираем строку из списка


def main():
    """Основная функция для взаимодействия с пользователем."""       # Точка входа в программу
    print("Привет!")                                                 # Приветствие
    print("Тебе нужен шифратор или дешифратор?")                     # Запрос действия
    print("1 - шифратор")                                            # Вариант 1
    print("2 - дешифратор")                                          # Вариант 2

    try:                                                             # Обработка ввода
        number = int(input())                                        # Читаем выбор пользователя
    except ValueError:                                               # Если введено не число
        print("Неправильный ввод!")                                  # Сообщение об ошибке
        return                                                       # Завершаем программу

    if number == 1:                                                  # Если выбран шифратор
        shift = 2                                                    # Сдвиг +2
    elif number == 2:                                                # Если выбран дешифратор
        shift = -2                                                   # Сдвиг -2
    else:                                                            # Если введено не 1 и не 2
        print("Неправильный ввод!")                                  # Ошибка
        return                                                       

    text = input()                                                   # Получаем текст от пользователя
    encrypted_text = caesar_cipher(text, shift)                      # Шифруем/дешифруем
    print(encrypted_text)                                            # Выводим результат

main()

*№2*
def check_winners(scores, student_score):
    """
    Проверяет, попал ли студент в тройку победителей по баллам.

    Args:
        scores (list of int): Список баллов всех участников, отсортированный по возрастанию.
        student_score (int): Балл студента, которого нужно проверить.

    Returns:
        None: Функция выводит результат в консоль.
    """
    if len(scores) < 3:  # Если участников меньше 3 — все автоматически в тройке
        print("Вы в тройке победителей!")
        return

    third_place_score = scores[-3]  # Минимальный балл для попадания в топ-3
    if student_score >= third_place_score:  # Сравниваем балл студента с порогом
        print("Вы в тройке победителей!")
    else:
        print("Вы не попали в тройку победителей.")


scores = sorted(map(int, input().split()))  # Получаем и сортируем баллы всех участников
student_score = int(input())                # Получаем балл студента

check_winners(scores, student_score)        # Вызываем функцию

*№3*
def print_pack_report(total_pies):
    """
    Выводит отчёт о возможной упаковке пирожных по коробкам по 3 или 5 штук.

    Args:
        total_pies (int): Общее количество пирожных.

    Returns:
        None: Результат выводится на экран.
    """
    for num in range(total_pies, 0, -1):             # Перебираем от n до 1
        if num % 5 == 0 and num % 3 == 0:            # Делится и на 3, и на 5
            print(f"{num} - расфасуем по 3 или по 5")
        elif num % 5 == 0:                            # Делится только на 5
            print(f"{num} - расфасуем по 5")
        elif num % 3 == 0:                            # Делится только на 3
            print(f"{num} - расфасуем по 3")
        else:                                         # Не делится ни на 3, ни на 5
            print(f"{num} - не заказываем!")


total_pies = int(input())                                     # Читаем количество пирожных
print_pack_report(total_pies)                                 # Вызываем функцию

*№4*
import random
import string


def generate_password(length, use_lower=True, use_upper=True, use_digits=True, use_special=True):
    """
    Генерирует сложный пароль по заданным параметрам.

    Args:
        length (int): Длина пароля.
        use_lower (bool): Включать ли строчные буквы.
        use_upper (bool): Включать ли заглавные буквы.
        use_digits (bool): Включать ли цифры.
        use_special (bool): Включать ли спецсимволы.

    Returns:
        str: Сгенерированный пароль.

    Raises:
        ValueError: Если не выбран ни один тип символов.
    """
    # Собираем алфавит на основе выбранных опций
    chars = ""
    if use_lower:
        chars += string.ascii_lowercase            # a-z
    if use_upper:
        chars += string.ascii_uppercase            # A-Z
    if use_digits:
        chars += string.digits                     # 0-9
    if use_special:
        chars += "!@#$%^&*()_+-=[]{}|;:,.<>?"

    # Проверяем, что хотя бы один тип символов выбран
    if not chars:
        raise ValueError("Выберите хотя бы один тип символов!")

    # Генерируем пароль случайным образом
    password = ''.join(random.choice(chars) for _ in range(length))
    return password


print("=" * 40)
print("🔐 Генератор сложных паролей")
print("=" * 40)

try:
    length = int(input("Введите длину пароля: "))   # Запрашиваем длину
except ValueError:
    print("⚠️ Введите число!")
    exit()

# Запрашиваем настройки
use_lower = input("Включить строчные буквы? (y/n): ").strip().lower() == 'y'
use_upper = input("Включить заглавные буквы? (y/n): ").strip().lower() == 'y'
use_digits = input("Включить цифры? (y/n): ").strip().lower() == 'y'
use_special = input("Включить спецсимволы? (y/n): ").strip().lower() == 'y'

print("\n" + "-" * 40)
print("⏳ Генерирую пароль...")

try:
    password = generate_password(
        length=length,
        use_lower=use_lower,
        use_upper=use_upper,
        use_digits=use_digits,
        use_special=use_special
    )
    print(f"\n✅ Ваш пароль: {password}")
except ValueError as e:
    print(f"❌ Ошибка: {e}")

print("-" * 40)
print("💡 Пароль готов! Сохраните его в надёжном месте.")

*№5*
def int_to_roman(num):
    """
    Преобразует целое число в римскую запись.

    Args:
        num (int): Целое число от 1 до 3999.

    Returns:
        str: Римское представление числа.
    """
    if not isinstance(num, int) or num < 1 or num > 3999:
        raise ValueError("Число должно быть целым от 1 до 3999")

    # Таблица значений: от наибольшего к наименьшему
    values = [
        (1000, 'M'), (900, 'CM'), (500, 'D'), (400, 'CD'),
        (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'),
        (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'), (1, 'I')
    ]

    result = ""
    for value, symbol in values:                   # Перебираем пары значение-символ
        count = num // value                       # Сколько раз символ повторяется
        result += symbol * count                   # Добавляем символ нужное количество раз
        num -= value * count                       # Уменьшаем число

    return result


def roman_to_int(roman):
    """
    Преобразует римское число в целое.

    Args:
        roman (str): Римская запись числа (например, "IV", "XII").

    Returns:
        int: Обычное целое число.

    Raises:
        ValueError: Если строка не является корректным римским числом.
    """
    roman_values = {
        'I': 1, 'V': 5, 'X': 10, 'L': 50,
        'C': 100, 'D': 500, 'M': 1000
    }

    total = 0
    prev_value = 0

    for char in reversed(roman.upper()):           # Читаем справа налево
        if char not in roman_values:
            raise ValueError(f"Некорректный символ: {char}")

        current_value = roman_values[char]
        if current_value >= prev_value:
            total += current_value                 # Прибавляем, если текущее >= предыдущего
        else:
            total -= current_value                 # Вычитаем, если текущее < предыдущего
        prev_value = current_value

    return total


print("=" * 40)
print("🔢 Римский конвертер")
print("=" * 40)

print("Выберите режим:")
print("1 - Обычное число → Римское")
print("2 - Римское число → Обычное")

try:
    choice = input("Ваш выбор (1 или 2): ").strip()
except EOFError:
    print("\nВыход.")
    exit()

if choice == "1":
    try:
        n = int(input("Введите число (1–3999): "))
        print(f"\n→ {n} = {int_to_roman(n)}")
    except ValueError as e:
        print(f"❌ Ошибка: {e}")

elif choice == "2":
    roman_input = input("Введите римское число: ").strip()
    try:
        result = roman_to_int(roman_input)
        print(f"\n→ {roman_input} = {result}")
    except ValueError as e:
        print(f"❌ Ошибка: {e}")

else:
    print("⚠️ Неверный выбор. Введите 1 или 2.")

print("-" * 40)

*№6*
import turtle

# Слово для угадывания
word = "онкасегу"  # можно заменить на любое

# Начальное состояние: все буквы скрыты
hidden = ["_"] * len(word)

# Максимальное количество ошибок
max_mistakes = 7
mistakes = 0

# Настройка черепашки
screen = turtle.Screen()
screen.title("🎮 Виселица")
screen.bgcolor("white")

pen = turtle.Turtle()
pen.speed(0)  # Максимальная скорость
pen.hideturtle()  # Скрываем черепаху
pen.pensize(3)

# Функция для рисования виселицы по этапам
def draw_hangman(step):
    pen.penup()
    pen.goto(-150, -100)
    pen.pendown()
    pen.color("black")

    if step >= 1:  # Опора
        pen.forward(100)
    if step >= 2:  # Столб
        pen.backward(50)
        pen.left(90)
        pen.forward(200)
    if step >= 3:  # Перекладина
        pen.right(90)
        pen.forward(80)
    if step >= 4:  # Верёвка
        pen.right(90)
        pen.forward(30)
    if step >= 5:  # Голова
        pen.right(90)
        pen.circle(15)
    if step >= 6:  # Тело
        pen.left(90)
        pen.penup()
        pen.forward(30)
        pen.pendown()
        pen.forward(60)
    if step >= 7:  # Руки и ноги
        pen.backward(40)
        pen.left(45)
        pen.forward(30)
        pen.backward(30)
        pen.right(90)
        pen.forward(30)
        pen.backward(30)
        pen.left(45)
        pen.forward(40)
        pen.left(45)
        pen.forward(30)
        pen.backward(30)
        pen.right(90)
        pen.forward(30)

print("🎮 Добро пожаловать в игру «Виселица»!")
print("Угадай слово по буквам. У тебя 7 попыток.")

while mistakes < max_mistakes and "_" in hidden:
    print("\n" + " ".join(hidden))             # Показываем текущее состояние слова
    guess = input("Введите букву: ").strip().lower()

    if len(guess) != 1 or not guess.isalpha():
        print("⚠️ Введите одну букву!")
        continue

    if guess in word:
        for i in range(len(word)):
            if word[i] == guess:
                hidden[i] = guess              # Открываем букву
        print("✅ Правильно!")
    else:
        mistakes += 1                          # Ошибка — рисуем часть виселицы
        print(f"❌ Нет такой буквы. Осталось {max_mistakes - mistakes} попыток.")
        draw_hangman(mistakes)                # Рисуем следующую часть

# Конец игры
if "_" not in hidden:
    print(f"\n🎉 Поздравляем! Ты угадал слово: {word}")
else:
    print(f"\n💀 Проиграл! Загаданное слово: {word}")

# Ожидание закрытия окна
turtle.done()