Choisissez votre style : colorisé, impression

Correction 4
Boucles conditionnelles et itérations

Les solutions suivantes ne sont évidemment pas uniques. Si vous en trouvez de meilleures (ou si vous trouvez des erreurs), faites-le savoir ! Merci.
Par ailleurs, les solutions proposées correspondent à l'état de vos connaissances au moment où la série est abordée. D'autres solutions pourront être envisagées une fois de nouveaux concepts acquis.
Exercice 1 Exercice 2 Exercice 3 Exercice 4 Exercice 5 Exercice 6 Exercice 7 Exercice 8

Exercice 1 : tables de multiplication

Exercice n°3 (pages 19 et 199) de l'ouvrage C++ par la pratique. 
#include <iostream> 
using namespace std;
 
int main()
{ 
    cout << "     Tables de multiplication" << endl;
    for (int i(2); i <= 10; ++i) { 
        cout << endl << " Table de " << i << " :" << endl; 
        for (int j(1); j <= 10; ++j) { 
            cout << "    " << i << " * " << j << " = " << i*j << endl; 
        }
    }
    return 0; 
}

Exercice 2 : rebonds de balles (1)

Exercice n°6 (pages 21 et 202) de l'ouvrage C++ par la pratique. 
#include <iostream>
#include <cmath>
using namespace std;
 
constexpr double g(9.81); // la constante de gravité terrestre
 
int main()
{
  // Saisie des valeurs, avec test de validité ------------
  double eps; // coefficient de rebond de la balle
  do {
    cout << "Coefficient de rebond (0 <= coeff < 1) : ";
    cin >> eps;
  } while ( (eps < 0.0) or (eps >= 1.0) );
 
  double h0; // hauteur avant rebond
  do {
    cout << "Hauteur initiale      (h0 > 0)         : ";
    cin >> h0;
  } while (h0 <= 0.0);
 
  int n; // nombre de rebonds à simuler
  do {
    cout << "Nombre de rebonds     (n >= 0)         : ";
    cin >> n;
  } while (n < 0);
 
  // Declarations -----------------------------------------
  double h1;           // hauteur après le rebond
  double v0, v1;       // vitesses avant et après le rebond
 
  // Boucle de calcul -------------------------------------
  for (int rebonds(1); rebonds <= n; ++rebonds) {
    // on fait une iteration par rebond
    v0 = sqrt(2.0 * g * h0);   // vitesse avant rebond
    v1 = eps * v0;             // vitesse apres le rebond
    h1 =(v1 * v1) / (2.0 * g); // hauteur après rebond
    h0 = h1;   // qui devient nouvelle haut. avant rebond suivant
  }
 
  // Affichage du resultat --------------------------------
  cout << "Au " << n
       << "e rebond, la hauteur atteinte est de " << h0 << endl;
  return 0;
}

Exercice 3 : rebonds de balles (2)

Exercice n°7 (pages 22 et 203) de l'ouvrage C++ par la pratique.

La différence entre cet exercice et le précédent réside dans la condition d'arrêt du calcul. Au lieu d'avoir un nombre fixe d'itération entré par l'utilisateur, facilement utilisable dans une boucle for, celui-ci est variable. Une boucle do..while qui compare le résultat du dernier calcul avec la valeur h_fin entrée par l'utilisateur est donc plus judicieuse. 

#include <iostream>
#include <cmath>
using namespace std;
 
constexpr double g(9.81); // la constante de gravité terrestre
 
int main()
{
  // Saisie des valeurs, avec test de validité ------------
  double eps; // coefficient de rebond de la balle
  do {
    cout << "Coefficient de rebond (0 <= coeff < 1) : ";
    cin >> eps;
  } while ( (eps < 0.0) or (eps >= 1.0) );
 
  double h0; // hauteur avant rebond
  do {
    cout << "Hauteur initiale      (h0 > 0)         : ";
    cin >> h0;
  } while (h0 <= 0.0);
 
  double h_fin; // hauteur finale
  do {
    cout << "Hauteur finale        (0 < h_fin < h0) : ";
    cin >> h_fin;
  } while ( (h_fin <= 0.0) or (h_fin >= h0) );
 
  // Declarations -----------------------------------------
  double h1;           // hauteur après le rebond
  double v0, v1;       // vitesses avant et après le rebond
  int rebonds(0);      // nombre de rebonds
 
  // Boucle de calcul -------------------------------------
  do {
    ++rebonds;                  // une iteration par rebond
    v0 = sqrt(2.0 * g * h0);    // vitesse avant rebond
    v1 = eps * v0;              // vitesse apres le rebond
    h1 = (v1 * v1) / (2.0 * g); // hauteur après rebond
    h0 = h1;   // qui devient nouvelle haut. avant rebond suivant
  } while (h0 > h_fin);
 
  // Affichage du resultat --------------------------------
  cout << "La balle rebondit " << rebonds
       << " fois avant que la hauteur de rebond (" << h0
       << ") soit inférieure à la limite de " << h_fin << endl;
  return 0;
}

Exercice 4 : nombres premiers

Exercice n°9 (pages 22 et 205) de l'ouvrage C++ par la pratique. 
#include <iostream>
#include <cmath>
using namespace std;
 
