100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 2

Voici ce que fait l’algorithme ci-dessus:

• Initialise la variable rev ← 0.
• Dans la boucle TantQue multiplie le nombre inversé ‘rev’ par 10, ajoutez le reste du nombre original ‘Nbr’ divisé par 10 à ‘rev’.
  • C’est-à-dire, rev ← rev + (Nbr mod 10)
• Diviser le nombre original par 10.
  • Dans cette étape, la valeur du nombre original ‘Nbr’ est mise à jour en la divisant par 10. À chaque itération, le dernier chiffre du nombre original ‘Nbr’ est supprimé et la boucle se termine lorsque la valeur du nombre original ‘Nbr’ est égale à 0.

Maintenant, inversons le nombre 123 en utilisant l’algorithme ci-dessus.

Nbr = 123
rev = 0
rev = rev * 10 + Nbr mod 10 = 0 * 10 + 123 mod 10 = 3
Nbr = Nbr/ 10 = 12
rev = rev * 10 + Nbr mod 10 = 3 * 10 + 12 mod 10 = 32
Nbr = Nbr/ 10 = 1
rev = rev * 10 + Nbr mod 10 = 32 * 10 + 1 mod 10 = 321
Nbr = Nbr/10 = 0.

Le résultat sera donc 321.

• Lire(Nbr) : récupère la hauteur du triangle.
• Pour i de 0 à Nbr-1 : une itération correspond à une ligne du triangle.
• Pour j de 1 à (Nbr*2)-1 : parcourt toutes les positions de la ligne, des espaces jusqu'aux étoiles.
• Si (j >= Nbr-i et j <= Nbr+i) : détermine les colonnes où les étoiles doivent être affichées.
• Ecrire("*") : affiche une étoile.
• Ecrire(" ") : affiche un espace afin de conserver la forme pyramidale.
• Ecrire("\n") : passe à la ligne suivante une fois la ligne courante terminée.

Une façon simple de déterminer si un nombre est premier est de faire une boucle allant de 2 à n-1 et de vérifier si le nombre est divisible par n'importe quel nombre de cette plage. Si c'est le cas, il ne s'agit pas d'un nombre premier ; sinon, c'est le cas.

• Lire(Nbr): saisit le nombre à vérifier.
• i ← 2: initialise le premier diviseur possible.
• TantQue (Nbr mod i ≠ 0 et i < Nbr): continue les tests tant qu'aucun diviseur n'est trouvé et que i est inférieur à Nbr.
• i ← i + 1: essaie le diviseur suivant.
• Si (i = Nbr): si aucun diviseur n'a été trouvé avant d'atteindre Nbr, alors le nombre est premier.
• Sinon: un diviseur a été trouvé, donc le nombre n'est pas premier.

L'algorithme ci-dessus invite l'utilisateur à saisir 5 nombres dans un tableau nommé myTab, puis affiche le total des éléments pairs et impaires.

Déclarez et initialisez deux variables avec zéro pour stocker les nombres pairs et impairs.
pair ← 0 et impair ← 0.

La première boucle POUR demande à l'utilisateur de saisir 5 éléments dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 5, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau myTab[i].

La deuxième boucle POUR parcourt le tableau myTab de 0 à 5. A l'intérieur de la boucle, incrémenter le nombre pair de 1 si l'élément courant du tableau est pair. Sinon, on incrémente le nombre impair.

Enfin, nous affichons le résultat à l'aide de Ecrire().

La première instruction Ecrire demande à l'utilisateur d'entrer N nombre d'éléments dans le tableau Tab à l'aide d'une boucle POUR, et stocke chaque entrée dans l'index correspondant du tableau Tab[i].

La boucle POUR suivante itère ensuite sur chaque élément de Tab et sépare les éléments pairs et impairs dans deux tableaux différents Tab1 et Tab2, respectivement, à l'aide d'instructions Si-SiNon. Les variables j et k sont utilisées pour suivre les indices des éléments pairs et impairs dans les deux tableaux.

Enfin, les deux dernières instructions Ecrire (Ligne 24 et 28) affichent les éléments pairs et impairs trouvés, respectivement, en utilisant une boucle POUR pour itérer sur chaque élément des deux tableaux.

Pour résoudre ce problème, il faut connaître la valeur ASCII d'un caractère. C'est la façon la plus simple de déterminer si un caractère est alphabétique ou non. Ce problème est résolu à l'aide des détails suivants:

• Les lettres majuscules (A-Z) se situent dans la plage 65-91 de la valeur ASCII.
• Les lettres minuscules (a-z) se situent dans la plage 97-122 de la valeur ASCII.
• Toute valeur ASCII différente est un caractère non alphabétique.

L'algorithme ci-dessus invite l'utilisateur à saisir 10 nombres dans un tableau nommé myTab.

La première boucle POUR demande à l'utilisateur de saisir 10 éléments dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 10, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau myTab[i].

Initialiser la variable "compteur" avec 0 pour stocker le nombre de doublons.

Pour compter le nombre total d'éléments dupliqués dans un tableau donné, nous avons besoin de deux boucles. Exécutez une boucle extérieure de 0 à la taille(10). La structure de la boucle doit ressembler à Pour i de 1 à 10 faire. Cette boucle est utilisée pour sélectionner chaque élément du tableau et vérifier les éléments suivants pour les éléments en double en utilisant une autre boucle imbriquée.

Exécutez une autre boucle interne pour trouver le premier doublon de l'élément actuel du tableau. Exécutez une boucle interne de i + 1 à la taille(10), la structure de la boucle devrait ressembler à Pour j de i+1 à 10 faire. Pourquoi exécuter la boucle à partir de i + 1 ? Parce que nous devons rechercher les éléments en double dans les éléments suivants, à partir de l'élément actuel.

La boucle interne vérifie la présence d'un élément en double. Si c'est le cas, le compteur est incrémenté. C'est-à-dire Si(myTab[i] = myTab[j]) alors, compteur ← compteur + 1.

Voici la logique descriptive étape par étape:

• L'utilisateur entre la base et les exposants. Les stocker dans deux variables, b et e.
• Déclarer et initialiser une autre variable pour stocker la puissance, puissance ← 1.
• Exécutez une boucle de 1 à exposant, en incrémentant le compteur de la boucle de 1 à chaque itération. La structure de la boucle doit ressembler à Pour i de 1 à e faire.
• Pour chaque itération à l'intérieur de la boucle, multipliez la puissance par la base, c'est-à-dire puissance ← puissance * b.
• Enfin, à la fin de la boucle, il ne reste plus que la puissance dans la variable puissance.

• check ← 0 : suppose au départ que les nombres sont dans l'ordre.
• Lire(myTab[1]) : saisit le premier nombre du tableau.
• Pour i de 2 à 10 : saisit les autres nombres un par un.
• Si (myTab[i] < myTab[i-1]) : vérifie si un nombre est inférieur au précédent.
• check ← 1 : indique qu'au moins une valeur n'est pas dans l'ordre croissant.
• Si (check = 0) : si aucune inversion n'a été détectée, les nombres sont dans un ordre croissant.

Remarque: cet algorithme vérifie que les nombres sont classés par ordre croissant (non décroissant). Il ne vérifie pas qu'ils sont réellement successifs (par exemple 1, 2, 3, 4). Pour tester des nombres successifs, il faudrait vérifier que myTab[i] = myTab[i-1] + 1.