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

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 et programmation. Nous espérons que ces exercices vous aideront à améliorer vos compétences sur les algorithmes et programmation. Les exercices corrigés suivantes sont actuellement disponibles, nous travaillons dur pour ajouter plus d’exercices. Bon apprentissage!

Vous pouvez lire notre tutoriel sur les algorithmes avant de résoudre les exercices suivants.

1. Écrire un algorithme pour afficher le message ‘Hello, World!’ sur l’écran.

Exemple de sortie:

Hello World!

Algorithme HelloWorld
Début  
  Ecrire("Hello, World!")
Fin

Dans cet algorithme, nous avons utilisé le mot « Écrire » pour afficher la chaîne de caractères Hello, world! sur notre écran. Voici l’organigramme de cet algorithme:

2. Écrire un algorithme permettant la saisie de deux nombres et l’affichage de leur somme.

Exemple de sortie:

Entrer 1er nombre: 10
Entrer 2éme nombre: 5
La somme de 10 et 5 = 15

Algorithme SommeDeuxNombres
Variables n1,n2,s :réels
Début  
 Ecrire("Entrer 1er nombre:")
 Lire(n1)   // Lit le premier nombre
 Ecrire("Entrer 2éme nombre:") 
 Lire(n2)   // Lit le deuxième nombre
 s ← n1 + n2   // Calcule la somme des deux nombres
 Ecrire("La somme de ",n1,"et",n2,"=",s)   // Affiche le résultat
Fin

Cet algorithme invite l’utilisateur à saisir deux nombres, les additionne, puis affiche le résultat. Voici l’organigramme de cet algorithme:

3. Écrire un algorithme permettant de permuter le contenu de deux entiers n1 et n2 entrés par l’utilisateur, et afficher ces entiers après permutation.

Exemple de sortie:

Entrer un entier n1 : 10
Entrer un entier n2 : 5
------permutation------
n1 = 5
n2 = 10

Algorithme Permutation

Variables n1,n2,tmp :entiers
Début  
 Ecrire("Entrer un entier n1:") 
 Lire (n1)    // Lit le premier entier
 Ecrire("Entrer un entier n2:") 
 Lire (n2)   // Lit le deuxième entier
 
 tmp ← n1   // Sauvegarde temporairement la valeur de n1
 n1 ← n2    // Affecte la valeur de n2 à n1
 n2 ← tmp   // Récupère l'ancienne valeur de n1
 
 Ecrire("------permutation------")
 Ecrire("n1 = ",n1)   // Affiche la nouvelle valeur de n1
 Ecrire("n2 = ",n2)   // Affiche la nouvelle valeur de n2
Fin

Cet algorithme déclare d’abord trois variables n1, n2 et tmp, puis demande à l’utilisateur de saisir deux nombres entiers. Ensuite, il utilise une variable temporaire tmp pour échanger les valeurs de n1 et n2, et enfin affiche les valeurs échangées. Voici l’organigramme de cet algorithme:

