1 / 26

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

PROVA INTERCORSO MOD.B a.a. 2005-2006. 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. 3-8-5-28 -7-6-2-1 28-5-8-3 -1-2-6-7-.

kaiyo
Download Presentation

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

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  2. 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 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; END; {****MAIN****} BEGIN A1[i]:=…………………….; N1:=10; inverti(A1,1,N1 DIV 2); END.

  3. 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 z k b c z k e f ra e f f a r q f a c q q a c z q a r z r 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; 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; 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; END; {*********** MAIN *************} BEGIN M1:=4; N1:=4; strin:='azr'; Am[i,j]:=‚…'; risolvi(Am,strin,1,1,M1,N1); END.

  4. 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 scremato115 90 11699111 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; 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.

  5. 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 4 3 5 6 3 per K=25 la funzione è vera 7 2 9 1 per K=15 la funzione è falsa 4 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; 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.

  6. 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 B risultato=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; 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.

  7. 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 Matrice Risultato TRUE 4 27 2 3 56 3 7 24 1 4 58 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; 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.

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

  9. 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 CUORE Matrice Z O A Risultato TRUE R T E U C O F 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; 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.

  10. 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 1 3 8 4 9 Somma dispari = 18 > K Somma pari = 7 Risultato 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; 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.

  11. 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 TRUE 3 7 6 4 7 3 4 6 4 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 *************} BEGIN M1:=4; N1:=4; Am[1,1]:=4; writeln('L''ipotesi Š ',verifica(Am,1,1,M1,N1)); writeln; readln; END.

  12. 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. 3472 3564 7946 4487 Risultato TRUE Somma superiore 35=6+2 Somma inferiore 94≠4+7 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 *************} 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.

  13. 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 A b a b b a a a b a b a b b a b a a Risultato 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 *************} 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.

  14. 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 Matrice B 4 4 7 8 3 3 3 6 7 4 7 3 2 6 1 4 5 8 7 8 8 7 6 4 8 Matrice A 3 4 7 8 4 3 7 6 3 2 7 3 2 6 3 4 7 8 5 5 8 7 6 4 1 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 *************} BEGIN M1:=5; Am[1,1]:=…………….; Bm[1,1]:=……………….; writeln('L''ipotesi Š ',verifica(Am,Bm,1,M1)); END.

  15. LISTE ESERCIZI A1.1-A1.6

  16. 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 L1 3 5 6 2 4 L2 8 10 7 7 3 L3 15 9 L1 5 2 L2 10 7 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.

  17. { ******** 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; 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; END;

  18. { ******** 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; PROCEDURE KillNode(VAR Node:LNodeP); BEGIN IF Node <> NIL THEN BEGIN dispose(Node); Node:=NIL END END;

  19. 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; 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.

  20. 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 r Lista f b r z b t r b Risultato f r r z t r r 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.

  21. 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; 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; END; END; 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.

  22. 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 L a c d e r s t Risultato L e d c a r s t 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;

  23. 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 o L3 d 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.

  24. 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; 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; 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.

  25. 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 2 L1 3 3 3 3 2 2 2 4 4 4 4 4 1 1 0 2 2 2 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; END; IF Not FLAG THEN BEGIN AItem:=Nod^.item; writeln(' - ',Aitem); END; END; END; 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.

  26. 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; 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.

More Related