Pages - Menu

Pages

Examen Corrigé Programmation : Gestion de Stock - Déclarations des variables - Tri - Calcul - Chaîne de caractères - ModulesTest avec Correction

Énonce :

Soit une société qui dispose d’un stock de 10 produits différents. Chaque produit est identifié par un numéro, possède un libellé, a un prix (en EUR) et est disponible en une certaine quantité.
     
Réalisez une application qui :

-  permet au magasinier de saisir les informations sur le stock à la fin de l’année;
-  calcule, pour chaque produit, la valeur en stock du produit;
-  affiche la valeur totale du stock de la société;
-  trie les produits dans l’ordre alphabétique croissant des libellés (en utilisant un tri par sélection);
-  affiche toutes les informations sur les produits dans l’ordre précité (1 produit par ligne);
-  trie ensuite les produits dans l’ordre décroissant de leur valeur en stock (en utilisant un tri par insertion);
-  affiche toutes les informations sur les produits dans l’ordre précité (1 produit par ligne).

Complément d’information!: l’application effectue ces opérations de manière purement séquentielle, il ne s’agit donc pas d’implémenter un système de menus.

Décomposez l’application en trois modules :

  • une unité contenant i)!les déclarations des types nécessaires pour représenter les produits et les tableaux à trier ainsi que ii)!la procédure de saisie, la fonction de calcul des valeurs de stock, les deux procédures de tri et la procédure d’affichage des produits;
  • une unité contenant la fonction de vérification de l’ordre alphabétique croissant entre deux chaînes de caractères et toute autre sous-routine que vous jugez utile d’implémenter dans ce contexte; 
  • le programme principal contenant le traitement décrit ci-dessus.

                  
----------------------------------------------------------------------------------------------------
Correction
----------------------------------------------------------------------------------------------------
      
Solution modèle
             
Contenu du fichier ALPHA.PAS
      
(* UNIT ALPHA avec sa sous-routine *)
unit ALPHA;
    
interface
  (* Entete de la sous-routine a implementer *)
  function INFERIEUR(CHAINE1, CHAINE2: string): boolean;
        
