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

PROVA INTERCORSO MOD.B a.a. 2005-2006

RICORSIONEESERCIZI 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. 3-8-5-28-7-6-2-1 28-5-8-3-1-2-6-7-

PROGRAM EserA11(output,input);TYPE Vett=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 THENBEGIN

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;END;{****MAIN****}BEGINA1[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

Matricea b c z k b c zk e f r a e f fa r q f a c q qa c z q a r z r

PROGRAM ESer21(input,output);TYPE mat=ARRAY[1..5,1..4] OF char; Stringa=STRING[10];VAR Am:mat;strin:stringa; r,c,M1,N1:integer;

PROCEDURE risolvi(VAR A:mat;VAR str1:stringa; i,j,M,N:integer);VAR temp:char;BEGINIF 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;END;

FUNCTION Appartiene(Elem:char; VAR str:STRINGA;K:integer):boolean;

BEGINIF K>length(str) THEN appartiene:=FALSEELSE IF elem=str[k] THEN appartiene:=TRUE ELSE appartiene:=appartiene(elem,str,k+1)END;

{*********** MAIN *************}BEGINM1:=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. stringa vettore risultato

scremato 115 90 116 99 111 71 76 rema

PROGRAM ESer31(input,output);TYPE vett=ARRAY[1..7] OF INTEGER; Stringa=STRING[20];VAR V1:vett;strin,tem:stringa; n1,M1:integer;

FUNCTION Appartiene(Elem:integer;VAR V1:vett;k,L:integer):boolean;BEGINIF K>=L THEN appartiene:=FALSEELSE 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);BEGINIF 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 *************}BEGINN1:=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.

4 2 1 43 5 6 3 per K=25 la funzione è vera7 2 9 1 per K=15 la funzione è falsa4 5 8 1

PROGRAM ESer41(input,output);TYPE mat=ARRAY[1..4,1..4] OF integer;VAR Am:mat; r,c,SumD,SumU,M1,K1:integer; FUNCTION risolvi(VAR A:mat; VAR sumdown,sumUp:integer;i,j,M,K:integer):boolean;BEGINIF 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 *************}BEGINM1:=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 invertito Somma elementi posto dispari =12[7 4 3 2 8 6] [6 8 2 3 4 7]Vettore Brisultato=FALSE[10 2 3 4 1 1] Somma elementi posto pari =5

PROGRAM ESer51(input,output);TYPE mat=ARRAY[1..6] OF integer;VAR Am,Bm:mat; r,c,SumD,SumP,M1:integer;

FUNCTION risolvi(VAR A,B:mat; sumd,sump:integer;M,i:integer):boolean;BEGINIF i>=M THENwrite(' 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 *************}BEGINM1:=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°.EsMatrice Risultato TRUE

4 2 7 23 5 6 37 2 4 14 5 8 1

PROGRAM ESer61(input,output);TYPE mat=ARRAY[1..4,1..4] OF integer;VAR Am:mat; r,c,Sum1,Sum2,sum3,sum4,M1:integer; FUNCTION risolvi(VAR A:mat; sumq1,sumq2,sumq3,sumq4:integer;i,j,M:integer):boolean;BEGINIF i>M div 2 THEN BEGIN risolvi:=(sumq1=sumq4) AND (sumq2=sumq3) ENDELSE 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 *************}BEGINM1:=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. 2005-2006

RICORSIONEESERCIZI 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.Es Stringa CUOREMatrice Z O A Risultato TRUE

R T EU C OF F U

PROGRAM ESerB11(input,output);TYPE mat=ARRAY[1..4,1..3] OF char; Stringa=STRING[10];VAR Am:mat;strin:stringa; r,c,M1,N1:integer;FUNCTION Appartiene(VAR A:mat;VAR str:STRINGA;i,j,K,M,N:integer):boolean;BEGINIF 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; ENDELSEappartiene:=TRUE;END;

{*********** MAIN *************}BEGINM1:=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= 9A 1 3 8 4 9Somma dispari = 18 > KSomma pari = 7Risultato FALSE

PROGRAM B21(output,input);TYPE Vett=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;BEGINIF 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) ENDELSE 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*)BEGINA1[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. Matrice Risultato

4 4 7 8 TRUE3 7 6 47 3 4 64 4 8 7

PROGRAM ESerB31(input,output);TYPE mat=ARRAY[1..4,1..4] OF integer;VAR Am: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; END;END;

{*********** MAIN *************}BEGINM1:=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.

3472356479464487

PROGRAM ESerB41(input,output);TYPE mat=ARRAY[1..4,1..4] OF integer;VAR Am: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 *************}BEGINM1:=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 TRUESomma superiore 35=6+2Somma inferiore 94≠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 NK.Es.

Stringa babM =3A b a b b a a a b a b a b b a b a aRisultato TRUE

PROGRAM ESerB51(input,output);TYPE mat=ARRAY[1..17] OF char; Stringa=STRING[10];VAR Am: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 *************}BEGINM1:=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);TYPE mat=ARRAY[1..5,1..5] OF integer;VAR Am,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 *************}BEGINM1:=5;Am[1,1]:=…………….;Bm[1,1]:=……………….;writeln('L''ipotesi Š ',verifica(Am,Bm,1,M1));END.

