École de technologie supérieure
Génie de la production automatisée
GPA665
Solutionnaire sur les exercices traitant des techniques de
programmation et des TDA de type liste
1. Techniques de programmation, boucles et tableaux
1)
Est-ce que le code compile et s’exécute sans accès mémoire incorrecte?
Oui
2)
Quelle est la sortie de la fonction?
15.000000 3.000000 1.414214
3) À quoi correspondent chacune des trois parties identifiées?
1. Initialisation d’un tableau de dimension 5 par les valeurs suivantes : 4 : 3 : 2 : 1 : 0 2. On fait des calculs sur les données du tableau Data et on met les résultats dans les
cases 1 et 2 du tableau Result (la somme dans la case 1 et la moyenne dans la case 2).
3. On calcule l’écart type des données contenues dans le tableau Data et on la met dans la troisième case du tableau Result.
2. Techniques de programmation, boucles, tableaux et fonctions
void ComputeBasicStat(float Data[], int NbData,
float *Min, float *Max,
float *Average, float *StD) {
// Déclaration des variables locales int i;
// Identification des valeurs min et max
*Min = *Max = Data[0];
for (i = 1; i < NbData; i++) { if (Data[i] < *Min) { *Min = Data[i];
}
if (Data[i] > *Max) { *Max = Data[i];
} }
// Calcule de la moyenne *Average = 0.0;
for (i = 0; i < NbData; i++) { *Average += Data[i];
}
*Average /= NbData;
// Calcule de l'écart type *StD = 0.0;
for (i = 0; i < NbData; i++) {
*StD += (float)pow(Data[i] - *Average, 2);
}
*StD /= NbData;
*StD = (float)sqrt(*StD);
}
3. Construction logique, conception, structure, fonctions et TDA
1)
Veuillez déclarer tous les types nécessaires à votre TDA.
// Structure décrivant les sommets du polygone typedef struct
{
double X, Y;
} SPoint2D;
// Structure décrivant les constituants du polygone typedef struct
{
char PolygonName[26];
SPoint2D *Outline;
int N;
double Perimeter;
} SPolygon;
2) Veuillez définir une fonction permettant d’initialiser votre TDA. N’oubliez pas que la
fonction d’initialisation (ou de création) est une fonction permettant de démarrer à vide (sans aucun élément) votre TDA afin qu’elle soit cohérente avec sa définition dès sa création.
/*****************************************************
Fonction de création de la structure d'un polygone.
Cette fonction initialise à vide la structure d'un polygone.
---.
Intrants : - Polygon : Le polygone à détruire Extrants : - Retourne 1 si la fonction réussie sinon 0
*****************************************************/
int CreatePolygon(SPolygon *Polygon) {
if (Polygon != NULL) {
strcpy(Polygon->PolygonName, "");
Polygon->Outline = NULL;
Polygon->N = 0;
Polygon->Perimeter = 0.0;
return 1;
} else { return 0;
} }
3)
Veuillez définir, si nécessaire, une fonction permettant de détruire (ou disposer) de votre TDA. Cette fonction sert principalement une seule fois, à la fin de l’utilisation du TDA.
/*****************************************************
Fonction de destruction d'un polygone. Libère toute la mémoire associée à un polygone.
---.
Intrants : - Polygon : Le polygone à détruire Extrants : - Retourne 1 si la fonction réussie sinon 0
*****************************************************/
int DestroyPolygon(SPolygon *Polygon) {
if (Polygon != NULL) {
if (Polygon->Outline != NULL) { free(Polygon->Outline);
}
strcpy(Polygon->PolygonName, "");
Polygon->Outline = NULL;
Polygon->N = 0;
Polygon->Perimeter = 0.0;
return 1;
} else { return 0;
} }
4)
Veuillez faire une fonction de lecture du fichier prescrit.
/*****************************************************
Fonction de lecture d'un fichier décrivant un polygone
---.
Intrants : - FileName : Nom du fichier d'entrée - Polygon : Pointeur vers la structure qui
contiendra la définition du polygone.
Extrants : - Le nombre de sommets lus.
Retourne -1 si la lecture a échouée
*****************************************************/
int OpenPolygon(char FileName[], SPolygon *Polygon) {
FILE *FileIn;
int i;
// Ouverture du fichier
if (FileIn = fopen(FileName, "rt")) {
// Lecture du nom et du nombre de sommets
fgets(Polygon->PolygonName, POLYGON_NAME_SIZE, FileIn);
fscanf(FileIn, "%d\n", &Polygon->N);
// Allocation dynamique du tableau en fonction de la taille if (Polygon->Outline =
(SPoint2D*) malloc(sizeof(SPoint2D) * Polygon->N)) { Polygon->Perimeter = 0.0;
if (Polygon->N > 0) {
// Lecture de tous les sommets et mise à jour du périmètre
fscanf(FileIn, "%lf %lf\n",
&(Polygon->Outline[0].X), &(Polygon->Outline[0].Y));
for (i = 1; i < Polygon->N; i++) { fscanf(FileIn, "%lf %lf\n",
&(Polygon->Outline[i].X), &(Polygon->Outline[i].Y));
Polygon->Perimeter +=
SideLength( &(Polygon->Outline[i-1]), &(Polygon->Outline[i]));
}
Polygon->Perimeter +=
SideLength( &(Polygon->Outline[0]), &(Polygon->Outline[Polygon->N-1]));
} }
// Fermeture du fichier fclose(FileIn);
return Polygon->N;
// Fichier manquant } else {
strcpy(Polygon->PolygonName, "");
Polygon->N = 0;
Polygon->Perimeter = 0.0;
return -1;
} }
/*****************************************************
Fonction calculant la longueur d'un segment en deux sommets.
---.
Intrants : - P1 & P2 : Les deux points représentant les coordonnées des sommets.
Extrants : - La longueur entre les deux sommets (calcule de distance euclidienne).
*****************************************************/
double SideLength(SPoint2D *P1, SPoint2D *P2) {
return sqrt(pow(P2->X - P1->X, 2) + pow(P2->Y - P1->Y, 2));
}
5) Veuillez faire une fonction d’écriture du fichier prescrit.
/*****************************************************
Fonction d'écriture d'un fichier décrivant un polygone
---.
Intrants : - FileName : Nom du fichier de sortie - Polygon : Pointeur vers la structure
contenant la définition du polygone.
Extrants : - Le nombre de sommets lus.
Retourne -1 si l'écriture a échouée
*****************************************************/
int SavePolygon(char FileName[], SPolygon *Polygon) {
FILE *FileOut;
int i;
// Ouverture du fichier pour l'écriture if (FileOut = fopen(FileName, "wt")) {
// Écriture du nom et du nombre de sommets fprintf(FileOut, "%s\n", Polygon->PolygonName);
fprintf(FileOut, "%d\n", Polygon->N);
// Écriture de tous les sommets for (i = 0; i < Polygon->N; i++) {
fprintf(FileOut, "%lf %lf\n", Polygon->Outline[i].X, Polygon->Outline[i].Y);
}
// Fermeture du fichier fclose(FileOut);
return Polygon->N;
// Fichier manquant } else {
return -1;
} }
4. Techniques de programmation, récursivité, paramètres passés par valeur et par référence
Quelle est la sortie du programme suivant?
256
5. Récursivité
void DessineFigure(int X, int Y, int R) {
if (R > 1) {
DrawCircle(X, Y, R);
if (R/2 > 1) { // Cette condition est facultative DessineFigure(X + 3/2*R, Y, R/2);
DessineFigure(X - 3/2*R, Y, R/2);
DessineFigure(X, Y + 3/2*R, R/2);
DessineFigure(X, Y - 3/2*R, R/2);
} } }
