Найти максимальная длина всех N-слово-длина подстроки разделяют две строки

я написал в Python difflib.SequenceMatcher и много времени нахождения ожидаемого случая быстрые способы найти самые длинные общие подстроки. Теоретически это должно быть сделано с "деревьями суффиксов" или связанными "массивами суффиксов", дополненными "самыми длинными общими массивами префиксов" (фразы в кавычках-это поисковые термины, если вы хотите Google для более.) Они могут решить проблему в худшем случае линейного времени. Но, как это иногда бывает, наихудшие алгоритмы линейного времени мучительно сложны и деликатны и страдают большими постоянными факторами - они все еще могут окупиться очень сильно, если данный корпус будет искать много раз, но это не типичный случай для Python difflib и это тоже не похоже на ваше дело.

в любом случае, мой вклад здесь-переписать SequenceMatcher ' s find_longest_match() способ вернуться все (локально) максимальные совпадения, которые он находит по пути. Примечания:

1. я собираюсь использовать to_words() функция Raymond Hettinger дал вам, но без преобразования в нижний регистр. Преобразование в нижний регистр приводит к выходу, который не совсем похож на то, что вы сказали, что хотите.

2. тем не менее, как я уже отметил в комментарии, это выводит "перо", которого нет в вашем списке желаемых результатов. У меня нет идея, почему это не так, так как "перо" появляется в обоих входах.

вот код:

import re
def to_words(text):
    'Break text into a list of words without punctuation'
    return re.findall(r"[a-zA-Z']+", text)

def match(a, b):
    # Make b the longer list.
    if len(a) > len(b):
        a, b = b, a
    # Map each word of b to a list of indices it occupies.
    b2j = {}
    for j, word in enumerate(b):
        b2j.setdefault(word, []).append(j)
    j2len = {}
    nothing = []
    unique = set() # set of all results
    def local_max_at_j(j):
        # maximum match ends with b[j], with length j2len[j]
        length = j2len[j]
        unique.add(" ".join(b[j-length+1: j+1]))
    # during an iteration of the loop, j2len[j] = length of longest
    # match ending with b[j] and the previous word in a
    for word in a:
        # look at all instances of word in b
        j2lenget = j2len.get
        newj2len = {}
        for j in b2j.get(word, nothing):
            newj2len[j] = j2lenget(j-1, 0) + 1
        # which indices have not been extended?  those are
        # (local) maximums
        for j in j2len:
            if j+1 not in newj2len:
                local_max_at_j(j)
        j2len = newj2len
    # and we may also have local maximums ending at the last word
    for j in j2len:
        local_max_at_j(j)
    return unique

затем:

a = "They all are white a sheet of spotless paper " \
    "when they first are born but they are to be " \
    "scrawled upon and blotted by every goose quill"
b = "You are all white, a sheet of lovely, spotless " \
    "paper, when you first are born; but you are to " \
    "be scrawled and blotted by every goose's quill"

print match(to_words(a), to_words(b))

отображает:

set(['all',
     'and blotted by every',
     'first are born but',
     'are to be scrawled',
     'are',
     'spotless paper when',
     'white a sheet of',
     'quill'])

EDIT-как это работает

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

для ввода последовательности a и b, картина матрицы M С len(a) строк и len(b) столбцы. В этом приложении, мы хотим M[i, j] чтобы содержать длину самой длинной общей смежной подпоследовательности, заканчивающейся на a[i] и b[j], и вычислительные правила очень просто:

1. M[i, j] = 0 если a[i] != b[j].
2. M[i, j] = M[i-1, j-1] + 1 если a[i] == b[j] (где мы предполагаем ссылку на матрицу вне границ молча возвращает 0).

интерпретация также очень проста в этом случае: существует локально максимум непустой матч заканчивается в a[i] и b[j], длиной M[i, j], если и только если M[i, j] является ненулевым, но M[i+1, j+1] либо 0, либо вне пределов.

вы можете использовать эти правила для написания очень простого и компактного кода с двумя циклами, который вычисляет M правильно для этой проблемы. Недостатком является то, что код будет принимать (лучшие, средние и в худших случаях)O(len(a) * len(b)) времени и пространство.

хотя это может быть озадачивающим сначала, код, который я опубликовал, делает именно это. Соединение скрыто, Потому что код сильно оптимизирован несколькими способами для ожидаемых случаев:

• вместо того, чтобы делать один проход для вычисления M, затем еще один проход для интерпретации результатов, вычисления и интерпретации чередуются за один проход a.

• из-за этого не нужно хранить всю матрицу. Вместо этого только текущая строка (newj2len) и предыдущая строка (j2len) одновременно присутствуют.

• и потому, что матрица в этом проблема обычно в основном нули, строка здесь представлена редко, через индексы столбцов отображения dict к ненулевым значениям. Нулевые записи являются "свободными", поскольку они никогда не хранятся явно.

• при обработке строки нет необходимости перебирать каждый столбец: предварительно вычисленный b2j dict сообщает нам точно интересные индексы столбцов в текущей строке (те столбцы, которые соответствуют текущему word С a).

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

EDIT-the dirt простая версия

вот код, который реализует 2D-матрицу напрямую, без попыток оптимизации (кроме этого Counter часто можно избежать явного хранения 0 записей). Это очень просто, коротко и легко:

def match(a, b):
    from collections import Counter
    M = Counter()
    for i in range(len(a)):
        for j in range(len(b)):
            if a[i] == b[j]:
                M[i, j] = M[i-1, j-1] + 1
    unique = set()
    for i in range(len(a)):
        for j in range(len(b)):
            if M[i, j] and not M[i+1, j+1]:
                length = M[i, j]
                unique.add(" ".join(a[i+1-length: i+1]))
    return unique

конечно ; -), который возвращает те же результаты, что и оптимизированный match() я опубликовал сначала.

EDIT - и еще без диктата!--68-->

просто для удовольствия : -) если у вас есть матрица модель вниз ПЭТ, этот код будет легко следовать. Примечательно, что значение ячейки матрицы зависит только от значений, расположенных по диагонали к северо-западу от ячейки. Поэтому "достаточно хорошо" просто пересечь все основные диагонали, двигаясь на юго-восток от всех ячеек на Западной и Северной границах. Таким образом, требуется только небольшое постоянное пространство, независимо от входных данных длина:

def match(a, b):
    from itertools import chain
    m, n = len(a), len(b)
    unique = set()
    for i, j in chain(((i, 0) for i in xrange(m)),
                      ((0, j) for j in xrange(1, n))):
        k = 0
        while i < m and j < n:
            if a[i] == b[j]:
                k += 1
            elif k:
                unique.add(" ".join(a[i-k: i]))
                k = 0
            i += 1
            j += 1
        if k:
            unique.add(" ".join(a[i-k: i]))
    return unique