Es5-6

Informatica A (per gestionali)
A.A. 2004/2005
Esercizi C
Array, matrici, tipi strutturati
ed enumerativi
Indice
1
Array ........................................................ 3
1.1
Codifica stringhe .................................................................................................................. 3
1.2
Media e varianza .................................................................................................................. 4
1.3
Filtraggio .............................................................................................................................. 5
1.4
Trasformazione .................................................................................................................... 6
1.5
Trova il massimo .................................................................................................................. 7
1.6
Ricerca lineare...................................................................................................................... 8
1.7
Merge di due array ordinati .................................................................................................. 9
1.8
Ordinamento per inserzione ............................................................................................... 11
1.9
Ordinamento con bubble sort ............................................................................................. 12
2 Matrici ..................................................... 14
2.1
Matrice simmetrica ............................................................................................................ 14
2.2
Scambio righe .................................................................................................................... 15
3 Tipi strutturati ed enumerativi ............................. 17
3.1
Numeri complessi .............................................................................................................. 17
3.2
Distanza tra due punti ........................................................................................................ 17
3.3
Definizione struttura dati complessa .................................................................................. 19
3.4
Squadra di calcio ................................................................................................................ 20
3.5
Schedine ............................................................................................................................. 22
2
1 Array
1.1 Codifica stringhe
Testo
Leggere, ed inserire in un array, una stringa di caratteri formata solo da lettere minuscole e dallo
spazio e terminata da '$'. Quindi:
- Per ogni carattere della stringa, mettere il carattere alfabeticamente successivo;
il carattere successivo della 'z' sarà la 'a'; il carattere successivo dello
spazio, sarà '_'. Per esempio, 'a'  'b' , 'g'  'h', 'z'  'a', ' '  '_'.
- Stampare la stringa così codificata.
NOTA: assumiamo che l’utente inserisca tutti i caratteri in una volta sola e quindi prema ENTER.
Pseudocodice
Usiamo il contatore per trovare la fine della stringa.
[azzera contatore i]
[leggi carattere]
while ([il carattere letto non è ‘$’])
{
[inserisci carattere nella posizione i-esima dell’array; incrementa i]
[leggi carattere]
}
[azzera contatore i]
for ([per ogni cella dell’array, fino alla (i-1)-esima])
{
if ([il carattere è lo spazio])
{
[inserisci ‘_’ nell’array che conterrà il risultato]
}
else if ([il carattere è minore di ‘z’])
{
[inserisci il carattere alfabeticamente successivo nell’array risultato]
}
else
{
[inserisci ‘a’ nell’array del risultato]
}
}
for ([per ogni cella dell’array, fino alla (i-1)-esima])
{
[scrivi carattere]
}
Implementazione
#include <stdio.h>
void main()
{
const int MAX = 1000;
const char terminatore = '$';
char c, stringa[MAX], codifica[MAX];
3
int numCaratteri = 0, i;
printf ("Inserisci caratteri; termina con %c:", terminatore);
scanf ("%c", &c);
while (c != terminatore)
{
stringa[numCaratteri] = c;
numCaratteri++;
scanf ("%c", &c);
}
for (i = 0; i < numCaratteri; i++)
{
if (stringa[i] == ' ')
{
codifica[i] = '_';
}
else if (stringa[i] < 'z')
{
codifica[i] = stringa[i] + 1;
}
else
{
codifica[i] = 'a';
}
}
printf ("\nStringa codificata: ");
for (i = 0; i < numCaratteri; i++)
{
printf ("%c", codifica[i]);
}
}
1.2 Media e varianza
Testo
Leggere un insieme di numeri, inserirlo in un array e calcolare la media e la varianza. L’utente
dovrà prima di tutto indicare quanti numeri vuole inserire nell’array.
Ricordiamo che la media di n dati ai si ottiene:
n
x
a
i 1
i
n
mentre la varianza è data da:
n
Var( x ) 
 (a
i 1
i
 x )2
