Question

经历了整整一天，无法弄清楚该怎么做，我觉得我需要在这里使用递归函数，任何技巧都很棒（采取的步骤，算法等）

给定单词w，将w的良好子序列定义为单词w'，使得

w'中的所有字母都不相同；
w'是通过删除w中的一些字母从w获得的。

以字典顺序返回所有良好子序列的列表，没有重复项

预期结果：

def good_subsequences(word):
'''
>>> good_subsequences('')
['']
>>> good_subsequences('aaa')
['', 'a']
>>> good_subsequences('aaabbb')
['', 'a', 'ab', 'b']
>>> good_subsequences('aaabbc')
['', 'a', 'ab', 'abc', 'ac', 'b', 'bc', 'c']
>>> good_subsequences('aaabbaaa')
['', 'a', 'ab', 'b', 'ba']
>>> good_subsequences('abbbcaaabccc')
['', 'a', 'ab', 'abc', 'ac', 'acb', 'b', 'ba', 'bac', 'bc', 'bca', 'c', 'ca', 'cab', 'cb']
>>> good_subsequences('abbbcaaabcccaaa')
['', 'a', 'ab', 'abc', 'ac', 'acb', 'b', 'ba', 'bac','bc', 'bca', 'c', 'ca', 'cab', 'cb', 'cba']
>>> good_subsequences('abbbcaaabcccaaabbbbbccab')
['', 'a', 'ab', 'abc', 'ac', 'acb', 'b', 'ba', 'bac','bc', 'bca', 'c', 'ca', 'cab', 'cb', 'cba']
'''

我在想的是

def good_subsequences(word):
L = ['']
current_char = ''
for i in range(0,len(word)):
    if  current_char != word[i]:
        L.append(word[i])
        current_char = word[i]
L = ''.join(L)
#call up _good_sub(L)

def _good_sub(word):
    #do a recursive function

Answer 1

您可以开始执行以下操作：

def good_subsequences(word):
    Letter_order = [word[0]]
    substrings = ['']
    for i in range(1,len(word)):
        if  Letter_order[-1] != word[i]:
            Letter_order .append(word[i])

现在，在for循环之后，您有了一个数组，该数组具有需要包含在最终子字符串数组中的所有字母顺序。在这里，您可能可以使用一个辅助函数，根据Letter_order数组中的字母顺序，依次检查所有可能的字母组合。

Answer 2

这只是蛮力。当您的字母中有许多不同的字符时，请不要尝试此操作...但是，如果您有很多重复的字符，则效果可能不错。

from itertools import combinations, permutations

def in_word(strg, word):
    i = 0
    for char in strg:
        try:
            i = word.index(char, i)
        except ValueError:
            return False
    return True

def good_subsequences(word):
    ret = ['']
    alphabet = set(word)
    for r in range(len(alphabet)):
        for comb in combinations(alphabet, r+1):
            for perm in permutations(comb, r+1):
                strg = ''.join(perm)
                if in_word(strg, word):
                    ret.append(strg)
    return ret

它使用set将输入减少为唯一字母，然后循环遍历1、2、3，...，n个字母组合，然后循环遍历这些组合。 in_word然后检查该排列是否以您的原始单词（按顺序）出现。

Answer 3

与某些蛮力解决方案相比，具有后续排序的递归生成器方法，并且几乎没有超量生产：

from itertools import groupby

def simple(word, without=''):
    # remove adjacent duplicates and anything in 'without'
    return ''.join(k for k, _ in groupby(word) if k not in without)

def _gs(word):
    seen = set()
    s_word = simple(word)
    yield ''
    for i, char in enumerate(s_word):
        for sub in _gs(simple(s_word[i+1:], char)):
            new_sub = char + sub
            if new_sub not in seen:
                seen.add(new_sub)
                yield new_sub

def good_subsequences(word):
    return sorted(_gs(word))

>>> good_subsequences('')
['']
>>> good_subsequences('aaa')
['', 'a']
>>> good_subsequences('aaabbb')
['', 'a', 'ab', 'b']
>>> good_subsequences('aaabbc')
['', 'a', 'ab', 'abc', 'ac', 'b', 'bc', 'c']
>>> good_subsequences('aaabbaaa')
['', 'a', 'ab', 'b', 'ba']
>>> good_subsequences('abbbcaaabccc')
['', 'a', 'ab', 'abc', 'ac', 'acb', 'b', 'ba', 'bac', 'bc', 'bca', 'c', 'ca', 'cab', 'cb']

Answer 4

这仅提取连续的子序列

我相信这是一个简单的贪婪搜索：

def good_subsequences(w):
    L = {''}
    j = 0
    for i in range(len(w)):
        for k in range(i, j):
            L.add(w[i:j])
        while j < len(w) and w[j] not in w[i:j]:
            j += 1
            L.add(w[i:j])
    return L

在您的示例中，有一件事我不理解。为什么'abbbcaaabccc'会生成'bac'？

Answer 5

也许这不是一个“完整”的答案，并且没有为您提供代码，但这是针对问题的一种算法方法。

首先以与原始问题相同的方式重新表达问题。但是“接近”可能的实现。

输入单词w，找到

最长的好子序列（不同字母的最长的子序列）
一个好的子序列的所有子序列都是好的（但是不同的长序列的子序列可能会重叠： abc 和 acb 都具有 ab 作为子序列）

第二部分很容易处理（只需建立子序列并消除重复项）

要获得最长的字母，您需要将每个字母保留一次，并保留不同的位置。

但是首先，请注意重复字母并不重要。 aaabbbbbbbccaaa 将具有与 abca 相同的输出。因此，第一，清除所有连续的重复项

现在，您需要将每个字母的所有位置相互结合。例如。如果单词 a 在您的单词中出现3次，则需要尝试3次。如果字母b出现两次，则需要尝试两次，依此类推。示例：

Abacba最多包含3x2x1 = 6个，每个包含一个a，一个b和一个c => abc，acb，bac，acb，bca和cba。

现在删除重复的最长的好序列，并继续到上面的第二个要点

有关在给定字符串的情况下查找单词序列的算法或步骤的提示

5 个答案: