Exercices corrigés en Langage C : TP5

Exercices corrigés en Langage C :

Exercice 1 : 

Réécrire la fonction longueur (strln dans string.h) qui calcul la longueur d’une chaîne de caractères.
Prototype : int longueur(char *)

Correction exercice 1 :

int longueur(char *chaine) 
{ 
int i=0 ; 

 while(chaine[i] != ‘\0’) 
i++ ; 
return i ; 
} 

Exercice 2 : 

En utilisant la précédence lexicographique écrire une fonction qui convertie les chaînes de
caractères minuscules en chaînes de caractères majuscules.
Prototype : void majuscule(char *)

Correction exercice 2 :

#include<stdio.h> 
void majuscule(char *) ; 
main() 
{ 
 char chaine[] = "Ceci est une chaine !" ; 
  majuscule(chaine) ; 

 printf("%s\n",chaine) ; 
} 
void majuscule(char *chaine) 
{ 

 int i=0; 

 while(chaine[i] != '\0') 
{ 
if ((chaine[i] >= 'a') && (chaine[i] <= 'z')) 
chaine[i] += (int)'A' - (int)'a' ; 
i++ ; 
} 
} 

Exercice 3 :

Ecrire un programme qui lit deux chaînes de caractères, et qui indique leur précédence
lexicographique dans le code de caractères de la machine (ici: code ASCII). On écrira pour cela la
fonction precedence qui récupère les deux chaînes en paramètre et qui retourne 1 si la première
chaîne précède la deuxième, 2 si la deuxième précède la première, 0 si elle sont égale.
Prototype : int precedence(char *,char *)

Correction exercice 3 :

#include <stdio.h> 
int precedence(char *,char *) ; 
main() 
{ 

 /* Déclarations */ 
char CH1[50], CH2[50]; /* chaînes à comparer */ 
int r ; 

/* Saisie des données */

 printf("Entrez la première chaîne à comparer : "); 
gets(CH1); 
printf("Entrez la deuxième chaîne à comparer : "); 
gets(CH2); 
r = precedence (CH1,CH2) ; 
if(r==0) 
printf("\"%s\" est égal à \"%s\"\n", CH1, CH2); 
else if (r == 1) 
printf("\"%s\" précède \"%s\"\n", CH1, CH2); 
else 
printf("\"%s\" précède \"%s\"\n", CH2, CH1); 
} 
int precedence (char *CH1,char *CH2) 
{ 
int I; /* indice courant */ 
int r ; 

for (I=0; (CH1[I]==CH2[I]) && CH1[I] && CH2[I]; I++) ; 

if (CH1[I]==CH2[I]) 

r = 0 ; 
else if (CH1[I]<CH2[I]) 
r = 1 ; 
else 
r = 2 ; 
return r; 
} 

Exercice 4 : 

Ecrire une procédure qui lit une chaîne de caractères et l'interprète comme un entier positif dans la
base décimale. On écrira 2 fonctions :
La fonction chaine2entier qui récupère une chaîne de caractère et retourne un entier.
Prototype : int chaine2entier(char *)
La fonction estentier qui récupère un caractère et retourne 0 s’il ne correspond pas à un chiffre 1
s’il correspond à un chiffre.
Prototype : int estentier(char) ;

Correction exercice 4 :

#include<stdio.h> 
int estentier(char) ; 
int chaine2entier(char *) ; 

 main() 
{ 
 /* Déclarations */ 
char CH[100]; /* chaîne numérique à convertir */ 
long N; /* résultat numérique */ 

printf("Entrez un nombre entier et positif : "); 
gets(CH); 
printf("%s\n",CH) ; 

N = chaine2entier(CH) ; 
if(N<0) 
printf("%s ne représente pas correctement un entier positif.\n", CH); 
else 
printf("La chaine %s a pour valeur %d\n" ,CH,N) ; 
} 
 int chaine2entier(char *CH) 
{ 
int I; 
int N = 0 ; 
int OK = 1; 

for (I=0; OK && CH[I]; I++) 
if (estentier(CH[I])) 
N = N*10 + (CH[I]-'0'); 
else 
OK=0; 
if (OK) 
return N ; 
else 
return -1 ; 
} 

int estentier(char c) 
{ 
if ((c>='0')&&(c<='9')) 
return 1 ; 
else 
return 0 ; 
} 

Read More

Exercices corrigés en Langage C : TP4

Exercices corrigés en Langage C :

Exercice 1 : 

Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du type int
(dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des valeurs entrées au
clavier et afficher le tableau ainsi que la somme de tous ses éléments.
Pour cela on écrira les fonctions suivantes :

void RemplirTableau(void)
void AfficherTableau(void)

Correction exercice 1 :

#include <stdio.h> 
void RemplirTableau(void) ; 
void AfficherTableau(void) ; 

 int T[50][50]; /* tableau donné */ 
int L, C; /* dimensions */ 

main() 
{ 
/* Déclarations */ 
long SOM; /* somme des éléments - type long */ 

/* Saisie des données */ 
printf("Nombre de lignes (max.50) : "); 
scanf("%d", &L ); 
printf("Nombre de colonnes (max.50) : "); 
scanf("%d", &C );

 RemplirTableau() ; 

 AfficherTableau() ; 

 /* Calcul de la somme */ 

for (SOM=0, I=0; I<L; I++) 
for (J=0; J<C; J++) 
SOM += T[I][J]; 

/* Edition du résultat */ 
printf("Somme des éléments : %ld\n", SOM); 
return 0; 
} 

void RemplirTableau(void) 
{ 
int i,j ; 

for (i=0; i<L; i++) 
for (j=0; j<C; j++) 
{ 
 printf("Elément[%d][%d] : ",i,j); 
 scanf("%d", &T[i][j]); 
} 
} 

void AfficherTableau(void) 
{ 
int i,j ; 

printf("Tableau donné :\n"); 
for (i=0; i<L; i++) 
{ 
 for (j=0; j<C; j++) 
printf("%d\t", T[i][j]); 
printf("\n"); 
} 
} 

Exercice 2 : 

Ecrire un programme qui réalise l'addition de deux matrices A et B de même dimension N x M (N
et M sont saisies au clavier).

rappel :

| a | b | + | a’ | b’ | = | a + a’ | b + b’ |
| c | d |   | c’ | d’ |   | c + c‘ | d + d’ |

Correction exercice 2 :

#include <stdio.h> 
main() 
{ 

 /* Déclarations */ 
int A[50][50]; /* matrice donnée */ 
int B[50][50]; /* matrice donnée */ 
int C[50][50]; /* matrice résultat */ 
int N, M; /* dimensions des matrices */ 
int I, J; /* indices courants */ 

/* Saisie des données */ 
printf("Nombre de lignes (max.50) : "); 
scanf("%d", &N ); 

printf("Nombre de colonnes (max.50) : "); 
scanf("%d", &M ); 
printf("*** Matrice A ***\n"); 
for (I=0; I<N; I++) 

for (J=0; J<M; J++) 
{ 
printf("Elément[%d][%d] : ",I,J); 
scanf("%d", &A[I][J]); 
} 
printf("*** Matrice B ***\n"); 
for (I=0; I<N; I++) 
for (J=0; J<M; J++) 
{ 
printf("Elément[%d][%d] : ",I,J); 
scanf("%d", &B[I][J]); 
} 
 /* Affichage des matrices */ 
printf("Matrice donnée A :\n"); 
for (I=0; I<N; I++) 
{ 
for (J=0; J<M; J++) 
printf("%7d", A[I][J]); 
printf("\n"); 
} 
printf("Matrice donnée B :\n"); 
for (I=0; I<N; I++) 
{ 
for (J=0; J<M; J++) 
printf("%7d", B[I][J]); 
printf("\n"); 
} 
 /* Affectation du résultat de l'addition à C */ 
for (I=0; I<N; I++) 
for (J=0; J<M; J++) 
C[I][J] = A[I][J]+B[I][J]; 

/* Edition du résultat */ 
printf("Matrice résultat C :\n"); 
for (I=0; I<N; I++) 
{ 
for (J=0; J<M; J++) 
printf("%7d", C[I][J]); 
printf("\n"); 
} 
return 0; 
} 

Exercice 3 : 

Ecrire un programme qui réalise le produit de deux matrices carrées de même dimension.

rappel :

| a | b | * | a’ | b’ | = | a*a’ + b*c’ | a*b’ + b*d’ |
| c | d |   | c’ | d’ |   | c*a’ + d*c‘ | c*b’ + d*d’ |


Correction exercice 3 :

#include <stdio.h> 
main() 
{ 
 /* Déclarations */ 
int A[50][50]; /* matrice donnée */ 
int B[50][50]; /* matrice donnée */ 
int C[50][50]; /* matrice résultat */ 
int N ; /* dimension des matrices (les matrices sont carrées)*/ 
int i,j,k; /* indices courants */ 

/* Saisie des données */ 
printf("Nombre de lignes et de colonnes (max.50) : "); 
scanf("%d", &N ); 

printf("*** Matrice A ***\n"); 

for (i=0; i<N; i++) 
for (j=0; j<N; j++) 
{ 


printf("Elément[%d][%d] : ",i,j); 
scanf("%d", &A[i][j]); 

} 
printf("*** Matrice B ***\n"); 
for (i=0; i<N; i++) 


for (j=0; j<N; j++) 

{ 
printf("Elément[%d][%d] : ",i,j); 
scanf("%d", &B[i][j]); 

} 

 /* Affichage des matrices */ 
printf("Matrice donnée A :\n"); 
for (i=0; i<N; i++) 
{ 

for (j=0; j<N; j++) 
printf("%7d", A[i][j]); 

printf("\n"); 
} 
printf("Matrice donnée B :\n"); 
for (i=0; i<N; i++) 
{ 


for (j=0; j<N; j++) 
printf("%7d", B[i][j]); 
printf("\n"); 
} 


 /* Affectation du résultat du produit à C */ 
for (i=0; i<N; i++) 
for (j=0; j<N; j++) 
{ 

C[i][j] = 0 ; 
for(k = 0 ; k<N ; k++) 
C[i][j] += A[i][k]*B[k][j]; 
} 


/* Edition du résultat */ 
printf("Matrice résultat C :\n"); 
for (i=0; i<N; i++) 
{ 

for (j=0; j<N; j++) 
printf("%7d", C[i][j]); 
printf("\n"); 
} 
} 

Read More

Exercices corrigés en Langage C : TP3

Exercices corrigés en Langage C :

Exercice 1 :

Ecrire un programme qui saisit la dimension N d’un tableau de int (le tableau est initialement
définit avec une taille maximum MAX que N ne doit pas excéder) remplit le tableau par des valeurs
entrées au clavier et l’affiche.

Le programme doit ensuite effacer toutes les occurrences de la valeur 0 dans le tableau, tasser les
éléments restants et afficher le tableau ainsi modifier.

Pour cela écrire les fonctions suivantes :

void SaisirTableau (int *Tab, int N) ;
void AfficherTableau(int *Tab, int N) ;
int TasserTableau(int *Tab , int N) ;

Correction exercice 1 :

#include <stdio.h> 
#define MAX 50 
void SaisirTableau(int *, int ) ; 
void AfficherTableau(int *, int) ; 
int TasserTableau(int *, int) ; 
main() 
{ 
 /* Déclarations */ 
int T[MAX]; /* tableau donné */ 
int N,M; /* dimension */ 

/* Saisie de la dimension */ 
do 
{ 
printf("Dimension du tableau (max.%d) : ",MAX); 
scanf("%d", &N ); 
}while(N>MAX) ; 

/* Saisie des données */ 
SaisirTableau(T,N) ; 

 /* Affichage du tableau */ 
AfficherTableau(T,N) ; 

/*Tasser les elements du tableau */ 
M = TasserTableau(T,N) ; 

/* Edition des résultats */ 

AfficherTableau(T ,M) ; 
} 

void SaisirTableau(int *Tab, int N) 
{ 
int i ; 

for (i=0; i<N; i++) 
{ 
printf("Elément %d : ", i); 
scanf("%d", &Tab[i]); 
} 
} 

void AfficherTableau(int *Tab, int N) 

{ 
int i ; 
printf("Tableau donné : \n"); 
for (i=0; i<N; i++)

 printf("%d ", Tab[i]); 
printf("\n"); 
} 

int TasserTableau(int * Tab, int N) 
{ 
int i,j ; 

/* Effacer les zéros et comprimer : */ 
/* Copier tous les éléments de i vers j et */ 
/* augmenter j pour les éléments non nuls. */ 

for (i=0, j=0 ; i<N ; i++) 
{ 
Tab[j] = Tab[i] ; 
if (Tab[i]) 
j++ ; 
} 
 /* La nouvelle dimension du tableau est retournée */ 
return j ; 
} 

Exercice 2 :

Ecrire un programme qui saisit la dimension N d’un tableau de int remplit le tableau par des
valeurs entrées au clavier et l’affiche.

Copier ensuite toutes les composantes strictement positives dans un deuxième tableau Tpos et
toutes les valeurs strictement négatives dans un tableau Tneg. Afficher Tpos et Tneg.

Ecrire la fonction suivante :

int TrierTableau(int *, int *, int *,int)

Correction exercice 2 :

#include <stdio.h> 
#define MAX 50 
main() 
{ 
 /* Déclarations */

 /* Les tableaux et leurs dimensions */ 
int T[MAX], TPOS[MAX], TNEG[MAX]; 
int N,M, Npos, NNEG; 
int I; /* indice courant */ 

/* Saisie de la dimension */ 
do 
{ 
printf("Dimension du tableau (max.%d) : ",MAX); 
scanf("%d", &N ); 

}while(N>MAX) ; 

/* Saisie des données */ 

SaisirTableau(T,N) ; 

 /* Affichage du tableau */ 
AfficherTableau(T,N) ; 

/*Tasser les elements du tableau */ 
M = TasserTableau(T,N) ; 

/* Trier le tableau */ 
Npos = TrierTableau(T,TPOS,TNEG,M) ; 

/* Edition des resultats */ 
printf(”Elements positifs : \n”) ; 
AfficherTableau(TPOS,Npos) ; 
printf(”Elements négatifs : \n”) ; 
AfficherTableau(TNEG,N-Npos) ; 

} 
int TrierTableau(int *T, int *TPOS, int *TNEG, int N) 
{ 

 int npos=0, nneg=0; 
int i ; 


 /* Transfert des données */ 

for (i=0; i<N; i++) 
{ 
if (T[i]>0) 
{ 
TPOS[npos]=T[i]; 
npos++; 
} 
if (T[i]<0) 
{ 
TNEG[nneg]=T[i]; 
nneg++; 
} 
} 
return npos ; 
} 

Exercice 3 :

Ecrire un programme qui calcul le produit scalaire de deux vecteurs d’entiers U et V de même
dimension.

Ecrire la fonction suivante :

long ProduitScalaire(int *U,int *V, int dimension)

Correction exercice 3 :

#include <stdio.h> 
#define MAX 50 
long ProduitScalaire(int *,int *, int) ; 
main() 
{ 
 /* Déclarations */ 
int U[MAX], V[MAX]; /* tableaux donnés */ 
int N; /* dimension */ 
int I; /* indice courant */ 
long PS; /* produit scalaire */ 

/* Saisie des données */ 
do 
{ 
printf("Dimension du tableau (max.%d) : ",MAX); 
scanf("%d", &N ); 
}while(N>MAX) ; 
printf("** Premier tableau **\n"); 
for (I=0; I<N; I++) 
{ 
 printf("Elément %d : ", I); 

 scanf("%d", &U[I]); 
} 
printf("** Deuxième tableau **\n"); 
for (I=0; I<N; I++) 
{ 
 printf("Elément %d : ", I); 
 scanf("%d", &V[I]); 
} 

 /* Calcul du produit scalaire */ 

PS = ProduitScalaire(U,V,N) ; 

/* Edition du résultat */ 
printf("Produit scalaire : %ld\n", PS); 
} 

long ProduitScalaire(int *U, int *V,int N) 

{ 
long ps ; 
int i ; 

for (ps=0, i=0; i<N; i++) 
ps += (long)U[i]*V[i]; 
Return ps ; 
} 

Read More

Exercices corrigés en langage C: TP2

Exercices corrigés en Langage C :

Exercice 1 : 

Calculez la somme des N premiers termes de la série harmonique : 1 + 1/2 + 1/3 + ... + 1/N

