/*ESEMPIO 1  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
int fat(int);

main()
{
/* esempio 1 del capitolo 10*/
int n;
printf("Calcolo del fattoriale\n\n");
printf("Dammi un numero naturale\n");
scanf("%d",&n);
if (n>0) printf("\nIl fattoriale di %d e' %d:\n",n, fat(n));
 else   printf("\n Non se pole fa' \n");
 }

int fat(int n)
{
if (n==0) return 1;
    else return (n*fat(n-1));
}

/*ESEMPIO 2  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
int dispo(int, int ,int);

main()
{
/* esempio 2 del capitolo 10*/
int n,k;
printf("Disposizioni semplici di di K su N oggetti\n\n");
printf("Dammi un numero naturale N\n");
scanf("%d",&n);
getchar();
printf("Dammi un numero naturale K\n");
scanf("%d",&k);
if (n>k) printf("\nLe disposizioni semplici di %d su %d sono %d:\n",k, n, dispo(k,n,n));
   else   printf("\n Non se pole fa' \n");
   }

int dispo(int k, int n, int m)
{
if (n==m-k) 
    return 1;
    else 
    return (n*dispo(k,n-1,m));
}

/*ESEMPIO 2bis  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>

int fat(int); 
int dispo2(int, int);

main()
{
/* esempio 2 del capitolo 10 col fattoriale*/
int n,k;
printf("Disposizioni semplici di di K su N oggetti, col fattoriale\n\n");
printf("Dammi un numero naturale N\n");
scanf("%d",&n);
getchar();
printf("Dammi un numero naturale K\n");
scanf("%d",&k);
if (n>k) printf("\nLe disposizioni semplici di %d su %d sono %d:\n",k, n, dispo2(k,n));
  else   printf("\n Non se pole fa' \n");}


int fat(int n)
{
if (n==0) 
   return 1;
  else 
   return (n*fat(n-1));
}


int dispo2(int k, int n)
{
   return (fat(n)/fat(n-k));
}

/*ESEMPIO 3  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
int comb(int,int);
int dispo(int, int ,int);
int fat(int);

main()
{
/* esempio 2 del capitolo 10*/
int n,k;
printf("Combinazioni semplici di N oggetti presi K a K\n\n");
printf("Dammi un numero naturale N\n");
scanf("%d",&n);
getchar();
printf("Dammi un numero naturale K\n");
scanf("%d",&k);
if (n>k) printf("\nLe comb semplici di %d su %d sono %d:\n",k, n, comb(k,n));
  else   printf("\n Non se pole fa' \n");
  }

int comb(int k, int n)
{
return(dispo(k,n,n)/fat(k));
}

int dispo(int k, int n, int m)
{
if (n==m-k) 
    return 1;
    else 
    return (n*dispo(k,n-1,m));
}

int fat(int n)
{
if (n==0) 
   return 1;
  else 
   return (n*fat(n-1));
}

/*ESEMPIO 3bis  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
int comb(int,int);
int dispo(int, int ,int);
int fat(int);

main()
{
/* esempio 2 del capitolo 10*/
int n,k;
printf("Combinazioni semplici di N oggetti presi K a K\n\n");
printf("Dammi un numero naturale N\n");
scanf("%d",&n);
getchar();
printf("Dammi un numero naturale K\n");
scanf("%d",&k);
if (n>k) printf("\nLe comb semplici di %d su %d sono %d:\n",k, n, comb(k,n));
  else   printf("\n Non se pole fa' \n");
  }

int comb(int k, int n)
{
return(dispo(k,n,n)/dispo(k,k,k));
}

int dispo(int k, int n, int m)
{
if (n==m-k) 
    return 1;
    else 
    return (n*dispo(k,n-1,m));
}

int fat(int n)
{
if (n==0) 
   return 1;
  else 
   return (n*fat(n-1));
}

/*ESEMPIO 3ter  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 

int dispo2(int, int);
int fat(int);

main()
{
/* esempio 2 del capitolo 10*/
int n,k;
printf("Combinazioni semplici di N oggetti presi K a K\n\n");
printf("Dammi un numero naturale N\n");
scanf("%d",&n);
getchar();
printf("Dammi un numero naturale K\n");
scanf("%d",&k);
if (n>k) printf("\nLe comb semplici di %d su %d sono %d:\n",k, n, dispo2(k,n)/fat(k));
  else   printf("\n Non se pole fa' \n");
  }


int dispo2(int k, int n)
{
   return (fat(n)/fat(n-k));
}

int fat(int n)
{
if (n==0) 
   return 1;
  else 
   return (n*fat(n-1));
}

/*ESEMPIO 4  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/

#include <stdio.h>
 
int fibo(int);

main()
{
/* esempio 4 del capitolo 10*/
int n;
printf("Calcolo del numero di Fibonacci\n\n");
printf("Dammi un numero naturale\n");
scanf("%d",&n);
if (n>0) printf("\nIl numero di Fibonacci di  %d e' %d:\n",n, fibo(n));
 else   printf("\n Non se pole fa' \n");
 }

