Puntatori - esercizi vari

//Puntatori da stampare

/*-----------------------------------------------------------------------*/
//1)Sostituisci gli elementi dispari di un vettore con lo zero

#include <stdio.h>
#include <stdlib.h>

//prototipo funzione
void sostituisci(int *vettore, int n){
    /*questa funzione prende come parametro il vettore e la sua dimensione*/
    while(n>=0){//questo ciclo while viene eseguito tante volte
    //quanto e' la lunghezza del vettore
        if(*(vettore+(n-1))%2==1){//quello che fa e' controllare per ogni elemento
        //del vettore quanto e' il resto dopo averlo diviso per due. se il resto risulta essere
        //uno, vuol dire che e' un numero dispari, quindi da quanto stabilisce l'esercizio dobbiamo
        //sostituire quell'elemento con uno zero

        //possiamo notare come: il primo elemento che viene esaminato del vettore sia quello in posizione
        //n-1, questo perche gli indici del vettore vanno da 0 a N-1, quindi accedere alla posizione N non sarebbe
        //valido perche non fa parte del nostro vettore

            *(vettore+(n-1))=0;//ricordiamoci che per scrivere proprio nella cella puntata
            //dal puntatore dobbiamo ricordarci di mettere l'asterisco. cioe dobbiamo derefernziare
        }//questo controllo/scansione delle lettere viene fatto a partire dall'ultima e poi indietro
        //verso l'inizio del vettore, cioe da destra verso sinisitra
        n--;//ad ogni iterazione decrmenta n di una unita e' in questo modo esamina il prossimo
        //elemento del vettore.
    }
}

/*-----------------------------------------------------------------------*/
//2) Stampa una stringa carattere per carattere

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

void printCharacters(const char *sptr){
    /*il fatto che ci sia quel const dentro alla partentesi, sta ad indicare
     * che quella variabile che prendiamo in input verra solo elaborata ma
     * non potra' essere modificata. */

    //con il ciclo for andiamo a scandire tutta la stringa.
    /*il ciclo for viene iterato tante volte fino a quando la condizione rimane valida,
    cioe questo ciclo scandisce la stringa fino a quando non arriva al carattere terminatore*/
    for(;*sptr!='\0'; sptr++){
        /*La condizione di rimanenza all interno del for, e' finche non troviamo
         * il carattere di terminazione.*/
        printf("%c", *sptr);//ad ogni il giro stampa il carattere puntato dal puntatore.
        /*Finche non trovi il carattere di terminazione stampa il carattere*/
        }
}
/*-----------------------------------------------------------------------*/
//3) Converti stringa da minuscolo a maiuscolo

/*questa funzione prende come parametro una stringa, e quello che fa e' andare a convertire la stringa
da minuscolo a maiuscolo.*/
void upper(char *str1){
    while(*str1!='\0'){//il ciclo while dice, scandisci/scansiona la stringa fino a quando
    //non trovi il carattere terminatore

        //ad ogni giro controlla
        //se il codice asci indica una lettera minuscola,
        //se lo e', trasformala in maiuscola sottraendo -32
        if(*str1>96 && *str1<123){
            *str1=*str1-32;
        }
    str1++; //passa ad esaminare il prossimo carattere
    }
}

/*-----------------------------------------------------------------------*/
//4)Calcola lunghezza della stringa

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int mystrnlen(char *s){
    char *p=s;//dichiara un puntatore che si chiama *p, poi fai puntare P all inizio
    //della stringa, poi lascialo fermo li, e usando il parametro come puntatore
    //scorri la stringa fino a quando non arrivi alla fine , cioe al carattere di terminazione.

    //ora quello che avremmo saranno due puntatori, uno che punta al primo carattere della stringa, \
    //ed uno che punta al secondo carattere della stringa. per sapere quanti elementi ci sono
    //facciamo la sottrazione tra puntatori

    while(*s!='\0'){
        /*Faccio scorrere il puntatore s della stringa, fino alla fine ossia fino a quando non
         * incontra il carattere '\0'*/
        s++;//faccio avanzare il puntatore in avanti
    }

    return s-p;
    /*Alla fine, il puntatore p puntera' ancora alla prima posizione della stringa
     * mentere il puntatore s puntera' all ultima posizione. per trovare la lunghezza
     * della stringa, ossia il numero di elementi, basta che facciamo la differenza tra
     * puntatori e otteniamo il risultato.*/

    }

/*-----------------------------------------------------------------------*/
//5)Copia le due stringhe in una terza stringa

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

/* Questa funzione prende in input tre parametri, il primo parametro
 * e' la stringa sulla quale ricopiare il secondo parametro, che anche esso
 * e una stringa. il terzo parametro invece, e' un numero, un intero, che
 * ci dice quanti caratteri del secondo parametro vanno ricopiati nella
 * prima stringa.*/

