1. Подсчет гласных букв в строке

def count_vowels(text):
    """
    Подсчитывает количество гласных букв в строке
    """
    vowels = "aeiouаеёиоуыэюя"  # Английские и русские гласные
    count = 0
    
    # Приводим текст к нижнему регистру для унификации
    text_lower = text.lower()
    
    # Проверяем каждый символ
    for char in text_lower:
        if char in vowels:
            count += 1
            
    return count

# Пример использования
text = "Hello, World! Привет, мир!"
print(f"Гласных букв: {count_vowels(text)}")

2. Проверка на палиндром

def is_palindrome(text):
    """
    Проверяет, является ли строка палиндромом
    """
    # Удаляем пробелы и приводим к нижнему регистру
    cleaned_text = ''.join(char.lower() for char in text if char.isalnum())
    
    # Сравниваем строку с её обратным представлением
    return cleaned_text == cleaned_text[::-1]

# Пример использования
print(is_palindrome("А роза упала на лапу Азора"))  # True
print(is_palindrome("Hello"))  # False

3. Подсчет слов в строке

def count_words(text):
    """
    Подсчитывает количество слов в строке
    """
    # Разделяем строку по пробелам
    words = text.split()
    
    # Удаляем пустые строки (если есть множественные пробелы)
    words = [word for word in words if word.strip()]
    
    return len(words)

# Пример использования
text = "Python — высокоуровневый язык программирования"
print(f"Количество слов: {count_words(text)}")

4. Инвертирование строки

def reverse_string(text):
    """
    Возвращает строку в обратном порядке
    """
    # Способ 1: Используем срез
    return text[::-1]

def reverse_string_manual(text):
    """
    Инвертирование строки вручную (для понимания алгоритма)
    """
    reversed_text = ""
    
    # Проходим по строке с конца
    for i in range(len(text) - 1, -1, -1):
        reversed_text += text[i]
        
    return reversed_text

# Пример использования
text = "Python"
print(f"Инвертированная строка: {reverse_string(text)}")
print(f"Инвертированная строка (вручную): {reverse_string_manual(text)}")

5. Поиск самого длинного слова

def find_longest_word(text):
    """
    Находит самое длинное слово в строке
    """
    # Удаляем знаки препинания и разбиваем на слова
    import string
    translator = str.maketrans('', '', string.punctuation)
    cleaned_text = text.translate(translator)
    
    words = cleaned_text.split()
    
    # Находим слово с максимальной длиной
    if not words:
        return ""
    
    return max(words, key=len)

# Пример использования
text = "Я изучаю программирование на Python"
print(f"Самое длинное слово: {find_longest_word(text)}")

6. Подсчет повторений символов

def count_characters(text):
    """
    Подсчитывает частоту каждого символа в строке
    """
    char_count = {}
    
    for char in text:
        # Игнорируем пробелы (можно настроить)
        if char != ' ':
            char_count[char] = char_count.get(char, 0) + 1
            
    return char_count

# Пример использования
text = "программирование"
result = count_characters(text)
for char, count in sorted(result.items()):
    print(f"'{char}': {count}")

7. Удаление дубликатов символов

def remove_duplicates(text):
    """
    Удаляет повторяющиеся символы из строки
    """
    seen = set()
    result = []
    
    for char in text:
        if char not in seen:
            seen.add(char)
            result.append(char)
            
    return ''.join(result)

# Пример использования
text = "программирование"
print(f"Без дубликатов: {remove_duplicates(text)}")

8. Проверка на анаграмму

def is_anagram(str1, str2):
    """
    Проверяет, являются ли строки анаграммами
    """
    # Удаляем пробелы и приводим к нижнему регистру
    str1_clean = ''.join(str1.lower().split())
    str2_clean = ''.join(str2.lower().split())
    
    # Сравниваем отсортированные символы
    return sorted(str1_clean) == sorted(str2_clean)

# Пример использования
print(is_anagram("listen", "silent"))  # True
print(is_anagram("python", "typhon"))  # True

9. Шифр Цезаря

def caesar_cipher(text, shift):
    """
    Шифрует текст шифром Цезаря
    """
    result = ""
    
    for char in text:
        if char.isalpha():  # Если символ - буква
            # Определяем базовый код в зависимости от регистра
            base = ord('A') if char.isupper() else ord('a')
            # Сдвигаем символ
            shifted_char = chr((ord(char) - base + shift) % 26 + base)
            result += shifted_char
        else:
            result += char
            
    return result

# Пример использования
text = "Hello, World!"
shift = 3
encrypted = caesar_cipher(text, shift)
print(f"Зашифровано: {encrypted}")
decrypted = caesar_cipher(encrypted, -shift)
print(f"Расшифровано: {decrypted}")

