Найти все вхождения подстроки в строке в Python
Привет, кодеры!! В этой статье мы рассмотрим методы в Python, чтобы найти все вхождения в строку. Чтобы сделать концепцию ясной, мы рассмотрим подробную иллюстрацию кода для достижения требуемого результата.
Что такое подстрока?
Подстрока в Python – это последовательность символов, представленных в другой строке. Например, рассмотрим сильный abaabaabbaab. Здесь arab – это подстрока, встречающаяся дважды в строке. Кроме того, abs – это еще одна подстрока, встречающаяся трижды в строке.
Часто при обработке строк у нас могут возникнуть проблемы с обработкой подстрок. Это включает в себя неудобство нахождения всех позиций определенной подстроки в строке. В этой статье мы обсудим, как мы можем справиться с этим.
Код Python для поиска всех вхождений в строку
1)Использование понимания списка + начинается с() в Python для поиска всех вхождений в строку
Эта функция помогает найти заданную подстроку во всей строке или в заданной части строки.
Синтаксис:
string.startswith(значение, начало, конец)
Список параметров:
- значение: Это обязательное поле. Он содержит значение, с помощью которого мы проверяем, начинается ли строка с этого значения.
- start: Это необязательное поле. Это целочисленное значение, которое определяет позицию, с которой следует начать поиск.
- конец: Это необязательное поле. Это целочисленное значение, которое указывает позицию, с которой следует завершить поиск.
Возвращаемое значение:
Возвращает индекс, по которому найдена данная подстрока.
Вывод и объяснение:
В этом коде входная строка была “python pool for python coding”. Мы выбрали подстроку “python”. Используя функцию starts with() , мы нашли вхождения подстроки в строку. В результате мы нашли подстроку в индексах 0 и 15.
2) Использование re.finditer() в Python для поиска всех вхождений в строку
Это функция href=”https://docs.python.org/3/library/re.html”>библиотека регулярных выражений, предоставляемая python, которая помогает найти вхождение определенного шаблона в строку. href=”https://docs.python.org/3/library/re.html”>библиотека регулярных выражений, предоставляемая python, которая помогает найти вхождение определенного шаблона в строку.
Синтаксис:
Список параметров:
- pattern: шаблон, который должен быть согласован
Возвращаемое значение:
Эта функция возвращает итератор неперекрывающихся совпадений для шаблона в строке.
Вывод и объяснение:
В этом коде входная строка была “python pool for python coding”. Мы выбрали подстроку “python”. Используя функцию re.finditer (), мы нашли неперекрывающиеся вхождения подстроки в строке. В результате мы нашли подстроку в индексах 0 и 15.
3) Использование re.findall() в Python для поиска всех вхождений в строку
Эта функция используется для поиска всех неперекрывающихся подстрок в данной строке. Строка тщательно сканируется слева направо, возвращая совпадения в том же порядке.
Синтаксис:
Список параметров:
- pattern: шаблон, который должен быть согласован
Возвращаемое значение:
Он возвращает все совпадения шаблона в виде списка строк.
Вывод и объяснение:
В этом коде входная строка была “python pool 123 for python 456 coding”. Мы выбрали подстроку “\d+”. Используя функцию re.findall (), мы нашли вхождения подстроки. В этом случае мы ищем целые числа в строке. В результате на выходе получается список, содержащий все целочисленные значения.
Вывод: Python находит все вхождения в строку
В этой статье мы изучили различные способы поиска всех вхождений данной подстроки в строку с помощью различных функций в Python.
re — Regular expression operations¶
This module provides regular expression matching operations similar to those found in Perl.
Both patterns and strings to be searched can be Unicode strings ( str ) as well as 8-bit strings ( bytes ). However, Unicode strings and 8-bit strings cannot be mixed: that is, you cannot match a Unicode string with a byte pattern or vice-versa; similarly, when asking for a substitution, the replacement string must be of the same type as both the pattern and the search string.
Regular expressions use the backslash character ( ‘\’ ) to indicate special forms or to allow special characters to be used without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals; for example, to match a literal backslash, one might have to write ‘\\\\’ as the pattern string, because the regular expression must be \\ , and each backslash must be expressed as \\ inside a regular Python string literal. Also, please note that any invalid escape sequences in Python’s usage of the backslash in string literals now generate a DeprecationWarning and in the future this will become a SyntaxError . This behaviour will happen even if it is a valid escape sequence for a regular expression.
The solution is to use Python’s raw string notation for regular expression patterns; backslashes are not handled in any special way in a string literal prefixed with ‘r’ . So r"\n" is a two-character string containing ‘\’ and ‘n’ , while "\n" is a one-character string containing a newline. Usually patterns will be expressed in Python code using this raw string notation.
It is important to note that most regular expression operations are available as module-level functions and methods on compiled regular expressions . The functions are shortcuts that don’t require you to compile a regex object first, but miss some fine-tuning parameters.
The third-party regex module, which has an API compatible with the standard library re module, but offers additional functionality and a more thorough Unicode support.
Regular Expression Syntax¶
A regular expression (or RE) specifies a set of strings that matches it; the functions in this module let you check if a particular string matches a given regular expression (or if a given regular expression matches a particular string, which comes down to the same thing).
Regular expressions can be concatenated to form new regular expressions; if A and B are both regular expressions, then AB is also a regular expression. In general, if a string p matches A and another string q matches B, the string pq will match AB. This holds unless A or B contain low precedence operations; boundary conditions between A and B; or have numbered group references. Thus, complex expressions can easily be constructed from simpler primitive expressions like the ones described here. For details of the theory and implementation of regular expressions, consult the Friedl book [Frie09] , or almost any textbook about compiler construction.
A brief explanation of the format of regular expressions follows. For further information and a gentler presentation, consult the Regular Expression HOWTO .
Regular expressions can contain both special and ordinary characters. Most ordinary characters, like ‘A’ , ‘a’ , or ‘0’ , are the simplest regular expressions; they simply match themselves. You can concatenate ordinary characters, so last matches the string ‘last’ . (In the rest of this section, we’ll write RE’s in this special style , usually without quotes, and strings to be matched ‘in single quotes’ .)
Some characters, like ‘|’ or ‘(‘ , are special. Special characters either stand for classes of ordinary characters, or affect how the regular expressions around them are interpreted.
Repetition operators or quantifiers ( * , + , ? ,
The special characters are:
(Dot.) In the default mode, this matches any character except a newline. If the DOTALL flag has been specified, this matches any character including a newline.
(Caret.) Matches the start of the string, and in MULTILINE mode also matches immediately after each newline.
Matches the end of the string or just before the newline at the end of the string, and in MULTILINE mode also matches before a newline. foo matches both ‘foo’ and ‘foobar’, while the regular expression foo$ matches only ‘foo’. More interestingly, searching for foo.$ in ‘foo1\nfoo2\n’ matches ‘foo2’ normally, but ‘foo1’ in MULTILINE mode; searching for a single $ in ‘foo\n’ will find two (empty) matches: one just before the newline, and one at the end of the string.
Causes the resulting RE to match 0 or more repetitions of the preceding RE, as many repetitions as are possible. ab* will match ‘a’, ‘ab’, or ‘a’ followed by any number of ‘b’s.
Causes the resulting RE to match 1 or more repetitions of the preceding RE. ab+ will match ‘a’ followed by any non-zero number of ‘b’s; it will not match just ‘a’.
Causes the resulting RE to match 0 or 1 repetitions of the preceding RE. ab? will match either ‘a’ or ‘ab’.
The ‘*’ , ‘+’ , and ‘?’ quantifiers are all greedy; they match as much text as possible. Sometimes this behaviour isn’t desired; if the RE <.*> is matched against ‘<a> b <c>’ , it will match the entire string, and not just ‘<a>’ . Adding ? after the quantifier makes it perform the match in non-greedy or minimal fashion; as few characters as possible will be matched. Using the RE <.*?> will match only ‘<a>’ .
Like the ‘*’ , ‘+’ , and ‘?’ quantifiers, those where ‘+’ is appended also match as many times as possible. However, unlike the true greedy quantifiers, these do not allow back-tracking when the expression following it fails to match. These are known as possessive quantifiers. For example, a*a will match ‘aaaa’ because the a* will match all 4 ‘a’ s, but, when the final ‘a’ is encountered, the expression is backtracked so that in the end the a* ends up matching 3 ‘a’ s total, and the fourth ‘a’ is matched by the final ‘a’ . However, when a*+a is used to match ‘aaaa’ , the a*+ will match all 4 ‘a’ , but when the final ‘a’ fails to find any more characters to match, the expression cannot be backtracked and will thus fail to match. x*+ , x++ and x?+ are equivalent to (?>x*) , (?>x+) and (?>x?) correspondingly.
New in version 3.11.
Specifies that exactly m copies of the previous RE should be matched; fewer matches cause the entire RE not to match. For example, a <6>will match exactly six ‘a’ characters, but not five.
Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as many repetitions as possible. For example, a <3,5>will match from 3 to 5 ‘a’ characters. Omitting m specifies a lower bound of zero, and omitting n specifies an infinite upper bound. As an example, a<4,>b will match ‘aaaab’ or a thousand ‘a’ characters followed by a ‘b’ , but not ‘aaab’ . The comma may not be omitted or the modifier would be confused with the previously described form.
Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as few repetitions as possible. This is the non-greedy version of the previous quantifier. For example, on the 6-character string ‘aaaaaa’ , a <3,5>will match 5 ‘a’ characters, while a<3,5>? will only match 3 characters.
Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as many repetitions as possible without establishing any backtracking points. This is the possessive version of the quantifier above. For example, on the 6-character string ‘aaaaaa’ , a<3,5>+aa attempt to match 5 ‘a’ characters, then, requiring 2 more ‘a’ s, will need more characters than available and thus fail, while a<3,5>aa will match with a <3,5>capturing 5, then 4 ‘a’ s by backtracking and then the final 2 ‘a’ s are matched by the final aa in the pattern. x
New in version 3.11.
Either escapes special characters (permitting you to match characters like ‘*’ , ‘?’ , and so forth), or signals a special sequence; special sequences are discussed below.
If you’re not using a raw string to express the pattern, remember that Python also uses the backslash as an escape sequence in string literals; if the escape sequence isn’t recognized by Python’s parser, the backslash and subsequent character are included in the resulting string. However, if Python would recognize the resulting sequence, the backslash should be repeated twice. This is complicated and hard to understand, so it’s highly recommended that you use raw strings for all but the simplest expressions.
Used to indicate a set of characters. In a set:
Characters can be listed individually, e.g. [amk] will match ‘a’ , ‘m’ , or ‘k’ .
Ranges of characters can be indicated by giving two characters and separating them by a ‘-‘ , for example [a-z] will match any lowercase ASCII letter, [0-5][0-9] will match all the two-digits numbers from 00 to 59 , and [0-9A-Fa-f] will match any hexadecimal digit. If — is escaped (e.g. [a\-z] ) or if it’s placed as the first or last character (e.g. [-a] or [a-] ), it will match a literal ‘-‘ .
Special characters lose their special meaning inside sets. For example, [(+*)] will match any of the literal characters ‘(‘ , ‘+’ , ‘*’ , or ‘)’ .
Character classes such as \w or \S (defined below) are also accepted inside a set, although the characters they match depends on whether ASCII or LOCALE mode is in force.
Characters that are not within a range can be matched by complementing the set. If the first character of the set is ‘^’ , all the characters that are not in the set will be matched. For example, [^5] will match any character except ‘5’ , and [^^] will match any character except ‘^’ . ^ has no special meaning if it’s not the first character in the set.
To match a literal ‘]’ inside a set, precede it with a backslash, or place it at the beginning of the set. For example, both [()[\]<>] and []()[<>] will match a right bracket, as well as left bracket, braces, and parentheses.
Support of nested sets and set operations as in Unicode Technical Standard #18 might be added in the future. This would change the syntax, so to facilitate this change a FutureWarning will be raised in ambiguous cases for the time being. That includes sets starting with a literal ‘[‘ or containing literal character sequences ‘—‘ , ‘&&’ , ‘
‘ , and ‘||’ . To avoid a warning escape them with a backslash.
Changed in version 3.7: FutureWarning is raised if a character set contains constructs that will change semantically in the future.
A|B , where A and B can be arbitrary REs, creates a regular expression that will match either A or B. An arbitrary number of REs can be separated by the ‘|’ in this way. This can be used inside groups (see below) as well. As the target string is scanned, REs separated by ‘|’ are tried from left to right. When one pattern completely matches, that branch is accepted. This means that once A matches, B will not be tested further, even if it would produce a longer overall match. In other words, the ‘|’ operator is never greedy. To match a literal ‘|’ , use \| , or enclose it inside a character class, as in [|] .
Matches whatever regular expression is inside the parentheses, and indicates the start and end of a group; the contents of a group can be retrieved after a match has been performed, and can be matched later in the string with the \number special sequence, described below. To match the literals ‘(‘ or ‘)’ , use \( or \) , or enclose them inside a character class: [(] , [)] .
This is an extension notation (a ‘?’ following a ‘(‘ is not meaningful otherwise). The first character after the ‘?’ determines what the meaning and further syntax of the construct is. Extensions usually do not create a new group; (?P<name>. ) is the only exception to this rule. Following are the currently supported extensions.
(One or more letters from the set ‘a’ , ‘i’ , ‘L’ , ‘m’ , ‘s’ , ‘u’ , ‘x’ .) The group matches the empty string; the letters set the corresponding flags: re.A (ASCII-only matching), re.I (ignore case), re.L (locale dependent), re.M (multi-line), re.S (dot matches all), re.U (Unicode matching), and re.X (verbose), for the entire regular expression. (The flags are described in Module Contents .) This is useful if you wish to include the flags as part of the regular expression, instead of passing a flag argument to the re.compile() function. Flags should be used first in the expression string.
Changed in version 3.11: This construction can only be used at the start of the expression.
A non-capturing version of regular parentheses. Matches whatever regular expression is inside the parentheses, but the substring matched by the group cannot be retrieved after performing a match or referenced later in the pattern.
(Zero or more letters from the set ‘a’ , ‘i’ , ‘L’ , ‘m’ , ‘s’ , ‘u’ , ‘x’ , optionally followed by ‘-‘ followed by one or more letters from the ‘i’ , ‘m’ , ‘s’ , ‘x’ .) The letters set or remove the corresponding flags: re.A (ASCII-only matching), re.I (ignore case), re.L (locale dependent), re.M (multi-line), re.S (dot matches all), re.U (Unicode matching), and re.X (verbose), for the part of the expression. (The flags are described in Module Contents .)
The letters ‘a’ , ‘L’ and ‘u’ are mutually exclusive when used as inline flags, so they can’t be combined or follow ‘-‘ . Instead, when one of them appears in an inline group, it overrides the matching mode in the enclosing group. In Unicode patterns (?a. ) switches to ASCII-only matching, and (?u. ) switches to Unicode matching (default). In byte pattern (?L. ) switches to locale depending matching, and (?a. ) switches to ASCII-only matching (default). This override is only in effect for the narrow inline group, and the original matching mode is restored outside of the group.
New in version 3.6.
Changed in version 3.7: The letters ‘a’ , ‘L’ and ‘u’ also can be used in a group.
Attempts to match . as if it was a separate regular expression, and if successful, continues to match the rest of the pattern following it. If the subsequent pattern fails to match, the stack can only be unwound to a point before the (?>. ) because once exited, the expression, known as an atomic group, has thrown away all stack points within itself. Thus, (?>.*). would never match anything because first the .* would match all characters possible, then, having nothing left to match, the final . would fail to match. Since there are no stack points saved in the Atomic Group, and there is no stack point before it, the entire expression would thus fail to match.
New in version 3.11.
Similar to regular parentheses, but the substring matched by the group is accessible via the symbolic group name name. Group names must be valid Python identifiers, and each group name must be defined only once within a regular expression. A symbolic group is also a numbered group, just as if the group were not named.
Практика: Z-функция и КМП
Здесь и далее строки индексируются с нуля, т.е. первый символ строки имеет номер \(0\) . Также, здесь и далее \(s[i \ldots j]\) обозначает подстроку строки \(s\) от \(i\) -го символа до \(j\) -го включительно.
Пусть дана строка \(s\) длины \(n\) . Тогда \(Z(s)\) — это массив длины \(n\) , \(i\) -ый элемент которого равен наибольшему числу символов, начиная с позиции \(i\) , совпадающих с первыми символами строки \(s\) .
Иными словами, \(z[i]\) — это длина наибольшего общего префикса строки \(s\) и её \(i\) -го суффикса.
Первый элемент \(Z\) -функции, \(z[0]\) , обычно считают неопределённым. В данной статье мы будем считать, что он равен нулю (хотя ни в алгоритме, ни в приведённой реализации это ничего не меняет).
Далее будет привиден алгоритм вычисления \(Z\) -функции за время \(O(n)\) , а также различные применения этого алгоритма.
Примеры
Приведём для примера подсчитанную \(Z\) -функцию для нескольких строк:
Тривиальный алгоритм
Формальное определение можно представить в виде следующей элементарной реализации за \(O(n^2)\) :
Мы просто для каждой позиции \(i\) перебираем ответ для неё \(z[i]\) , начиная с нуля, и до тех пор, пока мы не обнаружим несовпадение или не дойдём до конца строки.
Разумеется, эта реализация слишком неэффективна, перейдём теперь к построению эффективного алгоритма.
Эффективный алгоритм вычисления Z-функции
Чтобы получить эффективный алгоритм, будем вычислять значения \(z[i]\) по очереди — от \(i=1\) до \(n-1\) , и при этом постараемся при вычислении очередного значения \(z[i]\) максимально использовать уже вычисленные значения.
Назовём для краткости подстроку, совпадающую с префиксом строки \(s\) , отрезком совпадения. Например, значение искомой Z-функции \(z[i]\) — это длина длиннейшего отрезок совпадения, начинающийся в позиции \(i\) (и заканчиваться он будет в позиции \(i + z[i] — 1\) ).
Для этого будем поддерживать координаты \(\boldsymbol<[l;r]>\) самого правого отрезка совпадения, т.е. из всех обнаруженных отрезков будем хранить тот, который оканчивается правее всего. В некотором смысле, индекс \(r\) — это такая граница, до которой наша строка уже была просканирована алгоритмом, а всё остальное — пока ещё не известно.
Тогда если текущий индекс, для которого мы хотим посчитать очередное значение \(Z\) -функции, — это \(i\) , мы имеем один из двух вариантов:
\(i > r\) — т.е. текущая позиция лежит за пределами того, что мы уже успели обработать.
Тогда будем искать \(z[i]\) тривиальным алгоритмом, т.е. просто пробуя значения \(z[i]=0\) , \(z[i]=1\) , и т.д. Заметим, что в итоге, если \(z[i]\) окажется \(> 0\) , то мы будем обязаны обновить координаты самого правого отрезка \([l; r]\) — т.к. \(i + z[i] — 1\) гарантированно окажется больше \(r\) .
\(i \le r\) — т.е. текущая позиция лежит внутри отрезка совпадения \([l; r]\) .
Тогда мы можем использовать уже подсчитанные предыдущие значения \(Z\) -функции, чтобы проинициализировать значение \(z[i]\) не нулём, а каким-то возможно бОльшим числом.
Для этого заметим, что подстроки \(s[l \ldots r]\) и \(s[0 \ldots r-l]\) совпадают. Это означает, что в качестве начального приближения для \(z[i]\) можно взять соответствующее ему значение из отрезка \(s[0 \ldots r-l]\) , а именно, значение \(z[i-l]\) .
Однако значение \(z[i-l]\) могло оказаться слишком большим: таким, что при применении его к позиции \(i\) оно «вылезет» за пределы границы \(r\) . Этого допустить нельзя, т.к. про символы правее \(r\) мы ничего не знаем, и они могут отличаться от требуемых.
Приведём пример такой ситуации, на примере строки «aaaabaa».
Когда мы дойдём до последней позиции \((i=6)\) , текущим самым правым отрезком будет \([5;6]\) . Позиции \(6\) с учётом этого отрезка будет соответствовать позиция \(6-5=1\) , ответ в которой равен \(z[1] = 3\) . Очевидно, что таким значением инициализировать \(z[6]\) нельзя, оно совершенно некорректно. Максимум, каким значением мы могли проинициализировать — это \(1\) , поскольку это наибольшее значение, которое не вылезает за пределы отрезка \([l;r]\) .
Таким образом, в качестве начального приближения для \(z[i]\) безопасно брать только такое выражение:
Проинициализировав \(z[i]\) таким значением \(z_0[i]\) , мы снова дальше действуем тривиальным алгоритмом — потому что после границы \(r\) , вообще говоря, могло обнаружиться продолжение отрезка совпадение, предугадать которое одними лишь предыдущими значениями \(Z\) -функции мы не можем.
Таким образом, весь алгоритм представляет из себя два случая, которые фактически различаются только начальным значением \(z[i]\) : в первом случае оно полагается равным нулю, а во втором — определяется по предыдущим значениям по указанной формуле. После этого обе ветки алгоритма сводятся к выполнению тривиального алгоритма, стартующего сразу с указанного начального значения.
Алгоритм получился весьма простым. Несмотря на то, что при каждом \(i\) в нём так или иначе выполняется тривиальный алгоритм — мы достигли существенного прогресса, получив алгоритм, работающий за линейное время (действительно, на каждый символ мы «посмотрим», т.е. сравним его с каким-либо предыдущим всего один раз).
Упражнение №1: \(Z\) -функция
Напишите \(Z\) -функцию. Пусть заголовком ее будет def z_func(s, n):
Упражнение №2: Поиск подстроки
Пусть даны две строки. Найти все вхождения второй строки в первую.
Упражнение №3: Количество разных подстрок
Найти число всех различных подстрок входящих в данную.
Упражнение №4: Период строки
Для данной строки \(s\) найти строку \(p\) минимальной длины, такую что \(s\) можно предстваить как конкатенацию одной или нескольких копий \(p\) .
Префикс-функция. Алгоритм Кнута-Морриса-Пратта
Материал частично позаимствован с сайта тоже e-maxx.ru.
Префикс-функция. Определение
Пусть дана строка \(s\) длины \(n\) . Тогда \(\pi(s)\) — это массив длины \(n\) , \(i\) -ый элемент которого ( \(\pi[i]\) ) определяется следующим образом: это длина наибольшего собственного суффикса подстроки \(s[0 \ldots i]\) , совпадающего с её префиксом (собственный суффикс — значит не совпадающий со всей строкой). В частности, значение \(\pi[0]\) полагается равным нулю.
Примечение: вообще говоря, в теории множеств собственным считается не пустое подмножество, не совпдающее с самим множеством. В данной статье, для простоты суффикс и префикс нулевой длины также считаются собственными.
Математически определение префикс-функции можно записать следующим образом:
Например, для строки «abcabcd» префикс-функция равна: \([0, 0, 0, 1, 2, 3, 0]\) , что означает:
Другой пример — для строки «aabaaab» она равна: \([0, 1, 0, 1, 2, 2, 3]\) .
Тривиальный алгоритм
Непосредственно следуя определению, можно написать такой алгоритм вычисления префикс-функции:
Как нетрудно заметить, работать он будет за \(O(n^3)\) , что слишком медленно.
Эффективный алгоритм
Для удобства будем обозначать подстроки строки \(s\) следующим образом: пусть \(p^k\) — префикс \(s\) длины \(k\) , \(s^k_i\) — подстрока длины \(k\) заканчивающаяся символом с номером \(i\) . Напомним, что первый символ строки имеет номер \(0\) .
Будем вычислять \(\pi[i]\) последовательно, начиная с \(\pi[1]\) . \(\pi[0]\) очевидно \(= 0\) . Постараемся на \(i\) шаге получить решение, используя уже известную информацию, т.е. предыдущие значения \(\pi\) .
Во-первых заметим, что \(\pi[i]\) превосходит \(\pi[i — 1]\) не более чем на 1. Действительно, раз уж \(p^<\pi[i]>\) = \(s^<\pi[i]>_i\) , значит и \(p^<\pi[i]-1>=s^<\pi[i]-1>_
Будем рассматривать убывающую последовательность \(\
По определению префикс-функции, очевидно, что \(k_0 = \pi[i — 1]\) . Пусть мы теперь знаем \(k_j\) , найдем \(k_
Ясно, что последовательность \(k_j\) заканчивается первым получившимся нулем. Если при этом условие \(s[k_j] = s[i]\) так и не было удовлетворено, то очередное \(\pi[i] = 0\) .
Итак, \(\pi[0] = 0\) , далее, на каждом шагу алгоритма будем вычислять последовательность \(k_j\) . Если для очередного \(k_j\) выполнено \(s[k_j] = s[i]\) , то \(\pi[i] = k_j + 1\) , переходим к следующему \(i\) . Если перебрали все \(k_j\) вплоть до нуля и совпадения нет, то \(\pi[i] = 0\) . Заметим, что дойдя до нуля совпадение тоже нужно проверить, в этом случае можно получить \(\pi[i] = 0 + 1 = 1\) .
Этот алгоритм был разработан Кнутом (Knuth) и Праттом (Pratt) и независимо от них Моррисом (Morris) в 1977 г. (как основной элемент для алгоритма поиска подстроки в строке). Легко видеть, что алгоритм имеет сложность \(O(n)\) : действительно, сложность шага, на котором префикс-функция возрастает, т.е. \(\pi[i] = \pi[i — 1] + 1\) есть \(O(1)\) , сложность шага на котором функция убывает есть \(O(\pi[i] — \pi[i — 1])\) . Т.е. общая сложность есть \(O(\sum_i| \pi[i] — \pi[i — 1]|)\) . Сумма положительных приростов префикс-функции не превышает \(n\) . А сумма отрицательных изменений не может превысить сумму положительных (иначе мы уйдем в минус). Значит сумма модулей изменений функции не превысит \(2n\) , значит общая сложность \(O(n)\) .
Как нетрудно заметить, этот алгоритм является онлайновым, т.е. он обрабатывает данные по ходу поступления — можно, например, считывать строку по одному символу и сразу обрабатывать этот символ, находя ответ для очередной позиции. Алгоритм требует хранения самой строки и предыдущих вычисленных значений префикс-функции, однако, как нетрудно заметить, если нам заранее известно максимальное значение, которое может принимать префикс-функция на всей строке, то достаточно будет хранить лишь на единицу большее количество первых символов строки и значений префикс-функции.
Поиск подстроки в строке. Алгоритм Кнута-Морриса-Пратта
Эта задача является классическим применением префикс-функции (и, собственно, она и была открыта в связи с этим).
Дан текст \(t\) и строка \(s\) , требуется найти и вывести позиции всех вхождений строки \(s\) в текст \(t\) .
Обозначим для удобства через \(n\) длину строки \(s\) , а через \(m\) — длину текста \(t\) .
Образуем строку \(s + \# + t\) , где символ \(\#\) — это разделитель, который не должен нигде более встречаться. Посчитаем для этой строки префикс-функцию. Теперь рассмотрим её значения, кроме первых \(n+1\) (которые, как видно, относятся к строке \(s\) и разделителю). По определению, значение \(\pi[i]\) показывает наидлиннейшую длину подстроки, оканчивающейся в позиции \(i\) и совпадающего с префиксом. Но в нашем случае это \(\pi[i]\) — фактически длина наибольшего блока совпадения со строкой \(s\) и оканчивающегося в позиции \(i\) . Больше, чем \(n\) , эта длина быть не может, за счёт разделителя. А вот равенство \(\pi[i] = n\) (там, где оно достигается), означает, что в позиции \(i\) оканчивается искомое вхождение строки \(s\) (только не надо забывать, что все позиции отсчитываются в склеенной строке \(s+\#+t\) ).
Таким образом, если в какой-то позиции \(i\) оказалось \(\pi[i] = n\) , то в позиции \(i — (n + 1) — n + 1 = i — 2n\) строки \(t\) начинается очередное вхождение строки \(s\) в строку \(t\) .
Как уже упоминалось при описании алгоритма вычисления префикс-функции, если известно, что значения префикс-функции не будут превышать некоторой величины, то достаточно хранить не всю строку и префикс-функцию, а только её начало. В нашем случае это означает, что нужно хранить в памяти лишь строку \(s + \#\) и значение префикс-функции на ней, а потом уже считывать по одному символу строку \(t\) и пересчитывать текущее значение префикс-функции.
Итак, алгоритм Кнута-Морриса-Пратта решает эту задачу за \(O(n+m)\) времени и \(O(n)\) памяти.
Упражнение №5: Префикс-функция
Напишите префикс-функцию. Пусть заголовком ее будет def p_func(s, n):
Упражнение №6: Поиск подстроки
Пусть даны две строки. Найти все вхождения второй строки в первую с помощью алгоритма Кнута-Морриса-Пратта.
Упражнение №7: Поиск подстроки онлайн
В первой строке ввода — число \(n\) , количество букв в паттерне. Во второй строке — паттерн, строка которую нужно искать в тексте. В каждой из последующих строк — символы текста, по одному в каждой строке. Необходимо вывести позиции вхождений паттерна в текст. Длина текста заранее не известна, он может быть очень большим.
Упражнение №8: Количество разных подстрок
Найти число всех различных подстрок входящих в данную с помощью префикс-функции.
Упражнение №9: Период строки
Для данной строки \(s\) найти строку \(p\) минимальной длины, такую что \(s\) можно предстваить как конкатенацию одной или нескольких копий \(p\) . Используйте префикс-функцию.
Python: найти все вхождения в строке
Подстрока в Python — это набор символов, который встречается в другой строке. Работа с подстроками часто может быть проблематичной. Одна из таких проблем — найти все вхождения подстроки в определенной строке.
В этом руководстве будут рассмотрены различные методы поиска всех вхождений подстроки в строке в Python.
Используйте функцию string.count() для поиска всех вхождений подстроки в строке в Python
string.count() — это встроенная функция в Python, которая возвращает количество или количество вхождений подстроки в данной конкретной строке. Кроме того, в нем есть дополнительные параметры start и end для указания индексов начальной и конечной позиций.
Метод count() просматривает строку и возвращает количество раз, когда определенная подстрока встречалась в строке.
Следующий код использует функцию string.count() для поиска всех вхождений подстроки в строку.
Это простой метод, который работает в любом случае. Единственный недостаток этого метода заключается в том, что он не возвращает различные индексы, по которым подстрока встречается в строке.
Используйте понимание списка и startswith() , чтобы найти все вхождения подстроки в строке в Python
Этому методу нужны две вещи: понимание списка и метод startswith() .
Функция startswith() выполняет задачу получения начальных индексов подстроки, а понимание списка используется для итерации по всей целевой строке.
Следующий код использует понимание списка и startswith() для поиска всех вхождений подстроки в строку.
Используйте re.finditer() , чтобы найти все вхождения подстроки в строке в Python
re.finditer() — это функция библиотеки регулярных выражений, которую Python предоставляет программистам для использования в своем коде. Это помогает в выполнении задачи поиска вхождения определенного шаблона в строке. Чтобы использовать эту функцию, нам нужно сначала импортировать библиотеку регулярных выражений re .
re.finditer() использует в своем синтаксисе параметры pattern и string . В этом случае шаблон относится к подстроке.
Следующий код использует функцию re.finditer() для поиска всех вхождений подстроки в строку.
Vaibhhav is an IT professional who has a strong-hold in Python programming and various projects under his belt. He has an eagerness to discover new things and is a quick learner.