Exercises on Algorithms and Data Structures

Ce laboratoire propose une série d'exercices d'algorithmique et de structures de données. Il permet d'apprendre à écrire des algorithmes simples en pseudo-code, à manipuler des conditions, des boucles, des variables et des structures de contrôle. Pour réaliser ces exercices, il est nécessaire de disposer d'un environnement permettant de saisir et d'exécuter des algorithmes en pseudo-code ou dans un langage de programmation similaire.

Objectifs

• Écrire des algorithmes pour résoudre des problèmes classiques (calcul de tarifs, IMC, propriétés de triangles, etc.).
• Utiliser des structures conditionnelles (si, sinon, cas) et des boucles (pour, tant que, répéter).
• Manipuler des variables de différents types (entiers, réels, chaînes de caractères, booléens).
• Comprendre et appliquer des concepts mathématiques simples dans des programmes.
• Développer une logique de programmation claire et structurée.

Prérequis et installation

• Connaissances de base en algorithmique (variables, conditions, boucles).
• Notions élémentaires en mathématiques (arithmétique, propriétés des triangles, calculs de moyenne).
• Un éditeur de texte ou un environnement de développement permettant d'écrire et tester des algorithmes en pseudo-code ou dans un langage proche.

Exercice 1 : Calcul des tarifs en fonction de l'âge

Écrire un algorithme qui calcule le prix d'une place selon l'âge du passager. Les règles sont :

• Les enfants de moins de 2 ans ne paient pas.
• Les enfants de moins de 10 ans paient moitié prix.
• Les personnes de moins de 27 ans ou de plus de 70 ans bénéficient d'une réduction de 10%.
• Sinon, le prix de base est appliqué.

L'utilisateur doit saisir le prix de base et l'âge, puis le programme affiche le prix final.

AlgorithmeTarifs
VAR prix, age : entier
DEBUT
  ecrire « Entrez le prix de la place, puis votre age : »
  lire (prix, age)
  Si (age < 2) Alors
    ecrire « Vous ne payez pas »
  Sinon
    Si (age < 10) Alors
      ecrire « Vous devez payer : », prix / 2
    Sinon
      Si ((age < 27) OU (age > 70)) Alors
        ecrire « Vous devez payer : », prix - (prix * 10) / 100
      Sinon
        ecrire « Vous devez payer : », prix
      FinSi
    FinSi
  FinSi
FIN

Ce programme permet de vérifier que les réductions sont correctement appliquées selon l'âge.

Exercice 2 : Calcul de l'indice de masse corporelle (IMC)

Écrire un algorithme qui demande le sexe (H/F), la taille (en cm) et le poids (en kg) d'une personne. Il calcule l'IMC selon la formule :

IMC = poids / (taille * taille)

et affiche un message selon les seuils :

• Pour un homme : "vous devriez surveiller votre alimentation" si IMC ≥ 25, "vous devriez prendre des forces" si IMC ≤ 19, sinon "vous êtes à votre poids de forme".
• Pour une femme : "vous devriez surveiller votre alimentation" si IMC ≥ 23, "vous devriez prendre des forces" si IMC ≤ 18, sinon "vous êtes à votre poids de forme".

Algorithme MasseCorpo
VAR
  taille, poids, indice : entier
  sexe : caractère
  phrase_finale : chaine
DEBUT
  ecrire (« Quel est votre sexe ? (H/F) »)
  lire (sexe)
  ecrire (« Entrez votre taille (en cm) puis votre poids (en kg) »)
  lire (taille, poids)
  indice ← poids / (taille * taille)
  Si (sexe = 'H') Alors
    Si (indice >= 25) Alors
      phrase_finale ← « vous devriez surveiller votre alim. »
    Sinon
      Si (indice <= 19) Alors
        phrase_finale ← « vous devriez prendre des forces. »
      Sinon
        phrase_finale ← « Vous êtes à votre poids de forme »
      FinSi
    FinSi
  Sinon
    Si (indice >= 23) Alors
      phrase_finale ← « vous devriez surveiller votre alim »
    Sinon
      Si (indice <= 18) Alors
        phrase_finale ← « vous devriez prendre des forces »
      Sinon
        phrase_finale ← « Vous êtes à votre poids de forme »
      FinSi
    FinSi
  FinSi
  ecrire (phrase_finale)
FIN

Ce programme illustre l'utilisation de conditions imbriquées et de variables de type chaîne pour afficher un message personnalisé.

Exercice 3 : Détermination du type de triangle

Écrire un algorithme qui demande les longueurs des trois côtés d'un triangle et affiche si le triangle est :

• rectangle
• isocèle
• isocèle rectangle
• équilatéral
• ou sans propriété particulière

Algorithme Triangles
VAR
  a, b, c : entier
  estRectangle, estIsocele, estEquilateral : booléen
DEBUT
  ecrire (« veuillez entrer l’hypoténuse : »)
  lire (a)
  ecrire (« veuillez entrer les 2 autres cotés : »)
  lire (b, c)
  estRectangle ← (a * a = b * b + c * c)
  estIsocele ← (a = b) OU (a = c) OU (b = c)
  estEquilateral ← (a = b) ET (a = c)
  Si (estEquilateral) Alors
    ecrire (« le triangle est equilatéral ! »)
  Sinon
    Si (estIsocele ET estRectangle) Alors
      ecrire (« le triangle est isocèle rectangle ! »)
    Sinon
      Si (estIsocele) Alors
        ecrire (« le triangle est isocèle ! »)
      Sinon
        Si (estRectangle) Alors
          ecrire (« le triangle est rectangle ! »)
        Sinon
          ecrire (« le triangle n’a pas de propriétés… »)
        FinSi
      FinSi
    FinSi
  FinSi
FIN

Ce programme montre comment combiner plusieurs conditions booléennes pour caractériser un triangle.

Exercice 4 : Recherche du minimum dans une suite de 10 réels

Écrire un algorithme qui lit 10 nombres réels au clavier et affiche le minimum.

Algorithme Minimum
VAR
  boucle : entier
  min, val : réel
DEBUT
  ecrire (« Entrez un réel : »)
  lire (min)
  Pour boucle de 1 à 9 pas de 1, faire
    ecrire (« Entrez un autre réel : »)
    lire (val)
    Si (val < min) Alors
      min = val
    FinSi
  FinPour
  ecrire (« le minimum est : », min)
FIN

Ce programme illustre l'utilisation d'une boucle pour parcourir une série de valeurs et conserver la plus petite.

Exercice 5 : Saisie d'un nombre entre 10 et 20

Écrire un algorithme qui demande un nombre compris entre 10 et 20, et répète la saisie tant que la valeur n'est pas correcte. Si la valeur est supérieure à 20, afficher « Plus petit ! », sinon « Plus grand ! ».

ALGORITHME SaisieCorrecte
VAR
  valeur : entier
DEBUT
  Répéter
    ecrire (« Entrez un nombre entier : »)
    lire (valeur)
    Si (valeur > 20) Alors
      ecrire (« Plus petit ! »)
    FinSi
    Si (valeur < 10) Alors
      ecrire (« Plus grand ! »)
    FinSi
  Jusqu’à ((valeur <= 20) ET (valeur >= 10))
FIN

Ce programme montre l'utilisation d'une boucle de répétition avec des conditions de sortie basées sur la valeur saisie.

Exercice 6 : Table de multiplication

Écrire un algorithme qui demande un nombre et affiche sa table de multiplication de 1 à 20.

Algorithme Multiplication
VAR
  table, i : entier
DEBUT
  ecrire (« Entrez la table de multiplication : »)
  lire (table)
  Pour i de 1 à 20 pas de 1, faire
    ecrire (table, ' x ', i, ' = ', table * i)
  FinPour
FIN

Ce programme permet de générer une table de multiplication complète pour un nombre donné.

Exercice 7 : Lecture d'une suite de réels terminée par zéro

Écrire un algorithme qui lit une suite de nombres réels jusqu'à la saisie de zéro, puis affiche la somme des nombres lus.

Algorithme lire_une_suite
VAR
  a, s : réels
DEBUT
  s ← 0
  Répéter
    ecrire (« entrer un nombre : »)
    lire (a)
    s ← s + a
  Jusqu'à (a = 0)
  ecrire (« la somme des nombres est : », s)
FIN

Ce programme montre comment accumuler une somme tout en contrôlant une condition d'arrêt.

Exercice 8 : Lecture des noms d'athlètes avec arrêt sur deux noms consécutifs identiques

Écrire un algorithme qui lit les noms des participants à un marathon et s'arrête dès que deux noms consécutifs sont identiques. Afficher ensuite le nombre de participants.

Algorithme lire_une_suite
VAR
  Nom1, nom2 : chaine de 30 caractères
  i : entier
DEBUT
  ecrire (« entrer un nom d’athlète : »)
  lire (nom1)
  ecrire (« entrer un nom d’athlète : »)
  lire (nom2)
  i ← 2
  Tantque (nom1 <> nom2)
    nom1 ← nom2
    ecrire (« entrer un nom d’athlète : »)
    lire (nom2)
    i ← i + 1
  Fintantque
  ecrire (« le nombre des participants est : », i)
FIN

Ce programme illustre la gestion de chaînes de caractères et la détection d'une condition d'arrêt basée sur la répétition.

Exercice 9 : Calcul de la moyenne d'âges

Écrire un algorithme qui demande les âges des personnes intéressées par un film, jusqu'à ce que l'utilisateur réponde 'N' à la question "Encore une autre personne (O/N) ?". Afficher la moyenne des âges.

Algorithme moyenne_age
VAR
  i, age, som : entier
  rep : caractère
DEBUT
  i ← 0
  som ← 0
  Répéter
    ecrire (« entrer l’âge de la personne »)
    lire (age)
    i ← i + 1
    som ← som + age
    ecrire (« Encore une autre personne (O/N) ? »)
    lire (rep)
  Jusqu'à (rep = 'N')
  ecrire (« la moyenne d’âges des personnes est : », som / i)
FIN

Ce programme montre la gestion d'une boucle avec une condition d'arrêt basée sur une réponse utilisateur et le calcul d'une moyenne.

Exercice 10 : Calcul de la factorielle

Écrire un algorithme qui calcule la factorielle d'un entier positif N :

N! = 1 × 2 × 3 × … × N

Algorithme factorielle
VAR
  i, N, fact : entier
DEBUT
  fact ← 1
  ecrire (« entrer un entier N : »)
  lire (N)
  pour i = 1 à N faire
    fact ← fact * i
  Finpour
  ecrire (« la factorielle de », N, « est : », fact)
FIN

Ce programme illustre l'utilisation d'une boucle pour le calcul d'un produit successif.

Exercice 11 : Calcul de la moyenne d'une classe

Écrire un algorithme qui calcule la moyenne des notes générales de 30 élèves.

Algorithme moyenne_classe
VAR
  i : entier
  NT, som : réel
CONST
  nb = 30
DEBUT
  som ← 0
  pour i = 1 à nb faire
    ecrire (« entrer la note N° », i, « : »)
    lire (NT)
    som ← som + NT
  Finpour
  ecrire (« la moyenne de la classe est : », som / nb)
FIN

Ce programme montre la gestion d'une boucle fixe et le calcul d'une moyenne.

Exercice 12 : Maximum, minimum et somme d'une liste terminée par un nombre négatif

Écrire un algorithme qui lit une liste de nombres positifs, s'arrête à la saisie d'un nombre négatif, puis affiche le maximum, le minimum et la somme des nombres lus.

Algorithme max_min_somme
VAR
  n, max, min, som : entier
DEBUT
  ecrire (« entrer un nombre »)
  lire (n)
  max ← n
  min ← n
  som ← n
  Tantque n > 0 faire
    ecrire (« entrer un nombre »)
    lire (n)
    Si n < min Alors
      min ← n
    FinSi
    Si n > max Alors
      max ← n
    FinSi
    som ← som + n
  FinTantque
  ecrire (« Le maximum est », max, « le minimum est », min)
FIN

Ce programme illustre la lecture dynamique d'une liste avec conditions d'arrêt et mise à jour des valeurs extrêmes.

Exercice 13 : Valeur absolue d'un réel

Écrire un algorithme qui affiche la valeur absolue d'un nombre réel saisi au clavier :

• |x| = x si x > 0
• |x| = -x si x < 0

Algorithme valeur_absolue
VAR
  X : réel
DEBUT
  ecrire (« entrer un nombre : »)
  lire (X)
  Si X > 0 alors
    ecrire (« la valeur absolue de X = », X)
  Sinon
    ecrire (« la valeur absolue de X = », -X)
  FinSi
FIN

Exercice 14 : Valeur absolue de la différence entre deux réels

Écrire un algorithme qui affiche la valeur absolue de la différence entre deux nombres réels x et y :

• |x - y| = x - y si x > y
• |x - y| = -(x - y) = y - x si x < y

Algorithme valeur_absolue_diff
VAR
  x, y : réel
DEBUT
  ecrire (« entrer x : »)
  lire (x)
  ecrire (« entrer y : »)
  lire (y)
  Si x > y alors
    ecrire (« la valeur absolue de x - y = », x - y)
  Sinon
    ecrire (« la valeur absolue de x - y = », y - x)
  FinSi
FIN

Exercice 15 : Affichage du jour de la semaine

Écrire un algorithme qui affiche le jour de la semaine correspondant à un chiffre entre 1 et 7, selon deux méthodes :

• Utilisation de conditions imbriquées
• Utilisation d'une structure "cas"

Algorithme affichage_jour
VAR
  jour : entier
DEBUT
  ecrire (« entrer un chiffre de 1 à 7 : »)
  lire (jour)
  Si jour = 1 alors
    ecrire (« lundi »)
  Sinon Si jour = 2 alors
    ecrire (« mardi »)
  Sinon Si jour = 3 alors
    ecrire (« mercredi »)
  Sinon Si jour = 4 alors
    ecrire (« jeudi »)
  Sinon Si jour = 5 alors
    ecrire (« vendredi »)
  Sinon Si jour = 6 alors
    ecrire (« samedi »)
  Sinon Si jour = 7 alors
    ecrire (« dimanche »)
  Sinon
    ecrire (« ce n’est pas un jour de semaine »)
  FinSi
FIN

Algorithme affichage_jour_cas
VAR
  jour : entier
DEBUT
  ecrire (« entrer un chiffre de 1 à 7 : »)
  lire (jour)
  Cas jour
    1 : ecrire (« LUNDI »)
    2 : ecrire (« MARDI »)
    3 : ecrire (« MERCREDI »)
    4 : ecrire (« JEUDI »)
    5 : ecrire (« VENDREDI »)
    6 : ecrire (« SAMEDI »)
    7 : ecrire (« DIMANCHE »)
    Sinon : ecrire (« il faut choisir un nombre entre 1 et 7 !!!! »)
  FinCas
FIN

Exercice 16 : Tri de deux nombres

Écrire un algorithme qui lit deux nombres entiers x et y et les affiche dans l'ordre croissant.

Algorithme tri_deux_nombre
VAR
  x, y : réels
DEBUT
  ecrire (« entrer x : »)
  lire (x)
  ecrire (« entrer y : »)
  lire (y)
  Si x > y alors
    ecrire (y, ' ', x)
  Sinon
    ecrire (x, ' ', y)
  FinSi
FIN

Exercice 17 : Test d'année bissextile

Écrire un algorithme qui teste si une année est bissextile. Une année est bissextile si :

• Elle est divisible par 4 et pas par 100, ou
• Elle est divisible par 400.

Algorithme annee_bissextile
VAR
  annee : entier
DEBUT
  ecrire (« entrer l’année : »)
  lire (annee)
  Si ((annee mod 4 = 0 ET annee mod 100 <> 0) OU (annee mod 400 = 0)) alors
    ecrire (« l’année que vous avez entrée est bissextile. »)
  Sinon
    ecrire (« l’année que vous avez entrée n’est pas bissextile. »)
  FinSi
FIN

Résultats attendus

Chaque exercice doit produire un résultat conforme aux spécifications :

• Exercice 1 : affichage correct du tarif selon l'âge.
• Exercice 2 : message adapté selon l'IMC et le sexe.
• Exercice 3 : identification correcte du type de triangle.
• Exercice 4 : affichage du minimum parmi 10 réels.
• Exercice 5 : répétition de la saisie jusqu'à obtention d'un nombre entre 10 et 20.
• Exercice 6 : affichage complet de la table de multiplication jusqu'à 20.
• Exercice 7 : somme correcte des nombres lus avant zéro.
• Exercice 8 : arrêt à deux noms consécutifs identiques et affichage du nombre de participants.
• Exercice 9 : calcul correct de la moyenne d'âges.
• Exercice 10 : calcul exact de la factorielle.
• Exercice 11 : moyenne correcte des notes de 30 élèves.
• Exercice 12 : affichage correct du maximum, minimum et somme.
• Exercice 13 et 14 : calcul correct des valeurs absolues.
• Exercice 15 : affichage correct du jour selon le chiffre saisi.
• Exercice 16 : affichage des deux nombres dans l'ordre croissant.
• Exercice 17 : identification correcte des années bissextiles.

Pièges courants

• Ne pas respecter les conditions d'arrêt dans les boucles (exercices 5, 7, 8, 9, 12).
• Confondre les opérateurs logiques OU/ET et les parenthèses dans les conditions complexes (exercice 1, 3, 17).
• Erreur dans le calcul de l'IMC en oubliant de convertir la taille en mètres si nécessaire (exercice 2).
• Mauvaise gestion des types de variables (entiers vs réels) pouvant fausser les calculs (exercices 4, 7, 12).
• Dans l'exercice 16, inverser l'ordre d'affichage des nombres.
• Dans l'exercice 15, oublier de gérer les cas hors de 1 à 7.
• Dans l'exercice 13, ne pas inverser le signe pour la valeur absolue si x < 0.
• Dans l'exercice 17, ne pas appliquer correctement la règle des années bissextiles (divisibilité par 4, 100, 400).