Remerciements

Programmation C

Travaux pratiques avec corrections

Support destiné aux étudiants de niveau

première année DUT informatique

Pr. Mohamed Tahrichi

Département Génie Informatique
Ecole Supérieure de Technologie
Université Mohammed Premier
Oujda
 Table des matières

TP 1 : Briques de base ................................................................................................................ 2

Corrigé TP1 ................................................................................................................................ 4
TP 2 : Structures de contrôle ...................................................................................................... 8
Corrigé TP2 .............................................................................................................................. 10
TP 3 : Tableaux et pointeurs .................................................................................................... 17
Corrigé TP3 .............................................................................................................................. 19
TP 4 : Les Fonctions et les chaines de caractères .................................................................... 27
Corrigé TP 4 ............................................................................................................................. 29

M. Tahrichi i

Département GI-ESTO
 TP 1 : Briques de base

Exercice 1.1
Ecrire un programme qui lit un entier x à partir du clavier, calcule son carré et affiche à l’écran
la valeur de x ainsi que celle du x2.
Exercice 1.2
1. Ecrire un programme qui déclare trois variables entières n, m, k. Et qui saisit deux valeurs
entières et les affecter à n et m.
2. Affecter à k la division de n par m, puis afficher le contenu de k à l’écran.
3. En utilisant une seule fois printf, afficher n, m et k sous la forme :
n m
k
Exercice 1.3
1. Ecrire un programme qui déclare cinq variables réelles x, y, z, somme et moyenne, puis
saisit trois valeurs réelles et les affecter à x, y et z.
2. Calculer la somme de x, y et z et l’affecter à la variable somme, puis afficher sa valeur à
l’écran.
3. Calculer la moyenne de x, y et z et l’affecter à la variable moyenne, puis afficher sa valeur
à l’écran.
Exercice 1.4
1. Ecrire un algorithme qui permet de lire trois réels et de calculer leur somme en utilisant
quatre variables.
2. Traduire cet algorithme en un programme C, en déclarant les variables de type double.
3. Refaire les questions 1 et 2 en utilisant seulement deux variables.
Exercice 1.5
Ecrire un programme qui lit un caractère au clavier et affiche le caractère ainsi que son code
ASCII.
Exercice 1.6
1. Ecrivez un programme qui lit la date du clavier et affiche les données ainsi reçues sur
l'écran.
Exemple : Introduisez la date (jour mois année): 10 11 2022
jour : 10
mois : 11
année : 2022
2. Testez les réactions du programme à vos entrées. Essayez d'introduire des nombres de
différents formats et différentes grandeurs.
3. Changez la partie format du programme de façon à séparer les différentes données par le
symbole '-’.

M. Tahrichi 2
Département GI-ESTO
Exercice 1.7
Écrivez un programme C qui inverse la casse d’un caractère saisi au clavier.
Exercice 1.8
1. Ecrire un programme qui permute et affiche les valeurs de deux variables A, B de type
entier qui sont entrées au clavier : A=>B , B=>A
2. Ecrire un programme qui permute et affiche les valeurs de trois variables A, B, C de type
entier qui sont entrées au clavier : A =>B ,B => C,C => A
Exercice 1.9
Ecrire un programme qui calcule le prix TTC (type float) d'un article à partir du prix HT (type
int) et du pourcentage de TVA (type int) à ajouter. Utilisez la formule suivante en faisant
attention aux priorités et aux conversions automatiques de type :
PTTC=PHT+PHT*(TVA/100).
Exercice 1.10
1. Écrire plus simplement l’instruction suivante :
z = (a>b ? a : b) + (a <= b ? a : b) ;
2. n étant de type int, écrire une expression qui prend la valeur :
-1 si n est négatif,
0 si n est nul,
1 si n est positif.
Exercice 1.11
Quels résultats fournit le programme suivant ?
#include <stdio.h>
main()
{
int n=10, p=5, q=10, r ;
r = n == (p = q) ;
printf ("A : n = %d p = %d q = %d r = %d\n", n, p, q, r) ;
n = p = q = 5 ;
n += p += q ;
printf ("B : n = %d p = %d q = %d\n", n, p, q) ;
q = n < p ? n++ : p++ ;
printf ("C : n = %d p = %d q = %d\n", n, p, q) ;
q = n > p ? n++ : p++ ;
printf ("D : n = %d p = %d q = %d\n", n, p, q) ;
}

M. Tahrichi 3
Département GI-ESTO
 Corrigé TP1

Exercice 1.1
#include <stdio.h>
#include <stdlib.h>
int main()
{
float x; //déclaration d’un réel
printf("Bonjour, donner un réel : ");
scanf("%f",&x); //lecture d’un réel
printf("le carre de %f est %f\n",x,x*x);
return 0 ;
}

Exercice 1.2
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n,m,k;
puts("Donner n : ");
scanf("%d",&n);
puts("Donner m : ");
scanf("%d",&m);
k=((float)n)/m; //attention n/m donnera toujours un entier, pour avoir la
// division réelle il faut au moins convertir un des deux
// nombre en float
printf("%d\t%d\n\t%d\a",n,m,k);// \t c’est pour tabulation horizontale
return 0 ;
}

Exercice 1.3
#include <stdio.h>
#include <stdlib.h>
int main()
{
float x,y,z,s,m;
puts("Merci de saisir 3 reels : ");
scanf("%f%f%f",&x,&y,&z);
s=x+y+z;

M. Tahrichi 4
Département GI-ESTO
m=s/3;
printf("La somme des nombres saisis est %10.2f\n",s); // on choisit un gabarit
printf("La moyenne de ces nombres est %10.2f\n",m); // et une précision
return 0 ;
}

Exercice 1.4
#include <stdio.h>
#include <stdlib.h>
int main()
{
// 3. En utilisant deux variables
float x,s=0;
printf("Donner un réel : ");
scanf("%f",&x);
s+=x; // s=s+x;
printf("Donner un réel : ");
scanf("%f",&x);
s+=x; // s=s+x;
printf("Donner un réel : ");
scanf("%f",&x);
s+=x; // s=s+x;
printf("La somme est %f\n",s);
return 0 ;
}

