/* Voici le fichier constituant le solutionnaire des exercices
   de revision pour l'examen No 1 en INF155.
   Chacune des fonctions représente la solution d'une des 
   questions.
*/

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

int Question1(void);    /* cette fonction serait normalement le "main" d'un programme. */

int nbtermes(long max); /* Prototype de la fonction à définir pour la question 2 */
int Question2(void);

int Question3(void);

int sommeChiffres(int x); /* Prototype de la fonction à définir pour la question 4 */
int Question4(void);
int Question5(void);

#define MAX 5
int Question6(void);

long Fibo(int N); /* Prototype de la fonction à définir pour la question 7 */
int Question7(void);

double PuissR(double x, int n);/* Prototype de la fonction à définir pour la question 8 */
int Question8(void);
int Question9(void);

int somme_cubes(int x);/* Prototype de la fonction à définir pour la question 10 */
int Question10(void);

int main(void){
   Question1();
   Question2();
   Question3();
   Question4();
   Question5();
   Question6();
   Question7();
   Question8();
   Question9();
   Question10();
   return EXIT_SUCCESS;
}

/*
Écrire un programme qui lit une séquence de nombres entiers. À la première valeur
négative, la lecture des données s’arrête et les informations suivantes sont affichées à
l’écran : le nombre d’entiers lus, la valeur minimale et la valeur maximale dans la liste
(sans inclure la valeur négative). Si la liste est vide (donc, commence immédiatement
avec une valeur négative) le programme affiche 0, 0, 0.
*/
int Question1(void){
  /* Cette fonction serait normalement le "main" */
  int N, Nb, min, max;
  printf("\n\nQUESTION 1\n----------\n\n");
  Nb = min = max = 0;
  printf("Un nombre entier (terminez la liste par un nombre négatif): ");
  scanf("%i", &N);
  if (N >= 0)
    min = max = N;
  while (N >= 0){
    Nb++;
    if (N > max) max = N;
    if (N < min) min = N;
    printf("Un nombre entier (terminez la liste par un nombre négatif): ");
    scanf("%i", &N);
  }
  printf("%i nombres ont été lus, le min est %i et le max est %i\n", Nb, min, max);
  return EXIT_SUCCESS;
}
/*
Définissez la fonction « nbtermes » dont le prototype est :
int nbtermes(long max);
Cette fonction doit calculer et retourner le nombre de termes nécessaires pour que la série
(1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...etc) dépasse la valeur « max » reçue en paramètre.
La série est définie comme la somme des valeurs de 1 à n.
*/
int nbtermes(long max){
  long somme;
  int i;
  somme = 0;
  i = 0;
  while (somme <= max){
      i++;
      somme += i;
  }
  return i;
}

int Question2(void){
  printf("\n\nQUESTION 2\n----------\n\n");
  /* quelques tests... */
  printf("pour %i, la fonction = %i\n", 500, nbtermes(500));
  printf("pour %i, la fonction = %i\n", 2, nbtermes(2));
  printf("pour %i, la fonction = %i\n", 1, nbtermes(1));
  printf("pour %i, la fonction = %i\n", 0, nbtermes(0));
  return EXIT_SUCCESS;
}

/*
Dans réaliser ce programme, imaginons d’abord que nous nous trouvons devant une grille
à la position (0,0). Le but du programme est d’effectuer des déplacements aléatoires tant
et aussi longtemps que le déplacement est situé à l’intérieur d’un cercle de rayon R (qui
sera fourni par l’utilisateur). À chaque coup, vous vous déplacez au hasard de la position
(x, y) à une des quatre positions voisines (x+1, y), (x-1, y), (x, y+1), ou (x, y-1). Tant
que x^2 + y^2 <= R^2, le programme continue les déplacements. À la fin, le programme
affiche le nombre de déplacements effectués. AIDE : Générez un nombre aléatoire entre
0 et 3 pour connaître la direction à prendre.
*/
int alea_min_max(int inf, int sup){
   return inf + (1.0 * rand() / RAND_MAX) * (sup - inf);
}

int Question3(void){
  int x, y, R, nbdeplacements, direction;
  printf("\n\nQUESTION 3\n----------\n\n");
  nbdeplacements = 0;
  printf("Un nombre entier positif pour le rayon: ");
  scanf("%i", &R);
  x = y = 0;
  while (x*x + y*y < R*R){
      direction = alea_min_max(0,3);
      if (direction == 0) x++;
      if (direction == 1) x--;
      if (direction == 2) y++;
      if (direction == 3) y--;
      nbdeplacements++;
  }
  printf("Nous avons effectué %i déplacements.\n", nbdeplacements);
  return EXIT_SUCCESS;
}

/*
Complétez la boucle qui accumule dans « tot » la somme des chiffres d’un nombre « x ».
Exemples : Si « x » vaut 1234, alors « tot » vaudra 10. Si « x » vaut 10201 alors « tot »
vaudra 4.
int x, tot = 0;
while (x) {
  ______________________ ;
  x /= 10 ;
}
*/

int sommeChiffres(int x){
   int tot;
   tot = 0;
   while (x){
      tot += (x % 10); /* voici la ligne manquante */
      x /= 10;
   }
   return tot;
}

int Question4(void){
  printf("\n\nQUESTION 4\n----------\n\n");
  /* quelques tests... */
  printf("pour %i, somme des chiffres = %i\n", 500, sommeChiffres(500));
  printf("pour %i, somme des chiffres = %i\n", 1256, sommeChiffres(1256));
  printf("pour %i, somme des chiffres = %i\n", 10201, sommeChiffres(10201));
  printf("pour %i, somme des chiffres = %i\n", 847, sommeChiffres(847));
  return EXIT_SUCCESS;
}

int Question5(void){
  printf("\n\nQUESTION 5\n----------\n\n");
  printf("Erreur 1 : scanf(\"%%d\", a); il manque le &.\n");
  printf("Erreur 2 : MAX = 2*a; impossible d'effectuer une assignation sur une constante.\n");
  printf("Erreur 3 : void main() le main doit retourner un int en ANSI C.\n");
  return EXIT_SUCCESS;
}

int Question6(void){
  int I, J;
  printf("\n\nQUESTION 6\n----------\n\n");
  for (I = 1; I <= MAX; I++){ /* Il y a MAX lignes à écrire */
     for (J = 1; J < I; J++) /* Affichage des espaces */
        printf("  ");
     for (J = I; J <= MAX; J++)/* Affichage des chiffres sur la ligne */
        printf("%d ", J);
     printf("\n");
  }
  return EXIT_SUCCESS;
}

/*
Écrire la fonction « long Fibo(int N); » qui calcule et retourne le N ième terme
(pour tout N>0) de la série de fibonacci. À partir des 2 premiers termes (1, 1), la série de
fibonacci est contruite en faisant la somme des 2 termes précédents (pour tout i > 2):
*/
long Fibo(int N){
   long terme1, terme2, nouveauTerme;
   int i;
   terme1 = terme2 = nouveauTerme = 1;
   for (i = 2; i < N; i++){
      nouveauTerme = terme1 + terme2;
      terme1 = terme2;
      terme2 = nouveauTerme;
   }
   return nouveauTerme;
}

int Question7(void){
  printf("\n\nQUESTION 7\n----------\n\n");
  /* quelques tests... */
  printf("pour %i, Fibo = %i\n", 1, sommeChiffres(1));
  printf("pour %i, Fibo = %i\n", 2, sommeChiffres(2));
  printf("pour %i, Fibo = %i\n", 3, sommeChiffres(3));
  printf("pour %i, Fibo = %i\n", 14, sommeChiffres(14));
  return EXIT_SUCCESS;
}

/*
Écrire la fonction « double PuissR(double x, int n); » qui calcule et retourne
la valeur de x n en utilisant la méthode de calcul de puissance à la russe. Voiçi les étapes
de cette méthode :
1. On commence avec un accumulateur « total » à 1
2. Si la valeur « n » est impaire, on multiplie « total » par « x »
3. On multiplie « x » par lui-même pour le mettre au carré, et on divise « n » par 2
(division entière!! )
4. On répète 2-3 jusqu'à ce que la valeur de « n » soit 0.
*/
double PuissR(double x, int n){
   double total;
   total = 1;
   while (n){
      if (n % 2)
         total *= x;
      x *= x;
      n /= 2;
   }
   return total;
}

int Question8(void){
  printf("\n\nQUESTION 8\n----------\n\n");
  /* quelques tests... */
  printf("pour %f^%i = %f\n", 5.0, 6, PuissR(5, 6));
  printf("pour %f^%i = %f\n", 5.0, 0, PuissR(5, 0));
  printf("pour %f^%i = %f\n", 2.0, 32, PuissR(2, 32));
  printf("pour %f^%i = %f\n", 8.0, 16, PuissR(8, 16));
  return EXIT_SUCCESS;
}

/*
Écrire une boucle qui effectue la lecture répétitive d’un choix entier : seulement les
chiffre 0, et 1 doivent être acceptés.
*/
int Question9(void){
  int choix;
  printf("\n\nQUESTION 9\n----------\n\n");
  printf("Faites votre choix en tappant 0 ou 1 : ");
  scanf("%i", &choix);
  while (choix != 0 && choix != 1){
    printf("S.V.P. Faites votre choix en tappant 0 ou 1 : ");
    scanf("%i", &choix);
  }
  return EXIT_SUCCESS;
}

/*
Écrire une fonction int somme_cubes(int x); qui retourne 1 (vrai) si une
valeur « x » est égale à la somme des cubes de chacun de ses chiffres, et sinon retourne 0
(faux).
*/
int somme_cubes(int x){
   int somme, xoriginal, chiffre;
   somme = 0;
   xoriginal = x;
   while (x){
      chiffre = x % 10;
      somme += chiffre * chiffre * chiffre;
      x /= 10;
   }
   if (somme == xoriginal) return 1;
   return 0;
}

/*
Parmi tous les entiers plus grand que 1, seulement quatre peuvent être représentés par la
somme des cubes de leurs chiffres. Sachant que ces quatres nombres sont compris entre
150 et 410, écrire un programme pour trouver et afficher ces quatres nombres en utilisant
« somme_cubes( ) ».
*/
int Question10(void){
  int n;
  printf("\n\nQUESTION 10\n-----------\n\n");
  for (n = 150; n <= 410; n++){
      if (somme_cubes(n))
         printf("La somme des chiffres (au cube) de %i  == %i.\n", n, n);
  }
  return EXIT_SUCCESS;
}