Risoluzione Tracce di Esame

Indice

1 Appello 17 Gennaio 2017
2 Appello 14 Febbraio 2017
3 Appello 11 Aprile 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 la radice quadrata di N: ');

    % Chiedo l'inserimento della radice quadrata di N, in modo tale da essere sicuro

    % che la dimensione N sia un quadrato perfetto (N = n*n) come richiesto dalla traccia

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

Appello 11 Aprile 2017

Traccia: Acquisire da file 25 numeri interi con segno e crea la matrice quadrata A di dimensioni 5x5; trasformare la matrice A, in modo tale che gli elementi di ogni sua singola riga risultino scambiati rispetto all'elemento centrale; stampa la nuova matrice A 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. Attenzione: è possibile eseguire correttamente il seguente programma solo se è presente, nella stessa directory in cui sono salvati gli script, un file di testo, nominato dati.txt, che contiene 25 numeri interi.

La seguente funzione permette di leggere da file di testo 25 numeri interi e restituisce la matrice con i dati presenti nel file.

```
function [ A ] = leggiFile( )
```
```
    fileID = fopen('dati.txt','r');
```
```
    A = [];
```
```
    for i = 1 : 5
```
```
        for j = 1 : 5
```

            A(i,j) = fscanf(fileID, '%d ', 1);

```
        end
```
```
    end
```
```
    fclose(fileID);
```
```
end
```

La seguente funzione permette di trasformare la matrice A, in modo tale che gli elementi di ogni sua singola riga risultino scambiati rispetto all'elemento centrale.

```
function [ A ] = trasformaMatrice( A )
```
```
    for i = 1 : 5
```
```
        for j = 1 : 2
```
```
            temp = A(i,j);
```
```
            A(i,j) = A(i,6-j);
```
```
            A(i,6-j) = temp;
```
```
        end
```
```
    end
```
```
end
```

La seguente funzione permette di stampare su file di testo e binario la matrice A trasformata.

```
function [  ] = stampaFile( A )
```
```
    fileID = fopen('output.txt','w');
```
```
    fileID2 = fopen('output.dat','w');
```
```
    for i = 1 : 5
```
```
        for j = 1 : 5
```

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

            fwrite(fileID2, A(i,j), 'double');

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

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

%% Algoritmo che permette di acquisire da file 25 numeri interi con segno e crea la matrice quadrata A di dimensioni 5x5;

%  trasformare la matrice A, in modo tale che gli elementi di ogni sua singola riga risultino scambiati rispetto all'elemento centrale;

%  stampa la nuova matrice A in un file di testo e/o binario.

```
 
```
```
A = leggiFile();
```
```
A = trasformaMatrice(A);
```
```
stampaFile(A);
```

Risoluzione Tracce di Esame

Indice

Appello 17 Gennaio 2017

Appello 14 Febbraio 2017

Appello 11 Aprile 2017

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti