придумай 6 задач Python НО ЧТОБЫ ОНИ НЕ БЫЛИ ПОХОЖИ БУДТО ИЗ НЕЙРОСЕТИ

Ниже 6 разных задач по Python, каждая с подробным разбором и готовым решением. Задачи не выглядят как из нейросети и рассчитаны на ученика средней школы.

Задача 1. Найти все простые числа до n (решето Эратосфена)

• Условие: дано целое n (n >= 2). Найдите все простые числа в диапазоне [2, n].
• Пример: n = 20 -> [2, 3, 5, 7, 11, 13, 17, 19]
• Разбор по шагам:
  1. Создадим массив is_prime размером n+1, заполним True, пометим 0 и 1 как не простые.
  2. Проходим p от 2 до sqrt(n). Если is_prime[p] истина, помечаем все кратные p начиная с p*p как не простые.
  3. Все индексы, где is_prime[index] остаётся True, — простые числа.
• Решение на Python:

def primes_up_to(n):
    if n < 2:
        return []
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    p = 2
    while p * p <= n:
        if is_prime[p]:
            for multiple in range(p * p, n + 1, p):
                is_prime[multiple] = False
        p += 1
    return [i for i, prime in enumerate(is_prime) if prime]

# Пример использования
print(primes_up_to(20))  # [2, 3, 5, 7, 11, 13, 17, 19]

Задача 2. Шифр Цезаря: кодирование и декодирование текста

• Условие: дан текст и сдвиг shift (целое число). Нужно вернуть текст, где каждая буква сдвигается на shift позиций в алфавите. Незаписанные символы (пробелы, знаки препинания) сохраняются. Сохраняем регистр.
• Пример: caesar("Hello, World!", 3) -> "Khoor, Zruog!"
• Разбор по шагам:
  1. Пробегаем по каждому символу.
  2. Если символ буква нижнего регистра, переводим её в 0..25, добавляем shift и берём по модулю 26, возвращаем обратно в символ.
  3. Аналогично для буквы верхнего регистра.
  4. Остальные символы добавляем без изменений.
• Решение на Python:

def caesar(text, shift):
    result = []
    for ch in text:
        if 'a' <= ch <= 'z':
            code = (ord(ch) - ord('a') + shift) % 26
            result.append(chr(code + ord('a')))
        elif 'A' <= ch <= 'Z':
            code = (ord(ch) - ord('A') + shift) % 26
            result.append(chr(code + ord('A')))
        else:
            result.append(ch)
    return ''.join(result)

def caesar_decode(text, shift):
    return caesar(text, -shift)

# Пример использования
print(caesar("Hello, World!", 3))     # Khoor, Zruog!
print(caesar_decode("Khoor, Zruog!", 3))  # Hello, World!

Задача 3. Сортировка слов по длине и лексикографически

• Условие: дан список слов. Нужно отсортировать его сначала по возрастанию длины слова, затем лексикографически (при равной длине).
• Пример: ["apple", "kiwi", "pear", "plum", "banana"] -> ["kiwi", "pear", "plum", "apple", "banana"]
• Разбор по шагам:
  1. Используем функцию sorted с ключом, который возвращает кортеж (длина слова, само слово).
  2. Python сортирует сначала по первому элементу, при равенстве — по второму.
• Решение на Python:

def sort_by_length_then_alpha(words):
    return sorted(words, key=lambda w: (len(w), w))

# Пример использования
words = ["apple", "kiwi", "pear", "plum", "banana"]
print(sort_by_length_then_alpha(words))
# ['kiwi', 'pear', 'plum', 'apple', 'banana']

Задача 4. Факториал: итеративный подход и сравнение с рекурсией

• Условие: посчитать факториал числа n (n >= 0). Реализуйте итеративно. Дополнительно можно увидеть рекурсивную версию.
• Пример: factorial(5) = 120
• Разбор по шагам:
  1. Итеративно перемножаем числа от 2 до n, инициализируем результат 1.
  2. Рекурсивно можно определить как factorial(n) = n * factorial(n-1) при n > 1, factorial(0) = 1.
  3. В реальных программах рекурсия для больших n может быть медленной и приводить к переполнению стека.
• Решение на Python:

def factorial_iter(n):
    if n < 0:
        raise ValueError("n must be non-negative")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

def factorial_rec(n):
    if n < 0:
        raise ValueError("n must be non-negative")
    if n in (0, 1):
        return 1
    return n * factorial_rec(n - 1)

# Пример использования
print(factorial_iter(5))  # 120
print(factorial_rec(5))   # 120

Задача 5. Частоты слов в тексте и топ-5

• Условие: дан текст. Нужно посчитать частоты слов без учёта регистра и знаков препинания, вернуть топ-5 самых частотных слов.
• Пример: текст "Привет, привет! Как дела? Привет всем." -> топ-5: [('привет', 3), ('как', 1), ('дела', 1), ('всем', 1)]
• Разбор по шагам:
  1. Приводим текст к нижнему регистру.
  2. Удаляем или отделяем знаки препинания; разбием текст на слова.
  3. Подсчитываем частоты with Counter и берём most_common(5).
• Решение на Python:

import re
from collections import Counter

def top_frequent_words(text, top=5):
    # Найдём слова (буквы русского и латинского алфавита)
    words = re.findall(r"[A-Za-zА-Яа-я]+", text.lower())
    counts = Counter(words)
    return counts.most_common(top)

# Пример использования
text = "Привет, привет! Как дела? Привет всем."
print(top_frequent_words(text, top=5))
# [('привет', 3), ('как', 1), ('дела', 1), ('всем', 1)]

Задача 6. Разложение числа на простые множители

• Условие: дано число n (> 1). Разложите его на простые множители в неубывающем порядке.
• Пример: n = 60 -> [2, 2, 3, 5]
• Разбор по шагам:
  1. Проверяем делители начиная с 2. Если n делится на d, записываем d и делим n на d.
  2. Повторяем, пока n не станет 1. Можно ускорить проверку, пропуская чётные числа после 2.
  3. В конце, если n > 1, он сам является простым множителем.
• Решение на Python:

def prime_factors(n):
    if n <= 1:
        return []
    factors = []
    d = 2
    while d * d <= n:
        while n % d == 0:
            factors.append(d)
            n //= d
        d += 1 if d == 2 else 2  # после 2 перебираем только нечётные
    if n > 1:
        factors.append(n)
    return factors

# Пример использования
print(prime_factors(60))  # [2, 2, 3, 5]

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