Exercice 1.5
#include <stdio.h>
#include <stdlib.h>
int main()
{
char car; //déclaration d’un caractère
printf("Caractère c ? ");
scanf("%c",&car); //L’espace aussi sera lu comme caractère
// Les caractères sont représentés en tant que nombres
// (code ASCII) dans la mémoire
printf("Caractère c=%c (code ASCII %d)",car,car);
return 0 ;
}

M. Tahrichi 5
Département GI-ESTO
Exercice 1.6
#include <stdio.h>
#include <stdlib.h>
int main()
{
int jour,mois,annee;
printf("Introduisez la date jour/mois/annee :");
scanf("%d/%d/%d",&jour,&mois,&annee); // Le caractère / sera considéré comme
// séparateur lors de la lecture
printf("%d\"%d\"%d",jour,mois,annee);
return 0 ;
}

Exercice 1.7
#include <stdio.h>
#include <stdlib.h>
int main()
{
char c; char c_inv;
printf("donner un caractère : ");
scanf("%c",&c);
if('a'<=c && c<='z') // la comparaison ce fait sur les codes ASCII
c_inv=c-('a'-'A');
if('A'<=c && c<='B')
c_inv=c+('a'-'A');
if('z'<c || c<'A')
printf("%c n'est pas une lettre de l'alphabet \n",c);
else
printf("%c <----> %c\n",c,c_inv);
return 0;
}

Exercice 1.8
#include <stdio.h>
#include <stdlib.h>
int main()
{
int A,B;
int aide; // une variable d'aide pour effectuer la permutation
printf("Donnez deux entiers : ");

M. Tahrichi 6
Département GI-ESTO
scanf("%d%d",&A,&B);
printf("Avant permutation : A=%d, B=%d \n",A,B);
aide=A; // mettre A dans aide avant de la remplacer par B
A=B;
B=aide; // ici aide c’est la valeur initiale de A
printf("Après permutation : A=%d, B=%d \n",A,B);
return 0 ;
}

Exercice 1.9
#include <stdio.h>
#include <stdlib.h>
#define TVA 19.6 //définition d’une constante symbolique
int main()
{
double prixHT,prixTTC;
printf("Donner le prix H.T. de l'article : ");
scanf("%lf",&prixHT); // le code %lf pour le type double
prixTTC=prixHT+prixHT*(TVA/100);
printf("Prix H.T =%.2lf\nPrix TTC = %.2lf \n",prixHT,prixTTC);
return 0 ;
}

M. Tahrichi 7
Département GI-ESTO
 TP 2 : Structures de contrôle

Exercice 2.1
1. Écrire un programme qui test si un entier est pair ou impair.
2. Écrire un programme qui affiche l’inverse d’un chiffre.
3. Écrire un programme qui test si un entier est premier ou non.

Exercice 2.2
Écrire un algorithme qui permet de saisir les valeurs de trois variables entières p, q et n, de
tester si n est un multiple commun de p et q, et d’afficher :
• «n est un multiple commun de p et q» si n est un multiple commun de p et q
• « n n’est pas un multiple commun de p et q » sinon.

Exercice 2.3

Écrire un programme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe du
produit de A par B sans faire la multiplication.

Exercice 2.4

En utilisant l’instruction switch, écrire un programme qui demande à l’utilisateur une opération
à effectuer sous forme de caractère ( ‘+’, ‘-‘,‘*’, ‘/‘), il demande ensuite deux entiers, effectue
l’opération et affiche le résultat.

Exercice 2.5

1. Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme, leur
produit et leur moyenne. Choisissez un type approprié pour les valeurs à afficher. Le nombre
N est à entrer au clavier. Résolvez ce problème en utilisant
• la boucle while,
• la boucle do - while,
• la boucle for.
2. Laquelle des trois variantes est la plus naturelle pour ce problème ?
3. Répétez l'introduction du nombre N jusqu'à ce que N ait une valeur entre 1 et 15.
4. Quelle structure répétitive utilisez-vous ? Pourquoi ?

Exercice 2.6

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

Exercice 2.7
Écrire un programme qui demande à l'utilisateur de taper un entier N et qui calcule u(N) défini
par :
U0=3 et Un=[Link]-1+4 pour n>0.

M. Tahrichi 8
Département GI-ESTO
Exercice 2.8

Calculez le nième terme Un de la suite de FIBONACCI qui est donnée par la relation de
récurrence :
U1=1, U2=1 et Un=Un-1+Un-2, pour n>2.

Exercice 2.9

Écrire un programme qui permet de faire des opérations sur un entier. Le programme affiche la
valeur de l'entier puis affiche le menu suivant :
1. Ajouter 1 ;
2. Multiplier par 2 ;
3. Soustraire 4 ;
4. Quitter.
Le programme demande alors de taper un entier entre 1 et 4. Si l'utilisateur tape une valeur entre
1 et 3, on effectue l'opération, on affiche la nouvelle valeur de l'entier puis on réaffiche le menu
et ainsi de suite jusqu'à ce qu'on tape 4. Lorsqu'on tape 4, le programme se termine

Exercice 2.10

Écrire un programme qui demande de saisir 10 entiers et qui affiche le nombre d'occurrences
de la note la plus haute.

Exercice 2.11

On considère la suite hongroise :

U0=a (a entier)
Un+1=Un/2, si Un pair
Un+1=3*Un+1, sinon.
Pour toutes les valeurs a, il existe un entier N tel que UN=1 (conjecture admise).
Écrire un programme qui demande à l'utilisateur de taper a et qui affiche toutes les valeurs de
U(n) de n=1 à n=N.

Exercice 2.12

Écrire un programme qui réalise le petit jeu suivant. Tout d’abord, l’ordinateur choisit un entier
x entre 1 et 100. L’utilisateur essaie ensuite de le deviner. Il entre pour cela successivement des
entiers, et à chaque coup l’ordinateur lui indique si l’entier est supérieur à x, inférieur à x, ou
égal à x auquel cas la partie s’arrête et le nombre de coups est affiché.
Modifier ensuite le programme afin que l’utilisateur puisse, s’il le souhaite, recommencer une
partie. En quittant le programme, le meilleur score doit s’afficher.

M. Tahrichi 9
Département GI-ESTO
 Corrigé TP2

Exercice 2.1
#include <stdio.h>
#include <stdlib.h>
int main()
{
// 1. Tester si un nombre est pair ou impair
int n;
puts("Donnez un entier: ");
scanf("%d",&n);
if(n%2==0) // le reste de n sur 2 est nul ssi n est pair
printf("Ce nombre est pair\n");
else
printf("Ce nombre est impair \n");
// 2. Calculer l’inverse d’un nombre
float x; float r;
puts("Donnez un réel : ");
scanf("%f",&x);
if(x==0)
printf("O n'a pas d’inverse dans R\n");
else
{
r=1/x;
printf("l’inverse de %.2f est %.2f",x,r);
}
//3. Vérifier si un nombre est premier ou non
int n,i;
puts("Donnez un entier positif: ");
scanf("%d",&n);
i=2;
while(n%i!=0)
i++; // on augmente i tant que i ne divise pas n
if(i==n) // pas de diviseur <n
printf("Ce nombre est premier\n");
else
printf("Ce nombre n'est pas premier\n");
// une autre solution en utilisant la boucle for et break
for(i=2;i<n;i++)
{

M. Tahrichi 10
Département GI-ESTO
 if(n%i==0) break;
}
if(i==n)
printf("Ce nombre est premier\n");
else
printf("Ce nombre n'est pas premier\n");
return 0;
}

Exercice 2.2
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n,p,q;
puts("Donner n, p et q : ");
scanf("%d%d%d",&n,&p,&q);
if(n%p==0&&n%q==0) // p divise n et q divise n
printf("%d est un multiple commun de %d et %d",n,p,q);
else
printf("%d n'est pas un multiple commun de %d et %d",n,p,q);
return 0;
}

Exercice 2.3
#include <stdio.h>
#include <stdlib.h>
int main()
{
float A,B;
puts("Donnez deux reels :");
scanf("%f%f",&A,&B);
if(A>0&&B<0 || A<0&&B>0) //Les deux nombres ont le même signe
printf("Le produit est négatif");
else{
if(A==0 || B==0) printf("Le produit est nul");
else printf("Le produit est positif") ;}
return 0;
}

Exercice 2.4
M. Tahrichi 11
Département GI-ESTO
#include <stdio.h>
#include <stdlib.h>
int main()
{
float n1,n2;
char op; // pour l’opération
scanf("%f %c %f",&n1,&op,&n2); // on met des espaces dans le code !!
switch(op)
{
case '+': printf("%f\n",n1+n2); break;
case '-': printf("%f\n",n1-n2); break;
case '*': printf("%f\n",n1*n2); break;
case '/':
(n2==0)?printf("Erreur!, Division Par 0"):
printf("%f\n",n1/n2); // l’opérateur conditionnel
break;
default: printf("Opération invalide\n");
}
return 0;
}

Exercice 2.5
#include <stdio.h>
#include <stdlib.h>
int main()
{
int N,i;
int x;
int s,p;
float m;
puts("Vous avez combien de valeurs ? ");
scanf("%d",&N);
while(N<=15) // while car on ne connait pas à l’avance la taille de la boucle
{
s=0;p=1;
for(i=1;i<=N;i++) // for car on connait la taille de la boucle
{
printf("Valeur %d: ",i);
scanf("%d",&x);
s+=x; //s=s+x ;

M. Tahrichi 12
Département GI-ESTO
 p*=x; //p=p*x ;
}
m=((float)s)/N;
printf("La somme est %d\n",s);
printf("La preduit est %d\n",p);
printf("La moyenne est %.2f\n",m);
puts("Vous avez combien de valeurs <15 ? ");
scanf("%d",&N);
}
return 0;
}

Exercice 2.6
#include <stdio.h>
#include <stdlib.h>
int main()
{
int N,i;
float Hn ; //La valeur de la suite Harmonique
printf("Donner N :");
scanf("%d",&N);
Hn=0 ;
for(i=1;i<=n;i++)
{
Hn+=1.0/i; // i c’est un entier, donc il faut écrire 1.0
// Ou bien on peut convertir i par (float)i
}
printf("1+2+…+1/%d=%f\n",N,Hn);
return 0;
}

Exercice 2.7
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n,i;
int U;
U=3; // U(0)

M. Tahrichi 13
Département GI-ESTO
printf("Donner n :");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
U=3*U+4;
}
printf("U(%d)=%d\n",n,U);
return 0;
}

Exercice 2.8
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,x,y,z;
int n;
puts("Donner n:>0 ");
scanf("%d",&n);
x=y=1;
z=x;
for(i=3;i<=n;i++)
{
z=x+y; // On somme les deux termes précédents
x=y; // il faut conserver l’avant dernier terme Un-1
y=z; // et aussi le dernier terme Un
}
printf("Fibonacci(%d)=%d\n",n,z);
return 0;
}

Exercice 2.9
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n;
int choix;

M. Tahrichi 14
Département GI-ESTO
printf("Donnez votre nombre n: ");
scanf("%d",&n);
do
{
printf("Menu :\n");
printf("1: Ajouter \n");
printf("2: Multiplier par 2\n");
printf("3: Soustraire 4\n");
printf("4: Quitter\n");
printf("Tapez votre choix entre 1 et 4: ");
scanf("%d",&choix);
switch(choix)
{
case 1: n++; printf("n=%d\n",n);break;
case 2: n*=2; printf("n=%d\n",n);break;
case 3: n-=4; printf("n=%d\n",n);break;
case 4: break;
default : printf("choix invalide\n");
}
}while(choix!=4); // On répète tant que choix n’est pas 4
return 0;
}

Exercice 2.10
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,n,cp;
int max;
printf("valeur 1 : ");
scanf("%d",&n);
max=n;
cp=1;
for(i=2;i<=10;i++)
{ printf("valeur %d : ",i);
scanf("%d",&n);
if(n==max) cp++; // On incrémente cp quand on retrouve le max
if(n>max) {max=n; cp=1;}//Quand on trouve un nouveau max on met le cp à 1
}

M. Tahrichi 15
Département GI-ESTO
printf("la max est: %d, il se répète %d fois\n",max,cp);
return 0;
}

M. Tahrichi 16
Département GI-ESTO
 TP 3 : Tableaux et pointeurs

Exercice 3.1

Écrire un programme qui déclare un tableau d’entiers de taille prédéfinie puis qui, à l’aide d’un
menu interactif, permet d’effectuer les opérations suivantes :
• afficher la taille du tableau ;
• afficher le contenu du tableau
• modifier l’élément à l’indice i ;
• échanger les valeurs de deux éléments ;
• compter le nombre d’occurrences d’une valeur ;
• afficher la plus grande et la plus petite valeur du tableau.
• afficher les indices de la plus grande et de la plus petite valeur du tableau.
• …

Exercice 3.2

Un tableau A de dimension N+1 contient N valeurs entières triées par ordre croissant ; la
(N+1)ième valeur est indéfinie. Insérer une valeur VAL donnée au clavier dans le tableau A de
manière à obtenir un tableau de N+1 valeurs triées.

Exercice 3.3

Rechercher dans un tableau d'entiers A une valeur VAL entrée au clavier. Afficher la position
de VAL si elle se trouve dans le tableau, sinon afficher un message correspondant. La valeur
POS qui est utilisée pour mémoriser la position de la valeur dans le tableau, aura la valeur -1
aussi longtemps que VAL n'a pas été trouvée.
Implémenter deux versions :
a) La recherche séquentielle : Comparer successivement les valeurs du tableau avec la valeur
donnée.
b) La recherche dichotomique.

Exercice 3.4

On considère le programme suivant :

main()
{
int A = 1; int B = 2; int C = 3;
int *P1, *P2;
P1=&A;
P2=&C;
*P1=(*P2)++;
P1=P2;

M. Tahrichi 17
Département GI-ESTO
P2=&B;
*P1-=*P2;
++*P2;
*P1*=*P2;
A=++*P2**P1;
P1=&A;
*P2=*P1/=*P2;
return 0;
}

Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus.

A B C P1 P2
Init. 1 2 3
P1=&A 1 2 3 &A
P2=&C
*P1=(*P2)++
P1=P2
P2=&B
*P1-=*P2
++*P2
*P1*=*P2
A=++*P2**P1
P1=&A
*P2=*P1/=*P2

Exercice 3.5

Soit P un pointeur qui 'pointe' sur un tableau A :

int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
int *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]).

Exercice 3.6

Ecrire un programme qui lit au clavier deux tableaux dynamiques A et B de même taille
arbitrairement choisie par l’utilisateur et qui ajoute les éléments de B à la fin de A. Utiliser le
formalisme pointeur à chaque fois que cela est possible.
N.B. Utiliser le formalisme pointeur (pas de déclaration statique et pas d’utilisation d’indice)

M. Tahrichi 18
Département GI-ESTO
Exercice 3.7

Ecrire un programme qui créé dynamiquement deux vecteurs (de double) de même taille
arbitrairement choisie par l’utilisateur, initialise les deux vecteurs à l’aide des valeurs aléatoires
(utiliser la fonction rand()), affiche les vecteurs et calcul et affiche le produit scalaire.
Exercice 3.8

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.
Exercice 3.9

Ecrire un programme 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.

Corrigé TP3

Exercice 3.1
#include <stdio.h>
#include <stdlib.h>
int main()
{
int T[50]; // déclaration d’un tableau statique de taille 50
int N,i,j,choix,aide,x,cp;
printf("Donner la dimension de votre tableau(svp <50) ");
scanf("%d",&N); // on suppose ici que N<=50.
for(i=0;i<N;i++) // la lecture du tableau
{
printf("element %d: ",i);
scanf("%d",&T[i]);
}
do
{
printf("\n++++++Menu+++++\n");
printf("1. Afficher la taille \n");
printf("2. Afficher le tableau \n");
printf("3. Modifier l element d'indice i \n");
printf("4. Echanger deux elements \n");
printf("5. calculer le nmbre d'occu d'une valeur \n");
printf("6. Quitter \n");

M. Tahrichi 19
Département GI-ESTO
printf("Tapez votre choix ");
scanf("%d",&choix);
switch(choix) // selon la valeur de la variable choix
{
case 1 :
printf("ta dim du tableau est %d \n",N);
break;
case 2 :
printf("Affichage tableau \n");
for(i=0;i<N;i++)
{
printf("%d ",T[i]);
}
break;
case 3 :
printf("donner l'indice de l’élément à modifier :");
scanf("%d",&i);
if(0<=i && i<N)
{
printf("Donner la nouvelle valeur : ");
scanf("%d",&T[i]);
}
else
printf("cet indice est hors tableau\n");
break;
case 4 :
printf("Donner les indices des éléments a échanger");
scanf("%d%d",&i,&j);
if(0<=i && i<N && 0<=j && j<N)
{
aide=T[i];
T[i]=T[j];
T[j]=aide;
}
else
printf("Ces indices sont hors tableau \n");
break;
case 5 :
printf("Donner la valeur à rechercher ");
scanf("%d",&x);

M. Tahrichi 20
Département GI-ESTO
 cp=0;
for(i=0;i<N;i++)
{
if(T[i]==x) cp++;
}
printf("cette valeur se répète %d fois",cp);
break;
case 6: break;
default : printf("Choix invalide\n");

}
}while(choix!=6); // on répète tant que le choix n’esp pas 6.
return 0;
}