n 1
Pseudocodice
[leggi quantità di numeri da inserire: n]
for ([contatore i; ripeti per n volte])
{
4
[leggi numero e mettilo nella posizione i-esima]
[somma il numero letto alla variabile che contiene il totale]
}
[calcola media: il totale diviso per n]
[azzera la variabile che contiene il totale]
for ([contatore i; ripeti per n volte])
{
[calcola lo scarto quadratico e somma il numero alla variabile che contiene il totale]
}
[calcola varianza: il totale diviso per n-1]
[scrivi media e varianza]
Implementazione
#include <stdio.h>
#include <math.h>
void main()
{
const unsigned int MAX = 1000;
float arrayNumeri[MAX];
unsigned int i, num;
float totale = 0, media, varianza;
printf ("quanti numeri (max %d): ", MAX);
scanf ("%u", &num);
for (i = 0; i < num; i++)
{
printf ("Dato (%u): ", i);
scanf ("%f", &arrayNumeri[i]);
totale = totale + arrayNumeri[i];
}
media = totale / num;
totale = 0;
for (i = 0; i < num; i++)
{
totale = totale + pow (arrayNumeri[i] - media, 2);
}
varianza = totale / (num – 1);
printf ("Media: %f, varianza: %f", media, varianza);
}
1.3 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()
{
5
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.4 Trasformazione
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: ");
6
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]);
}
}
1.5 Trova il massimo
Testo
Leggere un insieme di numeri interi e inserirlo in un array. L’insieme sarà terminato dal numero
zero. Successivamente, trovare:
- Il numero massimo
- La posizione del numero massimo.
Pseudocodice
[leggi numero]
if ([numero  0 AND contatore numeri è inferiore al massimo permesso dall’array])
{
[inserisci il numero nell’array alla posizione data dal contatore]
[incrementa il contatore]
[leggi numero successivo]
}
[il massimo è il numero nella cella zero]
[la posizione del massimo è la posizione zero]
for ([l’indice i va dalla cella 1 a quella indicata da contatore-1])
{
if ([numero cella i-esima è maggiore nel massimo])
{
[il massimo è il numero nella cella i-esima]
[la posizione del massimo è la posizione i-esima]
}
}
[scrivi massimo e posizione del massimo]
7
Implementazione
#include <stdio.h>
void main()
{
const unsigned int MAX = 1000;
int arrayNumeri[MAX], dato, max;
unsigned int i, num = 0, posizMax;
/* inizializzo la cella 0 perché, se non immetto niente */
/* nell’array, sarà lei il max
*/
arrayNumeri[0] = 0;
scanf ("%d", &dato);
while (dato != 0 && num < MAX)
{
arrayNumeri[num] = dato;
num = num + 1;
if (num < MAX)
/* non leggo il dato successivo */
{
/* se l’array è finito
*/
scanf ("%d", &dato);
}
}
max = arrayNumeri[0];
posizMax = 0;
for (i = 1; i < num; i++)
{
if (arrayNumeri[i] > max)
{
max = arrayNumeri[i];
posizMax = i;
}
}
printf ("Max:%d, posizione:%u", max, posizMax);
}
1.6 Ricerca lineare
Testo
L’utente inserisce in un array un certo numero di interi, l’utente inserisce un numero e l’elaboratore
controlla se è presente nell’array.
Se il numero è presente, si visualizza la posizione in cui è stato trovato.
Pseudocodice
[leggi quanti numeri ordinare]
[leggi il numero da cercare: x]
contatore = inizio vettore
do
{
if ([il numero nella cella corrente è uguale a x])
{
[segnala che il numero è stato trovato]
}
8
else
{
[incrementa contatore]
}
}while (x non è stato trovato E vettore non è terminato]
if ([il numero x è stato trovato])
{
[visualizza il numero ed il valore del contatore]
}
Implementazione
#include <stdio.h>
void main()
{
unsigned int i, n, trovato = 0;

int numeri [100], num;


printf ("Quanti numeri: ");

scanf ("%u", &n);

for (i = 0; i < n; i++)

{

printf ("Numero %u: ", i);

scanf ("%d", &numeri[i]);

}
printf ("Numero da cercare: ");
scanf ("%d", &num);
 i = 0;
do
 {
 if (numeri[i] == num)

{

trovato = 1;

}

else

{

i++;

}
 } while (trovato == 0 && i < n);
 if (trovato)
 {
 printf ("Numero: %d ", numeri[i]);

printf ("Posizione: %u\n", i);
 }
}
1.7 Merge di due array ordinati
Testo
L’utente inserisce due array composti da numeri interi ed ordinati in senso crescente. Le lunghezze
dei due array possono essere differenti.
9
L’elaboratore crea un terzo array ordinato, utilizzando i due array inseriti dall’utente.
Infine, quest’ultimo array viene visualizzato.
Pseudocodice
[leggi primo array]
[leggi secondo array]
[poni a zero i contatori j e k]
for ([ripeti un numero di volte pari alla somma delle lunghezze dei due array; contatore: i])
{
if ([primo array non terminato AND
cella j-esima primo array < cella k-esima secondo vettore OR
secondo array terminato])
{
[metti nella cella i-esima del terzo array, la cella j-esima del primo array]
[incrementa j]
}
else
{
[metti nella cella i-esima del terzo array, la cella k-esima del secondo array]
[incrementa k]
}
}
[visualizza il terzo array]
Implementazione
#include <stdio.h>
void main()
{
const int MAX = 100;
int array1[MAX], array2[MAX], merge[2 * MAX];
unsigned int n1, n2, im, i1, i2;
printf ("Lungh array 1: ");
scanf ("%u", &n1);
printf ("Lungh array 2: ");
scanf ("%u", &n2);
for (i1 = 0; i1 < n1; i1++)
{
printf ("Array1, numero: ");
scanf ("%d", &array1[i1]);
}
for (i2 = 0; i2 < n2; i2++)
{
printf ("Array2, numero: ");
scanf ("%d", &array2[i2]);
}
i1 = 0;
i2 = 0;
for (im = 0; im < n1 + n2; im++)
{
if (i1 < n1 && array1[i1] < array2[i2] || i2 >= n2)
10
{
merge[im] = array1[i1];
i1++;
}
else
{
merge[im] = array2[i2];
i2++;
}
}
for (im = 0; im < n1 + n2; im++)
{
printf ("%d\n", merge[im]);
}
}
1.8 Ordinamento per inserzione
Testo
L’elaboratore chiede all’utente quanti numeri interi vuole inserire e successivamente legge tutti
questi numeri.
Quindi, l’elaboratore ordina l’array in senso crescente e lo visualizza.
Pseudocodice
[leggi quanti numeri ordinare]
for ([ripeti per tutti i numeri da leggere, usando un contatore: n])
{
[leggi numero corrente]
[cerca la prima posizione p1 dell’array, tale che il numero memorizzata lì è
maggiore del numero corrente]
[sposta i dati contenuti nelle posizioni dell’array, dalla posizione p1 fino alla posizione n,
tutti nella cella successiva]
[inserisci nella posizione p1 il numero corrente]
}
for ([ripeti per tutti i numeri letti])
{
[scrivi il numero nella posizione corrente]
}
Implementazione
#include <stdio.h>
void main()
{
unsigned int tot;
int ultima, i, candidata, sposta;
int n, numeri[100];
printf ("Quanti numeri: ");
scanf ("%u", &tot);
for (ultima = 0; ultima < tot; ultima++)
{
printf ("Numero: ");
11
scanf ("%d", &n);
candidata = 0;
while (n >= numeri[candidata] &&
candidata <= ultima)
{
candidata++;
}
/* Sposto a partire dal fondo, altrimenti
sovrascrivo.
La variabile ultima indica l'ultima casella
occupata */
for (sposta=ultima; sposta>=candidata; sposta--)
{
numeri[sposta + 1] = numeri[sposta];
}
numeri[candidata] = n;
}
for (i = 0; i < tot; i++)
{
printf ("%d\n", numeri[i]);
}
}
1.9 Ordinamento con bubble sort
Testo
Lo stesso dell’esercizio precedente.
Pseudocodice
[leggi quanti numeri ordinare]
for ([ripeti per tutti i numeri da leggere, usando un contatore: n])
{
[leggi il numero e mettilo nella posizione n-esima dell’array]
}
do
{
[metti a falso la variabile che segnala uno scambio]
for ([per tutte le celle dell’array, meno l’ultima])
{
if ([il numero nella cella corrente è maggiore di quello della cella successiva])
{
[scambia il contenuto della cella corrente con quello della cella successiva]
[mette a vero la variabile che segnala uno scambio]
}
}
} while ([c’è stato uno scambio])
for ([esegui per tutte le posizioni occupate del vettore])
{
[scrivi il numero nella posizione corrente]
}
12
Implementazione
#include <stdio.h>
void main()
{
unsigned int tot, i, scambio;
int numeri [100], temporanea;
printf ("Quanti numeri: ");
scanf ("%u", &tot);
for (i = 0; i < tot; i++)
{
printf ("Numero: ");
scanf ("%d", &numeri[i]);
}
do
{
scambio = 0;
for (i = 0; i < tot - 1; i++)
{
if (numeri[i] > numeri[i + 1])
{
/* inizio scambio di due variabili */
temporanea = numeri[i];
numeri[i] = numeri[i + 1];
numeri[i + 1] = temporanea;
/* fine scambio di due variabili */
scambio = 1;
}
}
} while (scambio == 1);
for (i = 0; i < tot; i++)
{
printf ("%d\n", numeri[i]);
}
}
13
2 Matrici
2.1 Matrice simmetrica
Testo
L’utente inserisce una matrice quadrata, composta da numeri reali, ed il programma verifica (e
visualizza) se è simmetrica.
La dimensione della matrice inserita dall’utente è fissata all’interno del programma.
Ricordiamo che una matrice quadrata è simmetrica sse per ogni i,j vale ai,j = aj,i.
Pseudocodice
for ([contatore riga])
{
for ([contatore colonna])
{
[leggi numero e mettilo nella cella (riga, colonna)]
}
}
[assumi che la matrice sia simmetrica]
[azzera contatore colonna]
do
{
[contatore colonna  contatore riga +1]
do
{
if ([le celle (riga,colonna) e (colonna,riga) sono diverse])
{
[segnala che la matrice non è simmetrica]
}
[incrementa contatore colonna]
} while ([contatore colonna è minore della dimensione della matrice AND
la matrice è simmetrica])
[incrementa contatore riga]
} while ([contatore riga è minore di (dimensione della matrice, meno uno) AND
la matrice è simmetrica])
[scrivi il risultato della verifica]
Implementazione
#include <stdio.h>
void main()
{
const unsigned int DIM = 3;
unsigned int riga, colonna;
unsigned int simmetrica;
float matrice [DIM][DIM];
for (riga = 0; riga < DIM; riga++)
{
for (colonna = 0; colonna < DIM; colonna++)
{
14
printf ("numero (%u,%u): ", riga, colonna);
scanf ("%f", &matrice[riga][colonna]);
}
}
simmetrica = 1;
riga = 0;
do
{
colonna = riga + 1;
do
{
if (matrice[riga][colonna]!=matrice[colonna][riga])
{
simmetrica = 0;
}
colonna++;
} while (colonna < DIM && simmetrica == 1);
riga++;
} while (riga < DIM - 1 && simmetrica == 1);
if (simmetrica == 1)
{
printf ("Matrice simmetrica\n");
}
else
{
printf ("Matrice non simmetrica\n");
}
}
2.2 Scambio righe
Testo
L’utente inserisce una matrice composta da numeri interi. Il programma scambia le righe pari con
quelle dispari.
Le dimensioni della inserita dall’utente sono fissate all’interno del programma.
Pseudocodice
for ([contatore riga])
{
for ([contatore colonna])
{
[leggi numero e mettilo nella cella (riga, colonna)]
}
}
for ([contatore riga; va da zero al numero i righe della matrice, meno uno; incremento di 2])
{
for ([contatore colonna])
{
[scambia la cella (riga, colonna) con quella (riga + 1, colonna)]
}
}
15
for ([contatore riga])
{
for ([contatore colonna])
{
[visualizza numero nella cella (riga, colonna)]
}
}
Implementazione
#include <stdio.h>
void main()
{
const unsigned int DIMRIGA = 5, DIMCOL = 4;
unsigned int riga, colonna;
int matrice [DIMRIGA][DIMCOL], temporanea;
for (riga = 0; riga < DIMRIGA; riga++)
{
for (colonna = 0; colonna < DIMCOL; colonna++)
{
printf ("numero (%u,%u): ", riga, colonna);
scanf ("%d", &matrice[riga][colonna]);
}
}
for (riga = 0; riga < DIMRIGA - 1; riga = riga + 2)
{
for (colonna = 0; colonna < DIMCOL; colonna++)
{
temporanea = matrice[riga][colonna];
matrice[riga][colonna]=matrice[riga + 1][colonna];
matrice[riga + 1][colonna] = temporanea;
}
}
for (riga = 0; riga < DIMRIGA; riga++)
{
for (colonna = 0; colonna < DIMCOL; colonna++)
{
printf ("%d ", matrice[riga][colonna]);
}
printf ("\n");
}
}
16
3 Tipi strutturati ed enumerativi
3.1 Numeri complessi
Testo
L’utente inserisce due numeri complessi (parte reale e parte immaginaria) e l’elaboratore esegue
l’operazione di somma, es:
3+4i + 5-6i = 8-2i
Il programma chiede all’utente se vuole calcolare un’altra somma. Se l’utente inserisce il carattere
‘q’ il programma termina, altrimenti ricomincia daccapo.
Implementazione
#include <stdio.h>
void main()
{
typedef struct
{
float reale;
float immag;
} Complesso;
Complesso n1, n2, somma;
char fine;
do
{
printf ("Numero 1, parte reale: ");
scanf ("%f", &n1.reale);
printf ("Numero 1, parte immag: ");
scanf ("%f", &n1.immag);
printf ("Numero 2, parte reale: ");
scanf ("%f", &n2.reale);
printf ("Numero 2, parte immag: ");
scanf ("%f", &n2.immag);
somma.reale = n1.reale + n2.reale;
somma.immag = n1.immag + n2.immag;
printf ("Totale: %f%+fi\n", somma.reale,
somma.immag);
printf ("Fine? ");
scanf ("%*c");
scanf ("%c", &fine);
}while (fine != 'q');
}
3.2 Distanza tra due punti
Testo
Il programma permette di inserire le coordinate x e y di due punti e calcola la distanza.
Se l’utente inserisce due punti le cui coordinate sono entrambe zero, il programma –dopo il calcolo
della distanza– termina. Altrimenti, si comincia daccapo.
Definire il punto come tipo strutturato avente due coordinate (x e y).
17
Ricordiamo che la distanza d è calcolata:
d
(ax bx )  (a y by )
2
2
Usare le funzioni pow(base,esp) e sqrt(base)che calcolano, ripettivamente, baseesp e
Per esempio:
float a, b, c;
a = 3;
b = 2;
c = pow(a, b);
c = sqrt(c);
base .
/* dopo la pow(), c conterrà 9, cioè 32 */
/* dopo la sqrt(), c conterrà 3, cioè 9 */
/* Posso anche eseguire le due operazioni in un colpo solo */
c = sqrt(pow(a, b));
/* dopo le due operazioni, c varrà 3 */
Per usare la pow() e la sqrt(), devo includere la libreria math.h. Quindi, il programma dovrà
contenere l’istruzione:
#include <math.h>
Pseudocodice
do
{
[leggi coordinate primo punto]
[leggi coordinate secondo punto]
[calcola distanza]
[scrivi distanza]
} while ([le quattro coordinate non sono tutte a zero])
Implementazione
#include <stdio.h>
#include <math.h>
void main()
{
typedef struct
{
int x;
int y;
} Punto;
Punto a, b;
float distanza;
do
{
printf ("\npunto 1, coord x: ");
scanf ("%d", &a.x);
printf ("punto 1, coord y: ");
18
scanf ("%d", &a.y);
printf ("punto 2, coord x: ");
scanf ("%d", &b.x);
printf ("punto 2, coord y: ");
scanf ("%d", &b.y);
distanza = sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
printf ("distanza: %f", distanza);
} while (!(a.x==0 && a.y==0 && b.x==0 && b.y==0));
3.3 Definizione struttura dati complessa
Testo
Si definisca la seguente struttura dati (usando opportunamente la typedef struct):
1. 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;
2. 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;
3. 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.
4. 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
19
 Quindi, vettStudenti: 1000 Studente x 308 byte = 308000 byte
3.4 Squadra di calcio
Testo
Il programma, partendo da un array che contiene i dati personali dei calciatori di una squadra,
permette di calcolare:
- totale goal fatti dalla squadra
o goal fatti dagli attaccanti
o goal fatti dai centrocampisti
o goal fatti dai difensori
- totale goal subiti dalla squadra
Il programma inoltre visualizza i dati personali di tutti i giocatori.
Per ogni giocatore, il programma memorizza:
- numero di maglia
- ruolo
- goal fatti (subiti, se è un portiere)
Pseudocodice
for ([ripeti per ogni giocatore contenuto nel vettore])
{
[scrivi i dati del giocatore]
if ([il giocatore non è un portiere])
{
[somma i goal del giocatore al contatore dei goal fatti]
if ([il giocatore è un attaccante])
{
[somma i goal del giocatore al contatore dei goal degli attaccanti]
}
else if ([il giocatore è un centrocampista])
{
[somma i goal del giocatore al contatore dei goal dei centrocampisti]
}
else
{
[somma i goal del giocatore al contatore dei goal dei difensori]
}
}
else
{
[somma i goal del giocatore al contatore dei goal subiti]
}
}
[scrivi contatore goal fatti, goal degli attaccanti, dei centrocampisti, dei difensori]
[scrivi contatore goal subiti]
Implementazione
#include <stdio.h>
void main()
{
20
typedef enum {portiere, difensore, centrocampista,
attaccante} TipoRuolo;
typedef struct
{
unsigned int numero;
unsigned int goal;
TipoRuolo ruolo;
} Giocatore;
const unsigned int maxGiocatori = 30;
Giocatore giocatori[maxGiocatori];
unsigned int i, numGiocatori;
unsigned int totaleGoalFatti = 0, totaleGoalSubiti = 0;
unsigned int goalAttaccanti = 0, goalDifensori = 0,
goalCentrocampisti = 0;
/* DATI. In un programma vero, sarebbero letti da un file */
giocatori[0].numero = 9;
giocatori[0].goal = 9;
giocatori[0].ruolo = attaccante;
giocatori[1].numero = 7;
giocatori[1].goal = 3;
giocatori[1].ruolo = centrocampista;
giocatori[2].numero = 3;
giocatori[2].goal = 1;
giocatori[2].ruolo = difensore;
giocatori[3].numero = 1;
giocatori[3].goal = 9;
giocatori[3].ruolo = portiere;
numGiocatori = 4;
/* Fine DATI. */
for (i = 0; i < numGiocatori; i++)
{
printf ("Giocatore: %u, ruolo: %u, goal: %u\n",
giocatori[i].numero, giocatori[i].ruolo,
giocatori[i].goal);
if (giocatori[i].ruolo != portiere)
{
totaleGoalFatti = totaleGoalFatti +
giocatori[i].goal;
if (giocatori[i].ruolo == attaccante)
{
goalAttaccanti = goalAttaccanti +
giocatori[i].goal;
}
else if (giocatori[i].ruolo == centrocampista)
{
goalCentrocampisti = goalCentrocampisti +
giocatori[i].goal;
}
else
{
21
goalDifensori = goalDifensori +
giocatori[i].goal;
}
}
else
{
totaleGoalSubiti = totaleGoalSubiti +
giocatori[i].goal;
}
}
printf ("Goal fatti: %u\n", totaleGoalFatti);
printf ("Attacco: %u, centrocampo: %u, difesa: %u\n",
goalAttaccanti, goalCentrocampisti, goalDifensori);
printf ("Goal subiti: %u\n", totaleGoalSubiti);
}
3.5 Schedine
Testo
Il programma, partendo da un array, di dimensione prefissata, che contiene in ogni cella:
- codice giocata
- data della giocata
- colonna con i tredici segni
copia in un altro vettore solo le giocate dell’anno 2002.
Quindi, visualizza queste giocate.
NOTA: assumiamo che l’utente inserisca tutti i segni della colonna (‘1’, ‘x’ o ‘2’) in una volta sola
e quindi prema ENTER.
Implementazione
#include <stdio.h>
void main()
{
const unsigned int NUMSEGNI = 13, NUMGIOCATE = 3;
const unsigned int ANNOCERCATO = 2002;
typedef struct
{
unsigned int giorno;
unsigned int mese;
unsigned int anno;
} TipoData;
typedef struct
{
unsigned int codice;
TipoData data;
char colonna[NUMSEGNI];
} Giocata;
Giocata giocate[NUMGIOCATE], trovate[NUMGIOCATE];
unsigned int i, k, j = 0;
for (i = 0; i < NUMGIOCATE; i++)
{
22
printf ("Codice: ");
scanf ("%u", &giocate[i].codice);
printf ("Giorno mese anno: ");
scanf ("%u", &giocate[i].data.giorno);
scanf ("%u", &giocate[i].data.mese);
scanf ("%u", &giocate[i].data.anno);
scanf ("%*c"); /* butto via ENTER rimasto in stdin*/
printf ("Colonna: ");
for (k = 0; k < NUMSEGNI; k++)
{
scanf ("%c", &giocate[i].colonna[k]);
}
}
for (i = 0; i < NUMGIOCATE; i++)
{
if (giocate[i].data.anno == ANNOCERCATO)
{
trovate[j] = giocate[i];
j++;
}
}
for (i = 0; i < j; i++)
{
printf ("Cod: %u ", trovate[i].codice);
printf ("Data: %u/%u/%u\n", trovate[i].data.giorno,
trovate[i].data.mese,
trovate[i].data.anno);
for (k = 0; k < NUMSEGNI; k++)
{
printf ("%c ", trovate[i].colonna[k]);
}
printf ("\n");
}
}
23