Come funziona il generatore automatico di testi

Nel post precedente ho parlato di un generatore automatico di testi in "lingua italiana". Ecco come ho fatto a costruirlo (ho usato il python perché mi piace, ma anche chi non lo conosce dovrebbe essere in grado di seguire il sorgente, il linguaggio non lo conosco bene nemmeno io e quindi non ho usato costruzioni strane e incomprensibili).

L'idea di base è questa: non faccio una analisi statistica del testo, perché tenere una tabella delle frequenze di tutte le possibili sestine diventa improponibile. Uso invece il testo stesso come generatore.

E cioè: leggo il testo in memoria e, quando ho bisogno di generare un carattere, estraggo una lettera a caso dal testo. E fin qua è facile.

Se devo generare delle coppie di caratteri, invece, faccio così: all'inizio leggo una lettera a caso, poi a partire da un punto casuale del testo cerco la prima occorrenza di quella particolare lettera, e scelgo la lettera immediatamente successiva. Memorizzo quest'ultima lettera e continuo così.

Se poi devo generare delle terne tengo in memoria una coppia di lettere, e a partire da un punto casuale del testo cerco quella coppia e prendo la lettera successiva, e così via.

Vediamo un po' se si capisce il sorgente. Partiamo così:

f=open("i_promes.txt","r")

testo=f.read()

testo=testo.replace("\x0D","")
testo=testo.replace("\x0A","")

N=len(testo)

from random import randrange

M = 1000 #dimensione massima del testo da generare
K = 6 #memoria del generatore casuale

buffer=testo[randrange(N)]
if K==0:
  buffer=""

output=""

Dovrebbe essere semplice: leggo tutto il file all'interno della variabile testo, tolgo dai piedi i caratteri di line feed e carriage return, memorizzo in N la lunghezza del testo, e importo la funzione che mi serve per generare numeri casuali. Poi definisco M, la lunghezza del testo che deve essere generato, e K, la memoria del generatore (nello scorso post ho mostrato il risultato per i valori di K che vanno da 0 a 6).

Poi inizializzo un buffer che memorizzerà i caratteri che dovrò cercare (ma se K è uguale a zero il buffer non mi serve, quindi lo riazzero (lo so, era più elegante inserire un if, ma questa è una correzione dell'ultimo minuto…), e preparo la variabile che memorizzerà l'output e che si chiama, giustamente, output.

Ora viene il bello: la funzione che cerca, all'interno del testo, la prima occorrenza dei caratteri contenuti nel buffer. Il testo viene immaginato infinito, quando arrivo alla fine ricomincio dall'inizio.

def trova(lista,posizione):
  #restituisce il carattere successivo a quelli presenti nella lista
  #a partire dalla posizione data, cerca la prima occorrenza di lista
  #(l'ho chiamata lista, ma e' poi una stringa, ehm)
  l=len(lista)

  if l==0:
    return randrange(N)
  
  trovato = False
  c=0
  j=(posizione) % N

  while not trovato:

    if lista[c]==testo[j]:
      c+=1
    else:
      j=j-c #devo riportare indietro j, maledetto
      c=0

    if c==l:
      trovato=True

    j+=1
    j%=N

  return j%N

Questa funzione trova la posizione in cui compaiono tutti i caratteri di lista, a partire dalla posizione indicata dalla variabile posizione. Le prime righe fanno funzionare il generatore senza memoria: se la lista l è vuota, restituisci un numero casuale e basta. Altrimenti vai avanti.

La variabile trovato si occupa di fare terminare il ciclo; all'inizio non ho ancora trovato niente e quindi è settata a False. La variabile c serve per scorrere il buffer, e la j invece scorre il testo (la j viene sempre usata modulo N, in modo da essere riazzerata se supera N).

Poi comincia il ciclo di ricerca: fino a che non è stato trovato tutto ciò che è contenuto nel buffer si fa una ricerca: se il primo carattere del buffer è uguale al carattere nel testo, aumento c di 1 (così successivamente proverò col secondo carattere del buffer, col terzo, eccetera), altrimenti vado avanti. Il vado avanti mi ha fatto penare, e questo è il motivo del commento nella riga j=j-c.

Le cose stanno in questo modo: supponiamo che il buffer contenga le lettere "abc" e che nel testo siano presenti invece le lettere "aabc". Allora il primo confronto ha successo, ma il secondo no: c viene riazzerato, ma j non deve proseguire dal terzo carattere del testo, cioè b, ma deve tornare indietro. So che mi sono spiegato male, ma provate a togliere la riga maledetta e vedrete che non funziona più.

Il resto è facile: se c è uguale alla lunghezza del buffer l, ho trovato tutto quello che cercavo. Segnalo il tutto settando la variabile trovato e restituisco j (che è stato già incrementato di 1 e che quindi punta al primo carattere dopo la stringa trovata). Ed ecco fatto.

Manca il programma principale, molto semplice:

for i in xrange(M):
    j=trova(buffer,randrange(N))
    buffer+=testo[j]
    output+=testo[j]
    if len(buffer)>K:
      buffer=buffer[1:] #cancello il primo carattere


print output

Faccio un ciclo lungo M, all'interno del quale chiamo la funzione trova. Aggiungo al buffer e a output il nuovo carattere restituito da trova, e se il buffer è troppo lungo lo accorcio.

Fine.

Se avete idee per migliorare, dite pure. Con un generatore a memoria 6 comincia a diventare lento.