Structures de base des algorithmes | Exercices corrigés

Concepts & Exercices

\(\text{Algorithme} = \text{Variables} + \text{Instructions} + \text{Structures de contrôle}\)

Structure d'un algorithme

📦

Variables : Espaces mémoire pour stocker des données.

🔄

Séquence : Instructions exécutées dans l'ordre.

❓

Conditionnelle : Instructions exécutées selon une condition.

🔁

Boucles : Répétition d'instructions tant qu'une condition est vraie.

Exercice 1

Écrire un algorithme qui calcule le discriminant d'une équation du second degré ax² + bx + c = 0 et affiche le nombre de solutions.

Exercice 2

Écrire un algorithme qui calcule la somme des n premiers entiers naturels en utilisant une boucle.

Exercice 3

Écrire un algorithme qui recherche si un élément appartient à un tableau de 10 nombres.

Exercice 4

Écrire un algorithme qui trie un tableau de 5 nombres par ordre croissant en utilisant un tri simple.

Exercice 5

Écrire un algorithme qui calcule la moyenne d'un tableau de notes et détermine la mention (passable, bien, très bien).

Corrigé : Exercices 1 à 3

1 Discriminant d'équation

Définition :

Discriminant : Pour l'équation \(ax^2 + bx + c = 0\), \(\Delta = b^2 - 4ac\).

Structure de l'algorithme :

Déclaration des variables
Saisie des coefficients
Calcul du discriminant
Structure conditionnelle pour le nombre de solutions

Algorithme complet

Variables a, b, c, delta : réels
Début
  Afficher("Entrez le coefficient a : ")
  Lire(a)
  Afficher("Entrez le coefficient b : ")
  Lire(b)
  Afficher("Entrez le coefficient c : ")
  Lire(c)
  
  delta ← b*b - 4*a*c
  
  Si delta > 0 Alors
    Afficher("L'équation a deux solutions")
  Sinon Si delta = 0 Alors
    Afficher("L'équation a une solution")
  Sinon
    Afficher("L'équation n'a pas de solution réelle")
  FinSi
Fin

Étape 1 : Variables

Variables déclarées : a, b, c, delta (tous de type réel)

Étape 2 : Entrées

Saisie des coefficients a, b, c

Étape 3 : Calcul

\(\Delta = b^2 - 4ac\) (structure de séquence)

Étape 4 : Conditionnelle

Structure conditionnelle imbriquée pour traiter les 3 cas

Si \(\Delta > 0\) : 2 solutions

Si \(\Delta = 0\) : 1 solution

Si \(\Delta < 0\) : 0 solution réelle

Réponse finale :

L'algorithme utilise une structure conditionnelle pour déterminer le nombre de solutions en fonction du discriminant.

Règles appliquées :

• Variables : Déclaration explicite des types

• Séquence : Instructions exécutées dans l'ordre

• Conditionnelle : Structure SI-SINON-SINON SI

Point clé 1

Le discriminant détermine le nombre de solutions d'une équation du second degré

Point clé 2

La structure conditionnelle permet de gérer plusieurs cas

2 Somme des n premiers entiers

Définition :

Somme des entiers : \(S = 1 + 2 + 3 + ... + n = \frac{n(n+1)}{2}\).

Algorithme avec boucle

Variables n, i, somme : entiers
Début
  Afficher("Entrez la valeur de n : ")
  Lire(n)
  
  somme ← 0
  i ← 1
  
  TantQue i <= n Faire
    somme ← somme + i
    i ← i + 1
  FinTantQue
  
  Afficher("La somme des ", n, " premiers entiers est : ", somme)
Fin

Étape 1 : Initialisation

Variables déclarées : n, i, somme

Initialisation : somme = 0, i = 1

Étape 2 : Boucle TantQue

Condition : i ≤ n

Instruction : somme ← somme + i

Incrémentation : i ← i + 1

Étape 3 : Trace de l'exécution (pour n=5)

i=1: somme=0+1=1

i=2: somme=1+2=3

i=3: somme=3+3=6

i=4: somme=6+4=10

i=5: somme=10+5=15

i=6: condition fausse, sortie de la boucle

Étape 4 : Alternative avec Pour

Pour i de 1 à n Faire
  somme ← somme + i
FinPour

Réponse finale :

L'algorithme utilise une boucle pour accumuler les entiers de 1 à n dans une variable somme.

Règles appliquées :

• Boucle : Répétition contrôlée par une condition

• Accumulateur : Variable qui accumule les valeurs

• Invariant : somme contient la somme des entiers de 1 à i-1

Point clé 1

La boucle TantQue nécessite une initialisation avant la boucle

Point clé 2

La condition de continuation doit évoluer à chaque itération

3 Recherche dans un tableau

Définition :

Tableau : Structure de données contenant des éléments de même type.

Algorithme de recherche

Variables tab[10] : réels
Variables i, element, trouve : entiers
Début
  // Initialisation du tableau
  Pour i de 0 à 9 Faire
    Afficher("Entrez l'élément ", i, " : ")
    Lire(tab[i])
  FinPour
  
  Afficher("Entrez l'élément à rechercher : ")
  Lire(element)
  
  trouve ← 0
  i ← 0
  
  TantQue (i < 10) ET (trouve = 0) Faire
    Si tab[i] = element Alors
      trouve ← 1
    Sinon
      i ← i + 1
    FinSi
  FinTantQue
  
  Si trouve = 1 Alors
    Afficher("L'élément est présent à l'indice ", i)
  Sinon
    Afficher("L'élément n'est pas dans le tableau")
  FinSi
Fin

Étape 1 : Déclaration

Tableau tab de 10 réels

Variables i, element, trouve

Étape 2 : Initialisation du tableau

Boucle Pour pour remplir le tableau

Étape 3 : Recherche

Initialisation : trouve = 0, i = 0

Boucle TantQue avec condition composée

Si élément trouvé : trouve = 1 (sortie de boucle)

Étape 4 : Résultat

Structure conditionnelle pour afficher le résultat

Réponse finale :

L'algorithme utilise une boucle conditionnelle pour rechercher un élément dans un tableau.

Règles appliquées :

• Tableau : Accès aux éléments par indice

• Boucle : Condition composée pour arrêt anticipé

• Booléen : Variable indicatrice de statut

Point clé 1

La recherche s'arrête dès que l'élément est trouvé

Point clé 2

Utilisation d'une variable booléenne pour contrôler la boucle

Corrigé : Exercices 4 à 5

4 Tri d'un tableau

Définition :

Tri à bulles : Algorithme de tri qui compare les éléments adjacents et les échange si nécessaire.

Algorithme de tri à bulles

Variables tab[5] : réels
Variables i, j, temp : réels
Début
  // Initialisation du tableau
  Pour i de 0 à 4 Faire
    Afficher("Entrez l'élément ", i, " : ")
    Lire(tab[i])
  FinPour
  
  // Tri à bulles
  Pour i de 0 à 3 Faire
    Pour j de 0 à 3-i Faire
      Si tab[j] > tab[j+1] Alors
        temp ← tab[j]
        tab[j] ← tab[j+1]
        tab[j+1] ← temp
      FinSi
    FinPour
  FinPour
  
  // Affichage du tableau trié
  Afficher("Tableau trié : ")
  Pour i de 0 à 4 Faire
    Afficher(tab[i], " ")
  FinPour
Fin

Étape 1 : Déclaration et initialisation

Tableau tab de 5 réels

Variables i, j, temp

Remplissage du tableau

Étape 2 : Boucles imbriquées

Boucle extérieure : i de 0 à 3 (itérations de tri)

Boucle intérieure : j de 0 à 3-i (comparaisons)

Étape 3 : Comparaison et échange

Si tab[j] > tab[j+1] alors échange

Utilisation de la variable temporaire pour l'échange

Étape 4 : Trace de l'exécution (exemple)

Tableau initial : [5, 2, 8, 1, 9]

Après itération 1 : [2, 5, 1, 8, 9]

Après itération 2 : [2, 1, 5, 8, 9]

Après itération 3 : [1, 2, 5, 8, 9]

Réponse finale :

L'algorithme utilise des boucles imbriquées pour trier le tableau par ordre croissant.

Règles appliquées :

• Boucles imbriquées : Structure Pour dans une autre Structure Pour

• Échange : Utilisation d'une variable temporaire

• Optimisation : La borne supérieure diminue à chaque itération

Point clé 1

Les boucles imbriquées permettent de comparer tous les couples d'éléments

Point clé 2

La variable temporaire est nécessaire pour échanger deux valeurs

5 Calcul de moyenne et mention

Définition :

Moyenne : Somme des valeurs divisée par le nombre de valeurs.

Algorithme de calcul de moyenne

Variables notes[5] : réels
Variables i, somme, moyenne : réels
Début
  // Initialisation du tableau de notes
  Pour i de 0 à 4 Faire
    Répéter
      Afficher("Entrez la note ", i+1, " : ")
      Lire(notes[i])
    Jusqu'à (notes[i] >= 0) ET (notes[i] <= 20)
  FinPour
  
  // Calcul de la somme
  somme ← 0
  Pour i de 0 à 4 Faire
    somme ← somme + notes[i]
  FinPour
  
  // Calcul de la moyenne
  moyenne ← somme / 5
  
  // Attribution de la mention
  Si moyenne >= 16 Alors
    Afficher("Moyenne : ", moyenne, " - Mention : Très bien")
  Sinon Si moyenne >= 14 Alors
    Afficher("Moyenne : ", moyenne, " - Mention : Bien")
  Sinon Si moyenne >= 12 Alors
    Afficher("Moyenne : ", moyenne, " - Mention : Assez bien")
  Sinon Si moyenne >= 10 Alors
    Afficher("Moyenne : ", moyenne, " - Mention : Passable")
  Sinon
    Afficher("Moyenne : ", moyenne, " - Mention : Insuffisant")
  FinSi
Fin

Étape 1 : Saisie validée

Structure Répéter...Jusqu'à pour valider les notes entre 0 et 20

Étape 2 : Calcul de la somme

Boucle Pour pour accumuler les notes

Étape 3 : Calcul de la moyenne

moyenne = somme / nombre_d'éléments

Étape 4 : Attribution de la mention

Structure conditionnelle imbriquée pour les mentions

Très bien : ≥ 16, Bien : ≥ 14, Assez bien : ≥ 12, Passable : ≥ 10

Étape 5 : Structure alternative (Pour une taille variable)

Variables n : entier
// Demander le nombre de notes
Afficher("Combien de notes ? ")
Lire(n)
// Redimensionner ou utiliser une structure adaptée

Réponse finale :

L'algorithme calcule la moyenne d'un tableau de notes et attribue une mention selon des seuils prédéfinis.

Règles appliquées :

• Validation : Structure Répéter...Jusqu'à pour contrôler les entrées

• Calcul : Accumulation suivie de division

• Classification : Structure conditionnelle pour catégoriser

Point clé 1

La validation des entrées garantit la cohérence des données

Point clé 2

Les seuils de classification doivent être ordonnés de manière logique

Cours bien détaillé

\(\text{Algorithme} = \sum_{i=1}^{n} \text{instruction}_i\)

Structure séquentielle

📦

Variables : Espaces mémoire nommés pour stocker des données.

🔄

Séquence : Instructions exécutées dans l'ordre d'écriture.

❓

Conditionnelle : Exécution conditionnée par une expression booléenne.

🔁

Boucles : Répétition d'instructions selon une condition.

💡

Conseil : Toujours déclarer les variables avec leur type

🔍

Attention : Vérifier que les boucles ont une condition de sortie

⚡

Astuce : Indenter le code pour améliorer la lisibilité

📋

Méthode : Structurer l'algorithme en phases claires

✅

Vérification : Faire une trace d'exécution pour valider l'algorithme

Méthodologie de construction :

Analyse du problème : Identifier les données d'entrée et les résultats attendus
Choix des structures : Sélectionner les structures de contrôle appropriées
Implémentation : Écrire l'algorithme en respectant la syntaxe
Validation : Vérifier avec des exemples concrets

Règles fondamentales :

Les variables doivent être déclarées avant utilisation
Les boucles doivent avoir une condition de terminaison
Les structures conditionnelles doivent couvrir tous les cas possibles
Les tableaux ont des indices généralement de 0 à n-1
Les algorithmes doivent être lisibles et commentés

\(\text{Si condition Alors instruction1 Sinon instruction2 FinSi}\)

Structure conditionnelle

Structures de base des algorithmesExercices corrigés

Structures de base des algorithmes
Exercices corrigés