用于单词搜索的递归函数

Question

给定字母：字母示例

letters = 'hutfb' 

我收到了一个包含单词列表的文件。

我需要编写一个递归函数，让我可以检查字母的所有可能性。如果可能在文件中的单词列表中，我需要打印该特定单词。

所以对于给定的字母

他们可以创造单词：

• 一个
• 猫
• 交流
• 行动
• 出租车

等等等等

字母组成的每个组合我都需要检查文件以查看它是否是有效的单词。如果是我需要打印它们。

我不知道怎么开始写这个函数。

Answer 1

我同意@dparolin 关于处理单词文件以查看单词是否符合字母，而不是生成可能的单词并查看它们是否在文件中。这使我们不必将文件读入内存，因为我们一次只需要检查一个单词。并且可以通过递归测试来完成：

letters = 'catbt'

def is_match(letters, word):

    if not word:
        return True

    if not letters:
        return False

    letter = letters.pop()

    if letter in word:
        word.remove(letter)

    return is_match(letters, word)

with open('words.txt') as words:
    for word in words:
        word = word.strip()

        if is_match(list(letters), list(word)):
            print(word)

示例用法

% python3 test.py
act
at
bat
cab
cat
tab
tact
%

我们应该能够毫无问题地处理大量信件。

Answer 2

不幸的是，我现在对递归函数无能为力，但考虑到如果在创建过程中不过滤，更多的字母/字符很容易爆炸成数十亿个潜在组合，我有一个通过迭代已知单词的古怪替代方案。无论如何，这些都必须在内存中。

[编辑] 删除了排序，因为它并没有真正提供任何好处，修复了我在迭代时错误地设置为 true 的问题

# Some letters, separated by space
letters = 'c a t b'
# letters = 't t a c b'

# # Assuming a word per line, this is the code to read it
# with open("words_on_file.txt", "r") as words:
#     words_to_look_for = [x.strip() for x in words]
#     print(words_to_look_for)

# Alternative for quick test
known_words = [
    'cat',
    'bat',
    'a',
    'cab',
    'superman',
    'ac',
    'act',
    'grumpycat',
    'zoo',
    'tab'
]

# Create a list of chars by splitting
list_letters = letters.split(" ")

for word in known_words:
    # Create a list of chars
    list_word = list(word)
    if len(list_word) > len(list_letters):
        # We cannot have longer words than we have count of letters
        # print(word, "too long, skipping")
        continue

    # Now iterate over the chars in the word and see if we have
    # enough chars/letters
    temp_letters = list_letters[:]

    # This was originally False as default, but if we iterate over each
    # letter of the word and succeed we have a match
    found = True
    for char in list_word:
        # print(char)
        if char in temp_letters:
            # Remove char so it cannot match again
            # list.remove() takes only the first found
            temp_letters.remove(char)
        else:
            # print(char, "not available")
            found = False
            break

    if found is True:
        print(word)

您可以从 itertools documentation 复制和粘贴产品功能并使用 ExtinctSpecie 提供的代码，它没有进一步的依赖关系，但是我发现不调整它会返回所有潜在选项，包括我没有立即理解的字符重复。

def product(*args, repeat=1):
    # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
    pools = [tuple(pool) for pool in args] * repeat
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)

Answer 3

import itertools
str = "c a t b"
letters = list(str.replace(" ",""))
words_to_look_for = []

for index, letter in enumerate(letters):
    keywords = [''.join(i) for i in itertools.product(letters, repeat = index+1)]
    words_to_look_for.extend(keywords)

print(words_to_look_for)

https://stackoverflow.com/questions/7074051/....

Answer 4

如上所述，这不会仅适用于你双手可数的字母数量。有太多的可能性要检查。但是，如果您要尝试此操作，代码将如下所示。

letters = ['a', 'b', 'c']

def powerset(letters):
    output = [set()]
    for x in letters:
        output.extend([y.union({x}) for y in output])
    return output

for subset in powerset(letters):
    for potential_word in map(''.join, itertools.permutations(list(subset))):
        # Check if potential_word is a word

这不会尝试包含重复字母的单词（那将是另一层疯狂），但它会尝试所有可能的潜在单词，这些单词可能由您以任意顺序输入的字母的子集构成。

[编辑] 刚刚意识到您要求递归解决方案。不知道是否需要这样做，但是可以将 powerset 函数更改为递归。不过，我认为这会使它变得更丑陋，更难理解。