4. Écrire un algorithme pour calculer la factorielle d’un nombre entier saisi par l’utilisateur. (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:

5. Écrire un algorithme permettant d’afficher si un nombre saisi est pair ou impair.

Exemple de sortie:

Entrer un nombre: 8 
Nombre pair

Algorithme  PairImpair
Variables nbr :entier
Début 
  Ecrire("Entrer un nombre:")
  Lire(nbr)   // Lit le nombre saisi par l'utilisateur
  // Vérifie si le reste de division par 2 est égal à 0
  Si(nbr mod 2 = 0) alors   
      Ecrire("Nombre pair")  // Le nombre est pair
     SiNon
      Ecrire("Nombre impair")  // Le nombre est impair
  FinSi
Fin

Si un nombre est divisible par 2 sans reste, il est pair. Vous pouvez calculer le reste à l’aide de l’opérateur modulo « mod », comme ceci nbr mod 2 = 0. Si un nombre divisé par 2 laisse un reste de 1, le nombre est impair. Vous pouvez le vérifier en utilisant nbr mod 2 = 1. Voici l’organigramme de cet algorithme:

6. Écrire un algorithme permettant d’afficher le plus grand des 3 nombres saisis au clavier.

Exemple de sortie:

Entrer 1er nombre : 2
Entrer 2éme nombre: 9
Entrer 3éme nombre: 7
Le nombre le plus grand est: 9

Algorithme Max3Nbr
Variables n1,n2,n3,max :entiers
Début
  Ecrire("Entrer 1er nombre :")  
  Lire(n1)  // Lit le premier nombre
  Ecrire("Entrer 2éme nombre:")  
  Lire(n2)  // Lit le deuxième nombre
  Ecrire("Entrer 3éme nombre:")  
  Lire(n3)  // Lit le troisième nombre
   max ← n1    // Suppose que n1 est le plus grand nombre
   Si (n2 >= max) alors
      max ← n2  //Remplace max si n2 est supérieur ou égal à max
   FinSi
   
   Si(n3 >= max) alors 
      max ← n3  //Remplace max si n3 est supérieur ou égal à max
   FinSi
 // Affiche le plus grand nombre
 Ecrire("Le nombre le plus grand est: ",max) 
Fin

Voici l’organigramme de cet algorithme:

7. 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:

🚀 Boostez votre productivité avec les meilleurs outils Web → Essayez-les

8. Écrire un algorithme qui calcule la valeur absolue d’un nombre saisi par l’utilisateur.

Exemple de sortie:

Entrer un nombre: -5
La valeur absolue de -5 est 5

Algorithme NbrAbsolue
Variable n :entier
Début
   Ecrire("Entrer un nombre :") 
   Lire(n)  // Lit le nombre saisi par l'utilisateur
   Si(n >= 0) alors  // Vérifie si le nombre est positif ou égal à 0
   // Pour un nombre positif, sa valeur absolue est le nombre lui-même
     Ecrire("La valeur absolue de ",n," est ",n)
   SiNon 
     // Pour un nombre négatif, on change son signe
     Ecrire("La valeur absolue de ",n," est ",-n)
   FinSi
Fin

Voici l’organigramme de cet algorithme:

9. Écrire un algorithme qui calcule la moyenne de 3 nombres entrés par l’utilisateur.

Exemple de sortie:

Entrer 1er nombre :  5
Entrer 2éme nombre:  7
Entrer 3éme nombre:  3
La moyenne est : 5

Algorithme Moyenne3Nbr
Variables n1,n2,n3,moy:entiers
Début
	Ecrire("Entrer n1:")
	Lire(n1)   // Lit le premier nombre
	Ecrire("Entrer n2:")
	Lire(n2)  // Lit le deuxième nombre
	Ecrire("Entrer n3:")
	Lire(n3)  // Lit le troisième nombre
	// Calcule la moyenne entière des trois nombres
	moy ← (n1+n2+n3) div 3
	// Affiche la moyenne calculée
	Ecrire("La moyenne est: ",moy)
Fin

La formule pour calculer la moyenne de plusieurs nombres est très simple. Il suffit d’additionner toutes les valeurs, puis de diviser le résultat par le nombre total de valeurs. La formule générale est donc:

Moyenne = Total des valeurs / Nombre de valeurs

Dans notre cas, nous avons 3 nombres. Pour calculer leur moyenne, il faut donc additionner les trois nombres, puis diviser le résultat par 3.

Organigramme:

10. É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:

11. 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:

12. 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:

13. 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:

14. 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:

15. 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:

16. Écrire un algorithme qui affiche la table de multiplication de 3. En utilisant la boucle For.

Exemple de sortie:

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:

17. É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:

18. 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:

19. 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:

20. Écrire un algorithme qui affiche la table de multiplication de 2. En utilisant la boucle Répéter Jusqu’à.

Exemple de sortie:

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:

21. Écrire un algorithme permettant de saisir 10 nombres et de les stocker dans un tableau appelé myTab, puis de les afficher.

Exemple de sortie:

6   3   8   1   5   9   4   2   6   0
6   3   8   1   5   9   4   2   6   0

Algorithme AfficherTableau
Variable myTab[10]:reéls 
         i : entier
Début
    Pour i de 1 jusqu❛à 10 faire   // Parcourt les 10 positions du tableau
	    lire(myTab[i]) // Lit une valeur et la stocke dans le tableau
    FinPour 
    // Parcourt à nouveau les 10 positions du tableau
    Pour i de 1 jusqu'à 10 faire   
	    Ecrire(myTab[i])  // Affiche la valeur située à la position i
    FinPour 
Fin

L'algorithme ci-dessus invite l'utilisateur à saisir 10 entiers dans un tableau nommé myTab, puis affiche les éléments du tableau.

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].

La deuxième boucle POUR affiche ensuite le contenu du tableau, qui parcourt les éléments de myTab et affiche chaque élément à l'aide de Ecrire().

