Travaux Pratiques en Langage de Programmation C

Travaux Pratiques
Langage de programmation
Réaliser par : ELFAGRICH Mahfoud

Programmation En langage C
TP 1
Variables, instructions conditionnelles
Dans cette première séance de travaux dirigés, nous abordons les points suivants :
• Les entrées/sorties en C ;
• L es d éc la ra ti o ns de variables et de constantes ;
• Les types de base ;
• Les structures conditionnelles if et if . . . else.
1. Déclaration de variables, les types en C
Dans tout programme, le programmeur fait appel à des données. Ces données
peuvent prendre des valeurs qui peuvent évoluer pendant toute l’exécution du
programme. On parle alors de variables. Une variable a un type qui déxtermine les
valeurs que la variable peut prendre ainsi que les opérations pouvant s’y appliquer.
Nous utiliserons les types standards de C suivant : int, float et char. Commentez le
programme suivant :
int main(void)
{
int i,j ; float x,y,z ;
i=3; j=5;
x=3.0;
printf("i= %d j=%d somme = %d \n", i,j,i+j);
i=j/2;y=x/2;z=j/2;
printf("i= %d \n y=%f z =%f\n",i,y,z);
return 0;
}
2. Lecture au clavier
La lecture au clavier se fait grâce à la fonction scanf. Il faut lui indiquer exactement le
type des données à lire :
%d pour int,%f pour float, %c pour char.
Pour les deux premiers types, les espaces, tabulations et passages à la ligne sont
considérés comme des séparateurs.
De plus chaque variable à lire doit ˆêtre précédée du symbole &. Ainsi scanf("%d",&i);
scanf("%f",&x); scanf("%d",&j); lit successivement au clavier un entier affecté à la
variable i, un réel affecté à la variable x et un entier affecté à la variable j (on peut
regrouper en une seule instruction scanf("%d%f%d",&i,&x,&j), mais cela demande
plus de précaution). Comme pour printf, il doit y avoir concordance entre le type et le
nombre des valeurs à lire et les variables fournies à la fonction.
Ecrire un programme qui demande un entier à l’utilisateur, le lit au clavier puis
l’affiche entre deux lignes vides.
1
3. Manipulation de nombres
Ecrire un programme lisant quatre variables de type int, affiche ensuite chaque
valeur sur une ligne, puis leur somme et leur moyenne sur la ligne suivante.
Par exemple, si l’utilisateur entre les valeurs : 12 3 14 5
Le programme affiche :
12
3
14
5
somme = 34, moyenne = 8.5
4. Structures conditionnelles
Ecrire un programme qui lit un entier et l’affiche s’il est positif.

Ecrire un programme qui lit un entier et affiche si ce nombre est pair ou impair.
5. Echange de valeurs
Ecrire une suite d’instructions échangeant le contenu de deux variables 𝑎, 𝑏 de type int
entrées par l’utilisateur. En dénduire un programme qui effectue l’échange si 𝑎 est
inferieur a 𝑏, et qui sinon augmente de 10 la valeur de 𝑏. On affiche les nouvelles
valeurs de 𝑎 et de 𝑏.
6. Etude du nombre de solutions d’une équation du second dégrée
On veut déterminer le nombre de solutions d’une équation du second degré 𝑎 𝑥 2 +

𝑏 𝑥 + 𝑐 = 0. Nous envisagerons les cas suivants :
• Si 𝑎 = 0 et 𝑏 = 0, l’´équation est dégénérée (0 ou une infinité de solutions).

• Si 𝑎 = 0 et 𝑏 ! = 0, il y a une racine ;
• Si 𝑎 ! = 0et 𝑐 = 0, il y a deux racines ;
• Sinon, on utilise le discriminant b2 − 4ac pour d´déterminer le nombre de
solutions
– Si le déterminant est négatif, pas de racines réelles ;
– Si le déterminant est nul, une racine double ;
– Si le déterminant est positif, deux racines ;
Ecrire un programme qui lit les coefficients 𝑎, 𝑏 et 𝑐, et qui calcule le nombre de

solutions de l’´équation du second degré associée.
2
TP 2
Itérations
Dans cette séance de travaux diriges, nous abordons les points suivants:
• la boucle for(initialisation ;condition de continuation ;incrément)
• la boucle while (condition de continuation)
• la boucle do. . . while (condition de continuation)
Itérations bornées
boucle for(initialisation ;condition de continuation ;incrément)
1. Somme d’entiers
• Ecrire un programme qui calcule la somme des 10 premières valeurs entières

entrées par l’utilisateur.
• Ecrire un programme qui lit un entier positif n entre par l’utilisateur, et qui calcule la
somme d’au plus 𝑛 entiers positifs entres par l’utilisateur (si une valeur négative est
entrée, elle est ignorée).
Exemple :
Entrez le nombre maximum d’entiers a sommer ; 5
Entrez 5 valeurs : 2 -4 3 6 -1
Somme des valeurs positives : 11
2. Fonction factorielle
On définit la factorielle d’un entier n de la manière suivante :
𝑛𝑜𝑛 𝑑é𝑓𝑖𝑛𝑖 𝑠𝑖 𝑛 < 0

