Exercice 1 - Triangle(*)

La difficulté de cet exercice consiste essentiellement à trouver la relation entre le numéro de ligne et le nombre d'étoiles et d'espaces. Soit $n$ le nombre total de lignes, et $i$ le numéro de ligne, commençant à 0. Le nombre d'espaces est donné par $s=n-i$, et le nombre d'étoiles vaut $e=2\cdot i+1$.

#include <iostream>

using namespace std;

int main(int argc, char **argv)
{
  int n;

  cout << "Entrez le nombre de lignes du triangle: ";
  cin >> n;

  for (int i=0; i<n; i++) {
    // ecrit les espaces avant le triangle
    for (int j=1; j<(n-i); j++)
      cout << " ";

    // ecrit les etoiles du triangle
    for (int j=0; j<(2*i+1); j++)
      cout << "*";

    // retour de ligne
    cout << endl;
  }

  return 0;
}

Exercice 2 - Tableaux

1. Pour afficher un tableau en colonne, il faut afficher un retour de ligne (endl) après chaque élément du tableau. endl représente un caractère spécial qui fait passer l'affichage à la ligne suivante. Il ne peut s'utiliser qu'à l'intérieur d'une instruction cout.
2. Notez que lorsqu'on déclare un tableau (exemple: int tableau[20];), ses éléments ne sont pas initialisés. Cela signifie que la valeur contenue dans les éléments du tableau est (plus ou moins) aléatoire. Comme pour les variables, il n'est pas conseillé de lire le contenu d'un tableau avant son initialisation, vu qu'on ne sait jamais ce qu'on va y trouver.

   En particulier, - contrairement à ce qui est proposé dans ce corrigé - il est possible de calculer le maximum et le minimum en affectant la valeur du premier élément du tableau aux variables min et max, et en parcourant ensuite le reste du tableau. Dans ce cas, il faut prendre soin de n'affecter leur valeur initiale à min et max qu'après avoir initialisé le tableau!

3. Comme les éléments de T sont générés aléatoirement, il est impossible de connaître à l'avance la taille des tableaux Tpairs et Timpairs. Tout ce que nous savons, c'est qu'ils auront au plus nb_elements éléments. La solution consiste donc à déclarer 2 tableaux de taille nb_elements.

   Pour peupler Tpairs et Timpairs, on parcourt T et on ajoute ses éléments à Tpairs et Timpairs en fonction de leur parité. Il faut maintenir un indice séparé pour chacun des deux tableaux Tpairs et Timpairs.

   Finalement, pour leur affichage, il faut prendre soin d'afficher le bon nombre d'éléments qui ont effectivement été insérés dans ces tableaux.

#include <iostream>

using namespace std;

int main(int argc, char **argv)
{
  const int nb_elements = 10;
  
  int T[nb_elements];
  int Tpairs[nb_elements];
  int Timpairs[nb_elements];
  int somme = 0;
  float produit = 1; // int est trop petit pour le produit
  int nb_pairs = 0, nb_impairs = 0;
  int min = 100;  // on sait que les nombres seront
  int max = 0;    // compris entre 0 et 100

  // initialisation
  for(int i = 0; i < nb_elements; i++)
    T[i] = rand() % 100 + 1;

  // affichage du tableau en colonne
  for (int i=0; i<nb_elements; i++)
    cout << T[i] << endl;

  // affichage du tableau en ligne
  for (int i=0; i< nb_elements; i++)
    cout << T[i] << " ";
  cout << endl;

  // calcul du produit, de la somme, etc.
  for (int i=0; i<nb_elements; i++)
    {
      somme += T[i];
      produit *= T[i];
      if (T[i] < min) min = T[i];
      if (T[i] > max) max = T[i];

    }
   
  cout << "La somme de tous les elements de T est " << somme << endl;
  cout << "Le produit de tous les elements de T est " << produit << endl;
  cout << "Le plus petit element de T est " << min << endl;
  cout << "Le plus grand element de T est " << max << endl;

  // construction de Tpairs et Timpairs
  for (int i=0; i<nb_elements; i++)
    {
      if ((T[i] % 2) == 0)
        {
          Tpairs[nb_pairs] = T[i];
          nb_pairs++;
        }
      else
        {
          Timpairs[nb_impairs] = T[i];
          nb_impairs++;
        }
    }

  cout << "Les nombres pairs de T sont: " << endl;
  for (int i = 0; i < nb_pairs; i++)
    cout << "Tpairs[" << i << "] = " << Tpairs[i] << endl;
  
  cout << "Les nombres impairs de T sont: " << endl;
  for (int i = 0; i < nb_impairs; i++)
    cout << "Timpairs[" << i << "] = " << Timpairs[i] << endl;

  return 0;
}

Exercice 3 - Conversion binaire - décimal

1. Idéalement, il faudrait s'assurer que le nombre entré est plus petit que $2^{16}$. Ici, on ne le fait pas et si l'utilisateur entre un nombre plus grand, il sera tronqué.

2. Pour convertir un nombre binaire en décimal, il suffit d'additionner les puissances de 2 correspondant à chacun des bits.

3. Lorsqu'on décale les bits d'un tableau de binaires d'un cran vers la gauche, on multiplie le nombre par 2. Un déplacement d'un cran vers la droite correspond à une division entière par 2. On comprendra aisément ce qui se passe, si on applique le même décalage à un nombre en base 10.

   Notez que, lors d'un décalage des bits sur la gauche, les bits les plus à gauche sont perdus, et les nouveaux bits à droite sont égaux à 0. Il ne faut pas remettre au début les bits qui sont sortis du tableau à gauche. La même chose est valable lors d'un décalage à droite.

#include <iostream>

using namespace std;

int main(int argc, char ** argv)
{
  const int nb_bits = 16;
  bool binaire[nb_bits];
  int valeur;
  int valeur_apres_2_conversions;
  int puissance;

  cout << "Entrez un entier: ";
  cin >> valeur;

  // conversion decimal -> binaire
  int v = valeur;
  for (int i=0; i<nb_bits; i++)
    {
      binaire[i] = v % 2 == 1;
      v /= 2;
    }
  
  // affichage du nombre binaire
  for (int j=nb_bits-1; j>=0; j--)
    {
      cout << binaire[j];
      if (j % 4 == 0) // ajoute un espace chaque 4 bits
        cout << " ";
    }
  cout << endl;

  // conversion inverse
  puissance = 1;
  valeur_apres_2_conversions = 0;
  for (int i=0; i<nb_bits; i++)
    {
      valeur_apres_2_conversions += binaire[i] * puissance;
      puissance *= puissance;
    }

  cout << "Valeur retrouvee: " << valeur_apres_2_conversions << endl;

  // decalage des bits vers la gauche
  for (int i=nb_bits-1; i>0; i--)
    binaire[i] = binaire[i-1];
  binaire[0] = false;

  // affichage du binaire
  for (int j=nb_bits-1; j>=0; j--) 
    {
      cout << binaire[j];
      if (j % 4 == 0) // ajoute un espace chaque 4 bits
        cout << " ";
    }
  cout << endl;

  // conversion inverse
  puissance = 1;
  valeur_apres_2_conversions = 0;
  for (int i=0; i<nb_bits; i++)
    {
      valeur_apres_2_conversions += binaire[i] * puissance;
      puissance *= 2;
    }

  cout << "Valeur apres decalage: " << valeur_apres_2_conversions << endl;

  return 0;
}

Exercice 4 - Le Crible d'Ératosthène

La meilleure technique pour résoudre cet exercice consiste à se servir d'un tableau de boolean, initialisé à false. On parcourt ensuite le tableau en enlevant (i.e. en mettant à true) les multiples des nombres premiers.

#include <iostream>

using namespace std;

int main(int argc, char **argv)
{
  bool supprimes[100];

  supprimes[0] = true;   // 0 n'est pas premier
  supprimes[1] = true;   // 1 n'est pas premier
  for (int i=2; i<100; i++)
    supprimes[i] = false;

  for (int i=2; i<100; i++)
    if (!supprimes[i]) {
        int multiple = 2 * i;
        while (multiple < 100) {
          supprimes[multiple] = true;
          multiple += i;
        }
    }

  for (int i=0; i<100; i++)
    if (!supprimes[i])
      cout << i << " ";

  cout << endl;

  return 0;
}