Задачи на строки в Python с решениями, часть 2

Задачи на строки Python из этой подборки помогут закрепить срезы, методы split(), count(), find(), replace() и работу со словарями при подсчете символов. Каждое упражнение дано с условием, коротким разбором и готовым кодом, который можно сразу запустить. Если какие-то методы пока незнакомы, сначала посмотрите справочник методов строк, а простые задания есть в первой части.

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

В языке программирования Python строки представляют собой последовательности символов, заключенные в кавычки. Одинарные (' ') и двойные (" ") кавычки в Python используются для обозначения строк.

Python предоставляет множество возможностей для работы со строками. Вы можете выполнять операции конкатенации (объединения), извлечения подстроки по индексам, разделения строки на подстроки, замены символов и многое другое.

Кроме того, в Python доступен широкий спектр методов для работы со строками, таких как методы для поиска подстроки, удаления пробельных символов, изменения регистра символов и многих других функций.

Задача 1. Реверс строки

Необходимо написать программу на Python, которая будет принимать строку от пользователя и выводить её в обратном порядке символов.

Решение:

Для решения данной задачи используется простой и эффективный подход с использованием срезов в Python. Сначала программа запрашивает у пользователя ввод строки. Затем с помощью среза строки вида [::-1] получаем строку, записанную в обратном порядке. Наконец, выводим полученную строку на экран.

# Запрос ввода строки у пользователя
input_string = input("Введите строку: ")
# Используем срез для переворота строки и выводим результат
reversed_string = input_string[::-1]
print("Результат:", reversed_string)

Задача 2. Подсчет количества слов в строке

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя строку и подсчитывает количество слов в этой строке.

Решение:

Для решения данной задачи мы будем использовать метод split() для разделения строки на отдельные слова. Затем просто посчитаем количество полученных слов и выведем результат на экран.

# Запрашиваем у пользователя ввод строки
input_string = input("Введите строку: ")
# Используем метод split() для разделения строки на слова
words = input_string.split()
# Подсчитываем количество слов
word_count = len(words)
# Выводим результат
print(f"Количество слов в строке: {word_count}")

Эта программа на Python легко подсчитывает количество слов в любой введенной строке. Теперь вы можете быстро и удобно определить количество слов в любом тексте!

Задача 3. Поиск самого длинного слова в строке

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя строку и находит самое длинное слово в этой строке.

Решение:

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

# Запрашиваем у пользователя ввод строки
input_string = input("Введите строку: ")
# Используем метод split() для разделения строки на слова
words = input_string.split()
# Инициализируем переменную для хранения самого длинного слова
longest_word = ""
# Находим самое длинное слово
for word in words:
    if len(word) > len(longest_word):
        longest_word = word
# Выводим результат
print(f"Самое длинное слово в строке: {longest_word}")

Эта программа на Python позволяет быстро и легко найти самое длинное слово в любой введенной строке. Теперь вы можете проводить анализ текстов и находить ключевые слова с помощью этой программы!

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

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя строку и подстроку, а затем подсчитывает количество вхождений подстроки в данной строке.

Решение:

Для решения данной задачи мы будем использовать метод count() для подсчета количества вхождений подстроки в строку.

# Запрашиваем у пользователя ввод строки и подстроки
input_string = input("Введите строку: ")
substring = input("Введите подстроку: ")
# Используем метод count() для подсчета вхождений подстроки в строку
count = input_string.count(substring)
# Выводим результат
print(f"Количество вхождений подстроки в строку: {count}")

Эта программа на Python легко и быстро позволяет находить количество вхождений указанной подстроки в любой введенной строке. Теперь вы сможете эффективно анализировать тексты и находить нужные вхождения с помощью этой программы!

Задача 5. Поиск уникальных слов в строке

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя строку и выводит список уникальных слов, которые содержатся в этой строке.

Решение:

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

# Запрашиваем у пользователя ввод строки
input_string = input("Введите строку: ")
# Используем метод split() для разделения строки на слова
words = input_string.split()
# Создаем множество уникальных слов
unique_words = set(words)
# Выводим список уникальных слов
print("Уникальные слова в строке:")
for word in unique_words:
    print(word)

Множество не сохраняет порядок слов. Если порядок важен, используйте dict.fromkeys(words): словарь хранит ключи в порядке добавления.

Задача 6. Проверка на анаграммы

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя две строки и определяет, являются ли они анаграммами.

Решение:

Для решения данной задачи мы можем использовать сортировку символов в строках и сравнение отсортированных строк.