𝑛! = {
1 × 2 × …𝑛 > 0
Ecrire un programme qui affiche la factorielle d’un entier n entré par l’utilisateur. Le
programme affiche un message d’erreur si l’utilisateur entre un entier nńégatif.
1
3. Affichage d’un triangle

Ecrire un programme qui lit un entier 𝑛 entré par l’utilisateur et affiche un triangle isocèle de
base 2𝑛 − 1 et de hauteur n. Par exemple, pour 𝑛 = 4 :
*
**
***
****
***
**
*
Comment permettre l’utilisateur de choisir le symbole utilisé ?
Itérations non bornées :

boucle while et do ... while
4. Valeur maximale et minimale d’une suite d’entiers

On cherche à déterminer la valeur minimale et la valeur maximale d’une suite d’entiers
positifs entrés au clavier par l’utilisateur. On ne possédé aucune information sur le nombre
d’éléments de cette suite.
Ecrire un programme qui effectue la saisie d’une suite d’entiers. La saisie s’arrête lorsqu’un
nombre négatif est entré. Le programme affichera alors la valeur minimale, ainsi que la
valeur maximale de la suite d’entiers lus.
5. Somme
On veut lire au clavier un entier strictement positif. Pour cela on répète la lecture si
l’utilisateur entre une valeur incorrecte. Ecrire un programme qui lit un entier positif n
entré par l’utilisateur, et qui calcule la somme de exactement n entiers positifs entrés par
l’utilisateur (si une valeur négative est entrée, elle est ignorée).
6. Saisie d’une suite croissante

On veut effectuer la saisie contrôlée d’une suite croissante d’entiers non nuls entrée au
clavier par l’utilisateur. Le programme ne tient compte que des valeurs supérieures
à la valeur précédemment accepte. La saisie s’arrête lorsque l’utilisateur entre 0, et le
programme affiche le nombre d’entiers pris en compte ainsi que leur somme. Par exemple,
pour la suite (le symbole ↑ montre les valeurs prises en compte) :
−1 2 4 2 4 5 0
↑ ↑ ↑ ↑
Le programme affichera :
Nombre d’éléments : 4, somme : 10
2
TP3
Fonctions, transmission des
paramètres
Dans cette séance de travaux pratiques, nous abordons l’utilisation des
fonctions. Nous allons voir comment un problème peut être résolu en le
décomposant en plusieurs sous-problèmes plus simples.
Une partie des exercices de cette feuille concerne les nombres premiers.
Fonctions ne renvoyant pas de valeur
1. Table de multiplication
• Ecrire une fonction Multiple prenant en argument un entier n et qui affiche

sur une ligne les 10 premiers multiples de n. Par exemple, Multiples (2)
affichera :
0 2 4 6 8 10 12 14 16 18
• En déduire un programme Table qui affiche sur des lignes consécutives les
10 premiers multiples de 𝑝 pour 𝑝 variant de 1 a` 10.
2. Test de primalité
Un nombre est dit premier si ses seuls diviseurs sont 1 et lui-même. Par
convention, 1 n’est pas premier.
• Décrire la suite d’instructions permettant de déterminer si un nombre est

premier (algorithme).
• En dénduire une fonction AffichePremier qui prend en argument un
entier 𝑛 et qui affiche un message indiquant si l’entier n est premier ou
non.
Fonctions renvoyant une valeur
1. Ecrire une fonction Deuxpremiers qui recroît deux entiers et affiche les
messages :
Aucun des nombres n’est premier
Un seul nombre est premier
Les deux nombres sont premiers
On pourra transformer la fonction AffichePremier en une fonction EstPremier
qui renvoie la valeur 1 si le nombre est premier et l’entier 0 sinon. Ce choix
permet d’utiliser la valeur de retour par exemple dans un test.
2. Nombre premier supérieur un entier 𝒏

3. Ecrire une fonction PremierSuperieur prenant en argument un entier n et qui a
pour valeur le premier nombre premier supérieur ou égal à 𝑛.
1
4. Liste des nombres premiers

Ecrire une fonction PremiersPremiers prenant en argument un entier n et qui
affiche les nombres premiers inferieurs à 𝑛.
5. Nombres premiers jumeaux
Par définition, deux nombres premiers sont jumeaux si et seulement si leur
différence est égale à 2. Par exemple, 11 et 13 sont jumeaux. Ecrire une
fonction Jumelle prenant en argument un entier n positif qui affiche les couples
de nombres premiers jumeaux inferieurs à 𝑛 .
6. Décomposition en facteurs premiers
On cherche à afficher la d´décomposition en facteurs premiers d’un entier n.
• Trouver un algorithme qui détermine la décomposition en facteurs

premiers d’un entier n.
• En déduire une fonction Décomposition qui affiche la décomposition d’un
entier en facteurs premiers.
On pourra bien entendu utiliser les fonctions écrites
précédemment. Par exemple pour 8712, on aimerait avoir
l’affichage :
2^3 ∗ 3^2 ∗ 11^2
Papier, caillou, ciseaux
On veut ´écrire un programme permettant de jouer au jeu “papier, caillou,

ciseau“. On codera caillou par 0, papier par 1 et ciseaux par 2. Chaque joueur
propose son pari en tapant 0, 1 ou 2. Pour déterminer lequel des deux joueurs a`
gagné, on utilise l’algorithme suivant :
Soit J1 le pari du joueur 1 et J2 celui du joueur 2.
- Si J1 et J2 sont identiques le match est nul,

- J1 gagne si J1 = (J2 + 1) mod 3,
- J2 gagne dans le cas restant.
Pour ceci :
• Ecrire une fonction LireInf2 qui effectue la saisie contrôlée d’un entier entre 0
et 2.
• Ecrire une fonction arbitre qui recoit les paris des deux joueurs et qui renvoie
0 si le match et nul, 1 si le joueur 1 a gagné et 2 si c’est le joueur 2.
• Ecrire un programme qui arbitre 10 parties et qui affiche le score.
2
TP4
Fonctions, transmission des paramètres
Dans cette séance de travaux pratiques, nous approfondissons l’utilisation des fonctions.
Pour qu’une fonction puisse changer la valeur d’une variable, il est nécessaire de faire
précéder cette variable par &au moment de l’appel et faire précéder le paramètre dans la
définition de fonction par *.
1. Echange de deux valeurs
Ecrire une fonction Echange qui réalise l’´échange de deux valeurs entières
passées en argument.
2. Lecture contrôlée d’un entier strictement positif
Ecrire une fonction void LirePositif(int *n) qui réalise la lecture contrôlée d’un
entier strictement positif. Cette fonction affiche un message indiquant qu’une
valeur positive est attendue et répète la lecture jusqu’à ce que l’utilisateur entre
un entier positif. On pourra utiliser une variable locale pour la lecture de l’entier
au clavier.
3. Valeurs minimum et maximum d’une liste de 𝒏 valeurs entières
• Comment une fonction peut-elle transmettre plus d’une seule valeur la

partie du programme qui l’a appelé ?
• Ecrire une fonction MinMax qui transmet à la partie appelante le
minimum et le maximum de n entiers lus au clavier, ou 𝑛 est un
paramètre de la fonction.
• Ecrire un programme permettant de lire un entier positif net d’afficher le
minimum et le maximum de n valeurs lues au clavier.
4. Simplification de deux nombres repré

sentant une fraction
• Ecrire une fonction Simplifie qui recroît deux valeurs en paramètre

représentant le numérateur et le d´dénominateur d’une fraction et
transforme ces valeurs en numérateur et dénominateur d’une fraction
´équivalente simplifiée. Par exemple, si les variables données initialement
ont pour valeur 3 et 12, leur valeur après
• Exécution de la procédure sera ¼ ou 4
• La procédure recroît une fraction valide (c’est-à-dire, que le
dénominateur n’est pas nul).
• Ecrire une fonction qui réalise le même travail que la fonction Simplifie
mais qui indique une erreur grâce à la valeur retournée si le
dénominateur de la première fraction est nul.
1
TP 5
Tableaux
Dans cette séance de travaux pratiques, nous introduisons les structures de données
“tableaux”. Nous allons travailler sur des tableaux de taille 𝑁 (𝑁 est une constante définie dans
le programme).
Rappels
• Définition de constante symbolique
#define N 5 est une instruction du précompilateur. Toute apparition de N hors d’une

chaîne de caractères sera remplacée par 5.
• Tableau
Un tableau en C est une suite indicée d’éléments du même type. Les indices
commencent impérativement à l’indice 0. Une variable tableau est déclarée par :
Type des ´éléments Nom[taille] ;
1. Accès aux cases d’un tableau
Ecrire un programme qui déclare un tableau de N entiers et la valeur -1 dans toutes les
cases. Quel est l’intérêt d’utiliser une constante symbolique pour définir la taille du
tableau ?
ATTENTION C’est au programmeur de vérifier que les indices utilisés ne dépassent
pas la taille du tableau.
Tableaux et fonctions
L’indication qu’un paramètre est un tableau se fait uniquement par les [] : par
exemple void affiche (int suite [], ,). Il peut être nécessaire de transmettre à la fonction
la taille du tableau.
L’affectation d’une case d’un tableau transmis en paramètre d’une fonction change
définitivement la valeur de la case. Le passage du tableau en paramètre est toujours
un passage par adresse. En fait le C identifie le tableau et l’adresse de son premier
élément.
2. Lecture, affichage d’un tableau
• Ecrire une fonction Affichage prenant en argument un tableau T de N
entiers et qui effectue l’affichage de ce tableau.
• Ecrire une fonction Lecture qui prend un tableau T de N entiers en
argument et qui remplit le tableau T avec N entiers lus au clavier.
3. Calcul d’une moyenne
• Ecrire une fonction Moyenne prenant en argument un tableau T de N réels

et qui calcule la moyenne des éléments de ce tableau.
1
• En déduire une fonction SuperieurMoy qui compte le nombre d’éléments

supérieurs à la moyenne des éléments du tableau T donné en argument.
4. Modification dans un tableau
Ecrire une fonction Modif prenant en argument un tableau T et un entier i et qui
remplace la valeur T[i] par T[i]+2 (que faut-il vérifier ?) On effectuera un affichage du
tableau T après l’appel à Modif.
5. Tableau a deux dimensions
Définir un tableau carré à deux dimensions (N × N) de caractères Saisir les

coordonnées d’une case de ce tableau (indices de ligne et de colonne), et placer * dans
cette case. Placer des + dans les diagonales du tableau passant par ce point, et des
blancs partout ailleurs. Faire afficher le tableau ligne par ligne.
6. Triangle de Pascal
Les coefficients binomiaux formant le triangle de Pascal sont liés par les relations de
récurrence suivantes :
𝑘+1
𝐶𝑛+1 = 𝐶𝑛𝑘 + 𝐶𝑛𝑘+1 .
Nous voulons afficher le triangle de Pascal jusqu’à l’ordre 𝑁 .

Nous proposons de résoudre ce problème en utilisant trois structures différentes :
o Un tableau à deux dimensions de taille 𝑁 × 𝑁 ( la case T[i][j] contient 𝐶𝑗𝑖 deux
tableaux de taille 𝑁 ;
o Un tableau de taille 𝑁 .
Dans chaque cas, d´écrire la méthode utilisée et écrire la fonction AffichePascal qui
réalise l’affichage du triangle de Pascal.
2
TP6
Chaîne de caractères
Une chaîne de caractères en C est un tableau de char particulier. Les caractères à
prendre en compte dans le tableau sont en effet suivis par un caractère spécial, utilisé
comme marqueur de fin de mot : il s’agit du caractère de code ASCII 0, noté ’\0’.
Dans toute la suite de cette feuille, on travaillera sur des tableaux contenant au plus
MAXLET- TRES caractères, donc sur des chaînes contenant au plus MAXLETTRES−1
caractères différents de ’\0.
Rappels
Format pour lecture et écriture
• Le format chaîne de caractères est indiqué aux fonctions scanf et printf par %s.
• La fonction scanf remplace le premier séparateur (espace, tabulation ou passage à
la ligne) par ’\0’.
• La fonction printf n’affiche pas le ’\0’.
• Aucune vérification sur la validité des données n’est faite par ces fonctions : pas de
vérification que la place réservée est suffisante, ni que le symbole ’\0’ est présent.
• La fonction gets (char Mot[]) permet de lire une ligne formée de plusieurs mots. La
ligne est placée dans le tableau mot après avoir été changée en chaine de caractères,
c’est à dire que le caractère de fin de ligne (’ \n’) est remplacé par le caractère de fin
de mot (’\0’)
On supposera dans la suite que les chaînes manipulées sont correctes.
1. Saisie et affichage d’une chaîne de caractères

• Ecrire un programme qui lit une chaîne de caractères entrée par l’utilisateur et
qui l’affiche ensuite à l’´écran. La chaîne saisie sera stockée dans un tableau.
Utiliser le format %s de la fonction scanf.
• Ecrire une fonction SaisieLigneControlee qui prend un tableau de caractères t
de taille MAXLETTTRES en paramètres, qui effectue la saisie d’une ligne entrée
au clavier et la stocke dans le tableau passé en paramètre, sous forme d’une
chaîne. On pourra utiliser la valeur de retour pour indiquer si toute la ligne a
pu effectivement ˆêtre stockée. . .
2. Longueur d’une chaîne

Ecrire une fonction Longueur qui recroît une chaîne de caractères et renvoie le
nombre de caractères qu’elle contient (c’est à dire les caractères avant le premier
’\0’).
1
3. Nombre de chiffres
Ecrire une fonction NombreChiffres qui recroît une chaîne de caractères et renvoie
le nombre de chiffres qu’elle contient.
4. Différent
Ecrire une fonction Diffèrent qui recroît deux chaînes de caractères et qui renvoie 1
si elles sont différentes et 0 sinon.
5. Copie
E Ecrire une fonction Copie qui recroît deux chaînes de caractères et qui copie la
première dans la seconde.
6. Mise en majuscule
Ecrire une fonction MetEnMajuscule qui recroît une chaîne de caractères et met en
majuscule les lettres minuscules contenues dans cette chaîne.
7. Suppression des caractères non alphabétiques
Ecrire une fonction SupprimeNonAlphabetique qui recroît une chaîne de caractères
et supprime de cette chaîne les caractères qui ne sont pas alphabétiques. La
fonction renverra la longueur de la chaine obtenue après suppression.
8. Palindromes
Un mot est un palindrome s’il peut être lu indifféremment de droite à gauche ou de
gauche à droite (comme ´été, laval, . . .). On étend cette définition aux phrases en
ignorant les séparateurs, la ponctuation et la différence entre minuscules et
majuscules (ex : Esope reste et se repose.). Le but de l’exercice est de déterminer si
une phrase est un palindrome. Comment procéder pour ne pas transformer la
phrase d’origine ?
• Première méthode.
Ecrire une fonction Miroir qui recroît une chaîne de caractères et la remplace
par la chaîne écrite en sens inverse. Utiliser Miroir pour d´déterminer si une
chaîne est un palindrome.
• Deuxième méthode.
Procéder directement sur la chaîne à tester. On pourra même ´écrire une
fonction ne nécessitant pas de “nettoyer” la chaîne.
2
TD 7
Structures
Nous utiliserons dans ce TP la notion de structure, définie à l’aide de struct qui

permet de regrouper dans une même variable plusieurs informations de types
différents.
1. Définition de nom de type
Définir un type Date pour des variables formées d’un numéro de jour, d’un
nom de mois et d’un numéro d’année.
Ecrire la d´déclaration d’un type Fiche permettant de m´mémoriser les
informations sur un étudiant :
• Son nom ;
• Son prénom ;
• Sa date de Naissance, de type Date ;
• Sa formation, représentée par deux lettres ;
• S’il est redoublant ou non ;
• Son groupe de TD, représenté par un entier ;
• Ses notes, représentées par un tableau note d’au plus MAXNOTES réels ;
• Un entier nb notes indiquant le nombre de notes valides dans le tableau
note.
2. Polynômes
o Définir un type Polynômes permettant de manipuler des polynômes à une

variable, a coefficients réels de degré inferieur à DGMAX.
o Ecrire une fonction LirePolynome effectuant la saisie monôme par
monôme d’un polynôme. Pour chaque monôme, on indiquera le degré
puis le coefficient.
3. Rationnel
o Définir un type Rationnel composé de deux entiers : un numérateur et un

dénominateur.
o Ecrire une fonction LireRationnel qui effectue la lecture d’un rationnel

valide. Le rationnel mémorisé aura été simplifié.
o Ecrire une fonction SommeRationnel qui retourne la somme des deux

rationnels valides passés en argument. Le rationnel retourné aura ´été
simplifié.
1
4. Fiche
o Ecrire des fonctions de lecture et d’écriture d’une variable de type Date.
o Dans un premier temps, on ne se préoccupera pas de la validité de la date

entrée.
o Ecrire les fonctions LireFiche et EcrireFiche de lecture et d´écriture d’une

Fiche. Aucune note n’est entrée par la fonction LireFiche.
o Ecrire une fonction AjouteNote qui recroît une Fiche et ajoute une note, si
cela est possible.
o Ecrire une fonction Moyenne qui recroît une Fiche et renvoie, si cela est
possible, la moyenne des notes de l’étudiant.
2
TP 8
Tableau de structures
Nous utiliserons dans ce TP la structure de fiche définie dans le TP précédant.
1. Définitions de type
Définir un type Classe permettant de mémoriser au plus MAXELEVES Fiches.
2. Lecture et é́criture
En utilisant les fonctions précédemment définies, écrire les fonctions LireClasse et Ecrire-
Classe permettant la saisie ou l’affichage des fiches des élèves d’une classe.
• Ecrire une fonction MoyenneEleve prenant en argument une classe et une variable Nom de
type chaine de caractères et permettant de calculer la moyenne des notes d’un étudiant dont
le nom est égal à Nom.
• Ecrire une fonction Meilleure qui affiche les coordonnées de ou des étudiants ayant obtenu la
meilleure moyenne d’une classe (on utilisera un tableau défini localement).
• Ecrire une fonction SaisieOrdonnee qui ordonne alphabétiquement les fiches des étudiants au
moment de la saisie. On écrira pour cela une fonction insertion effectuant l’insertion d’une
fiche dans un tableau déjà ordonne.
3. Tri
Déduire de l’exercice précédent un algorithme de tri d’un tableau.
1
Remarque
Les corrections des exercices seront disponibles qu'au fur et à mesure du déroulement des
travaux pratiques à la fin de chaque séance.
Prog. C ---- Corrigé du TP n°1
Exercice 1.
/* Un programme C qui fait quelques opérations arithmétiques et affiche leurs résultats */
#include <stdio.h>
/* La ligne #include <stdio.h> est nécessaire pour permettre l'utilisation
des fonctions printf et scanf. Sans entrer dans les détails pour le moment,
disons simplement que cette ligne permet d'inclure un fichier contenant les
prototypes de toutes les fonctions d'entrée / sortie de base. */
int main(void) /* Lorsqu'un programme est chargé, son exécution commence par l'appel d'une
fonction spéciale du programme. Cette fonction doit impérativement s'appele
« main » pour que le compilateur puisse savoir que c'est cette fonction qui
marque le début du programme. La fonction main est appelée par le système
d'exploitation. La fonction <main> peut aussi recevoir des paramètres du
système d'exploitation. Ceci sera expliqué plus tard. Pour l'instant, on se
contentera d'une fonction main ne prenant pas de paramètre.*/
{
int i,j ; /* Déclarer deux variables (i et j) de type entier */
float x,y,z ; /* Déclarer trois variables (x, y, et z) de type entier float*/
i=3; /* Affecter la valeur 3 à la variable i de type entier*/
j=5; /* Affecter la valeur 5 à la variable i de type entier*/
x=3.0; /* Affecter la valeur 3.0 à la variable x de type float*/
printf("i= %d j=%d somme = %d \n", i,j,i+j); /* Afficher les valeurs de i, j et leur somme */
i=j/2;y=x/2;z=j/2; /* Faire quelques opérations arithmétiques. */
printf("i= %d \n y=%f z =%f\n",i,y,z); /* Afficher les valeurs de i, y et z*/
return 0; /* Sortir de la fonction <main> */

/* La fonction main doit renvoyer un code d'erreur d'exécution du programme,
le type de ce code est int. La valeur 0 retournée par la fonction main
indique que tout s'est déroulé correctement. En réalité, la valeur du code
de retour peut être interprétée différemment selon le système d'exploitation
utilisé.*/
Exercice 2.
#include <stdio.h>
main() {
int i;
printf("Entrez un entier :");

scanf("%d", &i);
printf("\n %d \n\n", i);
return 0;
}
Exercice 3.
#include <stdio.h>
main() {
int i, j, k, l;
printf("Entrez 4 entiers: ");

scanf("%d%d%d%d",&i,&j,&k,&l);
printf("\n%d\n%d\n%d\n%d\n", i, j, k, l);
printf("somme = %d, moyenne = %f\n", i+j+k+l, (i+j+k+l)/4.0);
return 0;
}
Exercice 4-a.
#include <stdio.h>
main() {
int i;
printf("Entrez un entier : "); scanf("%d", &i);
if (i>0) printf("\n%d est positif\n\n", i);
return 0;
}
Exercice 4-b.
#include <stdio.h>
main() {
int i;
printf("Entrez un entier : "); scanf("%d", &i);
if (i % 2 == 0)
printf("\n%d est pair\n\n", i);
else
printf("\n%d est impair\n\n", i);
return 0;
}
Exercice 5.
#include <stdio.h>
main() {
int a, b, temp;
printf("Entrez deux entiers (a et b): "); scanf("%d%d", &a, &b);if
(a < b ) {
temp = a;
a = b;
b = temp;
}
else
b = b + 10;
printf("\na = %d, b = %d\n\n", a, b);

return 0;
}
Exercice 6.
#include <stdio.h>
#include <math.h>
main () {
float a, b, c, x1, x2, d;
printf("Entrez les coefficients a,b et c :");

scanf("%f%f%f", &a, &b, &c);
if (a == 0 && b == 0)
printf("\nl'équation est dégénérée.\n\n");
else if (a == 0 && b != 0)
printf("\nIl y a une racine, x = %f.\n\n", -c/b);
else if (a != 0 && c == 0) {
x1 = 0.0;
x2 = (-b - b)/(2*a);
printf("\nIl y a deux racines, x1 = %f et x2= %f\n\n", x1, x2);
}
else {
d = b*b - 4*a*c;
if (d < 0)
printf("\nIl n'y a pas de racines réelles.\n\n");
else if (d == 0)
printf("\nIl y a une racine double, x1 = x2 = %f\n\n", -b/(2*a));else
{
x1 = (-b + sqrt(d))/(2*a);
x2 = (-b - sqrt(d))/(2*a);
printf("\nIl y a deux racines, x1 = %f et x2 = %f\n\n", x1, x2);
}
}
return 0;
}
Exercice-1
#include <stdio.h>
int main(void) {
int i, x, somme=0;
for (i=0; i<10; i++) {

printf("Entrez un entier: ");
scanf("%d", &x);
somme = somme + x;
}
printf("La somme de 10 entires entrées est = %d\n", somme);
return 0;
}
Exercice-1-b
#include <stdio.h>
int main(void) {
int i, n, x, somme=0;
printf("Entrez le nombre maximum d’entiers a sommer:");scanf("%d",

&n);
for (i=0; i<n; i++) {

printf("Entrez valeur N° %d :", i + 1);
scanf("%d", &x);
if (x > 0) somme += x;
}
printf("Somme des valeurs positives : %d\n", somme);
return 0;
}
Exercice-2
#include <stdio.h>
int main(void) {
int i, n, factorielle;
printf("\nEntrez un entier :"); scanf("%d", &n);
if (n < 0)
printf("\nUn entier négatif est entré, la factorielle est non défini.\n\n");
else {
factorielle = 1;
for(i=1; i<=n; i++)
factorielle *= i;
printf("\nLa factorielle de %d est %d\n\n", n, factorielle);
}
return 0;
}
Exercice-3
#include <stdio.h>
int main(void) {
int i, j, n;
printf("\nEntrez un entier: "); scanf("%d", &n);
for (i=0; i<n; i++) {

for (j=0; j < i+1; j++)
printf("*");
printf("\n");
}
for (i=0; i<n; i++) {
for (j=0; j < n - i - 1; j++)
printf("*");
printf("\n");
}
return 0;
}
Exercice-3-b
#include <stdio.h>
int main(void) {
int i, j, n;
char c;
printf("\nEntrez un entier: "); scanf("%d", &n);

printf("Entrez un caractère: "); scanf(" %c", &c);
for (i=0; i<n; i++) {
for (j=0; j < i+1; j++)
printf("%c", c);
printf("\n");
}
for (i=0; i<n; i++) {
for (j=0; j < n - i - 1; j++)
printf("%c", c);
printf("\n");
}
return 0;
}
Exercice-4
#include <stdio.h>
int main(void) {
int n, min, max;
printf("Entrez un entier :"); scanf("%d", &n);

if (n >= 0) {
min = n;
max = n;
do {
printf("Entrez un entier :"); scanf("%d", &n);
if (n >= 0) {
if (min > n) min = n;
if (max < n) max = n;
}
} while (n >= 0);
printf("La valeur minimale entrée est %d\n", min);

printf("La valeur maximale entrée est %d\n", max);
}
else
printf("Le première nombre entré est négatif... \n");
return 0;
}
Exercice-5
#include <stdio.h>
int main(void) {
int i, n, somme, x;
do {
printf("Entrez un entier positif:");
scanf("%d", &n);
} while (n <= 0);
somme = 0;
i=1;
printf("Maintenant, entrez %d entiers positifs\n", n);
while (i <= n) {
printf("Entrez entier n° %d (positif): ", i); scanf("%d", &x);
if (x > 0) {
somme += x;
i++;
}
}
printf("\nLa somme de %d entiers positifs entrés est %d\n", n, somme);
return 0;
}
Exercice-6
include <stdio.h>
int main(void) {
int count, x, somme=0, lmax;
printf("Entrez un entier: "); scanf("%d", &x);

lmax=x; count=0;
while (x != 0) {
printf("Entrez un entier: "); scanf("%d", &x);
if (x > lmax) {
somme += lmax;
count++;
lmax = x;
}
}
if (lmax != 0) {
somme += lmax;
count++;
}
printf("\nNombre d’éléments : %d, somme : %d\n", count, somme);
return 0;
}
================================================================================================
Fonctions ne renvoyant pas de valeur

==========================================
Exercice 1. (Table de multiplication)
#include <stdio.h>
void Multiples(int n);
int main(void) {
int j;
for (j=1; j<=10; j++) {
Multiples(j);
printf("\n");
}
return 0;
}
void Multiples(int n) {
int i;
for (i=0; i<10; i++) printf("%3d ", n*i);
}
Exercice 2. (Test de primalité)
#include <stdio.h>
void AffichePremier(int n);
int main(void) {
int test;
do {
printf("Entrez un entier positif : ");
scanf("%d", &test);
if (test < 0)
printf("%d est un numbre negatif. (il faut un numbre positif).\n", test);
} while (test < 0);
AffichePremier(test);
return 0;
}
void AffichePremier(int n) {
int i, estPremier = 1;
if (n == 1 || n == 0) estPremier = 0;
for (i = 2; i < n; i++) {
if (n % i == 0) {
estPremier = 0;
break;
}
}
if (estPremier)
printf("\n%d est un nombre premier.\n\n", n);
else
printf("\n%d n'est pas un nombre premier.\n\n", n);
}
Fonctions renvoyant une valeur
==========================================
Exercice 1. (Test de primalité)
#include <stdio.h>
int EstPremier(int n);

void DeuxPremiers(int, int);
int main(void) {
int n1, n2;
do {
scanf("%d%d", &n1, &n2);
if (n1 < 0 || n2 < 0)
printf("(n1= %d, n2= %d) - Il faut entrer deux numbres positifs).\n", n1, n2);
} while (n1 < 0 || n2 < 0);
DeuxPremiers(n1, n2);
return 0;
}
void DeuxPremiers(int n, int m) {
if (EstPremier(n) && EstPremier(m))

printf("\nLes deux nombres sont premiers.\n\n");
else if (!EstPremier(n) && !EstPremier(m))
printf("\nAucun des nombres n’est premier.\n\n");
else
printf("\nUn seul nombre est premier.\n\n");
}
int EstPremier(int n) {
if (n == 1 || n == 0) estPremier = 0;
for (i = 2; i < n; i++) {
if (n % i == 0) {
estPremier = 0;
break;
}
}
return (estPremier);
}
Exercice 2. (Nombre premier supérieur un entier n)
#include <stdio.h>

int PremierSuperieur(int n);
int main(void) {
int n;
do {
scanf("%d", &n);
if (n < 0)
printf("%d est un numbre negatif. (il faut un numbre positif).\n", n);
} while (n < 0);
printf("Le premier nombre premier superieur ou egal a %d est %d\n", n, PremierSuperieur(n));
return 0;
}
int PremierSuperieur(int n) {
for (;!EstPremier(n); n++);
return (n);
}
if (n == 1 || n == 0) estPremier = 0;
for (i = 2; i < n; i++) {

if (n % i == 0) {
estPremier = 0;
break;
}
}
}
Exercice 3. (Liste des nombres premiers)
#include <stdio.h>

void PremiersPremiers(int n);
int main(void) {
int n;
do {
scanf("%d", &n);
if (n < 0)
} while (n < 0);
PremiersPremiers(n);
return 0;
}
void PremiersPremiers(int n) {
int i;
printf("\nLes nombres premiers inferieurs a %d: ", n);

for (i = 2; i < n; i++)
if (EstPremier(i)) printf("%d ", i);
printf("\n\n");
}
if (n == 1 || n == 0) estPremier = 0;
for (i = 2; i < n; i++) {

if (n % i == 0) {
estPremier = 0;
break;
}
}
}
Exercice 4. (Nombres premiers jumeaux)
#include <stdio.h>

void Jumeaux(int n);
int main(void) {
int n;
do {
scanf("%d", &n);
if (n < 0)
} while (n < 0);
Jumeaux(n);
return 0;
}
void Jumeaux(int n) {
int i;
if (n <= 4)
printf("Pas de couples..\n");
else {
printf("\nLes couples de nombres premiers jumeaux inferieurs a %d: \n", n);for
(i = 2; i < n; i++)
if (EstPremier(i) && EstPremier(i+2)) printf("(%d, %d)\n", i, i+2);
}
}
if (n == 1 || n == 0) estPremier = 0;
for (i = 2; i < n; i++) {
if (n % i == 0) {
estPremier = 0;
break;
}
}
}
Exercice 5. (Décomposition en facteurs premiers)
#include <stdio.h>

void Decomposition(int n);
int main(void) {
int n;
do {
scanf("%d", &n);
if (n < 0)
} while (n < 0);
Decomposition(n);
return 0;
}
void Decomposition(int n) {
int divisor=2, power=0, flag=0;
printf("\nla decomposition en facteurs premiers de %d = ", n);

while (n >= divisor) {
if (n % divisor == 0) {
power += 1;
n = n / divisor;
flag = 1;
}
else {
if (flag) printf("%d^%d * ", divisor, power);
divisor++;
power=0;
flag = 0;
}
}
if (flag) printf("%d^%d", divisor, power);
printf("\n\n");
}
if (n == 1 || n == 0) estPremier = 0;
for (i = 2; i < n; i++) {
if (n % i == 0) {
estPremier = 0;
break;
}
}
}
Exercice 6. (Papier, caillou, ciseaux)
#include <stdio.h>
int LireInf2(void);
int arbitre(void);
int main(void) {
int j1=0, j2=0;
int i;
for ( i = 0 ; i < 10 ; i++ )

switch (arbitre()) {
case 1: j1++; break;
case 2: j2++; break;
default: break;
}
printf("\nScores :\n\tJoueur 1: %d\n\tJoueur 2: %d\n\n",j1, j2);
return 0;
}
int LireInf2(void) {
int i;
do {
printf("Entrez votre pari (0, 1, ou, 2): ");
scanf("%d",&i);
if (i < 0 || i > 2)
printf("\nIl faut entrer 0, 1, ou 2 !!!\n\n");
} while (i < 0 || i > 2);
return i;
}
int arbitre(void) {
int J1, J2;
printf("Codification :\n\tcaillou = 0\n\tpapier = 1\n\tciseau = 2\n");

printf("pari du joueur 1 :");
J1 = LireInf2();
printf("pari du joueur 2 :");
J2 = LireInf2();
if (J1==J2) return 0;
if (J1==((J2+1)%3)) return 1;
return 2;
}
/*
Exercice 1. Echange de deux valeurs
Ecrire une fonction Echange qui réalise l’échange de deux valeurs entières passées en
argument. */
#include <stdio.h>
void Echange(int *, int *);
int main(void) {
int x, y;
printf("Entrez deux entiers: ");

scanf("%d%d", &x, &y);
printf("\nAvant d'appeler fonction Echange:\n\tx = %d\n\ty = %d\n", x, y);Echange(&x,
&y);
printf("\nAprès d'appeler fonction Echange:\n\tx = %d\n\ty = %d\n", x, y);
return 0;
}
void Echange(int *a, int *b) {

int temp=*a;
*a = *b;
*b = temp;
}
/* Exercice 2. Lecture contrôlée d’un entier strictement positif

Ecrire une fonction void LirePositif(int *n) qui réalise la lecture contrôlée d’un
entier strictement positif. Cette fonction affiche un message indiquant qu’une valeur
positive est attendue et répète la lecture jusqu’à ce que l’utilisateur entre un entier
positif. On pourra utiliser une variable locale pour la lecture de l’entier au clavier. */
#include <stdio.h>
void LirePositif(int *);
int main(void) {
int value;
LirePositif(&value);
printf("\nLa valeur entree est %d\n", value);
return 0;
}
void LirePositif(int *valeur) {
do {
printf("Entrez un entier positif ?: ");
scanf("%d", valeur);
if ((*valeur) < 0) {
printf(" <--- %d est une valeur negative --->\n", (*valeur));
}
} while ((*valeur) < 0);
}
/* Exercice 3. Valeurs minimum et maximum d’une liste de n valeurs entières
• Comment une fonction peut-elle transmettre plus d’une seule valeur la partie du
programme qui l’a appele ?
• Ecrire une fonction MinMax qui transmet à la partie appelante le minimum et le
maximum de n entiers lus au clavier, où n est un paramétre de la fonction.
• Ecrire un programme permettant de lire un entier positif n d’afficher le minimum
et le maximum de n valeurs lues au clavier.
*/
#include <stdio.h>
void MinMax(int n, int *min, int *max);

