blocks|key|2671639|text|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%2B1)]
++++words_to_look_for.extend(keywords)

print(words_to_look_for)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2671640|https://stackoverflow.com/questions/7074051/....|unstyled|offset|length|2671641|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/7074051/what-is-the-best-way-to-generate-all-possible-three-letter-strings^0|0|0|1C|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

<pre><code>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)
</code></pre>

<a href="https://stackoverflow.com/questions/7074051/what-is-the-best-way-to-generate-all-possible-three-letter-strings">https://stackoverflow.com/questions/7074051/....</a>

blocks|key|16505|text|不幸的是，我现在对递归函数无能为力，但是如果在创建过程中不过滤，字母/字符的更高数量很容易爆炸成数十亿个潜在的组合，我有一个奇怪的选择，就是迭代已知的单词。无论如何，这些都必须存储在内存中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|16506|EDIT删除了排序，因为它不会提供任何好处，修复了迭代时错误设置为true的问题|16507|#+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)|code-block|syntax|javascript|16508|你可以从itertools+documentation中复制并粘贴一个乘积函数，然后使用ExtinctSpecie提供的代码，它没有更多的依赖关系，但是我发现在没有调整的情况下，它会返回所有可能的选项，包括我不能立即理解的字符的重复。|offset|length|16509|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%2B[y]+for+x+in+result+for+y+in+pool]
++++for+prod+in+result:
++++++++yield+tuple(prod)|16510|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/itertools.html#itertools.product^0|0|0|0|E|D|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$K|10|L|11|1|12]]|A|$]]|$1|M|3|N|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Unfortunately I cannot help just now with a recursive function, but given that a higher count of letters/characters can easily explode into billions of potential combinations if not filtered during creation I have a quirky alternative by iterating over the known words. Those have to be in memory anyway.

[EDIT] Removed the sorting as it does not really provide any benefit, fixed an issue where I falsely set to true on iteration

<pre><code># 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) &gt; 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)
</code></pre>

You could copy&amp;paste a product function from the itertools <a href="https://docs.python.org/3/library/itertools.html#itertools.product" rel="nofollow noreferrer">documentation</a> and use the code provided by ExtinctSpecie, it has no further dependencies, however I found without tweaking it returns all potential options including duplications of characters which I did not immediately understand.

<pre><code>def product(*args, repeat=1):
 # product('ABCD', 'xy') --&gt; Ax Ay Bx By Cx Cy Dx Dy
 # product(range(2), repeat=3) --&gt; 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)
</code></pre>

blocks|key|2671817|text|如上所述，这将是不可行的，因为任何超过你的双手可计数的字母数量。有太多的可能性需要检查。但是如果你尝试这样做，代码看起来会是这样的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2671818|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|code-block|syntax|javascript|2671819|这将不会尝试重复字母的单词(这将是另一层疯狂)，但它将尝试所有可能的潜在单词，这些单词可能由您以任何顺序给出的字母子集组成。|2671820|编辑刚刚意识到你请求了一个递归解决方案。不知道这是否是必需的，但是powerset函数可以更改为递归的。不过，我认为这会让它更难看，更难理解。|2671821|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

As noted above, this will not be feasible for any more than the number of letters countable on your two hands. There's just too many possibilities to check. But if you were to try this, here's how the code would look.

<pre><code>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
</code></pre>

This won't try words with duplicate letters (that would be another layer of insanity), but it will try all possible potential words that could be formed by a subset of the letters you give in any order.

[edit] Just realized you requested a recursive solution. Dunno if that's required or not, but the powerset function could be changed to be recursive. I think that would make it uglier and harder to comprehend, though.

blocks|key|2462541|text|我同意@dparolin关于处理单词文件以查看单词是否符合字母的观点，而不是生成可能的单词并查看它们是否在文件中。这允许我们不将文件读入内存，因为我们一次只需要检查一个单词。这可以通过一个递归测试来完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2462542|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)|code-block|syntax|javascript|2462543|示例用法|offset|length|style|BOLD|2462544|%25+python3+test.py
act
at
bat
cab
cat
tab
tact
%25|2462545|而且我们应该能够处理大量的信件而不会出现问题。|2462546|entityMap^0|0|0|0|4|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I agree with @dparolin about processing the words file to see if words conform to the letters, not generating possible words and seeing if they are in the file. This allows us not to read the file into memory, as we only need to examine one word at a time. And it can be done with a recursive test:

<pre><code>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)
</code></pre>

EXAMPLE USAGE

<pre><code>% python3 test.py
act
at
bat
cab
cat
tab
tact
%
</code></pre>

And we should be able to work with lots of letters without issue.

given letters: example of letters

<pre><code>letters = 'hutfb' 
</code></pre>

I am given a file with a list of words.

I need to write a recursive function that allows me to check all possibilities the letters can make. If the possibility is in the list of words from the file, I need to print that specific word. 

so for letters given

they can create the words:

<ul>
<li>a</li>
<li>cat</li>
<li>ac</li>
<li>act</li>
<li>cab</li>
</ul>

and so on and on 

each combination the letters make I need to check the file to see if its a valid word. if it is I need to print them. 

I don't know how start to write this function.

recursive function for wordsearch

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

给定字母:字母示例letters = 'hutfb' 我得到了一个包含单词列表的文件。我需要写一个递归函数，它允许我检查字母可能产生的所有可能性。如果可能出现在文件中的单词列表中，则需要打印该特定单词。所以对于给定的字母他们可以创造这样的单词：acatacactcab如此这般每一个字母的组合，我需要检查文件，看看它是否...

问用于单词搜索的递归函数
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用于单词搜索的递归函数EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用于单词搜索的递归函数
EN