Correction exercice 1 :

#include <stdio.h> 
main() 
{ 
int N; /* nombre de termes à calculer */ 

int I; /* compteur pour la boucle */ 
float SOM; /* Type float à cause de la précision du résultat. */ 

do 
{ 
printf ("Nombre de termes: "); 
scanf ("%d", &N); 
}while (N<1); 

for (SOM=0.0, I=1 ; I<=N ; I++) 
SOM += (float)1/I; 
printf("La somme des %d premiers termes est %f \n", N, SOM); 
return 0; 
} 

Exercice 2 : 

Affichez un triangle isocèle formé d'étoiles de N lignes (N est fourni au clavier).

Correction exercice 2 :

#include <stdio.h> 
main() 
{ 
int LIG; /* nombre de lignes */ 
int L; /* compteur des lignes */ 
int ESP; /* nombre d'espaces */ 
int I; /* compteur des caractères */ 

do 
{ 
printf("Nombres de lignes : "); 
scanf("%d", &LIG); 
}while (LIG<1 || LIG>20); 
for (L=0 ; L<LIG ; L++) 
{ 
ESP = LIG-L-1; 
for (I=0 ; I<ESP ; I++) 
putchar(' '); 
for (I=0 ; I<2*L+1 ; I++) 
putchar('*'); 
putchar('\n'); 
} 
return 0; 
} 

Exercice 3 : 

a) Calculez la racine carrée X d'un nombre réel positif A par approximations successives en
utilisant la relation de récurrence suivante:

XJ+1 = (XJ + A/XJ) / 2 X1 = A

La précision du calcul J est à entrer par l'utilisateur.

b) Assurez-vous lors de l'introduction des données que la valeur pour A est un réel positif et que J
est un entier naturel positif, plus petit que 50.

c) Affichez lors du calcul toutes les approximations calculées :

 La 1ère approximation de la racine carrée de ... est ...
 La 2e approximation de la racine carrée de ... est ...
 La 3e approximation de la racine carrée de ... est ...
 . . .

Correction exercice 3 :

#include <stdio.h> 
main() 
{ 
double A; /* donnée */ 
double X; /* approximation de la racine carrée de A */ 
int N; /* degré/précision de l'approximation */ 
int J; /* degré de l'approximation courante */ 

do 
{ 
printf("Entrer le réel positif A : "); 
scanf("%lf", &A); 

}while(A<0); 
do 
{ 
printf("Entrer le degré de l'approximation : "); 
scanf("%d", &N); 
} 
while(N<=0 || N>=50); 

 for(X=A, J=1 ; J<=N ; J++)

 { 
X = (X + A/X) / 2; 
printf("La %2d%s approximation de la racine carrée" 

" de %.2f est %.2f\n", J, (J==1)?"ère":"e", A, X); 
} 
return 0; 
} 

Exercice 4 :

Affiche la table des produits pour N variant de 1 à 10 :

X*Y I 0  1    2     3    4    5   6   7    8    9     10
0      I 0   0    0    0    0    0    0   0    0    0      0
1      I 0   1    2    3    4    5    6   7    8    9     10
2      I 0   2    4    6    8  10  12  14  16  18    20
3      I 0   3    6    9  12  15  18  21  24  27    30
4      I 0   4    8  12  16  20  24  28  32  36    40
5      I 0   5  10  15  20  25  30  35  40  45    50
6      I 0   6  12  18  24  30  36  42  48  54    60
7      I 0   7  14  21  28  35  42  49  56  63    70
8      I 0   8  16  24  32  40  48  56  64  72    80
9      I 0   9  18  27  36  45  54  63  72  81    90
10    I 0 10  20  30  40  50  60  70  80  90  100

Correction exercice 4 :

#include <stdio.h> 
main() 
{ 
 const int MAX = 10; /* nombre de lignes et de colonnes */ 

 int I; /* compteur des lignes */ 
 int J; /* compteur des colonnes */ 


 /* Affichage de l'en-tête */ 
printf(" X*Y I"); 
for (J=0 ; J<=MAX ; J++)


 printf("%4d", J); 
printf("\n"); 
printf("------"); 
for (J=0 ; J<=MAX ; J++)

 printf("----"); 
printf("\n");

 /* Affichage du tableau */ 
for (I=0 ; I<=MAX ; I++)

 { 
printf("%3d I", I); 
for (J=0 ; J<=MAX ; J++) 


printf("%4d", I*J); 
printf("\n"); 
} 
 return 0; 
} 

Read More

Exercices corrigés en langage C: TP1

Exercices corrigés en Langage C :

Exercice 1 : 

Ecrire un programme qui lit un caractère au clavier et affiche le caractère ainsi que son code
numérique en employant getchar et printf,

Correction exercice 1 :

#include <stdio.h> 
main() 
{ 
 int C ; 

printf("introduire un caractère suivi de 'Enter'\n"); 
C = getchar(); 
printf("Le caractère %c a le code ASCII %d\n", C, C); 
return 0; 
} 

Exercice 2 : 

Ecrire un programme qui calcule et affiche la distance DIST (type double) entre deux points A et B
du plan dont les coordonnées (XA, YA) et (XB, YB) sont entrées au clavier comme entiers.

Correction exercice 2 :

#include <stdio.h> 
#include <math.h> 
main() 
{ 


int XA, YA, XB, YB; 
double DIST;


 /* Attention: La chaîne de format que nous utilisons */ 
/* s'attend à ce que les données soient séparées par */ 
/* une virgule lors de l'entrée. */ 

printf("Entrez les coordonnées du point A : XA,YA "); 
scanf("%d,%d", &XA, &YA); 
printf("Entrez les coordonnées du point B : XB,YB "); 
scanf("%d,%d", &XB, &YB); 
DIST=sqrt(pow(XA-XB,2)+pow(YA-YB,2)); 
printf("La distance entre A(%d,% d) et B(%d, %d) est %.2f\n",XA, YA, XB, YB, DIST); 
return 0; 
} 

Exercice 3 : 

Ecrivez un programme qui calcule les solutions réelles d'une équation du second degré
ax2+bx+c = 0 en discutant la formule.

Utilisez une variable d'aide D pour la valeur du discriminant b2-4ac et décidez à l'aide de D, si
l'équation a une, deux ou aucune solution réelle. Utilisez des variables du type int pour A, B et C.

Considérez aussi les cas où l'utilisateur entre des valeurs nulles pour A; pour A et B; pour A, B et

C. Affichez les résultats et les messages nécessaires sur l'écran.
Modifier le programme afin de considérer le cas des solutions complexes.

Correction exercice 3 :

#include <stdio.h> 
#include <math.h> 
main() 

{ 
/* Calcul des solutions réelles et complexes d'une équation du second degré */ 
int A, B, C; 
double D; /* Discriminant */ 

printf("Calcul des solutions réelles et complexes d'une équation du second \n"); 
printf("degré de la forme ax^2 + bx + c = 0 \n\n"); 
printf("Introduisez les valeurs pour a, b, et c : "); 
scanf("%i %i %i", &A, &B, &C);

 /* Calcul du discriminant b^2-4ac */ 
D = pow(B,2) - 4.0*A*C; 

/* Distinction des différents cas */ 
if (A==0 && B==0 && C==0) /* 0x = 0 */ 
printf("Tout réel est une solution de cette équation.\n"); 
else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */ 
printf("Cette équation ne possède pas de solutions.\n"); 
else if (A==0) /* bx + c = 0 */ 
{ 
printf("La solution de cette équation du premier degré est :\n"); 
printf(" x = %.4f\n", (double)C/B); 
} 
else if (D<0) /* b^2-4ac < 0 */ 
{ 
printf("Les solutions complexes de cette équation sont les suivantes :\n"); 
printf(”x1 = %.4f + i%.4f\n”, (double)(-B),(double)(sqrt(-D)/(2*A))) ; 
printf(”x2 = %.4f + i%.4f\n”, (double)(-B),(double)(-sqrt(-D)/(2*A))) ;

 } 
else if (D==0) /* b^2-4ac = 0 */ 
{ 
printf("Cette équation a une seule solution réelle :\n"); 
printf(" x = %.4f\n", (double)-B/(2*A)); 
} 
else /* b^2-4ac > 0 */ 
{ 
printf("Les solutions réelles de cette équation sont :\n"); 
printf(" x1 = %.4f\n", (double)(-B+sqrt(D))/(2*A)); 
printf(" x2 = %.4f\n", (double)(-B-sqrt(D))/(2*A)); 
}
return 0; 
} 

Read More

Exercices corrigés en langage c : les méthodes de tri

Exercice 1 : Tri de Shell

Traduire la fonction TRI_SHELL définie ci-dessous en C.

Ecrire un programme pour tester la fonction TRI_SHELL.

   procédure TRI_SHELL(T,N)
   |  (* Trie un tableau T d'ordre N par la méthode
   |     de Shell en ordre croissant. *)
   |  résultat: entier tableau T[100]
   |  donnée: entier N
   |  entier SAUT, M, K
   |  booléen TERMINE
   |  en SAUT ranger N
   |  tant que (SAUT>1) faire
   |  |  en SAUT ranger SAUT divent 2
   |  |  répéter
   |  |  |  en TERMINE ranger vrai
   |  |  |  pour M variant de 1 à N-SAUT faire
   |  |  |  |  en K ranger M+SAUT
   |  |  |  |  si (T[M]>T[K]) alors
   |  |  |  |  |   PERMUTER(T[M],T[K])
   |  |  |  |  |   en TERMINE ranger faux
   |  |  |  |  fsi
   |  |  |  fpour
   |  |  jusqu'à TERMINE
   |  ftant (* SAUT <= 1 *)
   fprocédure (* fin TRI_SHELL *)
Remarque: L'algorithme a été développé par D.L.Shell en 1959. En comparant d'abord des éléments très éloignés, l'algorithme a tendance à éliminer rapidement les grandes perturbations dans l'ordre des éléments. La distance entre les éléments qui sont comparés est peu à peu réduite jusqu'à 1. A la fin du tri, les éléments voisins sont arrangés.

Correction exercice 1: Tri de Shell

#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void TRI_SHELL(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */ 

 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_SHELL(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void TRI_SHELL(int *T, int N)
{
  /* Trie un tableau T d'ordre N par la méthode de Shell */
 /* Prototypes des fonctions appelées */
 void PERMUTER(int *A, int *B);
 /* Variables locales */
 int SAUT, M, K;
 int TERMINE;
 /* Traitements */
 SAUT = N;
 while (SAUT>1)
     {
      SAUT /= 2;
      do
         {
          TERMINE=1;
          for (M=0; M<N-SAUT; M++)  /* Attention aux indices! */ 
               {
                K=M+SAUT;
                if (*(T+M) > *(T+K))
                   {
                    PERMUTER(T+M,T+K);
                    TERMINE=0;
                   }
               }
         }
      while(!TERMINE); /* Attention: utiliser la négation de */
     }        /* la condition employée en lang algorithmique */
}
 
void PERMUTER(int *A, int *B)
{
 int AIDE;
 AIDE = *A;
 *A   = *B;
 *B   = AIDE;
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 2:

Déterminer le maximum de N éléments d'un tableau TAB d'entiers de trois façons différentes:

a) la fonction MAX1 retourne la valeur maximale

b) la fonction MAX2 retourne l'indice de l'élément maximal

c) la fonction MAX3 retourne l'adresse de l'élément maximal

Ecrire un programme pour tester les trois fonctions.

Correction exercice 2:

Déterminer le maximum de N éléments d'un tableau TAB d'entiers de trois façons différentes:

a) la fonction MAX1 retourne la valeur maximale

int MAX1(int *TAB, int N)
{
 int MAX,I;  /* variables d'aide */
 MAX=*TAB;
 for (I=1; I<N; I++)
     if (MAX < *(TAB+I))
         MAX = *(TAB+I);
 return MAX;
}

b) la fonction MAX2 retourne l'indice de l'élément maximal

int MAX2(int *TAB, int N)
{
 int I,MAX; /* variables d'aide */
 MAX=0;
 for (I=1; I<N; I++)
   if (*(TAB+MAX) < *(TAB+I))
         MAX = I;
 return MAX;
}

c) la fonction MAX3 retourne l'adresse de l'élément maximal

int *MAX3(int *TAB, int N)
{
 int *MAX, *P; /* pointeurs d'aide */
 MAX=TAB;
 for (P=TAB; P<TAB+N; P++)
   if (*MAX < *P)
         MAX=P;
 return MAX;
}

Ecrire un programme pour tester les trois fonctions:

#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 int MAX1 (int *TAB, int N);
 int MAX2 (int *TAB, int N);
 int *MAX3(int *TAB, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */ 

 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 printf("MAX1 : %d \n",   MAX1(T,DIM)  );
 printf("MAX2 : %d \n", T[MAX2(T,DIM)] );
 printf("MAX3 : %d \n",  *MAX3(T,DIM)  );
 return 0;
}

int MAX1(int *TAB, int N)
{
 . . .
}

int MAX2(int *TAB, int N)
{
 . . .
}

int *MAX3(int *TAB, int N)
{
 . . .
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 3 : Tri par sélection

Ecrire la fonction TRI_SELECTION qui trie un tableau de N entiers par la méthode de sélection directe du maximum (voir exercice 7.14). La fonction fera appel à la fonction PERMUTER (définie dans le cours) et à la fonction MAX3 (définie dans l'exercice précédent).

Ecrire un programme pour tester la fonction TRI_SELECTION.

Correction exercice 3 : Tri par sélection

#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void TRI_SELECTION(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */ 


/* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_SELECTION(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void TRI_SELECTION(int *T, int N)
{
  /* Prototypes des fonctions appelées */
 void PERMUTER(int *A, int *B);
 int *MAX3(int *TAB, int N);
 /* Variables locales */
 int I;  /* rang à partir duquel T n'est pas trié */

 /* Tri par sélection directe du maximum */
 for (I=0 ; I<N-1 ; I++)
      PERMUTER(T+I, MAX3(T+I,N-I) );
}
 
int *MAX3(int *TAB, int N)
{
 . . .
}

void PERMUTER(int *A, int *B)
{
 . . .
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 4 :

Ecrire la fonction INSERER qui place un élément X à l'intérieur d'un tableau qui contient N éléments triés par ordre croissant, de façon à obtenir un tableau à N+1 éléments triés par ordre croissant. La dimension du tableau est incrémentée dans la fonction INSERER.

Ecrire un programme profitant des fonctions définies plus haut pour tester la fonction INSERER.

Correction exercice 4 : 

#include <stdio.h>
main()
{
 /* Prototypes des fonctions appelées */
 void INSERER(int X, int *T, int *N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */
 int A;      /* Nombre à insérer */ 
 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 printf("Introduire le nombre à insérer : ");
 scanf("%d", &A);
 INSERER(A, T, &DIM);
  printf("Tableau résultat : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void INSERER(int X, int *T, int *N)
{
  /* Variables locales */
 int I;
 /* Insertion de X dans le tableau T supposé trié: */
 /* Déplacer les éléments plus grands que X d'une  */
 /* position vers l'arrière. */
 for (I=*N ; I>0 && *(T+I-1)>X ; I--)
      *(T+I) = *(T+I-1);
  /* X est copié à la position du dernier élément déplacé */
 *(T+I)=X;
  /* Nouvelle dimension du tableau: */
 (*N)++; /* Attention aux parenthèses ! */ 
}
 
void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 5: Tri par insertion

Ecrire la fonction TRI_INSERTION qui utilise la fonction INSERER pour trier par ordre croissant les éléments d'un tableau à N éléments.

Ecrire un programme pour tester la fonction TRI_INSERTION.

Méthode: Trier le tableau de gauche à droite en insérant à chaque fois l'élément I+1 dans le tableau (déjà trié) des I premiers éléments.

Correction exercice 5: Tri par insertion

#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void TRI_INSERTION(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */
 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_INSERTION(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}


void TRI_INSERTION(int *T, int N)
{
  void INSERER(int X, int *T, int *N);
 /* Variables locales */
 int I;  /* indice courant */
 /* Tri de T par insertion */
 I=1;
 while (I<N)
      INSERER(*(T+I), T, &I);
}
 
void INSERER(int X, int *T, int *N)
{
 . . .
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 6 :

Ecrire la fonction RANGER qui arrange le contenu de ses deux paramètres X et Y de façon à ce que le contenu de X soit plus petit que celui de Y. RANGER retourne la valeur logique 1 si un échange a eu lieu, sinon 0.

Correction exercice 6 :

int RANGER(int *X, int *Y)
{
 int AIDE;
 if (*X>*Y)
     {
      AIDE = *X;
      *X = *Y;
      *Y = AIDE;
      return 1;
      }
 else
     return 0;
 }

Exercice 7 : Tri par propagation

Ecrire la fonction TRI_BULLE qui trie un tableau de N éléments entiers par ordre croissant en appliquant la méthode de la bulle (tri par propagation - voir exercice 7.15). Employer la fonction RANGER de l'exercice ci-dessus.

Ecrire un programme pour tester la fonction TRI_BULLE.

Correction exercice 7 : Tri par propagation

#include <stdio.h>
main()
{
 /* Prototypes des fonctions appelées */
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void TRI_BULLE(int *T, int N);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */
 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_BULLE(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void TRI_BULLE(int *T, int N)
{
  /* Prototypes des fonctions appelées */
 int RANGER(int *X, int *Y);
 /* Variables locales */
 int I,J;  /* indices courants */
 int FIN;  /* position où la dernière permutation a eu lieu */
      /* permet de ne pas trier un sous-ensemble déjà trié. */
 /* Tri de T par propagation de l'élément maximal */
 for (I=N-1 ; I>0 ; I=FIN)
    {
     FIN=0;
     for (J=0; J<I; J++)
          if (RANGER(T+J, T+J+1)) FIN = J;
    }
}
 
int RANGER(int *X, int *Y)
{
 . . .
}
void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}
void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 8 : Fusion de tableaux triés

Ecrire la fonction FUSION qui construit un tableau FUS trié par ordre croissant avec les éléments de deux tableaux A et B triés par ordre croissant. Pour deux tableaux de dimensions N et M, le tableau FUS aura la dimension N+M. (Méthode: voir exercice 7.13)

Ecrire un programme qui teste la fonction FUSION à l'aide de deux tableaux lus au clavier et triés à l'aide de TRI_BULLE.

Correction exercice 8 : Fusion de tableaux triés

#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void FUSION(int *A, int *B, int *FUS, int N, int M);
 void TRI_BULLE(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 /* Les tableaux et leurs dimensions */
 int A[100], B[100], FUS[200];
 int N, M;
 /* Traitements */
 printf("*** Tableau A ***\n");
 LIRE_TAB (A, &N, 100);
 printf("*** Tableau B ***\n");
 LIRE_TAB (B, &M, 100);
 TRI_BULLE(A, N);
  printf("Tableau A trié : \n");
 ECRIRE_TAB (A, N);
 TRI_BULLE(B, M);
  printf("Tableau B trié : \n");
 ECRIRE_TAB (B, M);
 FUSION(A,B,FUS,N,M);
  printf("Tableau FUS : \n");
 ECRIRE_TAB (FUS, N+M);
 return 0;
}


void FUSION(int *A, int *B, int *FUS, int N, int M)
{
  /* Variables locales */
 /* Indices courants dans A, B et FUS */
 int IA,IB,IFUS;  
 /* Fusion de A et B dans FUS */
 IA=0, IB=0; IFUS=0;
 while ((IA<N) && (IB<M))
    if (*(A+IA)<*(B+IB))
        {
         *(FUS+IFUS)=*(A+IA);
         IFUS++;
         IA++;
        }
    else
        {
         FUS[IFUS]=B[IB];
         IFUS++;
         IB++;
        }
  /* Si A ou B sont arrivés à la fin, alors */
 /* copier le reste de l'autre tableau.    */
 while (IA<N)
     {
      *(FUS+IFUS)=*(A+IA);
      IFUS++;
      IA++;
     }
 while (IB<M)
     {
      *(FUS+IFUS)=*(B+IB);
      IFUS++;
      IB++;
     }
}
 
void TRI_BULLE(int *T, int N)
{
 /* Prototypes des fonctions appelées */
 int RANGER(int *X, int *Y);
 . . .
}
int RANGER(int *X, int *Y)
{
 . . .
}
void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}
void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Read More

Exercices corrigés en langage C : Les pointeurs en langage C

Exercice 1 :

Soit P un pointeur qui 'pointe' sur un tableau A:
   int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
   int *P;
   P = A;
Quelles valeurs ou adresses fournissent ces expressions:
                    a)                 *P+2        
                    b)                 *(P+2)      
                    c)                 &P+1        
                    d)                 &A[4]-3    
                    e)                 A+3          
                    f)                  &A[7]-P    
                    g)                 P+(*P-10)
                    h)                 *(P+*(P+8)-A[7])        

Correction exercice 1 :

Soit P un pointeur qui 'pointe' sur un tableau A:
               int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
               int *P;
               P = A;

Quelles valeurs ou adresses fournissent ces expressions:
a)
*P+2
=>
la valeur 14
b)
*(P+2)
=>
la valeur 34
c)
&P+1
=>
l'adresse du pointeur derrière le pointeur P


(rarement utilisée)
d)
&A[4]-3
=>
l'adresse de la composante A[1]
e)
A+3
=>
l'adresse de la composante A[3]
f)
&A[7]-P
=>
la valeur (indice) 7
g)
P+(*P-10)
=>
l'adresse de la composante A[2]
h)
*(P+*(P+8)-A[7])
=>
la valeur 23

Exercice 2 :

Ecrire un programme en langage C qui lit un entier X et un tableau A du type int au clavier et élimine toutes les occurrences de X dans A en tassant les éléments restants. Le programme utilisera les pointeurs P1 et P2 pour parcourir le tableau.
                 
Correction exercice 2 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int A[50];    /* tableau donné        */
 int N;        /* dimension du tableau */
 int X;        /* valeur à éliminer    */
 int *P1, *P2; /* pointeurs d'aide     */

 /* Saisie des données */
 printf("Dimension du tableau (max.50) : ");
 scanf("%d", &N );
 for (P1=A; P1<A+N; P1++)
     {
      printf("Elément %d : ", P1-A);
      scanf("%d", P1);
     }
  printf("Introduire l'élément X à éliminer du tableau : ");
 scanf("%d", &X );
 /* Affichage du tableau */
 for (P1=A; P1<A+N; P1++)
     printf("%d ", *P1);
  printf("\n");
 /* Effacer toutes les occurrences de X et comprimer :  */
 /* Copier tous les éléments de P1 vers P2 et augmenter */
 /* P2 pour tous les éléments différents de X.          */
 for (P1=P2=A; P1<A+N; P1++)
     {
      *P2 = *P1;
      if (*P2 != X)
           P2++;
     }
  /* Nouvelle dimension de A */
 N = P2-A;
  /* Edition du résultat */
 for (P1=A; P1<A+N; P1++)
     printf("%d ", *P1);
  printf("\n");
 return 0;
}

Exercice 3 :

Ecrire un programme en langage C qui range les éléments d'un tableau A du type int dans l'ordre inverse. Le programme utilisera des pointeurs P1 et P2 et une variable numérique AIDE pour la permutation des éléments.


Correction exercice 3 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int A[50];    /* tableau donné        */
 int N;        /* dimension du tableau */
 int AIDE;     /* pour la permutation  */
 int *P1, *P2; /* pointeurs d'aide     */
 /* Saisie des données */
 printf("Dimension du tableau (max.50) : ");
 scanf("%d", &N );
 for (P1=A; P1<A+N; P1++)
     {
      printf("Elément %d : ", P1-A);
      scanf("%d", P1);
     }
  /* Affichage du tableau */
 for (P1=A; P1<A+N; P1++)
     printf("%d ", *P1);
  printf("\n");
 /* Inverser la tableau */
 for (P1=A,P2=A+(N-1); P1<P2; P1++,P2--)
     {
      AIDE = *P1;
      *P1  = *P2;
      *P2  = AIDE;
     }
  /* Edition du résultat */
 for (P1=A; P1<A+N; P1++)
      printf("%d ", *P1);
  printf("\n");
 return 0;
}

Exercice 4 :

Ecrire un programme en langage C qui lit deux tableaux d'entiers A et B et leurs dimensions N et M au clavier et qui ajoute les éléments de B à la fin de A. Utiliser deux pointeurs PA et PB pour le transfer et afficher le tableau résultant A.

Correction exercice 4 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int A[100], B[50]; /* tableaux */
 int N, M;    /* dimensions des tableaux */
 int *PA,*PB; /* pointeurs d'aide        */

  /* Saisie des données */
 printf("Dimension du tableau A (max.50) : ");
 scanf("%d", &N );
 for (PA=A; PA<A+N; PA++)
     {
      printf("Elément %d : ", PA-A);
      scanf("%d", PA);
     }
  printf("Dimension du tableau B (max.50) : ");
 scanf("%d", &M );
 for (PB=B; PB<B+M; PB++)
     {
      printf("Elément %d : ", PB-B);
      scanf("%d", PB);
     }
  /* Affichage des tableaux */
 printf("Tableau donné A :\n");
 for (PA=A; PA<A+N; PA++)
      printf("%d ", *PA);
  printf("\n");
 printf("Tableau donné B :\n");
 for (PB=B; PB<B+M; PB++)
      printf("%d ", *PB);
  printf("\n");
 /* Copier B à la fin de A */
 for (PA=A+N,PB=B ; PB<B+M ; PA++,PB++)
      *PA = *PB;
 /* Nouvelle dimension de A */
 N += M;
  /* Edition du résultat */
 printf("Tableau résultat A :\n");
 for (PA=A; PA<A+N; PA++)
      printf("%d ", *PA);
 printf("\n");
 return 0;
}

Exercice 5 :

Ecrire de deux façons différentes, un programme en langage C  qui vérifie sans utiliser une fonction de <string>, si une chaîne CH introduite au clavier est un palindrome:
a) en utilisant uniquement le formalisme tableau
b) en utilisant des pointeurs au lieu des indices numériques
Rappel: Un palindrome est un mot qui reste le même qu'on le lise de gauche à droite ou de droite à gauche:

Correction exercice 5 :

a) en utilisant uniquement le formalisme tableau
#include <stdio.h>
main()
{
 /* Déclarations */
 char CH[101]; /* chaîne donnée    */
 int I,J;      /* indices courants */
 int PALI;     /* indicateur logique:          */
               /* vrai si CH est un palindrome */

  /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Placer J sur la dernière lettre de la chaîne */
 for(J=0; CH[J]; J++)
     ;
 J--;
 /* Contrôler si CH est un palindrome */
 PALI=1;
 for (I=0 ; PALI && I<J ; I++,J--)
      if (CH[I] != CH[J])
          PALI=0;

  /* Affichage du résultat */
 if (PALI)
    printf("La chaîne \"%s\" est un palindrome.\n", CH);
 else
    printf("La chaîne \"%s\" n'est pas un palindrome.\n", CH);
 return 0;
}

b) en utilisant des pointeurs au lieu des indices numériques :
#include <stdio.h>
main()
{
 /* Déclarations */
 char CH[101];  /* chaîne donnée    */
 char *P1,*P2;  /* pointeurs d'aide */
  int PALI;  /* indicateur logique:          */
            /* vrai si CH est un palindrome */

  /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Placer P2 sur la dernière lettre de la chaîne */
 for (P2=CH; *P2; P2++)
      ;
 P2--;
 /* Contrôler si CH est un palindrome */
 PALI=1;
 for (P1=CH ; PALI && P1<P2 ; P1++,P2--)
      if (*P1 != *P2) PALI=0;
  /* Affichage du résultat */
 if (PALI)
    printf("La chaîne \"%s\" est un palindrome.\n", CH);
 else
    printf("La chaîne \"%s\" n'est pas un palindrome.\n", CH);
 return 0;
}

Exercice 6 :

Ecrire un programme en langage C qui lit une chaîne de caractères CH et détermine la longueur de la chaîne à l'aide d'un pointeur P. Le programme n'utilisera pas de variables numériques.

Correction exercice 6 :

#include <stdio.h>
main()
{
 /* Déclarations */
 char CH[101];  /* chaîne donnée   */
 char *P;       /* pointeur d'aide */

  /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Placer P à la fin de la chaîne */
 for (P=CH; *P; P++)
      ;
  /* Affichage du résultat */
 printf("La chaîne \"%s\" est formée de %d caractères.\n",
                                                     CH, P-CH);
 return 0;
}

Read More

Exercice corrigés en langage C : Les chaines de caractères en langage C

Exercice 1 :

Ecrire un programme en langage C qui lit 5 mots, séparés par des espaces et qui les affiche ensuite dans une ligne, mais dans l'ordre inverse. Les mots sont mémorisés dans 5 variables M1, ... ,M5.
Exemple
   voici une petite phrase !
   ! phrase petite une voici

Correction exercice 1 :

#include <stdio.h>
main()
{
 char M1[30], M2[30], M3[30], M4[30], M5[30];
 printf("Entrez 5 mots, séparés par des espaces :\n");
 scanf ("%s %s %s %s %s",  M1, M2, M3, M4, M5);
 printf("%s %s %s %s %s\n",M5, M4, M3, M2, M1);
  return 0;
}

Exercice 2 :

Ecrire un programme en langage C qui lit une ligne de texte (ne dépassant pas 200 caractères) la mémorise dans une variable TXT et affiche ensuite:
a) la longueur L de la chaîne.
b) le nombre de 'e' contenus dans le texte.
c) toute la phrase à rebours, sans changer le contenu de la
variable TXT.
d) toute la phrase à rebours, après avoir inversé l'ordre des
caractères dans TXT:
            voici une petite phrase !
            ! esarhp etitep enu iciov

Correction exercice 2 :

#include <stdio.h>
main()
{
 /* Déclarations */
 char TXT[201]; /* chaîne donnée       */
 int I,J;  /* indices courants         */
 int L;    /* longueur de la chaîne    */
 int C;    /* compteur des lettres 'e' */
 int AIDE; /* pour l'échange des caractères */

 /* Saisie des données */
 printf("Entrez une ligne de texte (max.200 caractères) :\n");
 gets(TXT); /* L'utilisation de scanf est impossible pour */
 /* lire une phrase contenant un nombre variable de mots. */

 /* a) Compter les caractères */
 /* La marque de fin de chaîne '\0' est */
 /* utilisée comme condition d'arrêt. */
 for (L=0; TXT[L]; L++)
     ;
 printf("Le texte est composé de %d caractères.\n",L);

 /* b) Compter les lettres 'e' dans le texte */
 C=0;
 for (I=0; TXT[I]; I++)
     if (TXT[I]=='e') C++;
 printf("Le texte contient %d lettres \'e\'.\n",C);

 /* c) Afficher la phrase à l'envers */
 for (I=L-1; I>=0; I--)
     putchar(TXT[I]);  /* ou printf("%c",TXT[I]); */
 putchar('\n');        /* ou printf("\n"); */

 /* d) Inverser l'ordre des caractères */
 for (I=0,J=L-1 ; I<J ; I++,J--)
    {
     AIDE=TXT[I];
     TXT[I]=TXT[J];
     TXT[J]=AIDE;
    }
 puts(TXT);  /* ou printf("%s\n",TXT); */
  return 0;
}

Exercice 3 :

Ecrire un programme en langage C qui lit un texte TXT (de moins de 200 caractères) et qui enlève toutes les apparitions du charactère 'e' en tassant les éléments restants. Les modifications se feront dans la même variable TXT.
Exemple:
   Cette ligne contient quelques lettres e.
   Ctt lign contint qulqus lttrs .

Correction exercice 3 :

#include <stdio.h>
main()
{
 /* Déclarations */
 char TXT[201]; /* chaîne donnée    */
 int  I,J;      /* indices courants */

 /* Saisie des données */
 printf("Entrez une ligne de texte (max.200 caractères) :\n");
 gets(TXT);
 /* Eliminer les lettres 'e' et comprimer :  */
 /* Copier les caractères de I vers J et incrémenter J */
 /* seulement pour les caractères différents de 'e'.   */
 for (J=0,I=0 ; TXT[I] ; I++)
    {
     TXT[J] = TXT[I];
     if (TXT[I] != 'e') J++;
    }
 /* Terminer la chaîne !! */
 TXT[J]='\0';
  /* Edition du résultat */
 puts(TXT);
  return 0;
}

Exercice 4 :

Ecrire un programme en langage C qui demande l'introduction du nom et du prénom de l'utilisateur et qui affiche alors la longueur totale du nom sans compter les espaces. Employer la fonction strlen.

Correction exercice 4 :

#include <stdio.h>
#include <string.h>
 main()
{
  char NOM[40], PRENOM[40];
  printf("Introduisez votre nom et votre prénom: \n");
  scanf("%s %s", NOM, PRENOM);
  printf("\nBonjour %s %s !\n", NOM, PRENOM);
  printf("Votre nom est composé de %d lettres.\n",
                                  strlen(NOM) + strlen(PRENOM));
 /* ou bien
  printf("Votre nom est composé de %d lettres.\n",
                                  strlen(strcat(NOM,PRENOM)));
 */
 return 0;
}

Exercice 5 :

Ecrire un programme en langage C qui lit un verbe régulier en "er" au clavier et qui en affiche la conjugaison au présent de l'indicatif de ce verbe. Contrôlez s'il s'agit bien d'un verbe en "er" avant de conjuguer. Utiliser les fonctions gets, puts, strcat et strlen.

Correction exercice 5 :

#include <stdio.h>
#include <string.h>
 main()
{
 /* Déclarations */
 char VERB[20]; /* chaîne contenant le verbe */
 char AFFI[30]; /* chaîne pour l'affichage   */
 int L;         /* longueur de la chaîne     */

 /* Saisie des données */
 printf("Verbe : ");
 gets(VERB);

 /* Contrôler s'il s'agit d'un verbe en 'er' */
 L=strlen(VERB);
 if ((VERB[L-2]!='e') || (VERB[L-1]!='r'))
      puts("\aCe n'est pas un verbe du premier groupe.!");
 else
     {
      /* Couper la terminaison 'er'. */
      VERB[L-2]='\0';
      /* Conjuguer ... */
      AFFI[0]='\0';
      strcat(AFFI, "je ");
      strcat(AFFI, VERB);
      strcat(AFFI, "e");
      puts(AFFI);

       . . .

      AFFI[0]='\0';
      strcat(AFFI, "ils ");
      strcat(AFFI, VERB);
      strcat(AFFI, "ent");
      puts(AFFI);
     }
  return 0;
}

Exercice 6 :

Ecrire un programme en langage C qui lit deux chaînes de caractères CH1 et CH2 et qui copie la première moitié de CH1 et la première moitié de CH2 dans une troisième chaîne CH3. Afficher le résultat.
a) Utiliser les fonctions spéciales de <string>.
b) Utiliser uniquement les fonctions gets et puts.

Correction exercice 6 :

a) Utiliser les fonctions spéciales de <string>.
#include <stdio.h>
#include <string.h>
 main()
{
 /* Déclarations */
 char CH1[100], CH2[100]; /* chaînes données */
 char CH3[100]="";        /* chaîne résultat */

 /* Saisie des données */
 printf("Introduisez la première chaîne de caractères : ");
 gets(CH1);
 printf("Introduisez la deuxième chaîne de caractères : ");
 gets(CH2);


 /* Traitements */
 strncpy(CH3, CH1, strlen(CH1)/2);
 strncat(CH3, CH2, strlen(CH2)/2);
  /* Affichage du résultat */
 printf("Un demi \"%s\" plus un demi \"%s\" donne \"%s\"\n",CH1, CH2, CH3);
 return 0;
}

b) Utiliser uniquement les fonctions gets et puts.
#include <stdio.h>
main()
{
 /* Déclarations */
 char CH1[100], CH2[100]; /* chaînes données  */
 char CH3[100]="";        /* chaîne résultat  */
 int L1,L2; /* longueurs de CH1 et CH2        */
 int I;     /* indice courant dans CH1 et CH2 */
 int J;     /* indice courant dans CH3        */

 /* Saisie des données */
 puts("Introduisez la première chaîne de caractères : ");
 gets(CH1);
 puts("Introduisez la deuxième chaîne de caractères : ");
 gets(CH2);

 /* Détermination les longueurs de CH1 et CH2 */
 for (L1=0; CH1[L1]; L1++) ;
 for (L2=0; CH2[L2]; L2++) ;
 /* Copier la première moitié de CH1 vers CH3 */
 for (I=0 ; I<(L1/2) ; I++)
     CH3[I]=CH1[I];
 /* Copier la première moitié de CH2 vers CH3 */
 J=I;
 for (I=0 ; I<(L2/2) ; I++)
    {
     CH3[J]=CH2[I];
     J++;
    }
 /* Terminer la chaîne CH3 */
 CH3[J]='\0';

 /* Affichage du résultat */
 puts("Chaîne résultat : ");
 puts(CH3);
 return 0;
}

Read More

Exercices corrigés en langage C : Les tableaux en langage C

Exercice 1:

Ecrire un programme en langage C qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Calculer et afficher ensuite la somme des éléments du tableau.

Correction exercice 1 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int T[50]; /* tableau donné  */
 int N;     /* dimension      */
 int I;     /* indice courant */
 long SOM;  /* somme des éléments - type long à cause */
            /* de la grandeur prévisible du résultat. */

 /* Saisie des données */
 printf("Dimension du tableau (max.50) : ");
 scanf("%d", &N );
 for (I=0; I<N; I++)
    {
     printf("Elément %d : ", I);
     scanf("%d", &T[I]);
    }
  /* Affichage du tableau */
 printf("Tableau donné :\n");
 for (I=0; I<N; I++)
     printf("%d ", T[I]);
 printf("\n");
  /* Calcul de la somme */
 for (SOM=0, I=0; I<N; I++)
     SOM += T[I];
  /* Edition du résultat */
 printf("Somme de éléments : %ld\n", SOM);
 return 0;
}

Exercice 2:

Ecrire un programme en langage C qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les éléments restants. Afficher le tableau résultant.

Correction exercice 2:

#include <stdio.h>
main()
{
 /* Déclarations */
 int T[50]; /* tableau donné    */
 int N;     /* dimension        */
 int I,J;   /* indices courants */

 /* Saisie des données */
 printf("Dimension du tableau (max.50) : ");
 scanf("%d", &N );
 for (I=0; I<N; I++)
    {
     printf("Elément %d : ", I);
     scanf("%d", &T[I]);
    }
 /* Affichage du tableau */
 printf("Tableau donné : \n");
 for (I=0; I<N; I++)
     printf("%d ", T[I]);
 printf("\n");
 /* Effacer les zéros et comprimer :        */
 /* Copier tous les éléments de I vers J et */
 /* augmenter J pour les éléments non nuls. */
 for (I=0, J=0 ; I<N ; I++)
     {
      T[J] = T[I];
      if (T[I]) J++;
     }
 /* Nouvelle dimension du tableau ! */
 N = J;
  /* Edition des résultats */
 printf("Tableau résultat :\n");
 for (I=0; I<N; I++)
     printf("%d ", T[I]);
 printf("\n");
 return 0;
}

Exercice 3:

Ecrire un programme en langage C  qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Ranger ensuite les éléments du tableau T dans l'ordre inverse sans utiliser de tableau d'aide. Afficher le tableau résultant.
Idée: Echanger les éléments du tableau à l'aide de deux indices qui parcourent le tableau en commençant respectivement au début et à la fin du tableau et qui se rencontrent en son milieu.

Correction exercice 3 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int T[50]; /* tableau donné */
 int N;     /* dimension     */
 int I,J;   /* indices courants */
 int AIDE;  /* pour l'échange   */

 /* Saisie des données */
 printf("Dimension du tableau (max.50) : ");
 scanf("%d", &N );
 for (I=0; I<N; I++)
    {
     printf("Elément %d : ", I);
     scanf("%d", &T[I]);
    }
 /* Affichage du tableau */
 printf("Tableau donné : \n");
 for (I=0; I<N; I++)
     printf("%d ", T[I]);
 printf("\n");
 /* Inverser le tableau */
 for (I=0, J=N-1 ; I<J ; I++,J--)
      /* Echange de T[I] et T[J] */
        {
         AIDE = T[I];
         T[I] = T[J];
         T[J] = AIDE;
        }
  /* Edition des résultats */
 printf("Tableau résultat :\n");
 for (I=0; I<N; I++)
     printf("%d ", T[I]);
 printf("\n");
 return 0;
}

Exercice 4:

Ecrire un programme en langage C qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Copiez ensuite toutes les composantes strictement positives dans un deuxième tableau TPOS et toutes les valeurs strictement négatives dans un troisième tableau TNEG. Afficher les tableaux TPOS et TNEG.

Correction exercice 4 :

#include <stdio.h>
main()
{
 /* Déclarations */
 /* Les tableaux et leurs dimensions */
 int T[50], TPOS[50], TNEG[50];
 int N,     NPOS,     NNEG;
 int I; /* indice courant */

 /* Saisie des données */
 printf("Dimension du tableau (max.50) : ");
 scanf("%d", &N );
 for (I=0; I<N; I++)
    {
     printf("Elément %d : ", I);
     scanf("%d", &T[I]);
    }
 /* Affichage du tableau */
 printf("Tableau donné :\n");
 for (I=0; I<N; I++)
     printf("%d ", T[I]);
 printf("\n");
 /* Initialisation des dimensions de TPOS et TNEG */
 NPOS=0;
 NNEG=0;
 /* Transfer des données */
 for (I=0; I<N; I++)
      { if (T[I]>0) {
                     TPOS[NPOS]=T[I];
                     NPOS++;
                    }
        if (T[I]<0) {
                     TNEG[NNEG]=T[I];
                     NNEG++;
                    }
      }
  /* Edition du résultat */
 printf("Tableau TPOS :\n");
 for (I=0; I<NPOS; I++)
     printf("%d ", TPOS[I]);
 printf("\n");
 printf("Tableau TNEG :\n");
 for (I=0; I<NNEG; I++)
     printf("%d ", TNEG[I]);
 printf("\n");
 return 0;
}

Exercice 5:

Ecrire un programme en langage C qui lit les dimensions L et C d'un tableau T à deux dimensions du type int (dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des valeurs entrées au clavier et afficher le tableau ainsi que la somme de tous ses éléments.

Correction exercice 5 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int T[50][50]; /* tableau donné */
 int L, C;  /* dimensions        */
 int I, J;  /* indices courants  */
 long SOM;  /* somme des éléments - type long à cause */
            /* de la grandeur prévisible du résultat. */

 /* Saisie des données */
 printf("Nombre de lignes   (max.50) : ");
 scanf("%d", &L );
 printf("Nombre de colonnes (max.50) : ");
 scanf("%d", &C );
 for (I=0; I<L; I++)
    for (J=0; J<C; J++)
        {
         printf("Elément[%d][%d] : ",I,J);
         scanf("%d", &T[I][J]);
        }
  /* Affichage du tableau */
 printf("Tableau donné :\n");
 for (I=0; I<L; I++)
    {
     for (J=0; J<C; J++)
         printf("%7d", T[I][J]);
     printf("\n");
    }
  /* Calcul de la somme  */
 for (SOM=0, I=0; I<L; I++)
     for (J=0; J<C; J++)
         SOM += T[I][J];
  /* Edition du résultat */
 printf("Somme des éléments : %ld\n", SOM);
 return 0;
}

Exercice 6:

Ecrire un programme en langage C qui lit les dimensions L et C d'un tableau T à deux dimensions du type int (dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des valeurs entrées au clavier et afficher le tableau ainsi que la somme de chaque ligne et de chaque colonne en n'utilisant qu'une variable d'aide pour la somme.

Correction exercice 6 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int T[50][50]; /* tableau donné    */
 int L, C;      /* dimensions       */
 int I, J;      /* indices courants */
 long SOM;  /* somme des éléments - type long à cause   */
            /* de la grandeur prévisible des résultats. */

 /* Saisie des données */
 printf("Nombre de lignes   (max.50) : ");
 scanf("%d", &L );
 printf("Nombre de colonnes (max.50) : ");
 scanf("%d", &C );
 for (I=0; I<L; I++)
    for (J=0; J<C; J++)
        {
         printf("Elément[%d][%d] : ",I,J);
         scanf("%d", &T[I][J]);
        }
 /* Affichage du tableau */
 printf("Tableau donné :\n");
 for (I=0; I<L; I++)
    {
     for (J=0; J<C; J++)
          printf("%7d", T[I][J]);
     printf("\n");
    }
 /* Calcul et affichage de la somme des lignes */
 for (I=0; I<L; I++)
     {
      for (SOM=0, J=0; J<C; J++)
             SOM += T[I][J];
      printf("Somme - ligne %d : %ld\n",I,SOM);
     }
 /* Calcul et affichage de la somme des colonnes */
 for (J=0; J<C; J++)
     {
      for (SOM=0, I=0; I<L; I++)
             SOM += T[I][J];
      printf("Somme - colonne %d : %ld\n",J,SOM);
     }
  return 0;
}

Exercice 7:

Ecrire un programme en langage C qui transfère un tableau M à deux dimensions L et C (dimensions maximales: 10 lignes et 10 colonnes) dans un tableau V à une dimension L*C.
Exemple:
     /         \
   | a b c d |             /                                \
   |  e f g h |  ==>   | a b c d e f g h i j k l |
    | i j k l  |               \                                 /
     \         /


Correction exercice 7:

#include <stdio.h>
main()
{
 /* Déclarations */
 int M[10][10]; /* tableau à 2 dimensions */
 int V[100];    /* tableau à 1 dimension  */
 int L, C;      /* dimensions       */
 int I, J;      /* indices courants */

 /* Saisie des données */
 printf("Nombre de lignes   (max.10) : ");
 scanf("%d", &L );
 printf("Nombre de colonnes (max.10) : ");
 scanf("%d", &C );
 for (I=0; I<L; I++)
    for (J=0; J<C; J++)
        {
         printf("Elément[%d][%d] : ",I,J);
         scanf("%d", &M[I][J]);
        }
 /* Affichage du tableau 2-dim */
 printf("Tableau donné :\n");
 for (I=0; I<L; I++)
    {
     for (J=0; J<C; J++)
          printf("%7d", M[I][J]);
     printf("\n");
    }
 /* Transfer des éléments ligne par ligne */
 for (I=0; I<L; I++)
      for (J=0; J<C; J++)
             V[I*C+J] = M[I][J];
  /* Affichage du tableau 1-dim */
 printf("Tableau résultat : ");
 for (I=0; I<L*C; I++)
     printf("%d ", V[I]);
 printf("\n");
 return 0;
}

Exercice 8:

Ecrire un programme en langage C qui calcule le produit scalaire de deux vecteurs d'entiers U et V (de même dimension).
Exemple:
   /          \   /          \
   | 3  2  -4 | * | 2  -3  5 | = 3*2+2*(-3)+(-4)*5 = -20
   \          /   \          /


Correction exercice 8 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int U[50], V[50]; /* tableaux donnés */
 int N;     /* dimension        */
 int I;     /* indice courant   */
 long PS;   /* produit scalaire */
 /* Saisie des données */
 printf("Dimension des tableaux (max.50) : ");
 scanf("%d", &N );
 printf("** Premier tableau **\n");
 for (I=0; I<N; I++)
    {
     printf("Elément %d : ", I);
     scanf("%d", &U[I]);
    }
 printf("** Deuxième tableau **\n");
 for (I=0; I<N; I++)
    {
     printf("Elément %d : ", I);
     scanf("%d", &V[I]);
    }
 /* Calcul du produit scalaire */
 for (PS=0, I=0; I<N; I++)
      PS += (long)U[I]*V[I];
  /* Edition du résultat */
 printf("Produit scalaire : %ld\n", PS);
 return 0;
}

Exercice 9:

Ecrire un programme en langage C qui détermine la plus grande et la plus petite valeur dans un tableau d'entiers A. Afficher ensuite la valeur et la position du maximum et du minimum. Si le tableau contient plusieurs maxima ou minima, le programme retiendra la position du premier maximum ou minimum rencontré.

Correction exercice 9 :

#include <stdio.h>
main()
{
 /* Déclarations */
 int A[50]; /* tableau donné  */
 int N;     /* dimension      */
 int I;     /* indice courant */
 int MIN;   /* position du minimum */
 int MAX;   /* position du maximum */
 /* Saisie des données */
 printf("Dimension du tableau (max.50) : ");
 scanf("%d", &N );
 for (I=0; I<N; I++)
    {
     printf("Elément %d : ", I);
     scanf("%d", &A[I]);
    }
 /* Affichage du tableau */

Read More