Exercices Corrigés En Algorithme – Fonctions et Procédures

Cette procédure permet simplement d’afficher le message « Hello, World! » lorsqu’elle est appelée.

Explication:

• Procédure afficherHello() : définit une procédure appelée afficherHello. Elle ne reçoit aucun paramètre.
• Ecrire("Hello, World!") : affiche le texte « Hello, World! ».
• FinProcédure : indique la fin de la procédure.

Cette procédure permet donc d’afficher n’importe quel message transmis en paramètre.

Explication:

• Procédure afficherMsg(str : chaîne de caractères) : définit une procédure appelée afficherMsg qui reçoit une chaîne de caractères str en paramètre.
• Ecrire(str) : affiche le contenu de str à l’écran.
• FinProcédure : indique la fin de la procé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:

• Fonction somme(n1, n2 : entier) : entier : définit une fonction appelée somme qui reçoit deux entiers et retourne un entier.
• n1 et n2 : représentent les deux nombres à additionner.
• Retourner n1 + n2 : calcule la somme des deux nombres et renvoie le résultat.
• FinFonction : indique la fin de la fonction.

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

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

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:

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

• 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 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(…) : 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:

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

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

• 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é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:

• 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é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:

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

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

• 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é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, 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:

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

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