# Запрашиваем у пользователя ввод двух строк
string1 = input("Введите первую строку: ")
string2 = input("Введите вторую строку: ")
# Убираем пробелы и приводим строки к нижнему регистру для удобства сравнения
string1 = string1.replace(" ", "").lower()
string2 = string2.replace(" ", "").lower()
# Сортируем символы в строках
sorted_string1 = sorted(string1)
sorted_string2 = sorted(string2)
# Проверяем, являются ли строки анаграммами
if sorted_string1 == sorted_string2:
    print("Введенные строки являются анаграммами.")
else:
    print("Введенные строки не являются анаграммами.")

Эта программа на Python позволяет быстро и легко проверить, являются ли две введенные строки анаграммами. Теперь вы сможете проводить анализ текстов и определять анаграммы с помощью этой программы!

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

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя строку и подсчитывает количество гласных и согласных букв в этой строке.

Решение:

Для решения данной задачи мы будем использовать цикл для перебора символов в строке и проверку на принадлежность к гласным или согласным буквам.

# Запрашиваем у пользователя ввод строки
input_string = input("Введите строку: ")
# Приводим строку к нижнему регистру для удобства подсчета
input_string = input_string.lower()
# Инициализируем счетчики для гласных и согласных букв
vowels = 0
consonants = 0
# Перебираем символы в строке и подсчитываем гласные и согласные буквы
for char in input_string:
    if char.isalpha():
        if char in 'aeiouаеёиоуыэюя':
            vowels += 1
        else:
            consonants += 1
# Выводим результат
print(f"Количество гласных букв: {vowels}")
print(f"Количество согласных букв: {consonants}")

Эта программа на Python позволяет быстро и легко подсчитать количество гласных и согласных букв в любой введенной строке. Теперь вы можете проводить анализ текстов и изучать распределение букв с помощью этой программы!

Задача 8. Проверка на палиндром

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя строку и определяет, является ли эта строка палиндромом.

Решение:

Для решения данной задачи мы можем использовать сравнение строки с её обратной версией.

# Запрашиваем у пользователя ввод строки
input_string = input("Введите строку: ")
# Убираем пробелы и приводим строку к нижнему регистру для удобства сравнения
input_string = input_string.replace(" ", "").lower()
# Сравниваем строку с ее обратной версией
if input_string == input_string[::-1]:
    print("Введенная строка является палиндромом.")
else:
    print("Введенная строка не является палиндромом.")

Эта программа на Python позволяет быстро и легко проверить, является ли введенная строка палиндромом. Теперь вы можете проводить анализ текстов и определять палиндромы с помощью этой программы!

Задача 9. Подсчет количества цифр в строке

Цель этой задачи - написать программу на Python, которая запрашивает у пользователя строку и подсчитывает количество цифр в этой строке.

Решение:

Для решения данной задачи мы будем использовать метод isdigit() для проверки каждого символа строки на то, является ли он цифрой.

# Запрашиваем у пользователя ввод строки
input_string = input("Введите строку: ")
# Инициализируем счетчик для цифр
digit_count = 0
# Перебираем символы в строке и подсчитываем количество цифр
for char in input_string:
    if char.isdigit():
        digit_count += 1
# Выводим результат
print(f"Количество цифр в строке: {digit_count}")

Эта программа на Python позволяет быстро и легко подсчитать количество цифр в любой введенной строке. Теперь вы можете анализировать тексты и изучать распределение цифр с помощью этой программы!

Задача 10. Поиск наибольшей общей подстроки

Цель этой задачи - написать программу на Python, которая находит наибольшую общую подстроку у двух заданных строк.

Решение:

Для решения данной задачи мы можем воспользоваться алгоритмом поиска наибольшей общей подстроки, например методом динамического программирования.

def longest_common_substring(s1, s2):
    m = len(s1)
    n = len(s2)
    # Создаем матрицу для хранения результатов промежуточных подстрок
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    max_length = 0  # Длина наибольшей общей подстроки
    end_index = 0  # Индекс конца наибольшей общей подстроки
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
                if dp[i][j] > max_length:
                    max_length = dp[i][j]
                    end_index = i
    return s1[end_index - max_length: end_index]
# Пример использования
s1 = "abcdefg"
s2 = "xbcdyz"
result = longest_common_substring(s1, s2)
print("Наибольшая общая подстрока:", result)

Этот код позволяет найти наибольшую общую подстроку у двух заданных строк. Вы можете использовать эту программу для сравнения текстов и нахождения общих подстрок.

Задача 11. Проверка на анаграммы

Цель этой задачи - написать программу на Python, которая определяет, являются ли две введенные пользователем строки анаграммами друг друга.

Решение:

def is_anagram(s1, s2):
    # Убираем пробелы и приводим строки к нижнему регистру для удобства сравнения
    s1 = s1.replace(" ", "").lower()
    s2 = s2.replace(" ", "").lower()
    # Сортируем символы в обеих строках
    sorted_s1 = sorted(s1)
    sorted_s2 = sorted(s2)
    # Проверяем, являются ли отсортированные строки идентичными
    return sorted_s1 == sorted_s2
# Пример использования
string1 = "listen"
string2 = "silent"
if is_anagram(string1, string2):
    print(f"{string1} и {string2} - анаграммы.")
else:
    print(f"{string1} и {string2} - не анаграммы.")

Этот код позволяет проверить, являются ли две введенные пользователем строки анаграммами. Вы можете использовать эту программу для сравнения слов и проверки их на наличие анаграмм.

Задача 12. Поиск всех вхождений подстроки в строку

Цель этой задачи - написать программу на Python, которая находит все вхождения заданной подстроки в исходной строке.

Решение:

Для решения данной задачи мы можем использовать метод find() для поиска вхождений подстроки или написать собственную функцию для более гибкого поиска.

def find_all_occurrences(main_string, sub_string):
    start = 0
    while start < len(main_string):
        pos = main_string.find(sub_string, start)
        if pos == -1:
            break
        print(f"Найдено вхождение на позиции {pos}")
        start = pos + 1
# Пример использования
main_str = "abracadabra"
sub_str = "abra"
print(f"Ищем вхождения подстроки '{sub_str}' в строке '{main_str}':")
find_all_occurrences(main_str, sub_str)

Этот код позволяет находить все вхождения заданной подстроки в исходной строке. Вы можете использовать эту программу для анализа текстов и поиска повторяющихся фрагментов.

Задача 13. Замена подстроки

Цель этой задачи - написать программу на Python, которая заменяет все вхождения заданной подстроки на новую подстроку в исходной строке.

Решение:

Для решения данной задачи мы можем использовать метод replace() для замены подстроки или написать собственную функцию для более гибкой замены.

def replace_substring(main_string, old_substring, new_substring):
    modified_string = main_string.replace(old_substring, new_substring)
    return modified_string
# Пример использования
original_string = "The quick brown fox jumps over the lazy dog"
old_sub = "fox"
new_sub = "cat"
result = replace_substring(original_string, old_sub, new_sub)
print(f"Результат замены: {result}")

Этот код позволяет осуществить замену всех вхождений заданной подстроки на новую подстроку в исходной строке. Вы можете использовать эту программу для обработки текстов и замены определенных фрагментов.

Задача 14. Поиск повторяющихся символов

Цель этой задачи - написать программу на Python, которая находит все повторяющиеся символы в заданной строке.

Решение:

Для решения данной задачи мы можем использовать словарь для отслеживания количества вхождений каждого символа.

def find_duplicate_characters(input_string):
    char_count = {}
    duplicates = []
    for char in input_string:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    for char, count in char_count.items():
        if count > 1:
            duplicates.append(char)
    return duplicates
# Пример использования
input_str = "hello"
result = find_duplicate_characters(input_str)
if result:
    print(f"Повторяющиеся символы в строке '{input_str}': {', '.join(result)}")
else:
    print("Нет повторяющихся символов в строке.")

Этот код позволяет найти все повторяющиеся символы в заданной строке. Вы можете использовать эту программу для обнаружения повторяющихся символов в тексте или строках данных.

Задача 15. Поиск самого длинного слова в строке

Цель этой задачи - написать программу на Python, которая находит самое длинное слово в заданной строке.

Решение:

Для решения данной задачи мы можем использовать разделение строки на слова и поиск самого длинного из них.

def find_longest_word(input_string):
    words = input_string.split()  # Разделяем строку на слова
    longest_word = max(words, key=len)  # Находим самое длинное слово по длине
    
    return longest_word
# Пример использования
input_str = "The quick brown fox jumped over the lazy dog"
longest_word = find_longest_word(input_str)
print(f"Самое длинное слово в строке: {longest_word}")

Этот код позволяет найти самое длинное слово в заданной строке. Вы можете использовать эту программу для анализа текстов и поиска самых длинных слов.

Задача 16. Подсчет количества слов в строке

Цель этой задачи - написать программу на Python, которая подсчитывает количество слов во введенной пользователем строке.

Решение:

Для решения этой задачи мы можем использовать метод split() для разделения строки на слова и подсчет полученного списка слов.

def count_words(input_string):
    words = input_string.split()
    return len(words)
# Пример использования
input_str = "Python is a powerful programming language"
word_count = count_words(input_str)
print(f"Количество слов в строке: {word_count}")

