PROVA INTERCORSO MOD.B a.a RICORSIONE ESERCIZI A1.1-A1.6

A.1.1. Assegnato un vettore di interi di lunghezza 2N scrivere una funzione ricorsiva per invertire il contenuto delle prime N caselle e quelle della seconda metà. Es PROGRAM EserA11(output,input); TYPEVett=ARRAY[1..10] OF integer; VAR A1:vett; N1,i:integer; PROCEDURE inverti(VAR A:vett; k:integer;N:integer); VAR Temp:integer; BEGIN IF k<N THEN inverti(A,k+1,N); IF K<=N div 2 THEN BEGIN Temp:=A[k]; A[k] :=A[N-k+1]; A[N-k+1]:=temp; Temp:=A[k+N]; A[k+N] :=A[2*N-k+1]; A[2*N-k+1]:=temp; END; {****MAIN****} BEGIN A1[i]:=…………………….; N1:=10; inverti(A1,1,N1 DIV 2); END.

A.2.1. Assegnata una matrice A, MxN di caratteri, con M  N scrivere una procedura ricorsiva per scambiare gli elementi A[i,j]con quelli A[i+1,j] se e solo se A[i,j] appartiene ad una stringa preassegnata e A[i+1,j] non vi appartiene. Es. stringa a z r Matrice a b c zk b c z k e f ra e f f a r q fa c q q a c z qa r z r PROGRAM ESer21(input,output); TYPEmat=ARRAY[1..5,1..4] OF char; Stringa=STRING[10]; VARAm:mat;strin:stringa; r,c,M1,N1:integer; PROCEDURE risolvi(VAR A:mat;VAR str1:stringa; i,j,M,N:integer); VAR temp:char; BEGIN IF i<M THEN IF j>N THEN risolvi(A,str1,i+1,1,M,N) ELSE BEGIN IF appartiene(A[i,j],str1,1) AND not appartiene(A[i+1,j],str1,1) THEN BEGIN temp:=A[i,j]; A[i,j]:=A[i+1,j]; A[i+1,j]:=temp; END; risolvi(A,str1,i,j+1,M,N); END; FUNCTION Appartiene(Elem:char; VAR str:STRINGA;K:integer):boolean; BEGIN IF K>length(str) THEN appartiene:=FALSE ELSE IF elem=str[k] THEN appartiene:=TRUE ELSE appartiene:=appartiene(elem,str,k+1) END; {*********** MAIN *************} BEGIN M1:=4; N1:=4; strin:='azr'; Am[i,j]:=‚…'; risolvi(Am,strin,1,1,M1,N1); END.

A.3.1. Data una stringa K ed un vettore V di interi di lunghezza N scrivere una procedura ricorsiva per eliminare dalla stringa K tutti quei caratteri il cui codice ASCII è presente nel vettore V. Es.stringavettorerisultato scremato rema PROGRAM ESer31(input,output); TYPEvett=ARRAY[1..7] OF INTEGER; Stringa=STRING[20]; VARV1:vett;strin,tem:stringa; n1,M1:integer; FUNCTION Appartiene(Elem:integer;VAR V1:vett;k,L:integer):boolean; BEGIN IF K>=L THEN appartiene:=FALSE ELSE IF elem=V1[k] THEN appartiene:=TRUE ELSE appartiene:=appartiene(elem,V1,k+1,L) END; PROCEDURE risolvi(VAR V:vett;VAR str1:stringa;VAR temp1:stringa; i,M,N:integer); BEGIN IF i<=1 THEN temp1:='' ELSE risolvi(V,str1,temp1,i-1,M,N); IF not appartiene(ord(str1[i]),V,1,N) THEN temp1:=temp1+str1[i]; END; {*********** MAIN *************} BEGIN N1:=7; V1[i]:=…….; strin:='scremato'; tem:=''; M1:=length(strin); risolvi(V1,strin,tem,m1,M1,N1); END.

