Es9

Informatica A (per gestionali)
A.A. 2004/2005
Esercizi C e diagrammi a blocchi
Preparazione prima prova intermedia
Indice
1
Array ........................................................ 3
1.1
Filtraggio .............................................................................................................................. 3
1.2
Trasformazione .................................................................................................................... 3
2 Struct e array ............................................... 5
2.1
Offerte fornitori .................................................................................................................... 5
2.2
GPS ...................................................................................................................................... 6
2.3
Esami studenti ...................................................................................................................... 7
3 Diagramma a blocchi e traccia di esecuzione .................. 8
3.1..................................................................................................................................................... 8
2
1 Array
1.1 Filtraggio
Testo
L’utente inserisce un array di numeri reali non negativi (un numero negativo indica la fine della fase
di inserimento). L’elaboratore calcola la seguente formula: v[i]  (v[i-1] + v[i] + v[i+1]) / 3
e visualizza l’array così filtrato.
Quando i corrisponde ai “bordi” dell’array, assumere che v[i-1] (oppure v[i+1]) valga zero.
Implementazione
#include <stdio.h>
void main()
{
unsigned int tot = 0, i;
float n, precedente, successivo, numeri[100];
printf ("Numero non negativo: ");
scanf ("%f", &n);
while (n >= 0)
{
numeri[tot] = n;
tot++;
printf ("Numero non negativo: ");
scanf ("%f", &n);
}
for (i = 0; i < tot; i++)
{
if (i == 0)
{
precedente = 0;
}
else
{
precedente = numeri[i - 1];
}
if (i == tot - 1)
{
successivo = 0;
}
else
{
successivo = numeri[i + 1];
}
printf ("%f\n", (precedente+numeri[i]+successivo)/3.0);
}
}
1.2 Trasformazione
3
Testo
L’utente inserisce un array di numeri interi, di lunghezza desiderata.
Chiamando v l’array e indicando con m la posizione dell’ultima cella inserita (l’array sarà quindi
composto da m+1 celle), il programma applica il seguente calcolo:
- per ogni i, in v[i] ed in v[m-i] si inserisce il valore v[i]+v[m-i]
Implementazione
#include <stdio.h>
void main()
{
const unsigned int MAX = 100;
unsigned int tot, m, i;
int numeri[MAX], temp;
printf ("Quanti numeri: ");
scanf ("%u", &tot);
/* saranno riempite tot celle, da 0 a tot-1 */
for (i = 0; i < tot; i++)
{
printf ("Numero:");
scanf ("%d", &numeri[i]);
}
m = tot - 1;
for (i = 0; i <= m / 2; i++)
{
temp = numeri[i] + numeri[m - i];
numeri[i] = temp;
numeri[m - i] = temp;
}
for (i = 0; i < tot; i++)
{
printf ("%d\n", numeri[i]);
}
}
4
2 Struct e array
2.1 Offerte fornitori
Testo
Il programma permette di inserire un certo numero di offerte di fornitori:
- codice fornitore (numero naturale)
- Nome fornitore (stringa)
- importo offerta in euro (numero float)
Quando l’utente inserisce 0 come codice fornitore, l’inserimento ha termine.
Il programma cerca e visualizza l’offerta migliore (la più economica).
Implementazione
#include <stdio.h>
void main()
{
const unsigned int MAX_OFFERTE = 1000, MAX_CAR = 20;
typedef char Stringa[MAX_CAR];
typedef struct
{
unsigned int codFornitore;
Stringa nomeFornitore;
float importo;
} Offerta;
Offerta arrayOfferte[MAX_OFFERTE], nuovaOfferta;
int numOfferte = 0, j;
float offertaMin;
unsigned int posizOffertaMin;
printf ("Codice fornitore: ");
scanf ("%u", &nuovaOfferta.codFornitore);
printf ("Nome fornitore: ");
scanf ("%s", nuovaOfferta.nomeFornitore);
printf ("Importo offerta (euro): ");
scanf ("%f", &nuovaOfferta.importo);
while (nuovaOfferta.codFornitore != 0)
{
arrayOfferte[numOfferte] = nuovaOfferta;
numOfferte++;
printf ("Codice fornitore: ");
scanf ("%u", &nuovaOfferta.codFornitore);
printf ("Nome fornitore: ");
scanf ("%s", nuovaOfferta.nomeFornitore);
printf ("Importo offerta (euro): ");
scanf ("%f", &nuovaOfferta.importo);
}
offertaMin = arrayOfferte[0].importo;
posizOffertaMin = 0;
for (j = 1; j < numOfferte; j++)
5
{
if (arrayOfferte[j].importo < offertaMin)
{
offertaMin = arrayOfferte[j].importo;
posizOffertaMin = j;
}
}
printf ("Cod.fornitore:%u,nome:%s,importo:%f\n",
arrayOfferte[posizOffertaMin].codFornitore,
arrayOfferte[posizOffertaMin].nomeFornitore,
arrayOfferte[posizOffertaMin].importo);
}
2.2 GPS
Testo
Un esempio di calcolo dell’occupazione in memoria di variabili strutturate
Un sistema GPS calcola e memorizza in un array una serie di coordinate geografiche. Sapendo che:
- Le variabili di tipo int occupano 16 bit
- Le variabili di tipo float occupano 32 bit
- Le variabili di tipo char occupano 8 bit
Ed avendo definito i seguenti tipi strutturati:
typedef struct
{
unsigned int
unsigned int
unsigned int
unsigned int
} Coordinata;
gradi;
minuti;
secondi;
frazSecondi;
typedef struct
{
Coordinata latitudine;
Coordinata longitudine;
float altitudine;
float distanzaPercorsa;
char unitaMisuraDistanza[2];
} Punto;
Calcolare quanti byte sono occupati dalla variabile percorso definita nel seguente modo:
Punto percorso[1000];
Soluzione
16 x 4 = 64 bit per le variabili di tipo Coordinata
64 x 2 + 32 x 2 + 8 x 2 = 208 bit per le variabili di tipo Punto
La variabile percorso è un array di 1000 celle di tipo Punto e quindi occupa:
208 x 1000 = 208000 bit, ovvero 208000 / 8 = 26000 byte. Ricordiamo che 1 byte = 8 bit.
6
2.3 Esami studenti
Testo
Definizione di tipi strutturati e calcolo dell’occupazione in memoria.
Si definisca il tipo strutturato Esame che permetta di rappresentare le informazioni riguardanti un
esame superato da un certo studente. Esame è composto dai seguenti dati:
 codiceCorso: una sequenza di 6 caratteri,
 votoRiportato: numero intero non negativo,
 annoAccademico: numero intero non negativo;
