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-7PROGRAM 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.
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
azr
Matrice
abcz
kbcz
kefr
aeff
FUNCTION Appartiene(Elem:char;
arqf
acqq
VAR str:STRINGA;K:integer):boolean;
aczq
arzr
BEGIN
PROGRAM ESer21(input,output);
IF K>length(str) THEN
TYPE
mat=ARRAY[1..5,1..4] OF char; Stringa=STRING[10];
appartiene:=FALSE
VAR
Am:mat;strin:stringa; r,c,M1,N1:integer;
ELSE
IF elem=str[k] THEN
PROCEDURE risolvi(VAR A:mat;VAR str1:stringa; i,j,M,N:integer);
appartiene:=TRUE
VAR temp:char;
ELSE
BEGIN
appartiene:=appartiene(elem,str,k+1)
IF i<M THEN
END;
IF j>N THEN
risolvi(A,str1,i+1,1,M,N)
ELSE
BEGIN
{*********** MAIN *************}
IF appartiene(A[i,j],str1,1) AND not appartiene(A[i+1,j],str1,1) THEN BEGIN
BEGIN
M1:=4;
temp:=A[i,j];
N1:=4;
A[i,j]:=A[i+1,j];
strin:='azr';
A[i+1,j]:=temp;
Am[i,j]:=‚…';
END;
risolvi(Am,strin,1,1,M1,N1);
risolvi(A,str1,i,j+1,M,N);
END.
END;
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;
BEGIN
IF K>=L THEN
appartiene:=FALSE
ELSE
IF elem=V1[k] THEN
appartiene:=TRUE
ELSE
appartiene:=appartiene(elem,V1,k+1,L)
END;
{*********** MAIN *************}
BEGIN
N1:=7;
V1[i]:=…….;
strin:='scremato';
tem:='';
M1:=length(strin);
risolvi(V1,strin,tem,m1,M1,N1);
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;
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); {*********** MAIN *************}
BEGIN
sumdown:=sumdown+A[i,j];
M1:=4;
sumup:=sumup+A[j,i];
Am[1,1]:=………….;
risolvi:=(sumdown>K) AND (sumUp<K)
K1:=7;
END;
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 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.
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
2
7
2
3
5
6
3
7
2
4
1
4
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;
BEGIN
IF i>M div 2 THEN
BEGIN
{*********** MAIN *************}
risolvi:=(sumq1=sumq4) AND (sumq2=sumq3)
BEGIN
END
M1:=4;
ELSE
Am[1,1]:=4;
IF j>M div 2 THEN
Sum1:=0;
risolvi:=risolvi(A,sumq1,sumq2,sumq3,sumq4,i+1,1,M)
Sum2:=0;
ELSE
risolvi:=risolvi(A,sumq1+A[i,j],sumq2+A[i,j+M div 2],sumq3+A[i+M div 2,j], Sum3:=0;
Sum4:=0;
sumq4+A[i+M div 2,j+M div 2],i,j+1,M)
writeln(' OUTPUT');
END;
writeln(' che la matrice sia corretta è'
,risolvi(Am,Sum1,Sum2,sum3,sum4,
1,1,M1));
END.
PROVA INTERCORSO MOD.B a.a. 2005-2006
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.
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
{*********** MAIN *************}
BEGIN
BEGIN
IF j>N THEN
M1:=4;
appartiene:=appartiene(A,str,i+1,1,k,M,N)
N1:=3;
ELSE
strin:='cuore';
IF A[i,j]=str[k] THEN
Am[1,1]:=‚….';
appartiene:=appartiene(A,str,1,1,k+1,M,N)
writeln(' stringa = ',strin);
ELSE
writeln('L''ipotesi che ',strin:2,' sia
appartiene:=appartiene(A,str,i,j+1,k,M,N)
contenuta in A è ',
END;
appartiene(Am,strin,1,1,1,M1,N1));
END
END.
ELSE
appartiene:=TRUE;
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
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.
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.
B.4.1.
Data una matrice A di interi 2Nx2N scrivere una funzione ricorsiva che verifichi se la somma degli elementi del
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.
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
babbaaabababbabaa
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)
{*********** MAIN *************}
ELSE
BEGIN
IF A[i]<>str[j] THEN
M1:=17;
verifica:=verifica(A,str,iold+1,iold+1,1,k,M,conta)
K1:=4;
ELSE
strin:='bab';
verifica:=verifica(A,str,iold,i+1,j+1,k,M,conta)
Am[1]:=‚……………';
END;
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.
Matrice
A
3
4
3
7
7
3
4
7
8
7
Risultato TRUE
7
6
2
8
6
8
3
6
5
4
4
2
3
5
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.
Matrice
4
3
7
4
8
B
4
3
3
5
7
7
6
2
8
6
8
7
6
7
4
3
4
1
8
8
LISTE
ESERCIZI A1.1-A1.6
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];
{ ******** MAIN *********}
ItemType= integer;
BEGIN
LNodeP=^LNodeType;
CreaLista(LL1);
LNodeType = RECORD
CreaLista(LL2);
Item:ItemType;
write(' Dammi occorrenza ');readln(k1);
Next:LNodeP
writeln(' LISTA INIZIALE L1'); writeln;
END;
LeggiLista(LL1);
VAR LL1,LL2,LL3,T3,LL3,prec1,prec2:LNodeP;
writeln(' LISTA INIZIALE L2'); writeln;
k1:ItemType;
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.
{ ******** 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 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;
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;
{ ******** 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 KillNode(VAR Node:LNodeP);
BEGIN
IF Node <> NIL THEN
BEGIN
dispose(Node);
Node:=NIL
END
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
PROCEDURE aggiungi(VAR Tx3:LNodeP;
ELSE
VAR Lx3:LNodeP;somma:integer);
BEGIN
VAR nodo:LNodep;
Cancella(TL1,prev1,myL1);
BEGIN
Cancella(TL2,prev2,myL2);
new(nodo);
multiplo:=multiplo(prev1,prev2,TL1,Tl2,TL3,L3, myl1,myl2,k)
nodo^.item:=somma;
END;
nodo^.next:=NIL;
END;
IF Tx3=NIL THEN
END;
BEGIN
Tx3:=nodo;
{ ******** MAIN *********}
Lx3:=Tx3;
BEGIN
END
………………………….
ELSE
T3:=NIL;Li3:=NIL;
BEGIN
prec1:=NIL;prec2:=NIL;
Lx3^.next:=nodo;
writeln(' LISTA CORRETTA');
Lx3:=nodo;
LeggiLista(multiplo(prec1,prec2,LL1,LL2,T3,Li3,LL1,LL2,K1));
END;
END.
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
br
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.
PROCEDURE aggiungi(VAR Tx3:LNodeP;VAR Lx3:LNodeP;caratt:char);
VAR nodo:LNodep;
BEGIN
new(nodo);
nodo^.item:=caratt;
FUNCTION aggiorna(VAR TL1:LNodeP;prev1,L1:LNodeP;k:string20):LNodeP;
nodo^.next:=lx3^.next;
BEGIN
IF Tx3=NIL THEN
IF L1=NIL THEN
BEGIN
aggiorna:=Tl1
Tx3:=nodo;
ELSE
Lx3:=Tx3;
BEGIN
END
IF (L1^.item) = k[1] THEN
ELSE
BEGIN
BEGIN
cancella(Tl1,prev1,L1);
Lx3^.next:=nodo;
aggiorna:=aggiorna(TL1,prev1,L1,k)
Lx3:=nodo;
END
END;
ELSE
END;
BEGIN
IF (L1^.item) = k[2] THEN
BEGIN
{ ******** MAIN *********}
Aggiungi(TL1,L1,k[2]);
BEGIN
aggiorna:=aggiorna(TL1,L1,L1^.next,k)
CreaLista(LL1);
END
write(' Dammi stringa ');readln(k1);
ELSE
writeln(' LISTA INIZIALE L1'); writeln;
BEGIN
LeggiLista(LL1);
aggiorna:=aggiorna(TL1,L1,L1^.next,k)
writeln(' LISTA FINALE L1'); writeln;
END;
prec1:=NIL;
END;
LeggiLista(aggiorna(LL1,prec1,LL1,K1));
END;
readln;
END;
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
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;
FUNCTION inverti(VAR TL1:LNodeP;prev1,L1:LNodeP;k:char):LNodeP
Next:LNodeP
VAR temp,temp2:LnodeP;
END;
BEGIN
VAR LL1,prec1:LNodeP;k1:char;
WHILE (L1<>NIL) AND (L1^.item<K) DO
{ ******** MAIN *********}
begin
BEGIN
temp2:=L1^.next;
CreaLista(LL1);
L1^.next:=prev1;
write(' Dammi carattere ');readln(k1);
prev1:=L1;
writeln(' LISTA INIZIALE L1'); writeln;
temp:=L1;
LeggiLista(LL1);
L1:=temp2;
writeln(' LISTA FINALE L1'); writeln;
end;
prec1:=NIL;
Tl1^.next:=temp2;
leggilista(inverti(LL1,prec1,LL1,K1));
inverti:=temp;
readln;
END;
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
adfedcu
->
dfdc
L2
b t a r s o ->
ao
L3
dfdcao
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;
END;
TL2:=L2;
Prev1^.next:=L2;
prev2:=prev1;
WHILE L2<>NIL DO
{ ******** MAIN *********}
BEGIN
BEGIN
IF NOT (L2^.ITEM IN ['a', 'e','i', 'o', 'u']) THEN
CreaLista(LL1);
Cancella(TL2,prev2,L2);
CreaLista(LL2);
ELSE
writeln(' LISTA INIZIALE L1'); writeln;
BEGIN
LeggiLista(LL1);
Prev2:=L2;
writeln(' LISTA INIZIALE L2'); writeln;
L2:=L2^.next;
LeggiLista(LL2);
END;
prec1:=NIL;
END;
writeln(' LISTA CORRETTA');
aggiorna:=TL1;
LeggiLista(aggiorna(LL1,LL1,prec1,LL2));
END;
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
324102
PROCEDURE LeggiLista(L1:LnodeP);
L1
333322244444110222
VAR TL1,Nod: LnodeP;Aitem:ItemType;flag:boolean;
BEGIN
TL1:=L1;
PROGRAM EserA23(output,input);
IF L1=NIL THEN writeln('Lista Vuota ')
CONST
ELSE
NullItem=-100 ;
{controllo di eventuali errori }
BEGIN
TYPE
Nod:=L1; flag:=FALSE;
STRING20=STRING[20];
WHILE (Nod^.next<>NIL) AND (Not FLAG) DO
ItemType= integer;
BEGIN
LNodeP=^LNodeType;
IF nod^.next=TL1 THEN
LNodeType = RECORD
BEGIN
Item:ItemType;
flag:=TRUE;
Next:LNodeP
writeln('Lista Circolare')
END;
END
VAR LL1;
ELSE
{ ******** MAIN *********}
BEGIN
BEGIN
AItem:=Nod^.item;
CreaLista(LL1);
writeln(' - ',Aitem);
writeln(' LISTA INIZIALE L1'); writeln;
Nod:=Nod^.next;
LeggiLista(LL1);
END;
writeln(' LISTA CORRETTA');
END;
LeggiLista(aggiorna(LL1,LL1));
IF Not FLAG THEN
readln;
BEGIN
END.
AItem:=Nod^.item;
writeln(' - ',Aitem);
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;
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.