P100108PZ0708 < Programmazione1

Tags: view all tags

<div align="center"><big><b>Programmazione I &nbsp; &nbsp;(canale P-Z) a.a. 2007-2008<br>
</b></big>
Docente: R. Silvestri &nbsp; &nbsp; Esercitatore: A. Carosi &nbsp; &nbsp;
Tutor: J. Stefa<br>
Esercizi di preparazione all'esame - 10 gennaio 2008
</div>
<br>
<div align="center"><big><b>Prima parte</b></big></div>

<dl><b>Esercizio 1</b>
<dd>Scrivere una funzione, con prototipo, <tt>int **MTri(long n)</tt>, che crea e restituisce una matrice 
triangolare di interi (<tt>int</tt>) i cui elementi hanno valori <tt>1,2,3,..., n(n+1)/2</tt>. 
Naturalmente, la matrice deve essere allocata dinamicamente e non bisogna usare
pi&ugrave; memoria di quella strettamente necessaria. Ad esempio se <tt>n = 5</tt> 
la funzione deve creare la matrice:
<tt><pre>
1  2  3  4  5
6  7  8  9 
10 11 12
13 14
15.
</pre></tt>
</dd>
<b>Soluzione</b>
<dd>
<tt><pre>
int **MTri(long n)
{
    int **M = malloc(n*sizeof(int *));    //Alloca il vettore delle righe
    long r, c, nc = n, k = 1;
    for (r = 0 ; r < n ; r++) {           //Per ogni riga della matrice...
        M[r] = malloc(nc*sizeof(int));        //Alloca la riga r-esima
        for (c = 0 ; c < nc ; c++) {          //Assegna i valori agli elementi della
            M[r][c] = k;                      //riga r-esima.
            k++;
        }
        nc--;
    }
    return M;
}
</pre></tt>
</dd>
</dl>
<dl><b>Esercizio 2</b>
<dd>Scrivere una funzione che preso in input una stringa stampa per ciascuna cifra (cio&egrave; un carattere 
dell'insieme <tt>0,1,2,3,4,5,6,7,8,9</tt>) presente nella stringa il numero di occorrenze. 
La stampa deve avvenire per cifre crescenti. Il prototipo della funzione &egrave; 
<tt>void</tt> <tt>StampaOcc(const char *)</tt>.
Ad esempio se la stringa di input &egrave;  <tt>"3aB91cz33391a"</tt>  allora la funzione deve stampare:
<tt><pre>
    la cifra 1 compare 2 volte
    la cifra 3 compare 4 volte
    la cifra 9 compare 2 volte
</pre></tt>
</dd>
<b>Soluzione</b>  
<dd>
<tt><pre>
void StampaOcc(const char *str)
{
    int i, occ[10];                  //Il vettore occ servira' a contare le occorrenze
    for (i = 0 ; i <= 9 ; i++) occ[i] = 0;   //Inizializza il vettore delle occorrenze
    i = 0;
    while (str[i] != '\0') {     //Scorri la stringa
        char c = str[i];
        if (c >= '0' && c <= '9')  //Se l'i-esimo carattere e' una cifra
            occ[c - '0']++;        //incrementa il numero di occorrenze.
    }
    for (i = 0 ; i <= 9 ; i++) {   //Per ogni cifra stampa il numero di
        if (occ[i] > 0)            //occorrenze (solo se e' maggiore di 0).
            printf("la cifra %d compare %d volte\n", i, occ[i]);
    }
} 
</pre></tt>
</dd>
</dl>

<dl><b>Esercizio 3</b>
<dd>Si scriva una funzione con il prototipo <tt>void</tt> <tt>StrTac(char *s1, const char  *s2)</tt>
che restituisce nel blocco puntato da <tt>s1</tt> la stringa formata concatenando la stringa 
<tt>s2</tt> seguita dalla stringa <tt>s1</tt>.
</dd>
<b>Soluzione</b> 
<dd>
<tt><pre>
void StrTac(char *s1, const char  *s2)
{
    int i, l1 = strlen(s1), l2 = strlen(s2);          //Calcola lunghezze stringhe
    for (i = l1 ; i >= 0 ; i--) s1[l2 + i] = s1[i];   //Sposta s1 di l2 posizioni
    for (i = 0 ; i < l2 ; i++) s1[i] = s2[i];         //Copia s2 nelle prime l2
}  
</pre></tt>
</dd>
</dl>
<hr width="100%" size="2"><br>
<div align="center"><big><b>Seconda parte</b></big></div>
<dl><b>Esercizio 4</b>
<dd>Scrivere una funzione che preso in input il puntatore al primo elemento di una lista di numeri e un intero non
negativo <tt>d</tt>, elimina dalla lista gli ultimi <tt>d</tt> elementi e ritorna il puntatore al primo 
elemento della lista cos&igrave; modificata.
Se la lista ha meno di <tt>d</tt> elementi, tutti gli elementi della lista vengono eliminati. 
Il tipo degli elementi della lista &egrave;
<tt><pre>
typedef struct NumElem {
    float           num;
    struct NumElem *pros;
} NumElem, *NumList;
</pre></tt>
Il prototipo della funzione &egrave; <tt>NumList</tt> <tt>CutTail(</tt><tt>NumList</tt> <tt>L, unsigned long d)</tt>.
</dd>
<b>Soluzione</b>   
<dd>
<tt><pre>
/* Funzione ausiliaria che elimina l'ultimo elemento della lista L
   e ritorna il puntatore alla lista cosi' modificata.             */
NumList DelLast(NumList L)
{
    if (L == NULL) return NULL;       //Se la lista e' vuota non fa nulla
    else if (L->pros == NULL) {       //Se la lista ha un solo elemento,
        free(L);                      //libera la memoria dell'elemento
        return NULL;                  //e ritorna la lista vuota.
    } else {                                         //Se la lista ha almeno due elementi,
        NumList p = L;                               //cerca l'ultimo elemento, mantenendo
        while (p->pros->pros != NULL) p = p->pros;   //il puntatore al penultimo.
        free(p->pros);
        p->pros = NULL;
        return L;
    }
}

NumList CutTail(NumList L, unsigned long d)
{
    for ( ; d > 0 ; d--) L = DelLast(L);
    return L;
} 
</pre></tt>
</dd>
</dl>
<dl><b>Esercizio 5</b>
<dd>Scrivere una funzione che presa in input una lista di stringhe crea una stringa uguale alla 
concatenazione delle stringhe
della lista. Il tipo degli elementi della lista &egrave; il seguente:
<tt><pre>
typedef struct StrElem {
    char *          str;
    struct StrElem *next;
} StrElem;
</pre></tt>
Il prototipo della funzione &egrave; <tt>char *ConcatList(const</tt> <tt>StrElem *)</tt>. 
Ovviamente la stringa ritornata deve essere allocata dinamicamente. Ad esempio se la 
lista &egrave;  <tt>"List" -> "a di es" -> "" -> "e" -> "mpio"</tt> allora la
funzione deve restituire la stringa <tt>"Lista di esempio"</tt>.
</dd>
<b>Soluzione</b>   
<dd>
<tt><pre>
char *ConcatList(const StrElem *L)
{
    char *stringa;
    const StrElem *p = L;
    long lung = 0;               //Calcola la lunghezza della stringa che
    while (p != NULL) {          //e' uguale alla somma delle lunghezze
        lung += strlen(p->str);  //delle stringhe della lista.
        p = p->next;
    }
    stringa = malloc((lung + 1)*sizeof(char));   //Alloca la stringa e
    stringa[0] = '\0';                           //inizializzala a vuota.
    p = L;
    while (p != NULL) {            //Concatena le stringhe della lista
        strcat(stringa, p->str);   //copiandole nella stringa.
        p = p->next;
    }
    return stringa;
}
</pre></tt>
</dd>
</dl>
<dl><b>Esercizio 6</b>
<dd>Si consideri il seguente tipo:
<tt><pre>
typedef struct {
    long     task;
    int      h;        //ore: 0 - 23
    int      m;        //minuti: 0 - 59
    int      s;        //secondi: 0 - 59
} TaskRec;
</pre></tt>
Scrivere una funzione, con prototipo <tt>long</tt> <tt>UpdateTasks(char *taskF, int hh, int mm, int ss)</tt>, che preso
in input il nome <tt>taskF</tt> di un file binario che contiene una sequenza di record del tipo <tt>TaskRec</tt> 
elimina da esso tutti i record il cui orario (dato dai campi <tt>h</tt>, <tt>m</tt> ed <tt>s</tt>) &egrave; 
antecedente all'orario dato da <tt>hh</tt>, <tt>mm</tt> ed <tt>ss</tt> (assumendo che tutti gli orari si 
riferiscano allo stesso giorno). La funzione ritorna il numero di record nel file aggiornato. 
Eliminare un record significa che gli eventuali record che vengono dopo nel file devono essere 
"spostati" per chiudere il "buco" lasciato dal record eliminato. Ad esempio, se inizialmente il file <tt>taskF</tt>
contiene la sequenza di record: <tt>
{1234, 2, 15, 23}, {2345, 7, 30, 15}, {1238, 7, 30, 11}, {2351, 13, 24, 53}</tt>
allora la chiamata <tt>UpdateTask(taskF, 7, 30, 15)</tt> ritorna <tt>2</tt> e la sequenza contenuta nel 
file diventa: <tt>
{2345, 7, 30, 15}, {2351, 13, 24, 53}</tt>.
</dd>
<b>Soluzione</b>   
<dd>
<tt><pre>
/* Funzione ausiliaria che ritorna 1 se l'orario (h, m, s) e' antecedente all'orario
   (hh, mm, ss), altrimenti ritorna 0.                                             */
short Ant(int h, int m, int s, int hh, int mm, int ss)
{
    if (h < hh) return 1;
    if (h == hh && m < mm) return 1;
    if (h == hh && m == mm && s < ss) return 1;
    return 0;
}

long UpdateTasks(char *taskF, int hh, int mm, int ss)
{
    FILE *f = fopen(taskF, "r+b");    //Apri il file binario in lettura e scrittura
    long nc = 0, posLast = 0, posNext = 0;   //posLast manterra' la posizione in cui spostare
    TaskRec rec;                             //il prossimo record valido e posNext manterra' la
    while (fread(&rec, sizeof(rec), 1, f) == 1) {    //posizione del prossimo record da leggere.
        if (!Ant(rec.h, rec.m, rec.s, hh, mm, ss)) {   //Se non e' antecedente...
            fseek(f, posLast, SEEK_SET);               //spostalo (o riscrivilo)
            fwrite(&rec, sizeof(rec), 1, f);
            posLast += sizeof(rec);
            nc++;
        }
        posNext += sizeof(rec);
        fseek(f, posNext, SEEK_SET);
    }
    fclose(f);
    return nc;
}
</pre></tt>
</dd>
</dl>