A.4.1. Assegnata una matrice A, MxM di interi, scrivere una funzione ricorsiva che dia TRUE se la somma degli elementi sottostanti la diagonale principale è maggiore di un valore prefissato K e la somma degli elementi soprastanti la diagonale principale è minore dello stesso valore K. Es per K=25 la funzione è vera 7291per K=15 la funzione è falsa 4581 PROGRAM ESer41(input,output); TYPEmat=ARRAY[1..4,1..4] OF integer; VARAm:mat; r,c,SumD,SumU,M1,K1:integer; FUNCTION risolvi(VAR A:mat; VAR sumdown,sumUp:integer;i,j,M,K:integer):boolean; BEGIN IF i>2 THEN IF (j<=1) THEN risolvi:=risolvi(A,sumdown,sumup,i-1,i-2,M,K) ELSE risolvi:=risolvi(A,sumdown,sumup,i,j-1,M,K); sumdown:=sumdown+A[i,j]; sumup:=sumup+A[j,i]; risolvi:=(sumdown>K) AND (sumUp<K) END; {*********** MAIN *************} BEGIN M1:=4; Am[1,1]:=………….; K1:=7; SumD:=0; SumU:=0; writeln(' OUTPUT'); writeln(' la matrice è corretta ', risolvi(Am,SumD,SumU,M1,M1-1,M1,K1)); writeln(' Perchè K=',k1:5,' e sumD ',sumd:5,' sumU ',sumU:5); END.

A.5.1. Assegnati due vettori A, B di interi, scrivere una funzione ricorsiva che dia TRUE se la somma degli elementi di posto dispari del primo vettore invertito è minore della somma degli elementi di posto pari del secondo vettore. Es. Vettore A Vettore A invertitoSomma elementi posto dispari =12 [ ] [ ] Vettore B risultato=FALSE [ ]Somma elementi posto pari =5 PROGRAM ESer51(input,output); TYPEmat=ARRAY[1..6] OF integer; VARAm,Bm:mat; r,c,SumD,SumP,M1:integer; FUNCTION risolvi(VAR A,B:mat; sumd,sump:integer;M,i:integer):boolean; BEGIN IF i>=M THEN write(' Essendo SumD di A invertito=',SumD:5,' e sumPari di B=',sumP:5,' l''ipotesi è ') ELSE risolvi:=risolvi(A,B,sumd+A[M-i+1],sump+B[i+1],M,i+2); risolvi:=(sumd=sump) END; {*********** MAIN *************} BEGIN M1:=6; Am[1]:=7; SumD:=0; SumP:=0; writeln(risolvi(Am,Bm,SumD,SumP,M1,1)); END.

A.6.1. Assegnata una matrice A, 2Mx2M di interi, scrivere una funzione ricorsiva che dia TRUE se la somma degli elementi del I° quadrante è uguale a quella del 4° e quella del 2° è uguale a quella del 3°. Es MatriceRisultatoTRUE PROGRAM ESer61(input,output); TYPEmat=ARRAY[1..4,1..4] OF integer; VARAm:mat; r,c,Sum1,Sum2,sum3,sum4,M1:integer; FUNCTION risolvi(VAR A:mat; sumq1,sumq2,sumq3,sumq4:integer;i,j,M:integer):boolean; BEGIN IF i>M div 2 THEN BEGIN risolvi:=(sumq1=sumq4) AND (sumq2=sumq3) END ELSE IF j>M div 2 THEN risolvi:=risolvi(A,sumq1,sumq2,sumq3,sumq4,i+1,1,M) ELSE risolvi:=risolvi(A,sumq1+A[i,j],sumq2+A[i,j+M div 2],sumq3+A[i+M div 2,j], sumq4+A[i+M div 2,j+M div 2],i,j+1,M) END; {*********** MAIN *************} BEGIN M1:=4; Am[1,1]:=4; Sum1:=0; Sum2:=0; Sum3:=0; Sum4:=0; writeln(' OUTPUT'); writeln(' che la matrice sia corretta è ',risolvi(Am,Sum1,Sum2,sum3,sum4, 1,1,M1)); END.

PROVA INTERCORSO MOD.B a.a RICORSIONE ESERCIZI B1.1-B1.6

