Notions | Exercices 1-5

Enoncé exercice 1

Ecrire un programme C qui permet d’afficher le message suivant: Bonjour.

Correction exercice 1

La première chose avec laquelle doit commencer ce programme sera la définition des directives du préprocesseur (lignes 1-2), ce qui revient à indiquer les bibliothèques nécessaires au fonctionnement des fonctions du programme.

Pour cet exercice on n’aura besoin que des deux bibliothèques stdio.h et stdlib.h. La première bibliothèque va permettre de faire marcher la fonction d’affichage printf, et la deuxième est invoquée pour pouvoir utiliser l’instruction system(“pause”) (ligne 6), qui permettra de bloquer la console d’exécution pour pouvoir prendre le temps nécessaire pour la visualisation du message affiché. Il faudra essayer d’enlever cette instruction pour sentir son effet, même si elle n’est plus nécessaire pour quelques IDE (éditeurs) qui maintiennent la console automatiquement après l’exécution de toutes les instructions du programme.)

A l’intérieur de la fonction main et à l’aide de printf (ligne 5) on va afficher le message Bonjour, suivi du caractère \n. Ce dernier va permettre de faire un retour à la ligne juste après l’affichage de Bonjour.

Finalement et en ce qui concerne l’instruction return 0 (ligne 7) il faut juste pour l’instant prendre l’habitude de la mettre à la fin du programme chaque fois qu’on utilise int main, et elle ne sera pas nécessaire dans le cas où on n’utilise que le main sans mentionner le int.

Solution exercice 1

#include<stdio.h>
#include<stdlib.h>
int main()
{
       printf("Bonjour\n");
       system("pause");
       return 0;
}

Enoncé exercice 2

Ecrire un programme C qui permet de lire en entrée un entier constitué de trois chiffres et d’afficher celui-ci inversé. Exemple: si l’entrée est 123 on affiche 321.

Correction exercice 2

Tout d’abord on va commencer par la déclaration des variables dont on aura besoin dans ce programme (ligne 5). La déclaration des variables en C se fait obligatoirement au début du programme juste après le int main. Trois variables de type int seront largement suffisantes pour réaliser ce programme :

• La variable a : cette variable va contenir le nombre entré par l’utilisateur.

• La variable c : celle-ci va contenir elle aussi l’entier entré, afin de le conserver pour l’affichage final, puisque le contenu de la variable a sera altéré comme on le verra plus tard.
• La variable b : va abriter le nombre inversé.

Après la déclaration des variables, on affiche à l’aide de la fonction printf un message où on demande à l’utilisateur d’entrer un entier composé de trois chiffres (ligne 6). Et avec la fonction scanf définie dans la bibliothèque stdio.h on va lire ce dernier vers la variable entière a. Pour ce faire, on utilisera le format %d réservé au type int (ligne 7).

Avant de se lancer dans l’inversion du nombre contenu dans la variable a, on va conserver la valeur initiale de a dans la variable c via une simple opération d’affectation (ligne 8).

Pour inverser l’entier a on doit pouvoir accéder à ses différents chiffres un par un. Ceci est possible grâce aux deux opérateurs % et /.

La quantité a%10 (ligne 9) représente le chiffre des unités de a. Ex: 234%10 = 4. A titre de rappel l’opérateur % appelé modulo représente le reste de la division entière de la première opérande sur la deuxième. En multipliant maintenant le chiffre des unités ainsi obtenu par cent, on le fera alors passer à la 3^ème position. Ex: b = (234%10)*100 = 4*100 = 400.

En suivant la même approche, on pourra constituer le deuxième chiffre du nombre inversé. Mais tout d’abord il faudra accéder au deuxième chiffre de a.

Le chiffre des unités de a n’étant plus utile, on peut s’en débarrasser en divisant a par dix (ligne 10). Ex: 234/10 = 23. A ce stade on peut récupérer le nouveau chiffre des unités de a qu’on doit multiplier ensuite par dix pour le faire passer à la deuxième position. Ex: (23%10)*10 = 3*10 = 30.

