F - funzioni varie

//Funzioni

/*-----------------------------------------------------------------------*/

//1)Dato un vettore toglie gli elementi dispari

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

//prototipo funzione
int *toglidispari(int *vettore,int n);

int main(){

    int dimensione;
    //questa variabile puntatore mi serve per allocare
    //la memoria necessaria per il mio vettore che andro'
    //ad acquisire
    int *p;

    //effettuo la lettura della dimensione del vettore
    printf("Quanti elementi avra' il tuo vettore: \n");
    scanf("%d", &dimensione);

    //alloco la memoria necessaria per il vettore
    p=(int *)malloc(sizeof(int)*dimensione);



    //riempio il vettore
    printf("Inserisci i valori: \n");
    int i;
    for(i=0;i<dimensione;i++){
        printf("Inserisci elemento %d: ", i+1);
        scanf("%d", &p[i]);
    }

    //siccome la mia funzione ritorna un puntatore.
    //allora dichiaro un variabile puntatore mia,  nella quale
    //andro a mettere il puntatore restituito dalla funzione
    int *risultato;
    //metto in risultato , il puntatore che mi restituisce la funzione
    risultato=toglidispari(p,dimensione);

    //ora il mio risultato e' nella variabile puntatore
    //nella quale ho messo il risultato.
    //faccio la stampa
    for(i=0;i<dimensione;i++){
        printf("Vettore nuovo :%d\n", risultato[i] );
    }

    return 0;


}

//definzione della funzione
//visto che voglio restituire un vettore, ma non posso in senso
//vero e proprio restituire un vettore, allora restituisco un
//puntatore al primo elemento
int *toglidispari(int *vettore,int n){
        int i;
        //la variabile con_dispari mi serve per sapere
        //in quale posizione scrivere i numeri nel nuovo
        //vettore
        int cont_dispari;
        cont_dispari=0;
        //il successivo puntatore con la successiva allocazione
        //della memoria mi serve perche dopo lo devo restituire
        int *nuovo;
        nuovo=(int *)malloc(sizeof(int)*n);
        for(i=0;i<n;i++){
            if(vettore[i]%2==0){
                nuovo[cont_dispari]=vettore[i];
                cont_dispari++;
            }
        }
        //ritorno il puntatore
        return nuovo;
}
/*-----------------------------------------------------------------------*/
//2)Conta il numero occorrenze di un carattere all'interno di una stringa
#include <stdio.h>
#include <stdlib.h>

//prototipo della funzione
int contaocc(char *s, char c);

//main di prova
int main(){
    char stringa[]="aleksandar123";
    int risultato;
    risultato=contaocc(stringa,'a');
    printf("%d", risultato);


}

//definizione della funzione
int contaocc(char *s, char c){
    //variabili che mi servono
    int contatore;
    contatore=0;

    while(*s!='\0'){//fino a quando non incontri il carattere di terminazione
    //vai a controllare se il carattere puntato corrisponde al carattere che stiamo
    //cercando, se si aumenta il contatore
        if(*s==c)
            contatore++;
        //faccio avanzare il while
        s++;//fai avanzare il puntatore
    }
    //sono fuori dal ciclo while, ora posso restituire il risultato
    return contatore;//ritorna il risultato che mi dice quante occorrenze ci sono
    //di quella lettera
}
/*-----------------------------------------------------------------------*/
//3)Funzione che stampa una scritta, finche non viene premuto un carattere
#include <stdio.h>
#include <stdlib.h>

//prototipo della funzione
void stampamess(void);

//main di prova
int main(){
    stampamess();

    return 0;
}

//definizione della funzione
void stampamess(void){
    char c;
    printf("Premere un tasto per continuare\n");
    scanf("%c", &c);//la lettura del carattere la uso per far terminare il programma
    }


/*-----------------------------------------------------------------------*/
//4)Funzione che calcola qualunque potenza
#include <stdio.h>
#include <stdlib.h>
/*Primo esercizio.
 * scrivere una funzione che calcoli qualunque potenza con esponente intero maggiore uguale a 0*/



//prototipo della funzione
//questa funzione prende come parametri la base e l'esponente
int qualunquePotenza(int base,int esponente);

//main di prova
main(){
    int risultato;
    risultato=qualunquePotenza(2,-3);

    printf("%d", risultato);
    }

//definizione della funzione
int qualunquePotenza(int base, int esponente){
        //nel caso dell'esponente negativo viene restituito -1
        if(esponente<0){
            return -1;//mi assicuro che l esponente sia maggiore uguale a 0.
            //se per caso mette un valore minore di zero, restituisci -1
        }
        //se l esponente non e' negativo, provvedo a calcolare la potenza
        int prodotto;
        prodotto=1;//non posso inizializzarla a zero, perche altrimenti mi porta a zero
        //tutto il prodotto

        //l'esponente indica anche il numero di volte che dobbiamo moltiplicare
        //la base per se stessa
        while(esponente>0){
            prodotto=prodotto*base;
            esponente--;//decrementiamo esponente, ossia il numero di volte
            //ancora da moltplicare la base per se stessa
        }

        return prodotto;//ritorna il risultato

}

/*-----------------------------------------------------------------------*/
//5)Calcola i numeri primi fino a N

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

void primin(int n);

int main(){
        primin(50);

}

//definizione dell esercizio

//la funzione ausiliaria che mi serve per stabilire se devo
//stampare un numero o no
int isprimo(int n){
    int divisore;
    divisore=2;

    while(divisore<n){
        if(n%divisore==0){
            return 0;//falso non e' primo, perche ho appena
            //trrovato un divisore compreso tra 2 e il numero-1.
            // e sapiamo che per essere primo non deve avere
            //divisore eccetto 1 e il numero stesso
        }
        divisore++;
        }
    return 1;
    }


