Correction TD_2

Exercice 1

Test directement réalisé à l’aide d’un programme. Le résultat est fonction de la machine avec
laquelle on travaille.

Exercice 2

Quel(s) type(s) numérique(s) pouvez-vous utiliser pour les groupes de nombres suivants?
Dressez un tableau et marquez le choix le plus économique:

Valeurs Type approprié

1 12 4 0 -125 char
1 12 -4 0 250 short int
1 12 4 0 250 unsigned char
1 12 -4 0.5 125 float
-220 32000 0 short int
-3000005.000000001 En float 3000005 en double ok
410 50000 2 unsigned short int
410 50000 -2 long int
3.14159265 1015 En float (1) = 3.1415927 pas de perte en
double
2*107 10000001 long int
2*10-7 10000001 float code hexa 3456bf95 (1)
-1.05*1050 0.0001 En float (1) codé INF donc double
305.122212 0 -12 En float (1) donne 305,12222 pas de perte en
double

Exercice 3

Série 1

Exo 1 : C=13, B=13, A=13.

Exo 2 : Ecrire un programme qui lit le prix HT d’un article, la quantité achetée et le taux de
TVA, et qui fournit le prix total TTC correspondant. Faire en sorte que des libellés
apparaissent clairement.

Entrée : réel prix HT, entier quantité article, réel TVA

Sortie : réel prix TTC

Variables HT, TTC, TVA : réel

Variables nb_article : entier

Début
écrire « Quel est le prix hors taxe de l’article ? »
lire HT
écrire « Quelle quantité de ce produit avez vous achetée ? »
lire nb_article
écrire « Quel est le taux de TVA pour cet article ? »
lire TVA
TTC ← nb_article*(HT * (1 + TVA))
écrire « La facture s’élève à », TTC, « euros TTC »
Fin

Exo 3 : Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce

nombre est positif ou négatif (on inclut le traitement du cas où le nombre vaut zéro).

Entrée : un entier
Sortie : affichage du signe de l’entier

Variable Nb : entier

Début
écrire « Entrez un nombre entier : »
lire Nb
Si Nb = 0 alors
écrire « Le nombre vaut zéro »
Sinon
Si Nb < 0 alors
écrire « le nombre est négatif »
Sinon
écrire « le nombre est positif »
FinSi
FinSi
Fin

Exo 4 : Ecrire un algorithme qui demande un nombre, jusqu’à ce que la réponse soit comprise
entre 10 et 20. En cas de réponse supérieure à 20, on fera apparaître un message : « Plus
petit ! », et inversement, « Plus grand ! » si le nombre est inférieur à 10.

Entrée : un entier
Sortie : affichage de texte
Variable N : entier
Début
N←0
TantQue (N < 10 ) OU (N>20)
écrire « Entrez un nombre : »
lire N
Si N < 10 alors
Ecrire « Plus grand ! »
Sinon
Si N > 20 alors
Ecrire « Plus petit ! »
Sinon
Ecrire « Correct »
FinSi
FinSi
FinTantQue
Fin
Série 2

Exo 1 : Indiquer si les instructions suivantes sont correctes ou fausses dans le langage C.
Proposer une correction pour les instructions fausses.

Expression Explication
int C, 1t ; Faux. Un nom de variable ne peut
commencer par un chiffre.
int C5x, Faux. Une instruction se termine par un « ; »
real reel ; décimal, Faux. Pas de type real. Si plusieurs variables,
on les sépare par des « , » et on termine par
« ; ». On évité les accents dans les noms.
double C.5, C_5 ; ?C ; Faux. Pas de « . » ou de « ? » dans le nom.
Même remarque que précédemment sur la
séparation des variables.
double auto, int, C ; Faux. Auto et int noms réservés.
Double p) ; short ; Faux. short nom reserve. Pas de « ) » dans le
nom. double n’a pas de majuscule.
5=I ; Faux. 5 est une constante, on ne peut
changer sa valeur.
for(i=0,i=<5,i++) Faux. Le séparateur dans un for est « ; ». Le
égal est toujours après le signe d’infériorité.
if(a=3) Faux. L’égalité se traduit par = =. = seul
correspond à l’affectation.

Exo 2 : Comment fait-on pour incrémenter d’une unité la valeur d’une variable A ?

Il existe plusieurs méthodes pour incrémenter une variable d’une unité.

A = A+1 ;
A +=1 ;
A++ ;
++A ;

Ces 4 écritures donnent le même résultat.

- La première correspond à l’écriture classique.
- L’opérateur d’assignation += permet de simplifier l’opération d’incrémentation.
L’instruction va prendre la valeur qui est dans A, l’incrémenter et la stocker dans A.
- L’opérateur ++ va permettre de remplacer les notations lourdes précédentes et va se
révéler utile dans les boucles qui ont besoin d’un compteur notamment dans les
boucles for.
Les deux premières écritures sont également valables pour les opérations - , * , /.
Ex : A=A*4 peut s’écrire A*=4 et donnera le même résultat.

La place du ++ peut cependant avoir un résultat différent :

Ex :
int N,X ;
N=5 ;
X=++N ;
Résultat : X=6 et N=6. On charge la valeur de N on l’incrémente de 1 et on l’affecte à X.
int N,X ;
N=5 ;
X=N++ ;

Résultat : X=5 et N=6.On charge la valeur de N dans X puis on l’incrémente.

Ces remarques sont applicables également à --.

Exo 3 : Quelle est la valeur affectée à la variable fee par l’instruction de if quand speed est
égal à 75 ?

if (speed > 35)

{fee = 20.0;}
else if (speed > 50)
{fee = 40.0;}
else if (speed > 75)
{fee = 60.0;}

fee vaut 20.0 avec ce programme pour une vitesse de 75. En effet la première condition est
vérifiée donc l'instruction du premier if sera effectuée et le programme s'arrêtera.

Exo 4 : Idem pour le if ci-dessous quand speed est égal 75. Quel est le programme qui vous
semble le plus raisonnable ?

if (speed > 75)

{fee = 60.0;}
else if (speed > 50)
{fee = 40.0;}
else if (speed > 35)
{fee = 20.0;}

Cette fois-ci, fee vaut 40.0 pour une vitesse de 75. Ce programme est le plus raisonnable d'un
point de vue sécurité, étant donné qu'il applique le bon coefficient de freinage suivant la
vitesse. Le premier programme appliquera le même coefficient dès que l'on roulera à une
vitesse supérieure à 35. En résumé, l'ordre, l'écriture des accolades et l'indentation permettent
d'éviter des erreurs qui peuvent conduire à des systèmes peu sûrs.

Exo 5 : Expliquer la différence entre les deux instructions suivantes :

if (x >= 0) if (x >= 0)
{x = x+1;} {x = x+1;}
else if (x >= 1) if (x >= 1)
{x = x +2;} {x = x +2;}

Pour le programme de gauche, la première condition sera vérifiée dans tous les cas de figure
et seule l'instruction x+=1 sera effectuée. Donc le résultat sera la valeur entrée, incrémentée
de 1.
Pour le programme de droite, cette fois-ci, les deux conditions seront vérifiées à chaque fois et
le nombre entré sera incrémenté de 3 .
Exo 6 : Réécrire la boucle suivante en utilisant la boucle for puis en utilisant la boucle do
while

count = 0;
i =0 ;
while (i < n)
{
if (x == i)
count = count + 1;
i = i+1;
}

Boucle for: Boucle do while:

count = 0; do
for(i=0;i<n;i++) {
{ if(x==i)
if(x==i) {
{ count=count + 1;
count = count + 1; }
} i = i + 1;
} }
while(i<n);

Exo 7 : Écrire un programme qui accepte en entrée un nombre en kilomètres et restitue en

sortie sa valeur correspondante en miles (1 mile = 1.6 km). Implémenter ce programme en
langage C.

Entrée : un réel
Sortie : un réel

Variables km,mile : réel

Début
écrire « Entrez un nombre de kilomètres : »
lire km
mile ← km : 1.6
écrire km, « kilomètres correspondent à », mile, « miles. »
Fin

Traduction
#include <stdio.h>
int main(void)
{
float km,mile;
printf(“ Entrez un nombre de kilomètres : ”);
scanf(“ %f ”, &km);
mile = km / 1.6;
printf(“%f kilomètres correspondent à %f miles”,km,mile);
return(0);
}

Exercice 4 – basic en langage C

Exo1 : Écrivez un programme qui permute les valeurs de deux variables lues au clavier.

// programme qui permute les valeurs de 2 entiers entres au clavier

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int nb1, nb2, inter;

//saisie
printf("Entrez deux entiers : ");
scanf("%d %d", &nb1, &nb2) ;

printf("nb1 contient %d et nb2 contient %d\n", nb1, nb2);

//permutation
inter = nb1;
nb1 = nb2;
nb2 = inter;

//affichage du resultat
printf("nb1 contient %d et nb2 contient %d\n", nb1, nb2);

return 0;
}

Exo2 : Écrivez un programme qui effectue une permutation circulaire vers la droite de 4
variables lues au clavier.

// permutation circulaire de 4 entiers lus au clavier

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x, y, z, t, inter;

//saisie
printf("Entrez quatre entiers : ");
scanf("%d %d %d %d", &x, &y, &z, &t);

printf("x = %d, y = %d, z = %d et t = %d\n", x, y, z, t);

//permutation circulaire
inter = x;
 x = y;
y = z;
z = t;
t = inter;

//affichage du resultat
printf("x = %d, y = %d, z = %d et t = %d\n", x, y, z, t);

return 0;
}

Exo3 : Écrivez un programme qui donne le maximum de 3 nombres lus au clavier et effectuez
des tests pour :
258
420
8 -6 1

// maximum de 3 nombres lus au clavier

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x, y, z;

//saisie
printf("Entrez trois nombres : ");
scanf("%d%d%d", &x, &y, &z);

//recherche du maximum
if(x > y) { // comparer x et z
if(x > z)
printf("le plus grand nombre est %d\n", x);
else
printf("le plus grand nombre est %d\n", z);
}
else { // comparer y et z
if(y > z)
printf("le plus grand nombre est %d\n", y);
else
printf("le plus grand nombre est %d\n", z);
}

return 0;
}

Exo4 : Écrivez un programme qui calcule la moyenne de 4 nombres lus au clavier et donne le
minimum

// calculer la moyenne de 4 nombres et donner le minimum

 #include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x, y, z, t;
float moyenne;

//saisie
printf("Entrez quatre entiers : ");
scanf("%d%d%d%d", &x, &y, &z, &t);

// calcul de la moyenne
moyenne = (float)(x+y+z+t)/4;
printf("la moyenne est %.2f\n", moyenne);

//recherche du minimum
if((x < y) && (x < z) && (x < t))
printf("le plus petit nombre est %d\n", x);
else if((y < x) && (y < z) && (y < t))
printf("le plus petit nombre est %d\n", y);
else if((z < x) && (z < y) && (z < t))
printf("le plus petit nombre est %d\n", z);
else
printf("le plus petit nombre est %d\n", t);

return 0;
}

Exo5 : Écrivez un programme qui donne une température en degrés celsius à partir d'une
température Fahrenheit (C = (5/9) * (F - 32))

// programme qui donne une temperature en degres Celsius

// a partir d'une temperature en degres Fahrenheit
// C = (5/9)*(F-32)

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
float fahr;
float deg;

//saisie
printf("Entrez une temperature en degres Fahrenheit : ");
scanf("%f", &fahr);

// calcul des degres Celsius

deg = (5.0/9.0)*(fahr - 32);

// affichage du resultat
printf("%.2f degres F = %.2f degres C\n", fahr, deg);

return 0;
}
Exo 6 : Écrire un programme qui accepte en entrée un nombre en kilomètres et restitue en
sortie sa valeur correspondante en miles (1 mile = 1.6 km). Implémenter ce programme en
langage C.
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
float km;
float mil;

//saisie
printf("Entrez une distance en miles : ");
scanf("%f", &mil);

// calcul des degres Celsius

km = 1.6 * mil;

// affichage du resultat
printf("%.2f miles = %.2f km \n", mil, km);

return 0;
}