char *PadString(const char *str, unsigned start, unsigned end, char pad)
{
    int k;                                               //Alloca la nuova stringa
    char *newStr = malloc((strlen(str) + start + end + 1)*sizeof(char));
    for (k = 0 ; k < start ; k++) newStr[k] = pad;       //Scrivi i caratteri pad iniziali
    for ( ; *str != '\0' ; str++, k++) newStr[k] = *str; //Copia i caratteri di str
    for ( ; end > 0 ; end--, k++) newStr[k] = pad;       //Scrivi i caratteri pad finali
    newStr[k] = '\0';
    return newStr;
}

/* Funzione ausiliaria che ritorna vero se la stringa in posizione k e' da
   eliminare.                                                              */
short IsDel(char **V, long n, long k)
{
    long i = k + 1;
    while (i < n && strcmp(V[k], V[i]) > 0) i++;
    return (i < n);
}

char *Coll(char **strVec, long n)
{
    long k, len = 0;                                  //Calcola la somma delle
    for (k = 0 ; k < n ; k++)                         //lunghezze delle stringhe
        if (IsDel(strVec, n, k))                      //da eliminare.
            len += strlen(strVec[k]);
    char *newStr = malloc((len + 1)*sizeof(char));    //Alloca la nuova stringa e
    newStr[0] = '\0';                                 //concatena le stringhe da
    for (k = 0 ; k < n ; k++)                         //eliminare e rilascia la
        if (IsDel(strVec, n, k)) {                    //memoria delle stringhe
            strcat(newStr, V[k]);                     //eliminate.
            free(V[k]);
            V[k] = NULL;
        }
    return newStr;
}

long Com(int A[], long dimA, int B[], long dimB)
{
    long k = 0, i;         //La variabile k manterra' l'indice della prima
                           //posizione disponibile del vettore A.
    for (i = 0 ; i < dimA ; i++) {
        long j = 0;
        while (j < dimB && A[i] != B[j]) j++;  //Controlla se A[i] appare in B
        if (A[i] == B[j]) {                    //Se e' cosi' sposta A[i] nella
            A[k] = A[i];                       //prima posizione disponibile,
            k++;                               //compattando cosi' il vettore.
        }
    }
    return k;
}

typedef struct Elem {
    int          val;
    struct Elem *next;
} Elem;

/* Funzione ausiliaria che ritorna il piu' piccolo intero strettamente maggiore di x *
 * contenuto nella lista L (se non esiste ritorna x).                                */
int MinMagg(int x, const Elem *L)
{
    int mm = x;
    while (L != NULL) {
        int v = L->val;
        if (v > x && (mm == x || v < mm)) mm = v;
        L = L->next;
    }
    return mm;
}

int *Piccoli(const Elem *L, unsigned k)
{
    int *vet = malloc(k*sizeof(int));  //Alloca il vettore
    const Elem *p = L;
    int i, min = L->val;               //Scorri la lista per trovare il minimo
    while (p != NULL) {
        if (p->val < min) min = p->val;
        p = p->next;
    }
    vet[0] = min;
    for (i = 1 ; i < k ; i++)             //Trova il prossimo intero piu' piccolo
        vet[i] = MinMagg(vet[i - 1], L);  //tramite la funzione MinMagg.
    return vet;
}

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

List Sposta(List L, unsigned k)
{
    List *p = &L;                  //Vai al k-esimo elemento mantenendo in
    while (*p != NULL && k > 1) {  //p l'indirizzo della locazione che 
        p = &((*p)->next);         //contiene il puntatore a tale elemento.
        k--;
    }
    if (*p != NULL) {                        //Se il k-esimo elemento esiste
        Elem *e = *p;                        //toglilo dalla lista, 
        *p = e->next;
        while (*p != NULL) p = &((*p)->next);  //arriva alla fine della lista
        *p = e;                                //e aggancia l'elemento. 
        e->next = NULL;
    }
    return L;
} 

typedef struct {
    short            str;    //1 se e' valido il campo s, 0 se e' valido il campo n
    union {
        char  s[101];        //se valido contiene una stringa di lunghezza <= 100
        int   n;             //se valido contiene un numero
    }                val;
} Rec;

typedef struct Elem {
    char *       string;
    struct Elem *next;
} Elem, *List;

/* Funzione ausiliaria che, se la stringa str non e' presente nella lista L, inserisce
   la stringa str nella lista ordinata L mantenendola ordinata.                        */
List InsOrd(List L, const char *str)
{
    Elem **prec = &L;    //Indirizzo della locazione che eventualmente dovra' contenere
                         //il puntatore all'elemento inserito.
    while (*prec != NULL && strcmp(str, (*prec)->string) > 0)   //Scorri la lista finche'
        prec = &((*prec)->next);                       //o la lista e' finita o trovi una
                                                       //stringa maggiore od uguale a str.
    if (*prec == NULL || strcmp(str, (*prec)->string) != 0) {    //Se non e' stata trovata
                                                                 //una stringa uguale a str...
        Elem *new = malloc(sizeof(Elem));                     //alloca un nuovo elemento
        new->string = malloc((strlen(str) + 1)*sizeof(char)); //Alloca memoria per la stringa
        strcpy(new->string, str);                             //Copia la stringa
        new->next = *prec;                                    //Inserisci il nuovo elemento
        *prec = new;                                          //nella lista.
    }
    return L;
}

List Update(List L, char *nameF)
{
    FILE *f = fopen(nameF, "rb");    //Apri il file binario in lettura
    Rec r;
    while (fread(&r, sizeof(Rec), 1, f) == 1)    //Leggi ogni record del file...
        if (r.str == 1)                     //Se il record contiene una stringa
            L = InsOrd(L, r.val.s);         //tenta di inserirla nella lista
    fclose(f);
    return L;
}