def gera_todas_palavras_validas(letras):
'''funcao adicional
gera todas as palavras validas, segundo a gramatica, que podem
ser construidas a partir do tuplo de letras que e introduzido
gera_todas_palavras_validas: tuplo -> conjunto_palavras'''
lista_palavras = list()
# inicializa uma lista, em que cada elemento e um caracter do tuplo
for ch in letras:
if ch not in lista_palavras:
lista_palavras = lista_palavras + [ch]
for n in range(1, len(letras)):
# a cada iteracao, concatena as letras as palavras existentes
# acrescenta a uma lista se ja la nao estiver
l = len(lista_palavras)
for i in range(l):
for ch in letras:
palavra = lista_palavras[i] + ch
if e_par_para_potencial(
palavra,
letras) == 0 and palavra not in lista_palavras:
lista_palavras = lista_palavras + [palavra]
c = cria_conjunto_palavras()
# filtra a lista, passando o para um conjunto de palavras,
# onde as palvras sao validas de acordo com a gramatica
for palavra in lista_palavras:
if e_palavra(palavra):
acrescenta_palavra(c, cria_palavra_potencial(palavra, letras))
return c
def gera_todas_palavras_validas(letras):
'''funcao adicional
gera todas as palavras validas, segundo a gramatica, que podem
ser construidas a partir do tuplo de letras que e introduzido
gera_todas_palavras_validas: tuplo -> conjunto_palavras'''
lista_palavras = list()
for ch in letras:
if ch not in lista_palavras:
lista_palavras = lista_palavras + [ch]
for n in range(1, len(letras)):
l = len(lista_palavras)
for i in range(l):
for ch in letras:
palavra = lista_palavras[i] + ch
if e_par_para_potencial(
palavra,
letras) == 0 and palavra not in lista_palavras:
lista_palavras = lista_palavras + [palavra]
c = cria_conjunto_palavras()
for palavra in lista_palavras:
if e_palavra(palavra):
acrescenta_palavra(c, cria_palavra_potencial(palavra, letras))
return c
def gera_todas_palavras_validas(letras):
'''
####### Funcao Adicional #######
A funcao gera_todas_palavras_validas gera todas as palavras possiveis dado um tuplo de letras respeitando uma gramatica.
Se possuir caracteres invalidos, levanta erro.
###> gera_todas_palavras_validas(('A','E','L'))
###> ['A', 'E', 'LA', 'LE', 'AEL', 'ALE', 'ELA', 'LAE']
################################
'''
lst = cria_conjunto_palavras()
tam = len(letras)
i = 1
while i <= tam:
lst += list(permutations(letras,i))
i+=1
nova = cria_conjunto_palavras()
#Como as permutacoes sao do tipo ('A','L','E'), este ciclo vai percorrer cada elemento dos novos tuplos criados e vai juntar todas as letras do tuplo.
# ('A','L','E') ----> ('ALE')
for i in range(len(lst)):
nova.append(''.join(lst[i]))
outro = []
#Verifica se a palavra respeita a gramatica
#verifica se esta no conjunto de palavras para descobrir, isto porque podem existir palavras com as mesmas letras ('A','L','A'),se for dado um tuplo com letras repetidas. Em contrario adiciona ao conjunto
for e in range(len(nova)):
if e_palavra(nova[e]) and cria_palavra_potencial(nova[e],letras):
if nova[e] in outro:
continue
else:
outro.append(nova[e])
return outro
def gera_todas_palavras_validas(letras):
"""
Recebe um tuplo letras e devolve um conjunto_palavras com
todas as palavras validas de acordo utilizam as letras do tuplo.
gera_todas_palavras_validas: tuplo de letras -> conjunto_palavras
"""
conj = cria_conjunto_palavras()
for i in range(1, len(letras) + 1):
for perm in permutations(letras, i):
combo = str.join('', perm)
if e_palavra(combo):
acrescenta_palavra(conj, cria_palavra_potencial(combo, letras))
return conj
def gera_todas_palavras_validas(letras):
"""
Devolve um conjunto_palavras com todas as palavras_validas possiveis de gerar com o conjunto de letras
Argumentos:
letras -- tuplo
"""
conj = cria_conjunto_palavras()
lst = []
for tamanho in range(1, len(letras) + 1):
lst += [''.join(l) for l in permutations(letras, tamanho)]
for e in lst:
if e_palavra(e):
acrescenta_palavra(conj, cria_palavra_potencial(e, letras))
return conj
def gera_todas_palavras_validas(tuplo):
"""
tuplo de letras --> conjunto_palavras
"""
aux_lst = []
#Para todos os tamanhos possiveis de gerar
for i in range(1, len(tuplo) + 1):
#Para todas as permutacoes com cada um desses tamanhos
for j in list(itertools.permutations(list(tuplo))):
#Para cada combinacao dessas permutacoes
for k in list(itertools.combinations(j, i)):
#Se a juncao das letras da lista for uma palavra
if e_palavra(cria_palavra_potencial("".join(k), tuplo)):
#Entao junta as palavras validas
aux_lst.append("".join(k))
#No final apresenta a lista de pal. validas sem repeticoes usando o set()
return list(set(aux_lst))
def gera_todas_palavras_validas(tuplo_letras): """ :Descricao gera_todas_palavras_validas: Dado um tuplo de letras gera todas as palavras validas \ associadas a Gramatica Guru, que e possivel formar usando exclusivamente as letras do tuplo :param tuplo_letras: Tuplo que contem as letras que podem ser utilizadas na palavra :return: Conjunto de palavras validas """ list_permutations = cria_conjunto_palavras() for tam in range(1, len(tuplo_letras)+1): for tuplo in permutations(tuplo_letras, tam): str_permutation = '' for letter in tuplo: str_permutation += letter if e_palavra(str_permutation): acrescenta_palavra(list_permutations, cria_palavra_potencial(str_permutation, tuplo_letras)) return list_permutations
def gera_todas_palavras_validas(letterSet):
"""
tuplo de letras --> conjunto_palavras
"""
if not isinstance(letterSet, tuple):
raise ValueError("gera_todas_palavras_validas: argumento invalido.")
validWordSet = cria_conjunto_palavras()
if len(letterSet) > 0:
for wordSize in range(1, len(letterSet) + 1):
for permutation in itertools.permutations(letterSet, wordSize):
word = ""
for letter in permutation:
word = word + letter
if e_palavra(word):
acrescenta_palavra(validWordSet,
cria_palavra_potencial(word, letterSet))
return validWordSet