Examen Corrigé Programmation : Gestion de Stock - Déclarations des variables - Tri - Calcul - Chaîne de caractères - ModulesTest avec Correction
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
--------------------------------------------------------------------------------------------
Article plus récent Article plus ancien
