Allocazione Dinamica - vari esempi

//Allocazione dinamica

/*-----------------------------------------------------------------------*/
//1)Duplica un array preso in input |Rialloca la memoria
#include <stdio.h>
#include <stdlib.h>
//funziona

//prototipo della funzione
int *dupplica_array(int *array, int dim);

int main(){
    int *p;
    int numero;

    printf("inserisci la dimensione del vettore: ");
    scanf("%d", &numero);

    p=(int*)malloc(sizeof(int)*numero);
    printf("inserisci gli elementi : \n");
    int i;
    for(i=0;i<numero;i++){
        printf("inserisci elemento: \n");
        scanf("%d", &p[i]);
    }

    p=realloc(p,2*numero);

    dupplica_array(p,numero);



    printf("stampo array : \n");
    for(i=0;i<numero*2;i++){
        printf("elemento %d \n", *p);
    }
    free(p);

    return 0;

}

//definizione della funzione

int *dupplica_array(int *array,int dim){
    int *duplicato;
    //alloco la memoria. ma devo per forza???
    //non potrei dichiare un vettore normale, e poi fare
    // return vettore alla fine?

    duplicato=(int *)malloc(sizeof(int)*2*dim);
    //ricopio la prima volta
    int i;

    for(i=0;i<dim;i++){
            duplicato[i]=array[i];
    }
    for(i=dim;i<dim*2;i++){
        duplicato[i]=array[i];
    }

    return duplicato;
}

/*-----------------------------------------------------------------------*/
//2)Sostituisci spazi con underscore | All.dinamica

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

/*3)scrivere un programma che preso in input una stringa, usando l'aritmetica dei puntatori, sostituisca gli spazi vuoti
con il simbolo _*/

void sostSpazi(char *stringa);

int main(){
    char *stringa;
    int dimensione;
    //in questo esercizio devo passare al programma una stringa
    //quello che posso fare e' andare a chiedere all'utente quanti
    //caratteri avra' la sua stringa, allocare la dimensione necessaria,
    //e poi fare la lettura.

    printf("Quanti caratteri avra' la tua stringa\n");
    scanf("%d", &dimensione);

    getchar();;

    //alloco la memoria necessaria
    int numcar;
    numcar=dimensione+1;
    stringa=(char *)malloc(sizeof(char)*numcar);

    printf("Inserisci la tua stringa: \n");
    fgets(stringa,dimensione,stdin);

    sostSpazi(stringa);

    printf("Dopo la sostituzione degli spazi la stringa risulta: \n");
    printf("%s", stringa);
    return 0;


    }

//definizione della funzione
void sostSpazi(char *stringa){
    while(*stringa!='\0'){
        if(*stringa==' ')
            *stringa='_';
        stringa++;
        }

    }

/*-----------------------------------------------------------------------*/
//3)Sostituisci el. dispari con gli zeri |All.dinamica

/*1) scrivere un programma che preso in input un vettore e la sua dimensione, usando l'aritmetica dei puntatori, rimpiazzi
tutti i numero dispari con uno zero*/

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

//prototipo funzione
void sostituisci(int *vettore, int n){
    while(n>=0){
        if(*(vettore+(n-1))%2==1){
            *(vettore+(n-1))=0;
        }
        n--;
    }
}

//main di prova
int main(){
    int *p;
    int numero;
    int i;

    printf("quanti elementi avra' il tuo vettore: \n");
    scanf("%d", &numero);




    p=(int *)malloc(sizeof(int)*numero);
    //chiamo la funzione

    //inserisco gli elementi nel vettore
    printf("Inserisci gli elementi nel vettore: \n");
    for(i=0;i<numero;i++){
        printf("inserisci elemento in posizione%d \n",i+1 );
        scanf("%d", &p[i]);
    }

    sostituisci(p,numero);


    //stampo il nuovo vettore dopo la sostituzione degli elementi
    //dispari con il numero zero
    printf("dopo l'effetto della funzione: \n");
    for(i=0;i<numero;i++){
        printf("%d ", p[i]);
        }


    return 0;
}



/*-----------------------------------------------------------------------*/
//4) Rendi maiuscole la prima lettere di ogni parola di una frase

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*4)scrivere un programma che presa in input una stringa renda maiuscole tutte le prime lettere di ogni parola
della stringa*/

void maiusc(char *stringa);

int main(){
    char *s;
    int numero;
    int dimensione;

    printf("Quanti elementi avra' la tua stringa: \n");
    scanf("%d", &dimensione);
    numero=dimensione+1;

    //alloco la memoria
    s=(char *)malloc(sizeof(char)*numero);

    getchar();
    printf("inserisci la stringa: \n");
    fgets(s,dimensione, stdin);



    maiusc(s);

    printf("Dopo la modifica : %s", s);
    free(s);
    return 0;

    }

void maiusc(char *stringa){
    toupper(stringa[0]);
    while(*stringa!='\0'){
        if(*stringa==' '){
            stringa++;
            //dopo essere passato al carattere successivo, controllo che il carattere
            //in oggetto sia minuscolo, perche se e gia maiuscolo non ha senso che
            //faccia qualcosa.
            //quindi noi passiamo alla lettera maiscola, dopo che abbiamo incontrato
            //uno spazio e dopo che ci siamo assicurati che il carattere non e' gia maiuscolo
            //ma e' minuscolo
            if(*stringa>96 && *stringa<123){
            *stringa=*stringa-32;
            stringa++;
            }
         }
        stringa++;
    }
}