Ce qu’il faut faire maintenant, est de faire la somme des deux nombres obtenus dans ces deux premières étapes pour constituer le chiffre des centaines et celui des dizaines de b. Ex: 400+30 = 430. Il faut noter que dans le code, l’obtention du chiffre des dizaines et l’addition sont faites dans une seule instruction (ligne 11).

La constitution du chiffre des unités de b se basera sur les mêmes principes précédents (lignes 12-13).

Reste à signaler que a/=10 et b+=a sont des manières abrégées d’écrire a=a/10 et b=b+a.

Finalement et lors de l’affichage, la variable c qui représente le nombre lu en entrée sera affichée à la place du premier %d de la fonction printf et le second %d sera substitué par la valeur de b (ligne 14).

Solution exercice 2

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int a,b,c;
    printf("donnez un entier de 3 chiffres\n");
    scanf("%d",&a);
    c=a;
    b=(a%10)*100;
    a=a/10;
    b=b+(a%10)*10;
    a/=10;
    b+=a;
    printf("le nombre %d inverse est %d\n",c,b);
    system("pause");
    return 0;
}

Enoncé exercice 3

Ecrire un programme C qui permet de lire deux nombres réels, et d’afficher ensuite leur produit, avec une précision de trois chiffres après la virgule.

Correction exercice 3

Dans cet exercice on veut écrire un programme qui calcule le produit de deux réels. La première chose à faire est la déclaration des variables dont on aura besoin. Trois variables x, y et p seront donc déclarées de type float (ligne 5). Un message ensuite est affiché à travers la fonction printf demandant à l’utilisateur de saisir les deux nombres (ligne 6). Ces deux réels vont être lus vers les deux variables x et y à l’aide de la fonction scanf (ligne 7). Et on peut remarquer par cette occasion l’indication du %f , qui représente le format dédié au type float.

Par la suite, on affecte à la variable p la valeur du produit de x et y, calculé en utilisant l’opérateur * (ligne 8).

Pour afficher le résultat, un %.3f est utilisé avec la fonction printf , et qui impose d’afficher le contenu de la variable de type float correspondante, qui est ici p, avec une précision de 3 chiffres après la virgule (ligne 9). Il est à signaler qu’une opération d’arrondi peut avoir lieu, donc à la place de 3,2348 on aura 3,235.

Solution exercice 3

#include<stdio.h>
#include<stdlib.h>
int main()
{
    float x,y,p;
    printf("Entrez deux reels:\n");
    scanf("%f%f",&x,&y);
    p=x*y;
    printf("le produit de %f et %f est: %.3f\n",x,y,p);
    system("pause");
    return 0;
}

Enoncé exercice 4

Ecrire un programme C qui permet de permuter le contenu de deux variables entières en passant par une troisième variable auxiliaire. Ceci et en affichant les deux variables avant et après permutation.

Correction exercice 4

Permuter le contenu de deux variables en utilisant une variable auxiliaire est similaire au fait d’interchanger les contenus de deux verres, un rempli d’eau et l’autre avec de l’huile. Il est évident qu’il faut passer par un troisième verre vide.

Soient a et b les deux variables dont on veut inverser le contenu. Et soit tmp la variable auxiliaire qui va aider à faire ceci. Cette dernière variable joue le rôle du verre vide dans l’analogie précédente.

La déclaration des variables et la lecture des entrées doit pour l’instant être à la portée. Donc on ne va s’intéresser qu’à la partie essentielle du programme, à savoir celle qui effectue la permutation (lignes 9-11). Et on va travailler sur l’exemple suivant pour bien en comprendre le fonctionnement:

Soit a = 12 et b = 34 les valeurs entrées par l’utilisateur. On commence par sauvegarde le contenu de la variable a dans tmp (ligne 9). Le statut des trois variables est alors: tmp = 12, a = 12 et b = 34.

La deuxième étape consiste à mettre le contenu de la variable b dans a (ligne 10). Le statut des variables à ce stade devient: tmp = 12 , a = 34 et b = 34. Et c’est là que le rôle de la variable auxiliaire tmp devient important, puisque sans elle la valeur initiale de a sera perdue.

La troisième et dernière étape consiste à récupérer le contenu de tmp dans b (ligne 11). Le statut final des variables est donc: tmp = 12, a = 34 et b = 12. Et il est claire qu’on a bien réussi à permuter les contenus des deux variables a et b.

Pour s’assurer de la réussite de la tâche, les deux variables a et b ont été affichées avant la permutation (ligne 8) et puis après la permutation (ligne 12).

Solution exercice 4

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int a,b,tmp;
    printf("Entrez deux entiers a et b:\n");
    scanf("%d%d",&a,&b);
    printf("Avant permutation: a = %d et b = %d.\n",a,b);
    tmp=a;
    a=b;
    b=tmp;
    printf("Apres permutation: a = %d et b = %d.\n",a,b);
    system("pause");
    return 0;
}

Enoncé exercice 5

Ecrire un programme C qui lit en entrée trois entiers et affiche leur moyenne avec une précision de deux chiffres après la virgule.

Correction exercice 5

On commence, comme toujours, par la déclaration des variables dont on aura besoin dans le programme. Dans ce cas-ci trois variables a, b et c de type int pour représenter les entrées de l’utilisateur et une quatrième moy de type float sont tout ce dont on va se servir.

Tout juste après la déclaration des variables vient la lecture des trois entiers à l’aide de la fonction scanf (ligne 8).

Une fois ces préparatifs sont achevés, il sera temps de passer au calcul de la moyenne. Mais avant ça, il faudra distinguer entre deux notions primordiales pour la réussite du programme et qui sont la division entière et la division réelle du langage C.

La division entière : c’est lorsque les deux quantités intervenantes dans la division sont de type int. Le résultat dans ce cas est la partie entière du quotient, c’est-à-dire la partie du côté gauche de la virgule. Par exemple, la division entière de 3 par 2 donne 1 et celle de 1 par 2 donne 0.

La division réelle : c’est lorsque l’une des deux opérandes au moins est de type float. Le résultat alors est le quotient habituel avec des chiffres après la virgule. Par exemple, la division réelle de 3.0 par 2 donne 1.5 et celle de 1.0 par 2 donne 0.5.

Ceci dit, pour calculer la moyenne des trois entiers a, b et c, si on fait: moy = (a+b+c)/3 on sera alors en présence d’une division entière, puisque a+b+c et 3 sont des quantités entières. Donc la moyenne obtenue par cette expression sera erronée.

La solution pour obtenir une division réelle sera de convertir une des deux opérandes en une quantité réelle. Il y’a deux méthode pour faire ça. La plus simple d’entre elles est d’utiliser 3.0 au lieu de 3, puisqu’en langage C 3.0 est une constante réelle. La deuxième méthode par contre, est plus instructive et c’est elle qui sera adoptée ici.

Dans ce programme on va utiliser une technique qui s’appelle la conversion de type ou le cast. Cette opération permet d’utiliser une variable ou une expression de type donné comme étant d’un type autre que le sien.

Ce qu’on veut ici, est de pouvoir utiliser la somme a+b+c comme un float, donc par le biais de la conversion de type on peut tout simplement écrire (float)(a+b+c) au lieu de (a+b+c) dans l’expression de la moyenne et ça va régler l’affaire (ligne 9).

Une fois la moyenne est calculée on va afficher la variable réelle moy à l’aide de la fonction printf en utilisant le format %.2f qui indique à la fonction printf que la variable moy doit être affichée en se limitant seulement aux deux chiffres après la virgule (ligne 9) .

Solution exercice 5

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int a,b,c;
    float moy;
    printf("Donnez 3 entiers:\n");
    scanf("%d%d%d",&a,&b,&c);
    moy=(float)(a+b+c)/3;
    printf("La moyenne de ces trois entiers est: %.2f\n",moy);
    system("pause");
    return 0;
}