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

Algorithme CelsiusToFahrenheit
Variables fahrenheit,celsius: entiers  
Début 
  fahrenheit ← 0   // Initialise la température Fahrenheit à 0
  Ecrire("Entrez la température en degrés Celsius:")
  Lire(celsius)  // Lit la température saisie en degrés Celsius
  // Convertit la température de Celsius en Fahrenheit
  fahrenheit ← (celsius * (9 div 5)) + 32
  // Affiche la température convertie
  Ecrire("La température en Fahrenheit est:",fahrenheit)
Fin

Explication:

• fahrenheit ← 0 : initialise la variable fahrenheit à zéro avant le calcul.
• Lire(celsius) : lit la température saisie par l’utilisateur en degrés Celsius.
• celsius * (9 div 5) + 32 : applique la formule de conversion de Celsius vers Fahrenheit.
• Ecrire(…) : affiche la température obtenue en degrés Fahrenheit.

Organigramme:

Algorithme Permuter2Nbr
Variables  N1,N2 :entiers
Début  
  Ecrire("Entrer le nombre N1:") 
  Lire(N1)   // Lit le premier nombre
  Ecrire("Entrer le nombre N2:") 
  Lire(N2)   // Lit le deuxième nombre

  // Stocke temporairement la somme des deux nombres dans N1
  N1 ← N1 + N2
  // Récupère l'ancienne valeur de N1 et la place dans N2
  N2 ← N1 - N2 
  // Récupère l'ancienne valeur de N2 et la place dans N1
  N1 ← N1 - N2 
  
  Ecrire("N1 = ",N1)  // Affiche la nouvelle valeur de N1
  Ecrire("N2 = ",N2)  // Affiche la nouvelle valeur de N2
Fin

Explication:

• Lire(N1) : lit le premier nombre saisi par l’utilisateur.
• Lire(N2) : lit le deuxième nombre.
• N1 ← N1 + N2 : additionne les deux valeurs et stocke temporairement le résultat dans N1.
• N2 ← N1 – N2 : permet de retrouver l’ancienne valeur de N1 et de la placer dans N2.
• N1 ← N1 – N2 : permet ensuite de retrouver l’ancienne valeur de N2 et de la placer dans N1.

Organigramme:

Algorithme Echange3Nbr
Variables  N1,N2,N3,tmp: Entiers
Début
 Ecrire("Entrer le nombre N1 :") 
 Lire(N1)            // Lit le premier nombre
 Ecrire("Entrer le nombre N2 :") 
 Lire(N2)            // Lit le deuxième nombre
 Ecrire("Entrer le nombre N3 :") 
 Lire(N3)            // Lit le troisième nombre
 
 Si(N1 > N2) alors  // Vérifie si N1 est supérieur à N2
  tmp ← N1          // Sauvegarde temporairement N1
  N1 ← N2           // Place N2 dans N1
  N2 ← tmp          // Place l'ancienne valeur de N1 dans N2
 FinSi
 
 Si(N1 > N3) alors  // Vérifie si N1 est supérieur à N3
  tmp ← N1          // Sauvegarde temporairement N1
  N1 ← N3           // Place N3 dans N1
  N3 ← tmp          // Place l'ancienne valeur de N1 dans N3
 FinSi	
 
 Si(N2 > N3) alors  // Vérifie si N2 est supérieur à N3
  tmp ← N2          // Sauvegarde temporairement N2
  N2 ← N3           // Place N3 dans N2
  N3 ← tmp          // Place l'ancienne valeur de N2 dans N3
 FinSi	
 
 Ecrire("N1 =",N1)  // Affiche le plus petit nombre
 Ecrire("N2 =",N2)  // Affiche le nombre intermédiaire
 Ecrire("N3 =",N3)  // Affiche le plus grand nombre
 
Fin

Explication:

• Lire(N1), Lire(N2), Lire(N3) : permettent de saisir les trois nombres à comparer.
• Si (N1 > N2) : vérifie si N1 est plus grand que N2. Si c’est le cas, les deux valeurs sont échangées.
• tmp ← N1 : sauvegarde temporairement une valeur avant de réaliser l’échange.
• N1 ← N2 puis N2 ← tmp : permutent les valeurs de N1 et N2.
• Si (N1 > N3) : compare ensuite N1 avec N3 et les échange si nécessaire.
• Si (N2 > N3) : compare enfin N2 avec N3 pour terminer le classement.
• Ecrire(…) : affiche les trois nombres dans l’ordre croissant.

Organigramme:

Algorithme ZéroALaFin
Variables  i,j,T[10],tmp: Entiers
Début
 
 Pour i de 1 jusqu’à 10 faire
  Lire(T[i])   // Lit les 10 éléments du tableau
 FinPour
 
 Pour i de 1 jusqu’à 10 faire
  Ecrire(T[i]) // Affiche le tableau avant la modification
 FinPour
   
 // Parcourt le tableau pour rechercher les zéros
 Pour i de 1 jusqu’à 9 faire
  // Vérifie si l'élément actuel est égal à 0
  Si(T[i] = 0) alors
       // Commence la recherche d'un élément non nul après le zéro
       j ← i + 1;
       // Cherche le prochain élément différent de 0
       TantQue(T[j]=0 et j<9) faire
          j ← j + 1    // Passe à la position suivante
       FinTantQue
       tmp ← T[i]   // Sauvegarde temporairement le zéro
       T[i]← T[j]   // Place l'élément non nul à la position du zéro
       T[j]← tmp    // Place le zéro à la position de l'élément déplacé
  FinSi
 FinPour
 
 // Parcourt le tableau après les déplacements
 Pour i de 1 jusqu’à 10 faire
    // Affiche le tableau avec les zéros déplacés à la fin
    Ecrire(T[i])
 FinPour
Fin

Explication:

• Lire(T[i]) : remplit le tableau avec les 10 valeurs saisies par l'utilisateur.
• Si (T[i] = 0) : vérifie si l'élément actuel est égal à zéro.
• j ← i + 1 : commence la recherche juste après la position contenant le zéro.
• TantQue (T[j] = 0 et j < 9) : cherche un élément différent de zéro parmi les positions suivantes.
• j ← j + 1 : avance dans le tableau jusqu'à trouver un élément non nul.
• tmp ← T[i] : sauvegarde temporairement la valeur de T[i].
• T[i] ← T[j] : remplace le zéro par l'élément non nul trouvé.
• T[j] ← tmp : déplace le zéro vers la position j.
• La dernière boucle Pour : affiche le tableau après avoir déplacé les zéros vers la fin.

Organigramme:

Procédure checkNbr(N:entier)
Début
    // Vérifie si le reste de la division de N par 2 est égal à 0
    Si(N mod 2 = 0) alors
       Ecrire(N," est impair.")    // Affiche que N est impair
    Sinon
       Ecrire(N," est pair.")      // Affiche que N est pair
    FinSi
FinProcédure

Quelle est la différence entre procédure et fonction? Une procédure est une routine qui peut accepter des arguments mais ne retourne aucune valeur. Une fonction est une routine qui peut accepter des arguments et retourne une ou plusieurs valeurs.

Explication:

• Procédure checkNbr(N : entier) : définit une procédure appelée checkNbr qui reçoit un entier N en paramètre.
• N mod 2 : calcule le reste de la division de N par 2.
• Si (N mod 2 = 0) : vérifie si N est divisible par 2.
• Sinon : s'exécute lorsque le nombre n'est pas divisible par 2.
• Ecrire(...) : affiche si le nombre est pair ou impair.

Organigramme:

Fonction strSize(str[]: tableau de caractères): entier
Variables size: entier
  size ← 0      // Initialise le compteur à 0
  // Parcourt le tableau jusqu'au caractère de fin '\0'
  Tant que(str[size] ≠ '\0') faire
    // Incrémente le compteur pour chaque caractère trouvé
    size ← size + 1                 
  FinTantque                              
  retourner size  // Retourne le nombre de caractères de la chaîne
FinFonction

Explication:

• Fonction strSize(...) : entier : définit une fonction appelée strSize qui retourne un entier correspondant à la longueur de la chaîne.
• str[] : tableau de caractères : représente la chaîne de caractères sous forme d'un tableau.
• size ← 0 : initialise le compteur de caractères à zéro.
• str[size] ≠ '\0' : vérifie si le caractère actuel est différent de '\0', qui représente la fin de la chaîne.
• size ← size + 1 : augmente le compteur après chaque caractère parcouru.
• Retourner size : renvoie le nombre total de caractères trouvés.

Organigramme:

Procédure initialiser(T[]: tableau d❛entier, taille:entier, val:entier)
  Variables i :entier; 
  Début 
    // Parcourt toutes les positions du tableau
    Pour i de 1 jusqu❛à taille faire 
      // Affecte la valeur val à la position i du tableau
      T[i] = val   
    finPour 
  fin 
finProcédure

Explication:

• Procédure initialiser(...) : définit une procédure appelée initialiser qui permet de remplir un tableau avec une même valeur.
• T[] : tableau d'entiers : représente le tableau qui doit être initialisé.
• taille : entier : indique le nombre d'éléments du tableau à parcourir.
• val : entier : représente la valeur qui sera affectée à chaque élément du tableau.
• Pour i de 1 jusqu'à taille faire : parcourt toutes les positions du tableau.
• T[i] ← val : affecte val à chaque position du tableau.
• FinProcédure : indique la fin de la procédure.

Organigramme:

Fonction nbrAbsolue(N : réel): réel
Début
 Si(N > 0) alors    // Vérifie si le nombre est positif
    retourner N   // Retourne directement N s'il est positif
 Sinon 
    retourner -N   // Retourne l'opposé de N s'il est négatif
FinFonction 

Explication:

• Fonction nbrAbsolue(N : réel) : réel : définit une fonction appelée nbrAbsolue qui reçoit un nombre réel N et retourne un réel.
• Si (N > 0) : vérifie si N est positif.
• Retourner N : retourne le nombre tel quel lorsqu'il est positif.
• Sinon : s'exécute lorsque N n'est pas positif.
• Retourner -N : transforme un nombre négatif en son équivalent positif.

Organigramme:

Fonction countChar(string[]:tableau de caractères, c:caractère): entier
Début
  Variables nbrChar,i:entiers
  nbrChar ← 0  // Initialise le compteur de caractères à 0
  i ← 0  // Commence le parcours de la chaîne à la première position
  // Parcourt la chaîne jusqu'au caractère de fin '\0'
  Tantque (string[i] ≠ '\0') faire
    // Vérifie si le caractère actuel correspond au caractère recherché
    Si (string[i] = c)   
      // Incrémente le compteur lorsqu'une correspondance est trouvée
      nbrChar ← nbrChar + 1
    FinSi
    // Passe au caractère suivant de la chaîne
    i ← i + 1
  FinTantque
  // Retourne le nombre total d'occurrences trouvées
  retourner nbrChar
Fin

Explication:

• countChar(string[], c) : définit une fonction qui reçoit une chaîne de caractères et un caractère à rechercher.
• nbrChar ← 0 : initialise le compteur à zéro, car aucune occurrence n'a encore été trouvée.
• i ← 0 : commence le parcours de la chaîne à la première position.
• string[i] ≠ '\0' : vérifie que l'on n'est pas arrivé à la fin de la chaîne.
• string[i] = c : compare le caractère actuel avec le caractère recherché.
• nbrChar ← nbrChar + 1 : augmente le compteur lorsqu'une correspondance est trouvée.
• i ← i + 1 : passe au caractère suivant.
• Retourner nbrChar : renvoie le nombre total d'occurrences du caractère.

Organigramme:

Procedure getMultiplication(N: entier)
Variables i: entier
Début
  // Parcourt les multiplicateurs de 1 à 10
  Pour i de 1 à 10 faire   
    // Calcule et affiche N multiplié par i
    Ecrire(N," x ",i," = ",N*i)
  FinPour
Fin

Explication:

• Procédure getMultiplication(N : entier) : définit une procédure qui reçoit un nombre entier N en paramètre.
• i : entier : déclare i comme compteur de la boucle.
• Pour i de 1 à 10 faire : répète l'opération pour les nombres de 1 à 10.
• N * i : calcule le résultat de la multiplication.
• Ecrire(...) : affiche chaque ligne de la table de multiplication.
• FinPour : marque la fin de la boucle.
• FinProcédure : marque la fin de la procédure.

Organigramme: