Python - 如何找到两个字符串的所有交集？

Question

如何找到两个字符串的所有交集（也称为最长公共子串）及其在两个字符串中的位置？

例如，如果 S1="never" 和 S2="forever" 则结果交集必须是 ["ever"] 并且它的位置是 [(1,3)]。如果S1="address" 和S2="oddness" 则结果交叉点为["dd","ess"]，它们的位置为[(1,1),(4,4)]。

最好不包含任何库的最短解决方案。但也欢迎任何正确的解决方案。

Answer 1

嗯，你是说你不能包含任何库。但是，Python 的标准 difflib 包含一个完全符合您期望的函数。考虑到这是一道 Python 面试题，熟悉 difflib 可能是面试官所期望的。

In [31]: import difflib

In [32]: difflib.SequenceMatcher(None, "never", "forever").get_matching_blocks()
Out[32]: [Match(a=1, b=3, size=4), Match(a=5, b=7, size=0)]


In [33]: difflib.SequenceMatcher(None, "address", "oddness").get_matching_blocks()
Out[33]: [Match(a=1, b=1, size=2), Match(a=4, b=4, size=3), Match(a=7, b=7, size=0)]

您总是可以忽略最后一个 Match 元组，因为它是虚拟的（根据文档）。

Answer 2

这可以在 O(n+m) 中完成，其中 n 和 m 是输入字符串的长度。

伪代码为：

function LCSubstr(S[1..m], T[1..n])
    L := array(1..m, 1..n)
    z := 0
    ret := {}
    for i := 1..m
        for j := 1..n
            if S[i] = T[j]
                if i = 1 or j = 1
                    L[i,j] := 1
                else
                    L[i,j] := L[i-1,j-1] + 1
                if L[i,j] > z
                    z := L[i,j]
                    ret := {}
                if L[i,j] = z
                    ret := ret ∪ {S[i-z+1..z]}
    return ret

有关更多详细信息，请参阅Longest_common_substring_problem 维基百科文章。

Answer 3

这是我能想到的：

import itertools

def longest_common_substring(s1, s2):
   set1 = set(s1[begin:end] for (begin, end) in
              itertools.combinations(range(len(s1)+1), 2))
   set2 = set(s2[begin:end] for (begin, end) in
              itertools.combinations(range(len(s2)+1), 2))
   common = set1.intersection(set2)
   maximal = [com for com in common
              if sum((s.find(com) for s in common)) == -1 * (len(common)-1)]
   return [(s, s1.index(s), s2.index(s)) for s in maximal]

检查一些值：

>>> longest_common_substring('address', 'oddness')
[('dd', 1, 1), ('ess', 4, 4)]
>>> longest_common_substring('never', 'forever')
[('ever', 1, 3)]
>>> longest_common_substring('call', 'wall')
[('all', 1, 1)]
>>> longest_common_substring('abcd1234', '1234abcd')
[('abcd', 0, 4), ('1234', 4, 0)]

Answer 4

包括电池！

difflib 模块可能对您有所帮助 - 这是一个快速而肮脏的并行 diff：

>>> import difflib
>>> list(difflib.ndiff("never","forever"))
['- n', '+ f', '+ o', '+ r', '  e', '  v', '  e', '  r']
>>> diffs = list(difflib.ndiff("never","forever"))
>>> for d in diffs:
...   print {' ': '  ', '-':'', '+':'    '}[d[0]]+d[1:]
...
 n
     f
     o
     r
   e
   v
   e
   r

Answer 5

我假设您只希望子字符串在它们各自的字符串中具有相同的绝对位置时匹配。例如，“abcd”和“bcde”不会有任何匹配项，即使两者都包含“bcd”。

a = "address"
b = "oddness"

#matches[x] is True if a[x] == b[x]
matches = map(lambda x: x[0] == x[1], zip(list(a), list(b)))

positions = filter(lambda x: matches[x], range(len(a)))
substrings = filter(lambda x: x.find("_") == -1 and x != "","".join(map(lambda x: ["_", a[x]][matches[x]], range(len(a)))).split("_"))

职位 = [1, 2, 4, 5, 6]

子字符串 = ['dd', 'ess']

如果你只想要子字符串，你可以把它压缩成一行：

filter(lambda x: x.find("_") == -1 and x != "","".join(map(lambda x: ["_", a[x]][map(lambda x: x[0] == x[1], zip(list(a), list(b)))[x]], range(len(a)))).split("_"))

Answer 6

def  IntersectStrings( first,  second):
x = list(first)
#print x
y = list(second)
lst1= []
lst2= []
for i in x:
    if i in y:
        lst1.append(i)
lst2 = sorted(lst1) + []
   # This  above step is an optional if it is required to be sorted      alphabetically use this or else remove it
return ''.join(lst2)

print IntersectStrings('hello','mello' )