Python 检查组合字符串中子字符串顺序的算法

问题如下：如果有两个字符串

str1

和

str2

，以及另一个字符串

str3

，请编写一个函数，检查

str3

是否同时包含

str1

的字母和

str2

的字母，其顺序与原始序列相同，尽管它们可能是交错的。因此，adbfec对于子字符串adf和bec返回true。我已经用Python编写了以下函数：

def isinter(str1,str2,str3):
    p1,p2,p3 = 0,0,0
    while p3 < len(str3):
        if p1 < len(str1) and str3[p3] == str1[p1]:
            p1 += 1
        elif p2 < len(str2) and str3[p3] == str2[p2]:
            p2 += 1
        else:
            break
        p3 = p1+p2
    return p3 == len(str3)

def isinter（str1、str2、str3）：
p1，p2，p3=0,0,0
而p3

---

这个程序还有另一个版本，在（最后一个解决方案）。现在哪一个更好？我认为是我的，因为它可能是在线性时间内完成的。无论它是否更好，我的算法还有进一步优化的余地吗？

另一种方法是使用python的regex模块re。您可以拆分str1的字符，并在每个字符周围加上.*以匹配它们之间的任意数量（或无）字符。这将为您提供与str1匹配的模式。然后对str2执行同样的操作，然后只需运行re.match（str1pattern，str3）和re.match（str2pattern，str3）。如果它们都返回对象（即除None之外的任何对象），则两个字符串都有一个匹配项

---

这可能会扩展得更好，因为它更容易添加更多的字符串进行检查，如果您需要更好的性能来搜索各种其他字符串，那么您也可以编译模式。

另一种方法是使用python的regex模块re。您可以拆分str1的字符，并在每个字符周围加上.*以匹配它们之间的任意数量（或无）字符。这将为您提供与str1匹配的模式。然后对str2执行同样的操作，然后只需运行re.match（str1pattern，str3）和re.match（str2pattern，str3）。如果它们都返回对象（即除None之外的任何对象），则两个字符串都有一个匹配项

---

这可能会更好地扩展，因为更容易添加更多字符串进行检查，如果您需要更好的性能来搜索各种其他字符串，那么您也可以编译模式。

您可以在列表中拆分所有三个字符串：

list1 = list(str1)

然后使用您现在使用的相同算法行走

list3

，检查

list3[i]

是否等于

list1[0]

或

list2[0]

。如果是，您将从相应列表中删除项目

过早的列表结束可能会被捕获为异常

算法将完全相同，但实现应该更高效

更新：事实证明它实际上不是（大约是时间的两倍）。哦，知道可能有用

在对不同场景进行基准测试时，结果表明，除非指定三个字符串长度是“精确的”（即len（p1）+len（p2）=len（p3）），否则最有效的优化是首先检查。如果两个输入字符串由于错误的字符串长度而无法匹配第三个字符串，则会立即丢弃所有情况

然后我遇到了两个字符串中都有相同字母的情况，将其分配给list1或list2可能会导致其中一个字符串不再匹配。在这些情况下，该算法失败并出现假阴性，这将需要递归

def isinter(str1,str2,str3,check=True):
    # print "Checking %s %s and %s" % (str1, str2, str3)
    p1,p2,p3 = 0,0,0
    if check:
        if len(str1)+len(str2) != len(str3):
            return False
    while p3 < len(str3):
        if p1 < len(str1) and str3[p3] == str1[p1]:
            if p2 < len(str2) and str3[p3] == str2[p2]:
                # does str3[p3] belong to str1 or str2?
                if True == isinter(str1[p1+1:], str2[p2:], str3[p3+1:], False):
                   return True
                if True == isinter(str1[p1:], str2[p2+1:], str3[p3+1:], False):
                   return True
                return False
            p1 += 1
        elif p2 < len(str2) and str3[p3] == str2[p2]:
            p2 += 1
        else:
            return False
        p3 += 1
    return p1 == len(str1) and p2 == len(str2) and p3 == len(str3)

---

毫不奇怪，完全重叠（每个字符串依次对应一个字母）会看到更大的差异，比率高达364:178（略高于2:1）。

您可以在列表中拆分所有三个字符串：

list1 = list(str1)

然后使用您现在使用的相同算法行走

list3

，检查

list3[i]

是否等于

list1[0]

或

list2[0]

。如果是，您将从相应列表中删除项目

过早的列表结束可能会被捕获为异常

算法将完全相同，但实现应该更高效

更新：事实证明它实际上不是（大约是时间的两倍）。哦，知道可能有用

在对不同场景进行基准测试时，结果表明，除非指定三个字符串长度是“精确的”（即len（p1）+len（p2）=len（p3）），否则最有效的优化是首先检查。如果两个输入字符串由于错误的字符串长度而无法匹配第三个字符串，则会立即丢弃所有情况

然后我遇到了两个字符串中都有相同字母的情况，将其分配给list1或list2可能会导致其中一个字符串不再匹配。在这些情况下，该算法失败并出现假阴性，这将需要递归

def isinter(str1,str2,str3,check=True):
    # print "Checking %s %s and %s" % (str1, str2, str3)
    p1,p2,p3 = 0,0,0
    if check:
        if len(str1)+len(str2) != len(str3):
            return False
    while p3 < len(str3):
        if p1 < len(str1) and str3[p3] == str1[p1]:
            if p2 < len(str2) and str3[p3] == str2[p2]:
                # does str3[p3] belong to str1 or str2?
                if True == isinter(str1[p1+1:], str2[p2:], str3[p3+1:], False):
                   return True
                if True == isinter(str1[p1:], str2[p2+1:], str3[p3+1:], False):
                   return True
                return False
            p1 += 1
        elif p2 < len(str2) and str3[p3] == str2[p2]:
            p2 += 1
        else:
            return False
        p3 += 1
    return p1 == len(str1) and p2 == len(str2) and p3 == len(str3)

---

毫不奇怪，完全重叠（每个字符串依次对应一个字母）会看到更大的差异，比率高达364:178（略高于2:1）。

不幸的是，您的版本无法正常工作。想象输入

ab

，

ac

，

acab

。您的算法返回不正确的

False

---

问题是，当在str3中看到的字母可以双向解释时，你总是走str1<代码>str2可能是行走所必需的，但它与您的算法没有同等的机会。

不幸的是，您的版本根本不起作用。想象输入

ab

，

ac

，

acab

。您的算法返回不正确的

False

---

问题是，当在str3中看到的字母可以双向解释时，你总是走str1<代码>str2可能是行走所必需的，但它与您的算法没有同等的机会。

首先，只是一个实现