Se familiariser avec l`environnement de programmation Dev-C++

1/6
Département de Mathématiques et Informatique Filière : SMP et SMC S4
FSO, UMP, Oujda Année : 2015 / 2016
Filières SMP (Sections A et B) et SMC S4 TP : Programmation en Langage C
- CORRIGE DES SERIES DE TP-
Séance 4 :
Exercice 1 :
1. Ecrire un algorithme qui lit trois entiers, qui calcule leur minimum. L’algorithme
affiche les trois variables ainsi que la valeur minimale. Pour réaliser cet algorithme, on
va utiliser une variable appelée m de type entier.
2. Traduire cet algorithme en un programme C.
****************
** Solution **
****************
Question 1. : Algorithme
Algorithme Minimum3Var
Début /* Début de l’algorithme */
/* Déclaration des variables */
Variable x, y, z : Entier;
Variable m : Entier;
/* Lecture à partir du clavier des trois variables x, y et z */
Afficher Entrez respectivement les variables x, y, z (toutes de type entier)  ;
Lire x ;
Lire y ;
Lire z ;
/* Calcul de m par affectation initiale et comparaisons successives */
m  x; // On suppose que le minimum est x.
si y > m alors m  y finsi; // Le nouveau minimum devient y.
si z > m alors m  z finsi; // Le nouveau minimum devient z.
/* Affichage */
Afficher x : , Afficher x ; Afficher <<SAUT DE LIGNE>> ;
Afficher y : , Afficher y ; Afficher <<SAUT DE LIGNE>> ;
Afficher z : , Afficher z ; Afficher <<SAUT DE LIGNE>> ;
Afficher Le minimum est :  ; Afficher m ; Afficher <<SAUT DE LIGNE>> ;
Fin /* Fin de l’algorithme */
Question 2. : Traduction en langage C
Programme Minimum3Var.c
#include <stdio.h>
main( ) {
// Déclaration des variables
int x, y, z ; // Variable qui représentent les données
int m ; // Variable qui représente le minimum
// Lecture des trois variables x, y et z
printf(Entrez respectivement les variables x, y, z (toutes de type entier):\n) ;
scanf(%d%d%d ,&x, &y, &z) ;

2/6
// Calcul de m par affectation initiale et comparaisons successives
m = x;
if (y<m) m=y ;
if(z<m) m=z ;
// Affichage
printf( \n ) ;
printf(x : %d\n, x ) ;
printf(y : %d\n, y ) ;
printf(z : %d\n, z ) ;
printf(Le minimum est : %d\n, m ) ;
getch();
}
Voici le résultat affiché par la fenêtre d’exécution.
Exercice 2 :
1. Ecrire un algorithme qui :
a. Déclare un tableau appelé T de 10 entiers,
b. Initialise les éléments de T avec les valeurs suivantes (dans cet ordre) en
utilisant une boucle : 0,10,20,30,40,50,60,70,80,90.
c. Effectuer l’affectation suivante : T[6] = -17 ;
d. Affiche les éléments du tableau séparés par des tabulations (c.à.d. ‘\t’) en
utilisant une boucle.
e. L’algorithme calcule la valeur minimale et l’affiche.
NB. Pour réaliser cet algorithme, on va utiliser une variable appelée m de type
entier.
2. Traduire cet algorithme en un programme C.
****************
** Solution **
****************
Question 1. : Algorithme
Algorithme Min10Tab
Début /* Début de l’algorithme */
/* Déclaration du tableau et des variables*/
T[10] : Entier; // Tableau de 10 entiers
int m : Entier; // Variable qui va contenir le minimum
int i : Entier ; // Variable pour indicer les éléments du tableau
/* Initialisation du tableau T avec une boucle */
pour i=0 à 9 pas 1 faire
DébutPour
T[i]  i*10 ; // Calcul et affectation en même temps
FinPour ;
T[6] = -17 ;
/* Affichage du tableau T avec une boucle */
Afficher Tableau T :,
Afficher <<SAUT DE LIGNE>>
pour i=0 à 9 pas 1 faire
DébutPour
Afficher T[i];

3/6
Afficher <<TABULATION>>
FinPour ;
Afficher <<SAUT DE LIGNE>>
/* Calcul du minimum */
m  T[0]; // On suppose que le minimum est le premier élément du tableau.
pour i=1 à 9 pas 1 faire
DébutPour
si T[i] < m alors
m  T[i] ; // Le minimum reçoit une nouvelle valeur
finsi
FinPour
/* Affichage du minimum*/
Afficher Le minimum est : , Afficher m
Fin /* Fin de l’algorithme */
Question 2. : Traduction en langage C
Programme Mini10Tab.c
#include <stdio.h>
main( ) {
// Déclaration des variables
int T[10] ; // Déclaration du tableau
int m ; // Variable qui représente le minimum
int i; // Variable indice
// Remplissage initial du tableau avec une boucle for
for(i=0;i<10;i++)
T[i]=i*10;
// Affectation de la valeur -17 au 7ème élément du tableau
T[6] = -17;
// Affichage du tableau
printf("Affichage du tableau T :\n");
for(i=0;i<10;i++)
printf("%d\t",T[i]);
// Calcul du minimum du tableau
m = T[0];
for(i=1;i<10;i++)
if (T[i]<m) m=T[i];
// Quand on sort de la boucle, on est sûr
// que m est la valeur minimale
// Affichage du minimum du tableau T
printf("\nLe minimum est : %d\n" , m ) ;
getch();
}
----------------------------------------------------------------------------------------------------------------------------------------
Voici le résultat affiché par la fenêtre d’exécution.
Exercice 3 :
Ecrire une fonction min( ) qui reçoit trois paramètres de type entier, qui calcule leur minimum
et renvoi cet entier comme valeur de retour. Effectuer un appel à la fonction min( ) dans la
fonction main(), avec des valeurs qui sont lues au clavier.
1. Ecrire l’algorithme
2. Ecrire la traduction en C

4/6
****************
** Solution **
****************
Question 1. : Algorithme
Algorithme Minimum3Fonct
Début /* Début de l’algorithme */
/* Définition de la fonction min( ) */
Fonction min(Entier x, Entier y, Entier z) : Entier /* La fonction possède 3 paramètres entiers */
/* Elle retourne une valeur entière */
{ /* Début du bloc de la fonction min( ) */
Variable A : Entier; /* Variable qui va représenter le minimum à calculer */
/* Calcul de A par affectation initiale et comparaisons successives */
A  x; // On suppose que le minimum est x.
si y > A alors A  y finsi; // Le nouveau minimum devient y.
si z > A alors A  z finsi; // Le nouveau minimum devient z.
/* Retourner le résultat de la fonction */
Retourner A ;
} /* Fin du bloc de la fonction min( )*/
/* Fin de définition de la fonction min( ) */
/* Définition du bloc principal de l’algorithme */
/* Déclaration des variables */
Variable x, y, z : Entier;
Variable m : Entier;
/* Lecture à partir du clavier des trois variables x, y et z */
Afficher Entrez respectivement les variables x, y, z (toutes de type entier)  ;
Lire x ;
Lire y ;
Lire z ;
/* Calcul de m par appel à la fonction min( ) */
m  min(x,y,z);
/* Affichage */
Afficher x : , Afficher x ; Afficher <<SAUT DE LIGNE>> ;
Afficher y : , Afficher y ; Afficher <<SAUT DE LIGNE>> ;
Afficher z : , Afficher z ; Afficher <<SAUT DE LIGNE>> ;
Afficher Le minimum est :  ; Afficher m ; Afficher <<SAUT DE LIGNE>> ;
Fin /* Fin de l’algorithme */
Question 2. : Traduction en langage C
Programme Minimum3Fonct.c
#include <stdio.h>
int min(int x, int y, int z)
{
int A;
A = x;
if (y<A) A=y;
if (z<A) A=z;
return A;
}
main( ) {
// Déclaration des variables
int x, y, z ; // Déclaration des variables
int m ; // Variable qui représente le minimum
// Lecture des variables
printf("S.V.P, entrez 3 entiers x, y et z :\n");
scanf("%d%d%d",&x,&y,&z);
// Calcul du minimum par appel à la fonction min()
// et affectation du résultat à la variable m

5/6
m = min(x,y,z);
// Affichage des trois variables
printf("\nx : %d\ty :%d\tz :%d\n",x,y,z);
printf("\nLe minimum est : %d\n",m) ;
getch();
}
Voici le résultat affiché par la fenêtre d’exécution.
Exercice 4 :
Ecrire une fonction somme( ) qui lit deux valeurs entières, qui calcule leur somme et renvoie
cette somme comme valeur de retour. Effectuer un appel à cette fonction dans la fonction
main(), avec des valeurs qui sont lues au clavier.
1. Ecrire l’algorithme
2. Ecrire la traduction en C
****************
** Solution **
****************
Question 1. : Algorithme
Algorithme Somme2Fonct
Début /* Début de l’algorithme */
/* Définition de la fonction somme( ) */
Fonction somme(Entier x, Entier y) : Entier /* La fonction possède 2 paramètres entiers */
/* Elle retourne une valeur entière */
{ /* Début du bloc de la fonction somme( ) */
Variable SOM : Entier; /* Variable qui va représenter la somme à calculer */
/* Calcul de la valeur de l variable SOM par simple addition */
SOM  x + y ;
/* Retourner le résultat de la fonction */
Retourner SOM ;
} /* Fin du bloc de la fonction somme( )*/
/* Fin de définition de la fonction somme( ) */
/* Définition du bloc principal de l’algorithme */
/* Déclaration des variables */
Variable x, y : Entier;
Variable S : Entier;
/* Lecture à partir du clavier des deux variables x et y */
Afficher Entrez respectivement les variables x et y (de type entier)  ;
Lire x ;
Lire y ;
/* Calcul de m par appel à la fonction min( ) */
S  somme(x,y);
/* Affichage des variables lues et du résultat*/
Afficher x : , Afficher x ; Afficher <<SAUT DE LIGNE>> ;
Afficher y : , Afficher y ; Afficher <<SAUT DE LIGNE>> ;
Afficher La somme est :  ; Afficher S ;
Fin /* Fin de l’algorithme */
Question 2. : Traduction en langage C
Programme Somme2Fonct.c
#include <stdio.h>