void mystrncpy(char *dest, char *source, int n){
    //i parametri si chiamano destinazione, source, numero
    while(*source && n-->0){/*il while continua fino a quando non e' terminata la stringa dalla quale stiamo
    //ricopiando , e fino a quando non abbiamo terminato il numero di lettere da scriver*/
    //le due condizioni devono essere legate, perche la stringa non deve essere finita e inoltre non devo aver
    //terminato il numero di lettere da copiare.

    //perche se metessimo un OR in mezzo a queste due, per far girare il ciclo basterebbe anche che N non sia ancora
    //zero ma paradossalmente la stringa dalla quale stiamo copiando gli N caratteri e' terminata, e noi anche se abbiamo
    //n caratteri da copiare, non abbiamo da dove farlo perche la stringa e' terminata

        /* *source usata in questo modo come condizione del ciclo sta a dire
         * finche e' vera, cioe finche non arriviamo al carattere '\0', infatti
         * il carattere '\0' e' uno zero, e lo zero codifica il falso. in poche
         * parole scrivere *source vorrebbe dire "finche e' vera".
         * la seconda parte dell and invece, conta quanti ancora caratteri sono
         * rimasti da copiare.*/

        *dest++=*source++;//qui viene fatta la copia della stringa vera e propria

        /*Finche le condizioni del while sono vere, ricopia i caratteri della stringa
         * source dentro a dest. */

        }

    /*perche andiamo a calcolare questo extra? per vedere se nella stringa di destinazione
    ci sono altre lettere oltre a quelle che abbiamo appena ricopiato, e questo lo sapremo facendo la lunghezza
    della stringa destinazione meno il numero di caratteri ricopiati (cioe meno n). se ci sono solo
    le n lettere, allora il risultao di questa operazione dovrebbe dare 0, altrimenti quello che ci verra' fuori ci dice
    quante lettere dobbiamo ancora scorrere prima di mettere il carattere di terminazione */

    int extra =strlen(dest)-n;

    /*Se extra vale 0, vuol dire che nella stringa dest ci sono solamente gli elementi
     * che ho appena ricopiato, se invece extra e' > di zero, allora vuol dire che ho
     * altre lettere in quella stringa dest, allora in base a quante sono, scorro
     * la stringa fino alla fine e metto il carattere terminatore. */

    while(extra-->0){
        *dest++;//scorri la stringa
    }

    *dest='\0';
    /*Metto il carattere terminatore*/
}

/*-----------------------------------------------------------------------*/
//6)Confronta N caratteri della seconda stringa con la prima stringa

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

/*Questa funzione prende due stringhe ed un intero, quello che fa e andara a
 * confrontare gli n caratteri della seconda stringa se sono uguali alla prima stringa.*/

int mystrncmp(char *lhs, char *rhs,int n){
    for(;*lhs==*rhs;lhs++,rhs++){
        /*La condizione di rimanenza all interno del for e' data dalla condizione
         * che i due caratteri esaminati delle due stringhe siano uguali, una volta
         * assicurati che si tratti di un due caratteri uguali andiamo a controllare se per
         * caso non siamo arrivati alla fine dei caratteri della prima stringa (e quindi non abbiamo
         * piu con cosa confrontare i cartteri della seconda stringa) o se per caso siano finiti il numero
         * di caratteri da confrontare della seconda stringa (n<=0)*/
        if(*lhs=='\0' || n--<=0){
            return 0;
            printf("Sondo dentro all'if");
        }

    }
    /*come risultato viene ritornato questo, perche nel caso delle due stringhe uguali (e anche di dimensioni uguali)
    alla fine del controllo, se i due caratteri puntati dai due puntatori sono uguali, la loro differenza fara' zero, funziona
    anche con le sottostringhe. se alla fine del controllo , che avverra' con l uscita dal ciclo perche o e' finita la stringa uno
    o sono finiti il numero di caratteri da conforontare, andranno fatta la differenza tra due puntatori, e quindi se sono uguali le stringhe
    o si tratta di una sottostringa, ci verra' restituito zero*/

    return *lhs-*rhs;

    //la funzione in questione restituisce zero per dire che le due stringhe sono uguali, altri valori altrimenti
    }





/*-----------------------------------------------------------------------*/
//7)Confronto due stringhe|Puntatori|Tengo presente il case