Matrice B4 4 7 8 33 3 6 7 47 3 2 6 14 5 8 7 88 7 6 4 8

Matrice A3 4 7 8 43 7 6 3 27 3 2 6 34 7 8 5 58 7 6 4 1

LISTEESERCIZI A1.1-A1.6

PROGRAM EserA13(output,input);CONSTNullItem=-100 ; {controllo di eventuali errori }TYPESTRING20=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 *********}BEGINCreaLista(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=3L1 3 5 6 2 4L2 8 10 7 7 3L3 15 9L1 5 2 L2 10 7

{ ******** MAIN *********}BEGINCreaLista(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);

BEGINnew(Nod);Nod^.Item:= AItem;Nod^.Next:=NIL

PROCEDURE CreaLista(VAR L1:LnodeP);VAR AnItem:ItemType; L,Node:LnodeP;BEGINWriteln('Dammi gli item (0 per uscire) ');readln(AnItem);IF AnItem=0 THEN L1:=NILELSEBEGIN 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; ENDEND;END;

PROCEDURE LeggiLista(L1:LnodeP);VAR Nod: LnodeP;Aitem:ItemType;BEGINIF 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;END;

PROCEDURE KillNode(VAR Node:LNodeP);BEGIN

IF Node <> NIL THEN BEGIN

dispose(Node);Node:=NIL

ENDEND;

{ ******** MAIN *********}BEGINCreaLista(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);VARTemp:LNodeP;BEGINIF prevc<>NIL THEN

Temp:= Prevc^.nextELSE

Temp:=Tlis; IF temp<>NIL THEN IF prevc<>NIL THEN

BEGIN myL:=temp^.next; Prevc^.next:=temp^.nextENDELSEBEGIN Tlis:=temp^.next; myL:=TlisEND;

KillNode(Temp);END;

FUNCTION multiplo(prev1,prev2:LNodeP;VAR TL1,TL2,TL3,L3:LNodeP;myl1,myl2:LNodeP;k:itemtype):LNodeP;BEGINIF 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; END;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;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.Stringa b rLista f b r z b t r bRisultato f r r z t r r

PROGRAM EserA23(output,input);CONSTNullItem='*' ; {controllo di eventuali errori }TYPESTRING20=STRING[20];ItemType= char;


Item:ItemType; Next:LNodeP

END;VAR LL1, prec1,prec2:LNodeP;k1:string20;{ ******** MAIN *********}BEGINCreaLista(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;END;

FUNCTION aggiorna(VAR TL1:LNodeP;prev1,L1:LNodeP;k:string20):LNodeP;BEGINIF L1=NIL THEN aggiorna:=Tl1 ELSE BEGIN IF (L1^.item) = k[1] THEN

BEGINcancella(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; END; END;END;

{ ******** MAIN *********}BEGINCreaLista(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=fL a c d e r s tRisultatoL e d c a r s t



Item:ItemType;Next:LNodeP

END;VAR LL1,prec1:LNodeP;k1:char;{ ******** MAIN *********}BEGINCreaLista(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;BEGINWHILE (L1<>NIL) AND (L1^.item<K) DObegin 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.

L1 a d f e d c u -> d f d c L2 b t a r s o -> a oL3 d f d c a o




END;VAR LL1,LL2,prec1:LNodeP;

{ ******** MAIN *********}BEGINCreaLista(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;BEGINWHILE L1<>NIL DO BEGIN

IF L1^.ITEM IN ['a', 'e', 'i', 'o', 'u'] THENCancella(TL1,prev1,L1);

ELSEBEGINPrev1:=L1;L1:=L1^.next;END;

END;TL2:=L2;Prev1^.next:=L2;prev2:=prev1;WHILE L2<>NIL DO BEGIN

IF NOT (L2^.ITEM IN ['a', 'e','i', 'o', 'u']) THENCancella(TL2,prev2,L2);

ELSEBEGINPrev2:=L2;L2:=L2^.next;END;

END;aggiorna:=TL1;END;

{ ******** MAIN *********}BEGINCreaLista(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.L1 3 2 4 1 0 2L1 3 3 3 3 2 2 2 4 4 4 4 4 1 1 0 2 2 2

PROGRAM EserA23(output,input);CONSTNullItem=-100 ; {controllo di eventuali errori }TYPESTRING20=STRING[20];ItemType= integer;



END;VAR LL1; { ******** MAIN *********}BEGINCreaLista(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;BEGINTL1:=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; END; IF Not FLAG THEN BEGIN AItem:=Nod^.item; writeln(' - ',Aitem); END; END;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;END;

FUNCTION aggiorna(VAR TL1:LNodeP; L1:LNodeP):LNodeP;VAR temp,prec:LNodeP; i:integer;BEGINWHILE L1<>NIL DO

BEGINTemp:=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 *********}BEGINCreaLista(LL1);writeln(' LISTA INIZIALE L1'); writeln;LeggiLista(LL1);writeln(' LISTA CORRETTA');LeggiLista(aggiorna(LL1,LL1));readln;END.

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

Documents

Transcript of PROVA INTERCORSO MOD.B a.a. 2005-2006 RICORSIONE ESERCIZI A1.1-A1.6.