void primin(int n){
    int contatore;
    contatore=0;

    while(contatore<=n){
            if(isprimo(contatore)==1)
                printf("%d ", contatore);

            contatore++;
    }
}


/*-----------------------------------------------------------------------*/
//6)Conta il numero di caratteri e di cifre di una stringa


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

//prototipo della funzione
void contaCarCif(char *s);

//main di prova
int main(){
    char stringa[]="aleksandar123";
    contaCarCif(stringa);
}

//definizione della funzione
void contaCarCif(char *s){
    int ContCar,ContCif;
    ContCar=0;
    ContCif=0;
    while(*s!='\0'){
        if((*s>96 && *s<123) || (*s>64 && *s<91) ){
            ContCar++;
        }
        if(*s>47 && *s<58){
            ContCif++;
        }
        //faccio avanzare il while
        s++;
    }
    //sono fuori dal ciclo while, ora posso restituire il risultato
    printf("I caratteri sono %d\n", ContCar);
    printf("Le cifre sono %d\n", ContCif);
    printf("La funzione e' Terminata!!!");
}

/*-----------------------------------------------------------------------*/
//7)Calcola i numeri triangolari fino ad un certo numero

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

 //prototipo della funzione
 //che calcola ennesimo numero triangolare
  int triangolare(int n);
  void visualiizaTriang(int n);


int main(){
    visualiizaTriang(50);
    }

 //l'ennesimo numero triangolare e' dato dalla somma di tutti numeri fino a quello

 int triangolare(int n){
     int somma;
     somma=0;
     int contatore;
     contatore=1;
     while(contatore<=n){
        somma=somma+contatore;
        contatore++;
     }
     return somma;
}


//visualizzo i numeri triangolari minori di n
void visualiizaTriang(int n){
    int count;
    count=0;
    int restituisci;
    while(count<n && triangolare(count)<n){

        restituisci=triangolare(count);
        printf("%d ", restituisci);
        count++;
        }

    }

/*-----------------------------------------------------------------------*/
//8)Calcola il cubo dei numeri < N fino a quando uno dei cubi non supera N

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

//definisco la funzione cubo
//prototipo funzione
int cubo(int n);
void cubofinon(int n);

int main(){
        cubofinon(100);

}

//definizione cubo
int cubo(int n){
    return n*n*n;
    }

//definizione funzione principale
void cubofinon(int n){
    int contatore;
    contatore=0;
    while(contatore<n && cubo(contatore)<n){
            printf("%d ",cubo(contatore));
            contatore++;
    }

}



/*-----------------------------------------------------------------------*/
//9) Tre varie funzioni

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

//prototipi delle funzioni

//14 - realizzare una funzione che accetti in ingresso un numero
//positivo n e visualizzi la successione dei numeri interi positivi
//da 1 a n.

void successione1n(int n);

/*16
 * realizzare una funzione che accetti in ingresso due numeri
 * interi positivi n e m, n minore di m, e visualizzi la
 * successione da n ad m*/
void daNadM(int n, int m);

/*15
 * realizzare una funzione che accetti in ingresso un intero
 * n e visualizzi la successione dei numeri interi positivi
 * dispari da 1 a n*/

void disparin(int n);


int main(){
        //provo 14
        successione1n(10);
        //provo 16
        daNadM(8,15);
        //provo 15
        disparin(15);

    }

//14
void successione1n(int n){
    int contatore;
    contatore=0;
    while(contatore<=n){
        printf("%d  ", contatore);
        contatore++;
    }
    printf("\n");
}

//16
void daNadM(int n, int m){
    if(n>m)
        printf("\n Errore! Il primo numero deve essere minore del secondo\n");
    else{
        while(n<=m){
            printf("%d ", n);
            n++;
        }   //chiudo while
    }//chiudo else
    printf("\n");
}
 //15
 void disparin(int n){
     int contatore;
     contatore=0;
     while(contatore<=n){
            if(contatore%2==1)
                printf("%d ", contatore);
         contatore++;
     }
}

/*-----------------------------------------------------------------------*/
//10)Data una stringa converti le lettere minuscole in maiuscole

void convertinMai(char *s){
    while(*s!='\0'){
        if(*s>96 && *s<123)
            *s=*s-32;
        s++;
    }
}

/*-----------------------------------------------------------------------*/
//11)Calcola il fattoriale di tutti numeri compresi tra 1 e N

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

//prototipo della funzione
int fattoriale(int n);
void fattfinon(int n);

//main di prova
int main(){
    fattfinon(8);

}


//definizione della funzione ausiliaria
int fattoriale(int n){
    if(n!=0)
        return n*fattoriale(n-1);
    else
        return 1;
    }

//definizione della funzione principale che fa uso
//della funzione ausiliaria
void fattfinon(int n){
    int contatore;
    contatore=0;
    while(contatore<=n){
            printf("%d|", fattoriale(contatore) );
            contatore++;
    }
}

/*-----------------------------------------------------------------------*/
//12)Determina se una stringa e’ vuota

/*determina se l'insieme e' vuoto*/

int is_empty(const char *set){
    return (set[0]=='\0');//qui ce un test booleano,
    //viene controllato se il primo carattere della stringa e' un
    //carattere di fine stringa, e di conseguenza si ha che si tratta
    //di una stringa vuota, se questa cosa e' vera allora viene restituito
    //1 che vuol dire true, altrimenti ci restituira' 0.
}