Remarques

• Un tableau commence à l'indice $0$. Le dernier élément d'un tableau déclaré par int T[nb_elements]; est donc placé à l'indice nb_elements - 1 et pas nb_elements.

• Quand le programme essaie d'accéder à un élément, le compilateur ne vérifie pas que l'indice soit correct. Si l'indice est incorrect, par exemple si on fait

  T[nb_elements] = 0; // on sort du tableau !
  

  deux choses peuvent se passer:

  • soit on écrase une donnée du programme, et la suite du programme ne va pas se dérouler correctement;
  • soit on essaie d'accéder à une partie de la mémoire qui n'appartient pas au programme, et le système d'exploitation arrête le programme, et affiche le message Segmentation fault.

  Il faut alors afficher les valeurs des différentes variables manipulées par le programme, comme vu pendant le cours.

Exercice 1 - Triangle(*)

Utilisez des boucles afin de construire un triangle isocèle formé par le caractère étoile (*). Affichez-en $n$ lignes, où $n$ est entré au clavier par l'utilisateur.

Exemple: pour $n$ = 5:

    *
   ***
  *****
 *******
*********

Exercice 2 - Tableaux

Recopiez le début de programme suivant:

#include <iostream>
#include <stdlib.h>

using namespace std;

int main(int argc, char ** argv)
{
  const int nb_elements = 10;

  int T[nb_elements];

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

  return 0;
}

1. Ajoutez le code qui affiche le tableau en colonne, puis changez votre code pour qu'il affiche le tableau en ligne.

2. Ajoutez le code qui calcule et affiche la somme, le produit, le plus petit et le plus grand des éléments de T. Attention: le produit peut devenir très grand et sortir de l'intervalle de représentation des int. Vous pouvez le déclarer en float pour éviter les problèmes.

   Utilisez une boucle pour l'initialisation, une autre pour l'affichage, une troisième pour le calcul de la somme, du produit, du minimum et du maximum.

3. Ajoutez la déclaration de 2 tableaux supplémentaires Tpairs et Timpairs. Ajoutez le code qui copie les éléments pairs de T dans Tpairs, et les éléments impairs dans Timpairs, puis qui affiche ces 2 tableaux. Pour déterminer si une valeur est paire, il suffit de tester si le reste de la division par 2 vaut 0.

   Utilisez une quatrième boucle pour la construction des tableaux Tpairs et Timpairs.

Exercice 3 - Conversion binaire - décimal

Nous allons représenter l'écriture d'une valeur en binaire par un tableau, appelé binaire, de 16 booléens. La valeur true représentera 1, la valeur false représentera 0. Le premier élément du tableau correspondra au premier bit sur la droite, le dernier élément au bit sur la gauche.

Par exemple, si binaire[0] vaut true, le premier bit sur la droite vaut 1.

1. Commencez par recopier le programme suivant:

   #include <iostream>
   
   using namespace std;
   
   int main(int argc, char ** argv)
   {
     bool binaire[16];
     int valeur;
     int valeur_apres_2_conversions;
   
     binaire[0]  = true;   binaire[1]  = false;   binaire[2]  = true;   binaire[3]  = false;
     binaire[4]  = false;  binaire[5]  = true;    binaire[6]  = true;   binaire[7]  = true;
     binaire[8]  = true;   binaire[9]  = false;   binaire[10] = true;   binaire[11] = true;
     binaire[12] = false;  binaire[13] = false;   binaire[14] = false;  binaire[15] = false;
   
     // ...
   
     return 0;
   }
   

   Ajoutez le code qui affiche le tableau binaire (à l'aide d'une boucle for) sous la forme:

   0000 1101 1110 0101
   

2. Remplacez le code qui initialise le tableau binaire par le code qui demande une valeur à l'utilisateur, et remplit le tableau binaire par l'écriture en binaire de la valeur. Rappel: l'écriture binaire est constituée des restes des divisions successives par 2. N'oubliez pas de remplir la partie gauche du tableau avec des 0, ou plutôt des false étant donné notre choix de représentation.

   Vérifiez votre programme. Pour la valeur 254, vous devez obtenir:

   0000 0000 1111 1110
   

3. Écrivez maintenant le code qui fait la conversion inverse, c'est-à-dire qui retrouve la valeur décimale du nombre représenté dans le tableau binaire. Affichez cette valeur et vérifiez qu'elle est bien identique à la valeur entrée.

4. Ajoutez le code qui décale les bits du tableau binaire d'un cran vers la gauche.

   Recopiez le code précédent pour trouver la valeur correspondant au tableau après le décalage et affichez-la. Que constatez-vous ?

Exercice 4 - Le Crible d'Ératosthène

Un nombre est dit premier s'il admet exactement 2 diviseurs distincts (1 et lui-même). 1 n'est donc pas premier.

Le crible d'Ératosthène une méthode de recherche des nombres premiers plus petits qu'un entier naturel $n$ donné. La méthode est simple:

• On commence par supprimer tous les multiples de 2 inférieurs à $n$.
• L'entier 3 n'a pas été supprimé et il ne peut être multiple des entiers qui le précèdent, sinon on l'aurait supprimé; il est donc premier. Supprimons alors tous les multiples de 3 inférieurs à $n$.
• L'entier 5 n'a pas été supprimé, il est donc premier. Supprimons tous les multiples de 5 inférieurs à $n$.
• Et ainsi de suite jusque $n$. Les valeurs n'ayant pas été supprimées sont les nombres entiers plus petits que $n$.

Écrivez le code qui applique cette méthode pour trouver les nombres premiers inférieurs à 100. Vous devez trouver: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97.

On utilisera un tableau de booléens:

  bool supprimes[100];

pour mémoriser les entiers qui ont été supprimés. N'oubliez pas d'initialiser chacun de ses éléments à false.