Exercice 3.2
#include <stdio.h>
#include <stdlib.h>
int main()
{
int T[50];
int N,i,j;
int x;
printf("Donner la dimension de votre tab (svp <49) ");
scanf("%d",&N);
printf("svp remplir le tableau avec des valeur triées \n");
for(i=0;i<N;i++) // on suppose que l’utilisateur donnera des valeurs triées
{
printf("element %d: ",i);
scanf("%d",&T[i]);
}
printf("Donner la valeur à insérer \n");
scanf("%d",&x);
i=0;
while(i<N && T[i]<x)
i++; //on cherche tout d’abord l’emplacement ou insérer la valeur x
for(j=N;j>i;j--)
T[j]=T[j-1]; // On déplace à droite les éléments à partir de i
T[i]=x; // On insère la valeur de x à l’emplacement i
for(i=0;i<N+1;i++) // On affiche tout le tableau (dimension N+1)

M. Tahrichi 21
Département GI-ESTO
 {
printf("%d ",T[i]);
}
return 0;
}

Exercice 3.3
#include <stdio.h>
#include <stdlib.h>
int main()
{
int T[50];
int N,i,pos;
int x;
printf("Donner la dimension de votre tab (svp <50) ");
scanf("%d",&N);
printf("Remplir le tableau :\n");
for(i=0;i<N;i++)
{
printf("element %d: ",i);
scanf("%d",&T[i]);
}
printf("Donner la valeur à rechercher \n");
scanf("%d",&x);
pos=-1;
i=0;
while(i<N && T[i]!=x) // On incrément tant que on a pas trouver x
i++; // Ou on a pas arriver à la fin du tableau
if(i<N) pos=i ;
printf("la position de %d est %d\n",x,pos);//-1 si la valeur n’existe pas
return 0;
}

Exercice 3.6
#include <stdio.h>
#include <stdlib.h>
int main()
{
// déclaration des tableaux dynamiques
int *A,*B; // On réserve juste l’espace pour le pointeur

M. Tahrichi 22
Département GI-ESTO
 // On n’a pas encore la taille du tableau
int N,i;
int* ad; int* ad1; // On déclare deux pointeurs
printf("Donner la taille des deux tableaux ");
scanf("%d",&N);
B=(int*)malloc(N*sizeof(int)); // On alloue de l’espace pour le tableau B
printf("Saisir le tableau B\n");
for(ad=B;ad<B+N;ad++) // On se déplace à l’aide des adresses
{
printf("B[%d]= ",ad-B);
scanf("%d",ad);
}
A=(int*)malloc(2*N*sizeof(int)); // On alloue de l’espace pour le tableau A
// attention ici on alloue le double
// car on va ajouter le tableau B à la fin
printf("Saisir le tableau A\n");
for(ad=A;ad<A+N;ad++)
{
printf("A[%d]= ",ad-A);
scanf("%d",ad);
}
for(ad=B,ad1=A+N;ad<B+N;ad++,ad1++) // ajouter B a la fin de A
*ad1=*ad; // *ad1 désigne la valeur !!
printf("A après l’ajout de B \n");
for(ad=A;ad<A+2*N;ad++)
{
printf("%d ",*ad);
}
return 0;
}

Exercice 3.7
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int *V1,*V2; // On déclare des pointeurs <==> tableaux dynamiques
int N,i,
ps=0;// le produit scalaire

M. Tahrichi 23
Département GI-ESTO
int* ad;
printf("Donner la taille commune des deux vecteurs ");
scanf("%d",&N);
V1=(int*)malloc(N*sizeof(int));// allocation dynamique de la mémoire
V2=(int*)malloc(N*sizeof(int)); // allocation dynamique de la mémoire
srand(time(NULL)); // redémarrer le générateur de la fonction rand()
for(ad=V1;ad<V1+N;ad++)
*ad=rand()%101; // ici on obtient un nombre aléatoire entre 0 et 100
for(ad=V2;ad<V2+N;ad++)
*ad=rand()%101; // ici on obtient un nombre aléatoire entre 0 et 100
printf("\nAffichage des deux vecteurs \n");
for(ad=V1;ad<V1+N;ad++)
printf("%d ",*ad);
printf("\n");
for(ad=V2;ad<V2+N;ad++)
printf("%d ",*ad);
for(ad1=V1,ad2=V2;ad1<V1+N;ad1++,ad2++)
ps+=*ad1**ad2;
printf("Le produit scalaire est %d\n",ps);
return 0;
}

Exercice 3.8
#include <stdio.h>
#include <stdlib.h>
int main()
{
int T[50][50] ;
int L,C;
int i,j;
printf("Donner le nombre de lignes : "); scanf("%d",&L);
printf("Donner le nombre de colonnes : "); scanf("%d",&C);
printf("\nRemplissage du Tableau\n");
for(i=0;i<L;i++)
{
for(j=0;j<C;j++)
{
printf("T[%d][%d]= ",i+1,j+1);
scanf("%d",&T[i][j]);
}

M. Tahrichi 24
Département GI-ESTO
 }
printf("\nAffichage du Tableau\n");
for(i=0;i<L;i++)
{
for(j=0;j<C;j++)
{
printf("%d ",T[i][j]);
}
printf("\n");
}
return 0;
}

Exercice 3.9
#include <stdio.h>
#include <stdlib.h>
int main()
{
int T[10][10];
int V[100];
int L,C;
int i,j;
int cp=0; // un compteur à utiliser pour remplir V
printf("Donner le nombre de lignes svp<=10: "); scanf("%d",&L);
printf("Donner le nombre de colonnes svp<=10 : "); scanf("%d",&C);
printf("\nRemplissage du Tableau \n");
for(i=0;i<L;i++)
{
for(j=0;j<C;j++)
{
printf("T[%d][%d]=",i+1,j+1);
scanf("%d",&T[i][j]);
}
}
for(i=0;i<L;i++)
{
for(j=0;j<C;j++)
{
V[cp]=T[i][j]; // transfert des éléments de T dans V
cp++; // il faut augmenter cp ici

M. Tahrichi 25
Département GI-ESTO
 }
}
printf("\nAffichage du tableau unidimensionnel\n");
for(j=0;j<L*C;j++)
{
printf("%d ",V[j]);
}
return 0;
}