Этот код позволяет подсчитать количество слов во введенной пользователем строке. Вы можете использовать эту программу для анализа текста и определения количества слов.

Задача 17. Поиск подстроки в строке

Напишите функцию, которая возвращает список позиций всех вхождений подстроки в строку, включая пересекающиеся.

Решение:

Для решения данной задачи мы можем использовать метод find() для поиска первого вхождения и написать свою функцию для поиска всех вхождений.

def find_substrings(main_string, substring):
    matches = []
    start = 0
    while start < len(main_string):
        start = main_string.find(substring, start)
        if start == -1:
            break
        matches.append(start)
        start += 1
    return matches
# Пример использования
input_str = "abracadabra cadabra"
substring = "cadabra"
positions = find_substrings(input_str, substring)
if positions:
    print(f"Подстрока '{substring}' найдена в позициях: {positions}")
else:
    print(f"Подстрока '{substring}' не найдена.")

Этот код позволяет найти все вхождения заданной подстроки в исходной строке. Вы можете использовать эту программу для поиска конкретных фрагментов в текстах или данных.

Задача 18. Сжатие строки по длинам серий

Напишите функцию, которая заменяет подряд идущие одинаковые символы на символ и число повторов: строка aaabccdddd превращается в a3b1c2d4. Такой прием называют RLE-сжатием, его спрашивают на собеседованиях для проверки работы с индексами.

Решение:

Проходим по строке и считаем длину текущей серии. Когда символ меняется, записываем пару "символ + счетчик" и начинаем новую серию. Куски собираем в список и склеиваем через join(), так быстрее, чем многократное сложение строк.

def rle(text):
    if not text:
        return ""
    parts = []
    count = 1
    for prev, cur in zip(text, text[1:]):
        if cur == prev:
            count += 1
        else:
            parts.append(f"{prev}{count}")
            count = 1
    parts.append(f"{text[-1]}{count}")
    return "".join(parts)

print(rle("aaabccdddd"))  # a3b1c2d4

Тот же результат дает itertools.groupby: "".join(f"{ch}{len(list(g))}" for ch, g in groupby(text)).

Задача 19. Частота каждой буквы

Пользователь вводит текст. Выведите три самые частые буквы и сколько раз каждая встретилась, без учета регистра, пробелов и знаков препинания.

Решение:

Оставляем только буквы через isalpha(), приводим к нижнему регистру и считаем через Counter из модуля collections. Метод most_common(n) сразу возвращает пары, отсортированные по убыванию частоты.

from collections import Counter

text = input("Введите текст: ")
letters = Counter(ch for ch in text.lower() if ch.isalpha())
for letter, n in letters.most_common(3):
    print(letter, n)

# Ввод: Мама мыла раму
# м 4
# а 4
# ы 1

Задача 20. Шифр Цезаря для русского алфавита

Напишите функцию, которая сдвигает каждую русскую букву на k позиций по алфавиту, сохраняя регистр. Остальные символы остаются без изменений. Для расшифровки достаточно вызвать функцию с отрицательным сдвигом.

Решение:

Алфавит храним строкой из 33 букв, позицию буквы находим через find(), а выход за конец алфавита обрабатываем остатком от деления.

ABC = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"

def caesar(text, k):
    result = []
    for ch in text:
        i = ABC.find(ch.lower())
        if i == -1:
            result.append(ch)
            continue
        new = ABC[(i + k) % len(ABC)]
        result.append(new.upper() if ch.isupper() else new)
    return "".join(result)

code = caesar("Привет, мир!", 3)
print(code)               # Тулезх, плу!
print(caesar(code, -3))   # Привет, мир!

Частые вопросы

Ответы на вопросы, которые чаще всего возникают при решении этих упражнений.

Почему строку нельзя изменить по индексу?

Строки в Python неизменяемые: запись s[0] = "A" вызовет TypeError. Нужно собрать новую строку, например "A" + s[1:], или превратить строку в список, поменять элемент и склеить обратно через "".join().

Чем find() отличается от index()?

Оба метода возвращают позицию первого вхождения подстроки. Если подстроки нет, find() вернет -1, а index() выбросит ValueError. Для проверки наличия проще всего использовать оператор in.

Почему count() находит меньше вхождений, чем цикл с find()?

Метод count() считает только непересекающиеся вхождения: в строке "aaaa" подстрока "aa" найдется 2 раза. Цикл из задачи 12 сдвигает начало поиска на один символ и находит 3 вхождения, включая пересекающиеся.

Как быстрее всего склеить много строк?

Соберите части в список и вызовите "".join(parts). Сложение через += в цикле каждый раз создает новую строку, на больших объемах это заметно медленнее.