Organigramme:

22. Écrire un algorithme permettant d'entrer 10 notes et d'afficher la moyenne de ces notes.

Exemple de sortie:

6   3   8   1   5   9   4   2   6   0
La moyenne est: 4,4

Algorithme NoteMoyenne 
Variables Notes[10], sum :réels
          i :entier
Début
    sum ← 0    // Initialise la somme des notes à 0
    Pour i de 1 jusqu'à 10 faire   // Parcourt les 10 notes à saisir
       Lire(Notes[i])     // Lit une note et la stocke dans le tableau
       sum ← sum + Notes[i]     // Ajoute la note à la somme totale
    FinPour
    // Calcule et affiche la moyenne des 10 notes
    Ecrire("La moyenne est:",sum/10)
Fin

L'algorithme demande à l'utilisateur de saisir 10 notes 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 Notes[i].

Ensuite, à chaque itération de la boucle, la somme de chaque élément saisi est calculée. Une fois la boucle POUR terminée, la moyenne est calculée et affichée à l'écran à l'aide de Ecrire().

Notes[10] : réels : déclare un tableau pouvant contenir 10 notes de type réel.
sum ← 0 : initialise la somme des notes à zéro avant de commencer les calculs.
Pour i de 1 jusqu'à 10 faire : permet de parcourir les 10 positions du tableau.
Lire(Notes[i]) : lit une note saisie par l'utilisateur et la stocke dans le tableau à la position i.
sum ← sum + Notes[i] : ajoute chaque note à la somme totale.
sum / 10 : divise la somme des 10 notes par 10 afin d'obtenir la moyenne.
Ecrire(...) : affiche la moyenne calculée.

Organigramme:

23. Écrire un algorithme permettant la saisi de 10 nombres et l'affichage du maximum de ces nombres.

Exemple de sortie:

Entrer un nombre: 6   
Entrer un nombre: 3   
Entrer un nombre: 8   
Entrer un nombre: 1   
Entrer un nombre: 5   
Entrer un nombre: 7   
Entrer un nombre: 4   
Entrer un nombre: 2   
Entrer un nombre: 6   
Entrer un nombre: 0
Le maximum est: 8

Algorithme myTabMax 
Variables myTab[10],max,i:réels
Début
   Ecrire("Entrer un nombre:")
   Lire(myTab[0])  // Lit le 1er nombre et le stocke dans le tableau
   max ← myTab[0] // Initialise max avec la 1er valeur du tableau

   // Parcourt les autres positions du tableau
   Pour i de 1 jusqu'à 10 faire   
      Ecrire("Entrer un nombre:")
      Lire(myTab[i])  // Lit un nombre et le stocke dans le tableau
	    // Vérifie si la valeur actuelle est supérieure au max
	    Si (myTab[i] > max) alors
	      max ← myTab[i]  // Met à jour max avec la nouvelle valeur
	    FinSi
   FinPour 
   // Affiche la plus grande valeur du tableau
   Ecrire("Le maximum est:",max)  
Fin

Dans cet algorithme nous avons créer une variable max et l'initier à myTab[0] pour stocker le maximum dans le tableau.

Lire(myTab[0]) : lit le premier nombre et le stocke dans la première position du tableau.
max ← myTab[0] : initialise max avec la première valeur. Elle sert de référence pour les comparaisons suivantes.
Pour i de 1 jusqu'à 9 faire : parcourt les 9 positions restantes du tableau.
Lire(myTab[i]) : lit chaque nouveau nombre et le stocke dans le tableau.
Si (myTab[i] > max) : vérifie si le nombre actuel est plus grand que le maximum trouvé jusqu'à présent.
max ← myTab[i] : met à jour le maximum lorsque la valeur actuelle est plus grande.
Ecrire(...) : affiche finalement la plus grande valeur trouvée.

Organigramme:

24. Ecrivez un algorithme qui permet d'entrer 10 nombres dans un tableau, et de calculer le nombre d'occurrences d'un élément E dans ce tableau. Où E est entré par l'utilisateur.

Exemple de sortie:

Entrer un nombre: 6   
Entrer un nombre: 3   
Entrer un nombre: 8   
Entrer un nombre: 6   
Entrer un nombre: 5   
Entrer un nombre: 7   
Entrer un nombre: 4   
Entrer un nombre: 6   
Entrer un nombre: 6   
Entrer un nombre: 0
Entrer Le nombre recherché: 6
Nombre d'occurences de 6 est 4

Algorithme NbrOccurences
Variables nbrRech,myTab[10]:réels
          nbrOcc,i:entiers
Début
   nbrOcc ← 0  // Initialise le compteur d'occurrences à 0
   Pour i de 1 jusqu❛à 10 faire   // Parcourt les 10 positions du tableau
       Ecrire("Entrer un nombre:")
       Lire(myTab[i])  // Lit un nombre et le stocke dans le tableau
   FinPour 
   
    Ecrire("Entrer Le nombre recherché:")
    Lire(nbrRech)  // Lit le nombre dont on veut compter les occurrences
    
     // Parcourt à nouveau toutes les valeurs du tableau
     Pour i de 1 jusqu❛à 10 faire
         // Vérifie si la valeur actuelle correspond au nbr recherché
         Si(myTab[i] = nbrRech) alors
            // Incrémente le compteur lorsqu'une occurrence est trouvé
            nbrOcc ← nbrOcc + 1 
         FinSi
     FinPour 
 // Affiche le nombre total d'occurrences
 Ecrire("Nombre d'occurences de ",nbrRech," est ",nbrOcc)
Fin

Pour compter le nombre d'occurrences d'une valeur spécifique dans un tableau, nous pouvons utiliser une simple boucle POUR tout en recherchant notre valeur cible. Si la valeur cible est trouvée, nous incrémentons la variable nbrOcc. Nous procédons de cette façon jusqu'à ce que l'ensemble du tableau soit parcouru.

Approche:

nbrOcc ← 0 : initialise le compteur d'occurrences à 0, car aucune valeur n'a encore été trouvée.
Lire(myTab[i]) : permet de remplir le tableau avec les 10 nombres saisis par l'utilisateur.
Lire(nbrRech) : lit le nombre que l'utilisateur souhaite rechercher dans le tableau.
Si (myTab[i] = nbrRech) : compare chaque élément du tableau avec le nombre recherché.
nbrOcc ← nbrOcc + 1 : augmente le compteur de 1 chaque fois qu'une correspondance est trouvée.
Ecrire(...) : affiche le nombre total de fois où le nombre recherché apparaît dans le tableau.

Organigramme:

🚀 Boostez votre productivité avec les meilleurs outils Web → Essayez-les

25. Ecrivez un algorithme pour entrer 10 entiers dans un tableau et trier ce tableau dans un ordre croissant. Affichez ensuite ce tableau après l'avoir trié.

Exemple de sortie:

Entrer un nombre: 8   
Entrer un nombre: 1  
Entrer un nombre: 5  
Entrer un nombre: 6   
Entrer un nombre: 3  
Entrer un nombre: 2   
Entrer un nombre: 4   
Entrer un nombre: 7   
Entrer un nombre: 9   
Entrer un nombre: 0
Tableau trié: 0    1    2    3    4    5    6    7    8    9

Algorithme TrierTab
Variables i,j,tmp,myTab[10]:entiers
Début
  Pour i de 1 jusqu❛à 10 faire   // Parcourt les 10 positions du tableau
    Ecrire("Entrer un nombre:")
    Lire(myTab[i])    // Lit un nombre et le stocke dans le tableau
  FinPour 
   
  // Parcourt le tableau jusqu❛à l❛avant-dernier élément
  Pour i de 1 jusqu❛à 9 faire   
     // Compare l❛élément actuel avec les suivants
     Pour j de i+1 jusqu❛à 10 faire 
       // Vérifie si un élément plus petit a été trouvé 
       Si(myTab[j] < myTab[i]) alors
           // Sauvegarde temporairement la valeur de myTab[i]
           tmp ← myTab[i]
           // Place la plus petite valeur à la position i   
           myTab[i] ← myTab[j] 
           // Place l❛ancienne valeur de myTab[i] à la position j
           myTab[j] ← tmp 
        FinSi
     FinPour 
   FinPour
   
    Pour i de 1 jusqu❛à 10 faire     // Parcourt le tableau trié
     Ecrire(myTab[i])    // Affiche les éléments dans l'ordre croissant
   FinPour	
Fin

L'algorithme ci-dessus invite l'utilisateur à saisir 10 nombres dans un tableau nommé myTab, puis affiche les éléments triés du tableau.

La deuxième boucle POUR parcourt le tableau myTab et permute les éléments du tableau(permute deux éléments aux positions i et j) en utilisant une variable temporaire pour contenir l'une des valeurs pendant la permutation. L'algorithme parcourt le tableau répétitivement, compare chaque paire d'éléments adjacents et les échange si nécessaire. Après le premier passage, l'élément le plus grand est placé à la fin du tableau.

