char *DelChar(const char  *str, char d)
{
    long i, j, ndc;
    for (ndc = 0, i = 0 ; str[i] != '\0' ; i++)       //Calcola il numero di caratteri
        if (str[i] == del) ndc++;                     //da eliminare.
            //Alloca lo spazio di memoria strettamente necessario per la nuova stringa
    char *newStr = malloc((strlen(str) - ndc + 1)*sizeof(char));
    for (j = 0, i = 0 ; string[i] != '\0' ; i++)      //Copia i caratteri diversi da d
        if (str[i] != d) newStr[j++] = str[i];        //nella nuova stringa.
    newStr[j] = '\0';
    return newStr;
}

void Inverti(int V[], int n)
{
    int i = 0, j = n - 1;    //L'indice i procede dall'inizio verso la fine del
    while (i < j) {          //vettore e l'indice j dalla fine verso l'inizio.
        int c = V[i];        //Scambia V[i] e V[j]
        V[i] = V[j];
        V[j] = c;
        i++;
        j--;
    }
}

     p 1
     e 1
     n 2
     i 0
     o 0

/* Funzione ausiliaria che ritorna il numero di occorrenze del carattere c
   nei primi n caratteri di s.                                             */
long CountOcc(const char *s, long n, char c)
{
    long k, nOcc = 0;
    for (k = 0 ; k < n ; k++) if (s[k] == c) nOcc++;
    return nOcc;
}

void PrintNumOcc(const char *str1, const char *str2)
{
    long k, len2 = strlen(str2);
    for (k = 0 ; str1[k] != '\0' ; k++) {    //Per ogni carattere c di str1...
        char c = str1[k];
        if (CountOcc(str1, k, c) == 0)       //Se e' la prima occorrenza di c in str1,       
            printf("%c %ld\n", c, CountOcc(str2, len2, c));   //stampa il numero di volte
    }                                                         //che c occorre in str2.
}

typedef struct SList {
    char          str[30];
    struct SList *next;
} SList;

void Ripulisci(SList *L)
{
    if (L != NULL && L->next != NULL) {
        SList *e = L;
        do {
            if (strcmp(e->str, e->next->str) == 0) {   //Se le stringhe sono uguali
                SList *p = e->next;                    //elimina il prossimo elemento.
                e->next = p->next;
                free(p);
            } else e = e->next;
        } while (e->next != NULL);
    }
}

typedef struct ENum {
    float        n;
    struct ENum *next;
} ENum;

/* Funzione ausiliaria che ritorna il puntatore al primo massimo della lista L.
   Se non ci sono massimi ritorna NULL.                                        */
ENum *PrimoMax(const ENum *L)
{
    if (L == NULL || L->next == NULL) return NULL;
    else {
        float prec = L->n;
        L = L->next;
        while (L->next != NULL && (L->n <= prec || L->n <= L->next->n)) {
            prec = L->n;
            L = L->next;
        }
        return (L->next != NULL ? L : NULL);
    }
}

float *Massimi(const ENum *L, long *dim)
{
    float *vetMax = NULL;
    long nMax = 0;
    const ENum *e = L;
    while ((e = PrimoMax(e)) != NULL) nMax++;   //Conta i massimi
    if (nMax > 0) {
        long i = 0;
        vetMax = malloc(nMax*sizeof(float));   //Alloca il vettore dei massimi
        while ((L = PrimoMax(L)) != NULL) vetMax[i++] = L->n;
    }
    *dim = nMax;
    return vetMax;
}

long CatFiles(char *conF, char *catF)
{
    FILE *fcon = fopen(conF, "r+");      //Apri il file conF in lettura e scrittura
    FILE *fcat = fopen(catF, "r");       //Apri il file catF in lettura
    long nc = 0;
    int c;
    while (fgetc(fcon) != EOF) nc++;     //Calcola il numero di caratteri di conF
    while ((c = fgetc(fcat)) != EOF) {   //Aggiungi il contenuto di catF a conF
        fputc(c, fcon);
        nc++;
    }
    fclose(fcon);
    fclose(fcat);
    return nc;
}