10. Форматирование телефонного номера

def format_phone_number(number):
    """
    Форматирует телефонный номер в стандартный вид
    """
    # Удаляем все нецифровые символы
    digits = ''.join(filter(str.isdigit, str(number)))
    
    # Проверяем длину номера
    if len(digits) == 11 and digits[0] == '8':
        digits = '7' + digits[1:]
    
    # Форматируем номер
    if len(digits) == 10:
        return f"+7 ({digits[:3]}) {digits[3:6]}-{digits[6:8]}-{digits[8:]}"
    elif len(digits) == 11:
        return f"+{digits[0]} ({digits[1:4]}) {digits[4:7]}-{digits[7:9]}-{digits[9:]}"
    else:
        return "Неверный формат номера"

# Пример использования
print(format_phone_number("89161234567"))
print(format_phone_number("+7 (916) 123-45-67"))

11. Поиск email-адресов в тексте

import re

def find_emails(text):
    """
    Находит все email-адреса в тексте
    """
    # Регулярное выражение для поиска email
    pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
    
    # Ищем все совпадения
    emails = re.findall(pattern, text)
    
    return emails

# Пример использования
text = """
Контакты: info@company.com, support@site.ru,
sales-department@company.org, not_an_email@
"""
emails = find_emails(text)
print("Найденные email:")
for email in emails:
    print(f"  - {email}")

12. Удаление HTML-тегов

import re

def remove_html_tags(text):
    """
    Удаляет HTML-теги из строки
    """
    # Регулярное выражение для поиска HTML-тегов
    clean = re.compile('<.*?>')
    
    # Удаляем теги
    cleaned_text = re.sub(clean, '', text)
    
    return cleaned_text

# Пример использования
html = "<h1>Заголовок</h1><p>Это <b>текст</b> с тегами.</p>"
print(f"Без тегов: {remove_html_tags(html)}")

13. Кодирование строки в Base64

import base64

def encode_base64(text):
    """
    Кодирует строку в Base64
    """
    # Преобразуем строку в байты
    text_bytes = text.encode('utf-8')
    
    # Кодируем в Base64
    encoded_bytes = base64.b64encode(text_bytes)
    
    # Возвращаем как строку
    return encoded_bytes.decode('utf-8')

def decode_base64(encoded_text):
    """
    Декодирует строку из Base64
    """
    # Декодируем
    decoded_bytes = base64.b64decode(encoded_text)
    
    # Возвращаем как строку
    return decoded_bytes.decode('utf-8')

# Пример использования
text = "Секретное сообщение"
encoded = encode_base64(text)
print(f"Закодировано: {encoded}")
decoded = decode_base64(encoded)
print(f"Раскодировано: {decoded}")

14. Подсчет смайликов в тексте

def count_smileys(text):
    """
    Подсчитывает количество смайликов в тексте
    """
    # Определяем паттерны смайликов
    smiley_patterns = [
        ':)', ':(', ':D', ':P', ';)', ':O',
        ':-)', ':-D', ':-P', ';-)',
        '🙂', '😀', '😂', '😊', '😎'
    ]
    
    count = 0
    for pattern in smiley_patterns:
        count += text.count(pattern)
    
    return count

# Пример использования
text = "Привет! :) Как дела? 😊 Сегодня отличный день! :-D"
print(f"Найдено смайликов: {count_smileys(text)}")

15. Проверка корректности скобок

def check_brackets(text):
    """
    Проверяет корректность расстановки скобок
    """
    stack = []
    bracket_pairs = {')': '(', ']': '[', '}': '{'}
    
    for char in text:
        if char in '([{':  # Открывающая скобка
            stack.append(char)
        elif char in ')]}':  # Закрывающая скобка
            if not stack:  # Если стек пуст
                return False
            if stack.pop() != bracket_pairs[char]:
                return False
    
    # Если после обработки стек пуст - все скобки закрыты
    return len(stack) == 0

# Пример использования
expressions = [
    "(a + b) * (c - d)",  # True
    "[(a + b) * c]",      # True
    "((a + b) * c",       # False
    ")a + b(",            # False
]

for expr in expressions:
    print(f"{expr}: {check_brackets(expr)}")

16. Удаление лишних пробелов

def normalize_spaces(text):
    """
    Удаляет лишние пробелы из строки
    """
    # Заменяем множественные пробелы на один
    import re
    normalized = re.sub(r'\s+', ' ', text)
    
    # Удаляем пробелы в начале и конце
    normalized = normalized.strip()
    
    return normalized

# Пример использования
text = "   Python   —   язык   программирования   "
print(f"Нормализовано: '{normalize_spaces(text)}'")

17. Транслитерация