void LirePositif(int *valeur);
int main(void) {
int n, min, max;
LirePositif(&n);
MinMax(n, &min, &max);
if (n) {
printf("Le minimum et Le maximum de %d valeurs lues au clavier sont:\n", n);
printf("\tLe minimum est %d\n\tLe maximum est %d\n", min, max);
}
return 0;
}
void MinMax(int n, int *min, int *max) {

int valeur_lue, compteur=0;
if (n==0) { printf("\n<--- n = 0 --->\n\n"); return; }

printf("\nEntrez %d valeurs entières\n", n);
printf("Entrez la valeur N°%d ?--> ", ++compteur); scanf("%d",&valeur_lue);
*min = valeur_lue;
*max = valeur_lue;
while (compteur < n) {
printf("Entrez la valeur N°%d ?--> ", ++compteur);
scanf("%d",&valeur_lue);
if (valeur_lue < (*min)) *min = valeur_lue;
if (valeur_lue > (*max)) *max = valeur_lue;
}
}
void LirePositif(int *valeur) {
do {
printf("Entrez un entier positif ?: ");
scanf("%d", valeur);
if ((*valeur) < 0) {
printf(" <--- %d est une valeur negative --->\n", (*valeur));
}
} while ((*valeur) < 0);
}
/* Exercice 4. Simplification de deux nombres représentant une fraction
• Ecrire une fonction Simplifie qui reçoit deux valeurs en paramètre représentant
le numérateur et le dénominateur d’une fraction et transforme ces valeurs en
numérateur et dénominateur d’une fraction équivalente simplifiée. Par exemple,
si les variables données initialement ont pour valeur 3 et 12, leur valeur après
exécution de la procédure sera 1 et 4 ( 3/12 = 1/4 ). On supposera dans ce cas que
la procédure reçoit une fraction valide (c’est-à-dire, que le dénominateur n’est pas
nul).
• Ecrire une fonction qui réalise le même travail que la fonction Simplifie mais qui
indique une erreur grâce à la valeur retournée si le dénominateur de la première
fraction est nul (!= 0 si le déroulement est correct, 0 en cas d’erreur).
*/
#include <stdio.h>
#include <stdlib.h>
int Simplifie(int *, int *);
int main(void) {
int numerateur, denominateur;
printf("Entrez le numérateur : "); scanf("%d", &numerateur);

printf("Entrez le dénominateur : "); scanf("%d", &denominateur);
if (Simplifie(&numerateur, &denominateur)==EXIT_SUCCESS)
printf("\nLa fraction simplifiée = %d/%d\n", numerateur, denominateur); else
printf("\n<--- Error - Simplifie() --->\n\n");
return 0;
}
int Simplifie(int *numerateur, int *denominateur) {

int diviseur=2;
if (*denominateur != 0) {
while ((*numerateur >= diviseur) && (*denominateur >= diviseur)) {
if ((*numerateur % diviseur == 0) && (*denominateur % diviseur == 0)) {
*numerateur /= diviseur;
*denominateur /= diviseur;
}
else
diviseur++;
}
return EXIT_SUCCESS;
}
else
return EXIT_FAILURE;
}
Exercice - 1
#include <stdio.h>
int main(void) {
char str[80];
printf("Entrez une chaıne de caracteres: ");

scanf("%[^\n]s", str);
printf("Vous avez entree au clavier la chaine de caracteres suivante:\n\t%s\n",str);
return 0;
}
Exercice - 1.1
#include <stdio.h>
#define MAXLETTTRES 30
int SaisieLigneControlee(char []);
int main(void) {
char str[MAXLETTTRES];
int is_ok;
is_ok=SaisieLigneControlee(str);
if (is_ok)
printf("\nVous avez entree au clavier la chaine de caracteres suivante:\n\t%s\n",str);
return 0;
}
int SaisieLigneControlee(char str[]) {

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
if (i > (MAXLETTTRES - 1)) {
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';

return is_ok;
}
Exercice - 2
#include <stdio.h>

int Longueur(char []);
int main(void) {
int is_ok;
if (is_ok) {
printf("Longueur de la chaine est de %d caracters\n", Longueur(str));
}
return 0;
}
int Longueur(char str[]) {

int length=0;
for (; str[length] != '\0'; length++);
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Exercice - 3
#include <stdio.h>
int NombreChiffres(char []);
int main(void) {
int is_ok;
if (is_ok) {
printf("Et elle contient %d chiffres\n", NombreChiffres(str));
}
return 0;
}
int NombreChiffres(char str[]) {

int i, nombre_de_chiffres=0;
for (i=0; str[i] != '\0'; i++)

if (str[i] >= '0' && str[i] <= '9') nombre_de_chiffres++;
return nombre_de_chiffres;
}

int length=0;
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Exercice - 4
#include <stdio.h>
#include <string.h>

int Different(char [], char[]);
int main(void) {
char str[MAXLETTTRES], str1[MAXLETTTRES];
int is_ok;
if (is_ok) {
}
is_ok=SaisieLigneControlee(str1);
if (is_ok) {
printf("\nVous avez entree au clavier la chaine de caracteres suivante:\n\t%s\n",str1);
printf("Longueur de la chaine est de %d caracters\n", Longueur(str1));
printf("Et elle contient %d chiffres\n", NombreChiffres(str1));
}
Different(str, str1) ?
printf("les deux chaines sont differentes\n") : printf("les deux chaines sont egale\n");
return 0;
}
int Different(char str1[], char str2[]) {

int i=0;
for (;str1[i] && str2[i]; i++)

if (str1[i] != str2[i]) break;
return ( !str1[i] && !str2[i] ) ? 0 : 1;

}

for (i=0; str[i] != '\0'; i++)

}

int length=0;
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Exercice - 5
#include <stdio.h>
#include <string.h>

void Copie(char [], char []);
int main(void) {
int is_ok;
if (is_ok) {
}
if (is_ok) {
}
Copie(str, str1);
printf("\nApres l'appel de Copie():\n\tstr = %s\n",str);
printf("\tstr1 = %s\n",str1);
return 0;
}
void Copie(char dest[], char source[]) {
int i=0;
for(;source[i]; i++) dest[i]=source[i];
dest[i]='\0';
}

int i=0;

return ( !str1[i] && !str2[i] ) ? 0 : 1;

}

