/*  STAMPA DI UN NUMERO INTERO  */



#include <stdio.h>
#include <math.h>


void print10(int n);  // stampa n in base 10 (versione ric.)
void print2(int n);   // stampa n in base 2  (versione ric.)
void print16(int n);  // stampa n in base 16 (versione ric.)
int length10(int n);   // numero cifre di n
int pos10(int n, int k);   // intero corrispondente alla cifra di n  in posizione k
void print10it(int n);  // stampa n in base 10 (versione it.)



int main(){
  int n;
  printf("Inserire n>=0  --->  ");
  scanf("%d", &n);
  if(n>=0){
    printf("\nStampa in base 10 (versione ric.)  ");
    print10(n);
    printf("\nStampa in base 2 (versione ric.)  ");
    print2(n);
    printf("\nStampa in base 16 (versione ric.)  ");
    print16(n);
    printf("\nNumero cifre (base 10): %d\n", length10(n)); 
    printf("Prima   cifra  (base 10): %d\n", pos10(n,length10(n)-1));
    printf("Ultima  cifra  (base 10): %d\n", pos10(n,0));
    printf("Stampa in base 10 (versione it.)  ");
    print10it(n);
    putchar('\n');
  }
  else
    printf("n deve essere >= 0\n");
  return 0;
}

/*****************************************************/


/*** NOTA  SULLA RAPPRESENTAZIONE DI INTERI NON NEGATIVI
     ==================================================


Dato un intero n>= 0

 n % 10  e' l'intero corrispondente all'ultima cifra della rappresentazione in base 10 di n

 n /10   e' l'intero la cui rappresentazione  in base 10
         e' data dalla rappresentazione in base 10 di n eliminando l'ultima cifra 

ESEMPIO

1725 % 10 = 5

1725 / 10 = 172


IN GENERALE

Data una base B >=2 

 n % B  e' l'intero corrispondente all'ultima cifra della rappresentazione in base B di n

 n /B   e' l'intero la cui rappresentazione  in base B
        e' data dalla rappresentazione in base B di n eliminando l'ultima cifra 



***/


/* Stampa un intero n>= 0  in base 10. 
   Versione ricorsiva  (ricorsione sul numero di cifre di n)   */

void print10(int n){
  if(n<10) // n ha una cifra
    putchar(n + '0');
  else{
    print10(n/10);  // stampa tutte le cifre tranne l'ultima 
    print10(n%10);  // stampa ultima cifra di n
// cosa succede invertendo le chiamate?
  }
}




/* Stampa un intero n>= 0  in base 2. 
   Versione ricorsiva  (ricorsione sul numero di cifre di n)   */

void print2(int n){
  if(n<2) // n ha una cifra
    putchar(n + '0');
  else{
    print2(n/2);  // stampa tutte le cifre tranne l'ultima 
    print2(n%2);  // stampa ultima cifra di n
  }
}


/* Stampa un intero n>= 0  in base 16. 
   Versione ricorsiva  (ricorsione sul numero di cifre di n)   */

void print16(int n){
  if(n<10) // n si rappresenta con uno dei caratteri '0', '1', ...,'9'
    putchar(n + '0');
  else if(n<16) // n si rappresenta con uno dei caratteri 'a'(n=10), 'b' (n=11), ...,'f'(n=15)
    putchar(n -10 + 'a');     
  else{
    print16(n/16);  // stampa tutte le cifre tranne l'ultima 
    print16(n%16);  // stampa ultima cifra di n
  }
}








/*****************************************************/


// prototipi funzioni usate in length10()



int length10_1(int n);
int length10_2(int n);
int length10_3(int n);





/* Restituisce il numero di cifre della rappresentazione in base 10
   di un intero n>= 0.
 */

int length10(int n){
  return  length10_1(n);
  // OPPURE:  return  length10_2(n);
  // OPPURE:  return  length10_3(n);
}




/* Restituisce il numero di cifre della rappresentazione in base 10
   di un intero n>= 0.
   Versione ricorsiva  (ricorsione sul numero di cifre di n)
   
 */

int length10_1(int n){
  if(n < 10)  // n ha una cifra
    return 1;
  else     // n ha piu' di 1 cifra
    return length10_1(n/10)+ 1;
}






/* Restituisce il numero di cifre della rappresentazione in base 10
   di un intero n>= 0.
   Versione iterativa. 
   
 */

int length10_2(int n){
  int k;
  for(k=1 ; n >= 10 ; k++)
    n = n/10;
  return k;
}




/* Restituisce il logaritmo in base b di n, con b>0, b!=1 e n>0 */

double lg(int b, int n){
  return log(n)/log(b);
}



/* Restituisce il numero di cifre della rappresentazione in base 10
   di un intero n>= 0.
   Calcolo diretto  mediante la formula.

     Parte intera(log_10(n)) + 1  

Il caso n=0 va trattato a parte, non essendo definito  log_10(0)
   
 */

int length10_3(int n){
  if(n == 0) 
    return 1;
  else
    return  floor(lg(10,n)) + 1;
  // OPPURE:
  //   return n == 0 ?  1 :  floor(lg(10,n)) + 1;
}



/*  Restituisce l'intero corrispondente alla cifra in posizione k 
    della rappresentazione in base 10  di un intero n>=0.
    Si assume 0 <= k < length10(n), dove:
     -  la posizione 0 corrisponde all'ultima cifra di n 
        (la cifra meno significativa)

    -  la posizione length10(n)-1  alla prima cifra di n  
       (la cifra piu' significativa)

*/

int pos10(int n, int k){
  n = n / (int)  pow(10,k); // il cast a int e' obbligatorio 
                            //  (altrimenti / e' la divisione fra double)
			    
  // n = intero ottenuto eliminando le cifre 0,1, ... k-1
  // la cifra in posizione k e' l'ultima di n
  return n %10;
}



/* Stampa un intero n>= 0  in base 10. 
   Versione iterativa.     */

void print10it(int n){
  int k;
  for(k = length10(n)-1; k >= 0; k--)
    putchar(pos10(n,k) + '0');
}


/* 

Le funzioni per la base 2 (oppure base 16) sono   analoghe, 
occorre 'sostituire' 10 con 2 (oppure 16)


*/