Dispensa matlab v1

Esercizi di MATLAB per il corso di Informatica B/C 2014/2015 Chapter 1 Introduzione ............................................................................................................................. 1-­‐2 Chapter 2 Funzioni .................................................................................................................................. 2-­‐20 Chapter 3 Ricorsione ............................................................................................................................... 3-­‐42 Chapter 4 Accesso ai file .......................................................................................................................... 4-­‐57 Chapter 5 Diagrammi .............................................................................................................................. 5-­‐58 Corso di Informatica B/C 2014-­‐15 1-­‐1 Chapter 1 Introduzione 1. Scrivere un programma che data una matrice a NxN crea una nuova matrice b ruotata di 90 gradi in senso antiorario rispetto ad a. Si consideri N=4 e la matrice a inizializzata con i valori [1 2 3 4; 2 3 4 5; 6 7 8 9; 0 0 0 0] Soluzione -­‐ script N=4;
a = [1 2 3 4; 2 3 4 5; 6 7 8 9; 0 0 0 0];
for x=1:N
for y=1:N
b(N+1-y,x)=a(x,y);
end
end
%stampo la matrice originale
a
%stampo la matrice ruotata
b
Soluzione -­‐ script N=4;
a=[1 2 3 4; 2 3 4 5; 6 7 8 9; 0 0 0 0];
%utilizzo la funzione di MATLAB rot90
a
b=rot90(a)
Corso di Informatica B/C 2014-­‐15 1-­‐2 2. Si realizzi uno script in Matlab che richieda l’inserimento dei tre coefficienti di un’equazione di secondo grado: e stampi il valore delle radici reali. ax2 + bx + c = 0
Suggerimento Le radici di un’equazione di secondo grado possono essere calcolate mediante la seguente formula: p
b ± b2 4ac
r =
2
Soluzione -­‐ script % Per risolvere l'esercizio bisogna calcolare il discriminante
%dell'equazione con la formula b^2-4*a*c Se è positive abbiamo due
%radici distinte,
%Se è nullo le radici sono reali e coincidenti,
%Se è negative le radici non sono reali.
a = input('Inserire a: ');
b = input('Inserire b: ');
c = input('Inserire c: ');
delta = b^2-4*a*c;
if delta < 0
disp('L''equazione non ha soluzioni reali');
elseif delta==0
disp(['x=' num2str(-b/(2*a))]);
else
disp(['x1=' num2str((-b-sqrt(delta))/(2*a)) ' x2=' ...
num2str((-b+sqrt(delta))/(2*a))]);
end
Corso di Informatica B/C 2014-­‐15 1-­‐3 3. Realizzare uno script che, data una matrice quadrata, a. ne estragga la diagonale principale. b. ne estragga la diagonale secondaria. c. elimini la diagonale principale e la secondaria Soluzione a) -­‐primo modo usare la matrice logica con true sulla diagonale principale; possiamo costruire una matrice logica B = logical(eye(N)) dove N è la dimensione della matrice di cui vogliamo estrarre la diagonale A(logical(eye(N)))
-­‐secondo modo utilizzando la funzione diag :) diag(A)
b) -­‐primo metodo, utilizzando logical e rot90 A(logical(rot90(eye(N))))
-­‐secondo metodo, utilizzando diag e rot90 diag(rot90(A))
c) -­‐primo metodo, usando logical e eye A(logical(eye(N))) = 0
% elimino la diagonale principale
A(logical(rot90(eye(N)))) = 0 % elimino la diagonale secondaria
-­‐ secondo metodo usando diag A -­‐ diag(diag(A)) %elimino la diagonale principale A -­‐ fliplr(diag(diag(rot90(A)))) %elimino la diagonale secondaria Corso di Informatica B/C 2014-­‐15 1-­‐4 4. Scrivere uno script che chieda un anno all’utente e stampi a video se l’anno è bisestile. Il programma deve continuare a chiedere all’utente anni, finché gli anni inseriti sono bisestili. Stampare a video il numero totale di anni bisestili inseriti. Soluzione bisestili.m -­‐ script clear clc bisestile = 1; counter = 0; while(bisestile) n = input(['inserire anno ']); div_4 = (mod(n , 4) == 0); div_100 = (mod(n , 100) == 0); div_400 = (mod(n , 400) == 0); bisestile = ((div_4) && ~(div_100)) || (div_400); stringa_output = num2str(n); if(bisestile == 0) stringa_output = [stringa_output , ' NON e'' ']; else stringa_output = [stringa_output ,' e'' ']; counter = counter + 1; end stringa_output = [stringa_output , 'bisestile']; disp(stringa_output); end disp(['game over hai inserito esattamente ' , num2str(counter) , ' bisestili']) Corso di Informatica B/C 2014-­‐15 1-­‐5 5. Scrivere uno script che analizzi i voti del primo compitino degli anni precedenti, stampando a schermo: •
•
•
•
media dei voti la media dei voti sufficienti la varianza dei voti sufficienti il numero di promossi al primo compitino % A.A. 2012-­‐-­‐2013 voti = [2 8 4 8.1 9.25 11.25 4.75 17 6.25 13 10 2 3.25 3.75... 8.5 16 8 1 2.5 12 10.75 6 12 10 11.75 3.5 10.5 8.5 14.25... 16.5 10.75 8 12 1 10 13 6.75 5.75 9.5 12.75 11 8.5 10.25... 14.5 4.25 5.5 9.75 16.5 13 15 13 13.75 13.5]; Soluzione media.m -­‐ script clear clc % A.A. 2012-­‐-­‐2013 voti=[2 8 4 8.1 9.25 11.25 4.75 17 6.25 13 10 2 3.25 3.75 8.5 16 8 1 2.5 12 10.75 6 12 10 11.75 3.5 10.5 8.5 14.25 16.5 10.75 8 12 1 10 13 6.75 5.75 9.5 12.75 11 8.5 10.25 14.5 4.25 5.5 9.75 16.5 13 15 13 13.75 13.5]; % calcolo media: soluzione "alla C" count = 0; tot =0; for ii = voti tot=tot + ii; count = count + 1; end media = tot/count; % oppure % soluzione alla MATLAB media = mean(voti); disp(['media: ' , num2str(media)]); % calcolo media sufficienti: soluzione "alla C" count = 0; tot = 0; for ii = voti(voti >= 8) tot=tot + ii; count = count + 1; end media_suff = tot/count; Corso di Informatica B/C 2014-­‐15 1-­‐6 % oppure % soluzione alla MATLAB media_suff = mean(voti(voti >= 8)) disp(['media dei sufficienti: ' , num2str(media_suff)]); % calcolo della varianza dei voti sufficienti "alla C" count = 0; tot = 0; for ii = voti(voti >= 8) tot = tot + (ii -­‐ media_suff).^2; count = count + 1; end var_suff = tot/count; % oppure soluzione alla MATLAB var_suff = var(voti(voti >= 8)) disp(['varianza dei sufficienti: ' , num2str(var_suff)]); % numero di voti sufficienti: soluzione "alla C" n_suff = 0; for ii = (voti >= 18) n_suff = n_suff + ii ; end % oppure % numero di voti sufficienti: soluzione "alla MATLAB" n_suff = sum(voti >= 18); disp(['numero di voti sufficienti: ' , num2str(n_suff)]); 6. Scrivere uno script che legga una frase in ingresso e la converta in alfabeto farfallino. Nota: nell’alfabeto farfallino ogni vocale viene sostituita dalla stringa 'vocale+f+vocale', cioè: 'a' = 'afa', 'e' = 'efe', 'i' = 'ifi', 'o' = 'ofo', 'u' = 'ufu' Soluzione farfallino.m -­‐ script clear clc frase = input(['inserire una stringa '] , 's'); far = []; for c = frase far=[far,c]; if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u') far = [far ,'f' ,c]; end end disp([frase , ' in alfabeto far diventa ' , far]) Corso di Informatica B/C 2014-­‐15 1-­‐7 7. Scrivere un programma (script) che calcoli la sequenza di Fibonacci di lunghezza 20, poi richieda di inserire un numero 2 < n < 4180 e valuti se il numero è di Fibonacci. Altrimenti restituisce il numero di Fibonacci più vicino. La successione di Fibonacci è definita così: F(0) = 0 F(1) = 1 F(n) = F (n − 1) + F (n − 2), n > 1 Cioè è composta dai numeri: 0 1 1 2 3 5 8 13 21 34 ... Soluzione fibonacci.m -­‐ script clear; clc; fibo = zeros(1,20); fibo(1) = 0; fibo(2) = 1; for i = 3:20 fibo(i) = fibo(i-­‐1) + fibo(i-­‐2); end fibo a = input('Inserire un numero: '); if sum(a == fibo) > 0 disp([num2str(a) 'e'' un numero di Fibonacci']); else inferiori = fibo(fibo < a); inferiori = inferiori(end); superiori = fibo(fibo > a); superiori = superiori(1); if superiori -­‐ a < a -­‐ inferiori vicino = superiori; else vicino = inferiori; end disp(['Il numero didi Fibonacci piu'' vicino a ' num2str(a) ' e'' ' num2str(vicino)]); end Corso di Informatica B/C 2014-­‐15 1-­‐8 8. Realizzare uno script che chieda all’utente due parole e stampi a video se una è anagramma dell’altra. Soluzione anagramma.m -­‐ script clear clc parola1 = input('Inserire la prima parola: ','s'); parola2 = input('Inserire la seconda parola: ','s'); isto1 = zeros(1,256); isto2 = zeros(1,256); for ii = parola1 isto1(ii) = isto1(ii) + 1; end for ii = parola2 isto2(ii) = isto2(ii) + 1; end if sum(isto1 == isto2) == 256 disp('Le due parole sono una l''anagramma dell''altra'); else disp('Le due parole non sono anagamma una dell''altra'); end 9. Utilizzando il fatto che il quadrato di n è uguale alla somma dei primi n numeri dispari, creare uno script che calcoli il quadrato di un numero inserito da utente (n < 100). Soluzione -­‐script clc clear N = input('Inserire il numero da elevare al quadrato (< 100): ' ); numeri = 2 * [0 : N -­‐ 1] + 1; c = 1; somma = 0; while c <= N somma = somma + numeri(c); c = c + 1; end fprintf('%d^2 = %d\n', N, somma); Corso di Informatica B/C 2014-­‐15 1-­‐9 10. Realizzare uno script Matlab per: a. Creare una matrice M di dimensioni 7 × 5 contenente 0, 1, 2, che rappresenti un momento di una partita di forza 4 in corso. b. Chiedere ai due giocatori, finchè uno di questi non inserisce la lettera ’q’ (quit), di inserire la colonna (tra 1 e 7) dove intende inserire la propria pedina. c. Inserire la pedina nella colonna corretta e visualizzare la matrice M così ottenuta. Soluzione forza4.m -­‐ script clear clc M = [ 0 0 0 0 0 0 0 ;... 0 0 0 0 0 0 0 ;... 0 0 0 0 0 0 0 ;... 0 0 0 0 0 0 0 ;... 0 0 0 0 0 0 0 ]; turno = 1; a = 6; while (a ~= 'q') disp(['E'' il turno del giocatore ' num2str(turno)]); a = input('Inserire una giocata (numero di colonna 1-­‐7) o uscire (q): '); if a~='q' if (M(1,a) ~= 0) disp('Giocata illegale'); else indici = M(:,a) == 0; pos_libera = sum(indici); M(pos_libera,a) = turno; imagesc(M); if turno == 1 turno = 2; else turno = 1; end end end end Corso di Informatica B/C 2014-­‐15 1-­‐10 11. Verificare se una matrice quadrata di dimensione arbitraria è un quadrato magico. Un quadrato è magico se la somma degli elementi sulle righe, sulle colonne e sulla diagonale principale è la stessa. Soluzione clear clc M = magic(4); %M = randi(4,3); [r c] = size(M); assert(r == c); %assert controlla se una condizione è vera. Altrimenti genera un errore somme = zeros(1,2 * r + 1); for ii = 1:r somme(ii) = sum(M(ii,:)); end for ii = (r+1):2*r somme(ii) = sum(M(:,ii-­‐r)); end somme(2*r+1) = sum(diag(M)); somme if sum(somme == somme(1)) == 2*r+1 disp('La matrice e'' un quadrato magico'); else disp('La matrice non e'' un quadrato magico'); end Corso di Informatica B/C 2014-­‐15 1-­‐11 12. Data una matrice 20 × 20 che rappresenta le partite di un campionato di calcio (con 0 per vittoria in casa, 1 per pareggio 2 per vittoria in trasferta come risultati possibili). Calcolare la classifica finale ordinata. Soluzione clear
clc
squadre = { 'Atalanta' 'Cagliari' 'Cesena' 'Chievo' 'Empoli' '
Fiorentina' 'Genoa'...
'Verona' 'Inter' 'Juventus' 'Lazio' 'Milan' 'Napoli' ' Palermo'
'Parma' 'Roma'...
'Sampdoria' 'Sassuolo' 'Torino' 'Udinese' };
squadre_alt = squadre;
risultati = randi(3,20)-1;
for ii = 1:20
risultati(ii,ii) = -1;
end
% Versione facile
punti = zeros(20,1);
for ii = 1:20
punti(ii) = sum(risultati(ii,:) == 0) * 3 +
sum(risultati( ii,:) == 1) + ...
sum(risultati(:,ii) == 2) * 3 + sum(risultati(:,ii) == 1);
end
%Versione difficile
punti_alt = sum(risultati == 0,2) * 3 + sum(risultati == 1,2)+…
sum(risultati' == 2,2) * 3 +sum(risultati' == 1,2);
%assert controlla se una condizione è vera. Altrimenti genera un errore
assert(sum(punti == punti_alt) == 20)
%forii=1:20
% disp(['La squadra ' squadre{ii} ' ha totalizzato '
num2str(punti(ii)) ' punti.']);
% end
%Ordiniamole
while (~isempty(punti))
maxi = max(punti);
trovato = 0;
counter = 1;
while trovato == 0
if punti(counter) == maxi
disp(['La squadra ' squadre{counter} ' ha
totalizzato ' num2str(punti(counter)) ' punti.' ]);
punti(counter) = [];
squadre(counter) = [];
trovato = 1;
else
counter = counter + 1;
end
Corso di Informatica B/C 2014-­‐15 1-­‐12 end
end
disp('-----------------------------------');
%Oppure chiediamo a MATLAB
[punti_alt indici] = sort(punti_alt,'descend');
squadre_alt = squadre_alt(indici);
for ii = 1:20
disp(['La squadra ' squadre_alt{ii} ' ha totalizzato '
num2str(punti_alt(ii)) ' punti.']);
end
13. Data una matrice quadrata, leggerla a spirale e metterne il contenuto in un vettore. La lettura a spirale avviene andando a leggere la prima riga, poi l’ultima colonna, quindi l’ultima riga ed infine la prima colonna. L’operazione si ripete per le colonne e righe progressivamente più interne. Soluzione clear
clc
%creo una matrice d’interi i cui valori sono generati randomicamente
M = randi(10,7);
M_old = M;
riga = 1;
colonna = 0;
inizio = 1;
fine = 0;
vec = [];
while(~isempty(M))
vec = [vec M(1,:)];
M(1,:) = [];
if (~isempty(M))
vec = [vec M(:,end)'];
M(:,end) = [];
end
if (~isempty(M))
vec = [vec M(end,end:-1:1)];
M(end,:) = [];
end
if (~isempty(M))
vec = [vec M(end:-1:1,1)'];
M(:,1) = [];
Corso di Informatica B/C 2014-­‐15 1-­‐13 end
end
%genero un errore se qualcosa non e’ andata bene
assert(sum(vec) == sum(M_old(:)));
14. (TdE) Dopo una gara automobilistica si ha come risultato tre tabelle le cui colonne rappresentano gli n partecipanti (numerati da 1 a n) e le righe gli m giri di pista effettuati. Il valore di ogni generica cella (i,j) delle tabelle rappresenta il tempo impiegato dal partecipante j per percorrere il giro i. Si scrivano le istruzioni per: •
•
•
calcolare il tempo totale medio che è stato impiegato dai partecipanti per completare la gara; determinare il vincitore della gara (cioè il numero del partecipante il cui tempo di percorrenza totale è minore di quello degli altri partecipanti); tracciare un grafico in cui l’asse delle x rappresenta i giri compiuti dal vincitore e l’asse delle y il tempo necessario per percorrere i giri.
Soluzione -­‐ script clear
clc
n_piloti = 10;
n_giri = 30;
minuti = randi(2,n_piloti,n_giri);
secondi = 60 * rand(n_piloti,n_giri);
millesimi = 1000 * rand(n_piloti,n_giri);
tempo_medio = mean(minuti * 60 + secondi + millesimi / 1000,2);
tempo_vinc = min(tempo_medio);
vinc = find(tempo_medio == tempo_vinc);
disp(['Il vincitore e '' ' num2str(vinc)]);
figure();
plot(1:n_piloti,tempo_medio);
title('Tempo medio piloti');
xlabel('Numero pilota');
ylabel('Tempo medio');
15. (TdE) Si scriva uno script in Matlab che svolga le seguenti operazioni: Corso di Informatica B/C 2014-­‐15 1-­‐14 •
•
•
•
Definisce una matrice quadrata di interi di dimensione N*N, con N pari a 5. Acquisisce da tastiera una sequenza di valori interi che memorizza nella porzione triangolare superiore della matrice. La parte triangolare superiore della matrice è costituita dalle celle poste sulla diagonale principale e al di sopra di tale diagonale. Copia in un array di dimensioni opportune tutti I valori della porzione triangolare di matrice che sono maggiori di -­‐10. Stampa il contenuto dell’array. Soluzione N=5;
for x=1:N
for y=x:N
M(x,y)=input(sprintf('M(%d,%d)= ',x,y));
end
end
%visualizza M
M
l=1;
for x=1:N
for y=x:N
if(M(x,y)>-10)
a(l)=M(x,y);
l=l+1;
end
end
end
% oppure
a = M(M>-10)'
%visualizza a
%così
a
%oppure utilizzando disp
disp(a)
16. Scrivere uno script che acquisisce un numero e verifica se è primo o meno stampando un apposito messaggio a video. Soluzione n = input('valore: ');
d = 2:n/2;
mod(n,d)
if all(mod(n,d)) %alternativa: ~any(mod(n,d)==0)
disp([num2str(n) ' è primo']);
else
disp([num2str(n) ' non è primo']);
end
Corso di Informatica B/C 2014-­‐15 1-­‐15 Corso di Informatica B/C 2014-­‐15 1-­‐16 17. Si vuole realizzare uno script per analizzare i voti conseguiti da una serie di studenti in un esame, partendo dai punteggi conseguiti in ciascun esercizio. I dati di partenza sono memorizzati in un file, il cui va chiesto il nome all'utente, e sono organizzati nel seguente modo: la prima riga del file contiene i punti massimi per ciascuno degli esercizi dell'esame e le successive righe i punteggi conseguiti da ciascuno degli studenti che ha partecipato all'esame. Un esempio di file è: 5 5 6 4 2 8 1 2 2 2 2 2 5 5 4 4 2 8 5 5 5 3 2 5 5 5 5 1 2 1 dove l'esame era composto da 6 esercizi ed è stato sostenuto da 4 studenti (gli studenti sono identificati con un indice progressivo, es: 1,2,3,4). Lo script deve eseguire le seguenti elaborazioni: • leggere i dati e salvarli in due matrici (una per i punti massimi ed una per i punteggi degli studenti) • verificare che i punteggi siano consistenti: un punteggio di un esercizio non è consistente se non compreso tra 0 ed il punteggio massimo conseguibile (per esempio per il primo esercizio dell'esempio sopra il punteggio deve essere compreso tra 0 e 5, estremi inclusi). Un esempio di file inconsistente è il seguente: 5 5 6 4 2 8 7 2 2 2 2 2 5 5 4 4 2 8 5 5 5 3 2 5 SE è stata identificata almeno un'inconsistenza riportare: • il numero di studenti con almeno un punteggio inconsistente • i dati degli studenti che presentano un'inconsistenza (in particolare visualizzare l'indice dello studente ed i suoi punteggi) ALTRIMENTI eseguire le seguenti elaborazioni: • calcolare i voti • contare il numero di studenti promossi • calcolare i voti massimo e minimo conseguiti dagli studenti promossi • contare il numero di voti scarsi (cioè compresi nell'intervallo [18;21]), di voti mediocri (voti nell'intervallo [22;25]) e di voti buoni (voti nell'intervallo [26;30]) • cercare e visualizzare gli indici gli studenti che hanno almeno un esercizio insufficiente (sufficienza al 50% del punteggio massimo) • individuare quale esercizio (o insieme di esercizi) è andato in media peggio (per ciascun esercizio bisogna calcolare il rapporto tra il punteggio medio conseguito dagli studenti ed il punteggio massimo) Corso di Informatica B/C 2014-­‐15 1-­‐17 Soluzione %caricare punteggi da un file di testo
%(prima riga punteggi massimi poi punteggi di ciascuno studente
%salvare in due strutture punteggi massimi da punteggi studenti
nomefile=input('inserire nome file: ','s');
dati=load(nomefile);
punti=dati(1,:);
punteggi=dati(2:end,:);
[nstudenti nesercizi]=size(punteggi);
%controllare se ci sono voti inconsistenti
%contare inconsistenze e stampare il seguente report:
%numero inconsistenze e lista studenti con dati inconsistenti
ninconsistenti=0;
inconsistenti=[];
for ii=1:nstudenti
if any(punti<punteggi(ii,:) | punteggi(ii,:)<0)
ninconsistenti=ninconsistenti+1;
inconsistenti(ninconsistenti)=ii;
end
end
disp(['inconsistenti: ' num2str(ninconsistenti)]);
if ninconsistenti>0
disp('max punti: ');
disp(num2str(punti));
disp('report inconsistenti: ');
for ii=1:length(inconsistenti)
disp([num2str(inconsistenti(ii)) ': '
num2str(punteggi(ii,:))]);
end
else
%se ok calcolare voti. contare max, min (non bocciato), numero
bocciati
%e fare statistiche sui presenti...
voti=sum(punteggi');
votomax=max(voti);
nbocciati=sum(voti<18);
votomin=min(voti(voti>=18));
numscarsi=sum(voti>=18 & voti<22);
nummedi=sum(voti>=22 & voti<26);
numbuoni=sum(voti>=26);
disp(['bocciati : ' num2str(nbocciati)]);
disp(['max voto : ' num2str(votomax)]);
disp(['min voto : ' num2str(votomin)]);
disp(['scarsi: ' num2str(numscarsi) ', discreti: '
num2str(nummedi) ', buoni:' num2str(numbuoni) ]);
%cercare gli studenti che hanno almeno un esercizio insufficiente
%insufficienza: (punteggio<punteggio_massimo/2)
nStudEsInsuf=0;
Corso di Informatica B/C 2014-­‐15 1-­‐18 studEsInsuf=[];
for ii=1:nstudenti
if any(punteggi(ii,:)<punti./2)
nStudEsInsuf=nStudEsInsuf+1;
studEsInsuf(nStudEsInsuf)=ii;
end
end
disp(['studenti con almeno un es insuff: '
num2str(studEsInsuf)]);
%vedere quale esercizio è andato in media peggio
mediaPunteggi=sum(punteggi)./nstudenti;
disp(['max punteggi: ' num2str(punti)]);
disp(['media punteggi: ' num2str(mediaPunteggi)]);
percPunteggi=mediaPunteggi./punti;
percPeggio=min(percPunteggi);
numeroEsercizio=1:nesercizi;
numEsPeggio=numeroEsercizio(percPunteggi==percPeggio);
disp(['esercizio peggiore: ' num2str(numEsPeggio)]);
%in alternativa:
%disp(['esercizio peggiore: '
num2str(find(percPunteggi==percPeggio))]);
end
Corso di Informatica B/C 2014-­‐15 1-­‐19 Chapter 2 Funzioni 1. Realizzare uno script MATLAB che richieda all’utente l’inserimento due parole e stampi a video se una è anagramma dell’altra. Soluzione anagramma.m -­‐ script % Anagramma: versione con funzioni.
% leggere 2 parole da tastiera
%
[parola1, parola2] = leggi_parole();
% costruire gli istogrammi secondo l'alfabeto ASCII esteso (256
simboli)
%
h1 = calcola_istogramma(parola1);
h2 = calcola_istogramma(parola2);
% visualizzare gli istogrammi come grafici a barre
%
figure, bar(h1)
figure, bar(h2)
% calcolare se si tratta di anagrammi
%
anagrammi = sono_anagrammi(h1, h2);
if (anagrammi)
fprintf('Le due parole sono anagrammi\n');
else
fprintf('Le due parole NON sono anagrammi\n');
end
leggi_parole.m -­‐ funzione function [p1, p2] = leggi_parole()
p1 = input('Inserici una parola o frase: ', 's');
p2 = input('Inserici una parola o frase: ', 's');
Corso di Informatica B/C 2014-­‐15 2-­‐20 calcola_istogramma.m -­‐ funzione function [h] = calcola_istogramma(parola)
h = zeros(1, 256);
for c = parola
h(c) = h(c) + 1;
end
sono_anagrammi.m -­‐ funzione function [an] = sono_anagrammi(h1, h2)
% assumo che gli istogrammi abbiano la stessa dimensione
% soluzione alla C
an = 1; %vero
ii = 1;
while an && ii < length(h1)
an = h1(ii) == h2(ii);
ii = ii + 1;
end
% soluzione alla MATLAB
an = all(h1 == h2);
% an = ~any(h1 ~= h2);
Corso di Informatica B/C 2014-­‐15 2-­‐21 2. (TdE) Scrivere un programma che: 1. acquisisca un numero da tastiera e continui a richiedere l'inserimento finché il numero inserito continui a non essere intero positivo 2. verificare se il numero intero positivo acquisito è perfetto, abbondante o difettivo: • Perfetto: numero i cui divisori positivi (escluso il numero stesso), sommano al numero stesso. • Abbondante: numero i cui divisori positivi (escluso il numero stesso), sommano ad un numero maggiore del numero stesso. • Difettivo: se non è perfetto e non è abbondante. 3. se il numero non è perfetto, controllare se è abbondante o difettivo e stampare un messaggio a video che lo dica. 4. inoltre, nel caso 3., richiedere anche un altro numero intero positivo b, e controllare se a e b sono amici: • Amici: due numeri sono amici quando la somma dei divisori del primo (escluso il numero stesso) coincide al secondo numero; e viceversa. 5. Scrivere un programma che elenchi i primi k numeri abbondanti, con k definito dall'utente. Soluzione divisori.m -­‐ script clc
clear
% inserimento di un numero positivo %
a = leggi_intero_positivo();
% a questo punto il numero inserito e` senz'altro positivo
% calcolo se il numero e` perfetto, abbondante o difettivo
[perfetto, abbondante] = numero_perfetto(a);
% se perfetto, allora stampo che e` perfetto e concludo
if (perfetto == 1)
disp([num2str(a), ' e` perfetto']);
else % altrimenti
% controllo se e` abbondante o difettivo
%
if (abbondante == 1)
disp([num2str(a), ' e` abbondante']);
else
disp([num2str(a), ' e` difettivo']);
end
% acquisisco un altro numero, riusando la funzione
b = leggi_intero_positivo();
% a e b sono amici?
amici = sono_amici(a, b);
if (amici == 1)
Corso di Informatica B/C 2014-­‐15 2-­‐22 disp([num2str(a), ' e ', num2str(b), ' sono amici']);
else
disp([num2str(a), ' e ', num2str(b), ' NON sono amici']);
end
end
leggi_intero_positivo.m -­‐ funzione function [n] = leggi_intero_positivo()
n = 0;
while n <= 0
n = input('Inserisci un numero intero positivo: ');
end
numero_perfetto.m -­‐ funzione function [perfetto, abbondante] = numero_perfetto(n)
% calcolo la somma dei divisori (escluso il numero stesso)
somma = somma_divisori(n);
% calcolo se la somma dei divisori coincide col numero stesso
perfetto = (n == somma);
% calcolo se il numero e` maggiore della somma dei suoi divisori
(abbondante)
abbondante = n > somma;
% alla fine dell'esecuzione di questa funzione, le variabili
'perfetto' e 'abbondante' saranno disponibili al programma chiamante.
somma_divisori.m -­‐ funzione function somma = somma_divisori(n)
% soluzione alla C, non raccomandata
somma = 0;
for d = 1:n/2
if (~mod(n, d)) % mod(n, d) == 0
somma = somma + d;
end
end
% soluzione alla MATLAB
%
Corso di Informatica B/C 2014-­‐15 2-­‐23 divisori = 1:n/2;
resti = mod(n, divisori);
divisori_interi = divisori(resti == 0);
somma = sum(divisori);
% soluzione compatta
%
somma = sum(divisori(mod(n, divisori) == 0));
sono_amici -­‐ funzione function amici = sono_amici(a, b)
amici = (somma_divisori(a) == b) && (somma_divisori(b) == a);
% end funzione sono_amici
elenca_k_abbondanti -­‐ script clear;
clc;
% inserimento di un numero positivo attraverso la chiamata della
funzione
%
k = leggi_intero_positivo();
for i = 1:k
[perfetto, abbondante] = numero_perfetto(i);
if (abbondante)
disp([ num2str(i), ' e'' abbondante'])
end
end
Corso di Informatica B/C 2014-­‐15 2-­‐24 3. (TdE) Scrivere una funzione che, ricevendo in ingresso una matrice M di numeri, restituisce in uscita una matrice MR, ottenuta da M nel seguente modo: • si calcola la media aritmetica dei valori di M • per i valori che in M sono minori della media, in MR si pone nella posizione corrispondente il valore -­‐1, • per quelli superiori alla media si pone il valore 1, • per gli altri (quelli uguali alla media) si pone lo stesso valore in M. Soluzione transformMatrix.m -­‐ funzione function [MR] = transformMatrix(M)
media = mean(mean(M));
MR = M;
MR(MR < media) = -1;
MR(MR > media) = 1;
% fine funzione transformMatrix
% soluzione alla C
[R, C] = size(M);
media = 0;
% somma di tutti gli elementi
for r = 1:R
for c = 1:C
media = media + M(r,c);
end
end
% calcolo media
media = media / (R * C);
% generazione MR elemento per elemento
for r = 1:R
for c = 1:C
if M(r,c) < media
MR(r,c) = -1;
else
if M(r,c) > media
MR(r,c) = 1;
else
MR(r,c) = M(r,c);
end
end
end
end
Corso di Informatica B/C 2014-­‐15 2-­‐25 4. (TdE) Scrivere un programma per la gestione di un magazzino dove ogni prodotto nel magazzino è univocamente identificato da un barcode (un numero intero) e da una tipologia (un carattere). Il software di gestione associa ad ogni prodotto due numeri, il primo che indica il numero di pezzi in stock il secondo che indica il numero di pezzi ordinati. Si ipotizzi che barcode, tipo, stock, ordine siano 4 vettori, già popolati, contenenti tutte le informazioni necessarie per la gestione del magazzino. (l'i-­‐simo elemento di stock e di ordine rappresentano le quantità relative al prodotto a cui è associato l'i-­‐simo elemento di barcode). Ad esempio: barcodes = [123 ; 1312 ; 12312 ; 1231 ; 99123]; tipo = ['A' ; 'A' ; 'X' ; 'W' ; 'W' ]; stock = [0 ; 300 ; 5 ; 6 ; 0 ]; ordine = [23 ; 100 ; 2 ; 100 ; 0 ]; Si scriva: a. la funzione “ricerca” che prende in ingresso un barcode e restituisce un messaggio contenente il tipo di prodotto, il numero di pezzi in stock ed in ordine. In caso di multiple occorrenze, scegliere la prima. b. un esempio di chiamata alla funzione "ricerca". c. la funzione “ricercaMancanti” che, a seconda di un parametro P, restituisca al programma chiamante un vettore contenente I codici a barre dei prodotti: • (se P = 0) non presenti in stock ma in ordine, • (se P = 1) non presenti in stock che non sono nemmeno in ordine, • (se P = 2) per cui ci sono più pezzi in ordine che attualmente in stock. d. Scrivere un esempio di chiamata alla funzione ricercaMancanti. e. Si scriva la funzione “aggiungiProdotto”, che permette di aggiungere al magazzino un nuovo prodotto (barcode + stock + ordine). f. Scrivere un esempio di chiamata alla funzione aggiungiProdotto. Soluzione ricerca.m – funzione % definizione funzioni
function [msg] = ricerca (b, t, s, o, bc)
bc_indici = find(b == bc);
b = b(bc_indici)(1);
t = t(bc_indici)(1);
s = s(bc_indici)(1);
o = o(bc_indici)(1);
Corso di Informatica B/C 2014-­‐15 2-­‐26 msg = ['il prodotto corrispondente al codice a barre ',
num2str(bc), ' e` di tipo ',num2str(t),
' elementi in stock: ', num2str(s),' in ordine: ',
num2str(o)
];
end ricercaMancanti.m -­‐ funzione function [prodotti] = ricercaMancanti(b, t, s, o, P)
switch P
case 0
bc_indici = find(s == 0 && o > 0);
case 1
bc_indici = find(s == 0 && o == 0);
case 2
bc_indici = find(o > s);
end
prodotti = b(bc_indici)
end
aggiungiProdotto.m -­‐ funzione function [b, t, s, o] = aggiungiProdotto(b, t, s, o, n_b, n_t ,n_s,
n_o)
b = [b; n_b];
t = [t; n_t];
s = [s; n_s];
o = [o; n_o];
end
Esempi d’uso delle funzioni % main
barcodes =
tipo =
stock =
ordine =
[123
['A'
[0
[23
;
;
;
;
1312
'A'
300
100
;
;
;
;
12312
'X'
5
2
;
;
;
;
1231
'W'
6
100
ricerca(barcodes, tipo, stock, ordine,
ricercaMancanti(barcodes, tipo, stock,
ricercaMancanti(barcodes, tipo, stock,
ricercaMancanti(barcodes, tipo, stock,
;
;
;
;
99123];
'W' ];
0
];
0
];
12312)
ordine, 0)
ordine, 1)
ordine, 2)
[barcodes, tipo, stock, ordine] = aggiungiProdotto(barcodes, tipo,
stop, ordine, 999, 'F', 3, 24) Corso di Informatica B/C 2014-­‐15 2-­‐27 5. Si scriva una funzione che legga una parola e restituisca 1 se tale parola è palindroma, zero altrimenti. Fornire un esempio di chiamata della funzione. Soluzione palindroma.m -­‐ funzione function [pal] = palindroma(par)
% soluzione "alla C"
len = size(par, 2);
pal = 1;
ii = 1;
while((ii <= len / 2 ) && pal)
if(par(ii) ~= par(end - ii + 1))
pal = 0;
end
ii = ii + 1;
end
% soluzione "alla MATLAB"
parAlContrario = par(end : -1 : 1);
corrispondenze = (par == parAlContrario);
if(sum(corrispondenze == size(par, 2)))
pal = 1;
else
pal = 0;
end
% alternativa super-compatta
pal = sum(par == par(end : -1 : 1))== size(par, 2);
Esempio di chiamata della funzione – script % acquisisco la parola%
parola = input('inserire parola '
,
's');
% chiamo la funzione
%
pal = palindroma(parola);
str = [parola];
if (pal)
str = [str , ' è '];
else
str = [str , ' NON è '];
end
disp([str , ' palindroma']); Corso di Informatica B/C 2014-­‐15 2-­‐28