for (i=0; str[i] != '\0'; i++)

}

int length=0;
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Exercice - 6
#include <stdio.h>
#include <string.h>

void MetEnMajuscule(char [], char[]);
int main(void) {
int is_ok;
if (is_ok) {
}
if (is_ok) {
}
Copie(str, str1);
MetEnMajuscule(str, str);
printf("\nApres l'appel de MetEnMajuscule():\n\tstr en Majuscule = %s\n",str);
return 0;
}
void MetEnMajuscule(char enMajuscule[], char source[]) {

int i=0;
for(;source[i]; i++)
if (source[i] >= 'a' && source[i] <= 'z')
enMajuscule[i] = 'A' + source[i] - 'a';
else
enMajuscule[i] = source[i];
enMajuscule[i] = '\0';
}

int i=0;
dest[i]='\0';
}
int i=0;

return ( !str1[i] && !str2[i] ) ? 0 : 1;

}

for (i=0; str[i] != '\0'; i++)

}

int length=0;
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Exercice - 7
#include <stdio.h>
#include <string.h>

int SupprimeNonAlphabetique(char [], char []);
int main(void) {
int is_ok;
if (is_ok) {
}
if (is_ok) {
}
Copie(str, str1);
SupprimeNonAlphabetique(str, str);
printf("\nApres l'appel de SupprimeNonAlphabetique():\n\tstr_modifiee = %s\n",str);
return 0;
}
int SupprimeNonAlphabetique(char str_modifiee[], char source[]) {

int i=0, compteur=0;
for(; source[i]; i++)

if ((source[i] >= 'A' && source[i] <= 'Z') || (source[i] >= 'a' && source[i] <= 'z')) {
str_modifiee[compteur] = source[i];
compteur++;
}
str_modifiee[compteur] = '\0';
return compteur;
}

