Examen Intra

Question 1 (15 points) Un inventaire de produits est géré à l'aide d'un fichier binaire à accès
direct. Vous devez écrire le code Ada de la procédure Détruire_produit afin
que le champ detruit du produit à retirer soit mis à la valeur true et que
l'enregistrement soit réécrit dans le fichier. Le numéro du produit
correspond directement au numéro de l'enregistrement de direct_io. Le
fichier est déjà ouvert et le lien logique est passé en paramètre à la
procédure. Le paramètre Succes retourne la valeur true si le traitement
s'est déroulé normalement, dans le cas contraire la valeur false est
retournée. Vous devez vous assurer que le numéro du produit reçu est
supérieur à 1 ou inférieur ou égal au numéro du dernier enregistrement
placé dans le fichier. L'accès aux produits doit se faire exclusivement en
mode accès direct et non séquentiellement. Soit les déclarations suivantes :
Type T_Produit IS RECORD
Description : string(1..30);
Prix : Float;
Quantite : Natural;
Detruit : Boolean;
END RECORD; PACKAGE ES_Produit IS NEW Ada.Direct_IO(T_Produit); PROCEDURE Detruire_Produit (Fichier : IN OUT ES_Produit.File_Type;
Numero : IN Natural;
Succes : OUT Boolean) IS Question 2 (15 points) Un palindrome est une suite de caractères qui se lit d'une façon
identique tant dans un sens que dans l'autre. À titre d'exemple, les mots
radar et laval sont des palindromes. À l'aide des services sur les types
Pile et File, vous devez écrire une fonction Ada qui déterminera si la
chaîne reçue en paramètre est un palindrome ou non. Vous devez, dans la
conception de votre solution, utiliser les structures suivantes : une pile
et une file. Dès le début, vous devez transférer chacun des caractères de
la chaîne dans la pile et dans la file. Par la suite, vous devez manipuler
le contenu de ces structures pour déterminer si la chaîne est un
palindrome. Si la chaîne reçue est bien un palindrome, la fonction
retournera la valeur true, sinon la valeur false sera retournée. Vous devez
utiliser les services sur pile et file en ne faisant aucune référence à
l'implantation de ces types. La dernière page de l'examen est un aide
mémoire sur la syntaxe des services sur ces types.
FUNCTION est_palindrome (Chaine : IN String) RETURN Boolean IS LaPile : Pile;
LaFile : File;
Question 3 (15 points) Il s'agit de faire l'implantation d'un programme faisant la gestion de
chaînes de caractères. Il sera possible grâce à ce programme de saisir des
chaînes, de les afficher en sens inverse, de les afficher verticalement et
de quitter le programme. L'option saisie de chaînes permet à l'utilisateur
d'entrer 10 chaînes de caractères de son choix. Le nombre de caractères
maximum de la chaîne est 24. Si l'utilisateur tente d'entrer une chaîne
plus longue, vous l'avisez et lui redemander de saisir une chaîne de
nouveau. L'utilisateur peut entrer une chaîne vide s'il le désire. S'il y
avait des chaînes entrées préalablement, elles seront écrasées par les
nouvelles. L'option afficher en sens inverse affiche les chaînes entrées par
l'utilisateur à l'envers. Par exemple, si l'utilisateur a entré "omoplate",
le programme affichera "etalpomo". Finalement, l'option afficher
verticalement affiche les chaînes entrées par l'utilisateur, inversées de
haut en bas à l'écran. Ce qui signifie que la dernière lettre du mot est
affichée sur une ligne et l'avant-dernière sur la ligne suivante, etc.
Cela pour chaque caractère et pour chaque chaîne Vous devez compléter l'écriture complète du programme principal et
appliquer la technique des échafaudages pour l'écriture des sous-programmes
du premier niveau (n'écrivez pas le programme en entier) seulement en
utilisant les déclarations suivantes : with Ada.Text_Io;
use Ada.Text_Io; procedure Gestion_Phrase is --constantes
Max_Car : constant := 24;
Max_Chaine : constant := 10; -- Instanciation des paquetages generiques
package Es_Entiers is new Integer_Io(Integer); --types
--représente une chaîne et sa longueur
type T_Chaine is
record
Chaine : String(1..max_car);
Lng : Natural;
end record; --contiendra le tableau des chaînes
type T_Tab_Chaine is array(1..max_chaine) of T_Chaine; ...DÉFINITION DE VOS SOUS-PROGRAMMES
-----------------
--variables
-----------------
Tab_Chaine : T_Tab_Chaine; Begin
--programme principal à ecrire End Gestion_Phrase;
Question 4 (15 points) Nous désirons conserver un certain nombre d'informations sur des
étudiants. Ces informations seront conservées dans un tableau ordonné
défini dans un module externe générique. Soit la partie spécification du module externe : generic
type T_Element is private;
type T_Cle is private;
with function PlusPetit(Element1, Element2 : T_Element) return Boolean;
with function Egale(Element1, Element2 : T_Element) return Boolean;
Max_Element : Integer := 500; package Tableau_Ordonne is
procedure Chercher(Cle : T_Cle; Element : out T_Element; Succes : out
Boolean);
procedure Ajouter (Element : T_Element);
procedure Enlever (Cle : T_Cle);
end;
Il s'agit d'écrire les définitions manquantes dans le programme client Q4
afin d'instancier le paquetage TABLEAU_ORDONNE pour 500 étudiants à partir
des définitions ci-bas. Les informations sur les étudiants sont le code
permanent, le nom, le prénom et l'adresse. Le champ clé pour toutes les
opérations est le code permanent.
WITH Tableau_Ordonne; PROCEDURE Q4 IS TYPE T_Etud IS RECORD
Nom : String(1..60);
Prenom : String(1..45);
Adresse : String(1..80);
Code : String(1..12);
END RECORD;
Question 5 (15 points) Soit le code suivant : with Ada.Text_Io;
use Ada.Text_Io; procedure Q5 is
package Es_Entiers is new Integer_Io(Integer); type T_Tab_Entier is array(1..7) of Integer; type T_Ptr_Tab is access T_Tab_Entier;
type T_Ptr_Ent is access Integer;
A : T_Ptr_Tab;
B : T_Ptr_Tab;
C : T_Ptr_Ent:=new Integer'(1);
Tab : T_Tab_Entier;
begin
A:=new T_Tab_Entier; B:=A; for I in A.all'range loop
A.all(I) := C.all * 2;
Tab(I) := A.all(I);
C.all := A.all(I) + 1;
end loop; for I in A.all'range loop
Es_Entiers.Put(Tab(I));
B.all(I) := 0;
end loop;
New_line;
for I in 1..7 loop
Es_Entiers.Put(A.all(I));
end loop;
New_line;
Es_Entiers.Put(C.all); end; Vous devez exécuter le code de la page précédente et indiquer quelles
seront les valeurs affichées par le programme.
Question 6 (10 points) Voici une procédure d'insertion d'éléments dans une liste simplement
chaînée ne comportant pas de noeud bidon ni en tête de liste, ni en fin de
liste. La procédure reçoit en paramètre l'élément à insérer, la liste (voir
la déclaration de T_Liste) et la valeur Avant ou Après (type T_Place) afin
d'indiquer à la procédure si on fait une insertion avant la position (pos)
courante ou après celle-ci. Cependant, cette procédure comporte 2 erreurs
de fonctionnement dans son bloc d'instructions. Vous devez donc trouver ces
erreurs en question et donner le code de remplacement des lignes fautives.
Vous ne devez pas réécrire tout le code de la procédure, mais identifiez
précisément les 2 erreurs et les correctifs à apporter. type T_Place is (Avant,Apres);
type T_Noeud;
type T_Position is access T_Noeud;
--le noeud contient un élément et un pointeur sur le suivant
type T_Noeud is record
Element : T_Element;
Suivant : T_Position;
end record;
--Un enregistrement qui contient les infos sur la liste
type T_Liste is record
Nbr : Natural :=0; --nombre d'éléments dans la
liste
Tete : T_Position; --pointe sur le début de la
liste
Fin : T_Position; --pointe sur la fin de la
liste
Pos : T_Position; --la position courante dans
la liste
end record; procedure Inserer(Element : T_Element;
L : in out T_Liste;
Place : T_Place) is Tmp : T_Position; begin --Inserer Tmp := new T_Noeud;
if L.Nbr = 0 then
Tmp.Element :=Element;
L.Tete := Tmp;
L.Pos := Tmp;
elsif Place = Avant then
Tmp.Element := L.Pos.Element;
Tmp.Suivant := L.Pos.Suivant;
L.Pos.Element := Element; if L.Pos = L.Fin then
L.Fin := Tmp;
end if; else
Tmp.Element := Element;
Tmp.Suivant := L.Pos.Suivant;
L.Pos.Suivant := Tmp;
if L.Pos = L.Fin then
L.Fin := Tmp;
end if;
L.Pos := Tmp; end if;
L.Nbr := L.Nbr + 1;
exception
when Storage_Error => raise Erreur_Memoire_Pleine;
end Inserer;
Question 7 (15 points) À partir des déclarations suivantes, vous devez écrire les services empiler
et dépiler. La structure de la pile est implantée par l'entremise d'une
liste simplement chaînée. La pile est vide lorsque Tete et Sommet = null.
Il est à noter que dans cette implantation le concepteur a fait les choix
suivants: l'ajout d'élements et le retrait se font en fin de liste. Du
point de vue logique, la pile est conforme aux spécifications et au
comportement attendu. With Unchecked_Deallocation ;
Type Tnoeud;
Type Ptr_Noeud is access Tnoeud;
Type Tnoeud is record
Element : Type_Element;
Suivant : Ptr_Noeud;
End record; Type Pile is record
Tete : Ptr_N?ud ; -- pointeur vers le premier
noeud de la liste
Sommet : Ptr_N?ud ;