Exercices Corrigés En Algorithme – Les boucles
La meilleure façon d’apprendre quelque chose est de pratiquer des exercices. Nous avons préparer ces exercices corrigés pour les personnes (débutantes ou intermédiaires) qui sont familières avec les algorithmes. Nous espérons que ces exercices vous aideront à améliorer vos compétences sur les boucles en algorithmique tels que la boucle ‘POUR’, ‘TantQue’, et ‘Répéter Jusqu’à’.
Vous pouvez lire notre tutoriel sur les algorithmes avant de résoudre les exercices suivants.
1. Écrire un algorithme qui affiche 10 fois « Hello ». En utilisant la boucle Tant que.
Exemple de sortie:
Hello Hello Hello Hello Hello Hello Hello Hello Hello Hello
Algorithme Hello10Fois
Variable n: entier
Début
n ← 1 // Initialise le compteur à 1
// Répète la boucle tant que n est inférieur ou égal à 10
TantQue(n <= 10) faire
Ecrire("Hello") // Affiche "Hello" à chaque répétition
n ← n + 1 // Incrémente le compteur de 1
FinTantQue
Fin
Dans cet algorithme, la boucle TantQue continuera à s'exécuter tant que la variable n est inférieure ou égale à 10. À l'intérieur de la boucle, le texte est affiché, puis la variable n est incrémentée de 1 jusqu'à ce que la condition ne soit plus remplie. Voici l'organigramme de cet algorithme:
2. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle TantQue.
Indication:
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55
Exemple de sortie:
La somme de 1 à 10 est 55
Algorithme Somme1A10
Variable i,sum: entiers
Début
i ← 1 // Initialise le compteur à 1
sum ← 0 // Initialise la somme à 0
// Répète la boucle tant que i est inférieur ou égal à 10
TantQue(i <= 10) faire
sum ← sum + i // Ajoute la valeur de i à la somme
i ← i + 1 // Incrémente le compteur de 1
FinTantQue
Ecrire("La somme de 1 à 10 est: ",sum) //Affiche la somme finale
Fin
Dans la boucle TantQue ci-dessus, la variable i est initialisée à 1 et la boucle se poursuit tant que i est inférieur ou égal à 10. À chaque itération de la boucle, la variable sum s'additionne à la valeur de i.
Enfin, la boucle incrémente la valeur de i de 1, et le processus se répète jusqu'à ce que la condition i <= 10 ne soit plus vraie. Dans ce cas on affiche le message "La somme de 1 à 10 est: sum".
Organigramme:
3. Écrire un algorithme pour calculer la factorielle d'un nombre entier saisi par l'utilisateur en utilisant la boucle 'POUR'. (Remarque: le factoriel de 5, qui s'écrit 5! = 5 × 4 × 3 × 2 × 1).
Exemple de sortie:
Saisir un nombre : 5 Le factoriel de 5 est: 120
Algorithme Factoriel
Variables nbr,f,i: entiers
Début
Ecrire("Saisir un nombre")
Lire (nbr) // Lit le nbr dont on veut calculer factoriel
f ← 1 // Initialise le factoriel à 1
// Parcourt tous les entiers de 1 jusqu'à nbr
Pour i de 1 jusqu'à nbr faire
f ← f * i // Multiplie progressivement le résultat par i
FinPour
// Affiche le résultat du factoriel
Ecrire("Le factoriel de ",nbr," est: " f)
Fin
Explications:
- Lire(nbr) : récupère le nombre saisi par l'utilisateur.
- f ← 1 : initialise le résultat à 1, car le factoriel est calculé par des multiplications.
- Pour i de 1 jusqu'à nbr : parcourt tous les nombres entiers de 1 à nbr.
- f ← f * i : multiplie progressivement f par chaque entier. Par exemple, pour 5 : 1 × 1 × 2 × 3 × 4 × 5 = 120.
- Ecrire(...) : affiche le factoriel calculé.
Voici l'organigramme de cet algorithme:
4. A quoi sert l'algorithme suivant?
Variable nbr : entier
Debut
nbr ← 0
Ecrire("Entrez un nombre entre 1 et 5")
TantQue(nbr < 1 ou nbr > 5)
Lire(nbr)
Si(nbr < 1 ou nbr > 5) Alors
Ecrire("Nombre incorrect. Recommencez")
FinSi
FinTantQue
Fin
Cet algorithme sert à demander à l’utilisateur de saisir un nombre compris entre 1 et 5, puis à vérifier que la valeur saisie est valide.
Explication:
- nbr ← 0 : initialise la variable nbr à 0.
Ecrire("Entrez un nombre entre 1 et 5"): demande à l’utilisateur de saisir un nombre.- TantQue(nbr < 1 ou nbr > 5) : répète la saisie tant que le nombre est inférieur à 1 ou supérieur à 5.
- Lire(nbr) : récupère le nombre saisi.
- Si le nombre est incorrect, l'algorithme affiche « Nombre incorrect. Recommencez ».
- Lorsque l'utilisateur saisit finalement un nombre entre 1 et 5, la boucle s'arrête.
Organigramme:
5. Ecrivez un algorithme qui calcule la somme de 1 à N, où N est saisi par l'utilisateur. En utilisant la boucle TantQue.
Indication:
1 + 2 + 3 + 4 + 5 + 6 + 7 = 28
Exemple de sortie:
Entrer un nombre: 7 La somme de 1 à 10 est 28
Algorithme SommeDe1AN
Variables i,sum,n: entiers
Debut
i ← 1 // Initialise le compteur à 1
sum ← 0 // Initialise la somme à 0
Ecrire("Entrer un nombre:")
Lire(n) // Lit la valeur de n saisie par l'utilisateur
// Répète la boucle tant que i est inférieur ou égal à n
TantQue(i <= n) faire
sum ← sum + i // Ajoute la valeur actuelle de i à la somme
i ← i + 1 // Incrémente i de 1 pour passer au nombre suivant
FinTantQue
Ecrire("La somme de 1 à n est:",sum) // Affiche la somme calculée
Fin
La boucle TantQue est itérée n fois. À chaque itération, la valeur de i est ajoutée à la somme sum et i est incrémenté de 1.
- i ← 1 : initialise le compteur à 1, car la somme commence par 1.
- sum ← 0 : initialise la somme à zéro avant de commencer les additions.
- Lire(n) : permet à l'utilisateur de saisir la valeur maximale n.
- TantQue (i <= n) : répète les opérations tant que i n'a pas dépassé n.
- sum ← sum + i : ajoute chaque nombre compris entre 1 et n à la somme.
- i ← i + 1 : augmente le compteur de 1 à chaque tour de boucle.
- Ecrire(...) : affiche la somme finale de tous les nombres de 1 à n.
Organigramme:
6. Ecrivez un algorithme qui affiche "Hello" 10 fois. En utilisant la boucle POUR.
Exemple de sortie:
Hello Hello Hello Hello Hello Hello Hello Hello Hello Hello
Algorithme Hello10Fois
Variable n: entier
Début
Pour n de 1 jusqu'à 10 faire // Répète la boucle 10 fois, de 1 à 10
Ecrire("Hello") // Affiche "Hello" à chaque répétition
FinPour
Fin
Dans cet algorithme, la boucle POUR continuera à s'exécuter tant que la variable n est inférieure ou égale à 10. À l'intérieur de la boucle, le texte est affiché, puis la variable n est incrémentée de 1 jusqu'à ce que la condition ne soit plus remplie. Voici l'organigramme de cet algorithme:
7. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle POUR.
Indication:
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55
Exemple de sortie:
La somme de 1 à 10 est 55
Algorithme Somme1A10
Variable i,sum: entiers
Début
sum ← 0 // Initialise la somme à 0
Pour i de 1 jusqu'à 10 faire // Parcourt les nombres de 1 à 10
sum ← sum + i // Ajoute la valeur actuelle de i à la somme
FinPour
Ecrire("La somme de 1 à 10 est:", sum) // Affiche la somme finale
Fin
Dans la boucle POUR ci-dessus, la variable i est initialisée à 1 et la boucle se poursuit tant que i est inférieur ou égal à 10. À chaque itération de la boucle, la variable sum s'additionne à la valeur de i.
- sum ← 0 : initialise la variable sum à zéro avant de commencer les additions.
- Pour i de 1 jusqu'à 10 faire : utilise une boucle Pour pour parcourir tous les nombres de 1 à 10.
- sum ← sum + i : ajoute chaque valeur de i à la somme.
- FinPour : marque la fin de la boucle.
- Ecrire(...) : affiche la somme obtenue après avoir additionné tous les nombres.
Organigramme:
8. Ecrivez un algorithme qui calcule la somme de 1 à N, où N est saisi par l'utilisateur. En utilisant la boucle POUR.
Indication:
1 + 2 + 3 + 4 + 5 + 6 + 7 = 28
Exemple de sortie:
Entrer un nombre: 7 La somme de 1 à 10 est 28
Algorithme SommeDe1AN
Variables i,sum,n: entiers
Début
sum ← 0 // Initialise la somme à 0
Ecrire("Entrer un nombre:")
Lire(n) // Lit la valeur de n saisie par l'utilisateur
Pour i de 1 jusqu'à n faire // Parcourt tous les nombres de 1 à n
sum ← sum + i // Ajoute la valeur actuelle de i à la somme
FinPour
Ecrire("La somme de 1 à n est:",sum) // Affiche la somme finale
Fin
La boucle POUR est itérée n fois. À chaque itération, la valeur de i est ajoutée à la somme sum et i est incrémenté de 1.
- sum ← 0 : initialise la somme à zéro avant de commencer les calculs.
- Lire(n) : lit le nombre saisi par l'utilisateur, qui représente la limite de la somme.
- Pour i de 1 jusqu'à n faire : répète les instructions pour tous les nombres compris entre 1 et n.
- sum ← sum + i : ajoute chaque nombre à la somme.
- FinPour : indique la fin de la boucle.
- Ecrire(...) : affiche la somme finale des nombres de 1 à n.
Organigramme:
9. Écrire un algorithme qui affiche la table de multiplication de 3. En utilisant la boucle For.
Exemple de sortie:
3 x 0 = 0 3 x 1 = 3 3 x 2 = 6 3 x 3 = 9 3 x 4 = 12 3 x 5 = 15 3 x 6 = 18 3 x 7 = 21 3 x 8 = 24 3 x 9 = 27 3 x 10= 30
Algorithme TableMultiplication
Variable i:entier
Début
Pour i de 0 jusqu'à 10 faire // Parcourt les nombres de 0 à 10
Ecrire("3 x ",i," = ",i*3) //Calcule & affiche le résultat de 3 × i
FinPour
Fin
Nous utilisons la boucle POUR pour afficher la table de multiplication de 3. La boucle s'exécute de i = 1 à i = 10. À chaque itération de la boucle, i * 3 est affiché.
- Pour i de 0 jusqu'à 10 faire : utilise une boucle Pour pour parcourir les valeurs de 0 à 10.
- Ecrire("3 x ", i, " = ", i * 3) : affiche chaque opération de la table de multiplication de 3.
- i * 3 : multiplie la valeur actuelle de i par 3.
- FinPour : indique la fin de la boucle.
Organigramme:
10. Écrire un algorithme qui affiche la table de multiplication d'un entier saisi par l'utilisateur, en utilisant la boucle POUR.
Exemple de sortie:
Entrer un nombre: 7 7 x 0 = 0 7 x 1 = 7 7 x 2 = 14 7 x 3 = 21 7 x 4 = 28 7 x 5 = 35 7 x 6 = 42 7 x 7 = 49 7 x 8 = 56 7 x 9 = 63 7 x 10= 70
Algorithme TableMultiplicationDeN
Variables i,n :entiers
Début
Ecrire("Donner un nombre:")
Lire(n) // Lit le nombre dont on veut afficher la table
Pour i de 0 jusqu'à 10 faire //Parcourt les multiplicateurs de 0 à 10
// Calcule et affiche chaque multiplication
Ecrire(n," x ",i," = ",i*n)
FinPour
Fin
Nous utilisons la boucle POUR pour afficher la table de multiplication de n. La boucle s'exécute de i = 1 à i = 10. À chaque itération de la boucle, i * n est affiché.
- Lire(n) : permet à l'utilisateur de saisir le nombre dont il souhaite obtenir la table de multiplication.
- Pour i de 0 jusqu'à 10 faire : répète les instructions pour les valeurs de i allant de 0 à 10.
- Ecrire(n, " x ", i, " = ", i * n) : affiche chaque opération de multiplication.
- i * n : calcule le résultat de la multiplication entre le nombre saisi n et le multiplicateur i.
- FinPour : indique la fin de la boucle.
Organigramme:
11. Ecrivez un algorithme qui affiche "Hello" 10 fois. En utilisant la boucle Répéter Jusqu’à.
Exemple de sortie:
Hello Hello Hello Hello Hello Hello Hello Hello Hello Hello
Algorithme Hello10Fois
Variables i: entier
Début
i ← 1 // Initialise le compteur à 1
Répéter
Ecrire("Hello") // Affiche "Hello" à chaque répétition
i ← i+1 // Incrémente le compteur de 1
Jusqu'à i>10 // Arrête la boucle lorsque i dépasse 10
Fin
La principale différence entre la boucle "TantQue" et "Répéter Jusqu’à" est que dans la boucle Répéter Jusqu’à", la boucle s'exécute une fois avant même de vérifier la condition, alors que dans une boucle "TantQue", la boucle s'exécute si la condition est vraie.
- i ← 1 : initialise le compteur à 1.
- Répéter : démarre une boucle qui sera exécutée au moins une fois.
- Ecrire("Hello") : affiche le message « Hello » à chaque tour de boucle.
- i ← i + 1 : augmente la valeur de i de 1 après chaque affichage.
- Jusqu'à i > 10 : arrête la boucle dès que i devient supérieur à 10.
Organigramme:
12. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle Répéter Jusqu’à.
Indication:
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55
Exemple de sortie:
La somme de 1 à 10 est 55
Algorithme Somme1A10
Variables i,sum: entiers
Début
sum ← 0 // Initialise la somme à 0
i ← 1 // Initialise le compteur à 1
Répéter
sum ← sum + i // Ajoute la valeur actuelle de i à la somme
i ← i+1 // Incrémente le compteur de 1
Jusqu'à i > 10 // Arrête la boucle lorsque i dépasse 10
Ecrire("La somme de 1 à 10 est:" sum) // Affiche la somme finale
Fin
- sum ← 0 : initialise la somme à zéro avant de commencer les additions.
- i ← 1 : initialise le compteur à 1, puisque la somme commence par 1.
- Répéter : démarre une boucle qui exécute les instructions au moins une fois.
- sum ← sum + i : ajoute la valeur actuelle de i à la somme.
- i ← i + 1 : augmente le compteur de 1 après chaque addition.
- Jusqu'à i > 10 : arrête la boucle lorsque i devient supérieur à 10.
- Ecrire(...) : affiche la somme calculée après la fin de la boucle.
Organigramme:
🚀 Boostez votre productivité avec les meilleurs outils Web → Essayez-les
13. Écrire un algorithme qui affiche la table de multiplication de 2. En utilisant la boucle Répéter Jusqu’à.
Exemple de sortie:
2 x 0 = 0 2 x 1 = 2 2 x 2 = 4 2 x 3 = 6 2 x 4 = 8 2 x 5 = 10 2 x 6 = 12 2 x 7 = 14 2 x 8 = 16 2 x 9 = 18 2 x 10= 20
Algorithme TableMultiplication
Variable i:entier
Début
i ← 0 // Initialise le compteur à 0
Répéter
Ecrire("2 x ",i," = ",i*2) // Calcule et affiche 2 × i
i ← i+1 // Incrémente le compteur de 1
Jusqu'à i > 10 // Arrête la boucle lorsque i dépasse 10
Fin
- i ← 0 : initialise le compteur à 0, car la table commence par 2 × 0.
- Répéter : démarre une boucle qui sera exécutée au moins une fois.
- Ecrire("2 x ", i, " = ", i * 2) : affiche chaque multiplication de la table de 2.
- i ← i + 1 : augmente le compteur de 1 après chaque calcul.
- Jusqu'à i > 10 : arrête la boucle lorsque i devient supérieur à 10.
Organigramme:
14. Écrire un algorithme permettant d'entrer un nombre et d'afficher le triangle d'étoiles. En utilisant la boucle POUR imbriqué.
Exemple de sortie:
Entrez un nombre: 5
*
***
*****
*******
*********
Algorithme TrianglEtoiles
Variables Nbr,i,j: entiers
Début
Ecrire("Entrez un nombre:")
Lire(Nbr) // Lit le nombre de lignes du triangle
Ecrire("\n")
// Parcourt chaque ligne du triangle
Pour i de 0 à Nbr-1 faire
// Parcourt chaque colonne de la ligne
Pour j de 1 à (Nbr*2)-1 faire
// Vérifie si la position actuelle doit contenir une étoile
Si (j >= Nbr-i et j <= Nbr+i ) alors
Ecrire("*") // Affiche une étoile
SiNon
Ecrire(" ") // Affiche un espace pour centrer le triangle
FinSi
FinPour
Ecrire("\n") // Passe à la ligne suivante
FinPour
Fin
- 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.
Organigramme:
15. Écrire un algorithme qui calcule les nombres de Fibonacci jusqu'à 50. En utilisant la boucle POUR.
Exemple de sortie:
Fibonacci jusqu'à 50: 1 1 2 3 5 8 13 21 34
Algorithme Fibonacci
Variables sum,f1,f2:entier
Début
sum ← 0 // Initialise la variable qui stockera le prochain terme
f1 ← 1 // Initialise le premier terme de la suite
f2 ← 1 // Initialise le deuxième terme de la suite
Pour i de 1 à 50 faire // Répète le calcul pour générer 50 termes
// Calcule le prochain terme en additionnant les deux précédents
sum ← f1 + f2
// Décale f1 vers f2 pour préparer le prochain calcul
f2 ← f1
// Met à jour f1 avec le nouveau terme calculé
f1 ← sum
Ecrire(sum) // Affiche le terme actuel de la suite
FinPour
Fin
Explications:
- sum ← 0 : initialise la variable qui contiendra le résultat de l'addition.
- f1 ← 1 et f2 ← 1 : définissent les deux premières valeurs utilisées pour commencer la suite.
- Pour i de 1 à 50 : répète le calcul 50 fois.
- sum ← f1 + f2 : calcule le terme suivant en additionnant les deux termes précédents.
- f2 ← f1 : décale la valeur de f1 vers f2.
- f1 ← sum : met f1 à jour avec le nouveau terme calculé.
- Ecrire(sum) : affiche chaque nouveau terme.
Organigramme:
16. Écrire un algorithme qui calculera une somme courante. L'utilisateur saisira des nombres qui seront ajoutés à la somme et, lorsqu'un nombre négatif sera rencontré, arrêtera d'ajouter des nombres et écrira le résultat final. En utilisant la boucle Répéter Jusqu'à.
Exemple de sortie:
1 2 3 4 -1 La somme est 10
Algorithme SommeNbr
Variables Nbr,sum:entiers
Début
sum ← 0 // Initialise la somme à 0
Répéter
Lire(Nbr) // Lit un nombre saisi par l'utilisateur
Si (Nbr >= 0) alors
sum ← Nbr + sum // Ajoute le nombre saisi à la somme
FinSi
Jusqu'à(Nbr < 0) // Arrête saisie dès qu un nbr négatif est rencontré
Ecrire("La somme est ",sum) // Affiche la somme calculée
Fin
Explications:
- sum ← 0 : initialise la variable sum à zéro. Cette variable va contenir la somme des nombres saisis.
- Répéter : démarre une boucle qui permet de saisir plusieurs nombres.
- Lire(Nbr) : demande à l'utilisateur de saisir un nombre et stocke sa valeur dans Nbr.
- Si (Nbr >= 0) : vérifie si le nombre saisi est positif ou égal à zéro.
- sum ← sum + Nbr : ajoute le nombre saisi à la somme uniquement s'il est positif ou nul.
- Jusqu'à (Nbr < 0) : arrête la boucle dès qu'un nombre négatif est saisi. Le nombre négatif sert uniquement à arrêter la saisie et n'est pas ajouté à la somme.
- Ecrire("La somme est ", sum) : affiche la somme finale de tous les nombres positifs ou nuls saisis.
Organigramme:
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 1
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 2
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 3
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 4
- 100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 5
- Exercices Corrigés En Algorithme – Les boucles
- Exercices Corrigés En Algorithme – Les tableaux
- Exercices Corrigés En Algorithme – Structure conditionnelle
- Exercices Corrigés En Algorithme – Fonctions et Procédures