B.1.1. Data una matrice A di caratteri MxN scrivere una funzione ricorsiva che verifichi se tutti i caratteri contenuti in una stringa preassegnata S sono presenti almeno una volta in A. EsStringaCUORE Matrice ZOARisultato TRUE RTE UCO FFU PROGRAM ESerB11(input,output); TYPEmat=ARRAY[1..4,1..3] OF char; Stringa=STRING[10]; VARAm:mat;strin:stringa; r,c,M1,N1:integer; FUNCTION Appartiene(VAR A:mat;VAR str:STRINGA;i,j,K,M,N:integer):boolean; BEGIN IF K<=length(str) THEN BEGIN IF i>M THEN appartiene:=FALSE ELSE BEGIN IF j>N THEN appartiene:=appartiene(A,str,i+1,1,k,M,N) ELSE IF A[i,j]=str[k] THEN appartiene:=appartiene(A,str,1,1,k+1,M,N) ELSE appartiene:=appartiene(A,str,i,j+1,k,M,N) END; END ELSE appartiene:=TRUE; END; {*********** MAIN *************} BEGIN M1:=4; N1:=3; strin:='cuore'; Am[1,1]:=‚….'; writeln(' stringa = ',strin); writeln('L''ipotesi che ',strin:2,' sia contenuta in A è ', appartiene(Am,strin,1,1,1,M1,N1)); END.

B.2.1. Dato un vettore A di interi di lunghezza N scrivere una funzione ricorsiva che verifichi che la somma degli elementi nelle posizioni dispari è maggiore di quella nelle posizioni pari e minore di un preassegnato valore K. Es. K= 9 A Somma dispari = 18 > K Somma pari = 7 Risultato FALSE PROGRAM B21(output,input); TYPEVett=ARRAY[1..10] OF integer; VAR A1:vett; N1,K1,Sd1,Sp1,i:integer; FUNCTION verifica(VAR A:vett; Sd,Sp,i,k:integer;N:integer):boolean; BEGIN IF i>N THEN BEGIN writeln(' Poichè Sd= ',Sd:3,' e Sp= ',Sp:3,' e K= ',k:3,' l''ipotesi è '); verifica:=(Sd>Sp) AND (Sd<K) END ELSE IF (i+1)<N THEN verifica:=verifica(A,Sd+A[i],Sp+A[i+1],i+2,K,N) ELSE verifica:=verifica(A,Sd+A[i],Sp,i+2,K,N) END; (*MAIN*) BEGIN A1[1]:=………….; K1:=29; N1:=5; Sd1:=0; Sp1:=0; writeln(verifica(A1,Sd1,Sp1,1,K1,N1)); END.

B.3.1. Sia A una matrice Mx2N scrivere una funzione ricorsiva che verifichi se ogni colonna di indice dispari è uguale a quella di indice pari che la segue immediatamente e invertita. Es. MatriceRisultato 4478TRUE PROGRAM ESerB31(input,output); TYPEmat=ARRAY[1..4,1..4] OF integer; VARAm:mat; r,c,M1,N1:integer; FUNCTION verifica(VAR A:mat;i,j,M,N2:integer):boolean; BEGIN IF j>N2 THEN verifica:=TRUE ELSE BEGIN IF i>M THEN verifica:=verifica(A,1,j+2,M,N2) ELSE BEGIN IF A[i,j]=A[M-i+1,j+1] THEN verifica:=verifica(A,i+1,j,M,N2) ELSE verifica:=FALSE END; {*********** MAIN *************} BEGIN M1:=4; N1:=4; Am[1,1]:=4; writeln('L''ipotesi Š ',verifica(Am,1,1,M1,N1)); writeln; readln; END.

B.4.1. Data una matrice A di interi 2Nx2N scrivere una funzione ricorsiva che verifichi se la somma degli elementi della metà superiore delle diagonali principale e secondaria sono uguali e se la somma degli elementi della metà inferiore delle diagonali principale e secondaria sono diverse PROGRAM ESerB41(input,output); TYPEmat=ARRAY[1..4,1..4] OF integer; VARAm:mat;Su1,Su2,So1,So2,r,c,M1:integer; FUNCTION verifica(VAR A:mat;Sup1,Sup2,Sot1,Sot2,i,M:integer):boolean; BEGIN IF i>M DIV 2 THEN verifica:=(Sup1=Sup2) AND (Sot1<>Sot2) ELSE verifica:=verifica(A,Sup1+A[i,i],Sup2+A[i,M-i+1], Sot1+A[M-i+1,i],Sot2+A[M-i+1,M-i+1],i+1,M); END; {*********** MAIN *************} BEGIN M1:=4; Am[1,1]:=,,,,,,,,,,,,,,,,,,,; Su1:=0;Su2:=0;So1:=0;So2:=0; writeln('L''ipotesi Š ',verifica(Am,Su1,Su2,So1,So2,1,M1)); END. Risultato TRUE Somma superiore 3  5=6+2 Somma inferiore 9  4≠4+7

B.5.1. Data una stringa S di lunghezza K scrivere una funzione ricorsiva che verifichi che non vi siano piú di M occorrenze di K in un vettore di caratteri di lunghezza N  K. Es. Stringa bab M =3 Ab a b b a a a b a b a b b a b a a Risultato TRUE PROGRAM ESerB51(input,output); TYPEmat=ARRAY[1..17] OF char; Stringa=STRING[10]; VARAm:mat;strin:stringa; c,M1,K1:integer; FUNCTION Verifica(VAR A:mat;VAR str:STRINGA;iold,i,j,K,M,conta:integer):boolean; BEGIN IF i>M THEN verifica:=(conta<=K) ELSE IF j>length(str) THEN verifica:=verifica(A,str,iold+1,iold+1,1,k,M,conta+1) ELSE IF A[i]<>str[j] THEN verifica:=verifica(A,str,iold+1,iold+1,1,k,M,conta) ELSE verifica:=verifica(A,str,iold,i+1,j+1,k,M,conta) END; {*********** MAIN *************} BEGIN M1:=17; K1:=4; strin:='bab'; Am[1]:=‚……………'; writeln('L''ipotesi che ',strin:2,' sia contenuta in A meno di ',K1:3, ' è ',Verifica(Am, strin,1,1,1,K1,M1,0)); END.

B.6.1. Data due matrici A e B di interi 2Nx2N scrivere una funzione ricorsiva che verifichi se la diagonale principale di A sia uguale alla secondaria di B e viceversa. Risultato TRUE PROGRAM ESerB61(input,output); TYPEmat=ARRAY[1..5,1..5] OF integer; VARAm,Bm:mat;r,c,M1:integer; FUNCTION verifica(VAR A,B:mat;i,M:integer):boolean; BEGIN IF i>M THEN verifica:=TRUE ELSE IF (A[i,i]=B[i,M-i+1]) AND (A[i,M-i+1]=B[i,i]) THEN verifica:=verifica(A,B,i+1,M) ELSE verifica:=FALSE; END; {*********** MAIN *************} BEGIN M1:=5; Am[1,1]:=…………….; Bm[1,1]:=……………….; writeln('L''ipotesi Š ',verifica(Am,Bm,1,M1)); END. MatriceB MatriceA

LISTE ESERCIZI A1.1-A1.6

PROGRAM EserA13(output,input); CONST NullItem=-100 ;{controllo di eventuali errori } TYPE STRING20=STRING[20]; ItemType= integer; LNodeP=^LNodeType; LNodeType = RECORD Item:ItemType; Next:LNodeP END; VAR LL1,LL2,LL3,T3,LL3,prec1,prec2:LNodeP; k1:ItemType; { ******** MAIN *********} BEGIN CreaLista(LL1); CreaLista(LL2); write(' Dammi occorrenza ');readln(k1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA INIZIALE L2'); writeln; LeggiLista(LL2); T3:=NIL;LL3:=NIL; prec1:=NIL;prec2:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(multiplo(prec1,prec2,LL1,LL2, T3,LL3,LL1,LL2,K1)); END. A.1.3. Assegnate due liste legate L1, L2 di interi con egual numero di nodi, scrivere una funzione per creare una lista L3 tale che per ogni coppia di elementi posti nella stessa posizione in L1 e L2 se la somma dei loro item è multiplo di un preassegnato K allora si aggiunge a L3 un nodo avente per item tale somma e i due nodi di L1 e L2 si lasciano al loro posto. Se la condizione non è verificata allora i nodi corrispondenti in L1 e L2 si cancellano. Es.Sia K=3 L L L3159 L1 5 2 L2 10 7

{ ******** MAIN *********} BEGIN CreaLista(LL1); CreaLista(LL2); write(' Dammi occorrenza ');readln(k1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA INIZIALE L2'); writeln; LeggiLista(LL2); T3:=NIL;Li3:=NIL; prec1:=NIL;prec2:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(multiplo(prec1,prec2,LL1,LL2,T3,Li3,LL1,LL2,K1)); END. PROCEDURE MakeNode(AItem:ItemType; VAR Nod:LNodeP); BEGIN new(Nod); Nod^.Item:= AItem; Nod^.Next:=NIL PROCEDURE CreaLista(VAR L1:LnodeP); VAR AnItem:ItemType; L,Node:LnodeP; BEGIN Writeln('Dammi gli item (0 per uscire) '); readln(AnItem); IF AnItem=0 THEN L1:=NIL ELSE BEGIN MakeNode(AnItem,L); L1:=L; WHILE AnItem <> 0 DO BEGIN readln(AnItem); IF AnItem<>0 THEN BEGIN MakeNode(AnItem,Node); L^.next:=Node; L:=Node END; END END; PROCEDURE LeggiLista(L1:LnodeP); VAR Nod: LnodeP;Aitem:ItemType; BEGIN IF L1=NIL THEN writeln('Lista Vuota ') ELSE BEGIN Nod:=L1; WHILE Nod^.next<>NIL DO BEGIN AItem:=Nod^.item; writeln(' - ',Aitem); Nod:=Nod^.next; END; AItem:=Nod^.item; writeln(' - ',Aitem); END;

PROCEDURE KillNode(VAR Node:LNodeP); BEGIN IF Node <> NIL THEN BEGIN dispose(Node); Node:=NIL END END; { ******** MAIN *********} BEGIN CreaLista(LL1); CreaLista(LL2); write(' Dammi occorrenza ');readln(k1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA INIZIALE L2'); writeln; LeggiLista(LL2); T3:=NIL;Li3:=NIL; prec1:=NIL;prec2:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(multiplo(prec1,prec2,LL1,LL2,T3,Li3,LL1,LL2,K1)); END. PROCEDURE Cancella(VAR TLis, prevc,myL:LNodeP); VAR Temp:LNodeP; BEGIN IF prevc<>NIL THEN Temp:= Prevc^.next ELSE Temp:=Tlis; IF temp<>NIL THEN IF prevc<>NIL THEN BEGIN myL:=temp^.next; Prevc^.next:=temp^.next END ELSE BEGIN Tlis:=temp^.next; myL:=Tlis END; KillNode(Temp); END;

FUNCTION multiplo(prev1,prev2:LNodeP;VAR TL1,TL2,TL3,L3:LNodeP;myl1,myl2:LNodeP;k:itemtype):LNodeP; BEGIN IF myl1=NIL THEN multiplo:=Tl3 ELSE BEGIN IF (myl1^.item+myl2^.item) MOD k =0 THEN BEGIN Prev1:=myl1; prev2:=myl2; Aggiungi(TL3,L3,myl1^.item+myl2^.item); multiplo:=multiplo(prev1,prev2,Tl1,Tl2,TL3,L3, myl1^.next,myl2^.next,k) END ELSE BEGIN Cancella(TL1,prev1,myL1); Cancella(TL2,prev2,myL2); multiplo:=multiplo(prev1,prev2,TL1,Tl2,TL3,L3, myl1,myl2,k) END; PROCEDURE aggiungi(VAR Tx3:LNodeP; VAR Lx3:LNodeP;somma:integer); VAR nodo:LNodep; BEGIN new(nodo); nodo^.item:=somma; nodo^.next:=NIL; IF Tx3=NIL THEN BEGIN Tx3:=nodo; Lx3:=Tx3; END ELSE BEGIN Lx3^.next:=nodo; Lx3:=nodo; END; { ******** MAIN *********} BEGIN …………………………. T3:=NIL;Li3:=NIL; prec1:=NIL;prec2:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(multiplo(prec1,prec2,LL1,LL2,T3,Li3,LL1,LL2,K1)); END.

A.2.3. Assegnata una lista L1 di caratteri e una stringa S di due caratteri. Scrivere una procedura che elimini da L1 tutti i nodi il cui item è uguale a S[1] e raddoppi tutti quelli uguali a S[2]. Es. Stringab r Listafbrzbtrb Risultatofrrztrr PROGRAM EserA23(output,input); CONST NullItem='*' ;{controllo di eventuali errori } TYPE STRING20=STRING[20]; ItemType= char; LNodeP=^LNodeType; LNodeType = RECORD Item:ItemType; Next:LNodeP END; VAR LL1, prec1,prec2:LNodeP;k1:string20; { ******** MAIN *********} BEGIN CreaLista(LL1); write(' Dammi stringa ');readln(k1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA FINALE L1'); writeln; prec1:=NIL; LeggiLista(aggiorna(LL1,prec1,LL1,K1)); readln; END.

PROCEDURE aggiungi(VAR Tx3:LNodeP;VAR Lx3:LNodeP;caratt:char); VAR nodo:LNodep; BEGIN new(nodo); nodo^.item:=caratt; nodo^.next:=lx3^.next; IF Tx3=NIL THEN BEGIN Tx3:=nodo; Lx3:=Tx3; END ELSE BEGIN Lx3^.next:=nodo; Lx3:=nodo; END; FUNCTION aggiorna(VAR TL1:LNodeP;prev1,L1:LNodeP;k:string20):LNodeP; BEGIN IF L1=NIL THEN aggiorna:=Tl1 ELSE BEGIN IF (L1^.item) = k[1] THEN BEGIN cancella(Tl1,prev1,L1); aggiorna:=aggiorna(TL1,prev1,L1,k) END ELSE BEGIN IF (L1^.item) = k[2] THEN BEGIN Aggiungi(TL1,L1,k[2]); aggiorna:=aggiorna(TL1,L1,L1^.next,k) END ELSE BEGIN aggiorna:=aggiorna(TL1,L1,L1^.next,k) END; { ******** MAIN *********} BEGIN CreaLista(LL1); write(' Dammi stringa ');readln(k1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA FINALE L1'); writeln; prec1:=NIL; LeggiLista(aggiorna(LL1,prec1,LL1,K1)); readln; END.

A.3.3. Data una lista L ordinata di caratteri, scrivere una funzione per invertire tutti i nodi il cui valore sia inferiore a un preassegnato carattere K. Es. K=f Lacderst Risultato Ledcarst PROGRAM EserA23(output,input); CONST NullItem='*' ;{controllo di eventuali errori } TYPE STRING20=STRING[20]; ItemType= char; LNodeP=^LNodeType; LNodeType = RECORD Item:ItemType; Next:LNodeP END; VAR LL1,prec1:LNodeP;k1:char; { ******** MAIN *********} BEGIN CreaLista(LL1); write(' Dammi carattere ');readln(k1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA FINALE L1'); writeln; prec1:=NIL; leggilista(inverti(LL1,prec1,LL1,K1)); readln; END. FUNCTION inverti(VAR TL1:LNodeP;prev1,L1:LNodeP;k:char):LNodeP; VAR temp,temp2:LnodeP; BEGIN WHILE (L1<>NIL) AND (L1^.item<K) DO begin temp2:=L1^.next; L1^.next:=prev1; prev1:=L1; temp:=L1; L1:=temp2; end; Tl1^.next:=temp2; inverti:=temp; END;

A.4.3. Date due liste L1, L2 di caratteri scrivere una funzione che restituisca una lista L3 ottenuta collegando in coda alla lista L1 la lista L2, eliminando da L1 tutte le vocali e dalla lista L2 tutte le consonanti. Es. L1a d f e d c u->d f d c L2b t a r s o->a o L3d f d c a o PROGRAM EserA43(output,input); CONST NullItem='*' ;{controllo di eventuali errori } TYPE STRING20=STRING[20]; ItemType= char; LNodeP=^LNodeType; LNodeType = RECORD Item:ItemType; Next:LNodeP END; VAR LL1,LL2,prec1:LNodeP; { ******** MAIN *********} BEGIN CreaLista(LL1); CreaLista(LL2); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA INIZIALE L2'); writeln; LeggiLista(LL2); prec1:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(aggiorna(LL1,LL1,prec1,LL2)); readln; END.

FUNCTION aggiorna(VAR TL1:LNodeP;L1,prev1:LNodeP;L2:LNodeP):LNodeP; VAR TL2,prev2:LNodeP; BEGIN WHILE L1<>NIL DO BEGIN IF L1^.ITEM IN ['a', 'e', 'i', 'o', 'u'] THEN Cancella(TL1,prev1,L1); ELSE BEGIN Prev1:=L1; L1:=L1^.next; END; TL2:=L2; Prev1^.next:=L2; prev2:=prev1; WHILE L2<>NIL DO BEGIN IF NOT (L2^.ITEM IN ['a', 'e','i', 'o', 'u']) THEN Cancella(TL2,prev2,L2); ELSE BEGIN Prev2:=L2; L2:=L2^.next; END; aggiorna:=TL1; END; { ******** MAIN *********} BEGIN CreaLista(LL1); CreaLista(LL2); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA INIZIALE L2'); writeln; LeggiLista(LL2); prec1:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(aggiorna(LL1,LL1,prec1,LL2)); readln; END.

A.5.3. Date una lista L1 di interi scrivere una funzione che la trasformi in una lista circolare in cui per ogni nodo se ne aggiungono di seguito ad esso tante copie quante vale l’intero contenuto nell’item. L L PROGRAM EserA23(output,input); CONST NullItem=-100 ;{controllo di eventuali errori } TYPE STRING20=STRING[20]; ItemType= integer; LNodeP=^LNodeType; LNodeType = RECORD Item:ItemType; Next:LNodeP END; VAR LL1; { ******** MAIN *********} BEGIN CreaLista(LL1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA CORRETTA'); LeggiLista(aggiorna(LL1,LL1)); readln; END. PROCEDURE LeggiLista(L1:LnodeP); VAR TL1,Nod: LnodeP;Aitem:ItemType;flag:boolean; BEGIN TL1:=L1; IF L1=NIL THEN writeln('Lista Vuota ') ELSE BEGIN Nod:=L1; flag:=FALSE; WHILE (Nod^.next<>NIL) AND (Not FLAG) DO BEGIN IF nod^.next=TL1 THEN BEGIN flag:=TRUE; writeln('Lista Circolare') END ELSE BEGIN AItem:=Nod^.item; writeln(' - ',Aitem); Nod:=Nod^.next; END; IF Not FLAG THEN BEGIN AItem:=Nod^.item; writeln(' - ',Aitem); END;

PROCEDURE aggiungi(VAR Lx3:LNodeP;caratt:integer); VAR nodo:LNodep; BEGIN new(nodo); nodo^.item:=caratt; nodo^.next:=lx3^.next; BEGIN Lx3^.next:=nodo; Lx3:=nodo; END; FUNCTION aggiorna(VAR TL1:LNodeP; L1:LNodeP):LNodeP; VAR temp,prec:LNodeP; i:integer; BEGIN WHILE L1<>NIL DO BEGIN Temp:=L1^.next; FOR I:=1 TO L1^.item DO Aggiungi(L1,L1^.item); prec:=L1; L1:=L1^.next; END; prec^.next:=TL1; aggiorna:=TL1; END; { ******** MAIN *********} BEGIN CreaLista(LL1); writeln(' LISTA INIZIALE L1'); writeln; LeggiLista(LL1); writeln(' LISTA CORRETTA'); LeggiLista(aggiorna(LL1,LL1)); readln; END.