Il rapporto (o il suo inverso) tra -2.5 e vale Soluzione. #include <stdio.h> typedef enum{false, true} bool;

Transcript

1 Esercizio 1 Scrivere un programma C che legge da tastiera una sequenza di numeri reali; la lettura termina quando la somma dei numeri immessi è maggiore di 50, e comunque non si possono immettere più di 100 numeri (se anche dopo avere immesso 100 numeri la loro somma non supera 50 la lettura termina comunque). Dopo avere letto tutti i numeri, se l utente ha inserito almeno 3 valori, cercare se esiste una coppia di numeri tali che il loro rapporto (o il suo inverso) sia uguale al primo numero immesso e, se esiste, stamparla. Esempio di funzionamento del programma: Inserisci numero: 6.25 Inserisci numero: -2.5 Inserisci numero: 20 Inserisci numero: Inserisci numero: Inserisci numero: 4 Inserisci numero: Il rapporto (o il suo inverso) tra -2.5 e vale #include <stdio.h> typedef enum{false, true bool; #define MAX_NUM 100 #define MAX_SUM 50 #define TOL main(){ float dati[max_num], sum = 0, rapp, inv_rapp; int i, j, n_dati; bool trovata = false; n_dati = 0; do { printf("inserisci numero: "); scanf("%f", &dati[n_dati]); sum += dati[n_dati]; n_dati++; while (sum <= MAX_SUM && n_dati < MAX_NUM); if (n_dati >= 3) { i = 1; while (!trovata && i<n_dati-1) { j = i+1; while (!trovata && j<n_dati) { if (dati[i] == 0 dati[j] == 0) { if (dati[0] == 0) { trovata = true; else {