implementation
            
  (* Comparaison alphabetique de deux chaines de caracteres        *)
  (* Les deux chaines a comparer sont passees par valeur           *)
  (* Les deux chaines sont transformees en chaines majuscules      *)
  (* Si la premiere precede la deuxieme dans l'ordre alphabetique, *)
  (* le resultat est 'true', sinon, il est 'false'                 *)
  function INFERIEUR(CHAINE1, CHAINE2: string): boolean;
    var I, DIFF: integer;
  begin
    DIFF := ord('A') - ord('a');
    for I := 1 to length(CHAINE1) do
      if ('a' <= CHAINE1[I]) AND (CHAINE1[I] <= 'z') then
        CHAINE1[I] := chr(ord(CHAINE1[I]) + DIFF);
    for I := 1 to length(CHAINE2) do
      if ('a' <= CHAINE2[I]) AND (CHAINE2[I] <= 'z') then
        CHAINE2[I] := chr(ord(CHAINE2[I]) + DIFF);
    INFERIEUR := CHAINE1 <= CHAINE2;
  end;

(* La UNIT ALPHA ne necessite aucune initialisation *)
begin
end.
      
Contenu du fichier INVENT.PAS
           
(* UNIT INVENT avec ses types et ses sous-routines *)
unit INVENT;
   
interface
  (* La UNIT INVENT utilise la UNIT ALPHA *)
  uses ALPHA;
      
  (* Nombre de produits dans un stock *)
       
  const DIM_TSTOCK = 10;
          
  (* Type d'un produit *)
  type TPRODUIT = record
    NUMERO: integer;
    LIBELLE: string;
    PRIX: real;
    QUANTITE: integer;
    VALEUR: real
  end;
      
  (* Type d'un stock *)
  type TSTOCK = array[0..DIM_TSTOCK] of TPRODUIT;
          
  (* Entetes des sous-routines a implementer *)
  procedure SAISIE_STOCK(var STOCK: TSTOCK);
  function CALCUL_VALEUR_STOCK(var STOCK: TSTOCK): real;
  procedure AFFICHAGE_STOCK(STOCK: TSTOCK);
  procedure TRI_LIB_STOCK(var STOCK: TSTOCK);
  procedure TRI_VAL_STOCK(var STOCK: TSTOCK);

implementation
        
  (* Saisie des informations sur les produits d'un stock *)
  (* Le stock est un argument passe par reference        *)
  (* Le champ valeur n'est pas saisi car il est calcule  *)
  procedure SAISIE_STOCK(var STOCK: TSTOCK);
    var I: integer;
  begin
    writeln('Saisie du stock:');
    for I := 1 to DIM_TSTOCK do
    begin
      writeln('STOCK[', I, ']');
      write('  NUMERO: ');
      readln(STOCK[I].NUMERO);
      write('  LIBELLE: ');
      readln(STOCK[I].LIBELLE);
      write('  PRIX: ');
      readln(STOCK[I].PRIX);
      write('  QUANTITE: ');
      readln(STOCK[I].QUANTITE)
    end
  end;

  (* Calcul de la valeur des produits en stock                         *)
  (* Le stock est un argument passe par reference                      *)
  (* Le champ VALEUR est calcule en fonction de la QUANTITE et du PRIX *)
  (* La fonction retourne la somme des champs VALEUR                   *)
  function CALCUL_VALEUR_STOCK(var STOCK: TSTOCK): real;
    var I: integer;
        VALEUR_STOCK: real;
  begin
    VALEUR_STOCK := 0;
    for I := 1 to DIM_TSTOCK do
    begin
      STOCK[I].VALEUR := STOCK[I].QUANTITE * STOCK[I].PRIX;
      VALEUR_STOCK := VALEUR_STOCK + STOCK[I].VALEUR
    end;
    CALCUL_VALEUR_STOCK := VALEUR_STOCK
  end;
        
  (* Affichage des informations sur les produits en stock *)
  (* Le stock est un argument passe par valeur            *)
  procedure AFFICHAGE_STOCK(STOCK: TSTOCK);
    var I: integer;
  begin
    writeln('Affichage du stock:');
    for I := 1 to DIM_TSTOCK do
    begin
      write('  STOCK[', I, '] > ');
      write('Numero: ', STOCK[I].NUMERO, ', ');
      write('Libelle: ', STOCK[I].LIBELLE, ', ');
      write('Prix: ', STOCK[I].PRIX:6:2, ', ');
      write('Quantite: ', STOCK[I].QUANTITE, ', ');
      write('Valeur: ', STOCK[I].VALEUR:6:2);
      writeln
    end
  end;

  (* Tri du stock par libelles croissant alphabetiquement *)
  (* Le stock est un argument passe par reference         *)
  (* On compare des libelles mais on permute des produits *)
  procedure TRI_LIB_STOCK(var STOCK: TSTOCK);
    var I, J, MIN: integer;
        TEMP: TPRODUIT;
  begin
    for I := 1 to DIM_TSTOCK-1 do
    begin
      MIN := I;
      for J := I + 1 to DIM_TSTOCK do
        if INFERIEUR(STOCK[J].LIBELLE, STOCK[MIN].LIBELLE) then MIN := J;
      TEMP := STOCK[MIN];
      STOCK[MIN] := STOCK[I];
      STOCK[I] := TEMP
    end
  end;

  (* Tri du stock par valeurs d'inventaire decroissantes *)
  (* Le stock est un argument passe par reference        *)
  (* On compare des valeurs mais on decale des produits  *)
  procedure TRI_VAL_STOCK(var STOCK: TSTOCK);
    var I, J: integer;
        TEMP: TPRODUIT;
  begin
    for I := 2 to DIM_TSTOCK do
    begin
      STOCK[0] := STOCK[I];
      J := I;
      TEMP := STOCK[I];
      while STOCK[J-1].VALEUR < TEMP.VALEUR do
      begin
        STOCK[J] := STOCK[J-1];
        J := J - 1
      end;
      STOCK[J] := TEMP
    end
  end;
      
(* La UNIT INVENT ne necessite aucune initialisation *)
begin
end.
       
Contenu du fichier FANN.PAS
      
program FANN;             (* Programme principal                           *)
    
  uses INVENT;            (* Le programme utilise la UNIT STOCK            *)
       
  var STOCK: TSTOCK;      (* Le stock a inventorier                        *)
      
begin
  SAISIE_STOCK(STOCK);    (* Saisie des informations sur le stock          *)
  writeln('Valeur totale du stock: ', CALCUL_VALEUR_STOCK(STOCK):6:2);
                          (* Calcul et affichage de la valeur du stock     *)
  TRI_LIB_STOCK(STOCK);   (* Tri alphabetique croissant selon les libelles *)
  AFFICHAGE_STOCK(STOCK); (* Affichage des informations                    *)
  TRI_VAL_STOCK(STOCK);   (* Tri decroissant selon les valeurs en stock    *)
  AFFICHAGE_STOCK(STOCK); (* Affichage des informations                    *)
end.
     
--------------------------------------------------------------------------------------------
Répartition des points

1.  Déclaration du type nécessaire pour représenter les produits                9 P
2.  Déclaration du type nécessaire pour représenter le tableau à trier          4 P
3.  Choix des types les plus appropriés pour les variables                          2 P
4.  Choix des mécanismes de passage des arguments les plus appropriés   2 P
5.  Comparaison alphabétique                                                                   4 P
6.  Saisie                                                                                                  4 P
7.  Calcul des valeurs de stock                                                                 3 P
8.  Tri par sélection                                                                                  9 P
9.  Tri par bulles                                                                                      9 P
10. Affichage                                                                                          3 P
11. Programme principal                                                                         2 P
12. Décomposition en modules                                                               9 P
--------------------------------------------------------------------------------------------
                

Aucun commentaire:

Enregistrer un commentaire