M. Tahrichi 26
Département GI-ESTO
 TP 4 : Les Fonctions et les chaines de caractères

Exercice 4.1
1. Ecrire La fonction LIRE_TAB à deux paramètres TAB, N, lit les N composantes d'un
tableau TAB du type int.
2. Ecrire la fonction ECRIRE_TAB à deux paramètres TAB et N qui affiche N composantes
du tableau TAB du type int.
3. Écrire la fonction SOMME_TAB qui calcule la somme des N éléments d'un tableau TAB
du type int. N et TAB sont fournis comme paramètres ; la somme est retournée comme
résultat.
4. A l'aide des fonctions précédentes, écrire un programme qui lit un tableau T d'une
dimension inférieure ou égale à 100 et affiche le tableau et la somme des éléments du
tableau.

Exercice 4.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

Exercice 4.3
Ecrire deux fonctions qui calculent la valeur XN pour une valeur réelle X (type double) et une
valeur entière positive N (type int) :
a) EXP1 retourne la valeur XN comme résultat.
b) EXP2 affecte la valeur XN à X.
Ecrire un programme qui teste les deux fonctions.

Exercice 4.4
Ecrire la fonction NCHIFFRES du type int qui obtient une valeur entière N (positive ou
négative) du type long comme paramètre et qui fournit le nombre de chiffres de N comme
résultat.
Ecrire un petit programme qui teste la fonction NCHIFFRES :
Exemple :
Introduire un nombre entier : 6457392
Le nombre 6457392 à 7 chiffres.

Exercice 4.5
1. Écrire un programme déterminant le nombre de lettres e (minuscules) présentes dans un
texte fourni au clavier.
2. Écrire un programme qui supprime tous les caractères o (minuscules) présents dans un
texte fourni au clavier. Affichez le texte modifié.
3. Écrire un programme qui lit au clavier un mot et qui l’affiche à l’envers.

M. Tahrichi 27
Département GI-ESTO
Exercice 4.6
Ecrire un programme C qui permet de lire à partir du clavier une suite de noms ne comportant
pas d'espaces et d'afficher le nombre de noms ayant plus de dix caractères. La suite se termine
lorsqu'on trappe le mot "FIN". On supposera que chaque nom ne dépasse pas 20 caractères.

Exercice 4.7
1. Écrire un programme 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.
2. Écrire une fonction qui remplace la première occurrence d'une chaîne de caractères CH1
par une chaîne CH2 dans une chaîne de caractères SUJ. Puis écrire un programme qui
remplace toutes les occurrences de CH1 par CH2 dans SUJ.

Exercice 4.8
Ecrire de deux façons différentes, un programme 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

Un palindrome est un mot qui reste le même qu'on le lise de gauche à droite ou de droite à
gauche. Exemples :
PIERRE ==> n'est pas un palindrome
OTTO ==> est un palindrome

Problème :
On souhaite modéliser des opérations permettant de gérer les articles dans un stock de magasin
à l'aide de tableaux à une dimension. On considère pour cela un tableau TabArt de chaînes de
caractères où les éléments représentent les codes des articles (10 caractères maximum), un
tableau TabStock d’entiers représentant la quantité en stock de chaque article, et un tableau
TabPrix de réels représentant les prix des articles.
Ainsi, un élément à l’indice i du tableau TabStock représente la quantité en stock de l’article de
la case i du tableau TabArt et qui a comme prix la case i du tableau TabPrix. On suppose que
les tableaux ont une capacité maximale définie par une constante max donnée (max =100).
1. Ecrire une fonction void LireArticles (char TabArt [max][10],int TabStock[], float TabPrix,
int N) permettant de remplir un tableau de chaînes de caractères TabArt de N articles, ainsi
que les tableaux TabStock et TabPrix (pour chaque article lire son code, sa quantité en stock
et son prix).
2. Ecrire une fonction void AfficherArticles (char TabArt[max][10], int TabStock[], float
TabPrix[], int N) permettant d’afficher la liste des articles avec leurs quantités en stock et
leurs prix.
3. Ecrire une fonction int QuantitéStock(char TabArt[max][10], int TabStock[], char
codeart[], int N) permettant de rechercher la quantité en stock d’un article donné (codeart)
et retourne sa quantité en stock s’il existe et -1 sinon.
4. Créer une procédure void AjouterArticle (char TabArt[max][10], int Tabstock[], float
TabPrix[], char codeart[], int qs, float px, int *N) permettant d’ajouter un article (codeart).
Cette opération consiste à ajouter le code de l’article codeart à la fin du tableau TabArt, la
quantité en stock qs dans le tableau TabStock et le prix px dans le tableau TabPrix.
M. Tahrichi 28
Département GI-ESTO
5. Ecrire une fonction void ApprovisionnerStock(char TabArt[max][10], int TabStock[], char
codeart[], int qs, int N) permettant d’approvisionner le stock d’un article en ajoutant une
quantité donnée au stock existant. Cette fonction effectue une recherche de code de l’article
dans le tableau TabArt, s’il existe alors elle ajoute la quantité qs au stock correspondant
dans le tableau TabStock, s’il n’existe pas elle affiche un message d’erreur.
6. Ecrire une fonction void MaxPrix(char TabArt[max][10], float TabPrix[],int N) qui permet
d’afficher le code et le prix de l’article le plus cher.
7. Ecrire une fonction void SupprimerArticle (char TabArt[max][10], int TabStock[], float
TabPrix[], char code[], int *N) permettant de supprimer un article stocké dans le tableau
TabArt en fournissant son code. Sa suppression entraine la suppression de sa quantité en
stock dans le tableau TabStock et de son prix du tableau TabPrix.
8. Ecrire un programme principale main() qui permet de :
a) Remplir les tableaux TabArt, TabPrix et TabStock.
b) Mettre à jour le stock d’un article donné par son code CD1 avec la quantité en stock
QT1 donnée.
c) Ajouter un article dont le code CD2, la quantité QT2 et le prix PX sont données par
l’utilisateur.
d) Supprimer les articles dont la quantité en stock est égale à 0.
e) Afficher tous les articles (code, prix et quantité).

