Lezione 6

Esercitazione 6
Array
Arrays
Array (o tabella o vettore):
è una variabile strutturata in cui è possibile memorizzare un numero
fissato di valori tutti dello stesso tipo.
Esempio
int a[6];
/* dichiarazione di un array di nome a atto a memorizzare
6 elementi di tipo int */
0
1
2
3
4
5
Arrays
Ogni elemento di un array è individuato da un indice (da 0 a lunghezza
dell’array meno 1).
Esempio
int a[6];
a[0] = 4;
a[1] = 42;
a[2] = 34;
a[3] = -23;
a[4] = 87;
a[5] = a[2];
4
42
34
-23
87
34
0
1
2
3
4
5
Esercizio
Descrivere l’output generato dal seguente programma.
#include <stdio.h>
main ( )
{
int a, b = 0;
int c [10] ;
for (a = 0; a< 10; a++)
c [a] = a;
for (a = 0; a < 10; ++a)
if ((c [a] % 2) == 0)
b += c[a];
printf (“%d”, b);
}
Soluzione
Il programma definisce un array c di 10 interi che contiene i
valori 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
)
)
calcola la somma degli elementi dell’array i cui valori sono pari;
)
quindi stampa il valore di tale somma che vale 20.
Esercizio: Crivello di Eratostene
Costruire una tabella di numeri interi
int tabella [DIM]
tale che:
¾
in corrispondenza di ogni indice da 0 a 100 c’è un numero 0 o 1 tale che
¾
se i è 0 o 1 allora tabella[i]==1;
per ogni i compreso tra 2 e 100,
™ se i è primo allora tabella[i]=1;
™ se i non è primo allora tabella[i]=0;
¾
Infine si stampino i numeri primi trovati.
Soluzione
™
inizializzazione
0
1
™
2
3
4
5
6
7
8
9
10
11
12
13
1
1
1
1
1
1
1
1
…
1
1
1
1
1
…
10
11
12
13
…
cancello i multipli di 2
0
1
™
1
1
2
3
4
5
6
7
8
9
1
1
1
0
1
0
1
0
1
0
1
0
1
…
10
11
12
13
…
0
1
0
1
cancello i multipli di 3
0
1
....
1
2
3
4
5
6
7
8
9
1
1
1
0
1
0
1
0
0
…
#include <stdio.h>
#define DIM 101
/* deve contenere i numeri da 0 a 100 */
main ( ) {
int i, j;
int tabella [DIM] ;
for (i = 0; i< DIM; i++)
tabella [i] = 1;
/* inizializzo la tabella */
printf (“%d “, 1);
for (i = 2; i < DIM; i++)
if (tabella [i] == 1) {
printf (“%d “, i);
for (j = 2; j * i < DIM; j++)
tabella [i * j] =0;
}
printf (“\n”);
}
/* elimino i multipli di i */
scanf
La funzione scanf
™
legge caratteri dallo standard input (tastiera),
™
li interpreta,
™
memorizza il risultato negli argomenti successivi (che sono
indirizzi di memoria).
La funzione scanf restituisce un intero che
™
rappresenta il numero di valori che sono stati letti con successo
scanf di caratteri
La funzione scanf
™
legge i caratteri dallo standard input (tastiera) esattamente
nell’ordine in cui vengono inseriti
™
i caratteri di “fine linea”, “tab” ecc. non vengono ignorati
(è dunque necessario tenere conto di tali caratteri)
™
è possibile ignorare i carattere di “fine linea”, “tab” e “spazi”
mettendo uno spazio prima di %c
Esercizio
Scrivere una funzione che inizializza un array di caratteri.
void inizializza_array (char tabella [ ], int dim)
{
int i;
for (i=0; i<dim; i++)
{
printf (“inserisci elemento %d e digita invio: ”, i+1);
scanf(“ %c”, &tabella[i]);
}
}
spazio (ignora tutti gli spazi e i tab che
precedono l’immissione del carattere)
Esercizio
Scrivere un programma che utilizza la funzione inizializza_array.
#include <stdio.h>
#define N 5
void inizializza_array (char tabella [ ], int dim){ ...}
main ( ) {
char array[N];
inizializza_array (array,N);
/* stampa la tabella */
printf(“\n la tabella inizializzata è: \n\n\t”);
for (i=0; i<N; i++)
printf (“%c “, array[i]);
printf(“\n\n”);
}
Output
Esempio di esecuzione del programma precedente.
inserisci elemento 1 e digita invio: l
inserisci elemento 2 e digita invio: i
inserisci elemento 3 e digita invio: b
inserisci elemento 4 e digita invio: r
inserisci elemento 5 e digita invio: o
la tabella inizializzata è:
libro
prompt$
Esercizio: istogrammi
Scrivere un programma che legge un vettore di interi di dimensione
fissata, e stampa il corrispondente istogramma.
Esempio:
Dato il vettore
1 3 2 4 7 9
stampa
1| *
3| ***
2| **
4| ****
7| *******
9| *********
#include <stdio.h>
#define DIM 10
int main(void) {
int vett [DIM];
int i, j;
/* leggi vettore */
printf("Inserire un vettore di interi di dimensione %d\n", DIM);
for (i = 0; i < DIM; i++)
scanf("%d", &vett[i]);
/* stampa dell'istogramma */
for (i = 0; i < DIM; i++) {
printf("%d |", vett[i]);
for (j = 0; j < vett[i]; j++)
printf("*");
printf("\n");
}
}
Le funzioni getchar e putchar
Le funzioni
™
int getchar (void): legge il prossimo carattere dallo standard
input e lo restituisce come valore intero.
™
int putchar(int c): visualizza il carattere memorizzato in c.
si trovano nella libreria stdio.h per l’input/output standard.
Esercizio: MCD
Scrivere un programma che calcola il massimo comune divisore tra
due numeri interi positivi, n e m.
Esempi:
MCD (5, 15) = 5
MCD (12, 16) = 4
MCD (100, 75) = 25
Esercizio (continua)
Una soluzione elegante è fornita dal ben noto algoritmo di Euclide.
L’idea si basa sulla seguente osservazione:
Per qualunque coppia di valori interi positivi x e y tali che x > y,
l’insieme dei divisori di x e y coincide con l’insieme dei divisori di
x-yey
Esercizio (continua)
Possiamo quindi risolvere il problema del MCD utilizzando il
seguente algoritmo.
ALGORITMO DI EUCLIDE
¾
¾
se m=n allora il MCD(m,n) è m (o n)
se m≠n allora
™ se m>n allora MCD(m,n)=MCD(m-n,n)
™ se m<n allora MCD(m,n)=MCD(m,n-m)
Ripetendo questo procedimento, prima o poi si ottengono due
numeri uguali che sono quindi il MCD(m,n) cercato.
Esercizio (continua)
Dimostriamo formalmente che l’algoritmo di Euclide è corretto.
Siano x e y due numeri interi positivi tali che x > y.
Denotiamo con Div(x,y) l’insieme dei divisori comuni di x e y.
Vogliamo mostrare che k ∈ Div(x,y) se e solo se k ∈ Div(x-y,y) per
qualunque scelta di k.
Proviamo le due implicazioni separatamente.
(⇒) Per definizione di divisore, k ∈ Div(x,y) implica che esistono due
interi s e t tali che x = s * k e y = t * k. Ma allora
x - y = (s * k) – (t * k) = (s – t) * k e quindi k ∈ Div(x-y,y).
⇐ k ∈ Div(x-y,y) implica che esistono s e t tali che x - y = s * k e
y = t * k. Ma allora x = x – y + y = s * k + t * k = (s + t) * k e quindi
k ∈ Div(x,y).
Soluzione
#include <stdio.h>
int MCD(int x, int y) {
while (x!=y)
if (x>y) x = x - y;
else y = y - x;
return x;
}
Invariante del ciclo:
Siano m e n i parametri attuali, quindi l’invariante è:
{ x > 0, y > 0, Div(x,y) = Div(m,n) }
Terminazione: la funzione d(x,y)=x+y per valori x > 0 e y > 0
decresce ad ogni iterazione del ciclo
Soluzione (continua)
int main ( ) {
int m, n, mcd;
printf(“Inserisci il numero intero positivo m: \n”);
scanf (“%d”, &m);
printf(“Inserisci il numero intero positivo n: \n”);
scanf (“%d”, &n);
mcd = MCD(m,n);
printf(“Il MCD di %d e %d è: %d\n”, m, n, mcd);
}