Esercizio 1 - Soluzione (1)

Transcript

Esercizio 1: Quadrato magico
Realizzare una funzione che, presa in input
una matrice quadrata, determini se è un
quadrato magico
Un quadrato magico è una matrice NxN

• I cuii elementi
l
ti sono TUTTI i numerii iinteri
t id
da 1 a
N2
i cuii
in
• Le somme degli elementi per tutte le righe, tutte
l colonne
le
l
e lle di
diagonalili sono equivalenti
i l ti
– Tale somma è detta “magic constant”
1
#define N 3
typedef int matrice[N][N];
typedef enum{false, true} boolean;
t
typedef
d f boolean
b l
covered[N*N];
d[N*N]
boolean verifyMatrix(matrice m, int dim)
{
covered c;
Vettore che verifica la
int i, j;
presenza, nella matrice,
dei numeri da 1 a N2
for(i = 0; i < dim*dim; i++)
Se c[i] è true significa che il
c[i] = false;
presente
numero i+1 è p
…
nella matrice
2
…
Controllo
for(i = 0; i < dim; i++)
{
sull’intervallo dei
for(j = 0; j < dim; j++)
valori [1,N2]
{
if(m[i][j] < 1 || m[i][j] > dim*dim)
{
return false;
}
if( c[ m[i][j] -1] == false)
{
c[ m[i][j] -1] = true;
}
I numeri non
else
devono essere
{
p
ripetuti
return false;
}
}
}
return true;
}
3

Essendo il calcolo su righe e colonne molto simile
simile, realizziamo
un’unica funzione sufficientemente generica
• La somiglianza è dovuta al fatto che la matrice è quadrata
• Un ulteriore parametro di questa funzione indica se il conteggio va
effettuato sulle righe o sulle colonne
boolean verifyRows(matrice m, int dim, int* sum)
{
return verify(m, dim, true, sum);
}
boolean verifyColumns(matrice m, int dim, int* sum)
{
return verify(m, dim, false, sum);
}
4
boolean verify(matrice m, int dim, boolean verifyRows, int* sum)
{
int i, j, partial;
*sum = -1;
for(i = 0; i < dim; i++)
{
partial = 0;
for(j = 0; j < dim; j++)
{
if(verifyRows)
partial = partial + m[i][j];
else
partial = partial + m[j][i];
}
if(*sum < 0)
*sum = partial;
else if (*sum != partial)
I i i li
Inizializzazione
i
return false;
della somma
}
; }
return true;
5
boolean
b
l
verifyDiagonals(matrice
if Di
l ( t i
m, int
i t dim,
di
i t* sum)
int*
)
{
int i, j, sum2 = 0;
*sum = 0;
for(i = 0; i < dim; i++)
*sum = *sum + m[i][i];
for(i = 0; i < dim; i++)
sum2
2 = sum2
2 + m[i][dim-i-1];
[i][di i 1]
return (*sum == sum2);
}
6
Definizione dei codici di ritorno della funzione
#define RESULT int
#define
#define
#d fi
#define
#define
#define
#define
NOT
NOT_WELL_FORMED
WELL FORMED 0;
ROWS_CHECK_FAILED 1;
COLUMNS
COLUMNS_CHECK_FAILED
CHECK FAILED 2
2;
DIAGONALS_CHECK_FAILED 3;
DIFFERENT_SUM 4;
MAGIC 5;
7
RESULT magicSquared(
matrice m, int dim,
int*magic_constant)
{
boolean result;
int sum, sum2;
result = verifyMatrix(m, dim);
if(!result)
return NOT_WELL_FORMED;
result = verifyRows(m,
y
( , dim,
, &sum);
);
if(!result)
return ROWS_CHECK_FAILED;
result
lt = verifyColumns(m,
if C l
(
di
dim, &
&sum2);
2)
if(!result)
return COLUMNS_CHECK_FAILED;
_
_
…
8
…
if(sum != sum2)
return DIFFERENT_SUM;
result = verifyDiagonals(m, dim, &sum2);
if(!result)
return DIAGONALS_CHECK_FAILED;
DIAGONALS CHECK FAILED;
if(sum != sum2)
return DIFFERENT_SUM;
*magic_constant = sum;
return MAGIC;
}
9
E
Esercizio
i i 2
2: Al
Algoritmi
it i di ordinamento
di
t
“Astrazione”
Astrazione degli algoritmi di ordinamento

