Leçons
Accéder à Diane

Algorithmes et structures de données

Aucune carte

Exercices sur les algorithmes, matrices et gestion de données pour l'ingénierie informatique.

Algorithmes et Structures de Données : Exercices Pratiques

Ce document détaille des algorithmes pour des tâches courantes en programmation, incluant la manipulation de séries numériques, le traitement de matrices, et la gestion de structures de données complexes comme un parking d'avions.

Calcul de la Somme d'une Série Numérique Spécifique

Cet algorithme calcule la somme d'une série où chaque terme est une répétition du chiffre de son indice.

Description de l'Algorithme

L'utilisateur est invité à saisir un nombre n (entre 1 et 9). Le programme valide cette entrée avant de calculer la somme S. Chaque terme de la série est construit en répétant le chiffre de son indice un nombre égal de fois.

Exemple

Si n = 5, la série est 5 + 55 + 555 + 5555 + 55555, et la somme S = 61725.

Pseudocode

ALGORITHME SommeSerie
  VARIABLES
    n : ENTIER
    i : ENTIER
    terme : ENTIER
    somme : ENTIER
  DEBUT
    somme = 0
    REPETER
      AFFICHER "Entrez un nombre n entre 1 et 9 :"
      LIRE n
    JUSQU'A (n >= 1 ET n <= 9)

    terme = 0
    POUR i ALLANT DE 1 A n FAIRE
      terme = terme * 10 + n   /* Construit le terme (n, nn, nnn, ...) */ 
      somme = somme + terme
    FIN POUR

    AFFICHER "La somme de la série est : ", somme
  FIN

Traitement de Matrices

Cet ensemble d'algorithmes permet de manipuler une matrice d'entiers, en la remplissant, en déterminant sa plage de valeurs et en calculant la somme des nombres pairs par colonne.

Définition de la Matrice

Soit MAT une matrice de taille N × M d'entiers, où N est le nombre de lignes (N ≤ 15) et M est le nombre de colonnes (M ≤ 20).

Fonctionnalités Requises

  1. Remplissage de la matrice : Remplir MAT avec des valeurs strictement positives.

  2. Plage de valeurs : Déterminer et afficher l'étendue des valeurs (minimum et maximum) présentes dans la matrice.

  3. Somme des nombres pairs par colonne : Calculer la somme des nombres pairs pour chaque colonne et stocker ces résultats dans un tableau T.

Pseudocode

ALGORITHME TraitementMatrice
  CONSTANTES
    N_MAX = 15
    M_MAX = 20
  VARIABLES
    MAT : TABLEAU [1..N_MAX, 1..M_MAX] DE ENTIER
    T : TABLEAU [1..M_MAX] DE ENTIER
    N, M : ENTIER
    i, j : ENTIER
    min_val, max_val : ENTIER
    somme_colonne_paire : ENTIER

  DEBUT
    /* 1. Remplissage de la matrice avec des valeurs strictement positives */
    AFFICHER "Entrez le nombre de lignes N (<= ", N_MAX, ") : "
    LIRE N
    AFFICHER "Entrez le nombre de colonnes M (<= ", M_MAX, ") : "
    LIRE M

    POUR i ALLANT DE 1 A N FAIRE
      POUR j ALLANT DE 1 A M FAIRE
        REPETER
          AFFICHER "Entrez la valeur pour MAT[", i, "][", j, "] (doit être > 0) :"
          LIRE MAT[i][j]
        JUSQU'A (MAT[i][j] > 0)
      FIN POUR
    FIN POUR

    /* 2. Déterminer et afficher la plage de valeurs de la matrice */
    min_val = MAT[1][1]
    max_val = MAT[1][1]

    POUR i ALLANT DE 1 A N FAIRE
      POUR j ALLANT DE 1 A M FAIRE
        SI MAT[i][j] < min_val ALORS
          min_val = MAT[i][j]
        FIN SI
        SI MAT[i][j] > max_val ALORS
          max_val = MAT[i][j]
        FIN SI
      FIN POUR
    FIN POUR
    AFFICHER "La valeur minimale de la matrice est : ", min_val
    AFFICHER "La valeur maximale de la matrice est : ", max_val

    /* 3. Calculer et afficher la somme des nombres pairs dans chaque colonne */
    POUR j ALLANT DE 1 A M FAIRE
      somme_colonne_paire = 0
      POUR i ALLANT DE 1 A N FAIRE
        SI MAT[i][j] MOD 2 = 0 ALORS
          somme_colonne_paire = somme_colonne_paire + MAT[i][j]
        FIN SI
      FIN POUR
      T[j] = somme_colonne_paire
      AFFICHER "Somme des nombres pairs de la colonne ", j, " : ", T[j]
    FIN POUR
  FIN

