1  2  3  4  5
6  7  8  9 
10 11 12
13 14
15.

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;
}

    la cifra 1 compare 2 volte
    la cifra 3 compare 4 volte
    la cifra 9 compare 2 volte

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]);
    }
} 

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
}  

typedef struct NumElem {
    float           num;
    struct NumElem *pros;
} NumElem, *NumList;

/* 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;
} 

typedef struct StrElem {
    char *          str;
    struct StrElem *next;
} StrElem;

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;
}

typedef struct {
    long     task;
    int      h;        //ore: 0 - 23
    int      m;        //minuti: 0 - 59
    int      s;        //secondi: 0 - 59
} TaskRec;

/* 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;
}