Exercices

École de technologie supérieure
INF-145
LABORATOIRE NUMÉRO 1
Exercices
1. OBJECTIF
Ce laboratoire a pour but de vous :
-
familiariser avec l’environnement Visual C++;
-
rappeler la syntaxe du langage C.
2. FONCTIONNEMENT DU LABORATOIRE
Ce laboratoire se compose de 12 exercices. Ceux-ci doivent tous être complétés
d’ici la prochaine séance de laboratoire.
Chaque exercice est accompagné d’une solution. Il vous est conseillé de ne pas
consulter cette dernière avant d’avoir complété l’exercice.
INF-145 Programmation avancée et langage C
Page 1
3. EXERCICES
1) Écrivez un programme qui affiche à l’écran la phrase latine « ab ovo usque ad
mala ».
Voir l'indice
Voir la solution
2) Le Watt est une unité de puissance qui correspond au transfert d’un joule
pendant une seconde dans un système énergétique. Sachant qu’un Watt
correspond à 0.2388459 calorie par seconde, écrivez un programme qui saisit
un nombre de Watt au clavier et affiche la puissance équivalente exprimée en
calorie par seconde.
Résultat attendu
Voir l'indice
Voir la solution
3) Soit le schéma électrique ci-dessous qui se compose d’une alimentation
continue et d’une résistance.
La tension se note V (exprimée en Volt) et la résistance se note R (exprimée
en Ohm). Sachant que la loi d’Ohm affirme que l’intensité du courant I (en
Ampère) peut être calculée à l’aide de la formule I = V / R, écrivez un
programme qui saisit la tension et la résistance et qui affiche l’intensité.
Résultat attendu
Voir l'indice
Voir la solution
INF-145 Programmation avancée et langage C
Page 2
4) Si on laisse tomber un objet sphérique dans l’atmosphère, celui-ci accélère
jusqu’à ce que son poids compense exactement la résistance de l’air. La
formule qui suit permet de calculer la vitesse limite V d’un tel objet.
V 
2mg
0.5 r 2
où :
-
m = la masse de la sphère (en kg);
g = l’accélération de la pesanteur (en m/s2) que nous fixerons à 9.81;
ρ = la masse volumique de l’air (en kg/m3) que nous fixerons à 1.2;
r = le rayon de la sphère (en m).
Écrivez un programme qui saisit la masse ainsi que le rayon de la sphère et
qui affiche sa vitesse maximale en chute libre.
Résultat attendu
Voir l'indice
Voir la solution
5) Écrivez un programme qui saisit deux nombres entiers au clavier et qui affiche
le plus petit de ces deux nombres.
Résultat attendu
Voir l'indice
Voir la solution
6) Écrivez un programme qui saisit deux nombres entiers au clavier et qui affiche
le plus grand de ces deux nombres.
Résultat attendu
Voir l'indice
Voir la solution
INF-145 Programmation avancée et langage C
Page 3
7) Le nombre de Reynolds sert à caractériser un écoulement en mécanique
des fluides. Il se calcule de la façon suivante :
R
VL
v
où :
-
V = vitesse caractéristique du fluide (en m/s);
L = la dimension caractéristique (en m);
v = la viscosité cinématique du fluide (en m2/s).
Un écoulement est laminaire lorsque R est inférieur à 2000, turbulent lorsque
R est supérieur à 4000 et transitoire dans tous les autres cas.
Écrivez un programme qui saisit V, L ainsi que v et qui affiche si l’écoulement
est laminaire, turbulent ou transitoire.
Résultat attendu
Voir l'indice
Voir la solution
8) On vous informe que sur un chantier on utilise la recette ci-dessous pour
fabriquer 1 m3 de béton.
3
RECETTE POUR FABRIQUER 1m DE BÉTON
350 kg de ciment
680 kg de sable (granulométrie de 1 à 5 mm)
1175 kg de gravier (granulométrie de 6 à 15 mm)
Écrivez un programme qui saisit un nombre de kg de ciment, de sable et de
gravier et qui affiche le volume maximal de béton qui peut alors être produit.
Résultat attendu
Voir l'indice
Voir la solution
INF-145 Programmation avancée et langage C
Page 4
Pour réaliser les quatre exercices qui suivent, vous aurez besoin de la fonction
nb_aleatoire. Le code qui suit montre comment utiliser cette fonction.
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
/* Pour avoir accès à time. */
/* Pour avoir accès à srand. */
/* Pour avoir accès à printf. */
/*
NB_ALEATOIRE
Cette fonction retourne une valeur aléatoire dans l'intervalle entier
[min, max]. Chaque valeur possède la même probabilité d'être générée.
PARAMÈTRES :
- min : La plus petite valeur pouvant être générée (type : int).
- max : La plus grande valeur pouvant être générée (type : int).
VALEUR DE RETOUR : Une valeur se trouvant dans l'intervalle
[min, max] (type : int).
ANTECEDENTS :
- On suppose que la fonction srand a préalablement été
appelé.
*/
int nb_aleatoire(int min, int max)
{
return min + (int)(rand() / (RAND_MAX + 0.001) * (max – min + 1));
}
int main(void)
{
int nombre_aleatoire;
/* Reçoit un nombre aléatoire. */
/* On initialise le générateur de nombres aléatoires. */
srand((unsigned int) time(NULL));
rand();
/* On génère un nombre dans l’intervalle [1, 10]. */
nombre_aleatoire = nb_aleatoire(1, 10);
/* On affiche le nombre généré. */
printf("Nombre : %i\n", nombre_aleatoire);
return EXIT_SUCCESS;
}
INF-145 Programmation avancée et langage C
Page 5
9) Écrivez un programme qui lance un cinq dés à 6 faces et affiche les cinq
valeurs obtenues.
Résultat attendu
Voir l'indice
Voir la solution
10) Écrivez un programme qui lance un dé à 6 faces un million de fois et affiche
la moyenne des lancers.
Résultat attendu
Voir l'indice
Voir la solution
11) Écrivez un programme qui estime la probabilité d’obtenir 7 lorsqu’on lance
deux dés à 6 faces et que l’on fait la somme du résultat obtenu.
Résultat attendu
Voir l'indice
Voir la solution
12) On souhaite estimer la probabilité d’obtenir trois valeurs croissantes (p. ex. :
3, 3, 6) lorsqu’on lance successivement trois fois un dé à 6 faces. Écrivez un
programme qui estime cette probabilité à l’aide d’une simulation.
Résultat attendu
Voir l'indice
Voir la solution
INF-145 Programmation avancée et langage C
Page 6
Solution de l’exercice 1
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf("ab ovo usque ad mala\n");
return EXIT_SUCCESS;
}
Quelques remarques :
-
La ligne #include <stdio.h> est nécessaire pour pouvoir appeler
la fonction printf.
-
La ligne #include <stdlib.h> est nécessaire pour pouvoir utiliser
la constante de compilation EXIT_SUCCESS.
-
Le \n dans le printf sert à indiquer qu’il faut sauter une ligne à
l’écran.
-
La constante de compilation EXIT_SUCCESS correspond à la valeur 0.
La dernière ligne pourrait donc être return 0;.
Voir la question
INF-145 Programmation avancée et langage C
Page 7
Solution de l’exercice 2
#include <stdio.h>
#include <stdlib.h>
/* Le nombre de calorie/seconde dans 1 Watt. */
#define NB_CALORIE_PAR_SECONDE_DANS_WATT 0.2388459
int main(void)
{
double nb_watt;
/* Pour lire les Watts au clavier. */
/* On saisit le nombre de Watt. */
printf("Veuillez entrer le nombre de Watt(s) : ");
scanf("%lf", &nb_watt);
/* On convertit les Watts en calorie par seconde. */
printf("%f Watt(s) = %f calorie par seconde\n",
nb_watt,
nb_watt * NB_CALORIE_PAR_SECONDE_DANS_WATT);
return EXIT_SUCCESS;
}
Quelques remarques :
-
On note que le nombre 0.2388459 est conservé sous forme de
constante (ce qui clarifie le code).
-
Prenez note qu’il ne faut pas utiliser l’opérateur = dans un #define.
-
Lors de la lecture au clavier avec scanf, l’utilisation de l’opérateur &
est essentiel. Nous verrons pourquoi il en est ainsi lors de la
présentation des pointeurs.
Voir la question
INF-145 Programmation avancée et langage C
Page 8
Solution de l’exercice 3
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
double tension;
/* Pour lire la tension (en Volt). */
double resistance; /* Pour lire la résistance (en Ohm). */
/* On saisit la tension. */
printf("Veuillez entrer la tension (en Volt) : ");
scanf("%lf", &tension);
/* On saisit la résistance. */
printf("Veuillez entrer la résistance (en Ohm) : ");
scanf("%lf", &resistance);
/* On affiche l'intensité du courant. */
printf("L'intensité du courant est de %f Ampère(s).\n",
tension / resistance);
return EXIT_SUCCESS;
}
Voir la question
INF-145 Programmation avancée et langage C
Page 9
Solution de l’exercice 4
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define ACCELERATION_GRAVITATIONNELLE 9.81
#define MASSE_VOLUMIQUE_AIR 1.2
#define PI 3.14159265
int main(void)
{
double masse;
double rayon;
/* En m/s^2. */
/* En kg/m^3. */
/* Pour saisir la masse (en kg). */
/* Pour saisir le rayon (en m). */
/* On saisit les informations sur la sphère. */
printf("Veuillez entrer la masse de la sphere : ");
scanf("%lf", &masse);
printf("Veuillez entrer le rayon de la sphere : ");
scanf("%lf", &rayon);
/* On affiche la vitesse limite. */
printf("La vitesse maximale de la sphere est %f m/s.\n",
sqrt(2 * masse * ACCELERATION_GRAVITATIONNELLE /
(0.5 * PI * rayon * rayon * MASSE_VOLUMIQUE_AIR)));
return EXIT_SUCCESS;
}
Voir la question
INF-145 Programmation avancée et langage C
Page 10
Solution de l’exercice 5
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int nb1;
/* Pour saisir le premier nombre. */
int nb2;
/* Pour saisir le second nombre. */
/* On saisit les deux nombres. */
printf("Veuillez entrer le premier nombre : ");
scanf("%i", &nb1);
printf("Veuillez entrer le second nombre : ");
scanf("%i", &nb2);
/* On affiche la plus petite des deux valeurs lues. */
if (nb1 < nb2)
{
printf("%i est plus petit que %i.\n", nb1, nb2);
}
else
{
printf("%i est plus petit que %i.\n", nb2, nb1);
}
return EXIT_SUCCESS;
}
Quelques remarques :
-
Nous prendrons l’habitude de toujours mettre des accolades après le
if et le else (même si ce n’est pas obligatoire lorsqu’il n’y a qu’une
seule instruction).
Voir la question
INF-145 Programmation avancée et langage C
Page 11
Solution de l’exercice 6
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int nb1;
/* Pour saisir le premier nombre. */
int nb2;
/* Pour saisir le second nombre. */
/* On saisit les deux nombres. */
printf("Veuillez entrer le premier nombre : ");
scanf("%i", &nb1);
printf("Veuillez entrer le second nombre : ");
scanf("%i", &nb2);
/* On affiche la plus grande des deux valeurs lues. */
if (nb1 > nb2)
{
printf("%i est plus grand que %i.\n", nb1, nb2);
}
else
{
printf("%i est plus grand que %i.\n", nb2, nb1);
}
return EXIT_SUCCESS;
}
Voir la question
INF-145 Programmation avancée et langage C
Page 12
Solution de l’exercice 7
#include <stdio.h>
#include <stdlib.h>
/* Les valeurs à partir desquelles l'écoulement change de régime. */
#define BORNE_ECOULEMENT_TRANSITOIRE 2000
#define BORNE_ECOULEMENT_TURBULENT 4000
int main(void)
{
double vitesse;
double dimension;
double viscosite;
double nombre_Reynolds;
/*
/*
/*
/*
Pour lire
Pour lire
Pour lire
La valeur
la vitesse du fluide (en m/s). */
la dimension (en m). */
la viscosité (en m^2/s). */
calculée du nombre de Reynolds. */
/* On saisit les trois informations nombres. */
printf("Veuillez entrer la vitesse du fluide (en m/s) : ");
scanf("%lf", &vitesse);
printf("Veuillez entrer la dimension (en m) : ");
scanf("%lf", &dimension);
printf("Veuillez entrer la viscosite (en m^2/s) : ");
scanf("%lf", &viscosite);
/* On calcule le nombre de Reynolds. */
nombre_Reynolds = vitesse * dimension / viscosite;
/* On affiche le type d'écoulement. */
if (nombre_Reynolds > BORNE_ECOULEMENT_TURBULENT)
{
printf("L'écoulement est turbulent.\n");
}
else if (nombre_Reynolds >= BORNE_ECOULEMENT_TRANSITOIRE)
{
printf("L'écoulement est transitoire.\n");
}
else
{
printf("L'écoulement est laminaire.\n");
}
return EXIT_SUCCESS;
}
Quelques remarques :
-
Lorsqu’on écrit un else if, il est inutile de vérifier si l’inverse de
l’expression dans le if est vraie. Ainsi, si on observe l’exemple qui
INF-145 Programmation avancée et langage C
Page 13
suit, lorsqu’on atteint la ligne contenant le else if, on sait que x n’est
pas plus petit que 0 (sinon, on serait en train d’exécuter le printf). Il
est donc inutile de vérifier si x est supérieur ou égal à 0.
if (x < 0)
{
printf("x est négatif.");
}
else if (x >= 0)
{
...
Voir la question
INF-145 Programmation avancée et langage C
Page 14
Solution de l’exercice 8
#include <stdio.h>
#include <stdlib.h>
/*
Les proportions de ciment, de sable et de gravier pour la fabrication
d'un mètre cube de béton.
*/
#define QTEE_CIMENT_RECETTE_BETON
#define QTEE_SABLE_RECETTE_BETON
#define QTEE_GRAVIER_RECETTE_BETON
int main(void)
{
double masse_ciment;
double masse_sable;
double masse_gravier;
350
680
1175
/* En kg. */
/* En kg. */
/* En kg. */
/* La quantité de ciment en kg. */
/* La quantité de sable en kg. */
/* La quantité de gravier en kg. */
/* Le volume maximal de béton pouvant être produit si on ne se limite
que par un seul ingrédient (le ciment, le sable ou le gravier).
*/
double volume_beton_pour_ciment, volume_beton_pour_sable,
volume_beton_pour_gravier;
/* Le volume maximal de béton pouvant être produit. */
double volume_maximal;
/* On saisit la quantité de ciment,
printf("Veuillez entrer la quantité
scanf("%lf", &masse_ciment);
printf("Veuillez entrer la quantité
scanf("%lf", &masse_sable);
printf("Veuillez entrer la quantité
scanf("%lf", &masse_gravier);
de sable et de gravier. */
de ciment (en kg) : ");
de sable (en kg) :");
de gravier (en kg) :");
/* On calcule le volume de béton pouvant être produit si on ne
se limite qu'au ciment, au sable ou au gravier.
*/
volume_beton_pour_ciment = masse_ciment / QTEE_CIMENT_RECETTE_BETON;
volume_beton_pour_sable = masse_sable / QTEE_SABLE_RECETTE_BETON;
volume_beton_pour_gravier = masse_gravier / QTEE_GRAVIER_RECETTE_BETON;
/* On trouve l'ingrédient qui limite le volume de béton pouvant être
produit. On choisit dont le minimum parmi volume_beton_pour_ciment,
volume_beton_pour_sable et volume_beton_pour_gravier.
*/
if (volume_beton_pour_ciment < volume_beton_pour_gravier)
{
if (volume_beton_pour_ciment < volume_beton_pour_sable)
{
volume_maximal = volume_beton_pour_ciment;
INF-145 Programmation avancée et langage C
Page 15
}
else
{
volume_maximal = volume_beton_pour_sable;
}
}
else
{
if (volume_beton_pour_gravier < volume_beton_pour_sable)
{
volume_maximal = volume_beton_pour_gravier;
}
else
{
volume_maximal = volume_beton_pour_sable;
}
}
/* On affiche le volume pouvant être produit. */
printf("Vous pourrez produire %.3f mètre(s) cube de béton.\n",
volume_maximal);
return EXIT_SUCCESS;
}
Voir la question
INF-145 Programmation avancée et langage C
Page 16
Solution de l’exercice 9
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
/* Pour avoir accès à time. */
/* Pour avoir accès à srand. */
/* Pour avoir accès à printf. */
#define NB_LANCERS 5
#define NB_FACES_DE 6
/* Le nombre de dés à lancer. */
/* Le nombre de faces du dé. */
int nb_aleatoire(int min, int max)
{
return min + (int)(rand()/(RAND_MAX+0.001) * (max - min + 1));
}
int main(void)
{
long int i;
/* Pour compter les lancers. */
/* On initialise le générateur de nombres aléatoires. */
srand((unsigned int) time(NULL));
rand();
/* On effectue les lancers. */
printf("Valeurs obtenues : ");
i = 0;
while (i < NB_LANCERS)
{
printf("%i ", nb_aleatoire(1, NB_FACES_DE));
i = i + 1;
}
return EXIT_SUCCESS;
}
Voir la question
INF-145 Programmation avancée et langage C
Page 17
Solution de l’exercice 10
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
/* Pour avoir accès à time. */
/* Pour avoir accès à srand. */
/* Pour avoir accès à printf. */
#define NB_LANCERS 1000000
#define NB_FACES_DE 6
/* Le nombre de lancers à réaliser. */
/* Le nombre de faces du dé. */
int nb_aleatoire(int min, int max)
{
return min + (int)(rand()/(RAND_MAX+0.001) * (max - min + 1));
}
int main(void)
{
double somme_lancers = 0;
long int i;
/* La somme de tous les lancers. */
/* Pour compter les lancers. */
/* On initialise le générateur de nombres aléatoires. */
srand((unsigned int) time(NULL));
rand();
/* On effectue les lancers. */
i = 0;
while (i < NB_LANCERS)
{
somme_lancers = somme_lancers + nb_aleatoire(1, NB_FACES_DE);
i = i + 1;
}
/* On affiche la moyenne des lancers. */
printf("Moyenne : %f\n", somme_lancers / NB_LANCERS);
return EXIT_SUCCESS;
}
Quelques remarques :
-
Il est essentiel ici d’initialiser la somme des lancers à 0.
-
On remarque dans la boucle que pour faire une somme, il faut
assigner à une variable la valeur déjà présente dans la variable à
laquelle on additionne un nombre (p. ex. : x = x + 1).
Voir la question
INF-145 Programmation avancée et langage C
Page 18
Solution de l’exercice 11
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
/* Pour avoir accès à time. */
/* Pour avoir accès à srand. */
/* Pour avoir accès à printf. */
#define NB_LANCERS 1000000
#define NB_FACES_DE 6
/* Le nombre de lancers à réaliser. */
/* Le nombre de faces du dé. */
int nb_aleatoire(int min, int max)
{
return min + (int)(rand()/(RAND_MAX+0.001) * (max - min + 1));
}
int main(void)
{
double nb_7 = 0;
long int i;
/* Le nombre de 7 obtenus. */
/* Pour compter les lancers. */
/* On initialise le générateur de nombres aléatoires. */
srand((unsigned int) time(NULL));
rand();
/* On effectue les lancers. */
i = 0;
while (i < NB_LANCERS)
{
/* On prend note de tous les 7 obtenus. */
if (nb_aleatoire(1, NB_FACES_DE) +
nb_aleatoire(1, NB_FACES_DE) == 7)
{
nb_7 = nb_7 + 1;
}
i = i + 1;
}
/* On affiche la probabilité d'obtenir 7. */
printf("Probabilité : %f\n", nb_7 / NB_LANCERS);
return EXIT_SUCCESS;
}
Quelques remarques :
-
Il est à noter que nb_aleatoire(1, 6) + nb_aleatoire(1, 6)
n’est pas équivalent à nb_aleatoire(1, 12).
Voir la question
INF-145 Programmation avancée et langage C
Page 19
Solution de l’exercice 12
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
/* Pour avoir accès à time. */
/* Pour avoir accès à srand. */
/* Pour avoir accès à printf. */
#define NB_LANCERS 1000000
#define NB_FACES_DE 6
/* Le nombre de lancers à réaliser. */
/* Le nombre de faces du dé. */
int nb_aleatoire(int min, int max)
{
return min + (int)(rand()/(RAND_MAX+0.001) * (max - min + 1));
}
int main(void)
{
long int nb_suites_croissantes = 0;
long int i;
int de1, de2, de3;
/* Nombre de suites croissantes.*/
/* Pour compter les essais. */
/* La valeur des 3 dés. */
/* On initialise le générateur de nombres aléatoires. */
srand((unsigned int) time(NULL));
rand();
/* On effectue les essais. */
i = 0;
while (i < NB_LANCERS)
{
/* On lance les trois dés. */
de1 = nb_aleatoire(1, NB_FACES_DE);
de2 = nb_aleatoire(1, NB_FACES_DE);
de3 = nb_aleatoire(1, NB_FACES_DE);
/* On vérifie si c'est une suite croissante. */
if (de1 <= de2)
{
if (de2 <= de3)
{
nb_suites_croissantes = nb_suites_croissantes + 1;
}
}
i = i + 1;
}
/* On affiche la probabilité d'obtenir une suite croissante. */
printf("Probabilité d'obtenir une suite croissante : %f\n",
1.0 * nb_suites_croissantes / NB_LANCERS);
return EXIT_SUCCESS;
}
INF-145 Programmation avancée et langage C
Page 20
Quelques remarques :
-
Nous verrons lors de la semaine prochaine comment regrouper deux
expressions booléennes pour n’en former qu’une seule. Cela nous
permettra, par exemple, de remplacer le code suivant :
if (de1 <= de2)
{
if (de2 <= de3)
{
...
}
}
par celui qui suit.
if (de1 <= de2 && de2 <= de3)
{
...
}
-
En C, lorsqu’on divise deux nombres entiers, la division réalisée est
une division entière. Ainsi, l’expression 3 / 4 vaut 0. Si on souhaite que
la division soit réelle, il faut qu’au moins un des opérandes soit un
nombre réel (p. ex. : 3.0 / 4, 3 / 4.0, 3.0 / 4.0 ou encore 1.0 * 3 / 4).
C’est la raison pour laquelle on multiplie le numérateur par 1.0 dans le
printf.
Voir la question
INF-145 Programmation avancée et langage C
Page 21