Gestion de Parking d'Avions

Cette section décrit la structure de données et les opérations pour gérer un parking d'avions dans un aéroport.

Définition d'un Avions

Chaque avion est caractérisé par :

  • Numéro d'immatriculation : Une chaîne de caractères unique.
  • Désignation : Contient le Nom (chaîne) et la Série (entier).
  • Capacité : Nombre de passagers (entier).
  • Nombre de vols mensuels : Un tableau de 12 entiers (de Janvier à Décembre).
  • Catégorie : Chaîne de caractères ("national" ou "international").

Questions et Solutions

1. Structure de Données du Parking

Le parking peut contenir un maximum de 30 avions. Nous utiliserons un tableau d'enregistrements (structures) pour représenter le parking.

TYPE designation_t EST ENREGISTREMENT
  nom : CHAINE
  serie : ENTIER
FIN ENREGISTREMENT

TYPE avion_t EST ENREGISTREMENT
  immatriculation : CHAINE
  designation : designation_t
  capacite : ENTIER
  vols_mensuels : TABLEAU [1..12] DE ENTIER
  categorie : CHAINE  /* "national" ou "international" */ 
FIN ENREGISTREMENT

CONSTANTE MAX_AVIONS = 30

TYPE parking_t EST ENREGISTREMENT
  avions : TABLEAU [1..MAX_AVIONS] DE avion_t
  nb_avions : ENTIER  /* Nombre actuel d'avions dans le parking */ 
FIN ENREGISTREMENT
2. Ajout de 7 Avions

Ajouter 7 avions au parking, en supposant qu'il est initialement vide. Les données des avions seraient soit saisies par l'utilisateur, soit pré-définies.

PROCEDURE AjouterAvion(VAR parking : parking_t, avion_a_ajouter : avion_t)
  DEBUT
    SI parking.nb_avions < MAX_AVIONS ALORS
      parking.nb_avions = parking.nb_avions + 1
      parking.avions[parking.nb_avions] = avion_a_ajouter
      AFFICHER "Avion ", avion_a_ajouter.immatriculation, " ajouté."
    SINON
      AFFICHER "Le parking est plein, impossible d'ajouter l'avion."
    FIN SI
  FIN

ALGORITHME InitialiserParking
  VARIABLES
    mon_parking : parking_t
    nouvel_avion : avion_t
    compteur : ENTIER
  DEBUT
    mon_parking.nb_avions = 0  /* Parking initialement vide */ 

    /* Exemple d'ajout de 7 avions (les données sont fictives pour l'exemple) */
    POUR compteur ALLANT DE 1 A 7 FAIRE
       /* Saisie ou attribution des valeurs pour nouvel_avion */ 
      nouvel_avion.immatriculation = "IMMAT" & compteur
      nouvel_avion.designation.nom = "Airbus"
      nouvel_avion.designation.serie = 320 + compteur
      nouvel_avion.capacite = 150 + compteur * 10
      POUR i ALLANT DE 1 A 12 FAIRE
        nouvel_avion.vols_mensuels[i] = 10 + i * 2
      FIN POUR
      SI compteur MOD 2 = 0 ALORS
        nouvel_avion.categorie = "national"
      SINON
        nouvel_avion.categorie = "international"
      FIN SI
      AjouterAvion(mon_parking, nouvel_avion)
    FIN POUR
  FIN
3. Affichage des Avions Nationaux
PROCEDURE AfficherAvionsNationaux(parking : parking_t)
  VARIABLES
    i : ENTIER
  DEBUT
    AFFICHER "--- Avions Nationaux ---"
    POUR i ALLANT DE 1 A parking.nb_avions FAIRE
      SI parking.avions[i].categorie = "national" ALORS
        AFFICHER "Immatriculation : ", parking.avions[i].immatriculation
        AFFICHER "  Nom : ", parking.avions[i].designation.nom
        AFFICHER "  Série : ", parking.avions[i].designation.serie
        AFFICHER "  Capacité : ", parking.avions[i].capacite
      FIN SI
    FIN POUR
    AFFICHER "------------------------"
  FIN