def transliterate(text):
    """
    Транслитерирует русский текст в латиницу
    """
    translit_dict = {
        'а': 'a', 'б': 'b', 'в': 'v', 'г': 'g', 'д': 'd',
        'е': 'e', 'ё': 'yo', 'ж': 'zh', 'з': 'z', 'и': 'i',
        'й': 'y', 'к': 'k', 'л': 'l', 'м': 'm', 'н': 'n',
        'о': 'o', 'п': 'p', 'р': 'r', 'с': 's', 'т': 't',
        'у': 'u', 'ф': 'f', 'х': 'kh', 'ц': 'ts', 'ч': 'ch',
        'ш': 'sh', 'щ': 'shch', 'ъ': '', 'ы': 'y', 'ь': '',
        'э': 'e', 'ю': 'yu', 'я': 'ya'
    }
    
    result = []
    
    for char in text.lower():
        if char in translit_dict:
            result.append(translit_dict[char])
        else:
            result.append(char)
    
    return ''.join(result)

# Пример использования
text = "Привет, мир!"
print(f"Транслитерация: {transliterate(text)}")

18. Поиск подстроки (алгоритм КМП)

def kmp_search(text, pattern):
    """
    Поиск подстроки с использованием алгоритма Кнута-Морриса-Пратта
    """
    # Функция для создания префикс-функции
    def compute_prefix(pattern):
        prefix = [0] * len(pattern)
        j = 0
        
        for i in range(1, len(pattern)):
            while j > 0 and pattern[i] != pattern[j]:
                j = prefix[j - 1]
            
            if pattern[i] == pattern[j]:
                j += 1
            
            prefix[i] = j
        
        return prefix
    
    if not pattern:
        return []
    
    # Вычисляем префикс-функцию
    prefix = compute_prefix(pattern)
    
    result = []
    j = 0
    
    for i in range(len(text)):
        while j > 0 and text[i] != pattern[j]:
            j = prefix[j - 1]
        
        if text[i] == pattern[j]:
            j += 1
        
        if j == len(pattern):
            result.append(i - j + 1)
            j = prefix[j - 1]
    
    return result

# Пример использования
text = "ababcabcabababd"
pattern = "ababd"
print(f"Найденные позиции: {kmp_search(text, pattern)}")

19. Генератор случайных строк

import random
import string

def generate_random_string(length=10, include_digits=True, include_special=False):
    """
    Генерирует случайную строку заданной длины
    """
    # Определяем набор символов
    characters = string.ascii_letters  # Буквы
    
    if include_digits:
        characters += string.digits  # Цифры
    
    if include_special:
        characters += string.punctuation  # Спецсимволы
    
    # Генерируем случайную строку
    return ''.join(random.choice(characters) for _ in range(length))

# Пример использования
print(f"Случайная строка: {generate_random_string(12)}")
print(f"С паролем: {generate_random_string(8, True, True)}")

20. Анализатор текста

def text_analyzer(text):
    """
    Анализирует текст и выводит статистику
    """
    # Удаляем лишние пробелы
    text = ' '.join(text.split())
    
    # Основная статистика
    stats = {
        'total_chars': len(text),
        'chars_without_spaces': len(text.replace(' ', '')),
        'word_count': len(text.split()),
        'sentence_count': text.count('.') + text.count('!') + text.count('?'),
        'avg_word_length': 0
    }
    
    # Вычисляем среднюю длину слова
    words = text.split()
    if words:
        stats['avg_word_length'] = sum(len(word) for word in words) / len(words)
    
    return stats

# Пример использования
text = "Python — это мощный язык программирования. Он прост в изучении!"
analysis = text_analyzer(text)

for key, value in analysis.items():
    print(f"{key}: {value}")

Методика решения строковых задач

Общие подходы:

1. Анализ задачи: Определить, что требуется сделать
2. Выбор метода: Выбрать подходящие строковые методы или алгоритмы
3. Обработка граничных случаев: Учесть пустые строки, регистр, пробелы
4. Тестирование: Проверить на различных входных данных

Полезные методы Python для работы со строками:

• str.split() - разбиение строки
• str.join() - объединение списка в строку
• str.find(), str.index() - поиск подстроки
• str.replace() - замена подстрок
• str.lower(), str.upper() - изменение регистра
• str.strip() - удаление пробелов
• str.startswith(), str.endswith() - проверка начала/конца

Оптимизация:

• Используйте генераторы списков для преобразований
• Применяйте join() вместо конкатенации в циклах
• Используйте регулярные выражения для сложных поисков
• Кэшируйте результаты при многократных вычислениях

Эти задачи покрывают основные аспекты работы со строками и помогут закрепить навыки программирования на Python.