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'。这会返回两个字符串

'aabaa'（'b'普通）
'baaab'（'aa'常见）。现在这应该是'baab'。

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

'aabaa'（'aab'普通）
'aabaaaab'（'aa'常见）。现在这应该是'aabaab'。

这将永远持续下去。

放置

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

自己看东西。

在测试3中，这就是正在发生的事情。同样适用于测试。

您当前的算法是：

一次比较两个原始列表的所有字符串
如果可能，请创建新字符串并附加到原始
使用附加列表再次运行整个事件（在'aab'，'baa'等字符串的情况下中断，因为它们不断创建字符串）

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

一次比较两个原始列表的所有字符串
新建并附加到新列表
向该函数发送新列表（仍然像aabaa这样的递归字符串会因为失败而需要添加。）

一个帮助函数，可以阻止此代码进行无限递归。

1 个答案: