Vous êtes sur la page 1sur 15

Exo 0 : Eliminer les parenthèses superflues dans les expressions suivantes :

a=(a+5) ; l’opérateur + est prioritaire sur l’opérateur d’affectation = donc l’expression peut être écrite
sous la forme : a=a+5 ;
a=(x=y)+2 ; l’opérateur + étant prioritaire sur l’opérateur d’affectation =, les parenthèses doivent
être maintenus.
a=(x==y) ; l’opérateur d’égalité == est prioritaire sur l’opérateur d’affectation = donc l’expression
logique x==y est évalué (1 représente la valeur vrai / 0 représente la valeur faux) avant d’être affecté
à la variable a. Les parenthèses sont dans ce cas superflues et l’expression peut être écrite sous la
forme : a=x==y;
(a<b)&&(c<d) ; l’opérateur < est prioritaire sur l’opérateur && donc les deux expressions logique
(a<b) et (c<d) sont évaluées (1 représente la valeur vrai / 0 représente la valeur faux) avant d’évaluer
le résultat par l’opérateur ET logique (&&) . Les parenthèses sont dans ce cas superflues et
l’expression peut être écrite sous la forme : a<b && c<d ;

Exo 1 : quelle est la valeur affectée aux différentes variables concernées par chacune des instructions
du programme suivant :

1
Elément de réponse :

q=n<p; l’expression logique n<p est évaluée en premier lieu. L’expression n<p vaut vrai (vrai en
langage « c » c’est 1/ faux en langage « c » c’est 0) donc q vaut 1.
q=n==p; l’expression logique n==p est évalué. L’expression n==p vaut faux (vrai en langage « c » c’est
1/ faux en langage « c » c’est 0) donc q vaut 0.
q=(p%n)+(p>n); dans cette instruction il ya combinaison entre une expression arithmétique (p%n)
avec % le modulo et une expression logique (p>n). (p%n) vaut 4 tandis que l’évaluation de
l’expression logique (p>n) donne vrai (vrai en langage « c » c’est 1) donc q=4+1=5.
x=p/n; la division p/n est une division entière car p et n sont de type int. Le résultat de cette division
vaut 1. Le resultat de la division est ensuite converti en float avant d’étre attribuer à x (qui est de
type float). x vaut donc 1.00 (%.2f pour afficher deux chiffres seulement après la virgule).
x=(float)p/n; les deux entiers p et n sont converti en float avant l’opération de division. Ainsi le
résultat est un float. x vaut 1.80.
x=(p+0.5)/n; 0.5 est un réel (float), donc p est converti en float avant d’être ajouté à 0.5. Le résultat
est divisé par le résultat de la conversion de n en float. x vaut 1.90.
x=(int)(p+0.5)/n; p est converti en float avant d’étre ajouté à 0.5. Le résultat 5.5 est alors converti en
int avant d’être divisé par l’entier n. le résultat de cette division entière est convertie en float avant
d’être attribué a x. x vaut donc 1.00.

#include <stdio.h>
#include <stdlib.h>
int main()
{
int n=5,p=9;
int q;
float x;
q=n<p;
printf("A/-la valeur affectee a la variable q apres l'instrcution q=n<p; est %d\n",q);
q=n==p;
printf("B/-la valeur affectee a la variable q apres l'instrcution q=n==p; est %d\n",q);
q=(p%n)+(p>n);
printf("C/-la valeur affectee a la variable q apres l'instrcution q=(p mod n)+(p>n); est %d\n",q);
x=p/n;
printf("D/-la valeur affectee a la variable x apres l'instrcution x=p/n; est %.2f\n",x);
x=(float)p/n;
printf("E/-la valeur affectee a la variable x apres l'instrcution x=(float)p/n; est %.2f\n",x);
x=(p+0.5)/n;
printf("F/-la valeur affectee a la variable x apres l'instrcution x=(p+0.5)/n; est %.2f\n",x);
x=(int)(p+0.5)/n;
printf("G/-la valeur affectee a la variable x apres l'instrcution x=(int)(p+0.5)/n; est %.2f\n",x);
return 0;
}

2
Exo 2 : quels résultats fournira le programme suivant :

Elément de réponse :

A : q= n++>p || p++!=3; en premier lieu la variable n sera comparée à la variable p avant que n ne
soit incrémenté de 1. Comme n=5 et p=2 alors n>p est vrai et vaut donc 1. Suite à cette comparaison
et comme il suffit d’un seul vrai pour que le OU logique soit à vrai, la deuxième partie l’expression
logique (p++!=3) ne sera pas évalué (ce qui explique pourquoi le p n’est pas incrémenté de 1 à la fin
de l’instruction). Ainsi q=1, p=2. A la fin de l’opération la variable n est incrémentée de 1 (n=6). On
obtient alors : n=6, p=2, q=1.
B : q= n++ <p || p++!=3; la variable n avant son incrémentation est comparée à la variable p. 5<2
vaut faux. Puisque la première partie du OU logique vaut faux il faudrait analyser la deuxième partie
du OU logique pour déterminer la valeur à attribuer au OU logique. P sera alors comparé à 3 avant
sont incrémentation. P=2 et donc p !=3 vaut vrai. Faux OU vrai donne vrai (le vrai en c est représenté
par le 1) ainsi q=1. Ensuite, la variable n sera incrémenté de 1 et la variable p sera également
incrémenté de 1. On obtient alors n=6, p=3, q=1.
C : q= ++n ==3 && ++p==3; en premier lieu la variable n est incrémentée puis comparée à la valeur
3. Sachant que n=5 et que ++n=6 alors ++n==3 vaut faux. Or pour que la relation du ET logique soit à
vrai il faut que les deux parties (++n ==3) et (++p==3) soient à vrai. Donc la relation du ET logique est
mise à faux (le faux en c est représenté par le 0) sans même évaluer (++p==3) se qui explique
pourquoi la variable p n’est pas incrémentée de 1. Ainsi q=0. On obtient alors n=6, p=2 (inchangée)
et q=0.

3
D : q=++n==6 && ++p==3; dans cette expression la variable n est incrémentée de 1 puis comparée à
6. ++n ==6 vaut vrai. Pour déterminer la valeur du ET logique il est nécessaire d’évaluer la seconde
expression ++p==3 ainsi p est incrémenté de 1 avant d’être comparé à 3. ++p==3 est vrai. Vrai ET vrai
vaut vrai (le vrai en c est représenté par le 1). Ainsi q=1. On obtient alors n=6, p=3, q=1.

#include <stdio.h>
#include <stdlib.h>
int main()
{
int n,p,q;
n=5;p=2;
// cas 1 :
q= n++>p || p++!=3;
printf("A: les valeurs des variables sont n=%d, p=%d, q=%d\n",n,p,q);

// cas 2 :
n=5;p=2;
q= n++ <p || p++!=3;
printf("B: les valeurs des variables sont n=%d, p=%d, q=%d\n",n,p,q);

// cas 3 :
n=5;p=2;
q= ++n ==3 && ++p==3;
printf("C: les valeurs des variables sont n=%d, p=%d, q=%d\n",n,p,q);

// cas 4 :
n=5;p=2;
q=++n==6 && ++p==3;
printf("D: les valeurs des variables sont n=%d, p=%d, q=%d\n",n,p,q);

return 0;
}

Exo 3 : quels résultats fourni le programme suivant :

#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,j,n;

// cas 1 :
i=0;n=i++;
printf("A: les valeurs des variables sont: i=%d, n=%d\n",i,n);

4
// cas 2 :
i=10;n=++i;
printf("B: les valeurs des variables sont: i=%d, n=%d\n",i,n);

// cas 3 :
i=20;j=5;n=i++ * ++j;
printf("C: les valeurs des variables sont: i=%d,j=%d,n=%d\n",i,j,n);

// cas 4 :
i=15;n=i+=3;
printf("D: les valeurs des variables sont: i=%d, n=%d\n",i,n);

// cas 5 :
i=3;j=5;n=i*=--j;
printf("E: les valeurs des variables sont: i=%d,j=%d,n=%d\n",i,j,n);

return 0;
}

Elément de réponse :
i=0; n=i++; dans ce cas de figure l’affectation de i à n précèdent l’incrémentation de i
(incrémentation de i veut dire i=i+1). Ainsi n =0 et i=1.
i=10;n=++i; dans ce cas de figure l’incrémentation de i précèdent l’affectation du résultat à la
variable n. Ainsi n =11 et i=11.
i=20;j=5;n=i++ * ++j; dans ce cas de figure j est incrémenté avant l’opération de multiplication * , par
contre i est incrémenté après deux opérations : l’opération de multiplication de i par j incrémentée

5
de 1 et l’affectation du résultat de cette multiplication à la variable n. Ainsi avec les valeurs initiales
i=20 , j=5 on obtient les valeurs finale, j=5+1=6, n=20*(6)=120 ,et i=20+1=21.
i=15;n=i+=3; on peut écrire n=i+=3; sous une forme moins compacte n=i=i+3; ainsi i est affectée à n,
or la valeur de i est égale à i+3. On obtient à partir de la valeur initiale i=15 les valeurs finales
i=15+3=18 et n=18.
i=3;j=5;n=i*=--j; l’instruction n=i*=--j; peut être écrite sous la forme n=i=i*--j; la première opération
à faire est une décrémentation de j avant d’effectuer l’opération de multiplication *. Le résultat de la
multiplication est attribué à i avant d’affecter le contenu de i à n. donc en ayant initialement i=3 et
j=5 on obtient j=5-1=4, i=3*4=12 et n=12.

Exo 4 : quels résultats fourni le programme suivant :

Elément de réponse :
r=n==(p=q); : la première tache a faire est d’affecter q à p (p=q) ainsi p=10. Ensuite nous comparons n
à la nouvelle valeur de p, puisque n=10 et p=10 alors n==(p=q) est vrai. La valeur vrai en langage c’est
vaut 1. Ainsi r=1. En résultat nous avons n=10, q=10, p=10,r=1.
n=p=q=5; avec cette instruction q reçoit la valeur 5, p reçoit q et n reçoit p. ainsi q=5, p=5, et n=5.
n+=p+=q; cette instruction est équivalente à n=n+(p=p+q) ; on obtient ainsi n=n+(p=5+5) ce qui vaut
n=5+(p=10) ; ainsi q=5, p=10, n=5+10=15, r=0.

#include <stdio.h>
#include <stdlib.h>
int main()
{
int n=10,p=5,q=10,r;

// cas 1 :
r=n==(p=q);
printf("A: les valeurs des variables sont: n=%d, p=%d, q=%d, r=%d\n",n,p,q,r);

6
// cas 2 :
r=0;
n=p=q=5;
n+=p+=q;
printf("B: les valeurs des variables sont: n=%d, p=%d, q=%d, r=%d\n",n,p,q,r);

return 0;
}

Exo 5 : quels résultats fourni le programme suivant :

#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("l'affectation d'un caractere a un entier permet de connaitre le code ASCII du
caractere:\n\n");
int x,y;
char z='S',t='A';
printf("A: le caractere attribue a la variable z est: %c\n",z);
printf("B: le code ASCII correspondand au caractere attribue a la variable z est: %d\n",z);
printf("C: le caractere attribue a la variable t est: %c\n",t);
printf("D: le code ASCII correspondand au caractere attribue a la variable t est: %d\n",t);
// cas 1 :

7
x=z;
y=t;
printf("E: les valeurs des variables sont: x=%d, y=%d, z=%c, t=%c\n",x,y,z,t);
printf("F: les caracteres correspondant aux valeurs des deux entiers x et y sont respectivement: %c
et %c \n",x,y);
return 0;
}

Exo 6 : Remplacer les deux instructions scanf("%d",&x); et scanf("%d",&y); par l’istruction scanf("%d
%d",&x,&y); est-il correcte ? Réponse : oui.

Exo 7 : soit le programme suivant :

Quels résultats affiche le programme lorsqu’on lui fournit en donnée :


a) 0

b) 1

c) 2

d) 4

8
e) 10

f) -5

g) 5

#include <stdio.h>
#include <stdlib.h>
int main()
{
int n;
char Use_goto='n';
printf("Donner la valeur de n :");
scanf("%d",&n);
switch (n)
{
case 0 :printf("Nul\n");
case 1 :printf("proche de Nul\n");
case 2 :printf("petit\n"); break;
case 3 :printf("moyen\n");
case 4 :printf("grand\n");
case 5 :printf("tres grand\n");Use_goto='o';goto La_suite;
case 6 :printf("le max de tous l'interval de donnees\n");
default :printf("non mesurable\n");
}
printf("On est sortie du swith sans usage de l'instruction goto\n");
//une etiquette se fait avant l'instrcuction ou on veut se brancher
La_suite : if (Use_goto=='o')printf("On est sortie du swith grace a l'instruction goto\n");
return 0;
}

Exo 8 : quelles erreurs ont été commises dans chacun des groupes d’instruction suivants :

a)

Il manque un point virgule à la fin du premier printf. Correction :

9
b)

Les valeurs qui suivent le mot case doivent être obligatoirement des constantes, or n est une
variable.

c)

Aucune erreur car LIMITE est une constante, LIMITE-1 est une constante et LIMITE+1 est également
une constante.

Exo 9 : écrire un programme qui calcul la racine carrée d’un nombre fournis par l’utilisateur. Le
programme doit afficher « erreur » lorsque l’utilisateur fournit une valeur négative. Rappelons que la
fonction sqrt (dont la définition se trouve dans math.h) fournie la racine carrée (le résultat de la
racine carré est un double) lorsqu’on lui fournit en argument un double.

#include <stdio.h>
#include <stdlib.h>
#include <math.h> //ne surtous pas oublier #include <math.h>.
int main()
{
float x,y;

10
printf("Donner la valeur de x : ");
scanf("%f",&x); // attention x est un réel donc le format c'est %f
if (x<0) printf("erreur vous avez donner une valeur négative");
else {y=sqrt(x); printf("la racine de x est : %f",y);}
return 0;
}

Exo 10 : Ecrire un programme qui lit deux nombre X et Y, et permute leurs valeurs. Exemple : si X =
20, Y = 25, on doit avoir : X = 25 et Y = 20. Le programme doit proposer à l’utilisateur deux
alternatives de permutation : une permutation sans l’usage d’une variable intermédiaire (si
l’utilisateur tape 1) et une permutation avec l’utilisation d’une variable intermédiaire (si l’utilisateur
tape 2). Une contrainte supplémentaire est ajoutée au programme. Il faut exprimer le choix de la
technique de permutation de trois manières différentes :
a)- utilisation exclusif du goto et d’un if sans else (Si…Alors...FinSi).
b)-utilisation exclusif d’un if…else (Si…Alors...Sinon…..FinSi).
c)-utilisation exclusif du swith (le selon).

#include <stdio.h>
#include <stdlib.h>
int main()
{
int X,Y,Inter;

11
int choix;
do
{
printf("Taper 1 pour faire une permutation sans variable intermediaire\n");
printf("Taper 2 pour faire une permutation avec une variable intermediaire\n");
scanf("%d",&choix);
} while (choix!=1 && choix!=2);
printf("Donner la valeur de X : ");
scanf("%d",&X);
printf("Donner la valeur de Y : ");
scanf("%d",&Y);
if (choix==2)goto suite;
printf("Permutation sans variable intermediaire\n");
X = X - Y;
Y = X + Y;
X = Y - X;
goto fin;
suite : printf("Permutation avec variable intermediaire\n");
Inter=X;
X=Y;
Y=Inter;
fin : printf("La nouvelle valeur de X est %d \n", X);
printf("La nouvelle valeur de Y est %d \n", Y);
return 0;
}

12
#include <stdio.h>
#include <stdlib.h>
int main()
{
int X,Y,Inter,choix;
do
{
printf("Taper 1 pour faire une permutation sans variable intermediaire\n");
printf("Taper 2 pour faire une permutation avec une variable intermediaire\n");
scanf("%d",&choix); } while (choix!=1 && choix!=2);
printf("Donner la valeur de X : "); scanf("%d",&X);
printf("Donner la valeur de Y : "); scanf("%d",&Y);
if (choix==1)
{
printf("Permutation sans variable intermediaire\n");
X = X - Y;
Y = X + Y;
X = Y - X;
}
else
{
printf("Permutation avec variable intermediaire\n");
Inter=X;

13
X=Y;
Y=Inter;
}
printf("La nouvelle valeur de X est %d \n", X);
printf("La nouvelle valeur de Y est %d \n", Y);
return 0;
}

#include <stdio.h>
#include <stdlib.h>
int main()
{
int X,Y,Inter,choix;
printf("Taper 1 pour faire une permutation sans variable intermediaire\n");
printf("Taper 2 pour faire une permutation avec une variable intermediaire\n");

14
scanf("%d",&choix);
switch (choix)
{
case 1 :
{
printf("Donner la valeur de X : "); scanf("%d",&X);
printf("Donner la valeur de Y : "); scanf("%d",&Y);
printf("Permutation sans variable intermediaire\n");
X = X - Y;
Y = X + Y;
X = Y - X;
printf("La nouvelle valeur de X est %d \n", X);
printf("La nouvelle valeur de Y est %d \n", Y);
break;
}
case 2 :
{
printf("Donner la valeur de X : "); scanf("%d",&X);
printf("Donner la valeur de Y : "); scanf("%d",&Y);
printf("Permutation avec variable intermediaire\n");
Inter=X;
X=Y;
Y=Inter;
printf("La nouvelle valeur de X est %d \n", X);
printf("La nouvelle valeur de Y est %d \n", Y);
break;
}
default : printf("erreur : vous avez taper la mauvaise touche\n");
}
return 0;
}

15