Afficher tous les nombres premiers inférieurs à un nombre donné

Enoncé
Ecrire un programme qui lit un entier n et affiche tous les nombres premiers inférieurs à n.

Solution
Dans cet exercice, l'enseignant tente de compliquer les choses pour pousser les étudiants à utiliser une boucle à l'intérieur d'une autre. C'est un autre exercice classique que nous rencontrons dans la majorité des livres d'introduction à l'algorithmique.

Le programme qui vérifie si un nombre donné est premier est expliqué ici.

Tous ce qui reste à faire c'est de parcourir les valeurs inférieurs à "n" et de tester pour chaque nombre est ce qu'il est premier ou pas.

Le code sera ainsi :

Program Premiers;

Var 
 n, i, j : Integer;
 diviseur : Boolean;

Begin
 
 WriteLn('Donnez la limite n : ');
 ReadLn(n);
 
 WriteLn('Les nombres premiers inférieurs à ', n, ' sont : ');
 {Boucle extérieure pour le parcours des valeurs}
 i := 2;
 While (i <= n) Do
 Begin
 
  j := 2;
  diviseur := false;
  
  {Boucle intérieur pour voir est ce que 
   la valeur i est un nombre premier}
  While ((j < i) And not(diviseur)) Do
  Begin
   If (i mod j = 0) Then
    diviseur := true
   Else
    j := j + 1;
  End;
  
  If (not(diviseur)) Then
   WriteLn(i);
  
  {Vérification de la valeur suivante}
  i := i + 1;
 End;
 
End.

Vérifier si un nombre est premier

Enoncé
Ecrire un programme qui lit un entier "n" et vérifie s'il est entier.

Solution
Comme j'ai mentionné ici, l'astuce du diviseur est un excellent moins pour faire des travaux dirigés sur la notion de la variable booléenne. Cette dernière est utilisée très souvent dans les boucles de type "Tant que" et "Répéter jusqu'à" comme une condition d'arrêt (pour sortir de la boucle).

Ainsi, les auteurs et les enseignants tentent de mettre cette "petite" astuce de diviseur dans des boucles.

Dans le cas de cet exercice, l'idée est de vérifier s'il est premier ou pas, c'est à dire, de rechercher un autre diviseur de "n" que "1" et "n" lui même. Cela implique un parcours des valeurs de 2 à n - 1 (l'optimisation n'est pas vraiment ma priorité actuellement) et voir si on peut trouver un diviseur.

On sort de la boucle si :

1. On termine le parcours des valeurs de 2 à n - 1 sans trouver un diviseur et le nombre n est déclaré premier.
2. On trouve un diviseur alors on n'a plus besoin de vérifier autre chose et le nombre n est déclaré non premier.

La présence de deux conditions dans la définition de la boucle nous oblige à faire une vérification pour savoir "pourquoi avons nous quitter la boucle ?".

Ainsi, le code sera de la forme :

Program Premier;

Var
 n, i : Integer;
 diviseur : Boolean;

Begin

 WriteLn('Donnez un nombre à tester : ');
 ReadLn(n);
 
 i := 2;
 diviseur :=  false;
 
 While (not(diviseur) And (i < n)) Do
 Begin
  If (n mod i = 0) Then
   diviseur := true
  Else
   i := i + 1;
 End;
 
 {Vérification pourquoi a-t-on quitté la boucle}
 If (diviseur) Then
  WriteLn('n n''est pas un nombre premier')
 Else
  WriteLn('n est un nombre premier');
 
End.