Python: Самая длинная подстрока
Реализуйте функцию find_longest_length() , принимающую на вход строку и возвращающую длину максимальной последовательности из неповторяющихся символов. Подстрока может состоять из одного символа. Например в строке qweqrty , можно выделить следующие подстроки: qwe , weqrty . Самой длинной будет weqrty , а её длина — 6 символов.
Для полного доступа к испытанию нужен базовый план
Базовый план откроет полный доступ ко всем курсам, упражнениям и урокам Хекслета, проектам и пожизненный доступ к теории пройденных уроков. Подписку можно отменить в любой момент.
click fraud protection
Процесс поиска самой длинной общей подпоследовательности:
Самый простой процесс поиска самой длинной общей подпоследовательности состоит в том, чтобы проверить каждый символ строки 1 и найти то же самое. последовательность в строке 2, проверяя каждый символ строки 2 один за другим, чтобы увидеть, является ли какая-либо подстрока общей в обеих строках. струны. Например, предположим, что у нас есть строка 1 «st1» и строка 2 «st2» с длинами a и b соответственно. Проверьте все подстроки «st1» и начните перебирать «st2», чтобы проверить, существует ли какая-либо подстрока «st1» как «st2». Начните с сопоставления подстроки длины 2 и увеличения длины на 1 на каждой итерации, доводя до максимальной длины строк.
Пример 1:
Этот пример посвящен поиску самой длинной общей подстроки с повторяющимися символами. Python предоставляет простые встроенные методы для выполнения любых функций. В приведенном ниже примере мы предоставили самый простой способ найти самую длинную общую подпоследовательность в двух строках. Комбинация циклов for и while используется для получения самой длинной общей подстроки в строке. Взгляните на пример, приведенный ниже:
ответ = Максимум ( ответ , к ) ;
возвращение ответ ;
если __название__ == ‘__главный__’ :
А = АББААБ
Б = ‘БАБААБ’
я = Лен ( А )
Дж = Лен ( Б )
Распечатать ( ‘Самая длинная общая подстрока в строке’ , LongComSubS ( А , Б ) )
Следующий вывод будет получен после выполнения вышеуказанного кода. Он найдет самую длинную общую подстроку и выдаст вам результат.
Пример 2:
Другой способ найти самую длинную общую подстроку — использовать итеративный подход. Цикл for используется для итерации, а условие if соответствует общей подстроке.
деф LongComSubS ( А , Б , м , н ) :
макслен = 0
endIndex = м
НАЙТИ = [ [ 0 за Икс в диапазон ( п + 1 ) ] за у в диапазон ( м + 1 ) ]
за я в диапазон ( 1 , м + 1 ) :
за Дж в диапазон ( 1 , п + 1 ) :
если А [ я — 1 ] == Б [ дж — 1 ] :
НАЙТИ [ я ] [ Дж ] = НАЙТИ [ я — 1 ] [ дж — 1 ] + 1
если НАЙТИ [ я ] [ Дж ] > максДлен:
макслен = НАЙТИ [ я ] [ Дж ]
endIndex = я
возвращение Икс [ endIndex — maxLen: endIndex ]
если __название__ == ‘__главный__’ :
А = АББААБ
Б = ‘БАБААБ’
я = Лен ( А )
Дж = Лен ( Б )
Распечатать ( ‘Самая длинная общая подстрока в строке’ , LongComSubS ( А , Б , я , Дж ) )
Выполните приведенный выше код в любом интерпретаторе Python, чтобы получить желаемый результат. Однако мы использовали инструмент Spyder для выполнения программы поиска самой длинной общей подстроки в строке. Вот вывод приведенного выше кода:
Пример 3:
Вот еще один пример, который поможет вам найти самую длинную общую подстроку в строке, используя кодирование Python. Этот метод является самым маленьким, простым и легким способом найти самую длинную общую подпоследовательность. Взгляните на пример кода, приведенный ниже:
деф _итер ( ) :
за а , б в молния ( ст1 , ст2 ) :
если а == б:
урожай а
еще :
возвращение
возвращение » . присоединиться ( _итер ( ) )
если __название__ == ‘__главный__’ :
А = АББААБ
Б = ‘БАБААБ’
Распечатать ( ‘Самая длинная общая подстрока в строке’ , LongComSubS ( А , Б ) )
Ниже вы можете найти вывод кода, приведенного выше.
Используя этот метод, мы вернули не общую подстроку, а длину этой общей подстроки. Чтобы помочь вам получить желаемый результат, мы показали как результаты, так и методы получения этих результатов.
Временная сложность и пространственная сложность для нахождения самой длинной общей подстроки
За выполнение или выполнение любой функции нужно платить; временная сложность является одной из этих затрат. Временная сложность любой функции рассчитывается путем анализа того, сколько времени может потребоваться для выполнения оператора. Следовательно, чтобы найти все подстроки в «st1», нам нужно O (a ^ 2), где «a» — длина «st1», а «O» — символ временной сложности. Однако временная сложность итерации и определение того, существует ли подстрока в «st2» или нет, составляет O (m), где «m» — длина «st2». Таким образом, общая временная сложность обнаружения самой длинной общей подстроки в двух строках составляет O(a^2*m). Более того, объемная сложность — это еще одна стоимость выполнения программы. Сложность пространства представляет собой пространство, которое программа или функция будет сохранять в памяти во время выполнения. Следовательно, пространственная сложность поиска самой длинной общей подпоследовательности составляет O (1), поскольку для ее выполнения не требуется никакого места.
Вывод:
В этой статье мы узнали о методах поиска самой длинной общей подстроки в строке с помощью программирования на Python. Мы предоставили три простых и легких примера, чтобы получить самую длинную общую подстроку в python. В первом примере используется комбинация циклов for и while. В то время как во втором примере мы следовали итеративному подходу, используя цикл for и логику if. Напротив, в третьем примере мы просто использовали встроенную функцию python для получения длины общей подстроки в строке. Напротив, временная сложность поиска самой длинной общей подстроки в строке с использованием python составляет O (a ^ 2 * m), где a и ma — длина двух строк; строка 1 и строка 2 соответственно.
[ Сборник задач ]
Тема 4. Работа со списками
Список – последовательность элементов, объединенных в один контейнер. Главная особенность – они изменяемы.
Элементы списка индексируются, состоят в основном из однотипных данных, перебираются, сохраняют порядок.
Для решения заданий необходимо повторить свойства и методы списков.
Читайте также
1. Перечислите характеристики типа данных «список», которые вы знаете.
2. Как проверить наличие элемента в списке?
Есть 2 очевидных способа:
1. При помощи конструкции in:
Пример – IDE
lst = [1, 2, 3, 14, 33, 1, 1]
if 1 in lst:
____print(‘Есть’)
Результат:
Есть
2. При помощи метода count:
Пример – IDE
lst = [1, 2, 3, 14, 33, 1, 1]
if lst.count(5):
____print(‘Есть’)
else:
____print(‘Нет’)
Результат:
Нет
3. Чем отличаются методы append() и extend()?
Метод append() добавляет в конец текущего списка новый элемент.
Метод extend() добавляет в конец текущего списка новые элементы в распакованном виде.
Посмотрим отличия на примере.
Пример – IDE
lst = [1, 2, 3, 14, 33, 1, 1]
lst.extend(‘Добавка’)
print(lst)
Результат:
[1, 2, 3, 14, 33, 1, 1, ‘Д’, ‘о’, ‘б’, ‘а’, ‘в’, ‘к’, ‘а’]
Пример – IDE
lst = [1, 2, 3, 14, 33, 1, 1]
lst.append(‘Добавка’)
print(lst)
Результат:
[1, 2, 3, 14, 33, 1, 1, ‘Добавка’]
4. Какие параметры можно передавать при срезах списков?
Для срезов можно пользоваться функцией slice() или специальным сокращением, куда входит 3 параметра: начало среза (по умолчанию – первый элемент), конец среза (конечный член списка, не включая его), шаг (по умолчанию – 1, т.е. выбираем все элементы без пропусков).
Пример – IDE
h = [1, 2, 3, 14, 33, 1, 9]
print(h[slice(2, 6, 2)])
Результат:
[3, 33]
Т.е. создаем новый список начиная с элемента с индексом 2 (в нашем случае это цифра 3) вплоть до 6 элемента (не включая его) с шагом 2 (пропускаем каждое второе значение).
Часть или все параметры можно опускать в специальных сокращениях.
Пример – IDE
h = [1, 2, 3, 14, 33, 1, 9]
print(h[2:6:2])
print(h[::2])
Результат:
[3, 33]
[1, 3, 33, 9]
5*. Что произойдет со списком lst1 в первом и втором случаях? Поясните результат.
Случай 1 – IDE
lst1 = [1, 2, 3, 14, 33, 1, 9]
lst2 = [1, 2, 3, 14, 33, 1, 9]
lst2.append(789)
Случай 2 – IDE
lst1 = [1, 2, 3, 14, 33, 1, 9]
lst2 = lst1
lst2.append(789)
В первом случае список lst1 не изменится, во втором – в нем появится новый элемент 789.
Первый пример показывает создание двух разных списков, хоть и являющихся равными. Тем не менее они занимают разные области в памяти. И изменение одного из списков не вызывает аналогичного поведения в другом.
Во втором примере обе переменные ссылаются на один список, поэтому модификация любой из них отразится на другой.
# Тест случая 1
lst1 = [1, 2, 3, 14, 33, 1, 9]
lst2 = [1, 2, 3, 14, 33, 1, 9]
lst2.append(789)
print(lst1, lst2, sep=’\n’)
Результат:
[1, 2, 3, 14, 33, 1, 9]
[1, 2, 3, 14, 33, 1, 9, 789]
# Тест случая 2
lst1 = [1, 2, 3, 14, 33, 1, 9]
lst2 = lst1
lst1.append(789)
print(lst1, lst2, sep=’\n’)
Результат:
[1, 2, 3, 14, 33, 1, 9, 789]
[1, 2, 3, 14, 33, 1, 9, 789]
Есть 3 часто применяемых варианта:
1. При помощи функции list():
Пример – IDE
text = ‘Строка’
print(list(text))
Результат:
[‘С’, ‘т’, ‘р’, ‘о’, ‘к’, ‘а’]
2. При помощи цикла for:
Пример – IDE
text = ‘Строка’
new_list = []
for i in text:
____new_list.append(i)
print(new_list)
Результат:
[‘С’, ‘т’, ‘р’, ‘о’, ‘к’, ‘а’]
3. При помощи генератора списков:
Пример – IDE
text = ‘Строка’
new_list = [i for i in text]
print(new_list)
Списки, кортежи и словари
Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.
Список (list) представляет тип данных, который хранит набор или последовательность элементов. Во многих языках программирования есть аналогичная структура данных, которая называется массив.
Создание списка
Для создания списка применяются квадратные скобки [] , внутри которых через запятую перечисляются элементы списка. Например, определим список чисел:
Подобным образом можно определять списки с данными других типов, например, определим список строк:
Также для создания списка можно использовать функцию-конструктор list() :
Оба этих определения списка аналогичны — они создают пустой список.
Список необязательно должен содержать только однотипные объекты. Мы можем поместить в один и тот же список одновременно строки, числа, объекты других типов данных:
Для проверки элементов списка можно использовать стандартную функцию print, которая выводит содержимое списка в удобочитаемом виде:
Конструктор list может принимать набор значений, на основе которых создается список:
Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *, то есть фактически применить операцию умножения к уже существующему списку:
Обращение к элементам списка
Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент — индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего — -2 и так далее.
Для изменения элемента списка достаточно присвоить ему новое значение:
Разложение списка
Python позволяет разложить список на отдельные элементы:
В данном случае переменным tom, bob и sam последовательно присваиваются элементы из списка people. Однако следует учитывать, что количество переменных должно быть равно числу элементов присваиваемого списка.
Перебор элементов
Для перебора элементов можно использовать как цикл for, так и цикл while.
Перебор с помощью цикла for :
Здесь будет производиться перебор списка people, и каждый его элемент будет помещаться в переменную person.
Перебор также можно сделать с помощью цикла while :
Для перебора с помощью функции len() получаем длину списка. С помощью счетчика i выводит по элементу, пока значение счетчика не станет равно длине списка.
Сравнение списков
Два списка считаются равными, если они содержат один и тот же набор элементов:
В данном случае оба списка будут равны.
Получение части списка
Если необходимо получить какую-то определенную часть списка, то мы можем применять специальный синтаксис, который может принимать следующие формы:
list[:end] : через параметр end передается индекс элемента, до которого нужно копировать список
list[start:end] : параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы
list[start:end:step] : параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.
Можно использовать отрицательные индексы, тогда отсчет будет идти с конца, например, -1 — предпоследний, -2 — третий сконца и так далее.
Методы и функции по работе со списками
Для управления элементами списки имеют целый ряд методов. Некоторые из них:
append(item) : добавляет элемент item в конец списка
insert(index, item) : добавляет элемент item в список по индексу index
extend(items) : добавляет набор элементов items в конец списка
remove(item) : удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError
clear() : удаление всех элементов из списка
index(item) : возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError
pop([index]) : удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.
count(item) : возвращает количество вхождений элемента item в список
sort([key]) : сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.
reverse() : расставляет все элементы в списке в обратном порядке
copy() : копирует список
Кроме того, Python предоставляет ряд встроенных функций для работы со списками:
len(list) : возвращает длину списка
sorted(list, [key]) : возвращает отсортированный список
min(list) : возвращает наименьший элемент списка
max(list) : возвращает наибольший элемент списка
Добавление и удаление элементов
Для добавления элемента применяются методы append() , extend и insert , а для удаления — методы remove() , pop() и clear() .
Проверка наличия элемента
Если определенный элемент не найден, то методы remove и index генерируют исключение. Чтобы избежать подобной ситуации, перед операцией с элементом можно проверять его наличие с помощью ключевого слова in :
Выражение if «Alice» in people возвращает True, если элемент «Alice» имеется в списке people. Поэтому конструкция if «Alice» in people может выполнить последующий блок инструкций в зависимости от наличия элемента в списке.
Удаление с помощью del
Python также поддерживает еще один способ удаления элементов списка — с помощью оператора del . В качестве параметра этому оператору передается удаляемый элемент или набор элементов:
Подсчет вхождений
Если необходимо узнать, сколько раз в списке присутствует тот или иной элемент, то можно применить метод count() :
Сортировка
Для сортировки по возрастанию применяется метод sort() :
Если необходимо отсортировать данные в обратном порядке, то мы можем после сортировки применить метод reverse() :
При сортировке фактически сравниваются два объекта, и который из них «меньше», ставится перед тем, который «больше». Понятия «больше» и «меньше» довольно условны. И если для чисел все просто — числа расставляются в порядке возрастания, то для строк и других объектов ситуация сложнее. В частности, строки оцениваются по первым символам. Если первые символы равны, оцениваются вторые символы и так далее. При чем цифровой символ считается «меньше», чем алфавитный заглавный символ, а заглавный символ считается меньше, чем строчный.
Таким образом, если в списке сочетаются строки с верхним и нижним регистром, то мы можем получить не совсем корректные результаты, так как для нас строка «bob» должна стоять до строки «Tom». И чтобы изменить стандартное поведение сортировки, мы можем передать в метод sort() в качестве параметра функцию:
Кроме метода sort мы можем использовать встроенную функцию sorted , которая имеет две формы:
sorted(list) : сортирует список list
sorted(list, key) : сортирует список list, применяя к элементам функцию key
При использовании этой функции следует учитывать, что эта функция не изменяет сортируемый список, а все отсортированные элементы она помещает в новый список, который возвращается в качестве результата.
Минимальное и максимальное значения
Встроенный функции Python min() и max() позволяют найти минимальное и максимальное значения соответственно:
Копирование списков
При копировании списков следует учитывать, что списки представляют изменяемый (mutable) тип, поэтому если обе переменных будут указывать на один и тот же список, то изменение одной переменной, затронет и другую переменную:
Это так называемое «поверхностное копирование» (shallow copy). И, как правило, такое поведение нежелательное. И чтобы происходило копирование элементов, но при этом переменные указывали на разные списки, необходимо выполнить глубокое копирование (deep copy). Для этого можно использовать метод copy() :
Соединение списков
Для объединения списков применяется операция сложения (+):
Списки списков
Списки кроме стандартных данных типа строк, чисел, также могут содержать другие списки. Подобные списки можно ассоциировать с таблицами, где вложенные списки выполняют роль строк. Например:
Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: people[0][1] — обращение ко второму элементу первого вложенного списка.
Добавление, удаление и изменение общего списка, а также вложенных списков аналогично тому, как это делается с обычными (одномерными) списками: