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

Fonction calculerPGCD(n1,n2:entier):entier
Début
   // Répète les calculs tant que les 2 nombres sont différents de 0
   Tantque(n1 * n2 ≠ 0) Faire
     // Vérifie quel nombre est le plus grand
     Si(n1 > n2) Alors
        // Soustrait n2 de n1 pour réduire le plus grand nombre
        n1 ← n1 - n2
     Sinon
        // Soustrait n1 de n2 pour réduire le plus grand nombre
        n2 ← n2 - n1
     FinSi
   FinTantque
   
   // Vérifie si n1 est devenu égal à 0
   Si(n1 = 0) alors
     retourner n2   // Le PGCD est alors contenu dans n2
   Sinon
     retourner n1  // Sinon, le PGCD est contenu dans n1
   FinSi
Fin 

Explication:

• Fonction calculerPGCD(n1, n2 : entier) : entier : définit une fonction qui reçoit deux entiers et retourne leur PGCD.
• TantQue (n1 * n2 ≠ 0) : continue les calculs tant que n1 et n2 ne sont pas nuls.
• Si (n1 > n2) : détermine lequel des deux nombres est le plus grand.
• n1 ← n1 – n2 : soustrait le plus petit nombre du plus grand.
• n2 ← n2 – n1 : même principe lorsque n2 est le plus grand.
• Si (n1 = 0) : lorsque n1 devient zéro, le PGCD est la valeur restante dans n2.
• Retourner n2 / Retourner n1 : renvoie le PGCD calculé.

Organigramme:

Procédure testSigne(n1,n2: réel)
Variables sum, mult: réels
Début
  Lire(n1, n2)  // Lit les 2 nombres saisis par l'utilisateur
  sum ← n1 + n2   // Calcule la somme des deux nombres
  mult ← n1 * n2  // Calcule le produit des deux nombres
  Si(sum ≥ 0) Alors  // Vérifie si la somme est positive ou nulle
    Ecrire("Somme positive")  // Affiche que la somme est positive
  Sinon
    Ecrire("Somme négative")  // Affiche que la somme est négative
  FinSi
  // Vérifie si le produit est positif ou nul
  Si(mult ≥ 0) Alors   
    // Affiche que le produit est positif
    Ecrire("Multiplication positif")  
  Sinon
    // Affiche que le produit est négatif
    Ecrire("Multiplication négatif")
  FinSi
FinProcédure 

Explication:

• Lire(n1, n2) : lit les deux nombres réels saisis par l’utilisateur.
• sum ← n1 + n2 : calcule la somme des deux nombres.
• mult ← n1 * n2 : calcule leur produit.
• Si (sum ≥ 0) : vérifie si la somme est positive ou égale à zéro.
• Si (mult ≥ 0) : vérifie si le produit est positif ou égal à zéro.
• Ecrire(…) : affiche le signe correspondant au résultat.

Organigramme:

Procédure nbrPremier(N:entier)
Variables flag:booleen 
		  compteur:entier
Début
  flag ← Vrai  // Suppose au départ que N est un nombre premier
  compteur ← 2  // Commence la recherche d'un diviseur à partir de 2

  // Continue tant qu'on n'a pas trouvé de diviseur
  // et que compteur ne dépasse pas N/2
  Tantque(compteur ≤ N/2 et flag = Vrai) Faire
    // Vérifie si N est divisible par compteur
    Si(N mod compteur = 0) Alors
      // Un diviseur a été trouvé : N n'est pas premier
      flag ← Faux
    Sinon
      // Passe au diviseur suivant
      compteur ← compteur + 1
    FinSi
  FinTantque
  // Vérifie si aucun diviseur n'a été trouvé
  Si(flag = Vrai) Alors
    // Affiche que N est un nombre premier
    Ecrire(N, " est premier")
  Sinon
    // Affiche que N n'est pas un nombre premier
    Ecrire(N, " n'est pas premier")
  FinSi
Fin

Explication:

• flag ← Vrai : considère initialement que le nombre est premier. flag servira à mémoriser le résultat du test.
• compteur ← 2 : commence à tester les diviseurs à partir de 2.
• N mod compteur = 0 : vérifie si N est divisible par compteur.
• flag ← Faux : si un diviseur est trouvé, le nombre n’est pas premier.
• compteur ← compteur + 1 : passe au diviseur suivant lorsqu’aucun diviseur n’a été trouvé.
• TantQue (… et flag = Vrai) : permet d’arrêter immédiatement la recherche dès qu’un diviseur est trouvé.
• Si (flag = Vrai) : si aucun diviseur n’a été trouvé, le nombre est considéré comme premier.

Organigramme:

Fonction fact(N: entier):entier 
Début
    // Vérifie si N est un cas de base du factoriel
    Si (N=0 ou N=1) alors
       retourner 1   // 0! et 1! sont égaux à 1
    Sinon   
       // Appelle la fonction avec N-1 puis multiplie par N
       retourner fact(n-1) * n
    FinSi 
Fin

Explication:

• Fonction fact(N : entier) : entier : définit une fonction fact qui reçoit un entier N et retourne son factoriel.
• Si (N = 0 ou N = 1) : définit le cas de base de la récursivité.
• Retourner 1 : le factoriel de 0 et de 1 vaut 1.
• fact(N – 1) : appelle la fonction elle-même avec une valeur diminuée de 1. C’est ce qu’on appelle une fonction récursive.
• fact(N – 1) * N : applique la définition du factoriel: N! = N × (N-1)!.

Organigramme:

Procédure NbrPaires(N1,N2:entiers)
Début
  // Vérifie que N1 est bien inférieur à N2
  Si(N1 >= N2) Alors
      // Affiche un message d'erreur si la condition n'est pas respectée
      Ecrire("Erreur: N1 doit étre inférieur à N2!")
  Sinon
    // Parcourt tous les nombres compris entre N1 et N2
    Tantque(N1 < N2) Faire
       // Vérifie si N1 est divisible par 2
       Si(N1 mod 2 = 0) Alors
          // Affiche N1 s'il est pair
          Ecrire(N1)
       FinSi
          N1 ← N1 + 1    // Passe au nombre suivant
    FinTantque
  FinSi
Fin 

Explication:

• Si (N1 >= N2) : vérifie que le premier nombre est bien inférieur au deuxième.
• Ecrire("Erreur...") : affiche un message si N1 est supérieur ou égal à N2.
• TantQue (N1 < N2) : parcourt les nombres de N1 jusqu'à N2 - 1.
• N1 mod 2 = 0 : vérifie si le nombre est pair.
• Ecrire(N1) : affiche le nombre lorsqu'il est pair.
• N1 ← N1 + 1 : augmente N1 de 1 afin de passer au nombre suivant.

Organigramme:

Fonction Fibonacci(N: entier): entier 
 Début 
     // Vérifie si N correspond à l'un des deux cas de base
     Si(N=0 ou N=1) alors
        // Les deux premiers termes de cette définition valent 1 
        Retourner 1
     Sinon
        // Appelle récursivement la fonction pour calculer les 
        // 2 termes précédents puis additionne leurs résultats
        Retourner Fibonacci(N-2) + Fibonacci(N-1)
    FinSi 
FinFonction

Explication:

• Fonction Fibonacci(N : entier) : entier : définit une fonction récursive qui reçoit un entier N et retourne le terme correspondant de la suite.
• Si (N = 0 ou N = 1) : représente les cas de base qui permettent d'arrêter la récursivité.
• Retourner 1 : selon cet algorithme, Fibonacci(0) et Fibonacci(1) valent 1.
• Fibonacci(N - 2) : calcule le terme situé deux positions avant.
• Fibonacci(N - 1) : calcule le terme situé une position avant.
• Fibonacci(N - 2) + Fibonacci(N - 1) : additionne les deux termes précédents pour obtenir le terme courant.

Organigramme:

Procédure nbrCompris(N1:entier, N2:entier) 
Début 
  Ecrire(N1)   // Affiche la valeur actuelle de N1
  Si(N1 < N2) alors   // Vérifie si N1 est encore inférieur à N2
    // Incrémente N1 de 1
    N1 ← N1 + 1       
    // Rappelle la procédure avec la nouvelle valeur de N1 
    nbrCompris(N1,N2)  
  FinSi 
FinProcédure

Explication:

• nbrCompris(N1, N2) : définit une procédure qui reçoit deux entiers en paramètres.
• Ecrire(N1) : affiche la valeur actuelle de N1.
• Si (N1 < N2) : vérifie si N1 est encore inférieur à N2.
• N1 ← N1 + 1 : augmente N1 de 1.
• nbrCompris(N1, N2) : appelle à nouveau la procédure avec la nouvelle valeur de N1. C'est une récursion.

Organigramme:

Procédure afficherNbrs(n: entier) 
Début 
  Ecrire(20 - n)   // Calcule et affiche 20 - n
  Si (n > 0) alors   // Vérifie si n est supérieur à 0
     n ← n + 1       // Incrémente n de 1
     afficherNbrs(n) //Rappelle la procédure avec la nouvelle valeur de n
  FinSi 
FinProcédure

Explication:

• Ecrire(20 - n) : affiche le résultat de 20 - n.
• Si (n > 0) : vérifie si la valeur de n est positive.
• n ← n + 1 : augmente n de 1 avant l'appel récursif.
• afficherNbrs(n) : appelle à nouveau la procédure. C'est une récursion.

Organigramme:

Fonction pow(b:réel, e:entier): réel
Début 
    // Vérifie si l'exposant est égal à 0
    Si(e = 0) alors 
       // Toute valeur élevée à la puissance 0 vaut 1   
       retourner 1
    Sinon
       // Calcule récursivement la puissance
       retourner pow(b, e-1) * b
    FinSi
FinFonction

Explication:

• pow(b : réel, e : entier) : la fonction reçoit une base b et un exposant e.
• Si (e = 0) : constitue le cas de base de la récursivité.
• Retourner 1 : car toute base élevée à la puissance 0 donne 1.
• pow(b, e - 1) : rappelle la fonction avec un exposant diminué de 1.
• pow(b, e - 1) * b : applique la formule bᵉ = bᵉ⁻¹ × b.

Organigramme:

Fonction sum(N: entier): entier 
Début
   Si(N=0) alors   // Vérifie si N a atteint le cas de base
      retourner 0  // La somme jusqu'à 0 est égale à 0
   Sinon 
      // Calcule récursivement la somme jusqu'à N-1, puis ajoute N
      retourner sum(N-1) + N
   FinSi
FinFonction

Explication:

• Fonction sum(N : entier) : entier : définit une fonction qui reçoit un entier N et retourne un entier.
• Si (N = 0) : représente le cas de base qui permet d'arrêter la récursivité.
• Retourner 0 : lorsque N = 0, la somme vaut 0.
• sum(N - 1) : appelle la fonction avec le nombre précédent.
• sum(N - 1) + N : ajoute N à la somme des nombres précédents.
• Retourner : renvoie le résultat calculé par la fonction.

Organigramme:

Fonction PGCD(n1:entier,n2:entier): entier 
Début        
    // Vérifie si le deuxième nombre est égal à 0       
    Si(n2 = 0) alors   
       retourner n1   // Si n2 = 0, le PGCD est n1
    FinSi 
    // Appelle récursivement la fonction avec n2
    // et le reste de la division de n1 par n2
    retourner PGCD(n2, n1 mod n2)
FinFonction

Explication:

• Fonction PGCD(n1, n2 : entier) : entier : définit une fonction qui reçoit deux entiers et retourne leur PGCD.
• Si (n2 = 0) : constitue le cas de base qui permet d'arrêter la récursivité.
• Retourner n1 : lorsque n2 vaut 0, le PGCD est n1.
• n1 mod n2 : calcule le reste de la division de n1 par n2.
• PGCD(n2, n1 mod n2) : rappelle la fonction avec de nouvelles valeurs. C'est une récursion.
• Retourner : renvoie finalement le PGCD obtenu.

Organigramme:

Procédure NombresPairs
Variables i,count,NbrPairs: entiers
          p : reel
Début
    // Initialise le compteur du nombre total de valeurs saisies
    count ← 0
    // Initialise le compteur du nombre de valeurs paires
    NbrPairs ← 0
    Répéter
       // Lit un nombre saisi par l'utilisateur
       Lire(i)
       // Incrémente le nombre total de valeurs saisies
       count ← count + 1
       // Vérifie si le nombre est pair
       Si (i mod 2 = 0) alors
          // Incrémente le compteur si le nombre est pair
          NbrPairs ← NbrPairs + 1
       FinSi
    //Arrête la saisie lorsqu'un nombre égal à -1 est rencontré
    Jusqu’à(i = -1)

    // Calcule le pourcentage de nombres pairs
    p ← NbrPairs * 100/count

    // Affiche le nombre de valeurs paires et leur pourcentage
    Ecrire("Nbr de valeurs paires =",NbrPairs,"| pourcentage =",p)
Fin 

Explication:

• count ← 0 : initialise le compteur du nombre de valeurs saisies.
• NbrPairs ← 0 : initialise le compteur des nombres pairs.
• Lire(i) : récupère un nombre saisi par l'utilisateur.
• count ← count + 1 : compte chaque valeur saisie.
• i mod 2 = 0 : vérifie si i est divisible par 2, donc s'il est pair.
• NbrPairs ← NbrPairs + 1 : augmente le nombre de valeurs paires trouvées.
• Jusqu'à (i = -1) : arrête la boucle lorsque l'utilisateur saisit -1.
• p ← NbrPairs * 100 / count : calcule le pourcentage de nombres pairs.
• Ecrire(...) : affiche le résultat final.

Organigramme:

Fonction calculerTTC(ht,tva:réel): réel
Variables ttc:réel
Début
    // Calcule le montant TTC en ajoutant la TVA au montant HT
    ttc ← ht * (1 + tva / 100)
    // Retourne le montant TTC calculé
    retourner ttc
FinFonction

Explication:

• Fonction calculerTTC(ht, tva : réel) : réel : définit une fonction qui reçoit le montant HT et le taux de TVA, puis retourne un résultat réel.
• ttc : réel : déclare une variable destinée à stocker le montant TTC.
• tva / 100 : transforme le taux de TVA en valeur décimale. Par exemple, 20 % devient 0,20.
• ht * (1 + tva / 100) : applique la formule: TTC = HT × (1 + TVA / 100)
• Retourner ttc : renvoie le montant TTC calculé.

Organigramme:

Procédure echoMatrice(matrice[2][3]:tableau d'entiers,ligne,col:entier)
Début 
    // Vérifie qu❛il reste encore des lignes à parcourir
    Si(ligne < 2) alors
        // Vérifie qu❛il reste encore des colonnes à parcourir
        Si(col < 3) alors 
            //Affiche l❛élément situé à la ligne & colonne actuelles
            Ecrire(matrice[ligne][col])
            // Appelle récursivement la procédure pour passer à 
            // la colonne suivante
            echoMatrice(matrice,ligne,col+1)
        Sinon 
            // Lorsque toutes les colonnes sont parcourues,
            // passe à la ligne suivante et recommence à la colonne 0
            echoMatrice(matrice,ligne+1,0)
        FinSi 
    FinSi 
FinProcédure

Explication:

• matrice[2][3] : représente une matrice de 2 lignes et 3 colonnes.
• ligne, col : indiquent la position actuelle dans la matrice.
• Si (ligne < 2) : vérifie que l'on est encore dans les limites des 2 lignes.
• Si (col < 3) : vérifie que l'on est encore dans les limites des 3 colonnes.
• Ecrire(matrice[ligne][col]) : affiche l'élément actuel de la matrice.
• echoMatrice(matrice, ligne, col + 1) : appelle la procédure avec la colonne suivante.
• echoMatrice(matrice, ligne + 1, 0) : lorsque toutes les colonnes de la ligne sont parcourues, passe à la ligne suivante et revient à la première colonne.
• La procédure est récursive : elle s'appelle elle-même jusqu'à ce que toutes les positions de la matrice soient parcourues.

Organigramme: