---

import random


def parse_grades(raw_data):
    grades = []
    for row in raw_data:
        parts = row.split("|")
        if len(parts) != 2:
            raise ValueError("Используй формат: предмет | оценка")

        subject = parts[0].strip()
        grade_text = parts[1].strip()

        if not subject:
            raise ValueError("Название предмета не может быть пустым")
        if not grade_text.isdigit():
            raise ValueError("Оценка должна быть целым числом от 2 до 5")

        grade = int(grade_text)
        if grade < 2 or grade > 5:
            raise ValueError("Оценка должна быть от 2 до 5")

        grades.append((subject, grade))

    if not grades:
        raise ValueError("Нужно добавить хотя бы одну запись")
    return grades


def count_grades(grades):
    counts = {}
    for subject, grade in grades:
        counts[grade] = counts.get(grade, 0) + 1
    return counts


def calculate_average(grades):
    total = 0
    for subject, grade in grades:
        total += grade
    return total / len(grades)


def find_best_subject(grades):
    best = grades[0]
    for item in grades:
        if item[1] > best[1]:
            best = item
    return best


def find_worst_subject(grades):
    worst = grades[0]
    for item in grades:
        if item[1] < worst[1]:
            worst = item
    return worst


template = [
    "Математика | 5",
    "Русский | 4",
    "Физика | 5",
    "История | 3",
    "Математика | 4",
    "Английский | 5",
    "Физика | 4",
    "Химия | 3",
    "Русский | 5",
    "История | 4"
]

while True:
    mode = input("1 — случайные данные, 2 — свой ввод, 3 — шаблон: ").strip()
    if mode in ("1", "2", "3"):
        break
    print("Выбери 1, 2 или 3.")

if mode == "1":
    subjects = ["Математика", "Русский", "Физика", "История"]
    raw_data = [
        random.choice(subjects) + " | " + str(random.randint(2, 5))
        for _ in range(10)
    ]
elif mode == "2":
    while True:
        try:
            n = int(input("Количество записей: ").strip())
            if n > 0:
                break
            print("Количество должно быть больше нуля.")
        except ValueError:
            print("Введи целое число.")

    raw_data = []
    for i in range(n):
        while True:
            row = input("Предмет | оценка: ").strip()
            try:
                parse_grades([row])
                raw_data.append(row)
                break
            except ValueError as error:
                print(error)

    raw_data = [row for row in raw_data]
elif mode == "3":
    raw_data = template[:]

grades = parse_grades(raw_data)

print("\n=== ШКОЛЬНЫЙ ЖУРНАЛ ===")
print("Средний балл:", round(calculate_average(grades), 2))
print("Лучшая оценка:", find_best_subject(grades))
print("Худшая оценка:", find_worst_subject(grades))
print("Частота оценок:", count_grades(grades))
import random
import time


def read_integer(prompt, minimum=None):
    while True:
        try:
            value = int(input(prompt).strip())
            if minimum is not None and value < minimum:
                print("Число должно быть не меньше", minimum)
                continue
            return value
        except ValueError:
            print("Введи целое число.")


def find_pairs_naive(prices, X):
    pairs = []
    seen = set()

    for i in range(len(prices)):
        for j in range(i + 1, len(prices)):
            if abs(prices[i] - prices[j]) == X:
                pair = (min(prices[i], prices[j]), max(prices[i], prices[j]))
                if pair not in seen:
                    seen.add(pair)
                    pairs.append(pair)

    return pairs


def find_pairs_optimized(prices, X):
    price_set = set(prices)
    pairs = set()

    if X == 0:
        counts = {}
        for price in prices:
            counts[price] = counts.get(price, 0) + 1
        for price, count in counts.items():
            if count >= 2:
                pairs.add((price, price))
    else:
        for price in price_set:
            if price + X in price_set:
                pairs.add((price, price + X))

    return sorted(pairs)


template = [100, 150, 200, 250, 250, 260, 350, 300]

while True:
    mode = input("1 — случайные данные, 2 — свой ввод, 3 — шаблон: ").strip()
    if mode in ("1", "2", "3"):
        break
    print("Выбери 1, 2 или 3.")

if mode == "1":
    n = read_integer("Количество цен: ", 1)
    prices = [random.randint(50, 1000) for _ in range(n)]
    X = read_integer("Разница X (неотрицательное число): ", 0)
elif mode == "2":
    while True:
        try:
            prices = [int(item) for item in input("Цены через пробел: ").split()]
            if not prices:
                print("Введи хотя бы одну цену.")
                continue
            break
        except ValueError:
            print("Цены должны быть целыми числами, разделёнными пробелами.")
    X = read_integer("Разница X (неотрицательное число): ", 0)
else:
    prices = template[:]
    X = 50

start = time.perf_counter()
pairs1 = find_pairs_naive(prices, X)
time1 = time.perf_counter() - start

start = time.perf_counter()
pairs2 = find_pairs_optimized(prices, X)
time2 = time.perf_counter() - start

print("\n=== УНИКАЛЬНЫЕ ПАРЫ ЦЕН ===")
print("Цены:", prices)
print("Разница X:", X)
print("Наивный алгоритм:", sorted(pairs1))
print("Оптимизированный алгоритм:", pairs2)
print(f"Время наивного: {time1:.8f} сек.")
print(f"Время оптимизированного: {time2:.8f} сек.")
print("Сложность наивного: O(N²).")
print("Сложность оптимизированного: O(N) в среднем.")
import random
import time


def read_integer(prompt, minimum=None):
    while True:
        try:
            value = int(input(prompt).strip())
            if minimum is not None and value < minimum:
                print("Число должно быть не меньше", minimum)
                continue
            return value
        except ValueError:
            print("Введи целое число.")


def decay(n, step, max_steps, path):
    path.append(n)

    if n < 10 or step >= max_steps:
        return step

    product = 1
    for digit in str(n):
        product *= int(digit)

    return decay(product, step + 1, max_steps, path)


def decay_loop(n, max_steps, path):
    step = 0

    while n >= 10 and step < max_steps:
        path.append(n)

        product = 1
        for digit in str(n):
            product *= int(digit)

        n = product
        step += 1

    path.append(n)
    return step


while True:
    mode = input("1 — случайные данные, 2 — свой ввод, 3 — шаблон: ").strip()
    if mode in ("1", "2", "3"):
        break
    print("Выбери 1, 2 или 3.")

if mode == "1":
    n = random.randint(10, 99999)
    limit = random.randint(5, 20)
elif mode == "2":
    n = read_integer("Введите неотрицательное целое число: ", 0)
    limit = read_integer("Лимит шагов: ", 0)
else:
    n = 39
    limit = 10

path_rec = []
start = time.perf_counter()
steps_rec = decay(n, 0, limit, path_rec)
time_rec = time.perf_counter() - start

path_loop = []
start = time.perf_counter()
steps_loop = decay_loop(n, limit, path_loop)
time_loop = time.perf_counter() - start

print("\n=== МОЛЕКУЛЯРНЫЙ РАСПАД ===")
print("Рекурсия:", " -> ".join(map(str, path_rec)))
print("Количество шагов:", steps_rec)
print("Цикл:", " -> ".join(map(str, path_loop)))
print("Количество шагов:", steps_loop)
print(f"Время рекурсии: {time_rec:.8f} сек.")
print(f"Время цикла: {time_loop:.8f} сек.")

if steps_rec == steps_loop and path_rec == path_loop:
    print("Проверка: результаты совпадают.")
else:
    print("Проверка: результаты различаются.")
import random


def get_digits(noise):
    for char in noise:
        if char.isdigit():
            yield char


template = "x7#b99!aL2@pQ5__%z1"

while True:
    mode = input("1 — случайные данные, 2 — свой ввод, 3 — шаблон: ").strip()
    if mode in ("1", "2", "3"):
        break
    print("Выбери 1, 2 или 3.")

if mode == "1":
    chars = "abcXYZ0123456789!#@%"
    noise = "".join(random.choice(chars) for _ in range(30))
elif mode == "2":
    noise = input("Введите зашумлённую строку: ")
else:
    noise = template

print("\n=== ДЕШИФРОВКА ===")
print("Исходный сигнал:", noise)
print("Найденные цифры:", "".join(get_digits(noise)))