Exercices td algorithmique et programmation basique correcti
Télécharger PDFExercices Corrigés d'Algorithmique - Partie 1
Ce document présente une série d'exercices d'algorithmique accompagnés de leurs corrections détaillées. Chaque problème aborde des concepts fondamentaux de la programmation, tels que les procédures, les fonctions, les boucles et les conditions, afin d'améliorer la compréhension et la capacité à résoudre des problèmes logiques.
Énoncés des Exercices
Exercice 1: Table de Multiplication
Énoncé : Écrire une procédure qui calcule et affiche la table de multiplication d'un nombre entier donné.
Exercice 2: Racine Carrée
Énoncé : Écrire une fonction qui calcule la racine carrée d'un nombre entier donné.
Exercice 3: Saisie Conditionnelle d'un Nombre
Énoncé : Écrire un algorithme qui demande un nombre compris entre 10 et 20. La saisie doit être répétée jusqu'à ce que la réponse convienne. En cas de réponse supérieure à 20, un message "Plus petit !" doit apparaître, et "Plus grand !" si le nombre est inférieur à 10.
Exercice 4: Calcul du Coût de Photocopie
Énoncé : Un magasin de reprographie facture 0,25 DH les dix premières photocopies, 0,20 DH les vingt suivantes et 0,15 DH au-delà. Écrire un algorithme qui demande à l'utilisateur le nombre de photocopies effectuées, puis affiche le montant correspondant.
Exercice 5: Compter les Occurrences d'un Caractère
Énoncé : Écrire un algorithme qui permet à l'utilisateur de saisir une suite de caractères se terminant par le caractère '*', et qui affiche à la fin le nombre d'apparitions de la lettre 'A' (en majuscule).
Exercice 6: Afficher les Nombres Pairs entre Deux Bornes
Énoncé : Écrire une procédure qui permet d'entrer deux valeurs M et N, et d'afficher toutes les valeurs paires comprises entre M et N (inclus).
Corrections Détaillées
Correction de l'Exercice 1
Correction : Nous allons construire une procédure pour calculer la table de multiplication. Cette procédure sera appelée avec un nombre fourni par l'utilisateur et affichera les produits de ce nombre avec les entiers de 1 à 10. Les fonctions et procédures sont des blocs de code réutilisables qui facilitent la structuration des algorithmes.
Voici deux implémentations, l'une utilisant une boucle "Pour" et l'autre une boucle "TantQue" :
PROCEDURE TABL_POUR(VAR X : ENTIER)
VAR i : ENTIER
DEBUT
Pour i de 1 à 10 Faire
Ecrire(X, " × ", i, " = ", X * i)
FinPour
FIN
PROCEDURE TABL_TANTQUE(VAR X : ENTIER)
VAR i : ENTIER
DEBUT
i ← 1
TantQue (i <= 10) Faire
Ecrire(X, " × ", i, " = ", X * i)
i ← i + 1
FinTantQue
FIN
Correction de l'Exercice 2
Correction : Cette fonction calcule la racine carrée d'un nombre donné. Il est important de noter que le nombre doit être positif pour que la racine carrée soit un nombre réel. En algorithmique, le symbole '^' est couramment utilisé pour l'opérateur de puissance, donc X^(1/2) représente la racine carrée de X.
FONCTION RACINECARREE(VAR X : ENTIER) RETOURNE REEL
VAR rac : REEL
DEBUT
// On suppose que X est déjà un nombre positif
rac ← X ^ (1/2)
Retourner(rac)
FIN
Correction de l'Exercice 3
Correction : L'algorithme demande à l'utilisateur de saisir un nombre et le force à être compris entre 10 et 20. Une boucle "TantQue" est utilisée pour répéter la saisie et les messages d'erreur tant que le nombre n'est pas dans l'intervalle spécifié.
ALGORITHME saisie_nombre_intervalle
VAR N : REEL
DEBUT
Ecrire("Entrez un nombre entre 10 et 20")
Lire(N) // Première lecture
TantQue (N < 10 OU N > 20) Faire
Si (N < 10) Alors
Ecrire("Plus grand !")
Sinon Si (N > 20) Alors
Ecrire("Plus petit !")
FinSi
Lire(N) // Lectures suivantes
FinTantQue
Ecrire("Le nombre ", N, " est valide.")
FIN
Explication : La première lecture de N est effectuée avant d'entrer dans la boucle. La condition de la boucle "TantQue" est ensuite évaluée avec cette première valeur. Si la condition est vraie (le nombre n'est pas entre 10 et 20), le corps de la boucle s'exécute, affichant un message et demandant une nouvelle saisie. La boucle continue de s'exécuter avec chaque nouvelle valeur saisie jusqu'à ce que la condition devienne fausse.
Correction de l'Exercice 4
Correction : Cet algorithme calcule le coût total des photocopies en appliquant des tarifs dégressifs. Il demande le nombre de photocopies à l'utilisateur, puis détermine le prix en fonction des tranches : 0,25 DH pour les 10 premières, 0,20 DH pour les 20 suivantes, et 0,15 DH pour toute photocopie au-delà de 30.
ALGORITHME calcul_cout_photocopies
VAR nbr_photocopies : ENTIER // Le nombre de photocopies est un entier
prix_total : REEL // Le prix peut contenir des décimales
DEBUT
Ecrire("Entrez le nombre de photocopies : ")
Lire(nbr_photocopies)
Si (nbr_photocopies <= 10) Alors
prix_total ← nbr_photocopies * 0.25
Sinon Si (nbr_photocopies <= 30) Alors // Pour 11 à 30 photocopies
prix_total ← (10 * 0.25) + ((nbr_photocopies - 10) * 0.20)
Sinon // Pour plus de 30 photocopies
prix_total ← (10 * 0.25) + (20 * 0.20) + ((nbr_photocopies - 30) * 0.15)
FinSi
Ecrire("Le prix total est : ", prix_total, " DH")
FIN
Attention : La variable 'prix_total' recevra une seule affectation parmi les trois conditions, selon la première condition vérifiée. Il est pertinent d'utiliser un type ENTIER pour le nombre de photocopies et un type REEL pour le prix total.
Correction de l'Exercice 5
Correction : L'algorithme lit une suite de caractères un par un jusqu'à ce que le caractère astérisque ('*') soit rencontré, signalant la fin de la saisie. Pendant ce processus, il compte le nombre de fois où la lettre 'A' (en majuscule) apparaît dans la suite. En algorithmique, le symbole '<>' signifie "est différent de".
ALGORITHME compter_apparitions_A
VAR caractere_lu : CARACTERE // Pour lire un caractère à la fois
compteur_A : ENTIER // Compteur des 'A'
DEBUT
compteur_A ← 0
Ecrire("Saisissez une suite de caractères (terminez par '*') :")
Lire(caractere_lu) // Première lecture avant la boucle
TantQue (caractere_lu <> '*') Faire
Si (caractere_lu = 'A') Alors
compteur_A ← compteur_A + 1
FinSi
Lire(caractere_lu) // Lecture suivante à l'intérieur de la boucle
FinTantQue
Ecrire("Nombre d'apparitions de 'A' est : ", compteur_A)
FIN
Explication : Un premier caractère est lu avant la boucle pour initialiser la condition. La boucle "TantQue" continue tant que le caractère lu n'est pas l'astérisque. À chaque itération, le caractère est vérifié, et un nouveau caractère est lu, préparant la prochaine évaluation de la condition de la boucle.
Correction de l'Exercice 6
Correction : Cette procédure affiche tous les nombres pairs compris entre deux entiers M et N (inclus). Pour gérer les cas où M et N sont entrés dans un ordre quelconque, un filtre est intégré pour s'assurer que N est toujours la borne inférieure et M la borne supérieure avant de commencer l'itération.
PROCEDURE afficher_nombres_pairs_entre_bornes
VAR M, N, Temp : ENTIER
DEBUT
Ecrire("Entrez la première valeur (M) : ")
Lire(M)
Ecrire("Entrez la deuxième valeur (N) : ")
Lire(N)
// Filtre : s'assure que N contient la plus petite valeur et M la plus grande
Si (N > M) Alors
Temp ← M // Sauvegarde temporaire de M
M ← N // M prend la valeur de N
N ← Temp // N prend l'ancienne valeur de M (qui était la plus petite)
FinSi
Ecrire("Les nombres pairs entre ", N, " et ", M, " sont :")
TantQue (N <= M) Faire // La boucle parcourt de N à M, inclus
Si (N % 2 = 0) Alors // Vérifie si N est pair
Ecrire(N)
FinSi
N ← N + 1
FinTantQue
FIN
Explication du filtre : Le bloc Si (N > M) Alors ... FinSi est un mécanisme de sécurité. Il garantit que la variable N contient la valeur minimale et M la valeur maximale avant l'exécution de la boucle d'affichage. Si, par exemple, l'utilisateur saisit N=33 et M=10, sans ce filtre, la boucle TantQue (N <= M) ne s'exécuterait jamais car la condition (33 <= 10) serait fausse dès le départ, et aucun nombre ne serait affiché. L'échange des valeurs permet à la boucle de fonctionner correctement dans tous les cas, en s'assurant que l'itération commence toujours par la plus petite des deux valeurs.
Rappel : L'expression A % B = C signifie, en algorithmique, que le reste de la division entière de A par B est égal à C. Par conséquent, N % 2 = 0 est la condition pour vérifier si un nombre N est pair.
Foire Aux Questions (FAQ)
Pourquoi utiliser des procédures et des fonctions en algorithmique ?
L'utilisation de procédures et de fonctions est essentielle pour organiser un algorithme. Elles permettent de décomposer un problème complexe en sous-problèmes plus simples, de réutiliser le code sans le réécrire (principe de modularité), et de rendre l'algorithme plus lisible et plus facile à maintenir. Une fonction est conçue pour retourner une valeur spécifique, tandis qu'une procédure exécute une série d'actions sans nécessairement produire de valeur en retour.
Quelle est la différence entre une boucle "Pour" et une boucle "TantQue" ?
La boucle "Pour" (souvent appelée "for" dans les langages de programmation) est principalement utilisée lorsque le nombre d'itérations est connu à l'avance ou peut être facilement déterminé (par exemple, pour répéter une action un nombre fixe de fois). En revanche, la boucle "TantQue" (ou "while") est employée lorsque le nombre d'itérations est indéterminé et dépend d'une condition qui doit rester vraie pour que la boucle continue. Elle est idéale pour les situations où l'on doit répéter une action jusqu'à ce qu'une certaine condition ne soit plus remplie, comme une saisie utilisateur valide ou la lecture d'une suite de caractères jusqu'à un marqueur de fin.
Comment vérifier si un nombre est pair ou impair en algorithmique ?
En algorithmique, pour déterminer si un nombre est pair ou impair, on utilise l'opérateur modulo (%). Cet opérateur renvoie le reste de la division entière. Un nombre est considéré comme pair si le reste de sa division par 2 est égal à 0 (Nombre % 2 = 0). Inversement, si le reste de sa division par 2 est égal à 1 (Nombre % 2 = 1), le nombre est impair.