Dans l'algorithme de tri à bulle, nous comparons les deux premiers éléments d'un tableau et les permutons si nécessaire.
Si nous voulons trier les éléments d'un tableau dans l'ordre croissant et si le premier élément est plus grand que le second, nous devons permuter les éléments.
Si le premier élément est plus petit que le second, il n'est pas nécessaire de permuter les éléments. Ce processus se poursuit jusqu'à ce que le dernier et l'avant-dernier élément soient comparés et permutés.

La troisième boucle POUR affiche ensuite le tableau trié, qui parcourt les éléments de myTab et affiche chaque élément à l'aide de Ecrire().

Lire(myTab[i]) : remplit le tableau avec les 10 nombres saisis par l'utilisateur.
Pour i de 1 jusqu'à 9 : sélectionne chaque position du tableau, sauf la dernière.
Pour j de i + 1 jusqu'à 10 : compare l'élément myTab[i] avec tous les éléments qui se trouvent après lui.
Si (myTab[j] < myTab[i]) : vérifie si un élément plus petit que myTab[i] a été trouvé.
tmp ← myTab[i] : sauvegarde temporairement la valeur de myTab[i] avant de l'échanger.
myTab[i] ← myTab[j] : place la plus petite valeur à la position i.
myTab[j] ← tmp : termine la permutation en plaçant l'ancienne valeur de myTab[i] à la position j.
Ecrire(myTab[i]) : affiche le tableau après son tri.

Organigramme:

26. Écrire un algorithme pour afficher les nombres pairs entre 0 et N, où N est saisi par l'utilisateur.

Exemple de sortie:

Entrer un nombre :  9
0  2  4  6  8

Algorithme NbrPaire
Variables i,N : entiers
Début    
 Ecrire("Entrer un nombre: ")
 lire(N)   // Lit la valeur limite saisie par l'utilisateur
  Pour i de 0 jusqu❛à N faire   // Parcourt tous les nombres de 0 à N
      Si(i mod 2 = 0) alors   // Vérifie si i est divisible par 2
      Ecrire(i)    // Affiche i s'il est pair
  FinPour
Fin

Description pas à pas de la logique permettant d'afficher tous les nombres pairs compris entre 1 et n à en utilisant l'instruction "Si":

L'utilisateur doit saisir la limite supérieure des nombres pairs. Stockez-la dans la variable N.
Exécutez la boucle "POUR" à partir de 1, jusqu'à N.
À l'intérieur du corps de la boucle, vérifiez la condition pair/impair. Si le nombre actuel i est divisible par 2, alors i est pair. Autrement dit, Si(i mod 2 = 0), la valeur de i est affichée.

Organigramme:

27. Ecrivez un algorithme qui calcule la somme des nombres impairs compris entre 1 et un nombre entier N saisi par l'utilisateur. Exemple N=10 Somme=1+3+5+7+9=25

Exemple de sortie:

Entrer un nombre :  10
25

Algorithme SumNbrImpaires
Variables sum,i,N: entiers
Début      
   sum ← 0    // Initialise la somme des nombres impairs à 0
   Ecrire("Entrer un nombre:")
   Lire(N)   // Lit la valeur limite saisie par l'utilisateur
   Pour i de 1 jusqu❛à N faire  // Parcourt tous les nombres de 1 à N
      Si (i mod 2 ≠ 0) alors   // Vérifie si i est un nombre impair
          sum ← sum + i     // Ajoute le nombre impair à la somme
      FinSi 
   FinPour
  Ecrire(sum)   // Affiche la somme des nombres impairs
Fin

Dans cet algorithme:

L'utilisateur doit saisir la limite supérieure des nombres impairs. Stockez-la dans la variable N.
Exécutez la boucle "POUR" à partir de 1, jusqu'à N.
À l'intérieur du corps de la boucle, vérifiez la condition pair/impair. Si le nombre actuel i n'est pas divisible par 2, alors i est impair. Autrement dit, Si(i mod 2 ≠ 0), nous ajoutons le nombre actuel i à la variable sum.
Enfin nous affichons la somme des nombres impairs.

Organigramme:

28. Écrire un algorithme permettant de calculer le plus grand commun diviseur (PGCD) entre deux nombres entiers entrés par l'utilisateur.

Exemple:

n1=18 et n2=45
PGCD(18, 45) = 9

Exemple de sortie:

Entrer deux nombres: 18  45
Le PGCD est : 9

Algorithme TrouverPGCD
Variables n1,n2,i,pgcd: entiers
Début   
    Ecrire("Entrer deux nombres:")
    Lire(n1,n2)   // Lit les deux nombres à comparer
    i ← 1    // Commence la recherche des diviseurs à 1
    // Parcourt les diviseurs possibles jusqu'au plus petit nombre
    TantQue(i<=n1 et i<=n2) faire
       // Vérifie si i divise exactement n1 et n2
       Si(n1 mod i=0 et n2 mod i=0) alors
          // Mémorise i comme le plus grand diviseur commun trouvé
          pgcd ← i 
       FinSi
       i ← i + 1    // Passe au diviseur suivant
    FinTantQue
    Ecrire("Le PGCD est:",pgcd) // Affiche le PGCD des deux nombres  
Fin

Dans ce programme, deux nombres entiers entrés par l'utilisateur sont stockés dans les variables n1 et n2. Ensuite, la boucle TantQue est itérée jusqu'à ce que i soit inférieur à n1 et n2.

A chaque itération, si n1 et n2 sont exactement divisibles par i, la valeur de i est affectée à la variable "pgcd".

Lorsque la boucle TantQue est terminée, le plus grand diviseur commun de deux nombres est stocké dans la variable "pgcd".

Lire(n1, n2) : lit les deux nombres dont on souhaite trouver le PGCD.
i ← 1 : initialise le diviseur à 1.
TantQue (i <= n1 et i <= n2) : teste les nombres jusqu'à la valeur du plus petit des deux nombres.
n1 mod i = 0 : vérifie si i est un diviseur de n1.
n2 mod i = 0 : vérifie également si i est un diviseur de n2.
pgcd ← i : lorsque i divise les deux nombres, il devient le dernier diviseur commun trouvé. Comme i augmente progressivement, le dernier sera le plus grand diviseur commun.
i ← i + 1 : passe au nombre suivant à tester.
Ecrire(...) : affiche le PGCD trouvé.

Organigramme:

29. Écrire un algorithme qui affiche un triangle d'entiers, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Donner un nombre: 7
1
22
333
4444
55555
666666
7777777

Algorithme NTriangle
Variables N,i,j: entiers  
Début     
 Ecrire("Donner un nombre: ")
 Lire(N)    // Lit le nombre de lignes du triangle

 // Parcourt les lignes du triangle
 Pour i de 1 jusqu❛à N faire   
    // Répète l'affichage i fois sur chaque ligne
    Pour j de 1 jusqu❛à i faire  
      Ecrire(i)   // Affiche la valeur de i
    FinPour
   Ecrire("\n")  // Passe à la ligne suivante
 FinPour
Fin

Le programme invite l'utilisateur à saisir un nombre à l'aide de la fonction Ecrire() et stocke la valeur dans la variable "N" à l'aide de la fonction Lire(). La boucle POUR est ensuite utilisée pour exécuter le code à l'intérieur de la boucle le nombre de fois spécifié par l'utilisateur. La boucle POUR commence avec "i" initialisé à 1, et la boucle continue jusqu'à ce que "i" soit inférieur ou égal à "N".

La deuxième boucle POUR est imbriquée dans la première boucle POUR et est utilisée pour exécuter de manière répétée le code à l'intérieur de la boucle pendant le nombre de fois spécifié par l'utilisateur. La boucle POUR commence avec "j" initialisé à 1, et la boucle continue jusqu'à ce que "j" soit inférieur ou égal à "i".

La fonction Ecrire() à l'intérieur de la boucle imbriquée est utilisée pour afficher le nombre actuelle (i) à l'écran à chaque fois que la boucle est exécutée. Les valeurs de "i" et "j" sont incrémentées de 1 à chaque itération des boucles, de sorte que les boucles se terminent finalement lorsque "i" et "j" atteignent la valeur de "N".

Organigramme:

30. Ecrire un algorithme qui compte le nombre de chiffres dans un nombre saisi par l'utilisateur.

Exemple de sortie:

Donner un nombre: 9876
Le nombre de chiffres est 4

Algorithme CompterChiffres
Variables Nbr,i: entiers  
Début        
  Ecrire("Donner un nombre: ")
  Lire(Nbr)   // Lit le nombre saisi par l'utilisateur
  i ← 1     // Initialise le compteur à 1 chiffre
  // Vérifie s'il reste encore des chiffres à parcourir
  TantQue(Nbr div 10 ≠ 0) faire
    Nbr ← Nbr div 10  // Supprime le dernier chiffre du nombre
    i ← i + 1  // Incrémente le nombre de chiffres comptés
  FinTantQue
  // Affiche le nombre total de chiffres
  Ecrire("Le nombre de chiffres est",i)  
Fin

L'algorithme divise le nombre saisi par l'utilisateur par 10 dans la boucle TantQue jusqu'à ce que le résultat atteigne zéro. Le nombre d'itérations correspondra au nombre de chiffres.

L'entier saisi par l'utilisateur est stocké dans la variable Nbr. Ensuite, la boucle TantQue est itérée jusqu'à ce que la condition (Nbr div 10 ≠ 0) soit évaluée à 0 (False).

Après la première itération, la valeur de Nbr est de 987 et le compteur est incrémenté à 1.
Après la deuxième itération, la valeur de Nbr sera de 98 et le compteur sera incrémenté à 2.
Après la troisième itération, la valeur de Nbr sera de 9 et le compteur sera incrémenté à 3.
Après la quatrième itération, la valeur de Nbr sera 0 et le compteur sera incrémenté à 4.
La condition de la boucle est alors évaluée à false et la boucle se termine.

Organigramme:

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

1. Écrire un algorithme pour afficher le message ‘Hello, World!’ sur l’écran.

2. Écrire un algorithme permettant la saisie de deux nombres et l’affichage de leur somme.

3. Écrire un algorithme permettant de permuter le contenu de deux entiers n1 et n2 entrés par l’utilisateur, et afficher ces entiers après permutation.

4. Écrire un algorithme pour calculer la factorielle d’un nombre entier saisi par l’utilisateur. (Remarque: le factoriel de 5, qui s’écrit 5! = 5 × 4 × 3 × 2 × 1).

5. Écrire un algorithme permettant d’afficher si un nombre saisi est pair ou impair.

6. Écrire un algorithme permettant d’afficher le plus grand des 3 nombres saisis au clavier.

7. A quoi sert l’algorithme suivant?

8. Écrire un algorithme qui calcule la valeur absolue d’un nombre saisi par l’utilisateur.

9. Écrire un algorithme qui calcule la moyenne de 3 nombres entrés par l’utilisateur.

10. Écrire un algorithme qui affiche 10 fois « Hello ». En utilisant la boucle Tant que.

11. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle TantQue.

12. Ecrivez un algorithme qui calcule la somme de 1 à N, où N est saisi par l'utilisateur. En utilisant la boucle TantQue.

13. Ecrivez un algorithme qui affiche "Hello" 10 fois. En utilisant la boucle POUR.

14. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle POUR.

15. Ecrivez un algorithme qui calcule la somme de 1 à N, où N est saisi par l'utilisateur. En utilisant la boucle POUR.

16. Écrire un algorithme qui affiche la table de multiplication de 3. En utilisant la boucle For.

17. Écrire un algorithme qui affiche la table de multiplication d'un entier saisi par l'utilisateur, en utilisant la boucle POUR.

18. Ecrivez un algorithme qui affiche "Hello" 10 fois. En utilisant la boucle Répéter Jusqu’à.

19. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle Répéter Jusqu’à.

20. Écrire un algorithme qui affiche la table de multiplication de 2. En utilisant la boucle Répéter Jusqu’à.

21. Écrire un algorithme permettant de saisir 10 nombres et de les stocker dans un tableau appelé myTab, puis de les afficher.

22. Écrire un algorithme permettant d'entrer 10 notes et d'afficher la moyenne de ces notes.

23. Écrire un algorithme permettant la saisi de 10 nombres et l'affichage du maximum de ces nombres.

24. Ecrivez un algorithme qui permet d'entrer 10 nombres dans un tableau, et de calculer le nombre d'occurrences d'un élément E dans ce tableau. Où E est entré par l'utilisateur.

25. Ecrivez un algorithme pour entrer 10 entiers dans un tableau et trier ce tableau dans un ordre croissant. Affichez ensuite ce tableau après l'avoir trié.

26. Écrire un algorithme pour afficher les nombres pairs entre 0 et N, où N est saisi par l'utilisateur.

27. Ecrivez un algorithme qui calcule la somme des nombres impairs compris entre 1 et un nombre entier N saisi par l'utilisateur. Exemple N=10 Somme=1+3+5+7+9=25

28. Écrire un algorithme permettant de calculer le plus grand commun diviseur (PGCD) entre deux nombres entiers entrés par l'utilisateur.

29. Écrire un algorithme qui affiche un triangle d'entiers, en fonction d'un entier N saisi par l'utilisateur.

30. Ecrire un algorithme qui compte le nombre de chiffres dans un nombre saisi par l'utilisateur.

Une réflexion sur “100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 1”

Laisser un commentaire Annuler la réponse

1. Écrire un algorithme pour afficher le message ‘Hello, World!’ sur l’écran.

2. Écrire un algorithme permettant la saisie de deux nombres et l’affichage de leur somme.

3. Écrire un algorithme permettant de permuter le contenu de deux entiers n1 et n2 entrés par l’utilisateur, et afficher ces entiers après permutation.

4. Écrire un algorithme pour calculer la factorielle d’un nombre entier saisi par l’utilisateur. (Remarque: le factoriel de 5, qui s’écrit 5! = 5 × 4 × 3 × 2 × 1).

5. Écrire un algorithme permettant d’afficher si un nombre saisi est pair ou impair.

6. Écrire un algorithme permettant d’afficher le plus grand des 3 nombres saisis au clavier.

7. A quoi sert l’algorithme suivant?

8. Écrire un algorithme qui calcule la valeur absolue d’un nombre saisi par l’utilisateur.

9. Écrire un algorithme qui calcule la moyenne de 3 nombres entrés par l’utilisateur.

10. Écrire un algorithme qui affiche 10 fois « Hello ». En utilisant la boucle Tant que.

11. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle TantQue.

12. Ecrivez un algorithme qui calcule la somme de 1 à N, où N est saisi par l'utilisateur. En utilisant la boucle TantQue.

13. Ecrivez un algorithme qui affiche "Hello" 10 fois. En utilisant la boucle POUR.

14. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle POUR.

15. Ecrivez un algorithme qui calcule la somme de 1 à N, où N est saisi par l'utilisateur. En utilisant la boucle POUR.

16. Écrire un algorithme qui affiche la table de multiplication de 3. En utilisant la boucle For.

17. Écrire un algorithme qui affiche la table de multiplication d'un entier saisi par l'utilisateur, en utilisant la boucle POUR.

18. Ecrivez un algorithme qui affiche "Hello" 10 fois. En utilisant la boucle Répéter Jusqu’à.

19. Ecrivez un algorithme qui calcule la somme de 1 à 10. En utilisant la boucle Répéter Jusqu’à.

20. Écrire un algorithme qui affiche la table de multiplication de 2. En utilisant la boucle Répéter Jusqu’à.

21. Écrire un algorithme permettant de saisir 10 nombres et de les stocker dans un tableau appelé myTab, puis de les afficher.

22. Écrire un algorithme permettant d'entrer 10 notes et d'afficher la moyenne de ces notes.

23. Écrire un algorithme permettant la saisi de 10 nombres et l'affichage du maximum de ces nombres.

24. Ecrivez un algorithme qui permet d'entrer 10 nombres dans un tableau, et de calculer le nombre d'occurrences d'un élément E dans ce tableau. Où E est entré par l'utilisateur.

25. Ecrivez un algorithme pour entrer 10 entiers dans un tableau et trier ce tableau dans un ordre croissant. Affichez ensuite ce tableau après l'avoir trié.

26. Écrire un algorithme pour afficher les nombres pairs entre 0 et N, où N est saisi par l'utilisateur.

27. Ecrivez un algorithme qui calcule la somme des nombres impairs compris entre 1 et un nombre entier N saisi par l'utilisateur. Exemple N=10 Somme=1+3+5+7+9=25

28. Écrire un algorithme permettant de calculer le plus grand commun diviseur (PGCD) entre deux nombres entiers entrés par l'utilisateur.

29. Écrire un algorithme qui affiche un triangle d'entiers, en fonction d'un entier N saisi par l'utilisateur.

30. Ecrire un algorithme qui compte le nombre de chiffres dans un nombre saisi par l'utilisateur.

Vous pourrez aussi aimer

Exercices Corrigés En Algorithme – Structure conditionnelle

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

Exercices Corrigés En Algorithme – Les tableaux

Une réflexion sur “100 Exercices Corrigés En Algorithme avec les Organigrammes – Partie 1”

Laisser un commentaire Annuler la réponse