Risoluzione Tracce di Esame

Indice

1 Appello 17 Gennaio 2017
2 Appello 14 Febbraio 2017

Appello 17 Gennaio 2017

Traccia: Algoritmo che acquisisce da tastiera gli elementi di una matrice A di dimensioni NxN, con N compreso nell’intervallo ]4,10], crea la matrice B con gli stessi elementi della matrice A, ma ordinati in ordine crescente per righe, e infine stampa gli elementi della matrice B in un file di testo e/o binario

Codice MATLAB Di seguito sono mostrate le funzioni e lo script principale che risolve il problema espresso nella traccia.

La prima funzione è quella che permette di acquisire da tastiera gli elementi di una matrice quadrata, noto il suo ordine.

function [ M ] = acquisisci_elementi( M, D )

%acquisisci_elementi Funzione per acquisire gli elementi della matrice quadrata

```
 
```
```
    for i = 1 : D
```
```
        for j = 1 : D
```
```
            M(i,j) = input('');
```
```
        end
```
```
    end
```
```
end
```

La seconda funzione permette di ordinare gli elementi di una matrice; in particolare, tutte le componenti della matrice sono prima inserite in un vettore V che è successivamente ordinato utilizzando l' algoritmo selection sort. Infine, viene chiamata la funzione matrice_da_vettore che crea la matrice MO, che viene restituita dalla funzione, inserendo gli elementi presenti nel vettore.

function [ MO ] = ordina_matrice( M, D )

%ordina_matrice Funzione per ordinare gli elementi di una matrice per righe

```
 
```
```
    V = [];
```
```
    k = 1;
```
```
    for i = 1 : D
```
```
        for j = 1 : D
```
```
          V(k) = M(i,j);
```
```
          k = k+1;
```
```
        end
```
```
    end
```
```
 
```
```
    V = ordina_vettore(V, k-1);
```
```
    MO = matrice_da_vettore(V, D);
```
```
end
```

La terza funzione implementa l'algoritmo del selection sort, effettuando un ordinamento delle componenti del vettore in maniera crescente.

function [ V ] = ordina_vettore( V, dim )

%ordina_vettore Funzione per ordinare in maniera crescente un vettore

```
 
```
```
    for i = 1 : dim-1
```
```
        i_min = i;
```
```
        j = i+1;
```
```
        for j = j : dim
```
```
            if V(j) < V(i_min)
```

                % Se vero, aggiorno l'indice dell'elemento minimo

```
                i_min = j;
```
```
             end
```
```
         end
```
```
 
```

        % Blocco di codice relativo allo scambio

```
        temp = V(i);
```
```
        V(i) = V(i_min);
```
```
        V(i_min) = temp;
```
```
    end
```
```
end
```

La quarta funzione è quella che permette di creare una matrice a partire dagli elementi di un vettore.

function [ M ] = matrice_da_vettore( V, D )

%matrice_da_vettore Funzione per le creazione di una matrice a partire da un vettore

```
 
```
```
    k = 1;
```
```
    M = [];
```
```
    for i = 1 : D
```
```
        for j = 1 : D
```
```
            M(i,j) = V(k);
```
```
            k = k+1;
```
```
        end
```
```
    end
```
```
end
```

La quinta funzione è quella che permette di salvare gli elementi di una matrice su un file di testo (formattandoli in maniera opportuna).

function [  ] = stampa_su_file_testo( M, D )

%stampa_su_file_testo Funzione per stampare su file di testo una matrice

```
 
```
```
    FILEID = fopen('matrice.txt','w');
```
```
    for i = 1 : D
```
```
        for j = 1 : D
```

            fprintf(FILEID, '%d ', M(i,j));

```
        end
```
```
        fprintf(FILEID, '\n');
```
```
    end
```
```
    fclose(FILEID);
```
```
end
```

La sesta funzione è quella che permette di salvare gli elementi di una matrice su un file binario.

function [  ] = stampa_su_file_binario( M, D )

%stampa_su_file_testo Funzione per stampare su file di testo una matrice

```
 
```
```
    FILEID = fopen('matrice.dat','w');
```
```
    for i = 1 : D
```
```
        for j = 1 : D
```

            fwrite(FILEID, M(i,j), 'double');

```
        end
```
```
    end
```
```
    fclose(FILEID);
```
```
end
```

Infine, è mostrato lo script principale nel quale vengono chiamate in maniera opportuna le funzioni precedentemente implementate.

%% Algoritmo che acquisisce da tastiera gli elementi di una matrice A di

% dimensioni NxN, con N compreso nell’intervallo ]4,10], crea la matrice B

% con gli stessi elementi della matrice A, ma ordinati in ordine crescente

% per righe, e infine stampa gli elementi della matrice B in un file

```
% di testo e/o binario
```
```
 
```
```
flag = true;
```
```
while flag == true
```
```
    N = input('');
```
```
    flag = N <= 4 || N > 10;
```
```
end
```
```
 
```
```
A = [];
```
```
A = acquisisci_elementi(A, N);
```
```
 
```
```
B = A;
```
```
B = ordina_matrice(B, N);
```
```
 
```
```
stampa_su_file_testo(B, N);
```
```
stampa_su_file_binario(B, N);
```

Appello 14 Febbraio 2017

Traccia: Algoritmo per acquisire da tastiera gli elementi di un vettore V di N elementi (con N di valore pari a un numero quadrato perfetto non inferiore a 16 e non superiore a 100), controllando che ogni elemento inserito non sia inferiore al precedente; creare una matrice quadrata in cui gli stessi elementi sono inseriti consecutivamente per righe evitando le ripetizioni e aggiungendo negli ultimi elementi della matrice tutti elementi nulli; infine, stampare la matrice finale in un file di testo e/o binario.

Codice MATLAB Di seguito sono mostrate le funzioni e lo script principale che risolve il problema espresso nella traccia.

La prima funzione è quella che permette di acquisire da tastiera gli elementi di una matrice quadrata, noto il suo ordine.

```
function V = caricaVettore( N )
```

% Funzione per il caricamento di un vettore di dimensione N, controllando che ogni elemento inserito non sia inferiore al precedente

```
    V(1) = input(' ');
```
```
    for i = 2:N
```
```
        flag = true;
```
```
        while flag
```
```
            V(i) = input(' ');
```
```
            flag = V(i) < V(i-1);
```
```
        end
```
```
    end
```
```
end
```

La seconda funzione permette di inserire in una matrice M (quadrata di ordine n) gli elementi presenti nel vettore V; gli elementi sono inseriti consecutivamente per righe evitando le ripetizioni. Terminati gli elementi del vettore, i restanti elementi della matrice sono valorizzati a 0.

```
function M = caricaMatrice( V, n )
```

% Funzione per la creazione della matrice M a partitre dal vettore V, evitando le ripetizione e valorizzando gli elementi rimanenti a 0

```
    k = 1;
```
```
    N = n*n;
```
```
    M = [];
```
```
    for i = 1 : n
```
```
        for j = 1 : n
```

            flag = k < N && V(k) == V(k+1);

```
            while flag == true
```
```
                k = k + 1;
```

                flag = k < N && V(k) == V(k+1);

```
            end
```
```
            if k <= N
```
```
                M(i,j) = V(k);
```
```
                k = k+1;
```
```
            else
```
```
                M(i,j) = 0;
```
```
            end
```
```
        end
```
```
    end
```
```
end
```

La terza funzione stampa su file di testo la matrice.

function [] = stampaMatrice( M, n, namefile )

% Funzione per la stampa su file di testo della matrice M

```
    fileID = fopen(namefile,'w');
```
```
    for i = 1 : n
```
```
        for j = 1 : n
```

            fprintf(fileID, '%d ', M(i,j));

```
        end
```
```
        fprintf(fileID,'\n');
```
```
    end
```
```
    fclose(fileID);
```
```
end
```

Infine, è mostrato lo script principale nel quale vengono chiamate in maniera opportuna le funzioni precedentemente implementate.

%% Algoritmo per acquisire da tastiera gli elementi di un vettore V di N elementi (con N di valore pari a un numero

% quadrato perfetto non inferiore a 16 e non superiore a 100), controllando che ogni elemento inserito

% non sia inferiore al precedente; creare una matrice quadrata in cui gli stessi elementi sono inseriti

% consecutivamente per righe evitando le ripetizioni e aggiungendo negli ultimi elementi della matrice

% tutti elementi nulli; infine, stampare la matrice finale in un file di testo e/o binario.

```
 
```
```
flag = true;
```
```
while flag == true
```
```
    n = input('Inserisci N: ');
```
```
    flag = n < 4 || n > 10;
```
```
end
```
```
 
```
```
N = n * n;
```
```
 
```
```
V = caricaVettore(N);
```
```
 
```
```
M = caricaMatrice(V,n);
```
```
 
```
```
stampaMatrice(M, n, 'matrice.txt');
```

Risoluzione Tracce di Esame

Indice

Appello 17 Gennaio 2017

Appello 14 Febbraio 2017

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti