Corriger les anomalies | Exercices corrigés

Concepts & Exercices

Qualité_{correction} = \frac{Anomalies_{corrigées}}{Anomalies_{identifiées}} × 100\%

Calcul de la qualité de correction

Erreur de syntaxe

🔧 Syntaxe

Problème de structure du code

Erreur logique

🧠 Logique

Comportement incorrect du programme

Erreur d'exécution

⚡ Runtime

Erreur pendant l'exécution

Types d'anomalies :

Syntaxiques : Problèmes de grammaire du langage
Sémantiques : Problèmes de logique ou de signification
Logiques : Comportement incorrect par rapport à l'attente
Runtime : Erreurs pendant l'exécution (division par zéro, etc.)

Exercice 1

Correction d'erreur de syntaxe dans une boucle

Exercice 2

Correction d'erreur logique dans un calcul

Exercice 3

Correction d'erreur d'exécution (division par zéro)

Exercice 4

Correction d'anomalie dans une fonction de comparaison

Exercice 5

Correction et validation d'une fonction de tri

Corrigé : Exercices 1 à 3

1 Correction syntaxe boucle

Définition :

Problème : Correction d'une erreur de syntaxe dans une boucle

Méthode de correction :

Identifier l'erreur de syntaxe dans le message
Localiser la ligne problématique
Appliquer la correction appropriée
Recompiler et tester

Identifier l'anomalie

Diagnostiquer la cause

Appliquer la correction

Valider la correction

Étape 1 : Code original avec erreur

FONCTION CalculSomme(n) : Entier
  somme ← 0
  POUR i DE 1 A n FAIRE
    somme ← somme + i
  FIN POUR  // Manque un point-virgule
  RETOURNE somme  // Mot-clé incorrect
FIN

ERREUR: Syntaxe incorrecte - Mot-clé "RETOURNE" au lieu de "RETOURNER"

Étape 2 : Diagnostic

Erreur identifiée : Mauvais mot-clé "RETOURNE" au lieu de "RETOURNER"
Ligne concernée : Ligne 5
Type d'erreur : Syntaxique
Correction requise : Remplacer "RETOURNE" par "RETOURNER"

Étape 3 : Code corrigé

FONCTION CalculSomme(n) : Entier
  somme ← 0
  POUR i DE 1 A n FAIRE
    somme ← somme + i
  FIN POUR
  RETOURNER somme  // Correction apportée
FIN

Anomalie corrigée - Syntaxe correcte

Correction effectuée :

Remplacement de "RETOURNE" par "RETOURNER" pour corriger l'erreur de syntaxe.

Règles de correction syntaxique :

• Respecter la grammaire du langage : Mots-clés, ponctuation

• Utiliser un éditeur avec coloration syntaxique : Facilite la détection

• Lire attentivement les messages d'erreur : Indique la ligne exacte

2 Correction erreur logique

Définition :

Problème : Correction d'une erreur logique dans un calcul de moyenne

Identifier le comportement incorrect

Analyser la logique du programme

Identifier l'erreur logique

Corriger la logique

Étape 1 : Code original avec erreur logique

FONCTION CalculMoyenne(liste_notes) : Réel
  somme ← 0
  POUR note IN liste_notes FAIRE
    somme ← somme + note
  FIN POUR
  moyenne ← somme / 2  // Erreur logique ici
  RETOURNER moyenne
FIN

// Test
resultat ← CalculMoyenne([10, 15, 20])  // Attendu: 15, Obtenu: 22.5

ERREUR LOGIQUE: Division par 2 au lieu de division par le nombre d'éléments

Étape 2 : Diagnostic de l'erreur

Comportement observé : Moyenne calculée comme somme/2 au lieu de somme/nombre_d_elements
Attendu pour [10,15,20] : (10+15+20)/3 = 45/3 = 15
Obtenu : (10+15+20)/2 = 45/2 = 22.5
Erreur : Division par 2 au lieu de LONGUEUR(liste_notes)

Étape 3 : Code corrigé

FONCTION CalculMoyenne(liste_notes) : Réel
  somme ← 0
  POUR note IN liste_notes FAIRE
    somme ← somme + note
  FIN POUR
  moyenne ← somme / LONGUEUR(liste_notes)  // Correction apportée
  RETOURNER moyenne
FIN

// Test
resultat ← CalculMoyenne([10, 15, 20])  // Maintenant: 15

Erreur logique corrigée - Calcul correct de la moyenne

Correction effectuée :

Remplacement de la division par 2 par une division par LONGUEUR(liste_notes).

Règles de correction logique :

• Tester avec des cas connus : Vérifier les résultats attendus

• Revoir la logique algorithmique : S'assurer de la validité mathématique

• Utiliser des variables explicites : Facilite la compréhension

3 Correction division par zéro

Définition :

Problème : Correction d'une erreur d'exécution (division par zéro)

\frac{x}{0} = Erreur_{runtime}

\frac{x}{y} = \begin{cases} \text{résultat} & \text{si } y \neq 0 \\ \text{erreur} & \text{si } y = 0 \end{cases}

Étape 1 : Code original avec erreur d'exécution

FONCTION CalculTaux(partie, total) : Réel
  RETOURNER partie / total  // Erreur si total = 0
FIN

// Tests
resultat1 ← CalculTaux(10, 5)   // OK: 2
resultat2 ← CalculTaux(10, 0)   // Erreur: division par zéro!

ERREUR RUNTIME: Division par zéro détectée

Étape 2 : Analyse de la situation

Problème : Division par zéro non gérée
Risque : Arrêt brutal du programme
Solution : Vérifier la valeur du diviseur avant la division
Stratégie : Ajouter une condition de protection

Étape 3 : Code corrigé avec gestion d'erreur

FONCTION CalculTaux(partie, total) : Réel
  SI total = 0 ALORS
    ERREUR "Division par zéro impossible"
    RETOURNER -1  // Valeur d'erreur
  FIN SI
  RETOURNER partie / total
FIN

// Tests
resultat1 ← CalculTaux(10, 5)   // OK: 2
resultat2 ← CalculTaux(10, 0)   // Géré: -1

Erreur d'exécution corrigée - Gestion de la division par zéro

Correction effectuée :

Ajout d'une condition pour vérifier si le diviseur est zéro avant la division.

Règles de gestion des erreurs runtime :

• Anticiper les cas critiques : Division par zéro, accès hors limites

• Utiliser des protections : Conditions de sécurité

• Fournir des valeurs de secours : Codes d'erreur ou valeurs par défaut

Corrigé : Exercices 4 à 5

4 Correction fonction comparaison

Définition :

Problème : Correction d'anomalie dans une fonction de comparaison

Cas normal

✅ Correct

a > b → 1, a < b → -1, a = b → 0

Cas erroné

❌ Bug

Inversion des valeurs de retour

Cas corrigé

🎯 Fix

Retours corrects selon la logique

Étape 1 : Fonction originale avec anomalie

FONCTION Comparer(a, b) : Entier
  SI a > b ALORS
    RETOURNER -1  // Erreur: devrait retourner 1
  SINON SI a < b ALORS
    RETOURNER 1   // Erreur: devrait retourner -1
  SINON
    RETOURNER 0
  FIN SI
FIN

// Tests
resultat1 ← Comparer(5, 3)   // Attendu: 1, Obtenu: -1
resultat2 ← Comparer(3, 5)   // Attendu: -1, Obtenu: 1
resultat3 ← Comparer(3, 3)   // OK: 0

Étape 2 : Analyse comparative des résultats

Test	Entrée	Attendu	Obtenu	Erreur
Test 1	Comparer(5, 3)	1	-1	Inversion
Test 2	Comparer(3, 5)	-1	1	Inversion
Test 3	Comparer(3, 3)	0	0	OK

Étape 3 : Code corrigé

FONCTION Comparer(a, b) : Entier
  SI a > b ALORS
    RETOURNER 1   // Correction: retourne 1 si a > b
  SINON SI a < b ALORS
    RETOURNER -1  // Correction: retourne -1 si a < b
  SINON
    RETOURNER 0   // OK: retourne 0 si a = b
  FIN SI
FIN

// Tests
resultat1 ← Comparer(5, 3)   // Maintenant: 1
resultat2 ← Comparer(3, 5)   // Maintenant: -1
resultat3 ← Comparer(3, 3)   // Toujours: 0

Fonction de comparaison corrigée - Logique correcte

Correction effectuée :

Inversion des valeurs de retour pour correspondre à la logique attendue.

Règles de correction logique :

• Tester avec des cas variés : Vérifier toutes les branches de code

• Analyser les résultats attendus : Comparer avec la spécification

• Corriger les inversions logiques : Vérifier les conditions et retours

5 Correction et validation tri

Définition :

Problème : Correction et validation d'une fonction de tri

Identifier le bug dans le tri

Diagnostiquer la cause

Appliquer la correction

Valider la correction

Étape 1 : Fonction de tri originale avec bug

FONCTION TriBulle(tableau) : Tableau
  n ← LONGUEUR(tableau)
  POUR i DE 0 A n-1 FAIRE
    POUR j DE 0 A n-1 FAIRE  // Erreur: devrait être n-i-1
      SI tableau[j] > tableau[j+1] ALORS
        ECHANGER tableau[j] ET tableau[j+1]
      FIN SI
    FIN POUR
  FIN POUR
  RETOURNER tableau
FIN

Étape 2 : Analyse du problème

Erreur : La borne supérieure de la boucle intérieure est n-1 au lieu de n-i-1
Conséquence : Accès hors limites (tableau[n]) et inefficacité
Symptômes : Erreur d'exécution ou tri incomplet
Diagnostic : La boucle compare des éléments au-delà de la zone utile

Étape 3 : Code corrigé

FONCTION TriBulle(tableau) : Tableau
  n ← LONGUEUR(tableau)
  POUR i DE 0 A n-1 FAIRE
    POUR j DE 0 A n-i-1 FAIRE  // Correction: borne réduite à chaque itération
      SI j+1 < n ET tableau[j] > tableau[j+1] ALORS
        ECHANGER tableau[j] ET tableau[j+1]
      FIN SI
    FIN POUR
  FIN POUR
  RETOURNER tableau
FIN

// Tests
original ← [3, 1, 4, 1, 5]
trie ← TriBulle(original)
// Attendu: [1, 1, 3, 4, 5]

Étape 4 : Validation complète

# Tests de validation
test1 ← TriBulle([3, 1, 4, 1, 5])     # Attendu: [1, 1, 3, 4, 5]
test2 ← TriBulle([])                   # Attendu: []
test3 ← TriBulle([5])                  # Attendu: [5]
test4 ← TriBulle([1, 2, 3, 4, 5])      # Attendu: [1, 2, 3, 4, 5] (déjà trié)
test5 ← TriBulle([5, 4, 3, 2, 1])      # Attendu: [1, 2, 3, 4, 5] (inversé)

Fonction de tri corrigée et validée - Tous les tests passent

Correction effectuée :

Correction de la borne de la boucle intérieure et ajout de la protection d'indice.

Règles de validation des corrections :

• Tester avec des cas limites : Vide, singleton, trié, inversé

• Vérifier la complexité : S'assurer que la correction n'empire pas les performances

• Confirmer la correction : Tous les tests existants doivent passer

Cours bien détaillé

Efficacité_{correction} = \frac{T_{identification} + T_{diagnostic} + T_{correction}}{T_{résolution}}

Processus de correction des anomalies

🔍

Identification : Repérer les symptômes de l'anomalie.

🧠

Diagnostic : Comprendre la cause profonde du problème.

🔧

Correction : Apporter la modification nécessaire.

✅

Validation : S'assurer que la correction résout le problème.

💡

Conseil : Toujours tester la correction avec les mêmes cas qui ont provoqué l'erreur

🔍

Attention : Vérifier que la correction ne crée pas de nouveaux bugs

⚡

Astuce : Utiliser des outils de débogage pour localiser les erreurs

📋

Méthode : Documenter les anomalies et leurs corrections

✅

Vérification : Tester la correction avec des cas variés

Méthodes de correction :

Débogage pas à pas : Exécuter le code instruction par instruction
Analyse statique : Examiner le code sans l'exécuter
Inspection de code : Revue par un pair
Test de bout en bout : Validation complète du fonctionnement

Règles importantes :

Ne jamais corriger une anomalie sans la comprendre d'abord
La correction doit résoudre le problème sans en créer de nouveaux
Toute correction doit être testée avant d'être validée
Documenter les corrections pour référence future

Points clés à retenir :

Systématicité : Suivre une méthode structurée pour corriger les anomalies
Prudence : Vérifier que la correction n'affecte pas d'autres parties du code
Validation : S'assurer que la correction résout le problème initial
Apprentissage : Tirer des leçons des anomalies pour éviter les récidives

Corriger les anomaliesExercices corrigés

Corriger les anomalies
Exercices corrigés