Ok.
Allora, iniziamo. Abbiamo un formato un
po' particolare stamattina
e ho deciso che oggi continuiamo con
esercitazioni, così continuiamo a vedere
un po' di cose che abbiamo visto ieri
riguardo eh macchine di touring non
deterministiche.
E riprendiamo dall'esercizio che abbiamo
lasciato ieri.
Come ultimo, non so se avete tentato
una risoluzione, ora lo trascrivo prima.
Allora, qua che abbiamo?
Allora, avevamo un linguaggio
L,
un linguaggio L tale che X^
N cancelletto
V con 1 cancelletto bla bla bla
cancelletto
V con Nale
che N è più grande di 0.
I V con I appartengono a
A B C D plus
e poi per ogni I tale che 1 I e va tra 1
ed n
esiste una stringa S con I
tale che
S con I è sottostringa di W con I.
La lunghezza di S con I è propriamente I
e inoltre S con I è uguale al suo
reverse, quindi S con I èindro.
Ok? Allora, eh come vi dicevo ieri, ci
sono vari approcci che possiamo
utilizzare per
risolvere questo esercizio. Ehm
e come
avevate detto voi in aula, qualcuno dei
nostri colleghi ci ha suggerito una
delle possibilità è prelevare nel
momento in cui si processano le varie
stringhe W. Quindi Ah, ok. A parte avere
un nastro in cui abbiamo il il un
contatore che ci tiene traccia di chi
sia l'indice i corrente in maniera tale
da sapere quanto valga. Dopodiché una
possibilità potrebbe essere prelevare S
con i dalla
w con i, cioè quindi andare su W con i,
prelevarne una porzione e poi verificare
che S con i sia una stringa palindroma e
sia della lunghezza giusta. Adesso
questo è un modo, va benissimo, è
corretto,
eh, prenderebbe il massimo dei punti,
ovviamente, se eh se implementato
correttamente a un esame. Ok, quindi da
questo punto di vista non c'è problema.
Eh, la soluzione che vi propongo io è
una soluzione leggermente differente,
eh, solamente perché volevo mostrarvi e
una delle caratteristiche di cosa possa
fare una macchina di Touring non
deterministica, cioè una macchina di
Touring non deterministica una cosa
interessante che può fare è che
eh può scrivere in anticipo su nastro
stringhe che gli serviranno che gli
serviranno dopo. Ok? Come fa a scrivere
queste cose? Beh, semplicemente possiamo
dire che la butti a caso su su un nastro
oppure come la metafora che usavamo ieri
in aula è che la macchina indovina la
stringa che gli servirà successivamente.
Ok? E noi possiamo dire usare questa
metafora, dicevamo ieri, che la macchina
indovini qualcosa solamente se
eh associamo insieme alla fase di gess
una fase di controllo, cioè noi vogliamo
controllare che quello che abbiamo
indovinato sia effettivamente corretto.
Qua nuovamente la questione, andiamo
velocissimo. Spero che sia chiaro dalla
dalla lezione di ieri,
dall'esercitazione di ieri, è che
nuovamente non è che la macchina sia in
grado di indovinare nulla o non è che la
macchina faccia un processamento
contemporaneo di tutte le possibili
computazioni, no? La macchina non fa
niente di tutto ciò perché la macchina
non c'è, perché la macchina non esiste,
è solo un modello astratto per il quale
noi abbiamo definito una condizione di
di accettazione che può essere vista
metaforicamente
come la macchina indovina o la macchina
prova tutte le possibilità. Ok? Cioè,
ognuno si può scegliere la metafora che
gli piace di più. sempre metafora è
l'importante è essere consapevoli che
questa è solamente una metafora, cioè è
un modo per ragionare
e nel momento in cui noi associamo
un guess con un check, la metafora del
indovinare è abbastanza efficace, nel
senso possiamo pensare la macchina come
in grado di eh indovinare quello che
deve deve fare. Ovviamente dobbiamo
usare la fase di controllo per eliminare
tutte le possibilità per la macchina di
accettare quando non dovrebbe. Questo
questa è la ragione. Questa è la ragione
perché senò se la macchina ha un modo di
accettare una stringa, allora su quella
stringa risponderà sì, anche se magari
doveva dire di no. Quindi per escludere
questo genere di possibilità noi
dobbiamo introdurre dei controlli che
filtrano
arrivare a configurazione accettante
quelle scelte sbagliate, insomma. Ok? E
quindi questo si fa con delle fasi di
check che possiamo introdurre
all'interno
eh della funzione di transizione della
macchina. Ok? Allora, quello che io vi
propongo per questa macchina, per questo
esercizio, è una macchina un po'
particolare, perché è una macchina che
la stringa S con i, invece di prelevarla
dalla
eh dalla stringa w con i che ci sta
input,
cioè quindi una cosa è che noi abbiamo w
di qui.
Qui c'è qualcosa che è w. Allora, un
approccio è andarsi a selezionare un
pezzo e metterlo su un nastro
secondario. Ok, prendiamo questa cosa
che abbiamo copiato, dopodiché
verifichiamo che questa sia palinda, no?
un altro modo che è quello che vi mostro
oggi perché è un modo di computare di
macchine di Touring non deterministiche
che ci può tornare utile e soprattutto
quando andremo a guardare la complessità
dei problemi è che sostanzialmente
noi abbiamo la nostra V con i sul nastro
di input. Quello che facciamo prima
è che la macchina scrive qualcosa sul
nastro, sul secondo nastro prima,
dopodiché va a verificare che quanto ha
scritto, a parte essere palindroma,
ovviamente, perché è un controllo che
dobbiamo sempre fare, andiamo a
verificare che questa cosa che abbiamo
indovinato sia effettivamente dentro la
stringa di input. Ok?
Trovo interessante questo modo di
computare della macchina perché in altre
circostanze,
come vedremo per esempio quando
analizziamo la classe NP eccetera,
vedremo che macchine non deterministiche
per quei tipi di problemi
in genere un lavoro che possono fare è
scrivere sul nastro una cosa iniziale
che verificano dopo. Ok? Quindi ecco
perché voglio mostrarvi questo modo di
calcolare in maniera tale da vedere che
in effetti questa macchina può fare
questa cosa, cioè può scrivere su nastro
roba che poi viene controllata
successivamente.
Ok, allora
eh
[Musica]
vediamo un po' come sia possibile
scrivere una macchina del genere.
Soluzione che proponiamo. Quindi, cosa
abbiamo? Sul primo nastro abbiamo
l'input come al solito.
Sul secondo nastro andrò a mettere n che
quindi sono il numero di x nella parte
iniziale della stringa.
Dopodiché
su terzo nastro io vado a memorizzare il
valore corrente di i.
Su quarto nastro andrò a memorizzare S
con I e su quinto nastro andrò a
memorizzare
S con i pure, però poi la leggerò in un
altro verso per avere accesso alla
eh alla stringa reverse. Ok? Quindi
questo è il piano di funzionamento della
macchina. Mi ricopio le X iniziali su
secondo nastro. Su terzo nastro terrò il
contatore I. Su quarto e quinto nastro
andrò a scrivere cose, ok? La macchina
andrà a indovinare che cos'è questa S
con I che fa parte di W con i. Ok,
allora vediamo un po'.
Mi serve un po' di spazio. C'è spazio.
Ok, partiamo da qua.
Quindi partiamo Q0.
Quindi leggiamo delle X primo nastro,
lasciamo X e andiamo avanti. Sul secondo
nastro non c'è niente, scriviamo X e
andiamo avanti e andiamo in Q1.
Questo cosa lo facciamo per tutti i
caratteri, eh.
tutti i caratteri. Quindi c'è X, lascio
X e vado avanti. Sul secondo nastro c'è
blank, scrivo X e vado avanti.
Ok, a un certo punto
eh raggiungeremo
eh il cancelletto. Qui si tratta di fare
un po' di cose trucchettose, cioè si
deve scrivere una macchina che più o
meno funzioni. Quindi che faccio? Supero
il cancelletto? non supero il
cancelletto. Questa è una cosa che uno
può decidere che fare, ok? Dipende uno
da come progetta la macchina. Poi
l'importante è che sia è che sia
consistente. Io qua decido di star
fermo. Eh,
si può fare in tanti mille in tanti
altri modi. Eh, ognuno si sceglie un po'
quello che il più gli aggrada. Ok,
quindi abbiamo in questa prima fase
iniziale della computazione la macchina
ricopia sul secondo astro il numero
delle X, così abbiamo N e e colloca la
eh la testina del secondo nastro eh la
testina del primo nastro la lascia sul
cancelletto. Ok? Allora, sostanzialmente
quello che io andrò a fare è per
verificare che il numero di w è
esattamente n, quello che andremo a fare
è sostanzialmente matchare il numero di
cancelletti che leggiamo con le x che
stanno sul secondo nastro.
Allora, qui possiamo avere una cosa di
questo tipo. Sul primo nastro c'è
cancelletto. Lascio cancelletto e vado
avanti. Sul secondo nastro c'è X, lo
cancello e vado indietro perché avevamo
lasciato la testina
su eh l'ultimo
carattere del secondo nastro. Su terzo
nastro iniziamo a incrementare le X
della I. Quindi c'è blank, scrivo X e
vado avanti perché la prima
stringa che andiamo a controllare è
WD1.
Ok? Dopodiché questo è il passaggio
peculiare di questa cosa qua.
Allora, mi serve un po' più di spazio.
Ok, quindi stiamo superando il primo
cancelletto della prima W.
ci rimuoviamo una X da secondo nastro,
così iniziamo a verificare che le W con
i sono tante quanto N.
Sul terzo nastro iniziamo a scrivere i,
in particolare aggiungiamo una X, poi
faremo in modo che il tutto torni e
quindi lì sul terzo nastro ci andiamo ad
aggiungere le X. Andiamo, per esempio,
in questo arco, quello che facciamo è
andiamo ad aggiungere una X a quello che
nelle computazioni successive sarà la I
precedente, quindi noi andremo ad
agganciare pezzi di X che stanno là
sopra. Però la parte peculiare di questo
di questo arco è questo qui, che noi su
quarto nastro dobbiamo andare a scrivere
la stringa S con I che stiamo ghessando.
E il modo di farlo è estremamente
semplice perché semplicemente noi
diciamo che c'è blank sul quarto nastro,
scriviamo un carattere alfa e andiamo
avanti. Vedete? Non non faccio al
momento nessun tipo di controllo,
semplicemente
sul primo sul quarto nastro non ci sta
niente, ci scrivo qualcosa. Questa è la
decisione che faccio. Siccome su quarto
e quinto nastro ci deve essere la stessa
cosa, allora faccio blank, scrivo alfa e
vado avanti.
Se qui avessi scritto qualcos'altro,
tipo su quinto nastro c'è blank e scrivo
beta con alfa e beta, magari due simboli
completamente arrelated, allora starei
potenzialmente scrivendo due cose
differenti sui due nastri. Siccome a me
serve la stessa cosa, quello che
facciamo è che su quarto nastro e su
quinto nastro non troviamo niente,
scriviamo lo stesso carattere, ma il
carattere che stiamo scrivendo la
macchina lo sta determinando, non
deterministicamente. Questo è la parte è
la parte importante. Ok? Dopodiché noi
dobbiamo scrivere su nastro
che cosa? Dobbiamo scrivere su nastro
una stringa S con I che è lunga tanto
quanto le eh
le X che stanno sul terzo nastro, perché
sulle su terzo nastro abbiamo le I. Ok?
E quindi semplicemente quello che
facciamo è sul terzo nastro c'è x,
lascio x e vado avanti. Sul quarto
nastro c'è blank, scrivo alfa e vado
avanti. Sul quinto nastro c'è blank,
scrivo alfa e vado avanti. Ok? Quindi in
questo stato Q3 e nella
transizione che si muove da Q2 a Q3 io
scrivo non deterministicamente
la eh stringa S con I.
Eh, ok, vedo una domanda. Sì.
Eh, ma nel terzinastro
bisognerebbe fare scrivo, leggo X,
scrivo X e vado indietro perché, cioè,
noi prima abbiamo
black, abbiamo scritto X, siamo andati
avanti. Dipende uno come si organizza la
Dipende uno come si organizza la X.
Dipende se quella X aggiuntiva che io ho
scritto sulla transizione del terzo
nastro la sto appiccicando all'inizio
della X o all'inizio del terzo nastro o
in fondo al terzo nastro. Adesso la
macchina come l'ho organizzata io è che
questa X iniziale di terzo nastro noi
l'attacchiamo all'inizio del contenuto
del terzo nastro. è ovvio che possiamo
metterlo in fondo e e mantenere tutto
coerente. L'importante è che sia
consistente, poi uno si organizza un po'
come vuole. Ok? Però eh cioè
mh però noi nel cioè nel stesso nastro
abbiamo scritto X e siamo andati avanti,
quindi teoricamente noi siamo oltre la X
in questo momento, no? Dipende da dove
ci arriveremo, perché se nel resto della
computazione che ancora non è stata
scritta la macchina prima di riciclare
su Q2 posiziona il terzo nastro sul
blank a sinistra delle X del terzo
nastro, allora la cosa funziona. Ah,
cioè dipende uno da come lo organizza,
eh, non è che c'è un modo singolo per
fare la cosa, l'importante è che sia
consistente. Poi se uno le X le scrive
da sinistra verso destra, da destra
verso sinistra è la stessa cosa. Ok. Ok.
Ok. Eh, vedo un'altra domanda,
guys. C'è una mano alzata,
senò toglietela
che poi diviene difficile tracciarla,
eh.
Ok.
Alri, quindi eh in Q3 cosa stiamo
facendo? Stiamo praticamente scrivendo
questa S con I su quarto e quinto su
quarto e quinto nastro, ok? E lo
facciamo m Non c'è spazio. C'è c'è
spazio. Non c'è spazio. E lo facciamo
fino a quando?
Lo facciamo fino a quando? Sul terzo
nastro. Non ci sta più niente. Quindi
sul terzo nastro
trovo blank, scrivo blank e torno
dietro. Sul quarto nastro c'è blank,
lascio blank e torno dietro. Sul quinto
nastro c'è blank, lascio blank e torno
dietro. Ok,
Q4. Allora,
uno può usare il quarto e il quinto
nastro come vuole. Allora, io il quarto
nastro lo uso per tenere
per controllare S con i e il quinto
nastro lo lo controllo, lo uso per
controllare e se reverse. Quindi mi
riavvolgo il quarto nastro e il quinto
nastro lo lascio lì dov'è. Ovviamente
ognuno può decidere come preferisce, eh.
Allora,
quindi sul quarto nastro c'è alfa,
lascio alfa e torno dietro fino a quando
sul quarto nastro c'è blank. Lascio
blank e vado avanti e andiamo in Q5.
In Q5. Eh, a questo punto
che cosa che cosa succede? Ok, andiamo
un po' più in alto.
Ok, non ci va più di alto di questo. Ok,
allora, in Q5 che cosa succede? In Q5,
praticamente eh
dobbiamo iniziare a trovare dentro w con
1 perché il primo giro sarà poi W con i,
dobbiamo trovare dove inizia S con I.
Questa cosa si può fare non
deterministicamente come abbiamo visto
le altre volte. Quindi semplicemente
cosa facciamo? Saltiamo caratteri sul
primo nastro, quindi C alfa lascio alfa
e vado avanti per arrivare fino al punto
dove inizia questa S così.
La scelta è di tipo non deterministico,
quindi arriveremo a un punto in cui sul
primo nastro c'è alfa, lascio alfa e
vado avanti. Sul quarto nastro c'è alfa.
Scrivo blank e vado avanti. Lo cancello
perché
poi il quarto nastro mi servirà dopo.
Sul quinto nastro c'è elf. Eh sì, alfa.
Alfa. Scrivo blank e torno indietro. Ok.
Quindi, come vedete,
in questo passaggio non solo sto
controllando la presenza di S con I
dentro W con I, ma sto anche verificando
che quello che era stato scritto su
quarto e quinto nastro è effettivamente
una stringa palindroma. Quindi, sul
primo nastro c'è alfa, lascio alfa e
vado avanti. Sul quarto nastro c'è alfa,
scrivo blank e vado avanti. Sul quinto
nastro c'è alfa, scrivo blank e torno
indietro. Ok, lo facciamo per tutti. Ci
fermiamo nel momento in cui il contenuto
di quarto e quinto nastro finisce.
Quindi sul quarto nastro c'è blank,
lascio blank e sto fermo. Sul quinto
nastro c'è blank, lascio blank e sto
fermo. Ok. E andiamo in Q7.
Ok. A questo punto
dobbiamo collegare i pezzi della
macchina. i pezzi della macchina perché
sostanzialmente dobbiamo o riciclare
verso Q2 nel momento in cui siamo nelle
W in mezzo oppure se le abbiamo viste
tutte eh quello che facciamo è andare a
verificare
il solito controllo di sanità
dell'input, cioè che non ci sia un
cancelletto che stia in fondo. Ok?
Allora, supponiamo di eh andare a
verificare le altre W con i come
facciamo a sapere che ci aspettiamo di
leggere altre W con i e non è che invece
era stata letta l'ultima?
È chiaro che ab quello che abbiamo fatto
finora.
Prego, prego.
Mi sente? Sì, sì, sì, sì, ora sì. Eh,
beh, non sappiamo a che punto siamo
arrivati in generale della nostra doppia
pupini, quindi continuiamo a leggere
alfa finché non raggiungiamo o un
cancelletto o un black.
Ok. Sì, ma in Q7 se noi vogliamo sapere
se dopo ci aspettiamo un'altra
eh un'altra W con i, come facciamo a
saperlo?
È ovvio che ci sono 1000 modi per farlo,
eh cioè si può fare anche quello che
dice lei, si arriva fino in fondo e e si
verifica.
Però una cosa che possiamo fare, siccome
stiamo tenendo sul secondo nastro il
numero delle i, il numero del il numero
n, quello che possiamo a verificare in
Q7 è se sul secondo nastro ci siano
delle X residue. Se ci sono delle X
residue, perché come potete vedere
nell'arco che va fra Q2 e Q3, noi il
contenuto di sul secondo nastro è che ci
sono delle X che iniziamo a cancellare e
torniamo dietro. Quindi poi il secondo
nastro, come potete osservare dagli
altri archi, non viene toccato fino a
Q7. Per questa ragione, se in Q7 sul
secondo nastro leggiamo che c'è una X,
allora noi ci aspettiamo di leggere una
w successiva, una wdi + 1. Ok? Quindi
questo è un controllo che possiamo fare
in Q7. Quindi sul secondo nastro c'è X,
lascio X e sto fermo e vado in Q8. In Q8
cosa posso fare in Q8?
Avanzo sul primo nastro, come ci ha
suggerito il nostro collega
e facciamo questa cosa qua. Quindi su
primo nastro. Adesso vi faccio vedere un
trucchettino di programmazione
di macchina. Ok? Quindi sul primo nastro
c'è alfa, lascio alfa e vado avanti.
Quindi andiamo verso
la fine del nostro eh w con i corrente
che stiamo analizzando. Pronti a leggere
la w con i + 1 perché nell'arco tra q e
q8 abbiamo letto una x sul secondo
nastro e di conseguenza ci aspettiamo
che qualcos'altro appaia. Ok, adesso
dobbiamo lasciare la macchina in una
condizione, in uno stato, come dire, un
po' sensato, ok?
Nel senso che nel momento in cui noi
portiamo la computazione
verso Q2, in maniera tale che possiamo
ciclare nuovamente,
la condizione in cui lasciamo le testine
sul nastro deve essere coerente con
quello che
ci troviamo in Q2. Allora, in Q2 l'arco
uscente da Q2 ha possiamo verificare che
su primo nastro
la testina era su cancelletto. Di
conseguenza, nella transizione fra Q8 e
Q2 la testina di primo nastro va
lasciata sul cancelletto perché in Q2 ci
aspettiamo che sia così.
E un'altra cosa che possiamo verificare
è che su terzo nastro, per come abbiamo
usato il terzo nastro, eh, perché poi
uno si può inventare quello che vuole,
eh, però per come abbiamo usato il terzo
nastro in Q2 noi ci aspettiamo che la
testina su terzo nastro, vi ricordo che
sul terzo nastro stiamo scrivendo la I,
la testina su terzo nastro venga
lasciata sul bianca a sinistra della
sequenza delle X. È qui che facciamo
tornare i conti, eh, perché il terzo
nastro lo potevamo gestire pure al
contrario che appendevamo a destra, qui
stiamo appendendo a sinistra, è la
stessa cosa, uno se lo gestisce come
vuole. Allora, quindi due cose dobbiamo
fare
prima di andare verso il secondo nastro.
Dobbiamo portare la testina di primo
nastro su un cancelletto che ci
aspettiamo di osservare perché nella
transizione fra Q7 e Q8 X è presente sul
secondo nastro e inoltre dobbiamo
mollare il la testina di terzo nastro
sul blank a sinistra sul primo blank a
sinistra della sequenza di X. Ok?
Quello che abbiamo fatto finora è
chiaro?
Sì. Ok, cool.
Allora, in Q8 stiamo avanzando,
ok? Stiamo avanzando
su primo nastro e portiamo la testina.
Dobbiamo portare la testina fino sul
cancelletto, però stavolta sul
cancelletto ci fermiamo. Ok?
Allora, quello che possiamo fare è
questa cosa qua. Guardate un po'.
Collego Q8 a Q2 e come condizione di
uscita metto che sul primo nastro c'è
cancelletto. Lascio cancelletto e sto
fermo. Ok, questo non è sufficiente
perché sappiamo, abbiamo appena detto
che dobbiamo fare pure un un del lavoro
su terzo nastro. Ok? Su terzo nastro
dobbiamo riavvolgere
fino a alla posizione blank. Ok? Allora,
metto questa condizione qua prima e poi
discutiamo assieme un pezzariello.
Quindi sul terzo nastro noi lo
riavvolgeremo, lo sposteremo fino alla
primo simbolo a sinistra
eh della sequenza di X.
Allora, va fatto questa cosa qua.
Guardate un po' questa cosa qui. Ok, sto
scrivendo qua che sul terzo nastro
riavvolgo. Ok, secondo voi questa cosa è
corretta o no?
Sì, sicuro. Perché, cioè, nel senso se
poi spero di aver capito perché poi Ok,
vediamo esattamente che cosa c'è scritto
sul loop sul sull'anellino di di stato
Q8. Qual è qual è l'etichetta? Cos'è che
stiamo dicendo di fare?
ragioniamo assieme
sull'input continuamo ad andare avanti.
Sì, senza modificare niente. Sì. E sul
terzo, mentre invece sul terzo leggendo
le X che dovrebbero essere la I eh
torniamo indietro però lasciando la X
intatta. Intatta. Ok. Ma adesso la Ok,
le faccio una domanda in maniera tale da
stimolare appunto il focusing su una
cosa
specifica. Vedo sì che c'è qualcuno in
coda. Sì, il
Ok, è scato il sole. Mi sa che non
vedrete più una cippa. Se state vedendo
me.
Né io vedo niente, quindi devo chiudere
la finestra.
Alri, giusto un secondo.
Ok, così si vede. Ok, rifocalizziamoci
sull'anellino
che sta in quoto. Abbiamo detto su primo
nastro c'è un simbolo qualsiasi alfa e
vado avanti. Lascio lì così lì comeè e
su terzo nastro c'è una X e vado dietro.
Ok.
Ma per quante volte questa cosa viene
fatta?
C'era qualcuno in coda? Sì, prego. Sì.
Eh, secondo me c'è il problema che non è
detto che abbiano la stessa lunghezza,
quindi io eh a un certo punto mi blocco.
Esattamente perché così come è scritto,
noi stiamo dicendo che per ogni
carattere che avanziamo sul primo nastro
avanz indietreggiamo sul terzo nastro,
cioè il numero di spostamenti che
facciamo, come ci diceva la nostra
collega, viene fatto in contemporanea.
Ok? Quindi il problema lì è che
avanzeremo su primo nastro tanti
caratteri quante sono le x su terzo
nastro. Questa cosa potrebbe funzionare,
questa cosa potrebbe non funzionare in
dipendenza delle x che stanno sul terzo
nastro. Ok? Quindi così come è scritta
questa cosa non è precisa, però quello
che possiamo fare è questo. Guardate un
po'. Eh, dov'è? Ok,
così.
E così, vedete cosa ho aggiunto? Ho
aggiunto due parentesine graffe. Qual è
il significato ora?
Eh, io andrò avanti finché ho spazio e
poi indietro finché ho spazio. Cioè,
quindi eh io riesco a farli, non li
faccio contemporaneamente, ma a pezzi e
poi esco finito su entrambi. Su
entrambi. Bravissimo. Esattamente così.
Ver è così. Adesso in che ordine
vengono vengono riavvolti i nastri?
Prima l'uno e poi l'altro?
Non penso ci interessi, cioè come vuole
lui. Così come Ma ma così come è
scritto, noi stiamo dicendo alla
macchina di farlo in uno specifico
ordine.
No, no.
Questo qui in effetti è un
riavvolgimento non deterministico, cioè
in quel pezzo di funzione di transizione
quella funzione di transizione è quella
parte di funzione di transizione è non
deterministica, cioè perché la macchina
lì può scegliere se riavvolge se
avanzare su uno o sull'altro nella
sequenza che più gli aggrada. Adesso
questa non è una cosa che ci importa,
come la nostra collega ci diceva, non è
che ci importa più di tanto. Quello che
ci importa, l'unica cosa che ci importa
è che noi ci spostiamo solamente quando
abbiamo raggiunto il cancelletto su
primo e il blank su terzo. Ok? Quindi
questo qui è un trucchettino per
riavvolgere i nastri in maniera non
deterministica, perché ovviamente non
stiamo specificando in che sequenza
farlo, ok? Però c'è da sottolineare che
questa cosa è corretta solamente se
usiamo le parentesi graffe nel modo in
cui l'avevo scritto prima. Non funziona.
Non funziona perché a quel punto
andrebbe a matchare sul numero di
eh sul numero di
sul numero di caratteri. Ok. Alright.
Quindi questo è un pezzo quasi completo
della macchina. L'ultima
cosa che ci manca da fare è questa cosa
qui in Q7. In Q7 in cui quando
controlliamo sul secondo nastro noi
siamo in grado di stabilire se ci
aspettiamo delle V con i successive o
meno. Quindi va aggiunta la condizione
di uscita. Quindi se sul secondo nastro
c'è blank, lascio blank e sto fermo,
allora vuol dire che lì
eh non mi aspetto nessuna V con i
successiva. Quindi quello che faccio è
avanzare sul primo nastro per vedere che
non ci sia niente di strano in fondo e
accetto quando sul primo nastro trovo
blank.
Chiaro? Ok,
vediamo. Mi sente? Sì. Avevo usato la
mano prima, non mi funziona il
microfono. Una cosa, nei primi stati la
X è nei corenti di un alfa, giusto? Eh,
può ripetere? Nei primi stati usciamo X
e come usiamo alfa normalmente una
lettera delfabeto
dice Q0 Q1. Ah ah la X, scusate, perché
le Hinguaggio è composto da X in giusto?
Ok.
X alliniz. Ah, perché devo contarle qu?
Sì, sì, sì. Quindi io le ricopio sul
secondo nastro, così io poi le posso
riutilizzare quando
quanto più mi aggrada. Allora, qua
magari facciamo qualcosa di facile e poi
pausa.
Cos'è? Questo l'abbiamo appena fatto,
no? Facciamo
Dov'è questo? C'ha troppi stati questa.
Ok, facciamo questo qua.
Alright.
Allora, questo qua
ho ricostruito il testo stamattina da
dall'esercizio che avevo svolto. Vediamo
di scriverlo decentemente. Allora, il
linguaggio è questo.
L'insieme
delle stringhe A. Cancelletto B.
Cancelletto W con 1. W con 1. W con2 W
con 2. Bla bla bla bla w con n w con n
tale che
A è strettamente magiore di B.
N è a
- b
w con i.
Sì, w con i la lunghezza di w con i è
almeno la lunghezza di b. Ok?
E poi abbiamo che A, B e W con I
appartengono a eh non lo so 01 Plus.
Spero di averlo ricostruito
correttamente. Ok, prendete qualche
minuto per pensare.
Ok,
qualche idea?
Eh, posso Mi sente? Sì, sì, sì. Allora,
tanto salverei, controllerei che hai
maggiore di B con un semplice controllo,
niente di particolarmente complesso
quello. Salverei ovviamente su due su
due nastri la lunghezza di A - B e la
lunghezza di B perché si servono
entrambi. Sì, sì. Poi farei un gess ogni
volta su WW1 con con Gess di P di lunga
per vedere se se puoi combattere quella
parte dopo. Sì, poi dopo salterei alla
coppia successiva dopo il gess successo.
Sì, sì, sì, sì, sì, sì. Assolutamente.
Così va benissamente controllando che
sia totale a men b totale di stringa che
controllo dopo. Sì, sì, sì, sì, sì, sì.
Esattamente. Quindi pure qua ci sono
vari modi per risolverlo.
Eh, uno potrebbe, che ne so, scrivere su
nastro la W con i che sta per andare a
leggere, oppure, come abbiamo fatto
nell'esempio precedente, oppure potrebbe
selezionarsi da eh
dalla
dal nastro in input una porzione che è
W. e la W con i entrambe vanno bene.
Entrambe vanno bene. E vabboh. Qui nelle
soluzioni proposte c'ho la seconda.
Andiamo a guardare come fare con la
seconda.
Eh, ok. Allora,
abbiamo Q0.
Questo lo stato di partenza.
Iniziamo a trascrivere la lunghezza di A
su secondo nastro. Su secondo nastro
metterò la lunghezza di A - B. La
lunghezza di Ao la lunghezza di B. Su
terzo nastro metterò la lunghezza di B e
su quarto nastro inserisco
le eh W con i che eh poi a poco a poco
mi vado a controllare. Ok. Quindi su
primo nastro c'è alfa, lascio alfa e
vado avanti.
Su secondo nastro c'è blank, scrivo X e
vado avanti.
A un certo punto sul primo nastro c'è
cancelletto. Lascio cancelletto e vado
avanti. Sul secondo nastro c'è blank,
lascio blank e torno indietro. Q1.
Adesso, siccome B deve essere almeno un
carattere, anche A dovrebbe essere
almeno un carattere, però controlliamo
che A è più grande di B, più lungo di B,
quindi basta imporre che B sia almeno un
carattere, da quello ci viene poi
gratis, che A deve contenere almeno un
carattere. Quindi sul primo nastro c'è
alfa, lascio alfa e vado avanti.
Sul secondo nastro c'è X, scrivo blank e
torno indietro. Quindi inizio a
calcolare la lunghezza di Ao la
lunghezza di B. Su terzo nastro c'è
blank, scrivo X e vado avanti. Inizio a
scrivermi la lunghezza di B terzo
nastro. Questa cosa la rifaccio. Quindi
sul primo nastro c'è alfa, lascio alfa e
vado avanti. Sul terzo nastro c'è X,
scrivo blank e torno indietro. Su Eh,
no, questo è due. Dov'è? Dov'è?
secondo.
Sul terzo c'è blank. scrivo X e vado
avanti. Ok, questa cosa la continuo fino
a quando arrivo al cancelletto. Quindi
sul primo c'è cancelletto, lascio
cancelletto e vado avanti. Sul secondo
c'è X, lascio X e sto fermo. In questo
modo controllo che la lunghezza di A era
maggiore della lunghezza di B. Non
faccio niente sul nastro perché
quella cosa, quella quantità mi serve
dopo, quindi c'ho esattamente quello che
mi serve e sta sul secondo nastro,
quindi c'è X, lascio X
e sto fermo.
Su terzo nastro, siccome siamo su blank,
ci spostiamo una posizione dietro. Ok.
Q3.
No,
no.
Facciamo meglio, sennò poi è difficile.
Facciamo così.
Ok, mettiamo C3 qua. Ok.
Allora, come detto, questo si può fare
in vari modi. Un modo è prelevare dalla
string input. Ok? Quindi, che cosa che
cosa abbiamo? Abbiamo che
sul primo nastro c'è alfa. Lascio alfa e
vado avanti.
Sul terzo nastro c'è X. Lascio X e torno
indietro perché devo essere sicuro di
prelevare da primo nastro qualcosa che è
lunga più di B. Quindi devo iniziare a
contarmi quanti carattere mi sto
prelevando. Sul quarto nastro me la sto
trascrivendo, c'è Blank, scrivo alfa e
vado
avanti.
A un certo punto
dobbiamo essere sicuri che
Dobbiamo essere sicuri che su terzo
nastro finiamo. Quindi c'è Blank, lascio
Blank e vado avanti. Così siamo sicuri
di averne presi almeno
almeno B, eh.
Ok.
Ok. Allora, il testo qua era
questo l'ho ricostruito, eh, qua è
maggiore uguale. M Ok,
quindi abbiamo sul terzo nastro blank
blank bla. Dopodiché ci andiamo a
prendere i caratteri, eventualmente
caratterii. Quindi sul primo nastro c'è
alfa, lascio alfa e vado avanti. Sul
quarto nastro c'è blank, scrivo alfa e
vado
avanti. Ok?
Poi ci serve che insomma questa è la
prima w o la iesima w che abbiamo
processato. Quindi sul secondo nastro
c'è X, scrivo blank e torno indietro.
Quando qui abbiamo finito di ricopiare
la parte che ci serviva, quindi sul
secondo nastro ci togliamo una X. Si può
fare ora, si può fare prima, è la
stessima cosa. Sul quarto nastro andiamo
indietro perché ci servirà poi la doppia
bu con i per fare la verifica. Ok,
quindi andiamo in Q5.
in Q5
riavvolgiamo
il
terzo e quarto nastro perché ci
serviranno per dopo. Ovviamente si può
fare in vario in vario ordine,
non è questo l'ordine per forza giusto.
Quindi su terzo nastro c'è X, lascio X e
vado avanti.
Su quarto nastro c'è
alfa, lascio alfa e torno indietro. Come
vedete faccio un riavvolgimento
come quello che avevamo visto
nell'esercizio
precedente. Ok? La condizione di uscita
è che su terzo nastro c'è blank, lascio
blank e torno indietro. Su quarto nastro
c'è blank. Lascio blank e vado avanti. E
andiamo in quella era Q5 Q6.
Una volta che è in Q6 quello che
dobbiamo verificare è che W con i sia
seguita da W con i. Quindi su primo
nastro c'è alfa, lascio alfa e vado
avanti. Su quarto nastro c'è alfa,
scrivo blank e vado avanti. Me lo
cancello perché così inizio a svuotare
il quarto nastro per quello che mi serve
dopo. Ok, la cosa finisce quando su
quarto nastro c'è blank, sto blank e sto
fermo e vado in Q7. Ok,
adesso, esattamente come prima, nel
momento in cui in Q7 io ho una
una vedo una X secondo nastro, allora so
che devo continuare a fare il giochino.
Quindi sul secondo nastro c'è X, lascio
X e sto fermo. Sto fermo perché la
cancellazione di X avviene dopo, ok?
Alri,
questo qua. E poi invece in Q7
abbiamo che se non abbiamo più nessuna X
accettiamo se
sul secondo nastro non c'è più niente.
Blank blank e sto fermo. Ma anche su
primo nastro non ci deve essere più
nulla e quindi accettiamo quotto.
Ok,
chiaro per tutti?
Sì. Ok. E con questo possiamo fare un
po' di pausa, 10 minuti, un quarto
d'ora. Ok, a tra poco.
La registrazione. Ok.
Option full screen. Ok.
Ok. Altro esercizio,
vediamo se riusciamo a farne un paio.
è il linguaggio delle stringhe A B1
bla bla bla
wn
tale che a vir bola w
appartiene ad A B C D plus.
E poi che abbiamo? la lunghezza di A è
maggiore della lunghezza di B.
N è A - B.
E poi che succede?
B
sottostringa di W con I.
Se
la lunghezza di W con i è pari
e B reverse è sottostringa di doppia V
con i se la lunghezza di doppia V con i
è dispar.
Ok,
come al solito prendiamoci 1 2 minuti
per pensare e poi ci abbiamo No.
Ja. Ok. Ed è
Sì.
Eh io ho pensato di Sì. Eh vabbè solita
solito controllo delle lunghezze, quello
non cambia. Poi di fare la guess sulla
parità, cioè quindi a pri ore decido se
eh WD è pari. Sì. e posso controllarlo
successivamente dopo andando a contare e
per ogni car, cioè io scelgo il
carattere, il primo carattere, no? Metto
una X nastro, il secondo tolgo quella X
e lo metto blank, poi se c'è il terzo
carattere metto X. In questo modo alla
fine se c'è X significa che è dispari,
se c'è un blank significa che è pari.
Sì, sì.
E poi dopo eh faccio la guess
sull'inizio della
sottostringa all'interno di vi e lo
controllo come abbiamo fatto ieri
essenzialmente. Sì, sì, sì, sì, sì.
Questa questa è una possibilità
ovviamente. Ehm,
io sì, ve ne propongo un'altra, ma
questa funziona nel momento in cui
av'altra mano alzata. Avete altre idee?
Una domanda. Ma se dobbiamo fare tanto
il check dopo sul parità di di spari,
non possiamo farlo prima e e dividere
poi fare una bislo
a quel punto. Sì, sì, sì. Questo in
effetti è quello che vi propongo io
perché sicuramente la soluzione della
nostra collega
funziona, cioè se stiamo attenti
funziona perché sostanzialmente quello
che lei ci sta suggerendo è eh di
utilizzare un flag sul nastro per sapere
se la sua la lunghezza di doppia bucon
dispari alla alla fine. Ovviamente si
deve stare attenti, il che rende rende
le label un po' un po' più incasinate,
perché dobbiamo stare attenti che ogni
spostamento che facciamo sulla ehm
sulla sul primo nastro, cioè che si può
fare, eh non è che non si può fare, però
poi si dovrà stare attenti che ogni
volta che ci spostiamo sul primo nastro
lì eh lì dobbiamo stare attenti a che
manteniamo il conteggio di di parità,
no, tramite questo flag
su un nastro aggiuntivo che si può fare,
eh, non è non è sbagliato, rende la cosa
un pelino più tricky. Un'altra soluzione
che era appunto quella che anche il
nostro collega ci suggeriva è che
possiamo fare un controllo preliminare
della parità
della lunghezza di W con i, quindi
andiamo a controllare se siano pari o
dispari e una volta che sappiamo se è
pari o dispari andiamo a fare la
verifica o di B o di B reverse dentro W.
Entrambi sono
eh vanno bene. Propenderei per la
seconda,
non perché sia più corretta, ma perché è
meno probabile sbagliare mentre la
scriviamo. Questa è la cosa, perché la
prima va benissimo, però si deve stare
attenti che ogni movimento che facciamo
su primo nastro è sempre tracciato
dall'aggiornamento del flag. sul secondo
nastro, eh, e quindi si deve stare eh un
pelino attenti, che si può fare, eh, si
può fare, però rispetto alla seconda
soluzione che è un pelino più lineare,
noi il controllo lo facciamo all'inizio
e dopodiché andiamo a verificare se ci
sta o una o la stringa B o il o il suo
reverse. Ripeto, preferisco
la seconda semplicemente perché è meno
probabile fare errori. Tutto qua. Sennò
entrambe vanno vanno bene. Ok. Allora,
quindi eh questo pezzo di macchina
iniziale è molto simile a quello che
abbiamo visto eh nelle altre
circostanze, nel quale, insomma,
dobbiamo fare i soliti controlli sulla
lunghezza delle stringhe e quindi
iniziamo. Q0 stato iniziale,
quindi sul primo nastro c'è alfa, lascio
alfa e vado avanti. Sul secondo nastro
c'è Blank, scrivo X e vado avanti.
Raggiungiamo sul primo nastro il
cancelletto,
lo superiamo.
Sul secondo nastro c'è Blank, lascio
blank e torno dietro in maniera tale da
poter iniziare la differenza.
Dopodiché sul primo nastro c'è alfa.
Lascio alfa e vado avanti. Ho iniziato a
leggere la stringa B.
Sul secondo nastro inizio a cancellare
in maniera tale che mi calcolo quanto
sia la lunghezza di Ao la lunghezza di
B. Su terzo nastro inizio a trascrivere
B perché mi serve dopo e vado avanti.
Quindi andiamo in Q2.
Facciamo sul primo nastro c'è alfa,
lascio alfa e vado avanti. Sul secondo
nastro c'è X, scrivo blank e torno
indietro. Sul terzo nastro c'è blank,
scrivo alfa e vado avanti.
Ok. E questa cosa si fa fino a quando
arriviamo al cancelletto. Sul primo c'è
cancelletto, lasciamo cancelletto e
andiamo avanti. Sul secondo c'è X,
lasciamo X e stiamo fermi. In questo
modo sappiamo anche che la lunghezza di
A è strettamente maggiore della
lunghezza di B. Sul no, sul terzo nastro
c'è blank. Lascio blank e torno dietro.
Q3.
A questo punto inizia un pezzettino
deterministico della macchina che serve
a stabilire se la W con i che stiamo
leggendo sia di eh lunghezza pari o
dispari.
Allora, siccome la W con i deve avere
almeno un carattere, sfruttiamo la cosa
e abbiamo sul secondo nastro c'è X.
Scrivo blank e torno indietro. Su primo
nastro c'è
alfa, lascio alfa e vado avanti. E
andiamo in uno stato Q4 che significa
che avrà il significato di ho letto un
numero dispari di simboli su W con i.
Siccome tra q3 e qi leggiamo il primo
simbolo di W con i, allora noi transiamo
verso questo stato qua. Quindi poi
oscilliamo fra due stati. Sul primo
nastro c'è alfa, lascio alfa e vado
avanti e vado in Q5. E in Q5
sul primo nastro c'è alfa. Lascio alfa e
vado avanti. Ok? Quindi, al termine del
processamento
eh della stringa W con i che può essere
terminata o dal cancelletto
o dal blank nel caso in cui sia l'ultima
W v con i, noi se terminiamo questa
procedura in Q4 o in Q5, noi sapremo che
la lunghezza della stringa è pari o
dispari. Se terminiamo in Q4 la cosa è
dispari. Se terminiamo in Q5 la
lunghezza è pari. Verifichiamo prima il
caso di Q4.
Se la lunghezza è dispari, noi dobbiamo
cercare B reverse. Ok?
Allora, la condizione di uscita qui è
doppia. Noi potremmo terminare su un
cancelletto.
Quindi c'è primo nastro, c'è
cancelletto, lascio cancelletto e vado
indietro. Oppure su primo nastro c'è
blank, lascio blank e torno indietro nel
caso in cui io stia processando la W con
N, cioè l'ultima. Ok, andiamo in Q6. Noi
dobbiamo cercare
la
eh
presenza di
w con eh R. Ok. E allora facciamo
eh reverse. Quello mi sa che è sbagliato
sul mio esercizio. M
Sì, è sbagliato. Ok,
quindi stiamo attenti qua perché mi sa
che lì avevo scritto una cosa sbagliata.
Quindi dobbiamo cercare la la B revered
dentro w con I. Perché se usciamo da Q4
la lunghezza di W con I era
dispari. Quindi che cosa facciamo?
Andiamo a cercare. Allora, su terzo
nastro noi abbiamo la copia di B e al
momento la copia di B terzo nastro è
stata lasciata con la testina in fondo,
cioè con la testina alla fine della
stringa B,
della copia della stringa B, quindi sul
lato destro. Quello che possiamo fare
quindi è questa cosa qui. Indietreggiamo
sul primo nastro. Sì,
siccome per conteggiare la lunghezza di
W con I abbiamo raggiunto la fine di W
con i, cioè, quindi in Q4 una volta che
sappiamo quanto è lunga, quanto è lunga
w con i e transiamo da Q4 a Q6, lì noi
abbiamo che la testina del primo nastro
sta in fondo a a W con i, quindi noi
dobbiamo indietreggiare su W con
alla ricerca di cosa? Dell'inizio
della stringa B reverse
all'interno della W con i. Ok?
Indietreggiamo su sul su primo nastro
perché la testina era in fondo alla
doppia V con. Ok? Quindi indietreggiamo
fino a quando decidiamo che quello è è
arrivato il momento. Quindi su primo
nastro c'è alfa, lascio alfa e vado
avanti. Su terzo nastro c'è alfa, lascio
alfa e torno dietro. Ok? In questo modo
verifico la inizio a verificare la
presenza di
B reverst dentro W con i, quindi primo,
sul primo c'è alfa lascio alfa e vado
avanti. Sul terzo c'è alfa, lascio alfa
e torno
e torno dietro. Ok.
Ok. Eh, questa cosa
la facciamo
fino a quando eh su terzo nastro, Ok, su
terzo nastro troviamo il blank,
ok? e andiamo avanti perché poi dovremo
lasciare la computazione in uno stato
consistente perché all'inizio di questi
stati, tipo in Q4 e Q5, noi ci
aspettiamo che la testina su terzo
nastro sia a destra. Quindi prima di
ritornare là sopra, prima di ritornare
verso Q3, noi dovremo spostare la
testina di terzo nastro verso destra.
Ok?
Quindi in Q eh 8 quello che facciamo è
portiamo il primo nastro verso la fine
di W con I.
Quindi sul primo nastro c'è alfa, lascio
alfa e vado avanti.
E dobbiamo riavvolgere anche il terzo
nastro.
Sul terzo nastro c'è alfa, lascio alfa e
vado avanti. Ovviamente queste sono due
etichette distinte. Ok? Per quella cosa
che abbiamo eh che abbiamo detto prima.
Ok?
Domanda per voi.
L'alfa,
questo alfa qua
e questo alfa qua sono collegati?
Prego.
Eh no, perché non vengono
contemporaneamente, quindi Sì,
esattamente, esattamente. Sono alfa in
due etichette distinte. Sposto questo
dall'altro lato, sennò si affolla. Terzo
nastro. C'è Blank, lascio Blank e sto
fermo. Ok.
Alright.
Allora, nel caso in cui questa si
processa la parte la parte in caso di
uscita da Q4, controlliamo la parte in
uscita da Q3
eh Q5, cioè quindi nel caso in cui il
eh
la lunghezza della doppia V con i eh sia
pari, di nuovo In uscita da
Q5 avremo un caso simile a prima, quindi
avremo che stiamo terminando su W con i,
quindi o terminiamo su un cancelletto e
andiamo indietro, o terminiamo su un
blank e andiamo indietro
e ci muoviamo. Quello è Q8, quindi
questo è Q9.
Ok,
a questo punto, siccome quello era pari,
dobbiamo cercare la presenza di W
dentro di B dentro W con I. Vi ricordo
che in uscita da Q5
noi abbiamo la testina su terzo nastro a
destra. Allora, quello che noi possiamo
fare è indietreggiare su primo nastro
alla ricerca della fine
alla ricerca della fine della eh stringa
B dentro W con I, dopodiché
indietreggiare contemporaneamente
primo nastro e eh terzo nastro. Ok?
Quindi
cerchiamo non deterministicamente
l'inizio della la fine della stringa B
dentro w con i, quindi sul primo nastro
c'è alfa, lascio alfa e torno dietro.
A un certo punto dice decidiamo di
essere arrivati al punto corretto e
quindi avremo sul primo nastro c'è alfa,
lascio alfa e torno dietro. Sul terzo
nastro c'è alfa, lascio alfa e torno
indietro.
Q10. Ok. Eh, piccolo commento qui noi,
guardate, stiamo andando nella stessa
direzione, quindi siccome sul terzo
nastro c'è B e noi stiamo controllando
entrambi i nastri muovendoci verso
sinistra, allora stiamo effettivamente
controllando la presenza di B dentro W
con i, anche se
ci stiamo muovendo verso sinistra. Ok,
quindi questo continuiamo.
Quindi sul primo nastro c'è alfa, lascio
alfa e torno indietro. Sul terzo nastro
c'è alfa, lascio alfa e torno indietro.
Ok.
Eh,
alright.
Adesso qui la situazione è un po'
differente
perché
Vediamo un secondo.
Sì, perché nel momento in cui noi stiamo
indietreggiando,
state attenti perché qui potrei fare
degli errori perché la soluzione che
avevo su carta è sbagliata, quindi è una
cosa che sto pensando ora.
Eh, allora, siccome qui stiamo
indietreggiando
sul primo e terzo nastro e poi per
rimettere la macchina in uno stato
consistente
dobbiamo riportare il primo nastro, la
testina di primo nastro verso la fine di
W con i noi dovremo avanzarla verso
destra.
La questione qual è? è che mentre noi
indietreggiamo la testina, le testine di
primo e terzo nastro, per verificare la
presenza di B su W con I,
quello che potrebbe accadere
è che
la presenza di doppia di di B su W con i
sia proprio all'inizio
sia proprio all'inizio della eh stringa
W con i dico Di conseguenza questa
etichetta qua, questa qui nello
specifico,
potrebbe far sì che al termine del check
della condizione la testina di primo
nastro si trovi su un cancelletto
e quindi non possiamo sfruttare magari
questo stato per avanzare
primo e terzo nastro, in quanto qui noi
ci aspettiamo che il primo nastro sia su
un simbolo tipo AB CD. Quindi dobbiamo
gestire le due cose
eh separatamente
e fare una cosa di questo tipo. Alri,
vediamo un po'. Quindi andiamo qua
e abbiamo che sul primo nastro c'è
alfa. Lascio alfa
e vado avanti.
Sul terzo nastro c'è blank. Lascio blank
e vado avanti.
Oppure
sul primo nastro c'è cancelletto, lascio
cancelletto e vado avanti. E sul terzo
nastro c'è
blank. Lascio blank e vado avanti. Ok,
così dovrebbe gestirla. A quel punto noi
ritorniamo in Q8 in cui avanziamo primo
nastro e terzo nastro.
A quel punto che succede? Succede che se
ci sta un cancelletto
su eh primo nastro, torniamo indietro. M
Ok, qua è un po' incasinata l'immagine.
Facciamo così.
Oplà.
Ecco qua. Ok. Dove sta? Quindi
questo qua sul primo nastro
c'è cancelletto.
Lascio cancelletto e vado avanti e
torniamo nella parte di dietro della
computazione. Oppure potrebbe accadere
che non ci sta niente, quindi serve un
altro ramo.
Ok.
In questo caso noi abbiamo che sul primo
nastro c'è Blank, lascio blank e sto
fermo, ma a quel punto anche il
conteggio sul secondo nastro deve essere
terminato. Ok. Q10 eh Q 118
Sì, questo è Q11. Ok,
dovrebbe andare
chiaro come funziona.
Alri, veniamo un altro.
Amo
uno
non troppo incasinito, visto che non
abbiamo tempo.
Questo l'abbiamo già visto.
Questo l'abbiamo visto pure.
Allora, direi
direi questo qua. Ok, facciamo questo
che è più breve.
Solito linguaggio, linguaggio di a sharp
b sharp w
con 1
w con n
e w con i provengono da
b+.
La lunghezza di A è maggiore della
lunghezza di B che è maggiore di 0.
Vabbò, questo l'abbiamo già detto n in
questo caso è la lunghezza di A più la
lunghezza di B.
E poi abbiamo che A è sottostringa di W
con i
con i pari
e B
reverse è sottostringa di W con I con i
dispari.
Ah no, era al contrario. Quindi questo
dispari
a con i dispari. Sì, è questo è il pari.
Alright.
Dispari
e questo con i pari. Ok. Nulla
nulla di estremamente complicato. Ok.
Qua dispari e pari. Qui si riferisce
agli indici, non alla lunghezza eh del
la lunghezza delle stringhe. Sì, prego.
Ma perché c'è control su zero se è un
più? Sì, sì, sì, sì. Quello è
ridondante. M Ok.
Alright. Ok. Eh, partiamo. Dovremmo
farcela in 12 minuti.
L'esercizio non mostra particolari
difficoltà perché a parte un po' di
conteggi da fare su A e B, queste cose
qua, alla fine dobbiamo verificare la
presenza di Aenza di B reverse,
prima uno e poi l'altro, indipendenza se
W con i è di indice pari o dispari,
tutto qua. Quindi avremo sul secondo
nastro un po' di conteggi in cui noi
riusciamo a calcolare questo N e poi su
terzo nastro metto a e su quarto nastro
metto beta reversted.
Eh, ok,
Q0
si parte.
Quindi sul primo nastro c'è Alfa. Lascio
alfa e vado avanti. Sul secondo nastro
c'è blank, scrivo X e vado avanti. Sul
terzo nastro inizio a copiare A. Quindi
c'è Blank, scrivo alfa e vado avanti.
Perché su arrivo al cancelletto, sul
primo nastro c'è cancelletto, lascio
cancelletto e vado avanti. Sul terzo
nastro
c'è blank. Scrivo blank e torno dietro
Q1.
Qui andiamo avanti e quindi sul primo
nastro c'è alfa, lascio alfa e vado
avanti. Sul secondo nastro c'è blank,
scrivo x e vado avanti. Quindi sul
secondo nastro inizio a calcolare la
somma della lunghezza di A più la
lunghezza di B. Sul terzo nastro inizio
a riavvolgere
A che avevo scritto prima. Siccome è in
linea di principio differente da B, dico
che su terzo nastro c'è un generico
simbolo beta. Su quarto nastro inizio a
scrivere la stringa B. Ok?
Questa cosa faccio in Q2 uguale sul
primo nastro c'è alfa, lascio alfa e
vado avanti. Sul secondo nastro c'è
blank, scrivo X e vado avanti. Sul terzo
nastro c'è beta, lascio beta e torno
dietro. Sul quarto nastro c'è Blank,
scrivo alfa e vado avanti. Ok, ci
fermiamo
quando sul primo nastro trovo
cancelletto. Lasco, lascio cancelletto e
vado avanti.
Sul secondo nastro c'è blank, lascio
blank e torno dietro. Sul terzo nastro
c'era beta, lascio beta e torno dietro.
In questo modo ho la garanzia che A, la
stringa A sia più lunga della stringa B.
E poi sul quarto nastro c'è blank.
Lascio blank e torno dietro e andiamo in
Q3.
Eh no, mi serve più spazio.
Ok.
Q3. Ok. Riavvolgo il terzo nastro,
giusto perché mi servirà poi per Ace
alfa, lascio alfa e torno dietro fino a
quando andiamo su terzo nastro che c'è
blank. Lascio blank e vado avanti e
andiamo in Q4.
Ok,
quindi abbiamo una sequenza adesso di V
con1, V con 2, V con 3. Una volta
dobbiamo verificare la presenza di A e
una volta la presenza di B reverse,
semplicemente facciamo prima l'uno e poi
l'altro in base all'indice in cui siamo.
Partiamo ovviamente dagli indici
dispari,
quindi sul secondo nastro c'è X, scrivo
blank e vado dietro. Inizio a fare
questi conteggi. Siccome stiamo
processando una V con una V con i
di indice
dispari, devo cercare dentro alla bucon
l'inizio della stringa A. Tutto non
deterministicamente. Quindi sul primo
nastro c'è alfa. Lascio alfa e vado
avanti fino a quando poi trovo il punto.
Qua c'è spazio, sì. Il punto in cui
inizia a dentro w con i. Quindi sul
primo nastro c'è alfa, lascio alfa e
vado avanti. Su terzo nastro c'è alfa,
lascio alfa e vado avanti. Andiamo in
Q6.
Verifichiamo la cosa per tutti i
caratteri. Quindi sul primo nastro c'è
alfa, lascio alfa e vado avanti. Sul
terzo nastro c'è alfa, lascio alfa e
vado avanti. Ok? Fino a quando sul terzo
nastro
non troviamo blank e usciamo dalla
condizione di jack. Ok. Qui andiamo in
Q7.
Adesso noi dobbiamo verificare se eh la
W con i che stavamo leggendo è l'ultima
o meno. Allora, quello che noi facciamo
in Q7 M dove sta lo spazio? Ok, lo metto
qua
in Q7. Avanziamo su primo nastro, quindi
c'è Alfa, lascio Alfa e vado avanti e
riavvolgiamo il terzo nastro perché ci
serve per dopo.
Alright. Adesso in Q7 noi sappiamo che
dobbiamo verificare una successiva W con
i se è presente un cancelletto. Quindi
sul primo nastro c'è cancelletto, lascio
cancelletto e vado avanti.
Contemporaneamente devo avere una X però
sul secondo nastro e quindi la cancello
e torno indietro e poi condizioni di
uscita che il terzo nastro sia stato
riavvolto completamente. Ok, voi non
leggete quello, quell'etichetta è primo
nastro, cancelletto cancelletto e vado
avanti. Secondo nastro X, scrivo blank e
torno dietro.
Terzo nastro, c'è blank. Lascio blank e
vado avanti. Ok. E vado in
Q8.
In Q8 che cosa si fa? Cerco la presenza
di B reverse, quindi sul primo nastro
c'è alfa, lascio alfa e vado avanti fino
a quando decido che è arrivato il
momento. Quindi sul primo nastro c'è
alfa, lascio alfa e vado avanti. Sul
quarto nastro c'è alfa, lascio alfa e
torno indietro.
Andiamo in Q9.
In Q9 continuiamo il controllo. Sul
primo nastro c'è Alfa, lascio Alfa e
vado avanti. Sul quarto nastro c'è Alfa,
lascio Alfa e torno indietro.
Procediamo fino a quando sul quarto
nastro non finiamo. Sul quarto nastro
c'è Blank. Lascio Blank e vado avanti
perché lo stavamo indietreggiando.
In Q10 facciamo i riavvolgimenti.
Eh, dove lo metto? Facciamo così. Qua
sul primo nastro c'è Alfa, lascio Alfa e
vado avanti. Sul quarto nastro c'è,
mettiamo un po' più di qua. Sul quarto
nastro c'è alfa. Lascio Alfa e vado
avanti. Ok.
Alright. Nel momento in cui ci dovesse
essere un cancelletto, allora ritorno
nello stato Q4. e continuo a fare il
processamento. Quindi sul primo nastro
c'è
cancelletto. Lascio cancelletto e vado
avanti. Sul quarto nastro c'è blank,
lascio blank e
torno dietro. Ok, quindi questo pezzo di
macchina si occupa di testare in
sequenza
la presenza di A dentro le W con i
di indice dispari e la presenza di B
reversted dentro le W con i di indice
pari. ha ovviamente introdotto il test
per di accettazione. Ok? E i punti in
cui facciamo il test
avanzando
sul primo nastro arriviamo invece che al
cancelletto, come in questo caso e in
questo caso arriviamo a un plank. Quindi
la condizione di accettazione sarà in
uscita da Q7 e da Q10.
Ok?
Quindi da Q7.
Sul primo nastro c'è Blank, lascio blank
e sto fermo. Sul secondo nastro c'è
Blank, lascio blank e sto fermo perché i
conti devono tornare e vado in Q11.
Similmente da Q10.
Sul primo nastro c'è Blank, lascio blank
e sto fermo. Sul secondo nastro c'è
Blank, lascio blank e
sto fermo.
Sì,
visto che una delle condizioni iniziali
era che la lunghezza di A fosse maggiore
della lunghezza di B, non dobbiamo
mettere questo controllo anche questo
controllo Sì, questo controllo viene
effettuato qui.
Dov'è? Qua. Nel momento in cui B
termina, perché ho beccato il
cancelletto dopo B, io verifico che su
terzo nastro ci sia un simbolo beta che
non sia blank. Ah, ok, ok, grazie.
Nulla, eh.
Ok, chiaro per tutti come funziona
questa macchina.
silenzio. Quindi assumo di sì. Eh, direi
che con questo per oggi possiamo
concludere. Quindi abbiamo visto un po'
di esercizi, probabilmente ne vedremo
altri in
futuro, devo però stabilire un po'
meglio. Eh, però credo che invece dalla
prossima lezione iniziamo
inizieremo a concentrarci
su risultati di calcolabilità.
inizieremo a vedere che ci sono
eh problemi che non sono linguaggi che
non sono nemmeno ricorsivamente
numerabili, quindi linguaggi per i quali
non abbiamo macchine che danno garanzia
di arresto, nemmeno in caso di eh di di
risposta positiva e inizieremo a vedere
un po' questi problemi come sono
collegati fra di loro e per far questo
introdurremo un concetto che è il
concetto di riduzione, magari non
proprio dalla primissima lezione, forse
fra due lezioni eccetera, che è un
concetto che poi ci porteremo avanti per
il resto del corso. Quindi quello sarà
un concetto fondamentale come si usa la
nozione di riduzione perché non solo ci
permette di stabilire che alcuni
problemi sono indecidibili,
ma sarà alla base della
dei tool che utilizzeremo per stabilire
che un problema è più difficile di un
altro. nel momento in cui andremo a
lavorare tramite la complessità, a
lavorare sulla complessità dei problemi,
il concetto di riduzione è una cosa che
utilizzeremo praticamente ogni giorno e
quindi ehm è importante che questa
nozione vi vi arrivi bene. Ok, con
questo possiamo concludere per oggi.
Grazie mille, buona giornata. Grazie
anche a lei. Arrivederci. Arrivederci.
Arrivederci. Ч.