Per quanto riguarda il secondo esercizio ho già fatto il programma e sembra funzionare
/********************************************************************************/
/* Progetto esame di Marino Giulio*/
/********************************************************************************/
/* Esercizio numero 2. */
/* Corso universitario. */
/*Questo algoritmo gestisce giornalmente le assenze effettuate dagli studenti durante un corso universitario
con durata di 20 giorni. Per ogni studente sono associati questi dati : nome,cognome,matricola,assenze,luogo
di nascita,data di nascita,indirizzo di residenza.
Inoltre sono consentite tre operazioni,oltre alla gestione delle assenze.
La prima operazione consente di stampare i dati e le presenze totali di tutti gli studenti.
La seconda operazione,dato un nome e un cognome,ricerca questo studente,e stampa tutti i dati e le assenze totali
relative allo studende ricercato.
La terza operazione consente di stampare il nome e il cognome dello studente che ha effettuato piu assenze durante
il corso. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define lungh_elenco 10
struct data
{
short giorno;
char *mese;
int anno;
};
struct indirizzo
{
int cap;
int n_civico;
char *strada;
};
struct studente
{
char *nome;
char *cognome;
int matricola;
int assenze;
char *luogo_nascita;
struct data data_nascita;
struct indirizzo dati_ind;
//Per memorizzare le informazioni di ogni studente.
//viene utilizzato un array di struct.
}elenco[lungh_elenco]={
{"Giulio","Marino",10,0,"Napoli",30,"settembre",1992,80023,1,"via rosselli"},
{"Nunzia","Esposito",9,0,"Casavatore",20,"novembre",1993,80021,1,"via dei mille"},
{"Giovanna","Amoruso",8,0,"Napoli",3,"novembre",1993,80010,3,"via fortunato"},
{"Sabato","Russo",7,0,"Sarno",10,"dicembre",1993,80010,4,"via Marche"},
{"Ferdinando","Izzo",6,0,"Girona",16,"aprile",1992,80100,5,"via Girona"},
{"Eduardo","Astro",5,0,"Napoli",20,"maggio",1994,80010,6,"via Tigre"},
{"Maurizio","Lesto",4,0,"Napoli",17,"aprile",1993,80010,70,"via Cerreto"},
{"Concetta","Mobili",3,0,"Napoli",30,"giugno",1993,80010,89,"via Piemonte"},
{"Luigi","Rossi",2,0,"Napoli",24,"maggio",1993,80010,45,"via Leone"},
{"Maria","Verdi",1,0,"Napoli",26,"aprile",1993,80010,14,"via Sapone"},
};
void assenze_corso(struct studente *);
void visualizza(struct studente * );
int ricerca_stud(struct studente *, char *,char *);
int max_assenze(struct studente *,int );
int max_I(int ,int );
int main()//INIZIO MAIN.
{
//BLOCCO DICHIARAZIONE VARIABILI.
int scelta_operazione;//VARIABILE PER SCEGLIERE L'OPERAZIONE CHE L'UTENTE VUOLE EFFETTURARE.
int i;//VARIABILE CONTATORE DEL CICLO FOR.
int i_trov;//VARIABILE CHE CONTIENE L'INDICE DELLO STUDENTE CHE SI RICHIEDE LA RICERCA.
int i_max;//VARIABILE CHE CONTIENE L'INDICE DELLO STUDENTE CHE HA FATTO PIU ASSENZE.
int risp_while;//VARIABILE CHE CONTIENE IL VALORE DI USCITA DEL CICLO WHILE.
int n=lungh_elenco;//VARIABILE CHE CONTIENE LA LUNGHEZZA DELL'ARRAY DI STRUCT.
char cognome[20],nome[20];//STRINGHE CHE CONTENGONO I VALORI DI RICERCA INSERITI DA INPUT.
printf("\nBenvenuto nel programma per la gestione delle assenze di un corso universitario\n\n\n\n");
assenze_corso(elenco);//CHIAMATA DELLA FUNCTION ASSENZE_CORSO,PER LA GESTIONE DELLE ASSENZE.
//ELENCO MESSAGGI A VIDEO PER LA SCELTA DELL'UTENTE DELL'OPERAZIONE DA EFFETTUARE.
printf("\nElenco operazione effettuabili :");
printf("\n\nOperazione numero 1: stampa i dati e le presenze totali di tutti gli studenti;\n\n");
printf("\n\nOperazione numero 2: inserisci un nome e un cognome per visualizzare i relativi dati e le relative assenze dello studente;\n\n");
printf("\n\nOperazione numero 3: stampa il nome e il cognome dello studente che ha fatto piu assenze durante il corso universitario;\n\n");
do
{
//ASSEGNAZIONE DELLA SCELTA DELL'OPERAZIONE.
printf("\nInserire il numero dell' operazione che si vuole effetture ");
scanf("%d",&scelta_operazione);
//SWITCH PER ESEGUIRE L'OPERAZIONE SCELTA.
switch(scelta_operazione)
{
case 1:
//STAMPA DI TUTTI GLI STUDENTI.
{
printf("\n\nElenco degli studenti del corso universitario\n\n");
visualizza(elenco);//CHIAMATA DELLA FUNCTION PER LA VISUALIZZAZIONE DELL'ARRAY DI STRUCT
};break;
case 2:
//DATO UN NOME E UN COGNOME DI UNO STUDENTE DA INPUT RICERCA SUOI DATI E LE SUE ASSENZE TOTALI.
{
//ACQUISIZIONE DEL COGNOME E DEL NOME DA RICERCARE.
printf("\nInserisci il cognome da ricercare dello studente\n");
fflush(stdin);
gets(cognome);
printf("\nInserisci il nome da ricercare dello studente\n");
gets(nome);
i_trov=ricerca_stud(elenco,cognome,nome);//CHIAMATA DELLA FUNCTION PER LA RICERCA DELLO STUDENTE.
if (i_trov==-1)
//SE L'UTENTE NON E' STATO TROVATO LA FUNCTION RICERCA_STUD RESTITUISCE IL VALORE -1.
printf("\nLo studente ricercato non e' presente nell' elenco\n");
else
{
//STAMPA DELLO STUDENTE CHE SI E' RICHIESTA LA RICERCA.
printf("\nDati dello studente ricercato:\n");
printf("%s %s\nMatricola:%d\nNumero di assenze:%d",elenco[i_trov].nome,elenco[i_trov].cognome,elenco[i_trov].matricola,elenco[i_trov].assenze);
printf("\nNato a %s il giorno %d %s %d",elenco[i_trov].luogo_nascita,elenco[i_trov].data_nascita.giorno,elenco[i_trov].data_nascita.mese,elenco[i_trov].data_nascita.anno);
printf("\nResidente in %s %d, C.A.P. %d\n\n",elenco[i_trov].dati_ind.strada,elenco[i_trov].dati_ind.n_civico,elenco[i_trov].dati_ind.cap);
printf("\n");
}
};break;
case 3:
//STAMPA IL NOME E COGNOME DELLO STUDENTE CHE HA EFFETTUATO PIU ASSENZE DURANTE IL CORSO.
{
i_max=max_assenze(elenco,n);//ASSEGNAZIONE A i_max DEL VALORE MASSIMO DI ASSENZE PRESENTE NELL'ARRAY DI STRUCT.
for (i=0;i<lungh_elenco;i++)//CICLO FOR PER LA STAMPA DELLO STUDENTE CHE HA EFFETTUATO PIU' ASSENZE.
if( i_max==elenco[i].assenze)//CONTROLLO SE IL VALORE MASSIMO DI ASSENZE E' UGUALE A QUELLO DELLO STUDENTE DI POSTO I-ESIMO.
{
//SE E' UGUALE, ALLORA STAMPA DEI DATI DELLO STUDENTE CHE HA EFFETTUATO PIU ASSENZE.
printf("\nDati dello studente che ha effattuato piu assenze:\n");
printf("%s %s\nMatricola:%d\nNumero di assenze:%d",elenco[i].nome,elenco[i].cognome,elenco[i].matricola,elenco[i].assenze);
printf("\nNato a %s il giorno %d %s %d",elenco[i].luogo_nascita,elenco[i].data_nascita.giorno,elenco[i].data_nascita.mese,elenco[i].data_nascita.anno);
printf("\nResidente in %s %d, C.A.P. %d\n\n",elenco[i].dati_ind.strada,elenco[i].dati_ind.n_civico,elenco[i].dati_ind.cap);
printf("\n");
}
};break;
}//FINE SWITCH.
printf("\nPer eseguire un altra operazione cliccare 1,per uscire cliccare 0 ");
scanf("%d",&risp_while);
}
//CICLO DO WHILE CHE RIPETE LE OPERAZIONI FINCHE' NON SI SCEGLIE DI USCIRE.
while(risp_while!=0); //FINE DO WHILE.
}//FINE DEL MAIN.
/********************************* FUNCTION **************************************/
void assenze_corso (struct studente *elenco)
/*Questa function gestisce le assenze degli studenti usando l'approccio incrementale
per indicare ogni giorno del corso e ogni studente del corso.Infatti ci sono due cicli for concatenati,
uno che simula la durata del corso (20 giorni) e l'altro,che ogni giorno,scorre tutto l'elenco
degli studenti del corso,aggiungendo ogni giorno,il valore 1 se lo studente e' assente.
Cosi' alla fine del corso avremo la somma totale delle assenze di ogni studente.
Inoltre per simulare le assenze durante il corso,viene usata la function C Rand che genera due valori:
0 ( alunno presente) e 1(alunno assente),che poi vanno sommate al relativo studente giorno per giorno.
A questa function viene passato l'array di strutture e in output non restiuisce nessun valore,
ma va a modificare, per indirizzo,il campo assenze di ogni array di strutture. */
{
int i,j;
int assenza_casuale;
int seed;
/*INSERIMENTO DA OUTPUT DEL SEME CHE GENERERA' LE ASSENZE IN MODO PSEUDOCASUALE*/
printf("\nInserire un valore,detto seme, per simulare le assenze durante il corso ");
scanf("%d",&seed);
srand(seed);//IN BASE A QUESTO SEME si GENERERA' UNA SEQUENZA DI VALORI PSEUDOCASUALI.
for(i=0;i<20;i++) //CICLO FOR PER LA DURATA DEL CORSO (20 GIORNI).
for(j=0;j<lungh_elenco;j++)
{//CICLO FOR PER SCORRERE TUTTO L'ELENCO DEGLI STUDENTI,QUESTO CICLO VERRA' EFFETTUATO PER L'INTERA DURATA DEL CORSO.
assenza_casuale=rand()%2;//LA FUNCTION RAND,FACENDO MODULO 2, CI RESTITUIRà SOLO I VALORI 0(PRESENTE) E 1(ASSENTE).
elenco[j].assenze=(elenco[j].assenze+assenza_casuale);//IN QUESTO MODO ABBIAMO UN CONTATORE DI ASSENZE PER OGNI STUDENTE.
//CODICE PER LA GESTIONE MANUALE DELLE ASSENZE DEL CORSO
/* printf("\n IL GIORNO %d DEL CORSO LO STUDENTE DI POSTO %d-SIMO NELL' ELENCO DEL CORSO,SE LO STUDENTE E' PRESENTE PREMERE 0 ALTRIMENTI 1\n",i,j);
scanf("%d",&assenza_manuale) //BISOGNA DICHIARARE ASSENZA MANUALE
elenco[j].assenze=(elenco[j].assenze+assenza_manuale); */
}
}//FINE FUNCTION
void visualizza(struct studente *elenco)
{
/*Questa function esegue l'approccio incrementale per visualizzare tutti i dati di ogni studente,
viene usato un ciclo for per stampare ogni volta tutti i dati relativi a uno studente.
Non restituisce nessun valore,e viene passato l'array di strutture. */
int i;
for(i=0;i<lungh_elenco;i++)
{
printf("\nDati dello studente al %d-simo posto\n",i+1);
printf("%s %s\nMatricola:%d\nNumero di presenze:%d",elenco[i].nome,elenco[i].cognome,elenco[i].matricola,(20-elenco[i].assenze));//20-ASSENZE,IN MODO CHE CI TROVIAMO LE PRESENZE TOTALI,E NON LE ASSENZE.
printf("\nNato a %s il giorno %d %s %d",elenco[i].luogo_nascita,elenco[i].data_nascita.giorno,elenco[i].data_nascita.mese,elenco[i].data_nascita.anno);
printf("\nResidente in %s %d, C.A.P. %d\n\n",elenco[i].dati_ind.strada,elenco[i].dati_ind.n_civico,elenco[i].dati_ind.cap);
printf("\n");
}
printf("\n\n");
}//FINE FUNCTION
int ricerca_stud(struct studente *elenco, char *cognome,char *nome)
/*Questa function usa la ricerca sequenziale con approccio iterativo per la ricerca di uno studente,
le vengono passate la struttura e le due chiavi(cognome e nome),inserite da input,e ritorna
un valore intero che corrisponde all'indice dello studente se è stato trovato;
se non è stato trovato alcuno studente che corrisponda con i dati immessi da input
allora ritornerà il valore -1.*/
{
int i=0;
int ind_trov=-1;
do{
if(strcmp(elenco[i].cognome,cognome)==0) //CONTROLLA CHE IL COGNOME DELL'ELENCO DI POSTO I-ESIMO E' UGUALE A QUELLO INSERITO DA INPUT.
//SE I DUE COGNOMI SONO UGUALI:
if(strcmp(elenco[i].nome,nome)==0) //CONTROLLA CHE IL COGNOME DELL'ELENCO DI POSTO I-ESIMO E' UGUALE A QUELLO INSERITO DA INPUT.
ind_trov=i;//SE ENTRAMBI I CONTROLLI RISULTANO VERI ALLORA L'INDICE DELLO STUDENTE DA RICERCARE AVRA' INDICE i.
i++;
}
while(ind_trov<-1||i<lungh_elenco);//CICLO DO-WHILE CHE RIPETE FINCHE' L'INDICE TROVATO E' DIVERSO DA -1 O FINCHE' i SIA MINORE DELLA LUNGHEZZA DELL'ELENCO(30).
return ind_trov;//RITORNA IL VALORE DELL'INDICE.
}//FINE FUNCTION.
int max_assenze(struct studente *elenco,int n)
/*Questa function calcola il massimo valore relativo al campo assenze dell'array di strutture.
Questa function e' costruita con approccio divide et impera,utilizzando la tecnica di programmazione ricorsiva.
Le viene passato l'array di strutture e il size dell'array di struttura e ritorna il valore massimo di assenze
effettuate dagli studenti.*/
{
int med;//DICHIARAZONE DELLA VARIABILE MEDIANO
if(n==1) //CASO BANALE,SE n E' UGUALE AL VALORE 1
{
return elenco[0].assenze; //RITORNA IL PRIMO ELEMENTO DI CAMPO ASSENZE DELL'ARRAY DI STRUCT
}
else //AUTOATTIVAZIONE SE n E' DIVERSO DAL VALORE 1
{
med=(n-1)/2; //CALCOLO DELL'ELEMENTO MEDIANO
return max_I(max_assenze(elenco,med+1),max_assenze(elenco+med+1,n-med-1)); //RITORNA IL VALORE MASSIMO TRA DUE VALORI, CHE VERRANNO PASSATI DALLE RISPETTIVE AUTOATTIVAZIONI ALLA FUNCTION max_i.
//COME VEDIAMO IL VALORE DI n DELLA FUNCTION MAN MANO DIVENTA PIU PICCOLO FINCHE' NON E' UGUALE AL CASO BANALE CIOè n==1.
}
}//FINE FUNCTION
int max_I(int a,int b)
/*Questa function calcola il massimo tra due numeri interi,e ritorna il numero maggiore tra i due.*/
{
if (a<b)
return b;//B E' MAGGIORE DI A.
else
return a;//A E' MAGGIORE DI B.
}