int fibo(int n)
{
if (n==0) return 1;
if (n==1) return 1;
    else return (fibo(n-1)+fibo(n-2));
}

/*ESERCIZIO 1  DEL CAPITOLO 10 DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
int fat(int);

main()
{
/* esemrcizio 1 del capitolo 10*/
int n;
printf("Calcolo dei primi n fattoriali\n\n");
printf("Dammi un numero naturale\n");
scanf("%d",&n);
printf("\nIl fattoriale di %d e' %d:\n",n, fat(n));
}

int fat(int n)
{int temp;
if (n==0) return 1;
    else {printf("\nIl fattoriale di %d e' %d:\n", n-1, temp=fat(n-1));return (n*temp);}
}

/*ESERCIZIO 2  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
int leggiesomma();

main()
{
/* esercizio 2 del capitolo 10*/
int n;
printf("Somma ricorsiva di N numeri\n\n");
printf("\nLa somma dei numeri che mi hai dato e' %d:\n" ,leggiesomma());
}

int leggiesomma()
{int n;
printf("Dammi un numero intero, ZERO per terminare \n");
scanf("%d",&n);
if (n==0) return 0;
    else return (n+leggiesomma());
}

/*ESERCIZIO 3  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
 double pote (float base, int esp);
main()
{
/* esercizio 3 del capitolo 10, potenza iterativa*/
/* identico a esercizio 1 del capitolo 7*/

float base; int esp;

printf("\nDammi un numero reale\n\n");
scanf("%f",&base);

printf("\nDammi un numero intero non negativo\n\n");
scanf("%d",&esp);

printf("\n Il numero%7.2f elevato alla %d  e' uguale a %7.2f\n",base, esp, pote(base, esp));
}

double pote(float base, int esp)

{
int i;
double ptz=1;

if (esp!=0)for(i=0; (i<esp); i++) ptz=ptz*base;
return ptz;
}

/*ESERCIZIO 4  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
/* esercizio 4 del capitolo 10, potenza ricorsiva*/

#include <stdio.h>
 
 double pote_ric (float base, int esp);
main()
{
float base; int esp;

printf("\nDammi un numero reale\n\n");
scanf("%f",&base);

printf("\nDammi un numero intero non negativo\n\n");
scanf("%d",&esp);

printf("\n Il numero%7.2f elevato alla %d  e' uguale a %7.2f\n",base, esp, pote_ric(base, esp));
}

double pote_ric(float base, int esp)

{
if (esp==0) return (1);
else return (base*pote_ric(base , esp-1));
}

/*ESERCIZIO 5  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
double pote (float base, int esp);
main()
{
/* esercizio 5 del capitolo 10*/
/* identico a esercizio 9 del capitolo 7*/

float base; int esp;

printf("\nDammi un numero reale\n\n");
scanf("%f",&base);

printf("\nDammi un numero intero \n\n");
scanf("%d",&esp);

printf("\n Il numero%7.2f elevato alla %d  e' uguale a %7.2f\n",base, esp, pote(base, esp));
}


double pote(float base, int esp)
{
int i;
double ptz=1;

if (esp!=0){
    for(i=0; (i<abs(esp)); i++) ptz=ptz*base;
    if (esp<0) ptz=1/ptz;
    } 
return ptz;
}
/*ESERCIZIO 6  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
/*#include <math.h>*/

/* esercizio 6 del capitolo 10, potenza ricorsiva, esponenete anche negativo*/

double pote_ric(float base, int esp);
main()
{
float base; int esp;

printf("\nDammi un numero reale\n\n");
scanf("%f",&base);

printf("\nDammi un numero intero qualsiasi\n\n");
scanf("%d",&esp);

printf("\n Il numero%7.2f elevato alla %d  e' uguale a %7.2f\n",
 base, esp, esp>0?pote_ric(base, esp):1/pote_ric(base,abs(esp)));
}

double pote_ric(float base,int esp)

{
if (esp==0) return (1);
else return (base*pote_ric(base,esp-1));
}

/*ESERCIZIO 7  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
/* esercizio 7 del capitolo 10 massimo comun divisore*/


#include <stdio.h>


int mcd_resti(int t, int k);
main()
{int t,k;


printf("\nDammi un numero intero\n\n");
scanf("%d",&t);

printf("\nDammi un altro numero intero \n\n");
scanf("%d",&k);

printf("\n Il massimo comun divisore di %d e %d  e' uguale a %d\n",
t,k,mcd_resti(t,k));
}

int mcd_resti(int t, int k)

{
if (k==0) return (t);
if (k>t) return mcd_resti(k,t);
     else return mcd_resti(k,t%k);
}

/*ESERCIZIO 8  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
/* esercizio 8 del capitolo 10 massimo comun divisore*/


#include <stdio.h>


int mcd_sott(int t, int k);
main()
{int t,k;


printf("\nDammi un numero intero\n\n");
scanf("%d",&t);

printf("\nDammi un altro numero intero \n\n");
scanf("%d",&k);

printf("\n Il massimo comun divisore di %d e %d  e' uguale a %d\n",
t,k,mcd_sott(t,k));
}

int mcd_sott(int t, int k)

{
if (k==t) return (t);
if (k>t) return mcd_sott(k,t);
     else return mcd_sott(t-k,k);
}

/*ESERCIZIO 9  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/

/* esercizio 9 del capitolo 10 massimo comun divisore*/
/* per rispondere alla domanda contiamo le ricorsioni*/
#include <stdio.h>
int contarst=0,contasot=0;

int mcd_sott(int t, int k);
int mcd_resti(int t, int k);
main()
{int t,k;


printf("\nDammi un numero intero\n\n");
scanf("%d",&t);

printf("\nDammi un altro numero intero \n\n");
scanf("%d",&k);

printf("\n Il massimo comun divisore di %d e %d  e' uguale a %d\n",
t,k,mcd_sott(t,k));
mcd_resti(t,k);
printf("\n Col metodo dei resti ho fatto  %d passi di ricorsione \n",
contarst);
printf("\n Col metodo delle sottrazioni ho fatto  %d passi di ricorsione \n",
contasot);
printf("\nQuale e' il migliore secondo te?? \n");
printf("\nSecondo me il ");
 if (contarst<contasot)printf("metodo dei resti");
    else printf("metodo delle sottrazioni");
}

int mcd_sott(int t, int k)

{contasot=contasot+1;
if (k==t) return (t);
if (k>t) return mcd_sott(k,t);
     else return mcd_sott(t-k,k);
}
int mcd_resti(int t, int k)

{contarst=contarst+1;
if (k==0) return (t);
if (k>t) return mcd_resti(k,t);
     else return mcd_resti(k,t%k);
     }
/*ESERCIZIO 10  DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/

#include <stdio.h>
 
int ricerca(int i,int j,int n);
int vet[20];

main()
{
/* esercizio 10 del capitolo 10*/
/*RICERCA BINARIA RICORSIVA*/

int i;
int num;
int ris;

for(i=0; (i<20);i++) vet[i]=i+1;
/*INIZIALIZZO IL VETTORE COI NUMERI DA 1 A 20*/
printf("\n Dammi un numero intero\n"); 
scanf("%d",&num);
ris=ricerca(0,19,num);
if (ris) printf("\n Il numero %d ci sta\n",num);
    else printf("\n Il numero %d non ci sta\n",num);
}

 int ricerca(int alto,int basso,int n)
 {
  printf("\n alto=%d, basso=%d, (alto+basso)/2= %d\n",alto,basso,(alto+basso)/2);
  printf("\n alto>basso%d  \n",alto>basso);
 if (alto>basso) return 0;

 if(n ==vet[(alto+basso)/2]) return 1;
 if(n >vet[(alto+basso)/2]) return ricerca(((alto+basso)/2+1),basso,n);
     else return ricerca(alto,((alto+basso)/2-1),n);
 }


/*ESERCIZIO 11 DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
float poli(int n,float x);
double pote_ric (float base, int esp);

main()
{
/* esercizio 11 del capitolo 10, versione  ingenua*/
int n;
float x;
printf("Calcolo del polinomio\n\n");
printf("Dammi un numero naturale\n");
scanf("%d",&n);
printf("Dammi un numero reale\n");
scanf("%f",&x);
printf("\nIl valore del polinomio  e' %f:\n",poli(n,x));
}

float poli(int n,float x)
{
if (n==1) return x;
    else return n*pote_ric(x,n)+poli(n-1,x);
}

double pote_ric(float base, int esp)

{
if (esp==0) return (1);
else return (base*pote_ric(base , esp-1));
}

/*ESERCIZIO 11bis DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/
#include <stdio.h>
 
float poli(int n,float x);

int i;
main()
{
/* esercizio 11 del capitolo 10, versione  smart*/
int n;
float x;

printf("Calcolo del polinomio\n\n");
printf("Dammi un numero naturale\n");
scanf("%d",&n);
printf("Dammi un numero reale\n");
scanf("%f",&x);
i=1;
printf("\nIl valore del polinomio  e' %f:\n",poli(n,x));
}

float poli(int n,float x)
/* CALCOLO ((( (nx+n-1)x+ n-2)x+...2)x+1)x */
{
if (i==n) return n*x+(n-1);
    else {i=i+1; return ((poli(n,x)+(i-1))*x);};
}


/*ESERCIZIO 12 DEL CAPITOLO 1é DEL BELLINI_GUIDI*/
/********************************************/
/********************************************/

/* esercizio 12 del capitolo 10*/
#include <stdio.h>
 
int elem(int n);


main()
{
int n;

printf("Calcolo della serie \n\n");
printf("Dammi un numero naturale\n");
scanf("%d",&n);

printf("\nIl valore della serie per n= %d e' %d:\n",n, elem(n));
}

int elem(int n)

{int temp1;
if (n==1) return 3;
if (n==2) return 7;
    else { printf("\nPer n=%d la serie vale %7d\n", n, temp1=(2*elem(n-1)-3*elem(n-2))); 
    return temp1;}
}