/*-----------------------------------------------------------------------*/
//5)Copia una stringa all’interno di una stringa allocata dinamicamente

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

//scrivere la funzione ricorsiva stringCopia che
//copia una stringa all'interno di un altra

//vado anche ad allocare dinamicamente la stringa di destinazione

//prototipo
void stringCopia(char *destinazione, char *sorgente);

//main di prova
int main(){
    char stringa[80];

    printf("Inserisci la stringa : MAX 80 char \n");
    fgets(stringa,80,stdin);

    //quanto spazio sto allocando ora? 80, o la lunghezza inserita dall'utente ricavata con strlen?
    char *p;
    p=(char *)malloc(strlen(stringa)+1);
    stringCopia(p,stringa);
    printf("Stampo la stringa : \n : %s", p);

    free(p);
    return 0;

}


//definizione della funzione
void stringCopia(char *destinazione, char *sorgente){
    if((*destinazione=*sorgente)!='\0')
        stringCopia(++destinazione,++sorgente);
        //cosi funziona ma se metto nella riga sopra
        //destinazione++, e sorgente++ mi va in segmentatio fault
    else
        *destinazione='\0';

}

//ricordarsi che strlen non conta il carattere di terminazione










/*-----------------------------------------------------------------------*/
//6) Somma gli elementi di una porzione di un array allocato dinamicamente

#include <stdio.h>
//importantissimo includere la libreria stdlib.h perche
//le funzioni per l'allocazione dinamica della memoria risiedono
//in essa
#include <stdlib.h>

//prototipo della funzione
int sommaporzione(int arr[], int inizio, int fine);

int main(){
        int i, elementi;
        int *area;
        int inizio;
        int fine;

        printf("Quanti elementi avra' il tuo vettore che vuoi analizzare: \n");
        scanf("%d", &elementi);

        //alloco la memoria, conoscendo/sapendo quanti elementi inserira' il
        //nostro utente
        area=(int *)malloc(sizeof(int)*elementi);

        printf("Inserisci i tuoi elementi all'interno del vettore: \n");
        for(i=0;i<elementi;i++){
            printf("Inserisci il tuo elemento in posizione %d :", i+1);
            scanf("%d", &area[i]);//uso notazione mista puntatore/vettore
        }

        printf("Ora inserisci inserisci gli indici per determinare la porzione della quale calcolare la somma\n");

        do{
        printf("Inserisci indice inferiore\n");
        scanf("%d", &inizio);
        }while(inizio<0 || inizio>elementi);

        do{
        printf("Inserisci indice superiore\n");
        scanf("%d", &fine);
        }while(fine<inizio || fine>elementi);

        int ris;
        ris=sommaporzione(area,inizio,fine);
        printf("La somma della porzione delmitata dagli indici e': %d\n", ris);


        free(area);
        return 0;
}

//definizione della funzione

int sommaporzione(int arr[], int inizio, int fine){
    int somma;
    somma=0;
    if(inizio==fine)
        return 0+ somma;
    else
        somma=arr[inizio]+sommaporzione(arr, inizio+1,fine);

    return somma;
}

/*-----------------------------------------------------------------------*/
//7)Conta gli elementi pari, di un array allocato dinamicamente

#include <stdio.h>
//importantissimo includere la libreria stdlib.h perche
//le funzioni per l'allocazione dinamica della memoria risiedono
//in essa
#include <stdlib.h>

//prototipo della funzione
int contapari(int arr[],int n);

int main(){
    int i, num_ele;
    int *p;
    //per ora dichiaro solo il puntatore, che mi servira'
    //per tenere l'indirizzo della memoria dinamica che allochero'.
    //allocando dinamicamente la memoria mi evito di dover gia in partenza
    //dover dichiarare un vettore di una dimensione prefissata
    // (es. array[100]), dove con molta probabilita'
    //andrei incontro ad uno spreco di memoria, questo perche e' impossibile che io
    //sappia gia di mio, l'utente quanti elementi ha intenzione di inserire.
    //quindi quello che faccio , prima chiedo all'utente quanti elementi vuole inserire
    //e poi con quella informazione mi alloco la memoria che mi serve, senza sprecare
    //spazio, alloco quella dimensione che mi ha detto l'utente.

    printf("Quanti elementi avra' il tuo vettore che vuoi inserire?\n");
    scanf("%d", &num_ele);

    //alloco la memoria necessaria
    p=(int *)malloc(num_ele*sizeof(int));

    printf("Inserisci i tuoi elementi all'interno del vettore: \n");
    for(i=0;i<num_ele;i++){
        printf("Inserisci il tuo elemento in posizione %d :", i+1);
        scanf("%d", &p[i]);
    }

    //ora richiamo la funzione
    int ris;
    ris=contapari(p,num_ele);

    //stampo il risultato
    printf("Il numero di elementi pari all'interno del nostro vettore e':%d", ris);

    free(p);

    return 0;
}






int contapari(int arr[],int n){

    if(n==0)
        return 0;
    else{
        if(arr[n]%2==0){
            return 1+contapari(arr,n-1);
        }
        else{
            return 0+contapari(arr,n-1);
        }
    }
}