Raccolta di alcuni esercizi proposti nei temi d esame di Informatica 1 nell anno accademico 2000/01

Transcript

1 Raccolta di alcuni esercizi proposti nei temi d esame di Informatica 1 nell anno accademico 2000/01 Esercizio 1 Simulare l esecuzione di ciascuna delle 5 chiamate a sottoprogrammi, limitandosi alla descrizione dei valori stampati tramite le printf. int vara = 100; int proc1(int); int proc2(int *); int proc3(int); void proc4(int, int*); main() { int varb=0, varc=50; /* situazione iniziale */ printf ("\n0) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 1 */ varb = proc1(varc); printf ("\n1) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 2 */ varb = proc2(&varc); printf ("\n2) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 3 */ varb = proc3(varc); printf ("\n3) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 4 */ varc = proc1(vara); printf ("\n4) vara = %d, varb = %d, varc = %d ", vara, varb, varc); int proc1(int par) { vara=vara+1; par = par - 10; return (par); int proc2(int *par) { *par = *par - 10; return (*par); int proc3(int par) { int vara; vara = par + 1; return (vara); 07/10/ :

2 Esercizio 2 Sia dato un vettore di strutture contenenti ciascuna la distanza tra due città A e B (inseriti dall utente). L utente inserisce il nome della città rispetto alla quale desidera conoscere la città più vicina, in base ai dati contenuti nell array di strutture. Visualizzare la città più vicina a quella specificata e la distanza tra le due città. #define N_CITTA 10 /* questa struttura contiene la distanza tra due citta' */ typedef struct { char cittaa[20]; char cittab[20]; int distanza; distanze; main() { distanze dati[n_citta]; /* vettore con le distanze tra varie citta */ char cercare[20]; /* nome della citta' da esaminare */ /* inserimento dei dati nell'array di strutture */ for (i=0;i<n_citta;i++) { printf("citta A [%d]:",i); scanf(" %s",dati[i].cittaa); printf("citta B [%d]:",i); scanf(" %s", dati[i].cittab); printf("distanza [%d]:",i); scanf(" %d", &dati[i].distanza); /* richiesta nome della citta' da esaminare */ printf("citta da esaminare :"); scanf(" %s", cercare); /* corpo del programma */ NOTA: Si supponga che le distanze non superino il valore Esercizio 3 Una lista circolare è una lista dinamica in cui l ultimo elemento punta al primo. Si scriva la procedura InvertiListaCirc che, ricevendo come parametro una lista circolare, la inverte senza creare un altra lista. Esercizio 4 Un Testo è rappresentato come un array di caratteri. Una Parola è rappresentata come un array di caratteri. Si scriva la funzione CercaParola che, ricevendo un Testo e una Parola come parametri, ricerca la Parola nel Testo: se la Parola viene trovata, ne restituisce la posizione (del primo carattere) nel Testo; in caso contrario viene restituito il valore 1. 07/10/ :

3 Esercizio 5 Il tipo ListaCifre, sotto definito, rappresenta un numero espresso in una base di numerazione b tramite una lista dinamica: ad esempio la sequenza rappresenta il numero duecentouno in base dieci e il numero dieci in base tre. Si realizzi la procedura DaDecimaleABase che costruisce la lista, passata per indirizzo, che rappresenta un numero decimale d in base b (si, utilizzi l intestazione sotto riportata). Due punti in più a chi fornisce una corretta soluzione ricorsiva. struct EL { int cifra; struct EL *prox; ; typedef struct EL ElemCifra; typedef ElemCifra *ListaCifre; void DaDecimaleABase (unsigned int d, unsigned int b, ListaCifre *ListPointer) { Esercizio 6 Spiegare i meccanismi della produzione di spazzatura (garbage) e dei riferimenti fluttuanti (dangling references) relativi alla programmazione tramite puntatori. Esercizio : 1 1: 1 1 2: : : : : : Nel triangolo di Tartaglia, ogni elemento (posto nella riga r e nella posizione p diversa da r e da 0) è dato dalla somma dei due elementi che occupano le posizioni p-1 e p sulla riga precedente (r-1). Per p=0 oppure p=r, l elemento è pari a 1. Si scriva la funzione Tartaglia che, ricevendo un parametro int riga e un parametro int posizione, calcola l elemento del triangolo di Tartaglia nella riga e nella posizione corrispondente. Ad esempio Tartaglia(2,0) restituisce 1, mentre Tartaglia(6,4) restituisce 15. Esercizio 8 Un Polinomio (di grado N) sia rappresentato da un array di N+1 float in cui ogni elemento rappresenta il coefficiente del termine il cui grado è dato dall indice dell elemento stesso. Un GrandePolinomio (di grado 2N) sia rappresentato da un array di 2N+1 float. Si scriva la funzione SommaPol che, ricevendo due Polinomi come parametri, restituisca un Polinomio dato dalla somma dei due Polinomi. Si scriva la funzione ProdottoPol che, ricevendo due Polinomi come parametri, restituisca un GrandePolinomio dato dal prodotto dei due Polinomi. Esercizio 9 Un Testo è rappresentato tramite una lista dinamica di caratteri. Una Parola è rappresentata da una lista dinamica di caratteri. Si scriva la funzione ricorsiva CercaParola che riceve un Testo e una Parola come parametri, cerca nel Testo i caratteri che costituiscono la Parola: i caratteri trovati possono anche essere separati da altri caratteri nel Testo, ma devono apparire nell ordine in cui appaiono nella Parola. La funzione deve restituire una lista di puntatori alle posizioni in cui i caratteri trovati appaiono nel Testo. Ad esempio, la parola botte nel testo vitroveretebenecolfruttodellaviteseneeviteretelabusonellavita si trova nelle posizioni indicate in grassetto, mentre la parola barile non si trova. 07/10/ :

4 Esercizio 10 Si consideri un file NOMI contenente dei record relativi all anagrafica di un certo numero di persone. I record all interno di tale file NON sono mantenuti ordinati rispetto al cognome. Vengono invece mantenute delle liste di record che raggruppano le anagrafiche relative alle persone che hanno il cognome che inizia con la stessa lettera. Ci saranno quindi tante liste di record quante sono le lettere dell alfabeto (considerare solo le maiuscole). Ogni record, quindi, oltre ai campi relativi all informazione vera e propria (cognome e nome), contiene un puntatore alla posizione assoluta nel file, del record successivo. L ultimo record di ciascuna lista contiene come posizione al record successivo il valore 1. Per sapere qual è il primo record di ogni lista, si ricorre a un secondo file, INDICE, che riporta per ogni lettera dell alfabeto, la posizione assoluta nel file NOMI del primo record della relativa lista. Se nel file NOMI non sono presenti anagrafiche relative a cognomi che iniziano con una certa lettera, il valore associato a tale campo per tale lettera sarà uguale a 1. Il file INDICE contiene sempre un record per ogni lettera. Sono date le strutture dei record dei due file: typedef struct { char lettera; long lista; rec_indice; typedef struct { char cognome[20]; char nome[20]; long succ; rec_nome; INDICE A 132 B -1 C 44 Z 0 NOMI ZULIANI CARLO -1 CRIPPA LUIGI 308 GIROLDI GIACOMO 352 ABATE FRANCO 660 CROTTA GIUSEPPE -1 MONTI MAURO 847 ANTERI PAOLO 2244 CROSIO ALDO 176 GUTTUSO IRENE -1 ROSSI GIOVANNI 1155 Nell esempio sopra riportato si vede come, partendo dal record relativo alla lettera C nel file INDICE, è possibile risalire al primo record del file NOMI associato a un cognome che inizia con la lettera C (CRIPPA, alla posizione 44) e da questo, tramite il proprio puntatore, ai successivi (CROSIO e CROTTA). Si scriva un programma che, richiesta all utente una lettera dell alfabeto (considerata sempre maiuscola) ricopi, utilizzando la struttura sopra esposta, i record del file NOMI che iniziano con quella lettera in una lista dinamica. Non è accettata la soluzione che legge il file sequenzialmente. Si descriva a parole cosa comporterebbe l inserimento nel file NOMI di una nuova anagrafica. Si ricerchi la soluzione che minimizza il numero di accessi ai file. Esercizio 11 Una Matrice (quadrata di ordine N) sia rappresentata da un array di N array di N float. Si scriva la funzione SommaMat che, ricevendo due Matrici come parametri, restituisca una Matrice data dalla somma delle due Matrici. Si scriva la funzione ProdottoMat che, ricevendo due Matrici come parametri, restituisca una Matrice data dal prodotto delle due Matrici. 07/10/ :

5 Esercizio 12 Simulare l'esecuzione di ciascuna delle 4 chiamate a sottoprogrammi, limitandosi alla descrizione dei valori stampati tramite le "printf". int X = 60; int p1(int); int p2(int *); int p3(int); main() { /* situazione iniziale */ int Y = 0, Z = 30; printf ("\n0) X = %d, Y = %d, Z = %d ", X, Y, Z); /* passo 1 */ X = p1(z); printf ("\n1) X = %d, Y = %d, Z = %d ", X, Y, Z); /* passo 2 */ Y = p2(&z); printf ("\n2) X = %d, Y = %d, Z = %d ", X, Y, Z); /* passo 3 */ Y = p3(z); printf ("\n4) X = %d, Y = %d, Z = %d ", X, Y, Z); /* passo 4 */ Y = p2(&y); printf ("\n5) X = %d, Y = %d, Z = %d ", X, Y, Z); int p1(int par) { par = par - 10; return (par); int p2(int *par) { X = *par; *par = *par - 5; return (X); int p3(int par) { int X; X = par + 1; printf("\n3) X = %d", ); return (X); Esercizio 13 Un singolo elemento di una ListaDinamica è costituito da un campo Info, contenente un carattere, e un campo Punt contenente il puntatore al successivo elemento (non sono contenuti puntatori a elementi precedenti). Scrivere una procedura InvertiDopoAster che scandisce la lista alla ricerca dell elemento il cui campo Info è il carattere * e inverte tra loro i due elementi successivi nella Lista stessa senza modificare il campo Info di alcun elemento. 07/10/ :

6 Esercizio 14 Simulare l'esecuzione di ciascuna delle 4 chiamate a sottoprogrammi, limitandosi alla descrizione dei valori stampati tramite le "printf". int vara = 12, varb = 25; int proc1(int *par) { *par = *par - 7; return (23); proc2(int *varx, int vary) { int varb; *varx = vary; varb = *varx + vary; int proc3(int vara) { int varz = 17; vara = vara + varz return (vara); main() { int varc = 63; /* situazione iniziale */ printf ("\n0) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 1 */ varc = proc1(&vara); printf ("\n1) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 2 */ proc2(&vara, varc); printf ("\n2) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 3 */ varb = proc3(varc); printf ("\n3) vara = %d, varb = %d, varc = %d ", vara, varb, varc); /* passo 4 */ varb = proc1(&varb); printf ("\n4) vara = %d, varb = %d, varc = %d ", vara, varb, varc); Esercizio 15 Un singolo elemento di una ListaDinamica è costituito da un campo Info, contenente un dato numerico, e un campo Punt contenente il puntatore al successivo elemento (non sono contenuti puntatori a elementi precedenti). Si scriva la procedura ricorsiva InvertiLista che, ricevendo come parametro una Lis adinamica, t la inverte senza creare un altra lista, restituendo il puntatore alla lista invertita. 07/10/ :

7 Esercizio 16 Scrivere un programma C che esegua la seguente funzionalità. Si legge da tastiera una sequenza di n interi positivi (massimo 100 numeri; la sequenza termina quando l'utente inserisce il numero 0); dopo avere letto tutti i numeri, per ogni numero letto viene stampato, ogni volta su una riga diversa e da sinistra verso destra, un numero di asterischi pari al numero in questione. Esempio di funzionamento del programma: Inserisci numero (0 per terminare): 3 Inserisci numero (0 per terminare): 6 Inserisci numero (0 per terminare): 3 Inserisci numero (0 per terminare): 5 Inserisci numero (0 per terminare): 0 *** ****** *** ***** #include <stdio.h> #define MAX_NUM 100 main(){ unsigned int dati[max_num], dato_corr; int i, j, n_dati; n_dati = 0; do { printf("inserisci numero (0 per terminare): "); scanf("%u", &dato_corr); if (dato_corr!= 0) { dati[n_dati] = dato_corr; n_dati++; while (dato_corr!= 0 && n_dati < MAX_NUM); for( i=0 ; i<n_dati ; i++ ){ for( j=0 ; j<dati[i] ; j++ ){ printf("*"); printf("\n"); 07/10/ :

8 Esercizio 17 Definire un tipo di dati che contiene le informazioni riguardanti un esame sostenuto da un qualunque studente universitario. Queste informazioni si compongono di: nome dell'esame (nessun nome è più lungo di 40 caratteri), codice alfanumerico (al massimo 6 lettere, per esempio AG0012), voto compreso tra 18 e 30 e lode (sia lo studente a decidere un'opportuna rappresentazione dell'eventuale lode; non sono ammessi i mezzi voti), numero di crediti associati all'esame (sono ammesse le frazioni di credito, per esempio 7,5). Definire quindi un tipo di dati che contiene le informazioni riguardanti la carriera scolastica di uno studente universitario. Di ogni studente si vogliono memorizzare le seguenti informazioni: nome (si suppone che un nome non sia composto da più di 50 lettere), matricola (un numero naturale), data di immatricolazione, numero di esami sostenuti, lista degli esami sostenuti, essendo un singolo esame descritto come in precedenza. Ogni studente può sostenere al massimo 29 esami. (se si ritiene utile, si possono definire altri tipi di dati, di supporto a quelli richiesti) typedef enum{false, true bool; typedef struct { unsigned short giorno; unsigned short mese; unsigned int anno; tipo_data; typedef struct { char nome[40]; char codice[6]; unsigned short voto; bool lode; float crediti; tipo_esame; typedef struct { char nome[50]; unsigned int matricola; tipo_data data_immatricolazione; tipo_esame esami[29]; unsigned short numero_esami; tipo_studente; 07/10/ :

9 Esercizio 18 Si scriva un programma che: Legge, carattere per carattere, una sequenza di parole scritte una di seguito all altra, consistenti di sole lettere dell alfabeto (non necessariamente appartenenti al vocabolario italiano), separate tra loro da uno o più spazi. La sequenza è poi terminata dal carattere speciale ETX (End of text). Riscrive le parole lette, una per riga ma in ordine inverso. Ogni parola consta al più di 20 caratteri; la sequenza di parole ne contiene al più 200. Qualora la sequenza contenga un carattere non ammissibile (ad esempio una cifra o un segno di interpunzione), oppure una parola sia più lunga di 20 caratteri, oppure la sequenza contenga più di 200 parole, l esecuzione del programma deve essere interrotta e deve essere prodotto sullo standard output un adeguato messaggio di errore. Ad esempio, in corrispondenza del file di ingresso (sullo SatndardInput): Alfa Giovanni domani ajjjhs poiche sempreverde hjjrstty sss ETX L uscita corrispondente deve essere: sss hjjrstty sempreverde poiche ajjjhs domani Giovanni Alfa Esercizio 19 Si vuole definire un modulo che realizza le funzioni di un archivio di fatture. Ogni fattura è descritta dalle seguenti informazioni: codice della fattura (codice alfanumerico di 8 caratteri); nome dell intestatario della fattura (al massimo 80 caratteri); importo della fattura; data di emissione della fattura. L archivio è memorizzato in maniera permanente in un file. Le funzioni che è possibile realizzare sull archivio sono: apertura di un archivio, identificato da una stringa di caratteri (se c è un archivio precedentemente aperto, questo viene preventivamente chiuso; in caso di mancata apertura ritorna un codice di errore); chiusura dell archivio (in caso di mancata chiusura ritorna un codice di errore); inserimento di una nuova fattura nell archivio (se l inserimento fallisce ritorna un codice di errore); stampa del contenuto dell archivio; riposizionamento all inizio dell archivio per una nuova lettura sequenziale (se non c è nessun archivio aperto ritorna un codice di errore); lettura sequenziale del prossimo elemento dell archivio (se non ci sono più fatture da leggere nell archivio, o se non ho ancora aperto alcun archivio ritorna un codice di errore); ricerca di una fattura secondo il suo codice (se la fattura cercata non esiste, o se non c è alcun archivio aperto ritorna un codice di errore). 07/10/ :

10 Si definisca l interfaccia (il file header del C, non l implementazione!) corrispondente al modulo sopra descritto. Si scriva un main che apre l archivio Fatture2000, e calcola l importo totale delle fatture emesse alla ditta FilippiniImpianti, stampando il risultato a video. Si implementi la funzione di lettura sequenziale del prossimo elemento dell archivio (realizzato tramite un file). Se l implementazione fa uso di variabili globali, darne la definizione; mostrare anche la clausola include per le librerie necessarie per realizzare la funzione. Si disegni un diagramma che rappresenti la struttura delle dipendenze tra i moduli (mostrare anche le dipendenze tra i moduli definiti dall utente e quelli della libreria standard del C). Nell implementazione del main e della funzione di lettura sequenziale è possibile usare le librerie standard del C viste a lezione (<stdio.h>, <stdlib.h>, <string.h>, ecc.). Ci appoggiamo ad un modulo usertypes.h che contiene un po di definizioni di tipi utili: /* usertypes.h */ typedef enum {false, true bool; typedef struct { unsigned short giorno; unsigned short mese; unsigned int anno; TipoData; L header del modulo archiviofatture e il seguente: /* archiviofatture.h */ #include "usertypes.h" #define MAX_CODICE 8 #define MAX_INTESTATARIO 80 typedef struct { char codice[max_codice+1]; char intestatario[max_intestatario+1]; unsigned long int importo; TipoData data; TipoFattura; /* le stringhe 'codice' e 'intestatario' sono piu' lunghe del necessario di un carattere per fare spazio al carattere '\000' di terminazione stringa */ bool apri (char *nomearchivio); bool chiudi(); bool inserisci_fattura (TipoFattura fattura); void stampa_archivio (); bool vai_inizio(); bool lettura_sequenziale (TipoFattura *fattura_letta); bool ricerca_fattura (TipoFattura *fattura_letta, char *codice); Il main desiderato ha la seguente codifica: 07/10/ :

11 /* mainfatture.c */ #include <string.h> #include <stdio.h> #include "archiviofatture.h" main () { TipoFattura fattura; unsigned long totale = 0; if (apri("fatture2000")) { vai_inizio(); while (lettura_sequenziale(&fattura)) { if (strcmp(fattura.intestatario, "FilippiniImpianti") == 0) totale += fattura.importo; printf("totale fatturato all'azienda FilippiniImpianti = %lu\n", totale); if (!chiudi()) printf("errore in fase di chiiusura dell'archivio\n"); else { printf("errore in fase di apertura archivio\n"); L implementazione della funzione leggi_sequenziale è la seguente (preceduta dalla definizione della variabile globale archivio, che è quella su cui tutte le funzioni del modulo implicitamente lavorano): #include "archiviofatture.h" #include <stdio.h> #include <string.h> /* questa libreria in realtà è usata da altre funzioni */ static FILE *archivio; bool lettura_sequenziale (TipoFattura *fattura_letta){ if (archivio == NULL) return false; if (feof(archivio)) return false; if(fread(fattura_letta, sizeof(tipofattura), 1, archivio)!= 1) return false; return true; Il grafo delle dipendenze tra i moduli è il seguente: mainfatture archiviofatture usertypes.h string.h stdio.h 07/10/ :

12 Esercizio 20 Si consideri la seguente dichiarazione typedef struct { int campo1; int campo2; int campo3; int campo4; struttura; Si scriva una funzione che riceva un parametro di tipo struttura e produca come risultato un valore dello stesso tipo in cui i campi risultino invertiti (il valore di campo4 si trovi in campo1, quello di campo3 in campo2, ecc.) Si trasformi poi la funzione in una procedura che esegua la medesima operazione sulla variabile di tipo struttura che le è passata come parametro. Parte 1. struttura InvertiStruttura (struttura param) { struttura varloc; varloc.campo1 = param.campo4; varloc.campo2 = param.campo3; varloc.campo3 = param.campo2; varloc.campo4 = param.campo1; return varloc; Parte 2. void ProcInvertiStruttura(struttura { struttura varloc; *param) varloc.campo1 = param->campo4; varloc.campo2 = param->campo3; varloc.campo3 = param->campo2; varloc.campo4 = param->campo1; param->campo4 = varloc.campo4; param->campo3 = varloc.campo3; param->campo2 = varloc.campo2; param->campo1 = varloc.campo1; Esercizio 21 Si considerino la tradizionale dichiarazione struct EL { int Info; struct EL *Prox; ; typedef struct EL ElemLista; typedef ElemLista *ListaDiInteri e la seguente funzione 07/10/ :

13 int sconosciuta (ListaDiInteri Lista) /*???*/ { x = 0; cursore = Lista; while (cursore!= NULL) { if (cursore->info > x) x = cursore->info; cursore = cursore->prox; return x; Si dica qual è il risultato della funzione sconosciuta quando vengono eseguite le seguenti chiamate: sconosciuta (L1) sconosciuta (L2) L1 ed L2 essendo, rispettivamente le liste rappresentate nella figura seguente. L L2 In generale, qual è il risultato prodotto dalla funzione per una generica lista di interi? Parte facoltativa Si ricodifichi la funzione sconosciuta in forma ricorsiva. Parte 1. La funzione produce come risultato 18, quando applicata alla lista L1 e 0 quando applicata a L2. In generale essa il valore massimo contenuto nella lista se essa contiene almeno un numero positivo; 0 in caso contrario (lista vuota o contenente solo numeri non positivi). Parte 2. (facoltativa) Si definisca in primo luogo la funzione ausiliaria int max(int p1, int p2) { if (p1 > p2) return p1; else return p2; successivamente la funzione sconosciuta può essere ricodifcata come segue, in forma ricorsiva int sconosciuta (ListaDiInteri Lista) /* la funzione produce il valore massimo contenuto nel parametro Lista se essa contiene almeno un numero positivo; 0 in caso contrario */ { if (Lista == NULL) return 0; else return (max(lista->info, sconosciuta(lista->prox)); 07/10/ :

14 Esercizio 22 Si vuole scrivere un programma che tiene traccia del numero di CD acquistati per ogni mese dell anno nell arco di 10 anni. Definire un tipo TipoDatiCD che contiene i dati di ogni CD: il titolo (lungo al massimo 50 caratteri), l autore (massimo 60 caratteri), l anno di pubblicazione, il numero di copie acquistate (anche più di una, se per esempio si vuole fare un regalo). Definire un tipo di dato CDAcqInMese che contiene l elenco dei CD comprati in un dato mese (si può assumere che non vengano acquistati più di 50 diversi titoli al mese) ed il numero di titoli diversi acquistati in quel mese. Definire una variabile globale elencocd che contiene l elenco dei CD acquistati mese per mese negli anni dal 1990 al Se si fa uso di tipi accessori, anche questi vanno definiti. Scrivere un main che, senza curarsi di come viene inizializzata la variabile elencocd (che supponiamo già caricata con i dati di interesse), esegue le seguenti operazioni: chiede all utente di inserire un anno (compreso tra 1990 e 1999); per ogni trimestre di quell anno (Gen-Mar, Apr-Giu, Lug-Set, Ott-Dic) stampa a video il numero di CD (contando anche le copie multiple dello stesso titolo) acquistati in quel periodo. #include <stdio.h> #define MAX_L_TITOLO 50 #define MAX_L_AUTORE 60 #define MAX_TIT_IN_MESE 50 typedef struct { char titolo[max_l_titolo]; char autore[max_l_autore]; int anno; int n_copie; TipoDatiCD; typedef struct { TipoDatiCD cd[max_tit_in_mese]; int n_titoli; CDAcqInMese; /* Le righe di 'elencocd' corrispondono agli anni dal 90 al 99, le colonne ai 12 mesi di ciascun anno */ CDAcqInMese elencocd[10][12]; main () { int anno; int i, j, k, totale_cd_trimestre; do { printf("inserisci un anno compreso tra 1990 e 1999: "); scanf("%d", &anno); while (anno < 1990 anno > 1999); /* tramuto l'anno interno nella riga corrspondente dell'array doppio 'elencocd' */ anno = anno ; /* il ciclo piu' esterno conta i trimestri, quello piu' interno i mesi del trimestre */ for( i=0 ; i<4 ; i++ ) { totale_cd_trimestre = 0; for( j=0 ; j<3 ; j++) { /* conto il numero di CD acquistati nel mese i*3+j e li aggiungo al totale del trimestre*/ for( k=0 ; k<elencocd[anno][i*3+j].n_titoli ; k++){ totale_cd_trimestre += elencocd[anno][i*3+j].cd[k].n_copie; printf("totale CD del trimestre n. %d dell'anno %d: %d\n", i+1, anno+1990, totale_cd_trimestre); 07/10/ :

15 Esercizio 23 Si vuole costruire una libreria che manipola triangoli in un piano cartesiano. Ogni triangolo è definito dalle coordinate x ed y dei suoi 3 punti. Parte a. Scrivere l interfaccia (non l implementazione) libtriangoli.h della libreria suddetta; questa definisce i tipi TipoTriangolo e TipoPunto, ed offre tutte e sole le seguenti funzioni: leggi_triang : chiede all utente di inserire da tastiera le coordinate dei punti del triangolo e ritorna un elemento di tipo TipoTriangolo; se l utente inserisce un triangolo degenere (per esempio se due punti coincidono) viene ritornato (non stampato a video!!!) un codice di errore; is_rettangolo : ritorna vero/falso a seconda che il triangolo passatole sia rettangolo o no; is_isoscele : ritorna vero/falso a seconda che il triangolo passatole sia isoscele o no; is_equilatero : ritorna vero/falso a seconda che il triangolo passatole sia equilatero o no; area_triang : ritorna l area del triangolo passatole; perim_triang : ritorna il perimetro del triangolo passatole; simili : riceve in ingresso due triangoli, e ritorna vero/falso a seconda che questi siano simili oppure no; circocentro : ritorna il punto che è il centro della circonferenza circoscritta al triangolo passatole come parametro; incentro : ritorna il punto che è il centro della circonferenza inscritta al triangolo passatole come parametro; stampa_triang : stampa a video le coordinate dei punti del triangolo passatole come argomento. Parte b Scrivere un main che, utilizzando le funzioni della libreria libtriang.h, esegue (nell ordine) le seguenti operazioni: legge le coordinate di 10 triangoli e li memorizza (se l utente immette le coordinate di un triangolo non valido, le coordinate vanno reimmesse); analizza i triangoli immessi a 2 a 2: per ogni coppia di triangoli simili stampa, di ogni triangolo della coppia, le coordinate dei punti ed il perimetro. Parte c Implementare la funzione (e solo quella!!!) perim_triang della libreria libriang.h; per l implementazione di questa funzione si ricorda che la libreria standard math.h offre, tra le altre, le funzioni sqrt e pow, le quali hanno le seguenti segnature: double sqrt (double n); double pow (double a, double b); e calcolano rispettivamente la radice quadrata di n e a b (si ricorda anche che la lunghezza di un segmento i cui estremi hanno coordinate (x1, y1) (x1, y2) è data da (x1 x2) 2 +(y1 y2) 2 ) 07/10/ :

16 parte a /* libtriangoli.h */ typedef struct { double x; double y; TipoPunto; typedef struct { TipoPunto v1; TipoPunto v2; TipoPunto v3; TipoTriangolo; typedef enum {false, true bool; bool leggi_triang ( TipoTriangolo *tr ); bool is_rettangolo ( TipoTriangolo tr ); bool is_isoscele ( TipoTriangolo tr ); bool is_equilatero ( TipoTriangolo tr ); double area_triang ( TipoTriangolo tr ); double perim_triang ( TipoTriangolo tr ); bool simili ( TipoTriangolo tr1, TipoTriangolo tr2 ); TipoPunto circocentro ( TipoTriangolo tr ); TipoPunto incentro ( TipoTriangolo tr ); void stampa_triang ( TipoTriangolo tr ); parte b /* maintriangoli.c */ #include <stdio.h> #include "libtriangoli.h" main (){ TipoTriangolo triangoli[10]; int i, j; i = 0; while (i<10){ printf("inserisci le coordinate del triangolo n. %d\n", i+1); if(leggi_triang(&triangoli[i])) { i++; else { printf("triangolo errato, reimmettilo\n"); for(i=0 ; i<9 ; i++){ for(j=i+1 ; j<10 ; j++){ if (simili(triangoli[i], triangoli[j])){ printf("i triangoli con le seguenti coordinate sono simili:\n"); printf("triangolo 1:\n"); stampa_triang(triangoli[i]); printf("triangolo 2:\n"); stampa_triang(triangoli[j]); 07/10/ :

17 parte c /* libtriangoli.c */ #include <math.h> #include "libtriangoli.h" double perim_triang(tipotriangolo tr){ double l1, l2, l3; l1 = sqrt(pow(tr.v1.x-tr.v2.x, 2)+pow(tr.v1.y-tr.v2.y, 2)); l2 = sqrt(pow(tr.v2.x-tr.v3.x, 2)+pow(tr.v2.y-tr.v3.y, 2)); l3 = sqrt(pow(tr.v3.x-tr.v1.x, 2)+pow(tr.v3.y-tr.v1.y, 2)); return l1+l2+l3; Esercizio 24 Si consideri il seguente programma: #include <stdio.h> #include <stdlib.h> main () { int **P; int *Q; Q = malloc(sizeof(int)); P = &Q; **P = 5; *Q = 4; printf( il valore finale di **P è %d \n, **P); Si dica, spiegandone brevemente le ragioni, quale sarà l output del programma. Parte facoltativa Si risolva lo stesso esercizio per la seguente variazione del programma precedente: #include <stdio.h> #include <stdlib.h> typedef int *Pint; main () { int **P; int *Q; int x; x = 27; Q = malloc(sizeof(int)); P = malloc(sizeof(pint)); *P = Q; **P = 4; Q = &x; P = &Q; *Q = 5; printf( il valore finale di **P è %d e quello di x è %d \n, **P, x); Dopo la malloc e l assegnazione P = &Q in memoria si crea una situazione come indicato in figura: 07/10/ :

18 P Q **P = 5 produce la situazione successiva seguente: P Q 5 *Q = 4 però riscrive il valore 4 nella stessa cella dove era stato scritto 5. Perciò il risultato finale è l output seguente: il valore finale di **P è 4. parte facoltativa Dopo l esecuzione delle istruzioni x = 27; Q = malloc(sizeof(int)); P = malloc(sizeof(pint)); *P = Q; si è creata la situazione seguente: P Q x Assegnando a Q l indirizzo di x e a P quello di Q, si ottiene l effetto che l assegnamento *Q = 5 sostituisce 5 a 27 in x. Ma x è anche puntata da **P. Quindi il risultato finale è l output seguente: il valore finale di **P è 5 e quello di x è 5. Esercizio 25 Realizzare un programma che legge da tastiera (e memorizza) una sequenza di caratteri alfabetici minuscoli (letti ad uno ad uno), terminata dal carattere #; se l utente inserisce un carattere non valido (un carattere maiuscolo, un numero o un simbolo che non sia #), il carattere non va memorizzato; la sequenza può essere lunga al massimo 100 elementi (escluso lo #). Il programma riproduce sullo standard output la sequenza di caratteri, convertendone il contenuto secondo la cifratura ROT-13. Questa cifratura prevede che ad ogni carattere che rappresenta la lettera tra le 26 dell'alfabeto in posizione i si sostituisca la lettera in posizione i+13 (mod 26). Ad esempio, digitando la sequenza di caratteri testodiprova#, il programma deve stampare la stringa di caratteri grfgbqvcebin. Si noti come applicando un numero pari di volte la trasformazione si riottenga il testo di partenza. #include <stdio.h> #define MAX_NUM 100 main(){ char dati[max_num], dato_corr, trasf; int i, j, n_dati; n_dati = 0; do { printf("inserisci carattere alfabetico (# per terminare, massimo %d caratteri): ", MAX_NUM); scanf(" %c", &dato_corr); if (dato_corr <= 'z' && dato_corr >= 'a') { dati[n_dati] = dato_corr; n_dati++; while (dato_corr!= '#' && n_dati < MAX_NUM); printf("\nsequenza trasformata:\n"); for( i=0 ; i<n_dati ; i++ ){ trasf = 'a' + (dati[i]+13 - 'a') % 26; printf("%c", trasf); printf("\n"); 27 07/10/ :

19 Esercizio 26 Si vuole scrivere una libreria che manipola i dati dei giocatori di squadre di calcio. Ogni giocatore è definito dal suo NOME (massimo 20 caratteri), COGNOME (massimo 30 caratteri), DATA DI NASCITA, NAZIONALITA (massimo 15 caratteri). Ogni squadra ha un nome (massimo 20 caratteri), ed è composta da al massimo 30 giocatori. Parte a Scrivere l interfaccia (non l implementazione) libcalcio.h della libreria suddetta; questa definisce i tipi TipoGiocatore e TipoSquadra (più eventualmente il TipoData, se si ritiene utile), ed offre tutte e sole le seguenti funzioni: leggi_giocatore : chiede all utente di inserire da tastiera i dati relativi ad un giocatore e ritorna un elemento di tipo TipoGiocatore; se l utente inserisce dei dati non validi (per esempio se il nome è vuoto) viene ritornato (non stampato a video!!!) un codice di errore; leggi_squadra : chiede all utente di inserire da tastiera i dati relativi ai giocatori di una squadra e ritorna un elemento di tipo TipoSquadra; se l utente inserisce dei dati non validi viene ritornato un codice di errore; conf_data_nascita : riceve in ingresso due giocatori, e ritorna 1 se giocatore1 è più vecchio di giocatore2, 0 se i due giocatori hanno la stessa età, 1 se giocatore2 è più vecchio di giocatore1 ; conf_nazionalita : riceve in ingresso due giocatori, e ritorna 1 se la nazionalità di giocatore1 precede quella di giocatore2 in ordine alfabetico, 0 se i due giocatori hanno la stessa nazionalità, 1 se la nazionalità di giocatore1 segue quella di giocatore2 in ordine alfabetico (per esempio francese viene prima di italiana in ordine alfabetico); ordina_squadra : riceve in ingresso una squadra ed un codice intero; se il codice è 0, restituisce un elemento TipoSquadra con gli stessi giocatori della squadra in ingresso, ma ordinati dal più giovane al più vecchio; se invece il codice è diverso da 0, restituisce un elemento TipoSquadra con gli stessi giocatori della squadra in ingresso, ma questa volta ordinati secondo la nazionalità in ordine crescente; stampa_giocatore : stampa a video i dati del giocatore passatole come argomento. stampa_squadra : stampa a video i dati della squadra passatale come argomento. Parte b Scrivere un main che, utilizzando le funzioni della libreria libcalcio.h, esegue nell ordine le seguenti operazioni: legge i dati relativi ai giocatori di una squadra di calcio e li memorizza (se l utente immette una squadra non valida, le coordinate vanno reimmesse); riordina i giocatori della squadra secondo l età, quindi stampa a video i dati della squadra così riordinata. Parte c Implementare la funzione (e solo quella!!!) ordina_squadra della libreria libcalcio.h; per l implementazione di questa funzione è lecito (anzi consigliato) usare le altre funzioni offerte dalla libreria libcalcio.h; come algoritmo di ordinamento si usi pure quello che si preferisce. 07/10/ :

20 parte a /* libcalcio.h */ #define MAX_NOME_GIOC 20 #define MAX_COGNOME_GIOC 30 #define MAX_NAZIONALITA 15 #define MAX_NOME_SQUADRA 20 #define MAX_GIOCATORI 30 typedef struct { unsigned short giorno; unsigned short mese; unsigned anno; TipoData; typedef struct { char nome[max_nome_gioc+1]; char cognome[max_cognome_gioc+1]; TipoData data_nascita; char nazionalita[max_nazionalita+1]; TipoGiocatore; typedef struct { char nome[max_nazionalita+1]; TipoGiocatore giocatori[max_giocatori]; unsigned short n_giocatori; TipoSquadra; typedef enum {false, true bool; bool leggi_triang ( TipoGiocatore *giocatore ); bool leggi_squadra ( TipoSquadra *squadra ); int conf_data_nascita ( TipoGiocatore giocatore1, TipoGiocatore giocatore2 ); int conf_nazionalita ( TipoGiocatore giocatore1, TipoGiocatore giocatore2 ); TipoSquadra ordina_squadra ( TipoSquadra squadra, int codice_ord ); void stampa_giocatore ( TipoGiocatore giocatore ); void stampa_squadra ( TipoSquadra squadra ); parte b /* maincalcio.c */ #include <stdio.h> #include "libcalcio.h" main (){ TipoSquadra squadra; while (!leggi_squadra(&squadra)){ printf("squadra inserita non valida, riprova\n"); stampa_squadra(ordina_squadra(squadra, 0)); 07/10/ :

21 parte c /* libcalcio.c */ #include "libcalcio.h" TipoSquadra ordina_squadra ( TipoSquadra squadra, int codice_ord ) { TipoGiocatore temp; bool ordinato; int i; while(ordinato == false){ ordinato = true; for ( i=0 ; i<squadra.n_giocatori-1 ; i++ ){ if ( codice_ord == 0 ) { if (conf_data_nascita(squadra.giocatori[i], squadra.giocatori[i+1]) < 0) { temp = squadra.giocatori[i]; squadra.giocatori[i] = squadra.giocatori[i+1]; squadra.giocatori[i+1] = temp; ordinato = false; else { if (conf_nazionalita(squadra.giocatori[i], squadra.giocatori[i+1]) > 0) { temp = squadra.giocatori[i]; squadra.giocatori[i] = squadra.giocatori[i+1]; squadra.giocatori[i+1] = temp; ordinato = false; Esercizio 27 Si ha la funzione ricorsiva: int Elabora( int n1, int n2 ) { int a, b; a = n1 + 1; b = n2-1; if (b <= 0) return a; else return Elabora(a,b); Descrivere l'esecuzione della funzione in seguito all'invocazione Elabora(4,3). La sequenza di chiamate ricorsive della funzione Elabora è la seguente: Elabora(4,3) Elabora(5,2) Elabora(6,1) Alla fine il valore ritornato dalla chiamata Elabora(4,3) è 7. 07/10/ :

22 Esercizio 28 Data una funzione calcola: int calcola( int *a, int b, int *c) { *a = *a * 2; b = b * 2; *c = *c - 2; return *a + b + *c; Qual è l'output del seguente frammento di programma? int z; int *y; int x; y = &x; z = 1; *y = 2; x = 3; z = calcola(&z,x,y); printf("%d, %d",z,x); Il frammento di codice stampa, nell ordine, i valori 9, 1. Infatti, prima della chiamata di calcola, z ha valore 1, y contiene l indirizzo di x, ed x vale 3 (quindi *y vale anch esso 3). Durante l esecuzione di calcola, x passa da 3 ad 1 con l istruzione *c = *c 2. z viene anch esso modificato (è passato per indirizzo), ma questa modifica viene poi annullata quando, al termine di calcola, il valore ritornato dalla funzione è assegnato a z. Poiché calcola ritorna 9 (la funzione era stata chiamata con z=1, x=3, *y=3), z alla fine vale 9. Esercizio 29 Scrivere un programma che legge da tastiera delle righe di caratteri (di lunghezza massima 100 caratteri). Per ogni riga letta, il programma conta il numero di occorrenze di ogni vocale (sia che appaia in caratteri maiuscoli che in quelli minuscoli). Quando l'utente immette una riga vuota, il programma stampa un istogramma verticale (dall'alto al basso) con tanti asterischi quante sono le occorrenze di ogni vocale. Per esempio, se l'utente immette le seguenti righe: NEL mezzo DEL cammin DI nostra vita<enter> mi RITROVAI per una SELVA oscura<enter> CHE la diritta via era SMARRITA<enter> <enter> Il programma stampa il seguente istogramma 07/10/ :

23 AEIOU ***** ***** **** **** *** *** *** * * * * * * * * * #define MAX_RIGA 100 #include <stdio.h> main() { char riga[max_riga+1]; unsigned int counter[5]; int i; /* inizializzo i contatori */ for( i=0 ; i<5 ; i++ ) counter[i] = 0; printf("inserisci riga di caratteri (max %d elementi):\n", MAX_RIGA); gets(riga); while(riga[0]!= '\000') { for( i=0 ; riga[i]!= '\000' ; i++ ) { if ( riga[i] == 'a' riga[i] == 'A' ) counter[0] += 1; else if ( riga[i] == 'e' riga[i] == 'E' ) counter[1] += 1; else if ( riga[i] == 'i' riga[i] == 'I' ) counter[2] += 1; else if ( riga[i] == 'o' riga[i] == 'O' ) counter[3] += 1; else if ( riga[i] == 'u' riga[i] == 'U' ) counter[4] += 1; printf("inserisci riga di caratteri (max %d elementi):\n", MAX_RIGA); gets(riga); printf("\naeiou\n"); while ( counter[0] > 0 counter[1] > 0 counter[2] > 0 counter[3] > 0 counter[4] > 0 ) { if (counter[0] > 0) { printf("*"); counter[0] -= 1; else { printf(" "); if (counter[1] > 0) { printf("*"); counter[1] -= 1; else { printf(" "); if (counter[2] > 0) { printf("*"); counter[2] -= 1; else { printf(" "); 07/10/ :

24 if (counter[3] > 0) { printf("*"); counter[3] -= 1; else { printf(" "); if (counter[4] > 0) { printf("*"); counter[4] -= 1; else { printf(" "); printf("\n"); Esercizio 30 Si vuole scrivere un modulo Dizionario che gestisce un dizionario di parole in italiano. Questo modulo offre un tipo TipoParola (che rappresenta una parola) ed un tipo ListaDiParole (una struttura dati a lista per contenere un numero arbitrario di parole), ma nasconde all utente l implementazione del dizionario in sè. TipoParola contiene il segno della parola (cioè la parola in sè, per esempio cane ; si ricorda che nella lingua italiana la parola con segno più lungo è precipitevolissimevolmente, di 26 lettere), il suo significato (lungo al massimo 200 caratteri), ed la forma della parola (le possibili forme sono: verbo, nome, aggettivo, avverbio, preposizione, articolo, interiezione). Parte a Scrivere l interfaccia (non l implementazione) Dizionario.h del suddetto modulo; questa definisce i tipi TipoParola e ListaDiParole (più eventualmente il tipo TipoFOrma) ed offre tutte e sole le seguenti funzioni: leggi_parola : chiede all utente di inserire da tastiera i dati relativi ad una parola e ritorna un elemento di tipo TipoParola; se l utente inserisce dei dati non validi (per esempio se la parola è vuota) viene ritornato (non stampato a video!!!) un codice di errore; aggiungi_parola : riceve in ingresso un elemento di tipo TipoParola e lo aggiunge al dizionario (se la parola già esiste nel dizionario questo rimane invariato); se la parola passata non è valida viene ritornato un codice di errore; trova_definizione : riceve in ingresso il segno di una parola, e ritorna il TipoParola che ne contiene la definizione; se la parola passata in ingresso non è presente nel dizionario viene ritornato un codice di errore; trova_sinonimi : riceve in ingresso un TipoParola, e ritorna una lista di parole sinonimi di quella passata; la lista ritornata è vuota se la parola in ingresso non è presente nel dizionario. Parte b Scrivere un main che, utilizzando le funzioni del modulo Dizionario.h, legge i dati relativi ad una parola (se i dati immessi non sono validi devono essere reimmessi), verifica se la parola esiste nel dizionario e, se non esiste, la aggiunge al dizionario stesso. Parte c Dare la definizione della variabile dizionario del file Dizionario.h: questa variabile contiene tutte le parole del dizionario e va implementata come un array di liste (una lista per ognuna delle 26 lettere dell alfabeto). Implementare la funzione (e solo quella!!!) trova_definizione del modulo Dizionario.h; le parole, nelle liste della variabile dizionario, possono essere memorizzate secondo l ordine alfabetico oppure no, è una scelta implementativa del programmatore. 07/10/ :

25 parte a /* Dizionario.h */ #define MAX_PAROLA 26 #define MAX_DESCR 200 typedef enum {verbo, nome, agg, avv, prep, art, inter TipoForma typedef struct { char segno[max_parola+1]; char significato[max_descr+1]; TipoForma forma; TipoParola; typedef struct EL { TipoParola el; struct EL *next; ElemListaDiParole; typedef ElemListaDiParole *ListaDiParole; typedef enum {false, true bool; bool leggi_parola ( TipoParola *parola ); bool aggiungi_parola ( TipoParola parola ); bool trova_definizione ( char segno[], TipoParola *parola ); ListaDiParole trova_sinonimi ( TipoParola parola); parte b /* maindizionario.c */ #include <stdio.h> #include "Dizionario.h" main (){ TipoParola parola, temp; while (!leggi_parola(&parola)){ printf("parola inserita non valida, riprova\n"); if (!trova_definizione(parola.segno, &temp) { aggiungi_parola(parola); 07/10/ :

26 parte c /* Dizionario.c */ #include "Dizionario.h" #include <string.h> ListaDiParole dizionario[26]; /* suppongo che le liste non siano ordinate */ bool trova_parola_in_lista ( char segno[], ListaDiParole lista, TipoParola *parola ) { if (lista == NULL) return false; if ( strcmp(segno, lista->el.segno) == 0 ){ *parola = lista->el; return true; else { return trova_parola_in_lista ( segno, lista->next, parola ); bool trova_definizione ( char segno[], TipoParola *parola ) { if ( segno[0] >= a && segno[0] <= z ) { return trova_parola_in_lista( segno, dizionario[p[0] a ], parola ); else if ( segno[0] >= A && segno[0] <= Z ) { return trova_parola_in_lista( segno, dizionario[p[0] A ], parola ); else { return false; Esercizio 31 Si ha la funzione ricorsiva: void Elabora( unsigned int i ) { if (i <= 1) { printf("%u\n", i); else { printf("%u", i % 2); Elabora( i / 2 ); Descrivere l'esecuzione della funzione in seguito all'invocazione Elabora(10), specificando che cosa rimane visualizzato sullo schermo alla fine dell esecuzione. La sequenza di chiamate ricorsive della funzione Elabora è la seguente: 07/10/ :

27 Elabora(10) Elabora(5) Elabora(2) Elabora(1) Alla fine rimane visualizzata la seguente sequenza di valori: La funzione Elabora infatti calcola in maniera ricorsiva la rappresentazione binaria (scritta con la cifra meno significativa a sinistra) del numero passatole. Esercizio 32 Data una funzione calcola: int calcola(int *a, int b, int *c) { *a = *a * b; b = b * 2; *c = *a - b; return *a + b + *c; ed il seguente programma: main() { int z; int *y; int x; y = &x; z = -1; *y = 1; x = 2; z = calcola(y,x,&z); Mostrare lo stato delle variabili x, y e z al termine dell'invocazione di calcola. Alla fine del main, la variabile x contiene il valore 4, la y punta a x, quindi *y a sua volta vale 4, mentre z vale 8. Infatti, prima della chiamata di calcola, z ha valore -1, y contiene l indirizzo di x, ed x vale 2 (quindi *y vale anch esso 3). Durante l esecuzione di calcola, x passa da 2 ad 4 con l istruzione *a = *a * b. z viene anch esso modificato (è passato per indirizzo), ma questa modifica viene poi annullata quando, al termine di calcola, il valore ritornato dalla funzione è assegnato a z. Poichè calcola ritorna 8 (la funzione era stata chiamata con z=-1, x=2, *y=2), z alla fine vale 8. 07/10/ :

28 Esercizio 33 Si consideri un computer la cui celle di memoria sono di 32 bit. Si ipotizzi che le istruzioni siano composta da due campi (codice_operativo, indirizzo) e che il primo dei due campi occupi 8 bit. Quante celle di memoria sono indirizzabili direttamente dalle istruzioni del computer? Supponendo che i bit del campo indirizzo identifichino non la cella che contiene l operando, ma la cella che (con i suoi 32 bit) contiene l indirizzo dell operando. Quante celle di memoria sono indirizzabili in tal caso dalle istruzioni del computer? Esercizio 34 Si considerino le seguenti dichiarazioni di un programma C: typedef struct { double c; int a[100]; pippo; int a; float b; pippo c; int d; int* e; e = &d; typedef struct { int c; float a[100]; pippo; int a; double b; pippo c; int d; int* e; e = &d; Si ipotizzi che: Una variabile intera occupi 2 bytes (1 parola). Una variabile float occupi 4 bytes (2 parole). Una variabile double occupi 8 bytes (4 parole). Nell allocare memoria, le variabili a, b, c, d, e siano memorizzare a partire dalla cella (parola) di indirizzo 100. A quale valore viene inizializzata la variabile e? Esercizio 35 Si considerino i seguenti frammenti di (pseudo)programma: int y, sum; float dato; leggi y; while (1) { leggi un insieme di dati interi e calcolane la somma sum; if (sum == 0) break; dato= y/sum; stampa dato int y, sum; float dato; leggi y; while (1) { leggi un insieme di dati interi e calcolane la somma sum; if (sum == 0) continue; dato= y/sum; stampa dato 07/10/ :

29 Si trasformino i due casi in frammenti che non contengano istruzioni "break" e "continue", ma solo "if" e "while" o "do-while". (scrivere i nuovi programmi nella colonna destra della tabella) Esercizio 36 Quale sarà il valore di sum dopo aver eseguito ognuno dei seguenti cicli annidati? sum = 0; for (i = 0; i <= 10; i++) for (j = 0; j <= 10; j++) sum = sum + i ; sum = 0; j = 0; do { j++; for (i = 5; i > j; i--) sum = sum + (i+j); while (j < 11); Esercizio 37 Le seguenti strutture dati descrivono le categorie di dipendenti in un azienda, le rispettive paghe orarie, e l archivio dei dati di tutti i 100 dipendenti dell azienda typedef enum {dirigente, quadro, impiegato, operaio categoria; int pagaoraria [4]; /* associa a ogni categoria la paga oraria: pagaoraria[0] è quella dei dirigenti etc. */ typedef struct { char nome[30]; /* nome e cognome del lavoratore */ categoria ruolo; /* categoria del lavoratore */ int oresettimanali; /* ore di lavoro settimanale */ dipendente; dipendente archivio[100]; Scrivere un frammento di codice che per ogni dipendente stampi nome e cognome e paga settimanale. Esercizio 38 Codificare una funzione int contarip(char *str, char c) che conti il numero di ripetizioni di un carattare (il secondo parametro) in una stringa (il primo parametro). La funzione deve essere codificata in due versioni: una prima che faccia uso di istruzioni iterative e una seconda che sfrutti il meccanismo della ricorsione. Esercizio 39 Con riferimento alle seguenti dichiarazioni typedef struct el { int info; struct el * prox; ElemLista; typedef ElemLista * ListaDiElem; si codifichi una funzione int sommatoria (ListaDiElem p) che calcoli e restituisca al programma chiamante la somma dei valori interi memorizzati nei nodi della lista ricevuta come parametro. 07/10/ :

30 Esercizio 40 Si consideri la seguente dichiarazione: typedef enum{bianco, Rosso, Verde, Blu, Nero Colore ; Quale tra questi potrebbe essere l'effetto della chiamata della funzione malloc(sizeof(colore))? dealloca una quantità di memoria pari a 5 celle di memoria; alloca una cella di memoria e ne restituisce l'indirizzo; alloca 5 celle di memoria e ne restituisce il puntatore; alloca 5 celle di memoria che puntano a un oggetto di tipo Colore. Esercizio 41 Scrivere un file di interfaccia che contenga le dichiarazioni di tipi e funzioni relative alla gestione di un calendario. Esso deve includere dichiarazioni per il tipo data che individua univocamente un giorno, il tipo giornosettimana che corrisponde ai sette giorni della settimana una funzione precede che, ricevendo due parametri di tipo data rappresentanti due giorni, stabilisce se il primo dei due precede temporalmente il secondo, e restituisce al chiamante un valore di verità rappresentante questa condizione; una funzione a valore intero distanza che, ricevendo due parametri di tipo data rappresentanti due giorni, calcola e restituisce al chiamante la loro distanza temporale in termini di numero di giorni; una funzione giornosett che, ricevendo come parametro un valore di tipo data, stabilisce a quale giorno della settimana essa corrisponde e restituisce tale valore al chiamante. Esercizio 42 Scrivi il numero N di lettere che compongono il tuo cognome. quante celle di memoria sono indirizzabili da un computer con istruzioni il cui campo indirizzo ha un numero di bit pari a N? converti N in binario. Esercizio 43 Riscrivi il seguente frammento di codice usando solo cicli while. s = 0; for (i = 0; i < 10; i++) { n = 0; for (j = 0; j <= i; j++) { n = n + 1; s = s + n; Quanto vale la variabile s al termine dell esecuzione del codice? 07/10/ :

31 Esercizio 44 Date le seguenti strutture di dati typedef struct { int codice; int votoriportato; esame; typedef struct { char nome[30]; esame esamisostenuti[30]; datistudente; datistudente archiviostudenti[100]; scrivi un frammento di codice che stampi (su una riga distinta) il nome e la votazione media solo per gli studenti che hanno riportato una votazione media maggiore o uguale a 24,5. Assumendo che variabili dei tipi di dati semplici occupino una cella di memoria, quante celle di memoria occupa la variabile archiviostudenti nell esercizio precedente? int i, j; float media; for ( i = 0; i < 100; i++ ) { media = 0.0; for ( j = 0; j < 30; j++ ) { media = media + archiviostudenti[i].esamisostenuti[j].votoriportato; media = media / 30.0 if ( media >= 24.5 ) printf ( \n %s ha la media del %f, archiviosudenti[i].nome, media); Esercizio 45 Che cosa produce nel programma seguente la chiamata della funzione boh? #define tot 100; main() { int v[tot]; void boh (int* a); /*prototipo della funzione*/... boh(v);... void boh(int* a) { int i; for(i=0; i<tot; i++) *(a+i)=0; Risposta: Pone a zero tutti gli elementi del vettore v. Esercizio 46 Data la seguente funzione ricorsiva, indicare qual è il valore calcolato dalla funzione in termini di un generico parametro a, assunto positivo. 07/10/ :