class NodoZeppa:
    def __init__(self, p):
        self.parola=p
        self.figli=[]

    def conta_parole(self):
        if not self.figli:
            return 1
        res = 1
        for figlio in self.figli:
            res+=figlio.conta_parole()
        return res

    def conta_parole_distinte(self):
        return len(self.parole_distinte())

    def parole_distinte(self):
        s=set()
        s.add(self.parola)
        for figlio in self.figli:
            s.update(figlio.parole_distinte())
        return s

    def conta_parole_foglia(self):
        if not self.figli:
            return 1
        res = 0
        for figlio in self.figli:
            res += figlio.conta_parole_foglia()
        return res

    def parole_foglia(self):
        s=set()
        if not self.figli:
            s.add(self.parola)
            return s
        for figlio in self.figli:
            s.update(figlio.parole_distinte())
        return s
    

    def stampa_parole(self):
        print(self.parola)
        for figlio in self.figli:
            figlio.stampa_parole()

    def altezza(self):
        '''Ritorna l'altezza dell'albero, ovvero la lunghezza del piu'
           lungo cammino dalla radice a una foglia dell'albero'''

    def cammini_parola(self, p):
        ''' Ritorna un insieme (tipo set) che per ogni nodo u dell'albero
            con la parola p, contiene una tupla della sequenza
            delle parole dei nodi dalla radice dell'albero fino al nodo u.
            esempio se invochiamo cammini_parola('spostata') dal nodo 'posta'
            otteniamo set(('posta','posata','sposata','spostata'), ('posta',
            'sposta','sposata','spostata')) '''

    def parole_occorrenze(self):
        ''' Ritorna un dizionario in cui per ogni parola presente nell'albero
            il valore e' il numero di volte che essa e' presente nell'albero '''

    def parole_maxFreq(self):
        ''' Ritorna un set con le parole di massima frequenza nell'albero '''

    def parole_lunghezza(self, l):
        ''' Ritorna un set con le parole di lunghezza l nell'albero '''

    def parole_maxLun(self):
        ''' Ritorna un set con le parole di lunghezza massima nell'albero '''

    def nodo_grado_max(self):
        ''' Ritorna il nodo con il grado massimo dell'albero '''

    def grado_max(self):
        ''' Ritorna il grado massimo dell'albero '''
        
    def parole_maxPro(self):
        ''' Ritorna le lista delle parole che si trovano nella profondita' 
            massima nell'albero ordinate lessicograficamente'''

    def parole_lunghezza_checontengono(self, l, s):
        ''' Ritorna un set con le parole di lunghezza l nell'albero che
            contengono la sequenza s'''

with open('parole_italiane.txt') as f:
    dizionario=set(f.read().split('\n'))

def genera_albero_zeppe(p):
    global dizionario
    if p in dizionario:
        radice = NodoZeppa(p)
        parole_figli=set()
        for i in range(len(p)+1):
            #for c in 'abcdefghijklmnopqrstuvwxyz':
            for c in range(ord('a'), ord('z')+1):
                newp=p[:i]+chr(c)+p[i:]
                if newp in dizionario and newp not in parole_figli:
                    parole_figli.add(newp)
                    radice.figli.append(genera_albero_zeppe(newp))
        return radice