int i=0;
else
}

int i=0;
dest[i]='\0';
}

int i=0;

return ( !str1[i] && !str2[i] ) ? 0 : 1;

}

for (i=0; str[i] != '\0'; i++)

}

int length=0;
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Exercice - 8
#include <stdio.h>
#include <string.h>

void Miroir(char []);
int Est_Palindrome(char []);
int main(void) {
int is_ok;
if (is_ok) {
}
if (is_ok) {
}
Copie(str, str1);
Miroir(str);
printf("\nApres l'appel de Miroir():\n\tstr_inversee = %s\n",str);
printf("\nApres l'appel d'Est_Palindrome():\n");

Est_Palindrome(str) ?
printf("\t%s est Palindrome\n", str) : printf("\t%s n'est pas Palindrome\n", str);
return 0;
}
int Est_Palindrome(char str[]) {

char str_rev[MAXLETTTRES];
Copie(str_rev, str);
Miroir(str_rev);
MetEnMajuscule(str_rev, str_rev);
return Different(str, str_rev) ? 0 : 1;

}
void Miroir(char str2rev[]) {

int i, len=Longueur(str2rev);
int limit=len/2;
char temp;
for(i=0; i < limit; i++) {

temp = str2rev[i];
str2rev[i] = str2rev[len-i-1];
str2rev[len-i-1]=temp;
}
}


compteur++;
}
return compteur;
}

int i=0;
else
}

int i=0;
dest[i]='\0';
}

int i=0;

return ( !str1[i] && !str2[i] ) ? 0 : 1;
}

for (i=0; str[i] != '\0'; i++)

}

int length=0;
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Exercice - 8-1
#include <stdio.h>
#include <string.h>

void Miroir(char []);
int IS_Palindrome(char []);
int main(void) {
int is_ok;
if (is_ok) {
}
if (is_ok) {
}
Copie(str, str1);
Miroir(str);
printf("\nApres l'appel de Miroir():\n\tstr_inversee = %s\n",str);
printf("\nApres l'appel de IS_Palindrome():\n");

IS_Palindrome(str) ?
printf("\t%s est Palindrome\n", str) : printf("\t%s n'est pas Palindrome\n", str);
return 0;
}
int IS_Palindrome(char str[]) {

int i, len=Longueur(str);
int limit=len/2, palindrome=1;
for(i=0; i < limit; i++)

if (str[i] != str[len - i - 1]) {
palindrome = 0;
break;
}
return palindrome;
}
void Miroir(char str2rev[]) {

int i, len=Longueur(str2rev);
int limit=len/2;
char temp;
for(i=0; i < limit; i++) {
temp = str2rev[i];
str2rev[i] = str2rev[len-i-1];
str2rev[len-i-1]=temp;
}
}


compteur++;
}
return compteur;
}

int i=0;
else
}

int i=0;
dest[i]='\0';
}

int i=0;

return ( !str1[i] && !str2[i] ) ? 0 : 1;

}

for (i=0; str[i] != '\0'; i++)

}

int length=0;
return length;
}

int i=0, is_ok=1;
char ch;

