Create a new version of paste:

//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.
}