int main()
{
    int n;               // le nombre à tester
    bool premier(true);  // résultat du test de primalité
    int diviseur(1);
 
    // Saisie du nombre à tester
    do {
        cout << "Entrez un nombre entier > 1 : ";
        cin >> n;
    } while (n <= 1);
 
    if (n % 2 == 0) {
        // le nombre est pair
        if (n != 2) {
            premier  = false;
            diviseur = 2;
        }
    } else {
        const double borne_max(sqrt(n));
        for (int i(3); (premier) and (i <= borne_max); i += 2) {
            if (n % i == 0) {
                premier  = false;
                diviseur = i;
            }
        }
    }
 
    cout << n ;
    if (premier) {
        cout << " est premier" << endl;
    } else {
        cout << " n'est pas premier, car il est divisible par "
             << diviseur << endl;
    }
    return 0;
}

Résultats :

2 est premier
16 n'est pas premier, car il est divisible par 2
17 est premier
91 n'est pas premier, car il est divisible par 7
589 n'est pas premier, car il est divisible par 19
1001 n'est pas premier, car il est divisible par 7
1009 est premier
1299827 est premier
2146654199 n'est pas premier, car il est divisible par 46327
(Niveau Avancé)  

Remarques :

Si vous souhaitez tester des nombres plus grands que 2147483647 (c'est-à-dire 231-1, qui d'ailleurs est premier !), remplacez
int n;
par
unsigned long int n;

Il faut aussi changer la déclaration de i dans le for :

for (unsigned long int i(3);

Vous pouvez alors tester jusqu'à 4294967295 (Essayez par exemple 4292870399).
La signification de tout cela sera vue plus tard dans le cours.

Pour ceux qui aimeraient tester de plus grand nombre encore, vous pouvez remplacer les entiers précédents (int puis unsigned long int) par (n'oubliez pas de le faire pour n et pour i) :

unsigned long long int n;

Ceci vous permet d'aller jusqu'à 18446744073709551615 (Essayez par exemple 18446744073709551577 ou 18446744073709551557 (il faut attendre un moment !)).

Exercice 5 : histoire de prêt

Exercice n°8 (pages 22 et 204) de l'ouvrage C++ par la pratique. 
#include <iostream>
using namespace std;
 
int main()
{
    double S0(0.0);
    do {
        cout << "Somme prêtée                    (S0 > 0) : ";
        cin >> S0;
    } while (S0 <= 0.0);
 
    double r(0.0);
    do {
        cout << "Montant fixe remboursé chaque mois (r > 0) : ";
        cin >> r;
    } while (r <= 0.0);
 
    double ir(0.0);
    do {
        cout << "Taux d'intérêt en % (0 < tx < 100) : ";
        cin >> ir;
    } while ( (ir <= 0.0) or (ir >= 100.0) );
    ir /= 100.00;
 
    double cumul(0.0); // somme des intérêts (cumulés)
    double S(S0);      // somme restant à rembourser
    int nbr(0);        // nombre de remboursements
 
    while (S > 0.0) {
        ++nbr;
        cumul = cumul + ir * S;
        S = S - r;
        cout << nbr << ": S=" << S << ", cumul=" << cumul << endl;
    }
    cout << "Somme des intérêts encaissés : " << cumul
         << "  (sur " << nbr << " mois)." << endl;
    return 0;
}

Remarque : on aurait aussi pu écrire la boucle à l'aide d'une itération for, par exemple :

for (double S(S0); S > 0.0; S -= r) {
  ++nbr;
  cumul += ir * S;
}

Exercice 6 : Suite et série

a)
#include <iostream>
using namespace std;
 
int main()
{
  double U(1.0);
 
  for (int n(1); n <= 10; ++n) {
    U = U / n; // ou aussi : U /= n;
    cout << "U" << n << " = " << U << endl;
  }
 
  return 0;
}
b)
#include <iostream>
using namespace std;
 
int main()
{
  double U(1.0);
  double V(U); // V0 = U0
 
  for (int n(1); n <= 10; ++n) {
    U = U / n; // ou aussi : U /= n;
    V = V + U; // ou aussi : V += U;
    cout << "U" << n << " = " << U
         << "        V" << n << " = " << V 
         << endl;
  }
 
  return 0;
}

Exercice 7 : Figures en mode texte

L'affichage d'une ligne se fait à l'aide d'une simple boucle for. Pour afficher plusieurs lignes, il faudra imbriquer 2 boucles for.

Pour le triangle, la longueur d'une ligne est fonction du numéro de ligne. Donc, la condition d'arrêt de la boucle écrivant une ligne dépendra du compteur de la boucle parent (j).

Pour la pyramide inversée, il suffit de rajouter un nombre variable d'espaces avant les nombres. 

#include <iostream>
 
using namespace std;
 
int main()
{
  // 1.
  for (int i(1); i <= 9; ++i) {
    cout << i;
  }
  cout << endl << endl;
 
  // 2.
  for (int j(1); j <= 9; ++j) {
    for (int i(1); i <= 9; ++i) {
      cout << i;
    }
    cout << endl;
  }
  cout << endl;
 
  // 3.
  for (int j(1); j <= 9; ++j) {
    for (int i(1); i <= j; ++i) { // la boucle va de 1 a j !!
      cout << i;
    }
    cout << endl;
  }
  cout << endl;
 
  // 4.
  for (int j(1); j <= 9; ++j) {
    for (int i(1); i <= (9-j); ++i) {
      cout << " ";
    }
    for (int i(1); i <= j; ++i) {
      cout << i;
    }
    cout << endl;
  }
  cout << endl;
 
  return 0;
}

Exercice 8 : 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 i + 1. 

#include <iostream>
using namespace std;
 
int main()
{
  cout << "Entrez le nombre de lignes du triangle : ";
  int n;
  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 a la ligne
    cout << endl;
  }
 
  return 0;
}
Dernière mise à jour : 2025/10/02 (15:32)