Tukukkk

I have a crossword in a matrix, like this one:

[

    ['TENNTP'],

    ['RCATIA'],

    ['VIRGWT'],

    ['ALEXNR'],

    ['NOHTYP'],

    ['NPLBTU']

]

and a list of solutions to the puzzle:
['CAT', 'PYTHON', 'PIGEON', 'ALEX']

I have to find the solutions in the puzzle (they can be find in every position/direction) and return a string with all the letters that aren't letters of the solutions.

For this matrix/crossword the string in return is:
'TENNTRAVIRWTNRPLNTU'
This is my code, but it doesn't work on certain crosswords and I can't find what's wrong.

def es1(ftesto):

lista_soluzioni=

matrice=

puzzle=''

parole_da_trovare=''

lenght=0

lista_da_txt=open(ftesto, 'r').readlines()

inizio=0

x=0

dizionario_parole_usate={}

while lista_da_txt[x]=='n':

    inizio+=1

    x+=1

righe=lista_da_txt[inizio]

righe=len(''.join(righe.split()))

while (lista_da_txt[inizio]!='n'):

    long=''.join(lista_da_txt[inizio].split())

    puzzle=puzzle +long+ 'n'

    inizio+=1

cruciverba=puzzle.replace('n','')

y=0

for x in range(len(cruciverba)+1):

    if x%righe==0 and x!=0:

        ls=list(cruciverba[y:x])

        matrice.append(ls)

        ls=

        y+=righe

lista_soluzioni=lista_da_txt[inizio:]

lista_soluzioni.sort()

a=lista_soluzioni.count('n')

del lista_soluzioni[0:a]

for i in range(0, len(lista_soluzioni)):

    parole_da_trovare=lista_soluzioni[i]

    lenght=len(parole_da_trovare)-1

    lista_soluzioni[i]=parole_da_trovare[0:lenght]

lunghezza= righe+1

lettere=[(letter, divmod(index, lunghezza))

            for index, letter in enumerate (puzzle)]

for i in lettere:

    dizionario_parole_usate.setdefault(i[1],0)

del lettere[-1]

parole_per_direzione= {}

direzioni= {'verso il basso':0, 'in diagonale a sx verso il basso':-1, 'in diagonale a dx verso il basso':1}

for parola, direzioni in direzioni.items():

    parole_per_direzione[parola] = 

    for x in range(lunghezza):

        for i in range(x, len(lettere), lunghezza + direzioni):

            parole_per_direzione[parola].append(lettere[i])

        parole_per_direzione[parola].append('n')

parole_per_direzione['verso dx'] = lettere

parole_per_direzione['verso sx'] = [i for i in reversed(lettere)]

parole_per_direzione['verso l'alto'] = [i for i in reversed(parole_per_direzione['verso il basso'])]

parole_per_direzione['in diagonale a sx verso l'alto'] = [i for i in reversed(parole_per_direzione['in diagonale a dx verso il basso'])]

parole_per_direzione['in diagonale a dx verso l'alto'] = [i for i in reversed(parole_per_direzione['in diagonale a sx verso il basso'])]

#print(parole_per_direzione)

for direzione, tuple in parole_per_direzione.items():

    stringa=''.join([i[0] for i in tuple if i[0]!='n'])

    stringa= ''.join([i[0] for i in tuple])

    for parola in lista_soluzioni:

        if parola in stringa:

            coordinate= tuple[stringa.index(parola)][1]

            #print (parola, 'è nella fila', coordinate[0]+1, 'e nella colonna', coordinate[1]+1, direzione + ".")

            x=coordinate[0]

            y=coordinate[1]

            i=0

            word=''

            if direzione=='verso il basso':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    x+=1

                    i+=1                    

            elif direzione=='verso l'alto':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    x-=1

                    i+=1                    

            elif direzione=='verso dx':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    y+=1

                    i+=1                    

            elif direzione=='verso sx':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    y-=1

                    i+=1                    

            elif direzione=='in diagonale a sx verso l'alto':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    x-=1

                    y-=1

                    i+=1                    

            elif direzione=='in diagonale a dx verso l'alto':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    x-=1

                    y+=1

                    i+=1                    

            elif direzione=='in diagonale a sx verso il basso':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    x+=1

                    y-=1

                    i+=1

            elif direzione=='in diagonale a dx verso il basso':

                while i!=len(parola):

                    word+=matrice[x][y]                        

                    dizionario_parole_usate[(x,y)]+=1

                    x+=1

                    y+=1

                    i+=1

a=list(dizionario_parole_usate.keys())

soluzione=''

for x in range(len(a)):

    if a[x][1]==righe:

        del dizionario_parole_usate[a[x]]

dizionario_parole_usate={k:v for k,v in dizionario_parole_usate.items() if v==0}

for x in range(len(lettere)):

    for key in dizionario_parole_usate:

        if lettere[x][1]==key:

            soluzione+=lettere[x][0]

return soluzione