Implementare i diversi algoritmi di ordinamento
ordinamento, facendo in
modo di astrarre completamente dal tipo degli elementi
del vettore
de
etto e
Fare anche in modo che vengano stampate delle
statistiche sul numero di confronti e di scambi
effettuati
Testare la soluzione su un vettore di interi, un vettore di
caratteri, un vettore di stringhe
10
Esercizio 2 - elementdef.h
elementdef h

Nel caso di interi…
interi
#ifndef ELEMENTDEF
#define ELEMENTDEF
typedef int Element;
#endif

Nel caso di stringhe…
#ifndef ELEMENTDEF
#define ELEMENTDEF
typedef char* Element;
#endif
#
11
Esercizio 2 - element.h
element h
#ifndef ELEMENT
#define ELEMENT
int compare(Element e1, Element e2);
void swap(Element *e1, Element *e2);
void assign(Element *lvalue, Element rvalue);
void printElement(Element e);
void printStatistics();
#endif
12
Esercizio 2 - element.c
element c (1)
#include "elementdef.h"
#include <stdio.h>
#include <string.h> //se il tipo è stringa…
int compareCounter = 0;
int swapCounter = 0;
void incrementCompareCounter()
{
compareCounter++;
}
void incrementSwapCounter()
{
swapCounter++;
}
13
element c (2)
void assign(Element
g (
*lvalue,
, Element rvalue)
)
{
*lvalue = rvalue;
}
void swap(Element *e1, Element *e2)
{
Element tmp;
assign(&tmp, *e1);
assign(e1,
i ( 1 *
*e2);
2)
assign(e2, tmp);
incrementSwapCounter();
}
14
element c (3)

Nel caso di interi…
int compare(Element e1, Element e2)
{
incrementCompareCounter();
return e1 - e2;
}
printElement(Element
(
e)
)
void p
{
printf(“%d\n”, e);
}

Nel caso di stringhe…
int compare(Element e1, Element e2)
{
incrementCompareCounter();
return strcmp(e1, e2);
}
// e ovviamente printElement con %s
15
Esercizio 2 - altri header
commondef.h
commondef h
#ifndef COMMONDEF
#define COMMONDEF
#define DIM 20
typedef
yp
Element Array[DIM];
y[
];
#endif
sort.h
sort h
void printArray(Array a, int dim);
void naiveSort(Array a, int dim);
gli altri tipi
p di sort…
// e tutti g
16
E
Esercizio
i i 2 – ad
d esempio
i printArray
i tA
#include
#include
#include
#include
"elementdef.h"
"commondef.h"
"element.h"
<stdio.h>
void printArray(Array a, int dim)
{
i t i
int
i;
printf("---VETTORE---\n");
for(i = 0; i < dim; i++)
printElement(a[i]);
printf("-------------\n");
printf(
\n );
}
17
E
Esercizio
i i 2 – ad
d esempio
i naiveSort
i S t
void naiveSort(Array a, int dim)
{
int j, i, posmin;
Element min;
for (j = 0; j < dim; j++)
{
posmin = j;
for ( assign(&min,
assign(&min a[j]),
a[j]) i = j + 1; i < dim; i++)
{
if(compare(a[i], min) < 0)
{
posmin = i;
assign(&min, a[i]);
}
}
if (posmin != j)
swap(&a[j], &a[posmin]);
}
}
18