do {
scanf("%c", &ch);
str[i] = ch;
i++;
is_ok = 0;
break;
}
} while (ch != '\n');
if (is_ok) str[i-1] ='\0';
return is_ok;
}
Structures
/* Exercice 1.1 Définition de nom de type

Définir un type Date pour des variables formées d’un numéro de jour, d’un nom
de mois et d’un numéro d’année.
Exercice 4.1 Fiche

• Ecrire des fonctions de lecture et d’écriture d’une variable de type Date.
Dans un premier temps, on ne se préocupera pas de la validité de la date entrée.
*/
#include <stdio.h>
typedef struct {
int jour;
char mois[10];
int annee;
} DATE;
DATE LireDate(void);
void AfficheDate(DATE);
int main(void) {
DATE date;
date = LireDate();
AfficheDate(date);
return 0;
}
void AfficheDate(DATE date) {

printf("The date is: %d %s %d\n", date.jour, date.mois, date.annee);
}
DATE LireDate(void) {
DATE temp;
printf("Enter a date (in this form:: Day(1-31) Month(Janvier - Decembre) Year(xxxx)):? ")
scanf("%d %s %d", &temp.jour, temp.mois, &temp.annee);
return temp;
}
/*
Exercice 1.2 Définition de nom de type
Ecrire la déclaration d’un type Fiche permettant de mémoriser les informations
sur un étudiant :
• son nom ;
• son prenom ;
• sa date de Naissance, de type Date ;
• sa formation, représentée par deux lettres ;
• s’il est redoublant ou non ;
• son groupe de TD, représenté par un entier ;
• ses notes, représentées par un tableau note d’au plus MAXNOTES rels;
• un entier nbnotes indiquant le nombre de notes valides dans le tableau note.
Exercice 4.2 Fiche

• Ecrire les fonctions LireFiche et EcrireFiche de lecture et d’écriture d’une Fiche.
Aucune note n’est entrée par la fonction LireFiche.
• Ecrire une fonction AjouteNote qui reçoit une Fiche et ajoute une note, si cela
est possible.
• Ecrire une fonction Moyenne qui reçoit une Fiche et renvoie, si cela est possible,
la moyenne des notes de l’étudiant.
*/
#include <stdio.h>
#define MAXNOTES 10
typedef struct {
int jour;
char mois[10];
int annee;
} DATE;
typedef struct {
char nom[10];
char prenom[10];
DATE date_naissance;
char info[3];
char redoublant;
int groupe;
float notes[MAXNOTES];
char nom_module[MAXNOTES][30];
int nbnotes;
} FICHE;
FICHE LireFiche(void);
void EcrireFiche(FICHE);
FICHE AjouteNote(FICHE);
int main(void) {
FICHE etd_fiche;
etd_fiche = LireFiche();
etd_fiche = AjouteNote(etd_fiche);
etd_fiche = AjouteNote(etd_fiche);
EcrireFiche(etd_fiche);
return 0;
}
FICHE AjouteNote(FICHE fiche) {
if (fiche.nbnotes < MAXNOTES) {

printf("Entrez le nom du module: ? ");
scanf(" %[^\n]s", fiche.nom_module[fiche.nbnotes]);
printf("Entrez sa notes pour ce module: ? ");
scanf("%f", &fiche.notes[fiche.nbnotes]);
fiche.nbnotes++;
}
else
printf("\n <---- c'est pas possible d'ajuter une note ----- >\n");
return fiche;
}
FICHE LireFiche(void) {
FICHE fiche;
printf("Entrez le nom de l'etudiant:? ");

scanf(" %s", fiche.nom);
printf("Son prenom:? ");

scanf(" %s", fiche.prenom);
printf("Sa date de Naissance: (dd mm yyyy) ? ");

scanf("%d %s %d", &fiche.date_naissance.jour, fiche.date_naissance.mois, &fiche.date_naiss
printf("Sa formation: ? ");

scanf(" %s", fiche.info);
printf("Il est redoublant ou non (O:Oui, N:Non) ? ");

scanf(" %c", &fiche.redoublant);
printf("Son groupe: ?");

scanf("%d", &fiche.groupe);
fiche.nbnotes=0;
return fiche;
}
void EcrireFiche(FICHE fiche) {

int i;
printf("La fiche de %s, %s\n", fiche.nom, fiche.prenom);

printf("\tSa date de Naissance est le %d %s %d\n", fiche.date_naissance.jour,
fiche.date_naissance.mois,
fiche.date_naissance.annee);
printf("\tSa formation: %s\n", fiche.info);
printf("\tSon groupe: %d\n", fiche.groupe);
printf("\tIl est redoublant: %s\n", (fiche.redoublant == 'O')? "Oui":"Non");

printf("\nSes notes: \n");
printf("\t Nom de Module Note\n");

printf("\t ---------------------------------- \n");
for (i=0; i<fiche.nbnotes; i++)
printf("\t %17s \t %5.2f\n", fiche.nom_module[i], fiche.notes[i]);
}
/*
Exercice 2. Polynomes
• Définir un type Polynomes permettant de manipuler des polynomes à une variable,
à coefficients réels de degré inférieur à DGMAX.
• Ecrire une fonction LirePolynome effectuant la saisie monome par monome d’un
polynome. Pour chaque monome, on indiquera le degré puis le coefficient.
*/
#include <stdio.h>
#define MAXDEGREE 101
#define MAX(x, y) (x > y ? x : y)
typedef struct {
int degree;
int coef[MAXDEGREE];
} polynomial;
typedef struct {
int coef;
int expo;
} term;
polynomial add_poly(polynomial, polynomial);

polynomial mul_poly(polynomial, polynomial);
polynomial mul_poly_by_term(polynomial, term);
void display_poly(polynomial, char);
polynomial read_poly();
int main(void) {
polynomial a, b, c;
int i;
printf("Enter the terms of the first polynomial:\n");

a = read_poly();
printf("Enter the terms of the second polynomial:\n");

b = read_poly();
display_poly(a, 'a');
display_poly(b, 'b');
c = add_poly(a, b);
printf("\nPolynomial c = a + b\n");
display_poly(c, 'c');
c = mul_poly(a, b);
printf("\nPolynomial c = a * b\n");
display_poly(c, 'c');
return 0;
}
polynomial mul_poly_by_term(polynomial a, term t) {

int i;
for (i=a.degree; i >= 0; i--) {

a.coef[i + t.expo] = a.coef[i] * t.coef;
if (t.expo) a.coef[i] = 0;
}
a.degree = a.degree + t.expo;
return a;
}
polynomial mul_poly(polynomial a, polynomial b) {

polynomial c = {0,0}; term t;
int i;
for (i=a.degree; i >= 0; i--) {

t.coef = a.coef[i]; t.expo=i;
c = add_poly(c, mul_poly_by_term(b, t));
}
return c;
}
polynomial add_poly(polynomial a, polynomial b) {

polynomial c;
int i;
c.degree = MAX(a.degree, b.degree);

for (i=c.degree; i >= 0; i--)
c.coef[i] = a.coef[i] + b.coef[i];
return c;
}
polynomial read_poly() {
polynomial a={0,0}; /* Initialize the polynomial to zero */
int i, nb_terms, expo, coef, max_expo=0;
do {
printf("Enter number of terms in your polynomial (a positive integer): ");
scanf("%d", &nb_terms);
if (nb_terms <= 0) printf("Invalide value assigend to nb_terms, another trail\n");
} while (nb_terms <= 0);
for (i=0; i < nb_terms; i++) {

printf("Enter the exponent (positive integer) :"); scanf("%d", &expo);
if (expo < 0) {
printf("Invalid exponent ...Enter a valid exponent\n");
i--;
continue;
}
if (expo > max_expo) max_expo = expo;
printf("Enter the coefficient: "); scanf("%d", &coef);
a.coef[expo] += coef; /* Accumulate similar terms */
}
a.degree = max_expo;
return a;
}
voiddisplay_poly(polynomial a, char poly_name) {

int i;
printf("\nPolynomail %c = ", poly_name);
for(i = a.degree; i > 0; i--)

if (a.coef[i]) printf("%dx^%d + ", a.coef[i], i);
if (a.coef[i]) printf("%d", a.coef[i]); else printf("0");

printf("\n");
}
/*
Exercice 3. Rationnel
• Définir un type Rationnel composé de deux entiers: un numérateur et un
dénominateur.
• Ecrire une fonction LireRationnel qui effectue la lecture d’un rationnel
valide. Le rationnel mémorisé aura été simplifié.
• Ecrire une fonction SommeRationnel qui retourne la somme des deux rationnels
valides passés en argument. Le rationnel retourné aura été simplifié.
*/
#include <stdio.h>
typedef struct {
int num;
int denom;
} Rationnel;
Rationnel LireRationnel(char *str);

Rationnel Simplifie(Rationnel);
Rationnel SommeRationnel(Rationnel, Rationnel);
void AfficheRationnel(Rationnel);
int main(void) {
Rationnel a = LireRationnel("1iere"), b = LireRationnel("2ieme");
Rationnel c = SommeRationnel(a, b);
printf("\nLa somme des deux rationnels est:\n\t\t");

AfficheRationnel(a); printf("+ "); AfficheRationnel(b); printf("= "); AfficheRationnel(c)
printf("\n\n");
return 0;
}
Rationnel SommeRationnel(Rationnel x, Rationnel y) {

Rationnel z = {x.num * y.denom + x.denom * y.num, x.denom * y.denom};
return Simplifie(z);
}
void AfficheRationnel(Rationnel x) {
printf("%d/%d ", x.num, x.denom);
}
Rationnel LireRationnel(char *str) {

Rationnel x;
printf("\nLire le %s rationnel :\n", str);
printf("\tEntrez le numerateur (une entier) :"); scanf("%d", &x.num);
do {
printf("\tEntrez le denominateur (une entier != 0) :");
scanf("%d", &x.denom);
if (x.denom == 0)
printf("\t\t <---- Le denominateur ( = %d) n'est pas valide ----> \n", x.denom);
} while(x.denom == 0);
return Simplifie(x);
}
Rationnel Simplifie(Rationnel x) {
int diviseur=2;
while ((x.num >= diviseur) && (x.denom >= diviseur)) {

if ((x.num % diviseur == 0) && (x.denom % diviseur == 0)) {
x.num /= diviseur;
x.denom /= diviseur;
}
else
diviseur++;
}
return x;
}
---------------------------------------****************--------------------------------------
===================
#include <stdio.h>
#include <string.h>
#define MAXNOTES 10
#define MAXELEVES 10
typedef struct {
int jour;
char mois[10];
int annee;
} DATE;
typedef struct {
char nom[10];
char prenom[10];
DATE date_naissance;
char info[3];
char redoublant;
int groupe;
float notes[MAXNOTES];
char nom_module[MAXNOTES][30];
int nbnotes;
// float moyenne;
} FICHE;
typedef struct {
int n_eleves;
FICHE les_eleves[MAXELEVES];
} CLASSE;
CLASSE LireClasse(void);
CLASSE SaisieOrdonnee(void);
void EcrireClasse(CLASSE);
void Meilleur(CLASSE);
CLASSE insertion(CLASSE, FICHE);
FICHE LireFiche(int);
void EcrireFiche(FICHE);
FICHE AjouteNote(FICHE, char []);
float Moyenne(FICHE);
float MoyenneEleve(CLASSE, char []);
char *touppercase(char []);
int main(void) {
CLASSE classe;
classe = LireClasse();
EcrireClasse(classe);
Meilleur(classe);
return 0;
}
CLASSE SaisieOrdonnee(void) {
CLASSE classe;
int i, n_eleves;
do {
printf("Entrez le nombre des eleves (1 - %d): ?", MAXELEVES);
scanf("%d", &n_eleves);
if (n_eleves < 1 || n_eleves > MAXELEVES)
printf("\n\terr <--- Entrez un nombre entre 1 et %d --->\n", MAXELEVES);
} while (n_eleves < 1 || n_eleves > MAXELEVES);
classe.n_eleves=0;
for (i=0; i < n_eleves; i++)
classe = insertion(classe, LireFiche(i+1));
return classe;
}
CLASSE LireClasse(void) {
CLASSE classe;
int i;
do {
printf("Entrez le nombre des eleves (1 - %d): ?", MAXELEVES);
scanf("%d", &classe.n_eleves);
if (classe.n_eleves < 1 || classe.n_eleves > MAXELEVES)
printf("\n\terr <--- Entrez un nombre entre 1 et %d --->\n", MAXELEVES);
} while (classe.n_eleves < 1 || classe.n_eleves > MAXELEVES);
for (i=0; i < classe.n_eleves; i++) {

classe.les_eleves[i] = LireFiche(i+1);
classe.les_eleves[i]=AjouteNote(classe.les_eleves[i], "Prog. C");
classe.les_eleves[i]=AjouteNote(classe.les_eleves[i], "Math");
}
return classe;
}
void EcrireClasse(CLASSE classe) {

int i;
for (i=0; i<classe.n_eleves; i++) {

EcrireFiche(classe.les_eleves[i]);
printf("\n
}
}
float MoyenneEleve(CLASSE classe, char Nom[]) {

int i;
for (i=0; i<classe.n_eleves; i++)

if (strcmp(classe.les_eleves[i].nom, Nom)==0) return (Moyenne(classe.les_eleves[i]));
return -1;
}
void Meilleur(CLASSE classe) {

int i, j, max_index;
struct {
char nom[30];
float moyenne;
} moyenne_eleves[MAXELEVES], temp;

moyenne_eleves[i].moyenne = Moyenne(classe.les_eleves[i]);
strcpy(moyenne_eleves[i].nom, classe.les_eleves[i].nom);
strcat(moyenne_eleves[i].nom, " ");
strcat(moyenne_eleves[i].nom, classe.les_eleves[i].prenom);
}
/* sorting */
max_index = i;
for (j= i + 1; j<classe.n_eleves; j++)
if (moyenne_eleves[max_index].moyenne < moyenne_eleves[j].moyenne) max_index=j;
if (i != max_index) {
temp = moyenne_eleves[max_index];
moyenne_eleves[max_index] = moyenne_eleves[i];
moyenne_eleves[i] = temp;
}
}
/* Listing best students along with their GPAs */

printf("\n------------------------------------------------------------------------------
printf("\tLe(s) etudiant(s) ayant obtenu la meilleure moyenne\n");
printf(" ----------------------------------------------------------------------------- \n
printf ("%25s\t\t\t%s", "Nom, Prènom ", "Moyenne\n");
for (i=0; i < classe.n_eleves && moyenne_eleves[0].moyenne == moyenne_eleves[i].moyenne;
printf("%20s\t\t\t\t%4.2f\n", moyenne_eleves[i].nom, moyenne_eleves[i].moyenne);
}
CLASSE insertion(CLASSE classe, FICHE fiche) {

int i, index=0;
for (i=0; i<classe.n_eleves; i++)

if (strcmp(touppercase(classe.les_eleves[i].nom), touppercase(fiche.nom)) > 0) {
index = i;
break;
}
if ((index == i) && classe.n_eleves) {

/* shift all elements after index by one to the rigth */
for (i=classe.n_eleves; i > index; i--)
classe.les_eleves[i] = classe.les_eleves[i-1];
classe.les_eleves[index] = fiche;
classe.les_eleves[index]=AjouteNote(classe.les_eleves[index], "Prog. C");
classe.les_eleves[index]=AjouteNote(classe.les_eleves[index], "Math");
}
else {
classe.les_eleves[classe.n_eleves] = fiche;
classe.les_eleves[classe.n_eleves]=AjouteNote(classe.les_eleves[classe.n_eleves], "Prog
classe.les_eleves[classe.n_eleves]=AjouteNote(classe.les_eleves[classe.n_eleves], "Math
}
classe.n_eleves++;
return classe;
}
float Moyenne(FICHE f) {
float somme=0;
int i;
for (i=0; i < f.nbnotes; i++)

somme += f.notes[i];
return (f.nbnotes)?(somme/f.nbnotes) :((float) -1);

}
FICHE AjouteNote(FICHE fiche, char module[]) {

int i;

if (strcmp(fiche.nom_module[i], module) == 0) return fiche;
/* if the module name exists then simply return without doing anything */
if (fiche.nbnotes < MAXNOTES) {

strcpy(fiche.nom_module[fiche.nbnotes], module);
printf("Entrez sa notes pour le module de %s: ? ", module);
scanf("%f", &fiche.notes[fiche.nbnotes]);
fiche.nbnotes++;
}
else
printf("\n <---- c'est pas possible d'ajuter une note ----- >\n");
return fiche;
}
FICHE LireFiche(int number) {

FICHE fiche;
printf("Entrez le nom de l'etudiant # %d:? ", number);

scanf(" %s", fiche.nom);
printf("Son prenom:? ");

scanf(" %s", fiche.prenom);
printf("Sa date de Naissance: (dd mm yyyy) ? ");

scanf("%d %s %d", &fiche.date_naissance.jour, fiche.date_naissance.mois, &fiche.date_naiss
printf("Sa formation: ? ");

scanf(" %s", fiche.info);
printf("Il est redoublant ou non (O:Oui, N:Non) ? ");

scanf(" %c", &fiche.redoublant);
printf("Son groupe: ?");

scanf("%d", &fiche.groupe);
fiche.nbnotes=0;
return fiche;
}
void EcrireFiche(FICHE fiche) {

int i;
printf("\n ----------------------------------------------- \n");
printf("La fiche de %s, %s\n", fiche.nom, fiche.prenom);
printf(" ----------------------------------------------- \n");
printf("\tSa date de Naissance est le %d %s %d\n", fiche.date_naissance.jour,
fiche.date_naissance.mois,
fiche.date_naissance.annee);
printf("\tSa formation: %s\n", fiche.info);
printf("\tSon groupe: %d\n", fiche.groupe);
printf("\tIl est redoublant: %s\n", (fiche.redoublant == 'O')? "Oui":"Non");

printf("\nSes notes: \n");
printf("\t Nom de Module Note\n");

printf("\t ---------------------------------- \n");
printf("\t %17s \t %5.2f\n", fiche.nom_module[i], fiche.notes[i]);
}
char *touppercase(char str[]) {

int i;
for( i=0; str[i]; i++)

if (str[i] >= 'a' && str[i] <= 'z') str[i] = 'A' + str[i] - 'a';
return str;
}

Travaux Pratiques en Langage de Programmation C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Travaux Pratiques en Langage de Programmation C

Transféré par

Droits d'auteur :

Formats disponibles

Travaux Pratiques

Réaliser par : ELFAGRICH Mahfoud

1. Déclaration de variables, les types en C

Ecrire un programme qui lit un entier et l’affiche s’il est positif.

On veut déterminer le nombre de solutions d’une équation du second degré 𝑎 𝑥 2 +

• Si 𝑎 = 0 et 𝑏 = 0, l’´équation est dégénérée (0 ou une infinité de solutions).

Ecrire un programme qui lit les coefficients 𝑎, 𝑏 et 𝑐, et qui calcule le nombre de

• Ecrire un programme qui calcule la somme des 10 premières valeurs entières

𝑛𝑜𝑛 𝑑é𝑓𝑖𝑛𝑖 𝑠𝑖 𝑛 < 0

3. Affichage d’un triangle

Comment permettre l’utilisateur de choisir le symbole utilisé ?

Itérations non bornées :

4. Valeur maximale et minimale d’une suite d’entiers

6. Saisie d’une suite croissante

Nombre d’éléments : 4, somme : 10

Fonctions ne renvoyant pas de valeur

• Ecrire une fonction Multiple prenant en argument un entier n et qui affiche

• Décrire la suite d’instructions permettant de déterminer si un nombre est

Fonctions renvoyant une valeur

2. Nombre premier supérieur un entier 𝒏

4. Liste des nombres premiers

• Trouver un algorithme qui détermine la décomposition en facteurs

2^3 ∗ 3^2 ∗ 11^2

Papier, caillou, ciseaux

On veut ´écrire un programme permettant de jouer au jeu “papier, caillou,

- Si J1 et J2 sont identiques le match est nul,

• Ecrire un programme qui arbitre 10 parties et qui affiche le score.

1. Echange de deux valeurs

• Comment une fonction peut-elle transmettre plus d’une seule valeur la

4. Simplification de deux nombres repré

• Ecrire une fonction Simplifie qui recroît deux valeurs en paramètre

• Définition de constante symbolique

#define N 5 est une instruction du précompilateur. Toute apparition de N hors d’une

1. Accès aux cases d’un tableau

• Ecrire une fonction Moyenne prenant en argument un tableau T de N réels

• En déduire une fonction SuperieurMoy qui compte le nombre d’éléments

Définir un tableau carré à deux dimensions (N × N) de caractères Saisir les

Nous voulons afficher le triangle de Pascal jusqu’à l’ordre 𝑁 .

1. Saisie et affichage d’une chaîne de caractères

2. Longueur d’une chaîne

Nous utiliserons dans ce TP la notion de structure, définie à l’aide de struct qui

1. Définition de nom de type

o Définir un type Polynômes permettant de manipuler des polynômes `a une

o Définir un type Rationnel composé de deux entiers : un numérateur et un

o Ecrire une fonction LireRationnel qui effectue la lecture d’un rationnel

o Ecrire une fonction SommeRationnel qui retourne la somme des deux

o Ecrire des fonctions de lecture et d’écriture d’une variable de type Date.

o Dans un premier temps, on ne se préoccupera pas de la validité de la date

o Ecrire les fonctions LireFiche et EcrireFiche de lecture et d´écriture d’une

Nous utiliserons dans ce TP la structure de fiche définie dans le TP précédant.

Définir un type Classe permettant de mémoriser au plus MAXELEVES Fiches.

Déduire de l’exercice précédent un algorithme de tri d’un tableau.

/* Un programme C qui fait quelques opérations arithmétiques et affiche leurs résultats */

float x,y,z ; /* Déclarer trois variables (x, y, et z) de type entier float*/

i=3; /* Affecter la valeur 3 à la variable i de type entier*/

j=5; /* Affecter la valeur 5 à la variable i de type entier*/

x=3.0; /* Affecter la valeur 3.0 à la variable x de type float*/

i=j/2;y=x/2;z=j/2; /* Faire quelques opérations arithmétiques. */

printf("i= %d \n y=%f z =%f\n",i,y,z); /* Afficher les valeurs de i, y et z*/

return 0; /* Sortir de la fonction <main> */

printf("Entrez un entier :");

printf("Entrez 4 entiers: ");

printf("Entrez un entier : "); scanf("%d", &i);

void Echange(int , int );

void Echange(int a, int b) {

void MinMax(int n, int min, int max);

void MinMax(int n, int min, int max) {

int Simplifie(int , int );

int Simplifie(int numerateur, int denominateur) {