Si definisca il tipo strutturato Studente che permetta di rappresentare informazioni riguardanti tutti
gli esami superati da un certo studente. Studente è composto dai seguenti dati:
 matricola: una sequenza di 6 caratteri,
 vettEsamiSuperati: un vettore composto da 30 celle di tipo Esame,
 numeroEsamiSuperati: numero intero non negativo.
Si definisca inoltre la variabile vettStudenti, che permetta di rappresentare l’insieme degli studenti
ad una certa università. L’università in questione potrà gestire un massimo di 1000 studenti.
Supponendo di riferirsi ad una architettura in cui una variabile di tipo char occupi 1 byte e un
intero occupi 2 byte, calcolare l’occupazione in memoria della variabile vettStudenti.
Soluzione
typedef struct
{
char codiceCorso[6];
unsigned int votoRiportato;
unsigned int annoAccademico;
} Esame;
typedef struct
{
char matricola[6];
Esame vettEsamiSuperati[30];
unsigned int numeroEsamiSuperati;
} Studente;
Studente vettStudenti[1000];
Occupazione di memoria:
Esame: 6 caratteri x 1 byte + 1 intero x 2 byte + 1 intero x 2 byte = 10 byte
Studente: 6 caratteri x 1 + 30 Esame x 10 byte + 1 intero x 2 byte = 308 byte
Quindi, vettStudenti: 1000 Studente x 308 byte = 308000 byte.
7
3 Diagramma a blocchi e traccia di esecuzione
3.1
A) Sia data una sequenza di numeri interi positivi diversi da zero. I valori sono letti in input da
tastiera. La fine dell’input è indicata dall’inserimento dello 0. Si calcoli:
a. Il numero di coppie di numeri consecutivi uguali
b. Il numero di coppie in cui il secondo numero e’ divisore del primo, ma non uguale
c. Si visualizzi un messaggio che dica quale tipo di coppie tra i due precedenti è
presente in numero maggiore.
Ad esempio, se la sequenza letta in input è 5 5 5 5 5 2 3 12 6 2, allora l’algoritmo calcolerà
4 come n.ro di coppie di interi uguali e 2 come n.ro di coppie in cui il secondo numero è
divisore del primo e visualizzerà il messaggio: “La sequenza contiene un numero maggiore
di coppie di numeri uguali”.
B) Si costruisca la traccia di esecuzione del programma in corrispondenza della sequenza di
ingresso: 4 4 4 2 9
NOTA: non è necessario controllare che i dati di ingresso siano maggiori o uguali a zero
Inizio
A
0
divis = 0; ugua = 0 1
Leggi d1
3
V
2
15
“Sequenza
non esiste”
F
d1 != 0
12 ugua > divis
5
d2 != 0
4
d1 == d2
F
“Più coppie
uguali”
18
Fine
F
V
6
Fine
14
“Più coppie
con divisore”
V
V
Leggi d2
16
“Nessuna
coppia”
ugua!= 0 || F
11
divis != 0
13
18
8
F
V
ugua++ 7
d1 % d2 == 0
F
V
divis++ 9
d1 = d2 10
A
8
Nº blocco
Prox
blocco
1
2
2
3
3
4
4
5
5
6
V
6
7
V
7
10
10
4
4
5
5
6
V
6
7
V
7
10
10
4
4
5
5
6
V
6
8
F
8
9
V
9
10
10
4
4
5
5
6
V
6
8
F
8
10
F
10
4
4
5
5
11
F
11
12
V
(1)
(2)
12
13
V
(1)
(2)
13
18
18
-
test
d1
d2
divis
ugua
0
0
4
V
4
1
4
4
2
4
2
1
2
9
9
0
9