int scmp(char *s1, char *s2){
    //il controllo del if va a controllare che le due stringhe che l'utente ha inserito
    //non siano stringhe vuote

    if(*s1!='\0' && *s2!='\0'){
        //dalla condizione del while possiamo capire
        //che e' richiesto che ogni volta, che si confronta le due
        //lettere tra le due stringhe, perche la condizione sia vera,
        //o si deve trattare di due lettere maiuscole, o si deve trattare
        //di entrambe le lettere minuscole. se ce una stessa lettera, ma in
        //una stringa e' maisucola, e nell'altra e'minuscola, non vengono
        //ritenute come due lettere uguali.
        //infatti questo programma e' case sensitive

        //se le due stringhe non suo vuote allora fai il controllo con il while.
        //il while richiede
        //1 condizione)che si tratti due caratteri uguali, due maiuscole oppure due minuscole
        //2 condizione) la seconda condizione richiede che ci sia almeno una stringa
        //che non sia ancora terminata. quindi questo ciclo va avanti finche i due caratteri esaminati
        //sono uguali e finche non sono terminate tutte e due le stringhe
        while(*s1-*s2==0 && (*s1!='\0' || *s2!='\0' ))
            s1++;//avanza il puntatore della stringa 1
            s2++;//avanza il puntatore della stringa 2
        }
    return (*s1-*s2);//se sono uguali dara' zero.
}



























/*-----------------------------------------------------------------------*/
//8)Confronta due stringhe | Puntatori |Ignoro il case sensitive

int scmpi(char *s1, char *s2){
    if(*s1!='\0' && *s2!='\0' ){
        /*Controllo che l utente non abbia inserito magari due stringhe vuote. Se lo due stringhe non
         * sono vuote procedo allora con il while. */

        while((*s1-*s2==0 || *s1-*s2==32 || *s1-*s2==-32 ) && (*s1!='\0' || *s2!='\0')){
            /*La condizione del while e' suddivisa in due parti, la prima e' data da 3 controlli che devono stabilire , se i due
             * caratteri correnti, della prima e seconda stringa facciano parte di una delle 3 combinazioni. la seconda parte del while
             * invece richiede come requisito per continuare, che almeno ci sia almeno una stringa che non sia finita. */
                s1++;
                s2++;
        }

    }
    return (*s1-*s2);
    /*Se le due stringe sono uguali alla fine i due puntatori punteranno entrambi al carattere terminatore, il che
     * vuole dire che avranno valore 0, quindi se sono uguali questa sottrazione ci dara' come risultato 0 */
}


/*-----------------------------------------------------------------------*/
//9)Conta gli zeri di un vettore usando i puntatori

//conta gli 0 di un vettore usando i puntatori
int contazeri(int *a, int n){
    int *puntatore=a;
    //dichiaro un puntatore che punta al primo elemento del vettore a appena inserito dall'utente
    if(*(puntatore+(n-1))==0)//se l'elemento puntato dal puntatore e' uguale ad uno zero, allora contalo sommando il 1
    //e richiama la stessa funzione ricorsivamente, questa volta pero' esaminando il carattere precedente
        return 1+contazeri(a,n-1);
    else
        return 0+contazeri(a,n-1);//non contare il carattere richiama la funzione

}

/*-----------------------------------------------------------------------*/
//10) Copia la prima stringa, ed N caratteri della seconda stringa, in un altra stringa

/*Questa funzione prende come paramteri 3 stringhe, e un intero.
 * Quello che fa e' ricopiare la stringa1 nella stringa destinazione
 * e copiare n caratteri della stringa2 anche essi nella stringa di destinazione.
 * quindi nella stringa destinazione noi avremmo tutta la stringa1 e n caratteri
 * della stringa2*/



void mystrncat(char *str1, char *str2, char *dest, int n){
    while(*str1){
        /*La condizione presente al interno del ciclo while
         * sta a dire "finche e' vera stringa1, cioe finche non trovi
         * il carattere terminatore della stringa1 tu fai quella cosa specificata
         * all interno del ciclo."*/
            *dest++=*str1++;
            /*Quello che devi fare e' ricopiare i caratteri della prima stringa all
             * interno della stringa destinazione*/
    }
    while(n-->0 && *str2!='\0'){
        /*Qui invece nel while abbiamo un contatore che ci indica quante caratteri della
         * seconda stringa dobbiamo copiare nella stringa di destinazione.
         * Abbiamo anche la condizione che *str2 deve essere diverso dal carattere terminatore.
         * in poche parole noi dobbiamo ricopiare le lettere finche n non arriva a zero, oppure
         * finche la seconda non arriva alla fine. in questo modo con questa condizione , se noi imettiamo
         * che devono essere copiati n caratteri piu di quanti ci sono nella stringa2 allora
         * verra copiata tutta la stringa. e noi usciremo dal while, perche arrivera' il momento in cui
         * il caratteri esaminato sara' uguale a '\0'. e quindi la condizione *str2!='\0' non sara piu verificata.*/
        *dest++=*str2++;
    }

    *dest++='\0';
    /*Alla fine aggiungiamo il carattere di terminazione*/
}