Corrigé TP 4

Exercice 4.1
#include <stdio.h>
#include <stdlib.h>
int main()
{
void Lire_Tab(int t[],int); // déclaration des fonctions
void Affiche_Tab(int t[],int);
int Somme_Tab(int t[],int);
int T[100];
int N;
printf("Donner la dimension de votre tableau: ");
scanf("%d",&N);
Lire_Tab(T,N);
Affiche_Tab(T,N);
printf("\nLa somme des éléments de ce tableau est %d",Somme_Tab(T,N));
return 0;
}
// Définition de la fonction de lecture
void Lire_Tab(int t[],int N)
{

M. Tahrichi 29
Département GI-ESTO
int i;
printf("\nLecture du tableau\n");
for(i=0;i<N;i++)
{
printf("Element %d : ",i+1);
scanf("%d",&t[i]);
}
}
// Définition de la fonction d’affichage
void Affiche_Tab(int t[],int N)
{
int i;
printf("\nAffichage du tableau\n");
for(i=0;i<N;i++)
{
printf("%d ",t[i]);
}
}
// Définition de la fonction qui calcul la somme
int Somme_Tab(int t[],int N)
{
int i; int s=0;
for(i=0;i<N;i++)
s+=t[i];
return s;
}

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

int main()
{
int Max1(int t[],int); //Déclaration des fonctions
int Max2(int t[],int);
int* Max3(int t[],int);
int T[100];
int i,N;
printf("Donner la taille de votre tableau : ");
scanf("%d",&N);

M. Tahrichi 30
Département GI-ESTO
for(i=0;i<N;i++)
{
printf("Element %d ",i+1);
scanf("%d",&T[i]);
}
printf("La plus grande valeur de ce tableau est %d\n",Max1(T,N));
printf("Son indice est %d\n",Max2(T,N));
printf("Son adresse est %d\n",Max3(T,N));
return 0;
}
// Définition des fonctions
int Max1(int t[],int n)
{
int i;
int vmax=t[0];
for(i=1;i<n;i++)
{
if(t[i]>vmax) vmax=t[i];
}
return vmax;
}
/********************/
int Max2(int t[],int n)
{
int i;
int imax=0;
for(i=1;i<n;i++)
{
if(t[i]>t[imax]) imax=i;
}
return imax;
}
/*********************/
int* Max3(int t[],int n)
{
int* ad;
int* admax=t;
for(ad=t+1;ad<t+n;ad++)
{
if(*ad>*admax) admax=ad;

M. Tahrichi 31
Département GI-ESTO
 }
return admax;
}

Exercice 4.3
#include <stdio.h>
#include <stdlib.h>
int main()
{
double EXP1(double,int); // Déclaration des fonctions
void EXP2(double*,int);
double x=2;
int n=3;
printf("%.2lf^%d=%.2lf\n",x,n,EXP1(x,n));
EXP2(&x,n); // On transmet &x comme argument pour pouvoir modifier x
printf("Après l'appel de EXP2 x=%.2lf\n",x);
return 0;
}
double EXP1(double x,int n)
{
int i=0;
double f=1;
while(i<n)
{
f=f*x;
i++;
}
return f;
}
void EXP2(double* x,int n) // cette fonction modifie la valeur de x
{ // pour cela elle prend un pointeur
int i=0; // comme premier argument
double f=1;
while(i<n)
{
f=f**x;
i++;
}
*x=f;
}

M. Tahrichi 32
Département GI-ESTO
Exercice 4.4
#include <stdio.h>
#include <stdlib.h>
int main()
{
int x;
int cp=1;
printf("Donner un entier x ");
scanf("%d",&x);
while(x=x/10) cp++;
printf("Ce nombre à %d chiffres",cp);
return 0;
}

Exercice 4.5
#include <stdio.h>
#include <stdlib.h>
#include <string.h> //Pour manipuler les chaines de caractères
int main()
{
//1. Le nombre de 'e' dans une chaine
char s[20];
char *ad,*ad2,c;
int cp=0;
printf("Donner un mots (svp <20 caracteres) ");
scanf("%s",s);
ad=strchr(s,'e');
while(ad!=NULL)
{
cp++;
ad=strchr(ad+1,'e');
}
printf("%s contient %d 'e'\n",s,cp);
//2. Supprimer les lettres 'o'
ad=strchr(s,'o');
while(ad!=NULL)
{
strcpy(ad,ad+1);
ad=strchr(s,'o');
}

M. Tahrichi 33
Département GI-ESTO
printf("Le mot sans 'o' : %s\n",s);
//3. Inverser le mot
for(ad=s,ad2=s+strlen(s)-1;ad<ad2;ad++,ad2--)
{
c=*ad;
*ad=*ad2;
*ad2=c;
}
printf("Le mot a l'envers %s\n",s);
return 0;
}

Exercice 4.6
#include <stdio.h>
#include <stdlib.h>
int main()
{
char s[20];
int cp=0;
do
{
printf("Tapez un nom, \"FIN\" pour s'arreter ");
scanf("%s",s);
if(strlen(s)>=10) cp++;
}while(strcmp(s,"FIN"));
printf("vous avez tapez %d noms comportant plus de 10 caractères \n",cp);
return 0;
}

Exercice 4.7
#include <stdio.h>
#include <stdlib.h>
int main()
{
char ch1[20],ch2[20],ch3[20];
printf("Donner la chaine 1 :");
gets(ch1);
printf("Donner la chaine 2 : ");
gets(ch2);

M. Tahrichi 34
Département GI-ESTO
strncpy(ch3,ch1,strlen(ch1)/2); // On copie la moitié de ch1 dans ch3
ch3[strlen(ch1)/2]='\0'; // il faut ajouter la fin de chaine à ch1
strcat(ch3,ch2+strlen(ch2)/2); // On ajoute la moitié de ch2 à ch1
puts(ch3);
return 0;
}

Exercice 4.8
#include <stdio.h>
#include <stdlib.h>
int main()
{
void Remplace1(char*,char*,char*);
char ch1[40],ch2[40],suj[40];
printf("Donner la chaine 1 :");
gets(ch1);
printf("Donner la chaine 2 : ");
gets(ch2);
printf("Donner la chaine suj : ");
gets(suj);
Remplace1(suj,ch1,ch2);
printf("Après avoir remplacé toutes les occurrences de %s par %s \n",ch1,ch2);
puts(suj);
return 0;
}
// Définition de la fonction qui remplace une chaine par une autre
void Remplace1(char* suj,char* ch1,char* ch2)
{
char* aide,*ad;
aide=(char*)malloc(strlen(suj)*sizeof(int));
while(ad=strstr(suj,ch1),ad!=NULL)// Tant que ch1 existe dans suj
{
strcpy(aide,ad+strlen(ch1)); // on sauvegarde la partie de la suj
// située après la chaine ch1
strcpy(ad,ch2); // on copie ch2 à l'emplacement de ch1 dans suj
strcat(ad,aide); // On ajoute la suite sauvegardée avant
}
}

M. Tahrichi 35
Département GI-ESTO
Problème
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
void LireArt(char TA[][10],int TS[],float TP[],int);
void AfficheArt(char TA[][10],int TS[],float TP[],int);
int QuantiteStock(char TA[][10], int TS[], char codeart[],int);
void AjouterArticle(char TA[][10],int TS[],float TP[],char codeart [], int,
float,int*);
void ApprovisionnerStock(char TA[][10],int TS[],char codeart[],int,int);
void MaxPrix(char TA[][10],float TP[],int);
void SupprimerArticle(char TA[][10],int TS[],float TP[],char code[],int*);
char TabArt[100][10]; // Déclaration d'un tableau de chaines de caracètres
int TabStock[100]; //Déclaration d'un tableau de int
float TabPrix[100]; //Déclaration d'un tableau de réels
int N,i,q; float p;
char code[10];
printf("Donner le nombre d'articles: ");
scanf("%d",&N);
LireArt(TabArt,TabStock,TabPrix,N);//Lecture des articles
AfficheArt(TabArt,TabStock,TabPrix,N);// Affichage des articles
printf("Code de l'article à mettre à jour : ");
scanf("%s",code);
printf("La quantité à ajouter : ");
scanf("%d",&q);
ApprovisionnerStock(TabArt,TabStock,code,q,N);
AfficheArt(TabArt,TabStock,TabPrix,N); // Affichage des articles
printf("Article à ajouter (code,quantité,prix): ");
scanf("%s%d%f",code,&q,&p);
AjouterArticle(TabArt,TabStock,TabPrix,code,q,p,&N);//Ajouter l'article
AfficheArt(TabArt,TabStock,TabPrix,N); // Affichage des articles
MaxPrix(TabArt,TabPrix,N);// Affichage de l'article le plus cher
printf("\nLes articles de quantité 0 sont supprimés\n");
i=0;
while(i<N)
{
if(QuantiteStock(TabArt,TabStock,TabArt[i],N)==0)
SupprimerArticle(TabArt,TabStock,TabPrix,TabArt[i],&N);

M. Tahrichi 36
Département GI-ESTO
 else
i++;
}
AfficheArt(TabArt,TabStock,TabPrix,N); // Affichage des articles
return 0;
}
//Définitions des fonctions
void LireArt(char TA[][10],int TS[],float TP[],int N)
{
int i;
printf("Lecture des articles\n");
for(i=0;i<N;i++)
{
printf("\nArticle code %d: ",i+1);
scanf("%s",TA[i]); //TA[i] désigne l'adresse de la i-ème chaine
printf("\nArticle quantite %d: ",i+1);
scanf("%d",&TS[i]);
printf("\nArticle prix %d: ",i+1);
scanf("%f",&TP[i]);
}
}
void AfficheArt(char TA[][10],int TS[],float TP[],int N)
{
int i;
printf("\nAffichage des articles\n");
for(i=0;i<N;i++)
{
printf("Article %d: %s %d %.2f\n",i+1,TA[i],TS[i],TP[i]);
}
}
int QuantiteStock(char TA[][10], int TS[], char codeart[], int N)
{
int i;
for(i=0;i<N;i++)
{
if(strcmp(TA[i],codeart)==0) return TS[i];//return provoque la sortie
}
return -1;
}

M. Tahrichi 37
Département GI-ESTO
void AjouterArticle(char TA[][10],int TS[],float TP[],char codeart[],int
qs,float px, int *N)
{
strcpy(TA[*N],codeart);
TS[*N]=qs;
TP[*N]=px;
(*N)++; //On augmente la dimension N
}
void ApprovisionnerStock(char TA[][10],int TS[],char codeart[],int qs,int N)
{
int i;
for(i=0;i<N;i++)
{
if(strcmp(TA[i],codeart)==0) {TS[i]+=qs; break;}
}
if(i==N)printf("Erreur,%s n'existe pas dans le stock\n",codeart);
}
void MaxPrix(char TA[][10],float TP[],int N)
{
int i;
int pmax=0;
for(i=1;i<N;i++)
{
if(TP[i]>TP[pmax]) pmax=i;
}
printf("code article plus cher : %s\n",TA[pmax]);
printf("prix article plus cher : %f\n",TP[pmax]);
}
void SupprimerArticle (char TA[][10],int TS[],float TP[],char code[], int *N)
{
int i,j;
for(i=0;i<*N;i++)
{
if(strcmp(TA[i],code)==0)
{
for(j=i;j<*N;j++)
{ strcpy(TA[i],TA[i+1]);
TS[i]=TS[i+1];
TP[i]=TP[i+1];
}
}
M. Tahrichi 38
Département GI-ESTO
 }
(*N)--;
}

M. Tahrichi 39
Département GI-ESTO