2 %f\n, rapp = dati[i]/dati[j]; inv_rapp = dati[j]/dati[i]; if (rapp - dati[0] < TOL && rapp - dati[0] > -TOL inv_rapp - dati[0] < TOL && inv_rapp - dati[0] > -TOL) { trovata = true; if (trovata == true) { printf( Il rapporto (o il suo inverso) tra %f e %f vale j++; i++; dati[i], dati[j], dati[0]); else { printf( Sono stati inseriti solo %d elementi\n, n_dati); Esercizio 2 Si vogliono definire i tipi di dato che servono per contenere le informazioni di un pubblico registro automobilistico dedicato ai motoveicoli. I tipi da definire sono i seguenti. TipoDatiMotoveicolo rappresenta i dati di un motoveicolo. Questi dati si compongono di: targa del motoveicolo (7 lettere), marca del motoveicolo (massimo 15 caratteri), modello (massimo 20 caratteri), cilindrata (in cc), potenza (in kw), categoria (motorino, scooter, motocicletta, motocarro). TipoDatiProprietario rappresenta i dati di una persona (il proprietario del motoveicolo): nome (massimo 30 caratteri), cognome (massimo 40 caratteri), codice fiscale (16 caratteri). TipoVocePRA rappresenta una singola voce nel registro automobilistico; una voce si compone di 2 elementi, i dati del proprietario del motoveicolo ed i dati del motoveicolo stesso. TipoPRA rappresenta un tipo adatto a contenere i dati di un PRA. Questo tipo di dati è un elenco di voci del PRA (si suppone che un PRA non possa contenere più di elementi), più un contatore che dice quante voci sono effettivamente presenti nel PRA. (se si ritiene utile, si possono definire altri tipi di dati, di supporto a quelli richiesti) typedef enum {motorino, scooter, motocicletta, motocarro TipoCategoria; char targa[7] char marca[15] char modello[20]

3 int cilindrata; float potenza; TipoCategoria categoria; TipoDatiMotoveicolo; char nome[30]; char cognome[40]; char codice_fiscale[16]; TipoDatiProprietario; TipoDatiMotoveicolo motoveicolo; TipoDatiProprietario proprietario; TipoVocePRA; TipoVocePRA elementi[10000]; int n_elementi; TipoPRA; Esercizio 3 Siano P, Q, R, tre puntatori a interi e x, y due variabili intere. Si dica quanto valgono rispettivamente x, y, *P, *Q, *R dopo l esecuzione della seguente sequenza di istruzioni. x = 3; y = 5; P = &x; Q = &y; R = P; *R = 10; y = x + *Q; x = x + *P; Q = R; P = Q Al termine dell esecuzione della sequenza di istruzioni le variabili valgono: x = 20, y = 15, P, Q, R puntano tutti a x e quindi *P = *Q = *R = 20. Esercizio 4 Scrivere un programma C che esegue le seguenti operazioni. Legge da tastiera una sequenza di esattamente 64 pacchetti di 4 bit ciascuno (si ricorda che un pacchetto di 4 bit altro non è che una sequenza di 4 interi che possono assumere solo i valori 0 o 1). Un pacchetto è ammissibile solo se contiene solo 0 e 1; pacchetti non ammissibili vanno reimmessi. Un pacchetto ammissibile è detto corretto se e solo se il numero di 1 in tutto il pacchetto è pari.

4 Il programma, quindi, per ogni pacchetto ammissibile, verifica se il pacchetto è corretto, e, dopo avere letto tutti i pacchetti, stampa prima i pacchetti corretti, quindi quelli scorretti. #define MAX_PACC 64 typedef int TipoPacchetto[4]; typedef enum {false, true bool; main() { TipoPacchetto corretti[max_pacc], non_corretti[max_pacc], corrente; int i, j, k, h, somma, n_corretti, n_non_corretti; bool ammissibile; i = 0; j = 0; k = 0; while(i<max_pacc) { printf( Pacchetto numero %d (4 bit, separare i singoli bit con degli spazi):, i+1); scanf( %d %d %d %d, &corrente[0], &corrente[1], &corrente[2], &corrente[3]); ammissibile = true; somma = 0; for(h=0 ; h<4 ; h++) { if(corrente[h] > 1 corrente[h] < 0) { ammissibile = false; else { somma += corrente[h]; if(ammissibile) { if (somma % 2 == 0) { for(h=0 ; h<4 ; h++) { corretti[j][h] = corrente[h]; j++; else { for(h=0 ; h<4 ; h++) { non_corretti[k][h] = corrente[h]; k++; i++; else { printf( Pacchetto immesso non ammissibile, reimmetterlo!\n ); n_corretti = j; n_non_corretti = k; printf( Pacchetti corretti:\n ); for(j=0 ; j<n_corretti ; j++) { for(h=0 ; h<4 ; h++) {printf( %d, corretti[j][h]); printf( \n ); printf( Pacchetti NON corretti:\n ); for(j=0 ; j<n_non_corretti ; j++) { for(h=0 ; h<4 ; h++) {printf( %d, non_corretti[j][h]); printf( \n );

5 Esercizio 5 Si abbia un file (binario) FileFatture contenente fatture. Ogni fattura sia del tipo TipoFatture dichiarato qui sotto. unsigned int NumFattura; char Nome[30]; char Cognome[40]; float Importo; char PartitaIva [12]; /*altri campi irrilevanti per l esercizio*/ TipoFatture; Si scriva una procedura che aggiorna una (e una sola!) fattura del file cambiandone l importo da Lire a Euro (si ricorda che un Euro vale 1936,27 Lire). La procedura riceve come parametro il numero d ordine della fattura nel file (si assuma che il numero di fattura denotato dal campo NumFattura- sia anche la posizione assunta dalla fattura nel file, cioè che la fattura numero 1 sia la prima, quella numero 2 la seconda, ecc.). Prima di procedere alla codifica della procedura si dichiarino eventuali variabili globali da essa utilizzate. Si supponga che il file sia già aperto al momento della chiamata della procedura. FILE *file_fatture; void aggiorna(unsigned int num_ord) { TipoFatture fattura; long pos_corr; pos_corr = ftell(file_fatture); fseek(file_fatture, sizeof(tipofatture)*(num_ord-1), SEEK_SET); fread(&fattura, sizeof(tipofattura), 1, file_fatture); fattura.importo = fattura.importo/ ; fseek(file_fatture, sizeof(tipofatture)*(num_ord-1), SEEK_SET); fwrite(&fattura, sizeof(tipofattura), 1, file_fatture); fseek(file_fatture, pos_corr, SEEK_SET); /*anche se non esplicitamente richiesto, la procedura lascia inalterata la posizione corrente del file*/ Esercizio 6 Si definisca un tipo di dato Giocattolo costituito dal nome del giocattolo (ad esempio Trenino_elettrico ), dalla data di fabbricazione, e dal prezzo. Se necessario, si definiscano in precedenza ulteriori tipi di dato utili per la definizione del tipo Giocattolo.

6 Si definisca poi un nuovo tipo Bambino, costituito dal nome del bambino e da una sequenza GiocattoliPosseduti. Tale sequenza è costituita a sua volta da un array di 10 elementi, ognuno dei quali essendo un puntatore al tipo Giocattolo. Si dichiarino successivamente due variabili, Giocattoli e Bambini, consistenti in due array, rispettivamante di MaxGiocattoli elementi del tipo Giocattolo e MaxBambini elementi del tipo Bambino. MaxGiocattoli e MaxBambini, pure da definire, sono i due valori costanti 20 e 30. Si può assumere che nè i nomi dei giocattoli, nè i nomi dei bambini siani più lunghi di 30 caratteri. #define MaxGiocattoli 20 #define MaxBambini 30 int giorno; int mese; int anno; Data; typedef char string[30]; string nome; Data datafabbricazione; float prezzo; Giocattolo; string nome; Giocattolo *GiocattoliPosseduti[10]; Bambino; Giocattolo Giocattoli[MaxGiocattoli]; Bambino Bambini[MaxBambini]; Esercizio 7 Con riferimento all esercizio 6, si scriva un frammento di programma C che: Legga da tastiera, mediante opportuno dialogo con l utente, il nome di un bambino e, se questo compare nell elenco dei bambini, stampa l elenco dei nomi dei giocattoli da lui posseduti. Nello scrivere il frammento di programma (ossia una sequenza di istruzioni che non costituisce necessariamente un programma completo) si assuma che l elenco dei bambini e l elenco dei giocattoli siano costituiti dalle variabili Bambini e Giocattoli già in memoria. Per semplicità si può assumere che l utente non commetta errori durante il dialogo con la macchina (ad esempio non fornisca nomi troppo lunghi).

7 Si facciano inoltre le seguenti assunzioni: Ogni stringa di caratteri che costituisca un nome (di giocattolo o di bambino) sia terminata dal carattere A capo ( \r ) Se il bambino possiede solo k giocattoli, k < 10, gli ultimi 10 k puntatori valgono NULL. La variabile NumBambini, che pure si assume sia già in memoria, contiene il numero di bambini effettivamente presenti nell elenco dei bambini. Un esempio di dialogo utente-programma è il seguente (NB: dopo aver battuto i caratteri che compongono il nome del bambino l utente batte il tasto A capo ) Immetti il nome di un bambino: Giovanni I giocattoli posseduti da Giovanni sono: Trenino_elettrico Cavallo_a_dondolo #include <stdio.h> #define. typedef. main () { Giocattolo Giocattoli[MaxGiocattoli]; Bambino Bambini[MaxBambini]; string NomeBambino; boolean trovato; int i, k, j, LunghNomeBamb, NumBambini; /* NumBambini indica il numero di bambini presenti nell elenco*/... /* parte di programma omessa. Comprenderà, tra l altro, * il dialogo utente-macchina per acquisire i dati e memorizzarli * nelle variabili Giocattoli e Bambini*/ printf ( Immetti il nome del bambino di cui vuoi conoscere i giocattoli:\n ); i = 0; scanf("%c", & NomeBambino[i]); while (NomeBambino[i]!= '\r') { i++; scanf("%c", &NomeBambino[i]) LunghNomeBamb = i; /*Si cerca nell array Bambini il nome immesso*/ trovato = false; k = 0;

8 while (! trovato && k < NumBambini) { for(i = 0; i <= LunghNomeBamb && Bambini[k].nome[i] == NomeBambino[i]; i++){; /*Si incrementa i finché la condizione rimane vera*/ if (i > LunghNomeBamb){ trovato = true; else { k++; if (! trovato){ printf ( Il bambino indicato non compare nell elenco\n ); else { printf ( I giocattoli posseduti dal bamino sono:\n ); i = 0; while (i<10 && Bambini[k].GiocattoliPosseduti[i]!= NULL) { for (j = 0; j < 30 && Bambini[k].GiocattoliPosseduti[i]->nome[j]!= \r ; j++){ printf ( %c, Bambini[k].GiocattoliPosseduti [i] -> nome[j]); i++; printf ( \n ), /*fine del frammento di programma*/... Esercizio 8 Scrivere un programma che legge da tastiera due sequenze di caratteri alfabetici minuscoli (non sono ammessi numeri, segni di punteggiatura, ecc.) separate dal carattere di spazio ed anche terminate dal carattere di spazio, e dice all'utente se le due parole sono una l'anagramma dell'altro. Nella sequenza sono ammesse ripetizioni della stessa lettera. Si trascuri il fatto che le parole possano avere un significato in italiano oppure no. Si supponga pure che l'utente non inserisca mai parole più lunghe di 50 caratteri. Se l'utente inserisce simboli non ammessi, questi vanno ignorati. Esempio di funzionamento: Inserisci le parole (separate e terminate da uno spazio): terkmit<spazio>mertkit<spazio> Le due parole sono una l'anagramma dell'altra. main () { char prima_parola[50], seconda_parola[50];

9 char curr; int l1 = 0, l2 = 0, i, j; int sono_anagrammi, trovato; printf("inserisci le parole (separate e terminate da uno spazio)\n"); do { scanf("%c", &curr); if (curr >= 'a' && curr <= 'z') { prima_parola[l1] = curr; l1++; while(l1<50 && curr!= ' '); do { scanf("%c", &curr); if (curr >= 'a' && curr <= 'z') { seconda_parola[l2] = curr; l2++; while(l2<50 && curr!= ' '); sono_anagrammi = 1; i = 0; while(sono_anagrammi && i<l1){ trovato = 0; j = 0; while(!trovato && i<l2){ if(prima_parola[l1] == seconda_parola[l2]){ trovato = 1; seconda_parola[l2] = '#'; j++; if (!trovato) sono_anagrammi = 0; i++; if(sono_anagrammi == 1) printf("le due parole sono una l'anagramma dell'altra.\n"); else printf("le due parole NON sono una l'anagramma dell'altra.\n"); Esercizo 9 Si definisca(no) i(l) tipi(o) di dato che serve(ono) per contenere le informazioni relative al listino prezzi di un concessionario di motocicli che fa anche officina meccanica. Per ogni modello di motociclo venduto devono essere definiti: nome del modello (massimo 30 caratteri), marca (massimo 20 caratteri), codice identificativo (10 cifre), prezzo, cilindrata (in cc), elenco dei pezzi sostituibili del motociclo. Di ogni pezzo sostituibile devono essere definiti: descrizione del pezzo (massimo 100 caratteri), codice identificativo (10 cifre), prezzo, numero di giorni in cui il pezzo arriva se ordinato, ore di lavoro necessarie per la sostituzione. Si supponga pur che il numero delle parti sostituibili di un motociclo sia al massimo 50. typedef char TipoCodice[10]; char descrizione[100]; TipoCodice codice; unsigned int prezzo;

10 unsigned int ritardo_ordine; unsigned int ore_lavoro; TipoPezzo; char nome[30]; char marca[20]; TipoCodice codice; unsigned int prezzo; unsigned int cilindrata; TipoPezzo pezzi_sost[50]; unsigned int n_pezzi_sost; TipoMotociclo; Esercizio 10 Con riferimento all'esercizio 9 si scriva un sottoprogramma che prende in ingresso la descrizione di un motociclo ed un elenco di codici di pezzi da sostituire, e ritorna: il costo totale della sostituzione, sapendo che ogni ora di lavoro costa 20 euro; il numero di giorni che bisogna aspettare per avere la riparazione efettuata nell'ipotesi che tutti i pezzi siano da ordinare, e che la riparazione possa essere fatta in giornata una volta che tutti i pezzi arrivano; un codice che è 0 se il calcolo fallisce (per esempio se uno dei codici di pezzo da sostituire non è in realtà un pezzo del motociclo), 1 altrimenti. Qualunque sottoprogramma ausiliaro (che non faccia parte della libreria standard del C) che viene eventualmente usato nel sottoprogramma precedente deve essere definito nella sua interezza. int calcolacosto (TipoMotociclo moto, TipoCodice pezzi[], unsigned int npezzi, unsigned int *costo, unsigned int *giorni){ TipoPezzo pezzo; int i; unsigned int c_parz = 0, g_parz = 0; for (i = 0; i<npezzi ; i++){ if(trovapezzo(moto.pezzi_sost, moto.npezzi, pezzi[i], &pezzo) == 0){ return 0; c_parz += pezzo.prezzo; if (pezzo.ritardo_ordine > g_parz){ g_parz = pezzo.ritardo_ordine; *costo = c_parz; *giorni = g_parz + 1; /* contiamo anche il giorno per la riparazione */

11 return 1; /* La seguente funzione prende in ingresso un elenco di pezzi * ed un codice di pezzo e ritorna il tipo di pezzo presente * nella lista (se presente). * Se il codice non e' presente nella lista ritorna 0, altrimenti 1. */ int trovapezzo( TipoPezzo pezzi[], unsigned int npezzi, TipoCodice cod, TipoPezzo *pezzo){ int i; if (pezzi == NULL) return 0; for (i = 0 ; i<npezzi; i++){ if (strcmp(pezzi[i].codice, cod) == 0) { *pezzo = pezzi[i]; return 1; return 0; Esercizio 11 Definire un tipo di dato TipoStrumentista che descrive i dati relativi ad un musicista jazz. Ogni musicista è definito da un nome (massimo 40 caratteri), da una data di nascita, e dallo strumento che suona. Ogni musicista suona un solo strumento, ed il tipo di strumento suonato può essere solo uno dei seguenti (non sono ammessi altri strumenti): pianoforte, basso, batteria, sax, tromba, trombone, flauto, clarinetto, voce. Definire un tipo TipoQuartetto che contiene i dati relativi ad un quartetto di musicisti. Ogni quartetto è caratterizzato da un nome (al massimo 30 caratteri) e da esattamente 4 musicisti (non uno di più, non uno di meno). Definire infine una variabile ElencoQuartetti che può contenere al massimo 100 quartetti. (se si ritiene utile, si possono definire altri tipi di dati, di supporto a quelli richiesti) #define L_NOME_MUS 40 #define L_NOME_QUAR 30 #define MAX_QUARTETTI 100 short giorno; short mese; int anno; TipoData; typedef enum {pianoforte, basso, batteria, sax, trombone, flauto, clarinetto, voce TipoStrumento;

12 char nome[l_nome_mus+1]; TipoData data_nascita; TipoStrumento strumento; TipoStrumentista; char nome[l_nome_quar+1]; TipoStrumentista musicisti[4]; TipoQuartetto; TipoQuartetto ElencoQuartetti[MAX_QUARTETTI]; Esercizio 12 Scrivere un frammento di programma C che, per ogni quartetto senza pianoforte (cioè in cui nessuno strumentista suona il pianoforte) presente nell'elenco ElencoQuartetti, stampa a video il nome del quartetto. In seguito stampa a video il nome di tutti i quartetti con pianoforte. Nel realizzare il frammento di programma si supponga che la variabile ElencoQuartetti di cui al punto precedente sia già stata inizializzata (sia cioè già stata caricata di dati, che non devono essere riletti da tastiera), e si supponga inoltre che un'altra variabile numquartetti, di tipo int (anch'essa già inizializzata) contenga il numero di quartetti effettivamente inseriti in ElencoQuartetti. main() { TipoQuartetto ElencoQuartetti[MAX_QUARTETTI]; int numquartetti[max_quartetti]; /* inizializzazione delle variabili sopra dichiarate, * da considerare già fatta */ TipoQuartetto QuartettiSenzaPiano[MAX_QUARTETTI]; TipoQuartetto QuartettiConPiano[MAX_QUARTETTI]; int numquarsenzapiano = 0, numquarconpiano = 0, i, j, trovato; for (i=0; i<numquartetti; i++){ j = 0; trovato = 0; while (trovato == 0 && j<4){ if (ElencoQuartetti[i].musicisti[j].strumento == pianoforte){ trovato = 1; j++; if (trovato == 0) { QuartettiSenzaPiano[numQuarSenzaPiano] = ElencoQuartetti[i]; numquarsenzapiano++; else { QuartettiConPiano[numQuarConPiano] = ElencoQuartetti[i]; numquarconpiano++;

13 printf( Quartetti senza piano:\n ); for (i=0; i<numquarsenzapiano; i++){ printf( %s\n, QuartettiSenzaPiano[i].nome); printf( Quartetti con piano:\n ); for (i=0; i<numquarconpiano; i++){ printf( %s\n, QuartettiConPiano[i].nome); Esercizio 13 Si definiscano i tipi TipoStrumentista e TipoQuartetto come nell'esercizio 11. Si definisca inoltre un tipo TipoConcerto costituito dal nome della località in cui il concerto si è tenuto (massimo 40 caratteri), dalla data in cui si è tenuto il concerto, e dal quartetto che ha tenuto il concerto. #define L_NOME_MUS 40 #define L_NOME_QUAR 30 #define MAX_QUARTETTI 100 short giorno; short mese; int anno; TipoData; typedef enum {pianoforte, basso, batteria, sax, trombone, flauto, clarinetto, voce TipoStrumento; char nome[l_nome_mus+1]; TipoData data_nascita; TipoStrumento strumento; TipoStrumentista; char nome[l_nome_quar+1]; TipoStrumentista musicisti[4]; TipoQuartetto; #define L_NOME_CONC 40 char nome_loc[l_nome_conc+1]; TipoData data; TipoQuartetto quartetto; TipoConcerto;

14 Esercizio 14 Si supponga di avere un file binario contenente un elenco di concerti. Si supponga inoltre che il file sia già stato aperto in modalità (binaria) lettura/scrittura. Si risolva uno (ed uno solo) dei seguenti punti. Variante a Dopo avere dichiarato eventuali variabili globali, definire una funzione CancellaConcertiDiQuartetto che riceve in ingresso il nome di un quartetto, e crea un nuovo file (sempre binario), di nome NuovaListaConcerti.dat, contenente l'elenco di tutti i concerti esclusi quelli del quartetto il cui nome è stato passato alla funzione. La funzione ritorna 1 se l'operazione è andata a buon fine, 0 altrimenti. Il file originario con l'elenco dei concerti rimane immutato. Variante b Dopo avere dichiarato eventuali variabili globali, definire una funzione CancellaConcertiDiQuartetto che riceve in ingresso il nome di un quartetto, e cancella dal file con l'elenco dei concerti tutti i concerti tenuti dal quartetto il cui come è stato passato alla funzione. La funzione ritorna 1 se l'operazione è andata a buon fine, 0 altrimenti; essa modifica il file originario con l'elenco dei concerti. In questa variante è ammesso (anzi, è consigliato) aprire file temporanei, in aggiunta al file originario. Variante c Dopo avere dichiarato eventuali variabili globali, definire una funzione CancellaConcertiDiQuartetto che riceve in ingresso il nome di un quartetto, e cancella dal file con l'elenco dei concerti tutti i concerti tenuti dal quartetto il cui come è stato passato alla funzione. La funzione ritorna 1 se l'operazione è andata a buon fine, 0 altrimenti; essa modifica il file originario con l'elenco dei concerti. In questa variante non è ammesso aprire file temporanei aggiuntivi, si può lavorare solo sul file originario. Aiuto per le varianti b e c: per troncare un file f alla lunghezza data dalla posizione corrente nel file, l istruzione da usare è la seguente: ftruncate(fileno(f), ftell(f)); variante a #include <string.h> #include <stdio.h> FILE *f_concerti; int CancellaConcertiDiQuartetto(char nome_quar[]){ TipoConcerto curr_conc;

15 FILE *nf = fopen( NuovaListaConcerti.dat, wb ); if (nf == NULL) return 0; rewind(f_concerti); while (!feof(f_concerti)){ if (fread(&curr_conc, sizeof(tipoconcerto), 1, f_concerti) == 1){ if (strcmp(curr_conc.quartetto.nome, nome_quar)!= 0) { if (fwrite(&curr_conc, sizeof(tipoconcerto), 1, nf)!= 1){ fclose(nf); return 0; else { fclose(nf); return 0; if (fclose(nf) == 0) return 1; else return 0; variante b #include <string.h> #include <stdio.h> FILE *f_concerti; int CancellaConcertiDiQuartetto(char nome_quar[]){ TipoConcerto curr_conc; FILE *tmp_f = fopen( _temp.dat, wb+ ); if (tmp_f == NULL) return 0; rewind(f_concerti); while (!feof(f_concerti)){ if (fread(&curr_conc, sizeof(tipoconcerto), 1, f_concerti) == 1){ if (strcmp(curr_conc.quartetto.nome, nome_quar)!= 0) { if (fwrite(&curr_conc, sizeof(tipoconcerto), 1, tmp_f)!= 1){ fclose(tmp_f); return 0; else { fclose(tmp_f); return 0; rewind(f_concerti); rewind(tmp_f); while (!feof(tmp_f)){ if (fread(&curr_conc, sizeof(tipoconcerto), 1, tmp_f) == 1) { if (fwrite(&curr_conc, sizeof(tipoconcerto), 1, f_concerti)!= 1) { fclose(tmp_f); return 0; else { fclose(tmp_f); return 0; /* tronco il file all ultima posizione in cui ho scritto * (il file riscritto è in generale più corto * del file originario) */ ftruncate(fileno(f_concerti), ftell(f_concerti)); if (fclose(tmp_f) == 0) return 1; else return 0;

16 variante c #include <string.h> #include <stdio.h> FILE *f_concerti; int CancellaConcertiDiQuartetto(char nome_quar[]){ TipoConcerto curr_conc; /* tengo due indici nel file: la prossima posizione in cui devo * scrivere (pos_next_write) e la prossima posizione da cui devo * leggere (pos_next_read) */ long pos_next_write, pos_next_read; rewind(f_concerti); pos_next_write = ftell(f_concerti); while (!feof(f_concerti)){ if (fread(&curr_conc, sizeof(tipoconcerto), 1, f_concerti) == 1) { if (strcmp(curr_conc.quartetto.nome, nome_quar)!= 0) { /* se il concerto è da mantenere, lo riscrivo nel file * f_concerti alla prossima posizione in cui devo scrivere. * Prima di scrivere, però, devo memorizzare la poszione * corrente nel file, perchè a questa posizione dovrò poi * tornare per ricominciare a leggere. */ pos_next_read = ftell(f_concerti); /* mi sposto nel file alla posizione in cui devo scrivere, * e poi effettivamente scrivo. */ if (fseek(f_concerti, pos_next_write, SEEK_SET)) return 0; if (fwrite(&curr_conc, sizeof(tipoconcerto), 1, f_concerti)!= 1) return 0; /* memorizzo la posizione corrente, che è la prossima posizione * in cui dovrò scrivere, e mi riporto nella posizione che è la * prossima da cui devo leggere */ pos_next_write = ftell(f_concerti); if (fseek(f_concerti, pos_next_read, SEEK_SET)) return 0; else { return 0; /* mi riporto sulla posizione che è la prossima in cui scrivere * (cioè appena dopo l ultimo concerto che va conservato, e tronco il * file (il file riscritto è in generale più corto del file originario */ if (fseek(f_concerti, pos_next_write, SEEK_SET)) return 0; ftruncate(fileno(f_concerti), ftell(f_concerti)); return 1; Esercizio 15 Si definisca un tipo di dato ContoCorrente contenente, tra l altro, almeno i seguenti campi: Numero del CC Nome dell intestatario Importo presente sul CC

17 Si definisca poi un sottoprogramma che riceva come parametro un numero di CC e un aggiornamento opportunamente codificato (ad esempio, un numero relativo, oppure un qualificatore deposito/prelievo seguito da un valore assoluto) ed apporti l aggiornamento richiesto ad un file, supposto già aperto ed il cui descrittore è contenuto in una variabile globale, di record di tipo ContoCorrente. Come può cambiare il sottoprogramma nell ipotesi che nel file il numero di CC coincida con la posizione occupata dal record (record relativo al CC # 0 in posizione 0, ecc.)? Parte facoltativa Si descriva sinteticamente, senza necessariamente codificare l intero sottoprogramma, come si potrebbe modificare il sottoprogramma se i parametri di ingresso fossero numero di conto e nome dell intestatario, ma uno dei due potesse mancare. Si considerino sia il caso in cui ogni persona possa essere intestatario al più di un solo CC sia il caso opposto. Sarebbe un sottoprogramma siffatto il modo migliore per affrontare il problema nella realtà quando l utente si presenta allo sportello fornendo solo uno dei dati suddetti? In caso negativo che alternativa proporreste? int CC; char intestatario[50]; double importo; ContoCorrente; typedef enum {fale, true boolean; boolean aggiorna(int n_cc, double variazione){ ContoCorrente curr; while(fread(&curr, sizeof(contocorrente), 1, file) == 1){ if (curr.cc == n_cc){ curr.importo += variazione; fseek(file, -sizeof(contocorrente), SEEK_CUR); if(fwrite(&curr, sizeof(contocorrente), 1, file) == 1){ return true; else { return false; return false; Se il numero di conto corrente coincide con la posizione nel file, il programma va modificato come segue: boolean aggiorna(int n_cc, double variazione){ ContoCorrente curr; if(fseek(file, sizeof(contocorrente)*n_cc, SEEK_SET)!= 0){

18 return false; if (fread(&curr, sizeof(contocorrente), 1, file)!= 1) return false; curr.importo += variazione; fseek(file, -sizeof(contocorrente), SEEK_CUR); if(fwrite(&curr, sizeof(contocorrente), 1, file) == 1){ return true; else { return false; Parte facoltativa L intestazione del sottoprogramma andrebbe modificata come segue: boolean aggiorna(int *n_cc, char intestatario[], double variazione) Il numero di conto corrente viene passato come puntatore adesso, per dare la possibilità di mettere NULL nel caso in cui non si voglia specificare alcun numero di conto corrente. Nel caso in cui sia il numero di conto che il nome del correntista vengono passati al sottoprogramma, nel ciclo while che va a trovare i dati del conto corrente da modificare occorre verificare se entrambi coincidono con i dati del conto appena letto. In caso positivo, si effettua la modifica, altrimenti, se non è possibile che una persona abbia intestati più conti correnti, viene segnalato un errore. Se invece una persona può avere intestati più conti correnti, si continua nella ricerca. Se invece uno solo tra numero di conto e nome dell interstatario è specificato, la verifica viene fatta con quello che c è e basta (e non è possibile fare la contro-verifica che i dati siano consistenti tra di loro). Se però è possibile che un correntista abbia più conti correnti e viene passato solo il nome dell intestatario, occorre verificare se esistono più CC con lo stesso intestatario e, in tal caso, sollevare un errore; altrimenti si può procedere con l aggiornamento. Un sottoprogramma siffatto non sarebbe la soluzione migliore. La soluzione migliore sarebbe di avere tre sottoprogrammi separati, uno che prende in ingresso solo il numero di conto corrente, uno che accetta solo il nome dell intestatario, ed uno che li accetta entrambi. Il main, o un sottoprogramma opportuno eventualmente interattivo, dovrebbe decidere quale dei sottoprogrammi è appropriato. Esercizio 16 Si consideri un programma contenente, tra l altro, la seguente dichiarazione int x

19 si consideri poi la seguente sequenza di istruzioni appartenente al programma: P1 = &x; P = &P1; *P1 = 10; **P = *P1 + 2*x; printf (, **P); Parte 1 Si completi la parte dichiarativa del programma con le dichiarazioni necessarie a far sì che il programma venga compilato con successo senza segnalazioni di errore e neanche warnings ed eseguito. Si completi inoltre l istruzione printf con la parte mancante indicata dai puntini, in modo che essa provochi la stampa del valore indicato da **P. Parte 2 Assumendo che prima dell esecuzione della sequenza di istruzioni x contenga il valore 5, si dica quale valore viene stampato dalla istruzione finale printf. parte 1 int *P1; int **P; printf ( Il contenuto della cella puntata dalla cella puntata dal puntatore P è %d \n, **P) parte 2 Dopo i primi due assegnamenti P1 punta a x e P punta a sua volta a P1. Il terzo assegnamento deposita perciò il valore 10 in x. Il quarto fa riferimento ancora ad x sia attraverso il doppio puntamento **P che attraverso il puntamento semplice P1. Perciò il valore *10 = 30 viene depositato in x e successivamente stampato. Esercizio 17 Si scriva un programma C che esegue le seguenti operazioni. Legge da tastiera una sequenza di caratteri lunga al massimo 12 caratteri e terminata da '*' e determina se: 1. la sequenza corrisponde ad un numero di telefono (cioè se è composta solo da numeri, non da altri caratteri) 2. il numero corrisponde ad un cellulare o ad un telefono fisso (un numero di telefono fisso inizia sempre per '0', tutti gli altri si possono considerare numeri di cellulare). Esempio di funzionamento del programma:

20 Inserisci numero: Il numero immesso corrisponde ad un telefono fisso. #include <stidio.h> #define MAX_C 12 main() { char n_tel[max_c]; char curr; int i, n_c, flag; /* flag e' uguale a 1 se la sequenza di caratteri contiene * solo cifre, 0 altrimenti */ flag = 1; printf("inserisci numero: "); n_c = 0; do { scanf("%c", &curr); if (curr!= '*') { n_tel[n_c] = curr; n_c++; if (curr < '0' curr > '9') { flag = 0; while(n_c < MAX_C && curr!= '*'); if (flag == 0 n_c == 0) { printf ("la sequenza inserita NON corrisponde ad un numero di telefono\n"); else { if (n_tel[0] == '0') { printf("il numero immesso corrisponde ad un telefono fisso\n"); else { printf("il numero immesso corrisponde ad un telefono cellulare\n"); Esercizio 18 Siano date le variabili x1, x2, y1, y2, rispettivamente di tipo <tipo_x1>, <tipo_x2>, <tipo_y1>, <tipo_y2> ed i sottoprogrammi P1 e P2: int P1(int **p1, int *p2, int p3){ x1 = x1 + **p1 + *p2 + p3; return **p1 + *p2 + p3;

21 int P2(int **p1, int *p2, int p3){ x2 = x2 + **p1 + *p2 + p3; p2 = &p3; return **p1 + *p2 + p3; Sia dato il corrispondente main: int main(){ x1 = 1; y1 = &x1; x2 = 1; y2 = &x2; x1 = P1(&y1, y1, x1); x2 = P2(&y2, y2, x2); printf("valore di x1: %<codice_x1>; \n Valore di x2: %<codice_x2>"); a. Si completi il programma costituito dai sottoprogrammi P1, P2 e main con adeguate parti dichiarative e direttive in modo che il programma possa essere compilato ed eseguito correttamente. b. Si dica poi, spiegandone il perchè, quali sono i valori stampati dalla printf finale del main. punto a. /* variabili globali */ int x1; int x2; int main(){ int *y1; int *y2; /*... */ printf("valore di x1: %d; \n Valore di x2: %d"); punto b. Il valore di x1 è 9, quello di x2 6. Infatti, quando viene invocato P1 la situazione è la seguente:

22 x1 1 y1 p1 p2 p3 1 Siccome P1 non cambia la struttura dei puntatori, in P1 prima viene assegnato a x1 il valore =4, poi viene ritornato il valore = 9. Quando P2 viene invocato, invece, la situazione è la seguente: x2 1 y2 p1 p2 p3 1 P2 però cambia la struttura dei puntatori dopo che a x2 è assegnato il valore =4, e la modifica come segue: x2 4 y2 p1 p2 p3 1 Quindi P2 ritorna il valore 4+1+1=6. Esercizio 19 Si definisca un tipo di dato ContoCorrente contenente, tra l altro, almeno i seguenti campi: Numero del CC Nome dell intestatario Importo presente sul CC Si definisca anche un tipo di dato AggiornamentoCC che descrive le operazioni di deposito/prelievo che possono venire effettuate su un conto corrente. AggiornamentoCC deve contenere le informazioni riguardo a quale conto corrente viene aggiornato, e al tipo di aggiornamento viene effettuato (deposito/prelievo e la somma depositata/prelevata).

23 Si definisca poi un sottoprogramma che riceve come parametri i descrittori di due file, uno contenente dei record di tipo ContoCorrente ed uno contenente dei record di tipo AggiornamentoCC. Sapendo che in entrambi i file i record sono ordinati in modo crescente secondo il numero di conto corrente, il sottoprogramma legge gli aggiornamenti dal file apposito, e li applica ai conti correnti i cui dati sono memorizzati nell'altro file. Si supponga che: nel file con gli aggiornamenti non ci possano essere due aggiornamenti riguardanti lo stesso conto corrente; non necessariamente ci sia un aggiornamento per ogni conto corrente; ci possano essere aggiornamenti relativi a conti correnti inesistenti. int CC; char intestatario[50]; double importo; ContoCorrente; int CC; double importoagg; AggiornamentoCC; typedef enum {false, true bool; bool aggiornadafile(file *conti, FILE *agg){ ContoCorrente conto_corr; AggiornamentoCC agg_corr; bool stop = false; rewind(conti); rewind(agg); if (feof(conti) feof(agg)) return true; if (fread(&conto_corr, sizeof(contocorrente), 1, conti)!= 1) return false; if (fread(&agg_corr, sizeof(aggiornamentocc), 1, agg)!= 1) return false; while(!stop){ if (agg_corr.cc == conto_corr.cc){ conto_corr.importo += agg_corr.importo; fseek(conti, -sizeof(contocorrente), SEEK_CUR); if(fwrite(&curr, sizeof(contocorrente), 1, file)!= 1) return false; if (feof(conti) feof(agg)) { stop = true; else { if (fread(&conto_corr, sizeof(contocorrente), 1, conti)!= 1) return false; if (fread(&agg_corr, sizeof(aggiornamentocc), 1, agg)!= 1) return false; else if(agg_corr.cc < conto_corr.cc) { if (feof(agg)) { stop = true; else { if (fread(&agg_corr, sizeof(aggiornamentocc), 1, agg)!= 1) return false;

24 else { if (feof(conti)) { stop = true; else { if (fread(&conto_corr, sizeof(contocorrente), 1, conti)!= 1) return false; return true; Esercizio 20 Scrivere un programma che legge da tastiera una sequenza di esattamente 10 numeri razionali, ognuno formato da numeratore e denominatore (sia numeratore che denominatore devono essere numeri interi) e: a) verifica che tutti abbiano denominatore diverso da zero; b) se tutti i numeri hanno denominatore diverso da zero stampa a video: a. la media dei numeri che sono interi (cioè con numeratore multiplo del denominatore) b. il prodotto di tutti i numeri int num; int den; TipoRazionale; typedef enum{false, true bool; main() { TipoRazionale seq[10]; int i, int n_int = 0; double media = 0.0; TipoRazionale prod; bool flag = true; for (i=0; i<10; i++){ printf("inserisci numero razionale nella forma <numeratore/denominatore>: "); scanf("%d/%d", &seq[i].num, &seq[i].den); if (seq[i].den == 0) flag = false; if (flag){ for (i=0; i<10; i++){ if (seq[i].num%seq[i].den == 0){ n_int++;

25 media += seq[i].num/seq[i].den; prod.num = prod.num * seq[i].num; prod.den = prod.den * seq[i].den; if (n_int > 0) media = media / n_int; printf("media numeri interi: %f\n", media); printf("prodotto numeri: %d/%d\n", prod.num, prod.den); Esercizo 21 parte a Si definisca(no) i(l) tipi(o) di dato che serve(ono) per contenere le informazioni relative alla carriera dei calciatori militanti in serie A. Per ogni calciatore devono essere definiti: Nome, Cognome, Data di nascita, Elenco dei dati delle stagioni giocate in Serie A (per ogni stagione giocata in serie A deve essere definito: anno, squadra in cui si è giocato, numero di partite giocate, numero di gol segnati), Media dei gol segnati per anno. Si assuma pure che un giocatore, in una stagione, gioca per al massimo una squadra. parte b Si scriva un sottoprogramma che prende in ingresso un file binario (supposto già aperto sia in letture che in scrittura) contenente i dati di tutti i calciatori di serie A, privi della media dei gol segnati per anno e lo aggiorna inserendo nell apposito campo la media suddetta. parte a short giorno; short mese; unsigned int anno; TipoData; char nome[30]; char cognome[30]; TipoData data_nascita; TipoStagione stagioni[30]; int n_stagioni; float media_gol; TipoGiocatore; int anno; char squadra[20]; int n_partite; int n_gol; TipoStagione;

26 parte b void clacolamedie(file *f){ rewind(f); TipoGiocatore g; while(fread(&g, sizeof(tipogiocatore), 1, f) == 1){ g.media_gol = clacolamediagol(g.stagioni, n_stagioni); fseek(biblio, -(sizeof(tipogiocatore)), SEEK_CUR); fwrite(&g, sizeof(tipogiocaotre), 1, f); Laddove la funzione calcolamediagol è definita come segue: float clacolamediagol(tipostagione s[], int num_stag){ int i; float somma = 0; for(i =0; i<num_stag; i++) somma += s[i].n_gol; if(num_stag > 0) return somma/n_stag else return 0; Esercizio 22 Si definiscano i seguenti tipi di dati. IstitutoOspedaliero, caratterizzato da un nome e da un indirizzo, e che può essere o privato o pubblico. Medico: ogni medico ha un nome e un indirizzo, e può essere o un medico della mutua, oppure no. Se il medico non è della mutua, questi afferisce ad un istituto ospedaliero (se invece il medico è della mutua, non afferisce ad alcun ospedale). Paziente, caratterizzato da un nome e da un codice identificativo alfanumerico di 10 caratteri; ogni paziente ha un medico della mutua, ed ha al massimo 20 ricoveri in ospedale. Un ricovero in ospedale (descritto dal tipo di dato Ricovero) si caratterizza per una data di inizio ricovero, una data di fine ricovero, l'istituto ospedaliero in cui il ricovero è stato effettuato e, eventualmente, l'operazione chirurgica effettuata (l'operazione chiurgica durante un ricovero è opzionale, ci può essere oppure no). Un'operazione chirurgica si caratterizza per la data in cui viene effettuata, il medico che la esegue, ed ha associata una descrizione a parole che dice di che cosa l'operazione è consistita. typedef enum{false, true bool; char nome[50]; char indirizzo[70];

27 bool privato; IstitutoOspedaliero; char nome[30]; char indirizzo[70]; bool dellamutua; IstitutoOspedaliero *istituto; Medico; char nome[30]; char id_sanitario[10]; Medico med; Ricovero ricoveri[20]; Paziente; TipoData inizio; TipoData fine; IstitutoOspedaliero ospedale; Operazione *op; Ricovero; TipoData data; Medico med; char descr[200]; Operazione; Esercizio 23 Sia dato un tipo di file di tipo testo (file di caratteri), contenente un elenco di record relativi a dei medici, ognuno con i seguenti dati: nome, indirizzo, si/no a seconda che il medico sia della mutua oppure no. Se il medico non è della mutua, il file contiene anche il nome e l'indirizzo dell'istituto ospedaliero a cui fa riferimento, ed il fatto che questo sia pubblico o privato ("si" se è pubblico, "no" se è privato). Ogni dato (nome indirizzo, ecc.) si trova una riga diversa, e ogni record termina con una riga contenente un #. Un esempio di record è il seguente: Mario Ferrari Corso Plebisciti, 12, Milano si # Umberto Veronesi via della Spiga, 4, Milano

28 no Istituto Oncologico Europeo via Ripamonti 435, Milano no # Si scriva una procedura che prende in ingresso il nome di un file del tipo di cui sopra, e crea un file binario "istitutiospedalieri" che contiene una serie di elementi di tipo IstitutoOspedaliero. Gli elementi di tipo IstitutoOspedaliero scritti nel file "istitutiospedalieri" sono tutti e soli gli istituti che compaiono nel file di tipo testo il cui nome è ricevuto in ingresso, scritti in un ordine a discrezione dello studente. Bonus di 3 punti se il file "istituti ospedalieri" è creato in modo che un istituto ospedaliero compaia al massimo una volta nel file (cioè se non ci sono ripetizioni di istituti ospedalieri). void scrivi_ospedali (char file_medici[]){ FILE *f_med, *f_osp; char temp[100]; char mutua[3]; char privato[3]; IstitutoOspedaliero ist; f_med = fopen(file_medici, "r"); f_osp = fopen("istitutiospedalieri", "wb"); while(!feof(f_med)){ /* le righe delle quali non mi interessa il contenuto le memorizzo * in un array 'temp' grande * a sufficienza per contenere tutte le stringhe di interesse. */ fgets(temp, 30, f_med); fgets(temp, 70, f_med); fgets(mutua, 3, f_med); if(strcmp(mutua, "no") == 0){ fgets(ist.nome, 50, f_med); fgets(ist.indirizzo, 70, f_med); fgets(privato, 3, f_med); if(strcmp(privato, "si") == 0){ ist.privato = true; else { ist.privato = false; /* versione semplice, che non si preoccupa di evitare possibili * ripetizioni dello stesso istituto ospedaliero nel file di output. */ fwrite(&ist, sizeof(istitutoospedaliero), 1, f_osp); /* suppongo che il formato del file sia corretto, e non faccio alcuna * verifica sul fatto che la prossima riga contenga esattamente un '#' * oppure no. Un'alternativa sarebbe di controllare che la riga inizi * effettivamente per '#', e ritornare un errore in caso contrario. */ fgets(temp, 80, f_med);

29 fclose(f_osp); fclose(f_med); Se avessi voluto evitare di avere ripetizioni di istituti ospedalieri nel file di output mi sarei potuto appoggiare sulla seguente procedura ausiliaria istituto_presente, che riceve in ingresso il descrittore di un file binario (gia' aperto sia in lettura che in scrittuta) contente i dati di istituti ospedalieri, ed il nome di un istituto ospedaliero, e ritorna true se nel file esiste un record corrispondente al nome passato. Si noti che, se l'istituto non viene trovato, il cursore del file si trova in fondo al file stesso, altrimenti si trova sull'elemento appena successivo a quello con nome uguale a quello passato come parametro. bool istituto_presente(file *file, char nome_osp[]){ IstitutoOspedaliero ist; rewind(file); while(!feof(file)){ fread(&ist, sizeof(istitutoospedaliero), 1, file); if(strcmp(ist.nome, nome_osp) == 0) return true; return false; Avendo a disposizione la procedura istituto_presente, al posto della semplice fwrite, nel corpo della procedura scrivi_ospedali va sostituito il seguente pezzo di codice: if(!istituto_presente(f_osp, ist.nome)) { fwrite(&ist, sizeof(istitutoospedaliero), 1, f_osp); Si noti inoltre che il file "istitutiospedalieri" in questo caso non puo' essere piu' aperto solo in scrittura, ma anche in lettura, quindi la chiamata alla fopen di "istitutiospedalieri" va modificata sostituendo al posto della modalita' di apertura "wb" la modalita' "wb+" come illustrato di seguito: f_osp = fopen("istitutiospedalieri", "wb+"); Esercizio 24 Si considerino le seguenti dichiarazioni: typedef int *tipo1; int x, y; int *a; tipo1 b; Si dica, per ognuna delle seguenti sequenze di istruzioni C, se essa è corretta o no; in caso positivo si dica qual è il risultato prodotto; in caso negativo si dica in che cosa consiste l errore e se si tratta di errore a compile-time o a run-time.

30 Sequenza 1: x = 0; y = 1; a = NULL; b = x; a = b; printf ( il valore di x e y è, rispettivamente, %d, %d, \n, x, y); Sequenza 2: scanf ( %d, &y); a = NULL; x = 0; if (y > 0) {b = a; x = *b + y; printf ( il valore di x e y è, rispettivamente, %d, %d, \n, x, y); Sequenza 3: a = &y; x = 2; y = 5; b = a; a = NULL; *b = y + x; printf ( il valore di x e y è, rispettivamente, %d, %d, \n, x, y); Sequenza 1: è scorretta in quanto l'assegnamento b=x non ha senso (b è un puntatore ad intero, x è un intero. Questo è un errore a compile-time (lo riconosce il compilatore). Sequenza 2: è scorretta in quanto, se il valore y immesso dall'utente è > 0, prima viene eseguito l'assegnamento b=a (in cui b va a puntare a NULL, in quanto a era stato inizializzato a NULL), e poi si cerca di dereferenziare b (*b), che però non è ammissibile in quanto b punta a NULL. Questo è un errore a run-time (lo si trova solo facendo girare il programma e fornendo in ingresso un valore di y > 0). Sequenza 3: è corretta, e stampa 2 per x e 7 per y. Infatti, prima dell'istruzione *b=y+x si ha una situazione in cui x vale 2, y vale 5, b punta a y, a punta a NULL. Quindi l'assegnamento mette il valore 7 (5+2) nella variabile puntata da b, che è y. Esercizio 25 Si scriva un programma che: Legge dallo StandardInput due stringhe di caratteri (lunghe al massimo 100 caratteri l'una) separate tra loro dal carattere speciale (non appartenente alle stringhe) # e terminate dallo stesso carattere '#' (si supponga pure che l'utente non immetta mai stringhe più lunghe di 100 caratteri). Verifica che le lunghezze delle due stringhe (senza contare il carattere '#') differiscano al massimo di un unità. In caso contrario interrompa l esecuzione scrivendo sullo StandardOutput un opportuno messaggio. Scriva sullo StandardOutput una stringa ottenuta alternando i caratteri delle due stringhe di ingresso (un carattere di una stringa seguito da un carattere dell altra mantenendo l ordine originario tra i caratteri della stessa stringa) secondo la regola seguente: o Se una delle due stringhe è più lunga dell altra si deve cominciare con il primo carattere della stringa più lunga. o Se le due stringhe sono di lunghezza uguale, si può cominciare con una qualsiasi delle due.

31 o Facoltativamente, se la stringa risultante è più lunga di 80 caratteri, ogni 80 caratteri scritti si deve andare a capo. #include <stdio.h> #define MAX_L 100 main () { char s1[max_l], s2[max_l], curr; int n_el1=0, n_el2=0; int i; do{ scanf("%c", &curr); if (curr!= '#'){ s1[n_el1] = curr; n_el1++; while(curr!= '#'); do{ scanf("%c", &curr); if(curr!= '#'){ s1[n_el2] = curr; n_el2++; while(curr!= '#'); if(n_el1-n_el2 <= 1 && n_el1-n_el2 >= -1){ /* caso in cui la stringa 1 è più lunga della stringa 2 */ if(n_el1 > n_el2){ for (i=0; i<n_el2; i++){ printf("%c%c", s1[i], s2[i]); if(((i+1)*2) % 80 == 0) printf("\n"); /* chiude il for */ printf("%c, s1[n_el1-1]) else { /*n_el2 >= n_el1*/ for (i=0; i<n_el1; i++){ printf("%c%c", s2[i], s1[i]); if(((i+1)*2) % 80 == 0) printf ("\n"); /* chiude il for */ /*se le due stringhe sono di lunghezza diversa*/ if(n_el2 > n_el1) printf ("%c, s2[n_el2-1]); /* chiude il ramo else dell if precedente*/ else { printf ("Le lunghezze delle stringhe differiscono tra loro di più di una unità"); Esercizio 26 Si scriva un programma che, non facendo uso di accesso diretto a file (ossia usando esclusivamente le funzioni di libreria fopen, fclose, fread, fwrite e rewind), dato un file di interi "InputInteri" produca un nuovo file "OutputInteri" contenente gli stessi elementi del file

32 di ingresso ma scritti in ordine inverso. Si assuma che la memoria centrale non sia sufficientemente grande da contenere l intero file ma possa contenerne circa i 2/3. NB: 1. Tra le varie possibili soluzioni saranno valutate meglio quelle più efficienti. 2. E auspicata una soluzione che faccia uso di opportuni sottoprogrammi. Alcuni di essi, eventualmente, potrebbero essere definiti anche solo parzialmente mediante pseudocodice, evitando una codifica completa. 3. Eventualmente si può assumere l ipotesi semplificativa che la dimensione del file sia nota a priori e valga la costante K. In tal caso il punteggio massimo dell esercizio viene diminuito di 1 punto. main () { /* elinfile calcola il numero di interi nel file binario f * (supposto gia' aperto in sola lettura). */ long int elinfile(file *f); /* readarrayfromfile prende in ingresso il descrittore di un file binario * (supposto aperto lettura) ed un array di interi, e legge n_el * interi dal file, memorizzandoli * nell'array (supposto grande a sufficienza per contenere i dati). */ void readarrayfromfile(file *f, int *ar, long int n_el); /* reversearrayinfile prende in ingresso il descrittore di un file * binario (supposto vuoto e aperto in sola scrittura) ed un array di * interi di lunghezza n_el e scrive il contenuto dell'array nel file, * partendo dall'ultimo elemento dell'array fino al primo. */ void reversearrayinfile(file *f, int *ar, long int n_el); /* appendfile prende in ingresso i descrittori di due file binari * fromfile ed infile, il primo aperto in lettura, il secondo in * scrittura, e scrive gli elementi del primo file in fondo al secondo, * mantenendo l'ordine in cui essi compaiono nel primo. */ void appendfile(file *fromfile, FILE *infile); FILE *in, *out, *tempfile; int *tempar; long int tot_n_el, n_el; in = fopen("inputinteri", "rb"); out = fopen("outputinteri", "wb"); tot_n_el = elinfile(in); n_el = tot_n_el/2 + 1; tempar = malloc(sizeof(int)*n_el); rewind(in); readarrayfromfile(in, tempar, n_el); tempfile = fopen("_tf", "wb+"); reversearrayinfile(tempfile, tempar, n_el); n_el = tot_n_el - n_el; readarrayfromfile(in, tempar, n_el); reversearrayinfile(out, tempar, n_el); appendfile(tempfile, out);

33 fclose(in); fclose(out); fclose(temp); long int elinfile(file *f){ int temp; long int res = 0; rewind(f); while(fread(&temp, sizeof(int), 1, f) == 1){ res++; return res; void readarrayfromfile(file *f, int *ar, long int n_el){ long int i; for(i=0 ; i<n_el ; i++){ fread(&ar[i], sizeof(int), 1, f); /* oppure, in alternativa, si poteva risolvere tutto con una * istruzione singola: * fread(ar, sizeof(int), n_el, f); */ void reversearrayinfile(file *f, int *ar, long int n_el){ long int i; for(i=n_el-1 ; i>=0 ; i--){ fwrite(&ar[i], sizeof(int), 1, f); void appendfile(file *fromfile, FILE *infile){ int temp; rewind(fromfile); while(fread(&temp, sizeof(int), 1, fromfile) == 1){ fwrite(&temp, sizeof(int), 1, infile); Esercizio 27 Parte a. Definire dei tipi di dato per contenere informazioni relative a patenti e multe. Una patente è definita da un numero identificativo, dal nome del proprietario, dal suo codice fiscale, da una data di rilascio e una di scadenza, e da un numero di punti ancora disponibili sulla patente. Una multa è definita da un numero identificativo, dal numero identificativo della patente cui viene addebitata, dalla data in cui è stata emessa, dall'ammontare della multa (in euro), dal numero di punti da togliere alla patente a causa della multa. Parte b. Codificare un sottoprogramma che prende in ingresso i descrittori fpat e fmul di 2 file (entrambi supposti aperti sia in lettura che in scrittura), uno contenente una serie di patenti, ed uno contenente una serie di multe, e ritorna il descrittore di un nuovo file.