4. Suppression d'un Avions par Numéro d'Immatriculation
PROCEDURE SupprimerAvion(VAR parking : parking_t, immat_a_supprimer : CHAINE)
  VARIABLES
    i, j : ENTIER
    trouve : BOOLEEN
  DEBUT
    trouve = FAUX
    i = 1
    TANT QUE i <= parking.nb_avions ET NON trouve FAIRE
      SI parking.avions[i].immatriculation = immat_a_supprimer ALORS
        trouve = VRAI
         /* Décaler les éléments pour combler le "trou" */ 
        POUR j ALLANT DE i A parking.nb_avions - 1 FAIRE
          parking.avions[j] = parking.avions[j+1]
        FIN POUR
        parking.nb_avions = parking.nb_avions - 1
        AFFICHER "Avion ", immat_a_supprimer, " supprimé du parking."
      FIN SI
      i = i + 1
    FIN TANT QUE

    SI NON trouve ALORS
      AFFICHER "Avion ", immat_a_supprimer, " non trouvé dans le parking."
    FIN SI
  FIN
5. Calcul du Nombre Total Annuel de Vols pour un Avions Donné
FONCTION CalculerVolsAnnuels(avion : avion_t) : ENTIER
  VARIABLES
    total_vols : ENTIER
    i : ENTIER
  DEBUT
    total_vols = 0
    POUR i ALLANT DE 1 A 12 FAIRE
      total_vols = total_vols + avion.vols_mensuels[i]
    FIN POUR
    RETOURNER total_vols
  FIN

ALGORITHME AfficherVolsAnnuelsAvionSpecific
  VARIABLES
    mon_parking : parking_t  /* Doit être initialisé et rempli */ 
    immat_recherchee : CHAINE
    i : ENTIER
    trouve : BOOLEEN
  DEBUT
    AFFICHER "Entrez l'immatriculation de l'avion dont vous voulez les vols annuels : "
    LIRE immat_recherchee

    trouve = FAUX
    POUR i ALLANT DE 1 A mon_parking.nb_avions FAIRE
      SI mon_parking.avions[i].immatriculation = immat_recherchee ALORS
        AFFICHER "Nombre total annuel de vols pour l'avion ", immat_recherchee, " : ", CalculerVolsAnnuels(mon_parking.avions[i])
        trouve = VRAI
      FIN SI
    FIN POUR

    SI NON trouve ALORS
      AFFICHER "Avion ", immat_recherchee, " non trouvé."
    FIN SI
  FIN
6. Calcul du Nombre Total de Vols pour Tous les Avions
FONCTION CalculerTotalVolsParking(parking : parking_t) : ENTIER
  VARIABLES
    grand_total_vols : ENTIER
    i : ENTIER
  DEBUT
    grand_total_vols = 0
    POUR i ALLANT DE 1 A parking.nb_avions FAIRE
      grand_total_vols = grand_total_vols + CalculerVolsAnnuels(parking.avions[i])
    FIN POUR
    RETOURNER grand_total_vols
  FIN

ALGORITHME AfficherTotalVolsGlobal
  VARIABLES
    mon_parking : parking_t  /* Doit être initialisé et rempli */ 
  DEBUT
    AFFICHER "Nombre total de vols pour tous les avions du parking : ", CalculerTotalVolsParking(mon_parking)
  FIN

Réflexions et Points Clés

  • Pour la série numérique, la clé est de construire chaque terme de manière itérative en multipliant par 10 et en ajoutant le chiffre n.
  • La gestion de matrices implique des boucles imbriquées pour parcourir les lignes et les colonnes.
  • Pour le parking d'avions, l'utilisation de structures ou d'enregistrements est fondamentale pour regrouper les données hétérogènes des avions.
  • La suppression dans un tableau nécessite de décaler les éléments après l'élément supprimé pour maintenir la contiguïté et la validité de l'indice nb_avions.
  • Des fonctions et procédures modulaires sont utilisées pour une meilleure organisation et réutilisabilité du code.

Lancer un quiz

Teste tes connaissances avec des questions interactives