阻止此代码无限递归的辅助函数。

Question

当我运行 testing1 时，一切都很好，但是当我运行 testing/testing3 时，我的函数是无限递归的。我知道为什么，但我不知道如何制作一个处理这种情况的函数。我需要在 frags 开头的辅助函数来检查给定的字符串是否会导致无限递归。有人对如何解决问题有任何想法吗？

testing = ["baa","aaag","gaaaam","mmmmb"]

testing1 = ["good", "odor", "jimmy", "roboj"]

testing3 = {"aab" , "baa"]

def solution(strings):
    original = strings[:]    
    fragmentsList = frags(strings)
    RealList = fragmentsList[len(original):]
    length = len(RealList)
    removeCounter = 0
    for x in range(0,length):
        for y in range(0,length):
            if x!=y:
                if RealList[x].find(RealList[y]) != -1 and RealList[y].find(RealList[x]) == -1:# x > y
                    RealList[y] = " "
                    removeCounter = removeCounter + 1
    for x in range(0,removeCounter):
        RealList.remove(" ")
    return RealList



def frags(strings):
    length = len(strings)
    for x in range(0,length):
        for y in range(0,length):
            if x != y:
                if fraghelper(strings[x],strings[y]) != -1:
                    toAppend = fraghelper(strings[x],strings[y])
                    for f in range(0,len(toAppend)):
                        if toAppend[f] not in strings:
                            strings.append(toAppend[f])

    if len(strings) != length:
        return frags(strings)
    else:
        return strings




def fraghelper(string1, string2):
    toReturn1 = " "
    toReturn2 = " "
    for i in reversed(range(len(string1))):
        if string2.startswith(string1[-i:]):
            toReturn1 = string1[:-i] + string2

    for i in reversed(range(len(string2))):
        if string1.startswith(string2[-i:]):
            toReturn2 = string2[:-i] + string1    

    if toReturn1 == " " and toReturn2 == " ":
        return -1
    elif toReturn1 == " ":    
        return [toReturn2]
    elif toReturn2 == " ":
        return [toReturn1]
    else:
        return [toReturn1, toReturn2]




print(testing)
print(solution(testing))

Answer 1

您的fraghelper 代码在两个字符串之间找到公共字符串，将其删除并附加到一个字符串中。

例如，它接受'good' 和'odor' 并返回'goodor'，因为'od' 在两者之间是通用的。同样，它适用于所有组合，包括新形成的字符串'goodor'。

现在假设字符串是'aab' 和'baa'。这将返回两个字符串

1. 'aabaa'（'b'常见）

2. 'baaab'（'aa' 普通）。现在应该是'baab'。

现在'aab' 将再次尝试使用'aabaa'。现在它会返回

1. 'aabaa'（'aab' 普通）

2. 'aabaaaab'（'aa' 常见）。现在应该是'aabaab'。

这将永远持续下去。

地点

print "fraghelper",strings[x],strings[y],fraghelper(strings[x],strings[y])

在第 29 行之后自己看东西。

在测试 3 中，这就是正在发生的事情。测试也是如此。

你当前的算法是：

1. 一次比较两个原始列表的所有字符串

2. 如果可能，创建新字符串并附加到原始字符串

3. 使用附加列表再次运行整个程序（在'aab'、'baa' 等字符串的情况下中断，因为它们会继续创建字符串）

我认为您可以通过以下方式实现您的目标：

1. 一次比较两个原始列表的所有字符串

2. 新建并追加到新列表

3. 向函数发送新列表（仍然是 aabaa 等递归字符串，因为需要添加 failure.logic。）