long *IndMax(const int  V[], long n, long  *nMax)
{
    long *ind = NULL;            //Inizializza i valori di ind e *nMax cosicche'
    *nMax = 0;                   //se n <= 0 ritorna NULL e in *nMax restituisce 0.
    if (n > 0) {                 
        long i, k;
        int max = V[0]; 
        for (i = 1 ; i < n ; i++)             //Calcola il valore massimo di V
            if (V[i] > max) max = V[i];
        for (i = 0 ; i < n ; i++)             //Calcola il numero di elementi di V
            if (V[i] == max) (*nMax)++;       //con valore massimo.
        ind = malloc((*nMax)*sizeof(long));   //Alloca il nuovo vettore
        for (k = 0, i = 0 ; i < n ; i++)      //Scrivi nel nuovo vettore gli indici
            if (V[i] == max) ind[k++] = i;    //degli elementi con valore massimo.
    }
    return ind;
}

char *ABCStringa(int nA, int nB, int nC)
{
    char *stringa = malloc((nA + nB + nC + 1)*sizeof(char));   //Alloca la stringa
    int n, i = 0;                //La variabile i conterra' sempre l'indice del
                                 //prossimo carattere (non ancora scritto).
    for (n = nA ; n > 0 ; n--) stringa[i++] = 'A';       //Scrivi le A
    for (n = nB ; n > 0 ; n--) stringa[i++] = 'B';       //Scrivi le B
    for (n = nC ; n > 0 ; n--) stringa[i++] = 'C';       //Scrivi le C
    stringa[i] = '\0';
    return stringa;
}

long EliminaDuplicati(int V[], long dim)
{
    long k = 0, i;
    for (i = 1 ; i < dim ; i++) {
        if (V[i] != V[k]) {
            k++;
            V[k] = V[i];
        }
    }
    return dim - (k + 1);
} 

typedef struct Elem {
    int          intero;
    struct Elem *next;
} Elem, *List;

/* Funzione ausiliaria che ritorna la somma degli interi della lista a partire
   dall'elemento e.                                                           */
int Somma(const Elem *e)
{
    int s = 0;
    while (e != NULL) {
        s += e->intero;
        e = e->next;
    }
    return s;
}

void SomList(List L)
{
    while (L != NULL) {
        L->intero = Somma(L);
        L = L->next;
    }
} 

typedef struct VStr {
    long         val;
    char *       str;        //stringa allocata dinamicamente
    struct VStr *next;
} VStr, *LStr;

int  Comp(LStr L)
{
    int max = 0, count = 0;
    LStr prev = NULL;                    //Manterra' il puntatore al primo elemento
    long val;                            //di una sequenza di elementi da sostituire.  
    while (L != NULL) {
        if (prev != NULL && val == L->val) {     //Se e' un elemento  di una sequenza
            int newLen = strlen(prev->str) + strlen(L->str);   //di elementi da sost.
            prev->str = realloc(prev->str, (newLen + 1)*sizeof(char));
            strcat(prev->str, L->str);           //Rialloca un blocco sufficiente per
            prev->next = L->next;                //mantenere la concatenazione.
            free(L->str);                        //Sgancia l'elemento dalla lista e
            free(L);                             //rilascia la memoria della stringa
            L = prev->next;                      //e dell'elemento.
            count++;
        } else {
            if (count > max) max = count;
            count = 1;
            val = L->val;
            prev = L;
            L = L->next;
        }
    }
    if (count > max) max = count;
    return max;
}

void  InvFile(char *nameF, char  *newF)
{
    FILE *f = fopen(nameF, "r");                //Apri il file in lettura
    int n, lenF = 0;
    while (fscanf(f, "%d", &n) == 1) lenF++;    //Conta gli interi nel file
    int k = 0, v[lenF];  //Vettore a dimensione variabile atto a contenere gli interi del file
    rewind(f);           //Riporta il cursore del file all'inizio
    while (fscanf(f, "%d", &(v[k])) == 1) k++;  //Copia gli interi del file nel vettore v
    fclose(f);
    FILE *nF = fopen(newF, "w");                //Crea ed apri il nuovo file
    for (k = lenF - 1 ; k >= 0 ; k--)           //Scrivi nel nuovo file gli interi in
        fprintf(nF, "%d ", v[k]);               //ordine inverso.
    fclose(nF);
}