Cómo resolver el siguiente rompecabezas de encontrar una palabra

Answer 1

Aquí hay una forma de resolverlo:

1. Encuentra una lista de palabras en francés. Una búsqueda de “lista de palabras del diccionario francés txt” nos da este sitio – WinEdt.org – Diccionarios, que aparentemente contienen archivos de datos del corrector ortográfico.
2. Escriba un programa que use un trie para guiar su búsqueda: cuando ve que el intento actual no es un prefijo de ninguna palabra, puede abortar de manera segura tratando de extenderlo hacia la derecha.
3. ¡Lucro!

Introduce letras: bagymnaseston
Encontrado: gimnasio
Encontrado: gimnasia
Encontrado: gimnasias
Encontrado: nase
Encontrado: nases
Encontrado: ses
Encontrado: est
Encontrado: ton
Introduce letras: ntrendroitss
Encontrado: rend
Encontrado: endroit
Encontrado: endroits
Encontrado: droit
Encontrado: droits
Encontrado: roi
Introduce letras: bbanlieuerrn
Encontrado: prohibición
Encontrado: banlieue
Encontrado: mentira
Encontrado: lieu
Encontrado: lieue
Encontrado: eue

Este diccionario parece contener todas las variantes de las palabras, al menos creo que algunos de los resultados anteriores son solo plurales. Por supuesto, podría usar su propio diccionario: es solo un archivo de texto que contiene una palabra por línea.

Aquí está el programa que, cuando se coloca en la misma carpeta que “fr.dic” (el archivo de diccionario sin comprimir) y se ejecuta con Python 3, produce los resultados anteriores:

class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


class TrieNode:
def __init__(self):
self.word_end = False
self.children = {} def find(self, key):
node = self
for char in key:
if char not in node.children:
return None
else:
node = node.children[char]
return node.word_end def insert(self, key):
node = self
i = 0
n = len(key) while i < n:
if key[i] in node.children:
node = node.children[key[i]]
i += 1
else:
break while i < n:
new_node = TrieNode()
node.children[key[i]] = new_node
node = new_node
i += 1 node.word_end = True french_trie = TrieNode() import codecs
with codecs.open("fr.dic", "r", "utf_16_le") as f:
for line in f:
word = line.strip().lower()
if len(word) > 2:
french_trie.insert(word) def find_french_words(row):
start = 0
end = 2
last = len(row) - 1 while start <= last - 2:
to_check = row[start:end + 1]
res = french_trie.find(to_check)
end += 1
if res is None or end > last:
start += 1
end = min(start + 2, last)
if res:
print("Found: {}".format(to_check)) if __name__ == "__main__":
while True:
find_french_words(input("Enter letters: "))


Presione Ctrl + C para salir. Hacer que tome toda la tabla y generar todas las filas, columnas y diagonales y luego pasarlas a find_french_words() se deja como ejercicio para el lector 😀