Examen Final - Automne 98 - 3.307 Page 1 sur 7 QUESTION 1 (3

Examen Final - Automne 98 - 3.307
QUESTION 1 (3 Points)
Ces déclarations sont utilisées pour les sous-questions 1.1 à 1.3.
const int LONGMAX = 51;
const int CDMAX
= 100;
typedef char type_string[LONGMAX];
enum type_classement {POURRI,PASSABLE,BON,TRES_BON,EXCELLENT};
struct type_CD
{
type_string Groupe;
type_string Titre;
int Nb_Chanson;
type_classement Classement;
};
type_CD Un_CD;
type_CD Mes_CD[CDMAX];
type_CD *Ptr_CD;
int Nb_CD, i;
1.1 Écrire dans votre cahier la lettre de chaque instruction syntaxiquement correcte.
Note: Les instructions sont indépendantes les unes des autres.
a) type_CD Autre_CD = {"Iron Maiden","The Number of the Beast",8,BON};
b) Ptr_CD.Nb_Chanson = Mes_CD[10].Nb_Chanson;
c) Mes_CD[6].Titre = Un_CD.Titre;
d) Ptr_CD = new type_CD;
1.2 Supposons que le tableau Mes_CD possède 30 enregistrements contenant de bonnes
valeurs. Ces 30 enregistrements sont classés en ordre croissant, dans le tableau, selon
leur champ Classement. Quel(s) bloc(s) d'instructions permet(tent) d'afficher les
groupes et les titres des CD dont le champ Classement est BON ?
Écrire dans votre cahier la ou les lettres correspondantes.
// bloc a)
for (Ptr_CD = &Mes_CD[BON]; Ptr_CD < &Mes_CD[TRES_BON]; Ptr_CD++)
cout << Ptr_CD->Groupe << "
" << Ptr_CD->Titre << endl;
(Suite à la page suivante)
Page 1 sur 7
Examen Final - Automne 98 - 3.307
i = 0;
// bloc b)
while (Mes_CD[i].Classement < BON) i++;
while (Mes_CD[i].Classement < TRES_BON)
cout << Mes_CD[i].Groupe << "
" << Mes_CD[i].Titre << endl;
Nb_CD = 30;
// bloc c)
for (i = 0; i < Nb_CD; i++)
switch (Mes_CD[i].Classement)
{
case POURRI :
case PASSABLE :
case BON : cout << Mes_CD[i].Groupe << "
"
<< Mes_CD[i].Titre << endl;
break;
case TRES_BON :
case EXCELLENT : break;
}
//bloc d)
for (i = 0; Mes_CD[i].Classement < TRES_BON; i++)
if (Mes_CD[i].Classement == BON)
cout << Mes_CD[i].Groupe << "
"
<< Mes_CD[i].Titre << endl;
1.3 Quelle instruction est équivalente à l'instruction suivante,
Mes_CD[3].Nb_Chanson = 14;
qui inscrit à la quatrième position de la variable Mes_CD, la valeur 14 dans le champ
NbChanson ?
Écrire dans votre cahier la lettre de votre réponse.
a)
b)
c)
d)
e)
Ptr_CD[4].Nb_Chanson = 14;
Mes_CD[TRES_BON].Nb_Chanson = 14;
Mes_CD[3].(Titre+1)= 14;
Ptr_CD->Nb_Chanson = 14;
Mes_CD[3]->Nb_Chanson = 14;
1.4 Que se passe-t-il lorsque nous faisons l'instruction delete Tete sur une liste
circulaire à liens doubles avec élément factice en mémoire ? Tete pointe sur
l'élément factice.
Écrire dans votre cahier la lettre de votre réponse.
a) Le pointeur Tete ne peut plus être utilisé.
b) L'espace mémoire de la structure contenant l'élément factice est libéré ou
disponible.
c) L'espace mémoire de la structure factice et de toutes les autres est libéré ou
disponible.
d) L'espace mémoire de la structure factice et de toutes les autres est libéré ou
disponible en plus du pointeur Tete.
e) L'espace mémoire de la structure située après l'élément factice est libéré ou
disponible.
Page 2 sur 7
devenu
devenu
devenu
devenu
Examen Final - Automne 98 - 3.307
QUESTION 2 (3 Points)
Quel sera l'affichage obtenu lors de l'exécution du programme ci-dessous ?
#include <iostream.h>
#include <fstream.h>
struct type_mesure
{
double Distance;
double Matiere;
};
void main()
{
type_mesure TabMesure[5] = {{5,12.1}, {10,102.2},{15,76.3},
{20,28.4}, {25, 15.5}};
fstream FicBin;
type_mesure Mesure;
int i;
FicBin.open("Mesure.bin",ios::out|ios::binary);
FicBin.write((char*) TabMesure, 5*sizeof(type_mesure));
FicBin.close();
FicBin.open("Mesure.bin",ios::in|ios::out|ios::binary);
FicBin.read((char*) TabMesure, 5*sizeof(type_mesure));
Mesure = TabMesure[2];
FicBin.seekp(2*sizeof(type_mesure), ios::beg);
FicBin.write((char *)& TabMesure[4], sizeof(type_mesure));
FicBin.seekp(4*sizeof(type_mesure), ios::beg);
FicBin.write((char*)& Mesure, sizeof(type_mesure));
FicBin.seekg(0, ios::beg);
FicBin.read((char*) TabMesure, 5*sizeof(type_mesure));
for (i=0;i<5;i++)
cout << TabMesure[i].Distance << ' ' << TabMesure[i].Matiere
<< endl;
FicBin.close();
}
Page 3 sur 7
Examen Final - Automne 98 - 3.307
QUESTION 3 (4.5 Points)
Le cube Rubik est un petit cube 3x3x3 avec des carreaux de couleurs. Le but du jeu est, à
partir d'un cube où les carreaux de couleurs sont mélangés, d'obtenir sur chaque surface
des carreaux de même couleur. Un fichier binaire contient la solution du cube Rubik pour
une configuration initiale des carreaux mélangés. Chacune des données du fichier binaire
est une valeur de type type_coup déclaré comme suit:
enum type_face { Haut , Bas, Gauche, Droite, Devant, Derriere};
struct type_coup
{
type_face Face;
int
Sens;
// la face à tourner
// peut prendre deux valeurs:
//
-1 rotation dans le sens anti-horaire
//
1 rotation dans le sens horaire
};
Pour appliquer cette solution il faut être capable de la lire. Ainsi, vous devez prendre
l’information dans le fichier binaire et inscrire cette information dans un fichier texte
pour être en mesure de l’imprimer.
Après la lecture du fichier binaire, le fichier texte aura la forme suivante:
Haut anti-horaire
Droite horaire
Devant anti-horaire
•••
Vous n’avez pas à écrire un nouveau programme pour cette question mais compléter une
portion du programme fourni ci-dessous.
PROGRAMME À COMPLÉTER :
#include <iostream.h>
#include <fstream.h>
enum type_face { Haut , Bas, Gauche, Droite, Devant, Derriere};
struct type_coup
{
type_face Face;
int Sens;
};
(Suite à la page suivante)
Page 4 sur 7
Examen Final - Automne 98 - 3.307
/**************************************************************/
/* Description: TraduireFace()
*/
/*
Réalise la conversion d'une valeur de
*/
/*
l'énumération type_face en chaîne de car.
*/
/* Paramètres: Face (IN) une valeur de l'énum. de type_face */
/*
MotFace (OUT) la chaîne de caractères
*/
/*
correspondante à Face
*/
/* Valeur de retour : Aucune
*/
/**************************************************************/
void TraduireFace(type_face Face, char MotFace[])
{
switch (Face)
{
case Haut
: strcpy(MotFace,"Haut");
break;
case Bas
: strcpy(MotFace,"Bas");
break;
case Gauche
: strcpy(MotFace,"Gauche");
break;
case Droite
: strcpy(MotFace,"Droite");
break;
case Devant
: strcpy(MotFace,"Devant");
break;
case Derriere : strcpy(MotFace,"Derriere");
};
}
void main (void)
{
char MotFace[10]; //Pour la traduction de l'énumération en
//chaîne de caractères avec TraduireFace()
ifstream Binaire;// le fichier binaire à lire
ofstream Texte;
// le fichier texte où sera écrite la solution
… AJOUTER LES AUTRES DÉCLARATIONS NÉCESSAIRES
//ouverture du fichier binaire contenant la réponse
Binaire.open("solution.bin",ios::binary);
// ouverture du fichier texte dans lequel est inscrit la réponse
Texte.open("solution.txt");
… INSCRIRE LES INSTRUCTIONS QUI LISENT LE FICHIER BINAIRE
… ET ECRIVENT ENSUITE LA SOLUTION DANS LE FICHIER
… SOLUTION.TXT
Binaire.close();
Texte.close();
}
Page 5 sur 7
Examen Final - Automne 98 - 3.307
QUESTION 4 (4.5 Points)
Une liste linéaire à liens simples contient l'inventaire d'un magasin. Chaque élément de la
liste représente un article vendu par le magasin. L'information conservée sur chaque
article est: le nom, le prix et le nombre en stock. Cette liste est construite à partir de la
déclaration suivante:
struct type_article
{
char Nom_Article[20];
float Prix;
int Stock;
type_article *Suivant;
};
La liste est créée et contient déjà plusieurs éléments. Elle se présente comme suit:
Tete
Telephone
Fil
Clavier
Modem
64.99
3.29
34.97
249.99
46
162
24
8
.....
NULL
Écrire une fonction qui calcule et retourne le montant d'une commande d'articles en
parcourant la liste. Cette commande ne comprendra que les articles dont la quantité en
stock sera inférieure à une quantité seuil. La quantité à commander sera la même pour
chacun des articles. La quantité seuil, la quantité d'articles à commander et la tête de la
liste seront reçues en paramètre. La fonction ne modifie pas le nombre d'articles en stock.
Par exemple, si la liste ne contenait que les quatre articles ci-haut, que le seuil est fixé à
trente et que la quantité à commander est de cinquante, alors la fonction retournerait
comme coût 14 248, soit:
50*34.97 (puisque 24 claviers <30)
+ 50*249.99 (puisque 8 modems <30 )
14 248
Page 6 sur 7
Examen Final - Automne 98 - 3.307
QUESTION 5 (5 Points)
Une théorie s'intéresse aux degrés de séparation de toutes les personnes sur la terre. Un
degré de séparation est un lien quelconque (ami, famille, connaissance, etc.) entre deux
personnes. Par exemple, si André connaît Julie, et que Julie connaît Sophie, alors il y a
deux degrés de séparation entre André et Sophie. La structure utilisée pour représenter les
liens est un tableau d'enregistrements défini selon les instructions suivantes:
struct type_personne
{
char Nom[20];
int Lien;
};
type_personne TabLiens[76];
Le champ Lien indique qu'il y a un lien entre la
personne dont le nom est inscrit dans le champ Nom
et celle située à la position du lien dans le tableau.
Par exemple pour le tableau ci-contre, il y a un lien
entre Josée et la personne située à la position 3, soit
Kim. Il s'agit d'un lien de degré 1. Kim a un lien
avec Salim en position 5. Donc Josée a un lien de
degré deux avec Salim (Josée, Kim, Salim).
0
1
2
3
4
5
.
.
75
Josée
Marie
Éric
Kim
Aniss
Salim
.
.
Anick
3
0
22
5
27
10
.
.
15
NOTE: Pour les deux questions suivantes nous considérons que les noms transmis en
paramètre sont présents et uniques dans le tableau de 76 noms. Vous n'avez pas
à utiliser de pointeur pour ces questions.
A) Écrire la fonction ChercherNom() qui reçoit en paramètre le nom d'une personne
et retourne sa position dans le tableau. La fonction reçoit également en paramètre le
tableau des noms liés. Le prototype de la fonction est,
int ChercherNom(char Nom[], type_personne TabNoms[76]);
B) Écrire la fonction TrouverDegre() qui utilise trois paramètres. Les deux premiers
sont des chaînes de caractères correspondant au nom de deux personnes dans le
tableau. Le troisième est le tableau des noms liés. La fonction fait appel à la fonction
ChercherNom() (question A) pour déterminer la position de la personne reçue
comme premier paramètre. La fonction recherche l'autre nom reçu en paramètre en
empruntant les champs liens. Finalement, la fonction retourne le degré du lien entre
ces deux personnes. Le prototype de la fonction est,
int TrouverDegre(char NomDebut[], char NomFin[],
type_personne TabNoms[76]);
Les professeurs du 3.307
Yves Boudreault, coordonnateur
Page 7 sur 7