Exercices en Pascal

Ecole Normale Suprieure
Dpartement dInformatique
Rabat
Encadr par : Mr.Brahim Lamharchi

Ralis par : Benallou Imane
Lazrak Chamae
Razzoug Milouda
Anne
universitaire : 2003 / 2004
A loccasion de la
prsentation de ce travail,
nous tenons exprimer notre
gratitude et notre
reconnaissance Mr . Brahim
Lamharchi, notre encadrant
de projet de fin dtude
lEcole Normale Suprieure de
Rabat pour les conseils quil
nous a prodigus tout au long
de ce travail.
Nous adressons galement

nos sincres remerciements
tous les autres enseignants
Sommaire
Sommaire
Introduction..........................................................................................................................1
lments de base dun programme en Pascal et en C.........................................................3
I- Structure dun programme...............................................................................................3
I-1. En langage Pascal..................................................................................................3
I-2. En langage C.........................................................................................................4
II- Types de donnes............................................................................................................4
II-1. Variables et constantes.........................................................................................4
II-1.1 Les variables..................................................................................................4
II-1.2 Les constantes................................................................................................6
II-2. Les types de base.................................................................................................7
II-2.1 En langage Pascal..........................................................................................7
II-2.2 En langage C..................................................................................................8
II-3. Crer un type de donne......................................................................................8
II-3.1 En langage Pascal..........................................................................................8
II-3.2 En langage C..................................................................................................9
III- Oprateurs et expressions..............................................................................................9
III-1. En langage Pascal...............................................................................................9
III-2. En langage C.....................................................................................................11
IV- Instructions simples.....................................................................................................14
IV-1. Instruction dentre...........................................................................................14
IV-2. Instructions de sortie.........................................................................................16
IV-3. Instruction daffectation...................................................................................17
V- Enonc des exercices....................................................................................................18
Structures de traitement alternatives et itratives..............................................................19
I- Instructions conditionnelles...........................................................................................19
II- Instructions rptitives..................................................................................................21
III- Enonc des exercices...................................................................................................22
Notion de sous-programmes..............................................................................................26
I. En langage Pascal...........................................................................................................26
I.1 Les procdures......................................................................................................26
ENS Rabat Dpartement dInformatique

Sommaire
I.2 Les fonctions........................................................................................................27

II- En langage C.................................................................................................................27
III- La rcursivit...............................................................................................................29
IV- Enonc des exercices...................................................................................................29
Les structures de donnes statiques..................................................................................33
I- Les structures de donnes homognes...........................................................................33
II- Les structures de donnes htrognes.........................................................................38
Les structures de donnes dynamiques..............................................................................42
I- En langage Pascal...........................................................................................................42
I-1. Les pointeurs.......................................................................................................42
II- En langage C.................................................................................................................49
Les fichiers.........................................................................................................................55
I- En langage Pascal...........................................................................................................55
I.1 Oprations sur les fichiers....................................................................................56
I.2 Les fichiers textes.................................................................................................57
II- En langage C.................................................................................................................58
II.1 Ouverture et cration d'un fichier........................................................................59
II.2 Ecriture dans un fichier.......................................................................................59
II.3 Lecture dans un fichier........................................................................................60
II.4 Dplacement dans un fichier...............................................................................61
II.5 Fermeture du fichier............................................................................................62
Solutions des exercices......................................................................................................63
Gestion de lcran..............................................................................................................66
I- Notion de fentre............................................................................................................66
II- Gestion du curseur........................................................................................................66
III- Instructions de gestion de lcran................................................................................66
IV Instructions de gestion des couleurs.............................................................................66
Conclusion.........................................................................................................................66
Rfrences..........................................................................................................................66
ENS Rabat Dpartement dInformatique

Introduction
INTRODUCTION
Un programme informatique se compose dune srie dinstructions, qui sont

excutes successivement par lordinateur. Lors de la cration dun programme,
il est ncessaire dy inclure les instructions correspondant la tche quon
souhaite voir accomplie par lordinateur. Le processus consistant dfinir les
instructions, devant tre excutes par lordinateur, se nomme programmation.
Beaucoup de langages de programmation sont apparus au fil des annes en

commenant par les langages intimement lis la machine (langage machine et
assembleur), viennent aprs les langages dits volus : interprts tels que Basic
et compils tels que Pascal et C.
Langage Pascal
Le langage Pascal est un langage de programmation de haut niveau. Il a t

conu par le professeur WIRTH Zurich en 1970 comme une aide
lenseignement de la programmation structure.
Langage C
Le langage C a t cr en 1972 par Denis RITCHIE avec un objectif

relativement limit : crire un systme dexploitation (UNIX). Mais, ses qualits
oprationnelles lont trs vite fait adopt par une large communaut de
programmeurs.
Une premire version du langage est apparue en 1978 avec louvrage de

Kernighan et Ritchie The C programming language . Mais le langage a
continu dvoluer aprs cette date travers les diffrents compilateurs qui ont
vu le jour. Son succs internationnel a amen lANSI (American National
Standard Institute) dfinir un C standard (on le qualifie souvent par le C ANSI).
Choix du sujet
Lenseignement de linformatique se rpand de plus en plus dans les

tablissements scolaires et pour toutes les options, luniversit, aux coles
dingnieurs, plus rcemment dans les lyces et collges et mme dans les coles
primaires prives.
ENS Rabat Dpartement dInformatique 1

Introduction
En particulier, lenseignement de lalgorithmique et de la programmation est, et

reste toujours un passage obligatoire pour la formation des futurs informaticiens.
Malgr lapparition dautres systmes de programmation trs volus et reposant
sur la programmation oriente objets, ceux-ci restent lis aux langages de
programmation de base tels que Pascal et C.
Objectif
Notre objectif cest de palier aux difficults que le programmeur (universitaire,
lve ingnieur, analyste-programmeur, etc.) puisse rencontrer au moment de son
apprentissage en lui proposant une srie dexercices diversifis et couvrant la
totalit des notions de base de la programmation. On lui propose aussi, la fin du
document, toutes les solutions des exercices proposs en Pascal et en C.

Elments de base dun programme en Pascal et en C
LMENTS DE BASE DUN

PROGRAMME EN PASCAL ET EN C
I- Structure dun programme

I-1. En langage Pascal
Un programme PASCAl se compose des lments suivants :
1- En-tte qui se compose du mot rserv PROGRAM suivi dun identificateur

du nom du programme, suivi du point virgule ;.
Exemple : PROGRAM Operations ;
2- Prambule dclaratif qui comporte :
La dclaration des bibliothques utilises, prcde par le mot rserv

USES. Les identificateurs des bibliothques sont spars par des
virgules et la liste est termine par un point virgule ;.
Exemple : USES Crt, Graph, Dos ;
La dclaration des identificateurs de types de donnes, dfinis par

lutilisateur, prcde par le mot rserv TYPE.
Exemple : TYPE Nombre = 0..99 ;
La dclaration des identificateurs de constantes, prcde par le mot

rserv CONST.
Exemple : CONST Pi = 3.14 ;
La dclaration des identificateurs de variables, prcde par le mot

rserv VAR.
Exemple : VAR A : INTEGER ;
3- Dfinition des diffrents sous-programmes (voir chapitre des sous-

programmes).

4- Dfinition du bloc principal du programme : ce bloc commence par le mot

rserv BEGIN suivi dune squence dinstructions (spares par des points
virgules ;) et se termine par le mot rserv END suivi du point ..
I-2. En langage C
1- Prambule dclaratif qui comporte :
La dclaration des bibliothques utilises, prcde par le mot rserv

#include
Exemple : #include <stdio.h>
La dclaration de lidentificateur de constante, prcde par le mot

rserv define.
Exemple : Define Pi 3.14.
La dclaration des identificateurs de variables, prcde par le type des

variables et suivie du point virgule ;.
Exemple : int x ;
2- En-tte : prcise le dbut du programme principal. Il se compose du mot

rserv Main().
3- Dfinition du bloc principal du programme : ce bloc commence par une

accolade ouvrante { et se termine par une accolade fermante }.
II- Types de donnes

II-1. Variables et constantes
II-1.1 Les variables
On appelle variable, un emplacement mmoire dans lequel est code une

information que lon peut modifier et utiliser grce un identificateur. Toute
variable doit tre dclare avant dtre utilise.
En langage Pascal

Syntaxe : Var <identificateur> : <type>;

Exemple : var x : integer ;
Variables globales et variables locales
Les variables dclares dans la partie dclaration du programme sont dites

globales.
Les variables dclares dans la partie dclaration dun sous-programme sont
dites locales.
Les variables globales sont connues par tous les sous-programmes, tandis que les
variables locales sont connues seulement par le sous-programme dans lequel
elles sont dclares.

En langage C
Syntaxe : <type> <identificateur> ;
Le de lidentificateur peut tre compos de chiffres, de lettres et du caractre _.

Le premier caractre doit tre ncessairement une lettre.
Exemple : int ident_1
Variables globales et variables locales
Selon l'endroit o on dclare une variable, celle-ci pourra tre accessible (visible)
de partout dans le code ou bien dans une portion confine de celui-ci ( l'intrieur
d'une fonction par exemple), on parle de porte (ou visibilit) d'une variable.
Lorsqu'une variable est dclare l'extrieur de toute fonction ou de tout bloc
d'instructions, elle est accessible de partout dans le code (n'importe quelle
fonction du programme peut faire appel cette variable). On parle alors de
variable globale.
Lorsque l'on dclare une variable l'intrieur d'un bloc d'instructions (entre des
accolades), sa porte se confine l'intrieur du bloc dans lequel elle est dclare.
II-1.2 Les constantes
Contrairement une variable, une constante ne peut tre modifie

(thoriquement).
En langage Pascal
Syntaxe : const <identificateur> = valeur ;

Exemple :
Remarque
Contrairement aux variables, il n'est nullement besoin de spcifier le type de la
constante. On peut tout de mme le faire, en utilisant le double point, comme
pour les variables.
Exemple : const Gravite : Real = 9.81;
En langage C
Syntaxe : const <type> <identificateur> = valeur ;

II-2. Les types de base
II-2.1 En langage Pascal
Mmoire
Type Description Intervalle Exemples
requise
Shortint Entiers courts -128 127 -125; 0; 32 1 octet
Integer Entiers "relatifs" -32 768 32 767 -30 000; 421; 2 octets
-2147483648 -12 545 454; 3
Longint Entiers longs 4 octets
2147483647 257
Entiers sur 1 Bit
Byte 0 255 12; 157 1 octet
(Byte ou Octet)
Entiers sur 2 Bits
Word 0 65 535 27; 4 589 2 octets
(Word ou Mot)
3.1415;
Real Nombres rels 2.9E-39 1.7E38 6 octets
789.457851
Nombres dcimaux 3.1415926; 178
Single 1.5E-45 3.4E38 4 octets
(simple prcision) 925.455678
54.5899; 9 897
Nombres dcimaux
Double 5E-324 1.7E308 669 8 octets
(double prcision)
651.45568959
3.14159265458;
Extended Nombres rels 3.4E-4932 1.1E4932 10 octets
9.81
Comp Entier -9.2E18 9.2E18 -271; 6 548 8 octets
Boolean logique sur 1 octet false ou true false; true 1 octet
256 caractres au
Chane de 'Hello!'; 'Allez- 256
String maximum (0
caractres vous bien ?' octets
255)
Chane de n n caractres String[6]-
String[n] n octets
caractres maximum >'Hello!'
1 caractre
Char 1 caractre 'R' 1 octet
maximum

II-2.2 En langage C
Taille (en
Type de donnes Signification Plage de valeurs accepte
octets)
Char Caractre 1 -128 127
Caractre non
unsigned char 1 0 255
sign
short int Entier court 2 -32768 32767
Entier court non
unsigned short int 2 0 65535
sign
int Entier 2 -32768 32767
unsigned int Entier non sign 2 0 65535
-2 147 483 648 2 147 483
long int Entier long 4
647
Entier long non
unsigned long int 2 0 4 294 967 295
sign
float flottant (rel) 4 3.4*10-38 3.4*1038
double flottant double 8 1.7*10-308 1.7*10308
flottant double
long double 10 3.4*10-4932 3.4*104932
long
II-3. Crer un type de donnes
II-3.1 En langage Pascal
Il est possible au programmeur de crer ses propres types. Les types doivent tre
dclars avec le mot-clef Type fortiori avant la dclaration des variables.
Exemple
Type matrice = Array[1..10,1..10] of integer;
Dfinit un type nomm matrice pour reprsenter une matrice carre dordre 10.
Type numr
Dans la dclaration dun type numr, il faut numrer toutes les valeurs de ce
type.
Syntaxe : type nom_du_type = (identificateur_1, identificateur_2,..,
identificateur_n)

Exemple : type jour = (lundi, mardi, mercredi, jeudi, vendredi, samedi,

dimanche) ;
Type intervalle
Syntaxe : type nom_du_type = dbut_de_l_intervalle..fin_de_l_intervalle
Exemple : Type age = 1..150 ;
Dclare un type nomm age dont les valeurs sont des entiers compris entre 1 et
150.
II-3.2 En langage C
Syntaxe : typedef Caracteristiques_du_type Nom_du_type

O :
Caracteristiques_du_type : reprsente un type de donnes existant (par exemple
float, short int, etc.)
Nom_du_type : dfinit le nom quon donne au nouveau type de donnes.
Exemple : typedef short int entier
Le type numr
Le type numr donne une liste de constantes par numration. Le premier
identificateur a, par dfaut, la valeur 0, le second a la valeur 1, etc. Une variable
de type numr est une variable entire.
Exemple :
typedef enum = {JAUNE = -2, ROUGE, VERT, VIOLET, BLEU} COULEUR;
main()
{
COULEUR coul1, coul2;
coul1 = VERT; // coul1 = 0
coul2 = coul1+2; // coul2 = 2
}
III- Oprateurs et expressions

III-1. En langage Pascal
Les expressions sont composes doprateurs et doprandes. La plupart des
oprateurs sont binaires, cest dire quils mettent en uvre deux oprandes
(exemple A+B). Les oprateurs un oprande sont dits unaires (exemple A).

Dans les expressions plus complexes, lexistence de rgles de priorit permet

dliminer toute ambigut dans lordre de ralisation des oprations.
Table de priorit des oprateurs
Ordre Oprateurs Ordre Oprateurs

0 (,[ 5 +,-
1 OR 6 *, /, DIV, MOD
2 AND 7 (+),(-)
3 NOT 8
4 < , >, <= , >= , <> , = 9
Remarque : (+) et (-) deux oprateurs unaires.

Les trois rgles fondamentales de priorit des oprateurs sont les suivantes :
1- Un oprande plac entre deux oprateurs de priorits diffrentes sera li

celui possdant la priorit la plus leve.
2- Un oprande plac entre deux oprateurs de mme priorit sera li celui qui
se trouve gauche.
3- Les expressions contenues entre parenthses sont values dabord afin de
traiter leur rsultat comme un seul oprande.
Dans une expression arithmtique, les oprateurs sont les oprateurs
arithmtiques (+,-,*, /, DIV, MOD).
Un oprande peut tre :
- Un nom de variable ou de constante numrique.

- Une constante numrique.
- Un nom de fonction de type numrique tel que COS, SIN, etc.
Une expression logique simple est une comparaison entre deux expressions
arithmtiques. Les oprateurs de comparaison sont =, <>, <, >, <=, >=.
Une expression logique est la compose dexpressions logiques simples par les
oprateurs logiques :
- OR et AND oprateurs logiques binaires, OR pour la disjonction et AND pour

la conjonction.

- NOT oprateur unaire, NOT oprateur de ngation.
III-2. En langage C
Oprateurs arithmtiques
Une expression peut comporter des oprations. Les objets dune opration sont
les oprandes, qui sont manipuls par les oprateurs.
Oprateur Fonction Nbre

d'oprandes
- Oppos 1
* Multiplicati 2
on
/ Division 2
% Modulo 2
(reste)
+ Addition 2
- Soustraction 2
Remarque : L'oprateur modulo ne peut s'appliquer qu' deux entiers, le rsultat

est le reste de la division entire.
Oprateurs dgalit, relationnels et logiques
Ces oprateurs travaillent sur des oprandes ayant deux valeurs : nul (faux) et
non-nul (vrai). Le rsultat est soit nul (faux), soit non-nul (vrai).
L'oprateur && (ET logique) a pour rsultat vrai si les deux oprandes ont une
valeur vraie. L'oprateur || (OU logique) a pour rsultat vrai si l'un au moins des
deux oprandes a une valeur vraie. Les valuations des oprations logiques sont
effectues de la gauche vers la droite. On peut imposer un ordre en utilisant des
parenthses. L'valuation cesse ds que la valeur de l'expression est tablie.

d'oprandes
! NON logique 1
< Infrieur 2
<= Infrieur ou 2
gal
> Suprieur 2


d'oprandes
>= Suprieur ou 2
gal
== galit 2
!= Ingalit 2
&& ET logique 2
|| OU logique 2
Remarque : Les oprateurs d'galit et logiques ne doivent pas s'appliquer sur

des flottants cause des erreurs d'arrondi. Pour tester l'galit 0 d'un rel, il est
prfrable de tester que sa valeur absolue est infrieure un trs petit.
Oprateurs de dcrmentation et d'incrmentation
Syntaxe : <variable> OP ou OP <variable>
O OP est lun des oprateurs ++ ou --.
Lexpression le_nombre = le_nombre +1 peut tre remplac par le_nombre++ ou

++le_nombre. Mais, ces expressions ne sont pas quivalentes ; la valeur de
lexpression le_nombre++ est gale la valeur de le_nombre avant
lincrmentation alors que ++le_nombre a pour valeur le_nombre aprs
lincrmentation.
Loprateur de dcrmentation a le mme comportement que le prcdent. Ainsi

linstruction le_reel-- diminue de 1 le contenu de le_reel.
Exemple : i++
Oprateur conditionnel
Cet oprateur ncessite trois oprandes et s'apparente un "si".
Syntaxe : expr1?expr2:expr3;
expr1 est value. Si elle est vraie, le rsultat est la valeur de expr2, sinon le
rsultat est la valeur de expr3.
Exemple : a==b?a=2:b=3;
Oprateurs sur les bits

Les oprandes de ces oprateurs doivent tre de type entier (char, int, long,
short), mais ils sont traits comme une suite de bits (donc de 0 et de 1).
L'oprateur ~ remplace chaque 0 par 1 et vice-versa.
Les oprateurs &, ^ et ! oprent sur chaque bit indpendamment. Ils sont
associatifs.
expr1 << expr2 dcale tous les bits de expr1 de expr2 positions vers la gauche ;
les bits vacant sont remplis par des 0.
expr1 >> expr2 dcale tous les bits de expr1 de expr2 positions vers la droite ; il
ne remplit les bits vacants par des 0 que si expr1 est de type unsigned, sinon,
selon les implmentations, il insre des copies du bit de signe ou des 0.

d'oprandes
~ Complmentatio 1
n1
<< Dcalage 2
gauche
>> Dcalage 2
droite
& ET logique 2
^ OU exclusif 2
| OU logique 2
Exemple:
unsigned char val = 1; // 00000001
val = val << 3; // 00001000
val = val >> 2; // 00000010
Remarque: Ne pas confondre les oprateurs sur les bits & et | et les oprateurs
sur les expressions && et ||.
Oprrateur sizeof
Loprateur sizeof fournit la taille en octets. Par exemple, dans une

implmentation o le type int est reprsent sur 2 octets, si lon suppose que lon
a affaire la dclaration int n ; lexpresion sizeof(n) vaudra 2.

Priorit entre oprateurs
Les priorits entre oprateurs dfinissent l'ordre dans lequel ils sont excuts. Le
tableau suivant rcapitule tous les oprateurs avec leur priorit.
En langage C, un certain nombre de notations servant rfrencer des objets sont
considres comme des oprateurs et, en tant que tels, soumises des rgles de
priorit.
Ce sont essentiellement :
- les rfrences des lments dun tableau ralises par [ ] ;
- des rfrences des champs dune structure oprateur -> ;
- des oprateurs dadressage * et &.
Ces oprateurs seront tudis ultrieurement dans les chapitres correspondant
aux tableaux, structures et pointeurs.
Catgorie Oprateurs
rfrence () [ ] -> .
unaire + - ++ -- | ~ * &
arithmtique */%
arithmtique +-
dcalage << >>
relationnels < <= > >=
relationnels == !=
manip. de bits &
manip. de bits ^
manip. de bits |
logique &&
logique ||
conditionnel ?:
affectation = += -= /= %= &= ^= |= <<= >>=
IV- Instructions simples

IV-1. Instructions dentre
Une instruction dentre permet de lire une donne partir du clavier.
En langage Pascal:

Syntaxe :
Read (V1, V2,., Vn) O Vi est une variable de tout type simple (sauf
numr) ou de type chane de caractres.
ReadLn (V1,V2,...Vn) mme effet que Read, mais il faut taper la touche
Entre aprs lentre de la donne. Linstruction ReadLn (sans argument)
attend la frappe de la touche Entre au clavier.
Exemple : read(x) ;
En langage C:
La fonction scanf
Syntaxe : scanf (format, liste_dadresses)
Format : constante chane (entre ""),
Pointeur sur une "chane de caractres"
Scanf("%d",&x) ;
Le tableau suivant prsente les diffrents formats existants :
Type de la Ivalue
Format
correspondant
c char
d int
hd short int
hu unsigned short
ld long int
lu unsigned long
f Float
lf double
s chane de caractres
u unsigned int
Liste_dadresses : liste de "lvalue", spares par des virgules, dun type en
accord avec le code de format correspondant.
La macro getchar()

Elle permet la lecture dun caractre. Lexpression : c=getchar(), joue le mme

rle que : scanf("%c",&c).
IV-2. Instructions de sortie

Une instruction de sortie permet laffichage sur lcran des valeurs
correspondantes aux arguments considrs.
En Pascal
Syntaxe
Write (val1,val2,,valn) O vali est une valeur dune donne constante ou

variable (sauf type numr), une constante chane de caractres, ou une
valeur dune expression.
WriteLn(val1,val2,valn) mme effet que Write, mais le curseur passe la
ligne suivante aprs laffichage.
Exemple : write(salut ,nom) ;
Remarque :
Une constante chane de caractres est mise entre apostrophe. Une
apostrophe comprise dans une chane doit tre ddouble.
Linstruction WriteLn (sans arguments) permet un saut de ligne.
En langage C :
La fonction printf
Syntaxe : printf (format, liste_dexpressions)
Format : constante chane (entre ""),

Pointeur sur une "chane de caractres"
Liste_dexpressions : suite dexpressions spares par des virgules dun type en
accord avec le code format correspondant.
Exemple : printf("salut %s",nom) ;
La macro putchar
Permet lcriture dun caractre. Lexpression putchar(c), joue le mme rle que :
printf("%c",c).

IV-3. Instruction daffectation

En langage Pascal :
Cette instruction permet de transcrire une valeur dans une variable. Le symbole
daffectation est :=
Syntaxe : <Var> := <Val> ;
O la variable <Var> peut tre de tout type et la valeur <Val> peut tre une
valeur constante, la valeur dune donne constante ou variable, la valeur dune
fonction, ou le rsultat dune expression.
Exemple : x :=2 ;
En langage C :
Affectation ordinaire
Syntaxe : <variable> = <expression> ;
Exemple : x=2 ;
Remarque :
La valeur affecte une variable doit tre de mme type ou de type compatible
celui de la variable.
Notion de Ivalue
On constate que loprateur daffectation impose des restrictions sur son premier
oprande. En effet, ce dernier doit tre une rfrence un emplacement mmoire
dont on pourra effectivement modifier la valeur.
Dans les autres langages, on dsigne souvent une telle rfrence par le nom
dune variable. Cependant, en langage C, la syntaxe est telle que cette notion
de variable nest pas assez prcise. Il faut introduire un mot nouveau : la
Ivalue ; ce terme dsigne une valeur gauche, cest--dire tout ce qui peut
apparatre gauche dun oprateur daffectation.
Affectation largie
Le langage C permet de condenser les affectations de la forme :
Ivalue = Ivalue oprateur expression

En : Ivalue oprateur= expression

Cette possibilit concerne tous les oprateurs binaires arithmtiques et de
manipulation de bits (voir chapitre suivant). La liste complte de tous ces
nouveaux oprateurs daffectation largie est : +=, -=, *=, /=, %=, |=, ^=, &=,
<<= et >>=.
Remarque
Ne confondez pas loprateur de comparaison <= avec un oprateur daffectation
largie. Notez bien que les oprateurs de comparaison ne sont pas concerns par
cette possibilit.
V-Enonc des exercices

Exercice 1
Ecrire un programme qui permet dafficher le message suivant : mon premier
programme.
Exercice 2
Ecrire un programme qui demande l'utilisateur les valeurs de 2 entiers x et y,
qui permute leurs valeurs et qui les affiche.
Exercice 3
Ecrire un programme qui change 3 entiers.
Exercice 4
Ecrire un programme qui demande l'utilisateur les coordonnes de 2 points
distincts du plan et qui affiche les coordonnes du point milieu.
Exercice 5
Ecrire un programme qui demande l'utilisateur une valeur pour U 0, r et n et qui
affiche la nime valeur de la suite arithmtique dfinie par U 0 et Un+1 = Un + r.
(On rappelle la proprit : Un = U0 + n.r ).

Structures de traitement alternatives et itratives
STRUCTURES DE TRAITEMENT
ALTERNATIVES ET ITRATIVES
Les instructions structures sont des instructions composes dautres

instructions devant tre excutes sous certaines conditions (instructions
conditionnelles) ou rptes plusieurs fois (instructions rptitives).
I- Instructions conditionnelles
En langage Pascal :
Instruction IFThen
Syntaxe : IF <Cond> THEN <Bloc> ;
Si <Cond> est vraie, le bloc dinstructions <Bloc> sera excut, sinon il sera
ignor.
Cette instruction reprsente lalternative simple (instruction de choix unaire).
Exemple : if a=b then a :=a+b ;
Instruction IFTHENELSE
Syntaxe : IF <Cond> THEN <Bloc1> ELSE <Bloc2>;
Si <Cond> est vraie, le bloc dinstructions <Bloc1> sera excut et le bloc

dinstructions <Bloc2> sera ignor, sinon cest le bloc dinstructions <bloc2> qui
sera excut et le bloc dinstructions <Bloc1> sera ignor.
Cette instruction reprsente lalternative complte (instruction de choix binaire).
Exemple : if a>b then a:=a-b
Else a:=b-a;
Remarque : la clause ELSE ne doit pas tre prcde par un point virgule ;.
Instruction CASE
Linstruction CASE est constitue dune expression de type scalaire,

reprsentant le slecteur, et dune liste de blocs dinstructions ; chacun tant

prcd par une tiquette de cas de mme type que le slecteur. Le bloc
dinstructions excut est celui dont ltiquette de cas correspond la valeur
courante du slecteur.
Une tiquette de cas est constitue de tous nombres de constantes ou

dintervalles, spars par des virgules et termins par le symbole :.
Syntaxe :
CASE <Slecteur> OF
Val1 : <Bloc1> ;
Val2 : <Bloc2> ;
..........................
Valn : <Blocn> ;
ELSE <Bloc>;
END;
En langage C :
Instruction IF :
Syntaxe : if (expression) instruction
Expression : expression quelconque.

Instruction : instruction simple termine par un point virgule, bloc dinstructions
places entre { et }, ou instruction structure.
Instruction IFElse :
Syntaxe : IF (expression) instruction1 ELSE instrucion2
Instruction SWITCH:
Syntaxe:
Switch(expression)
{ case constante1: [suite_dinstruction1]
case constante2: [suite_dinstruction2]
..........................................................
case constante n: [suite_dinstruction n]
[default : suite_dinstruction ]
}
Expression : expression entire quelconque,

Constante : expression constante dun type entier quelconque (char est accept
car il sera convertit en int),
Suite_dinstructions : squence dinstructions quelconques.
N.B : les crochets ([et]) signifient que ce quils renferment est facultatif.
Lexcution de linstruction switch commence par valuer lexpression figurant

aprs le mot switch, ensuite, chercher ltiquette de la forme case
x correspondant la valeur obtenue et excuter, enfin, linstruction figurant aprs
cette tiquette. Dans le cas o ltiquette ne figure pas dans la liste, cest le bloc
par dfaut qui est excut.
Remarque :
On peut ajouter linstruction break qui permet de sortir de linstruction
switch juste aprs lexcution du bloc de ltiquette choisie.
Switch(expression)
{ case constante1: [suite_dinstruction1]
break ;
case constante2: [suite_dinstruction2]
break ;
..........................................................
case constante n: [suite_dinstruction n]
break ;
[default : suite_dinstruction ]
}
les case peuvent apparatre dans nimporte quel ordre.
II- Instructions rptitives
Structures En langage Pascal En langage C

While <expression> While (<expression>)
Tant que
Do <bloc> <instruction>
Repeat<instruction> Do <instruction>
Rpter - jusqu
Until <expression> While(<expression>)
Pour For comp :=Vint To Valf For
Do <bloc> (<initialisation> ;<condition
For comp :=Vint DownTo de
Valf continuation ;<modification>)

Do <bloc> <instruction>
III- Enonc des exercices

Exercice 6
Ecrire un programme qui change les contenus de 2 donnes si elles sont de
signes contraires.
Exercice 7
Ecrire un programme qui change les contenus de 2 donnes si elles sont de
signes contraires, sinon, il met leur produit dans la premire donne et leur
somme dans la deuxime
Exercice 8
Ecrire un programme qui, tant donn un mois et son premier jour, affiche le
premier jour du mois suivant.
Exercice 9
Ecrire un programme qui calcule la somme des N premiers termes positifs.
Exercice 10
Ecrire un programme qui calcule la somme des N premiers termes positifs
impairs.

Exercice 11
Ecrire un programme qui calcule la somme des N premiers termes positifs pairs
non multiples de 3.
Exercice 12
Ecrire un programme qui calcule la somme 1/2 + 1/4 + 1/8 ++1/2n (n N*).
Exercice 13
Ecrire un programme qui calcule la somme 1+1/2-1/4+ 1/8-1/16+1/2 n (n
N*).
Exercice 14
Ecrire un programme qui donne le nombre N tel que la srie 1+1/2-1/3+1/4- 1/5+
1/N donne un rsultat gal ( 1/100 prs) 1,33.
Exercice 15
Ecrire un programme qui donne la plus grande valeur infrieure 1000 de la
somme 1+2+4+8++2N.
Exercice 16
Ecrire un programme qui calcule la somme 1+x+x2++xn (x rel et n entier).
Exercice 17
Calcul approch de x
Soient les deux suites: An+1= (An+Gn)/2 et Gn+1=2AnGn/(An+Gn) avec A0=x et
G0=1, on montre que lim An=lim Gn= x
n n
Ecrire un programme qui donne la valeur de x avec une prcision relative
=10-6, cest dire |An-Gn|/|Gn|<
Exercice 18
Sachant que la somme 1-1/3+1/5-1/7+1/9-, tend vers /4. crire un
programme qui calcule le nombre 10-6 prs
Exercice 19
Le dveloppement limit de la fonction sinus au voisinage de zro est sin x= x -
x3/3! + x5/5! -+(-1)p x2p+1/(2p+1)!+
Ecrire un programme qui calcule sin x 10-6 prs.
Exercice 20
Ecrire un programme qui calcule la somme, le produit et la diffrence de deux
donnes numriques.
Exercice 21
Ecrire un programme qui retourne le code dune donne de type Caractere.

Exercice 22
Ecrire un programme qui calcule le salaire net dun employ, sachant que celui-
ci a assur un certain nombres dheures de travail un prix fixe par heure, et que
lemployeur doit rduire de son salaire des charges qui sont calcules avec un
coefficient donn.
Exercice 23
Ecrire un programme qui permet de reprendre lexercice prcdant en
considrant que lemploy a assur des heures normales, des heures 25% et des
heures 50%.
Exercice 24
Ecrire un programme qui retourne si une donne numrique est paire ou impaire
(utiliser le reste de la division par 2).
Exercice 25
Ecrire un programme qui permet de lire trois donnes numriques et retourne si
la troisime donne est la somme des deux autres ou pas.
Exercice 26
Ecrire un programme qui, partir du salaire brut dun employ, dtermine
limpt payer sachant que les rgles de calcul des impts sont comme
suit :
salaire brut(SB) limpt payer

SB<1500 0%
1500<=SB<3000 10% du SB
3000<=SB<5000 450+30%(SB-3000)
SB>=5000 750+40%(SB-5000)
Exercice 27
Ecrire un programme qui fournit les racines de lquation Ax2+Bx+C=0.
Exercice 28
Ecrire un programme qui, tant donne une date (jour, mois, anne), affiche la
date du jour suivant.
Exercice 29
Ecrire un programme qui, tant donne une date (jour, mois, anne), affiche la
date du jour prcdent.
Exercice 30
Ecrire un programme qui calcule la somme 5+6+7+.+N (N>=5).
Exercice 31
Ecrire un programme qui calcule le produit des N (N>0) premiers entiers positifs.

Exercice 32
Ecrire un programme qui calcule la somme 1+1/2+1/4+1/6++1/2N (N>0).
Exercice 33
Ecrire un programme qui change les contenus de trois donnes numriques si
leur somme est paire, sinon il met la somme des trois dans la premire donne,
leur produit dans la seconde et la valeur zro dans la troisime.
Exercice 34
Ecrire un programme qui calcule la somme 1-1/2+1/3-1/4+1/N.

Notion de sous-programmes
NOTION DE SOUS-PROGRAMMES
Un sous-programme permet :
dviter dappliquer plusieurs endroits dun programme le mme traitement,
mme sil porte sur des objets diffrents.
dappliquer sous forme transportable un traitement dont on prvoit que
dautres programmes peuvent aussi en avoir besoin.
de dgager dun programme des tches de moindre importance ne laissant
dans son corps que la partie importante de lalgorithme do le gain de
lisibilit et de scurit.
I. En langage Pascal
Les sous-programmes en Pascal sont des procdures et des fonctions.
I.1 Les procdures

Une procdure doit tre dclare dans un programme, ou dans une procdure,
avant le corps du programme (de la procdure) et aprs les dclarations des
variables.
Le nom de la procdure est un identificateur qui, comme les autres dclarations
environnantes, sera local au programme ou la procdure lenvironnant.
La structure dune procdure est peu prs celle dun programme, len-tte
diffre, la procdure se termine par un point virgule au lieu dun point.
Syntaxe : procedure <Ident> ;
<Dclarations> ;
Begin
<Instructions> ;
End ;
Paramtres formels
La dclaration des procdures peut tre suivie dune liste de paramtres entre
parenthses. Un paramtre formel est destin tre remplac, chaque fois que la

procdure est active, par un autre objet dit paramtre effectif, le plus souvent
une variable, ou le rsultat dune expression, de la procdure appelante.
Syntaxe : Procedure <Nom> ( <mode> <Ident>.., <Ident> : <Type> ;.. ; <mode>
<Ident>,.., <Ident> : <Type>) ;
O <mode> = rien ou var.
Paramtres par valeurs et paramtres par adresse
Les objets sont transmis comme donnes dont la valeur doit tre inchange par
la procdure appele (on dit quon a une lecture pure).
Les objets sont transmis comme rsultat dont la valeur doit tre calcule par la
procdure appele et transmise la procdure appelante (on dit quon a une
criture pure).
Les objets sont transmis comme donnes qui doivent tre modifies par la
procdure appele (on dit quon a une lecture-criture).
En Pascal, la transmission des paramtres se fait de deux manires :
Transmission par valeur (lecture pure).
Transmission par adresse (criture pure, lecture-criture).
On indique les paramtres transmis par adresse, prcds par le mot rserv Var,
les autres ne sont prcds par aucune chose.
I.2 Les fonctions

Une fonction en Pascal se comporte comme une procdure sauf que la fonction
doit fournir un rsultat, elle a donc un type.
Syntaxe : Function <Ident> : <Type> ;
Function <Ident> (<liste_paramtres> ) : <Type> ;
Dans le corps de la fonction, on doit trouver quelque part laffectation dune
valeur lidentificateur de la fonction.
Exemple :
Function Minimum (x, y : Integer ) : Integer ;
Begin
If x<y then Minimum :=x
Else Minimum:=y
End;
II. En langage C

Les fonctions sont les seuls sous-programmes en C; elles permettent de regrouper

des instructions et de lancer leur excution grce un identificateur. La fonction
peut admettre des paramtres.
La fonction peut retourner une valeur. La dfinition dune fonction est compose
de deux lments :
son prototype :
Permet de prciser la classe de mmorisation, le type, lidentificateur et les

paramtres de la fonction ; cest lentte de la fonction.
Syntaxe :
[classe][type]<identificateur>([liste des paramtres formels]). La liste est

compose de la dclaration des paramtres formels :
<type><arg1>,<type><arg2>,,<type><argn>.
Si la liste est vide alors elle peut tre remplace par le mot void.
Son corps : cest un bloc dinstructions
[classe][type]<identificateur>([liste des paramtres formels])

{
<corps de la fonction>
}/*fin de la fonction*/
Ds quune instruction de retour est rencontre, lexcution de la fonction
sinterrompt. Cette instruction permet de transmettre ventuellement une valeur
au programme appelant.
Syntaxe :
return ; /*pas de valeur retourne*/

return <expression> ;
return(<expression>) ;
Si la fonction ne contient pas linstruction return, elle sachve automatiquement
la fin de son bloc.
Passage des paramtres par valeur

En langage C, le passage des paramtres se fait toujours par valeur,

c.--d. les fonctions travaillent sur les valeurs de leurs paramtres et n'ont pas
d'accs aux variables elles-mmes. Les paramtres d'une fonction sont
considrer comme des variables locales qui sont initialises automatiquement
par les valeurs indiques lors d'un appel. A l'intrieur de la fonction, nous
pouvons donc changer les valeurs des paramtres sans influencer les donnes
originales dans les fonctions appelantes.
Passage par adresse
Pour changer la valeur d'une variable de la fonction appelante, il faut que la

fonction appelante fournisse l'adresse de la variable et la fonction appele dclare
le paramtre comme pointeur.
On peut alors atteindre la variable l'aide du pointeur (voir chapitre structure de
donnes).
III. La rcursivit
Un sous-programme est dit rcursif sil sappelle lui-mme. Il doit contenir une condition
darrt. Considrons lexemple de la fonction pgcd(a, b) qui retourne le plus grand
diviseur commun des deux entiers a et b :
En langage C En langage Pascal

int pgcd(int a, int b) Funtion pgcd (a,b : integer): integer;
{ if (a = = b) return a; Begin
else if (a>b) return pgcd(a-b,b); If (a=b) then pgcd:=a
else pgcd(a,b-a); Else if (a>b) then pgcd:=pgcd(a-
} b,b)
Else pgcd:=pgcd(a,b-a)
End;
IV- Enonc des exercices

Exercice 35
Ecrire une fonction paramtre qui retourne si un nombre donn est premier ou
non.
Exercice 36
Ecrire une fonction paramtre qui retourne si un nombre donn est parfait ou
non.

Exercice 37
Ecrire une fonction paramtre qui retourne si deux nombres donns sont amis
ou non.
Exercice 38
Ecrire une fonction paramtre qui retourne linverse dun nombre entier donn.
Exercice 39
Ecrire une fonction rcursive permettant de calculer le PGDC de deux nombres
entiers positifs A et B.
Exercice 40
Ecrire une fonction rcursive permettant de calculer le PPMC de deux nombres
entiers positifs A et B.
Exercice 41
Ecrire une fonction rcursive qui permet de calculer le factoriel dun nombre
donn.
Exercice 42
Ecrire une fonction rcursive qui permet de calculer la puissance dun entier
donn.
Exercice 43
Ecrire une fonction rcursive qui calcule la valeur de la fonction dAckermann
A dfinie pour m>0 et n>0 par :
A(m, n)=A((m-1),A(m,n-1)) pour n>0, m>0 ;
A(0,n)=n+1 pour n>0;
A(m,0)=A(m-1,1) pour m>0 ;
Exercice 44
Ecrire une fonction qui fournit le nombre de chiffres dun entier donn.
Exercice 45
Ecrire une procdure qui permet de dessiner la lettre X, l'aide d'espaces et d'une
"lettre" fournie par l'utilisateur, auquel on demande aussi la "hauteur" du dessin
qu'il dsire obtenir.

Par exemple : avec les rponses a et 5, elle donnera :

a a
a a
a
a a
a a
Exercice 46
Soit un programme qui visualise un menu compos de trois rubriques : Hors
duvre, plat chaud et dessert.
Ecrire une procdure qui permet deffectuer, chaque fois, un choix exclusif.
Exercice 47
Ecrire une procedure paramtre, qui permet lchange des contenus de deux
paramtres formels par valeur A et B. Appeler cette procdure dans un
programme principal.On crira les rsultats dans le corps de la procdure, et dans
le programme principal.
Exercice 48
Ecrire une procedure paramtre, qui permet lchange des contenus de deux
paramtres formels par adresse A et B. Appeler cette procdure dans un
programme principal.On crira les rsultats dans le corps de la procdure, et dans
le programme principal.
Exercice 49
Ecrire une procdure qui affiche tous les nombres premiers qui sont compris
entre 1 et 200.
Exercice 50
Ecrire une procdure qui affiche tous les nombres parfaits qui sont compris entre
1 et 200.
Exercice 51
Ecrire une procdure qui permet dafficher tous les diviseurs dun entier N ainsi
que leur nombre.
Exercice 52
Affichez un triangle isocle form d'toiles sur N lignes (N est fourni au clavier).

Exemple : N=8
*
***
*****
*******
*********
***********
*************
***************
Exercice 53
Calculer pour une valeur X donne du type rel la valeur numrique d'un
polynme de degr n:
P(X) = AnXn + An-1Xn-1 + ... + A1X + A0
Les valeurs de n, des coefficients An, ..., A0 et de X seront entres au clavier.
Utiliser le schma de Horner qui vite les oprations d'exponentiation lors du
calcul:
Exercice 54
Ecrire une procdure qui affiche la table des produits pour N variant de 1 10 :
X*Y I 0 1 2 3 4 5 6 7 8 9 10
--------------------------------------------------
0 I 0 0 0 0 0 0 0 0 0 0 0
1 I 0 1 2 3 4 5 6 7 8 9 10
2 I 0 2 4 6 8 10 12 14 16 18 20
3 I 0 3 6 9 12 15 18 21 24 27 30
4 I 0 4 8 12 16 20 24 28 32 36 40
5 I 0 5 10 15 20 25 30 35 40 45 50
6 I 0 6 12 18 24 30 36 42 48 54 60
7 I 0 7 14 21 28 35 42 49 56 63 70
8 I 0 8 16 24 32 40 48 56 64 72 80
9 I 0 9 18 27 36 45 54 63 72 81 90
10 I 0 10 20 30 40 50 60 70 80 90 100

Les structures de donnes statiques
LES STRUCTURES DE
DONNES STATIQUES
Une structure de donnes est un ensemble organis dinformations relies

logiquement, ces informations peuvent tre traites collectivement ou
individuellement.
Une structure de donnes est caractrise par ses composantes et leur
organisation, mais surtout par ses mthodes daccs.
I. Les structures de donnes homognes

En langage Pascal:
Tableau
Un tableau est une suite dlments de mme type. En Pascal, la dclaration des
tableaux se fait comme suit :
Syntaxe : Var NomTab : Array[Min..Max] Of Type;
On accde un lment du tableau en utilisant un index : Exemple NomTab[4].
Chanes de caractres
En Pascal, la dfinition du type chane est constitue du mot rserv STRING

suivi de la longueur maximale entre crochets. La longueur est une constante
entire dans lintervalle [0,255]. Si la longueur maximale nest pas prcise, elle
est gale 255 par dfaut.
Les variables chanes occupent en mmoire la longueur maximale dfinie +1
octet. Le premier octet contient la longueur courante de la chane. Les caractres
individuels sont indexs de 1 la longueur maximale de la chane.
Expressions chanes
Le signe + est utilis pour concatner des chanes.

Exemple : 123 + 456 = 123456.
On peut comparer deux chanes, le rsultat est une valeur boolenne.

Exemple : 12 < 2 est vraie
Affectation de chanes
Loprateur daffectation est utilis pour affecter la valeur dune expression une
variable chane.
Exemple : p :=Programmation ;
Procdures sur les chanes
Procdure Commentaires
supprime dans la chane st une sous-chane contenant
DELETE (st,pos,num)
num caractres partir du caractre de position pos.
permet linsertion de la chane obj dans la chane target
INSERT(obj,target,pos)
la position pos.
convertit la valeur numrique de value en une chane,
STR(value,st)
et range le rsultat dans st.
convertit lexpression chane st en une valeur entire
ou relle (en fonction de type de var) et range la valeur
dans var. code doit tre une variable entire. Si aucune
VAL(st,var,code)
erreur nest dtecte, code est mise zro, sinon code a
la valeur de la position du premier caractre en erreur
et la valeur de var est indfinie.
Fonctions sur les chanes
Fonctions Commentaires
retourne une sous-chane contenant num caractres de
COPY(st,pos,num)
st en commenant par le caractre de position pos.
retourne une chane qui est la concatnation de ces
CONCAT(st1,st2,,stn)
arguments dans lordre o ils sont dclars.
LENGTH(st) retourne la longueur effective de la chane st.
si obj est contenu dans target alors pos retourne la
POS(obj,target) position du premier caractre de obj dans target sinon
pos retourne zro.
Ensembles

La structure de donnes Ensemble permet de reprsenter lobjet mathmatique

ensemble sur lequel on peut effectuer les oprations dappartenance, de runion,
etc.
Bien quen mathmatiques il ny ait pas de restriction sur les objets qui pourront
tre membre dun ensemble, Pascal ne procure quune forme restreinte
densemble. Les membres dun ensemble doivent tre tous de mme type appel
type de base.
Dclaration : <ident> : SET of <type>
Exemple: ens: set of char
Remarques
Le nombre maximum dun ensemble est 256.
On note par [ ] lensemble vide compatible avec tout type ensemble.
Oprateurs sur les ensembles

Le symbole dappartenance est IN
Le symbole dintersection est *
Le symbole de runion est +
Le symbole de diffrence est -
= test dgalit
<> test dingalit
>= vrai si tous les membres du second oprande sont inclus dans le premier.
<= vrai si tous les membres du premier oprande sont inclus dans le second.
En langage C
Tableau
En langage C, la syntaxe de la dfinition d'un tableau est la suivante :
Syntaxe : type Nom_du_tableau [Nombre d'lments]
Type : dfinit le type d'lments que contient le tableau (un tableau en langage C
est compos uniquement d'lments de mme type).
Nombre d'lments : est un nombre entier qui dtermine le nombre de cases du

tableau.
Exemple : int T[]20 ;

Chane de caractres
En langage C, une chane de caractres est un tableau de type char, dont le

dernier lment est le caractre nul '\0', c'est--dire le premier caractre du code
ASCII (dont la valeur est 0).
Ce caractre est un caractre de contrle (non affichable) qui permet d'indiquer la
fin de la chane de caractres. Ainsi, une chaine compose de n lments sera en
fait un tableau de n+1 lments de type char.
On peut par exemple reprsenter la chane "Bonjour" de la manire suivante:
B o n j o u r \0
Pour dfinir une chane de caractres en langage C, il suffit de dfinir un tableau

de caractres. Le nombre maximum de caractres que comportera la chane sera
gal au nombre d'lments du tableau moins un (rserv au caractre de fin de
chane).
Syntaxe : char Nom_du_tableau[Nombre_d_elements]
Lecture et criture des chanes
Le langage C offre plusieurs possibilits de lecture ou dcriture de chanes :

- Lutilisation du code de format %s dans les fonctions printf et scanf.
- Les fonctions spcifiques de lecture (gets) ou daffichage (puts) dune
chane.
Exemple : char ville[25] ;
gets(ville) ;
puts(ville) ;
Remarque : Avec le code %s de scanf, on utilise les dlimiteurs habituels
(espace ou la fin de ligne). Cela interdit donc la lecture dune chane contenant
des espaces. Avec gets seule la fin de ligne sert de dlimiteur.
Les fonctions de manipulation de chanes de caractres
De nombreuses fonctions de manipulation de chanes se trouvent dans le fichier

d'en-tte <string.h>, c'est la raison pour laquelle il faut ajouter la ligne suivante
au dbut du programme : #include <string.h>

recopie la seconde chane (source) la
strcat(but,source)
suite de la premire (but).
travaille de faon semblable strcat en
offrant en outre un contrle sur le
strncat(but,source,lgmax)
nombre de caractres qui seront
concatns la chane darrive (but).
compare deux chanes dont on lui
fournit ladresse et elle fournit une
valeur entire dfinie comme tant :
strcmp(chane1,chane2)
Positive si chane1 > chane2
Nulle si chane1 = chane2
Ngative si chane1 < chane2
travaille comme strcmp mais elle limite
strncmp(chane1,chane2,lgmax) la comparaison au nombre maximal de
caractres indiqus par lentier lgmax.
travaillent respectivement comme
stricmp(chane1,chane2) et strcmp et strncmp, mais sans tenir
strnicmp(chane1,chane2,lgmax) compte de la diffrence entre
majuscules et minuscules.
recopie la chane situe ladresse
strcpy(destin,source) source dans lemplacement dadresse
destin.
procde de manire analogue strcpy,
en limitant la copie au nombre de
strncpy(destin,source,lgmax)
caractres prciss par lexpression
entire lgmax.
recherche dans chane la premire
strchr(chane,caractre) position o apparat le caractre
mentionn.
ralise le mme traitement que strchr,
strrchr(chane,caractre) mais en explorant la chane concerne
partir de la fin.
recherche dans chane la premire
strstr(chane,sous-chane) occurrence de la sous-chane
mentionne.

II. Les structures de donnes htrognes

En langage Pascal
Les enregistements
Un enregistrement est un ensemble dinformations de types diffrents accessibles

individuellement ou collectivement. Cest une structure constitue dun nombre
fixe de composantes appeles champs.
Syntaxe : TYPE nom_type = RECORD champ1:type ; champ2:type ;.... END;
Exemple : TYPE date = RECORD
Jour : 1..31 ;
Mois : (jan,fev,mars,avr,mai,jui,juil,aout,sep,oct,nov,dec) ;
An : 1900..2000 ;
END ;
VAR date_nais : date ;
Laccs au champ jour dans date_nais par exemple se fait par date_nais.jour.
Laffectation entre deux variables enregistrements de mme type est autorise.
Exemple : with date do jour:=2;
Instruction with
Syntaxe: WITH nom_enregistrement DO instruction
Elle permet d'omettre le nom_enregistrement dans l'instruction.
En langage C
Les structures
Dans un tableau, tous les constituants doivent tre semblables. Ce n'est pas le cas
des structures, qui sont des variables composes de plusieurs variables (ou
CHAMPS) de types diffrents.
Syntaxe : struct Nom_Structure {

type_champ1 Nom_Champ1;
type_champ2 Nom_Champ2;
...
};

Exemple : struct date{

Int jour;
Int mois ;
Int annee ;
};
Dfinition dune variable structure
Cest une variable ayant comme type celui d'une structure que l'on a
prcdemment dclare.
Syntaxe : struct Nom_Structure Nom_Variable_Structuree;
- Nom_Structure reprsente le nom d'une structure que l'on aura

pralablement dclare.
- Nom_Variable_Structuree est le nom de la variable de type
Nom_Structure.
Pour accder aux champs d'une structure, on utilise un point plac entre le nom
de la variable structure que l'on a dfinie et le nom du champ.
Exemple : date_naiss.jour;

Exercice 55
Ecrire une procdure qui affiche les nombres ngatifs dune liste relle.
Exercice 56
Ecrire une procdure qui met zro la diagonale dune matrice carre.
Exercice 57
Ecrire une procdure qui affiche loccurrence dexistence dun nombre rel dans
une liste de nombres rels.
Exercice 58
Ecrire une procdure qui met le plus petit lment dune liste au dbut de celle-
ci.
Exercice 59
Ecrire une procdure qui met les lments ngatifs dune liste gauche et les
lments positifs droite de la liste.

Exercice 60
Ecrire une procdure qui classe une liste de notes de la plus petite la plus
grande.
Exercice 61
Etant donn N tudiants, leurs notes correspondantes M matires et leur
moyenne. Ecrire une procdure qui affiche ct de chaque tudiant son
classement.
Exercice 62
Le tri bulles est un tri par change. Le principe de base est de rordonner les
couples non classs tant quils existent. La mthode de tri bulles consiste
parcourir la liste en comparant deux lments successifs et en les permutant sil y
a lieu. Ecrire une procdure qui ralise ce tri.
Exercice 63
Un palindrome est un mot, ou une phrase, lisible indiffremment de la gauche
vers la droite ou inversement. Ecrire une fonction qui retourne si une chane de
caractres est un palindrome ou non.
Exercice 64
Ecrire une fonction qui retourne la frquence doccurencedun mot dans une
phrase.
Exercice 65
Ecrire une procdure qui enlve tous les blancs au dbut dune phrase et qui
laisse un seul blanc entre les diffrents mots de la phrase.
Exercice 66
Soit un nombre entier positif N. Ecrire une fonction qui donne son quivalent
dans une base donne B (2B16).
Exercice 67
Soit N un nombre donn en base B (B 10). Ecrire une fonction qui donne son
quivalent en base 10.
Exercice 68
Soit N un nombre donn en base B1. Ecrire une fonction qui donne son
quivalent en base B2.

Exercice 69
Si on est amen raliser des oprations sur des nombres entiers trs grands, on
peut utiliser les chanes de caractres pour reprsenter ces nombres et ensuite
faire lopration par bloc.
Ecrire une procdure pour raliser lopration daddition sur de tels nombres.
Exercice 70
Ecrire une procdure qui permet de passer de la reprsentation dun nombre en
chiffres romains sa reprsentation dcimale.
Exercice 71
Ecrire une procdure qui permet de passer de la reprsentation dcimale dun
nombre sa reprsentation en chiffres romains.
Exercice 72
Ecrire une fonction qui retourne le dterminant dune matrice carre.
Exercice 73
Ecrire une procdure qui calcule linverse dune matrice carre.
Exercice 74
Un carr magique est un carr divis en cellules dans lesquelles les nombres
entiers, partir de 1 sont disposs de telle sorte que les sommes de chaque ligne,
de chaque colonne et de chaque diagonale soient gales.
Exemple :
6 1 8
7 5 3
2 6 4
Ecrire une procdure qui permet de raliser le carr magique dordre n (n

impair).
Exercice 75
Ecrire un programme qui permet de saisir et dafficher les informations dune
liste dtudiants.
Exercice 76
Ecrire les procdures qui donnent le calcul sur les nombres complexes au moyen
dun type enregistrement.

Les structures de donnes dynamiques
LES STRUCTURES DE DONNES

DYNAMIQUES
Dans la pratique, trs souvent, on veut reprsenter des objets, soit dont on ne
connat pas priori la taille, soit dont la taille est variable, selon les cas ou au
cours du traitement. On est alors amen utiliser des structures qui peuvent
voluer, pour bien sadapter ces objets. Ce sont les structures de donnes
dynamiques.
I- En langage Pascal
I-1. Les pointeurs
Un pointeur est une variable contenant l'adresse d'une autre variable d'un type
donn.
Syntaxe : type type_pointeur = ^type_base ;
type_base = ident_type ;
Si le type de base type_base est un identificateur non encore dclar, il doit ltre
dans la mme partie de la dclaration que le type pointeur type_pointeur.
Exemple : type ref = înteger ;
Remarques :
ref est une variable pointeur et ref^ la variable pointe.
La constante NIL peut tre affecte nimporte quelle variable pointeur
(NIL ne fait rfrence aucun lment du type associ).
Le type prdfini Pointer indique un pointeur non typ, cest--dire un
pointeur qui ne pointe pas sur un type particulier.
Loprateur @ fait pointer la variable pointeur sur une zone mmoire
contenant une variable.
Procdures et fonctions dallocation dynamique de mmoire

Ces procdures et fonctions permettent de manipuler le tas (zone de mmoire qui

correspond tout ou partie de lespace mmoire laiss vacant aprs chargement
du programme).
Procdures ou fonctions Commentaires

cre un espace mmoire de la taille de la
New (var p:pointeur) variable pointe et affecte ladresse de
celui-ci au pointeur
cre une nouvelle variable dynamique de la
GetMem (var p:pointeur;
taille indique et place son adresse dans une
taille:word)
variable pointeur.
fait pointer la variable pointeur sur une
adresse mmoire spcifique sans faire
intervenir de notion de variable occupant
Ptr (seg,dep:word)
cet espace. Ptr convertit une adresse format
segment:dplacement en une valeur de type
pointeur.
libre la mmoire dune variable
Dipose (var p:pointeur)
dynamique.
FreeMem (var libre la mmoire dune variable
p:pointeur;taille:word) dynamique dune certaine taille
mmorise la valeur du pointeur de tas dans
Mark (var p:pointeur)
une variable de type pointeur.
restaure le tas dans une configuration
Release (var p:pointeur) donne. Le pointeur p doit tre initialis par
la procdure Mark.
Les listes chanes
Une liste chane est une suite de donnes (liste) lies entre elles. Le lien est
ralis par des pointeurs. Chaque lment de la liste est un enregistrement dont
lun des champs est un pointeur qui pointe vers llment suivant.

Tte de la liste
L a1
e1 a2 e2 a3 en NIL
Queue de la liste
Exemple :
type nbrpoint = ^nombre ;
nombre = record
nbr : integer ;
suivant : nbrpoint ;
end ;
Linsertion dun lment x dans une liste chane se fait en deux tapes :
1. allocation de lespace mmoire quoccuperait x.
2. cration des liens avec llment de gauche puis de droite.
Llimination dun lment x dune liste chane se fait en deux tapes :

1. cration des liens entre llment de gauche et de droite.
2. libration de lespace mmoire quoccupait x.
Les arbres
Lorsquon gnralise la notion de listes chanes en associant chaque lment

de la liste 2 ou plusieurs successeurs, tout en gardant une structure une seule
tte, on obtient ce quon peut appeler un arbre.
A
B C
D E F G
I
H
J

Dfinitions :
Nud : chaque lment dun arbre est appel nud.

Racine darbre : le premier nud darbre est appel racine (ici A).
Feuille : un nud sans successeur est appel feuille (comme D, E, F, H,
I,J).
Arc : un lien entre 2 nuds successifs est appel arc.
Chemin : un chemin est une squence darcs reliant deux nuds dun
mme arbre (A B E).
Pre / Fils / Anctre / Descendant :
- Un successeur B dun nud A est appel fils de A, A est alors pre
de B ;
- Si A dispose dun autre fils C alors B et C sont frres ;
- B et C sont aussi appels des descendants immdiats ;
- Les fils de B et C sont aussi des descendants de A ;
- A est alors lanctre des fils de B et C ainsi que de leurs fils.
Arbre valu : cest un arbre dont les arcs portent des tiquettes permettant
de dfinir ce quon appelle un cot pour se rendre dun nud lautre. Il
est possible de calculer le cot relativement un chemin.
Arbre binaire : les arbres binaires sont le type darbre le plus utilis car il
est plus simple grer et implmenter, il dispose au maximum de 2 fils.
Le premier est appel fils gauche, le deuxime fils droit. Par contre, un
arbre multiple est un arbre dont chaque nud peut disposer de plus de 2
fils. Il sagit donc dune structure plus complexe que celle des arbres
binaires. Pour faciliter leur gestion, il existe plusieurs mthodes pour
transformer un arbre en son quivalent binaire. Parmi ces mthodes, on
peut citer la suivante :
Le 1er fils dun nud est marqu comme fils gauche de larbre binaire
correspondant.
Les autres fils sont rangs successivement comme fils droit du 1 er fils
c'est--dire pour chaque nud de larbre binaire obtenu, son 1er fils se
trouve gauche et son 1er frre se trouve droite.
Parcours darbres binaires

On appelle parcours dun arbre tout algorithme permettant daccder une et une
seule fois tous les nuds de larbre. On distingue six parcours gnraux,
symtriques deux deux, valides pour les arbres binaires quelconques et rpartis
en trois catgories qui sont :
Les parcours en prordre (prfixs)
Parcourir un arbre binaire en prordre cest dabord inspecter la racine, puis
parcourir en prordre le sous-arbre gauche (respectivement le sous-arbre droit) et
enfin parcourir en prordre le sous- arbre droit (respectivement le sous-arbre
gauche).
Exemple :
8
5
10
1 4
1
2
7
Parcours en prordre racine, sous-arbre gauche, sous-arbre droit 2, 5, 1, 7, 4, 8,

10, 12.
Parcours en prordre racine, sous-arbre droit, sous-arbre gauche 2, 8, 10, 12, 5, 4,
1, 7.
Les parcours en postordre (postfixs)
Parcourir un arbre binaire en postordre cest dabord parcourir en postordre le
sous-arbre gauche (respectivement le sous-arbre droit), puis parcourir en
postordre le sous-arbre droit (respectivement le sous-arbre gauche) et enfin
inspecter la racine.
Exemple : mme exemple que prcdemment.
Parcours en postordre sous-arbre gauche, sous-arbre droit 7, 1, 4, 5, 12, 10, 8, 2.
Parcours en postordre sous-arbre droit, sous-arbre gauche 12, 10, 8, 7, 1, 4, 5, 2.
Les parcours en ordre (infixs)

Parcourir un arbre binaire en ordre cest dabord parcourir en ordre le sous-arbre

gauche (respectivement le sous-arbre droit), puis inspecter la racine et enfin
parcourir en ordre le sous-arbre droit (respectivement le sous-arbre gauche).
Exemple : mme exemple que prcdemment.
Parcours en ordre sous-arbre gauche, racine, sous-arbre droit 1, 7, 5, 4, 2, 8, 12,
10.
Parcours en ordre sous-arbre droit, racine, sous-arbre gauche 10, 12, 8, 2, 4, 5, 7,
1.
Arbres ordonns
Arbre binaire ordonn horizontalement

Un arbre binaire est ordonn horizontalement (de gauche droite) si la cl de
tout nud non feuille est suprieure toutes celles de son sous-arbre gauche et
est infrieure toutes celles de son sous-arbre droit.
Exemple :
8
4
1
9 0
5
1
3
Recherche dun lment dans un arbre ordonn horizontalement

La recherche dun lment dans un arbre ordonn horizontalement qui tient
compte de lordre est dichotomique et donc trs suprieure une recherche
systmatique laide dun parcours gnral.
Insertion dun lment
Le principe de linsertion dun lment dans un arbre binaire ordonn
horizontalement est le suivant : on recherche de faon rcursive la place de
llment, ce qui conduit ncessairement une feuille si llment ne figure pas
dj dans larbre, puis on accroche llment cette feuille.
Exemple : insertion de llment 6 dans larbre suivant

8 8
4 4 1
1 0
9 0
5 5 9
1
1 3
Insertion 6
3
Suppression dun lment

Le principe de la suppression dun lment dun arbre binaire ordonn
horizontalement est le suivant :
- si llment est une feuille alors on le supprime simplement.
- si llment na quun descendant alors on le remplace par ce
descendant.
- si llment a deux descendants, on le remplace au choix, soit par
llment le plus droite du sous-arbre gauche, soit par llment le
plus gauche du sous-arbre droit, afin de conserver la proprit
dordre horizontal.
Exemple : Suppression de llment 7
1 1
6 6
7 1 6 1
8 8
4 9 4 9
2 2
4 4
2 6 8 1 2 8 1
0 0
Suppression
Reprsentation dun arbre en Pascal

Une manire possible de reprsenter un arbre est la suivante : lensemble des fils
du mme pre forme une liste, donc chaque fils a un pointeur vers son frre qui
le suit. Le dernier frre a 0. Chaque pre a un pointeur vers son premier fils.
Les fils de la dernire gnration (feuilles) ont 0. Chaque fils un pointeur vers
son pre. Lanctre (racine) a 0.
Cela va tre contenu dans un array of record :
type gene = Record
nom : string;
pere : integer ;
frere : integer ;
fils : integer;
end ;
arbre = array [1..max] of gene ;
var mafamille : arbre;
Exemple : (entre parenthse figure lindice dans le tableau)
Pierre (1)
Paul (2) Jacques (3)
Marcel (4) George (5) Jean (6)
Grard (7) Alain (8) Louis (9)
1 2 3
Pierre 0 0 2 Paul 1 3 4 Jacques 1 0 6
II. En langage C
Les pointeurs
Un pointeur est une variable qui doit tre dfinie en prcisant le type de la
variable pointe, de la faon suivante :
Syntaxe : type * Nom_du_pointeur
Le type de la variable pointe peut-tre aussi bien un type primaire (tel que int,
char, etc.) qu'un type complexe (tel que struct, etc .).

Aprs avoir dclar, un pointeur il faut l'initialiser en utilisant l'oprateur

d'affectation '=' suivi de l'oprateur d'adresse '&' auquel est accoll un nom de
variable (celle-ci doit bien sr avoir t dfinie auparavant).
Syntaxe : Nom_du_pointeur = &nom_de_la_variable_pointee;
Aprs (et seulement aprs) avoir dclar et initialis un pointeur, il est possible
d'accder au contenu de l'adresse mmoire pointe par le pointeur grce
l'oprateur '*'.
Fonctions dallocation dynamique de mmoire
Le prototype de ces fonctions figure la fois dans stdlib.h et dans alloc.h.
alloue un emplacement de taille octets,
sans linitialiser et fournit ladresse
void * malloc(size_t taille) correspondante lorsque lallocation a
russi ou un pointeur nul dans le cas
contraire.
alloue lemplacement ncessaire
void * calloc(size_t nb_blocs,size_t
nb_blocs conscutifs, ayant chacun
taille)
une taille de taille octets.
permet de modifier la taille dune zone
void * realloc(void * pointeur, size_t
pralablement alloue (par malloc,
taille)
calloc ou realloc).
libre la mmoire dadresse adr. Ce
pointeur doit obligatoirement dsigner
void free(void* adr) une zone pralablement alloue par
malloc, calloc, realloc. Si adr est nul,
cette fonction ne fait rien.
Les tableaux dynamiques
Syntaxe : Type *T ;
T = (type*) malloc (sizeof(type)*N) ; Avec N tant le nombre
dlments
du tableau.
Les listes chanes

Une liste chane est une structure comportant des champs contenant des donnes
et un pointeur vers une structure de mme type. Ainsi, la structure correspondant
une liste chane contenant une chane de 15 caractres et un entier ressemble
ceci:
struct Nom_de_la_liste {
char Chaine[16];
int Entier;
struct Nom_de_la_liste * pSuivant;
};
Les arbres
La reprsentation dynamique non contigu consiste crer des nuds

sparment les uns des autres et les relier par le chanage adquat pour
prciser quun nud donn est fils gauche ou fils droit dun autre nud.
Ainsi, chaque nud est constitu de 3 parties : linformation, un pointeur sur
le nud gauche et un pointeur sur le nud droit.
info
g d
info
info
g d
g d
info
g d
Exemple :
Pour le cas dun arbre de caractres, la structure est la suivante :
Typedef struct str{
char info ;
str *g, *d ;
} *Arbre p;

Exercice 77
Ecrire une procdure qui permet la cration en file dune liste chane.
Exercice 78
Ecrire une procdure qui permet la cration en pile dune liste chane.
Exercice 79
Ecrire une procdure qui recherche un lment dans une liste chane.
Exercice 80
Ecrire une procdure qui insert un lment dans une liste chane.
Exercice 81
Ecrire une procdure qui limine un lment dune liste chane.
Exercice 82
Ecrire une procdure qui empile un lment dans une pile reprsente par une
liste chane.
Exercice 83
Ecrire une procdure qui dsempile un lment dans une pile reprsente par une
liste chane.
Exercice 84
Ecrire une procdure qui permet la cration dune liste doublement chane.
Exercice 85
Ecrire une procdure qui recherche un lment dans une liste doublement
chane.
Exercice 86
Ecrire une procdure qui insert un lment dans une liste doublement chane.
Exercice 87
Ecrire une procdure qui limine un lment dune liste doublement chane.
Exercice 89
Ecrire une fonction qui recherche un lment dans une liste chane circulaire.
Exercice 90

Ecrire une procdure qui insert un lment dans une liste chane circulaire.
Exercice 91
Ecrire une procdure qui limine un lment dune liste chane circulaire.
Exercice 92
Un paragraphe est une suite de phrases. Une phrase est une suite de mots qui se
termine par un point (.). Deux mots sont spars par un blanc ( ).
Dans cet exercice on reprsentera un paragraphe par une liste chane, et aussi
une phrase par une liste chane.
1- Ecrire une procdure qui permet la cration dune telle reprsentation.
2- Ecrire une procdure qui permet la recherche de la premire occurrence
dun mot dans le paragraphe. Le rsultat de la recherche donne la position
de ce mot.
3- Ecrire une procdure qui permet linsertion dun mot M1 aprs un mot
M2 donn. Si le mot M2 ne se trouve pas dans le paragraphe, on ne fait
pas dinsertion.
4- Ecrire une procdure qui permet llimination dun mot M1 du
paragraphe.
5- Ecrire une fonction qui permet la recherche dune phrase, donne par son
premier mot, dans le paragraphe. Le rsultat de la recherche donne la
position de cette phrase dans le paragraphe.
6- Ecrire une procdure qui permet linsertion dune phrase ph1 aprs une
phrase ph2 donne. Si la phrase ph2 ne se trouve pas dans le paragraphe,
on insert ph1 la fin du paragraphe.
7- Ecrire une procdure qui permet llimination dune phrase ph1 du
paragraphe.
Exercice 93
Ecrire la procdure du parcours dun arbre binaire en prordre.
Exercice 94
Ecrire la procdure du parcours dun arbre binaire en postordre.
Exercice 95
Ecrire la procdure du parcours dun arbre binaire en ordre.
Exercice 96
Ecrire une fonction qui recherche un lment dans un arbre ordonn
horizontalement.

Exercice 97
Ecrire une procdure qui insert un lment dans un arbre ordonn
horizontalement.
Exercice 98
Ecrire une procdure qui supprime un lment dans un arbre ordonn
horizontalement.

Les fichiers
LES FICHIERS
Dans tous les langages de programmation, on utilise la notion de fichier. Il s'agit

d'enregistrer des donnes sur un support plus durable (disquette, disque dur, etc.).
Les principales manipulations sur un fichier sont :
- L'ouverture du fichier
- La lecture ou lcriture d'un lment du fichier
- Le dplacement sur le fichier.
- La fermeture du fichier.
Des erreurs de manipulation d'un fichier peuvent survenir. En particulier, on a
comme erreurs classiques :
- La tentative d'ouvrir en lecture un fichier qui n'existe pas.
- La tentative de lire au del de la fin d'un fichier.
- La tentative d'crire sur une disquette dj pleine ou sur un fichier protg
en criture.
Dans la majorit des langages de programmation, on distingue deux types de
fichiers: les fichiers textes et les fichiers binaires.
Fichier texte
La tte de lecture et d'criture se trouve sur un octet et cet octet est interprt
comme un caractre en code ASCII. On a alors ce qu'on appelle un fichier texte.
Un texte est en gnral divis en lignes, marques par des caractres de fin de
ligne et termin par un code de fin de fichier. Un fichier texte peut se lire
caractre par caractre ou ligne par ligne.
Fichier binaire
La tte de lecture et d'criture recouvre une variable, d'un type quelconque (rel,
double, structure, tableau, etc.) code sur n octets comme en mmoire centrale.
On parle alors de fichier binaire. Une opration de lecture lit en bloc tous les
octets constituant cette variable.
I. En langage Pascal
En Pascal, un type fichier est dfini par le mot rserv "File Of" suivi du type des
composantes de ce fichier.

Les fichiers
Exemple :
Type Fic_mess = File Of string[80] ;
Fic_pers = File Of Record
Nom, prn:string[14];
Doti:string[6];
End;
I.1 Oprations sur les fichiers

Soit filvar un identificateur de variable de type fichier.
Expression Commentaires
str est une expression chane rsultant en tout nom lgal de
fichier. Le nom du fichier est affect la variable filval et
Assign(filval,str) toutes les oprations suivantes sur filval affecteront le fichier
disque (externe) str. Assign ne doit jamais tre utilise sur un
fichier en cours dutilisation.
un nouveau fichier disque dont le nom est assign la variable
filval est cre et prpar pour le traitement. Le pointeur de
Rewrite(filval) fichier est plac au dbut de celui-ci (cest--dire : sur
lenregistrement numro 0). Un fichier disque cre par
Rewrite est vide.
le fichier disque affect la variable filval est prpar pour le
traitement. Le pointeur de ce fichier est positionn sur le
Reset(filval)
composant numro 0. filval doit rfrencer un fichier existant,
sinon il se produira une erreur dentre/sortie.
var reprsente une ou plusieurs variables de mme type que
les lments de filval. Chaque variable est lue sur le fichier
Read(filval,var)
disque. Aprs chaque opration de lecture le pointeur de
fichier est avanc sur le composant suivant.
var reprsente une ou plusieurs variables de mme type que
les lments de filval. Chaque variable est crite sur le fichier
Write(filval,var)
disque. Aprs chaque opration dcriture le pointeur de
fichier est avanc sur le composant suivant.
dplace le pointeur de fichier sur le n ime composant du fichier
Seek(filval,n)
rfrenc par filval. N est une expression entire.
Filesize(filval) retourne le nombre de composants dun fichier.
Close(filval) le fichier disque associ filval est ferm et le rpertoire du
disque est mis jour. Pour tenir compte des modifications
apportes au fichier, il est ncessaire de fermer un fichier

Les fichiers
Expression Commentaires
aprs traitement.
fonction boolenne qui retourne vraie si le pointeur de fichier
Eof(filval)
est positionn la fin du fichier disque.
fonction entire retournant la position courante du pointeur de
Filepos(filval)
fichier.
Remarque : un paramtre formel de type fichier doit tre toujours donn par
adresse.
I.2 Les fichiers textes

Dclaration
La dclaration dun fichier texte se fait par le mot rserv Text.

Exemple : var fich_text : Text ;
Oprations sur les fichiers textes
Toute opration sur les fichiers textes doit tre prcde par un appel la
procdure Assign, Un appel Reset ou Rewrite doit prcder toute opration
de lecture ou decriture.
Rewrite permet de crer un nouveau fichier texte et la seule opration autorise

est lajout de nouveaux lments la fin de ce fichier.
Reset est utilise pour ouvrir un fichier existant en lecture, la seule opration
permise sur ce fichier est la lecture squentielle. Lorsquun nouveau fichier texte
est ferm, une marque de fin de fichier est mise la fin du fichier.
Lentre et la sortie des caractres dans les fichiers textes seffectuent par les procdures
Read(filvar,c) et Write(filval,c). Les procdures Readln, Writeln et la fonction EoLn
permettent le traitement des lignes dun fichier texte.
Expressions Commentaires
Readln(filvar) ou va au dbut de la ligne suivante, cest--dire

Les fichiers
Expressions Commentaires
carte tous les caractres jusque et y compris la

readln(filvar,st1,st2,..,stn)
squence CR/LF (la marque de la fin de ligne).
Writeln(filvar) ou crit une marque de fin de ligne, cest--dire une

writeln(filvar,st1,..,stn) squence CR/LF dans le fichier texte.
fonction boolenne retournant vrai si la fin de

ligne a t atteinte, cest--dire si le pointeur de
EoLn(filvar) fichier est positionn sur le caractre CR de la
squence CR/LF. Si Eof(filvar) est vrai alors
EoLn(filvar) est galement vrai.
similaire EoLn, mais carte les espaces et les

seekEoLn(filvar)
Tabs avant de faire le test.
retourne vrai si le pointeur de fichier est

Eof(filvar)
positionn sur la fin de fichier (Ctrl-Z).
similaire Eof, mais carte les espaces, les Tabs

SeekEof(filvar) et les marques de fin de ligne avant de faire le
test.
ouvre un fichier texte existant en mode ajout.

Append(var filvar :Text) Aprs un appel Append, seule lcriture est
autorise.
vide la mmoire tampon associe un fichier

Flush(var filvar :Text)
texte ouvert en mode criture.
assigne un tampon dentre/sortie un fichier

texte. Toute variable fichier de type texte dispose
SetTextBuf(var dun tampon mmoire, dont la taille est de 128
filvar:Text;var octets par dfaut. Le tampon est utilis lors des
tampon[ ;taille :Word]) oprations de lecture et dcriture. La taille est
suffisante pour la plupart des applications.
SetTextBuf doit tre utilise juste aprs Assign.

Les fichiers
Remarques :
Les procdures et fonctions Seek, FilePos et FileSize ne sappliquent pas aux

fichiers textes.
Ctrl-Z a pour code ASCCI 26, CR 13 et LF 10.
II. En langage C
Pour pouvoir manipuler les fichiers en C, on doit dclarer un pointeur sur la
structure FILE.
Exemple : FILE *sortie ;
II.1 Ouverture et cration d'un fichier

La fonction fopen a pour argument deux chanes de caractres, le nom du fichier
et le mode d'ouverture. Elle donne comme rsultat un pointeur qui est NULL si
l'ouverture a chou, sinon le pointeur renvoy est utilis dans les critures, les
lectures et les dplacements ultrieurs.
Exemple:
#include <stdio.h>
FILE *Pointeur_sur_fichier;
Pointeur_sur_fichier = fopen("C:\IUT\essai.txt", "wt");
Ouvre (ou cre s'il n'existe pas) un fichier texte nomm essai.txt dans le
rpertoire IUT du disque C. Les modes de base sont :
"r" (read : lecture) : lecture seulement ; le fichier doit exister.
"w" (write : criture) : criture seulement. Si le fichier nexiste pas, il est
cr. Sil existe, son ancien contenu est perdu.
"a" (append : ajout) : si le fichier existe dj, il sera tendu. Sil nexiste
pas, il sera cr.
"r+" : mise jour (lecture et criture). Le fichier doit exister.
"t" ou "b" : lorsque limplmentation distingue les fichiers de texte des
autres, il est possible dajouter lune de ces deux lettres chacun des modes
prcdents. La lettre t prcise que lon a affaire un fichier texte ; la lettre
b prcise que lon a affaire un fichier binaire.
II.2 Ecriture dans un fichier

Les fichiers
fprintf : criture formate dans un fichier. Cette fonction est l'quivalent pour un
fichier de printf pour les sorties l'cran. Les formats (prcds du symbole %)
sont les mmes.
Exemple :
char erreur;
erreur = fprintf(Pointeur_sur_fichier, "Le chiffre %d s'crit quatre", 4);
Dans un fichier texte
fputc : ce qui signifie "met un caractre dans un fichier". Comme son nom
l'indique, cette fonction crit un octet dans un fichier.
Exemple:
char erreur;
erreur = fputc('x', Pointeur_sur_fichier);
fputs : ce qui signifie "met une chane dans un fichier". Comme son nom
l'indique galement, cette fonction crit une chane de caractres dans un
fichier.
Exemple :
char erreur;
erreur = fputs("chane de caractre", Pointeur_sur_fichier);
Remarque :
Dans ces deux cas, la variable erreur de type char contient le dernier caractre
crit et EOF si une erreur se prsente (fin de fichier, disque plein, etc.).
Dans un fichier binaire
fwrite : crit dans un fichier des objets d'un type quelconque. Il faut
prciser la taille d'un objet (par exemple avec sizeof(objet)), le nombre
d'objets crire et le pointeur du fichier destination. Cette fois, la fonction
renvoie le nombre d'lments effectivement crits. Pour tester que tout va
bien, il faut comparer le nombre d'lments crits avec le nombre d'objets
crire.
Syntaxe :
nombre_d_elements_ecrits = fwrite(ptr_sur_tableau, taille_element,
nb_elements, fichier)

Les fichiers
II.3 Lecture dans un fichier

Les oprations de lecture sont les symtriques de celles d'criture. On retrouve la
mme classification et peu prs la mme syntaxe.
fscanf : lecture formate analogue scanf.

Syntaxe : Nb_lu = fscanf(Pointeur_sur_fichier, format, liste de pointeurs);
O : Nb_lu est le nombre d'arguments lus et accepts. Par exemple :
Nb_lu = fscanf(Pointeur_sur_fichier, "%s", Chane);
Met dans Chane les caractres situs entre le dbut et la fin de fichier ou
le prochain espace blanc. Les espaces blancs initiaux sont
automatiquement sauts. Les formats de fscanf sont les mmes que ceux
de scanf.
Dans un fichier texte

fgetc : ce qui signifie "prend un caractre dans un fichier".
Exemple :
int caractere;
caractere = fgetc(Pointeur_sur_fichier);
fgets : ce qui signifie "prend une chane dans un fichier". Lit un certain
nombre de caractres dans un fichier et les met dans une chane en ajoutant
le caractre nul la fin.
Exemple :
fgets(Chaine, 10, Pointeur_sur_fichier);
Lit 10 caractres dans le fichier et les crits dans Chaine. Un dernier
caractre nul est ajout. Mais, si une fin de ligne (EOL) est rencontre
avant le dixime caractre lu, seuls les caractres avant la fin de ligne
seront lus et ils seront suivis dans la chane par EOL et NULL.
Dans un fichier binaire
Syntaxe : Nb_lu = fread(pointeur_sur_tableau, taille_element, nb_elements,

fichier);
Nb_lu est gal nb_elements si l'criture s'est passe sans incident.

Exemple:
#include <stdio.h>

Les fichiers
FILE *Pointeur_sur_fichier;
fopen("C:\IUT\essai.dta", "wb");
int tableau[5];
nb = fread(tableau, sizeof(int), 3, Pointeur_sur_fichier);
Lit dans le fichier binaire "essai.dta" des nombres entiers et les range dans les
trois premires cellules du tableau ; nb a pour valeur le nombre d'lments crits,
3 si tout s'est bien pass.
II.4 Dplacement dans un fichier

int fseek(FILE *flux,long noct,int org): place le pointeur du flux indiqu
un endroit dfini comme tant situ noct octets de lorigine spcifie par
org :
org = SEEK_SET correspond au dbut du fichier.
org = SEEK_CUR correspond la position actuelle du pointeur.
org = SEEK_END correspond la fin du fichier.
long ftell (FILE *flux) : fournit la position courante du pointeur du flux
indiqu (exprime en octets par rapport au dbut du fichier).
II.5 Fermeture du fichier

int fclose(FILE *flux) : dsalloue lespace mmoire associ au flux
concern et ferme le fichier correspondant. Fournit la valeur EOF en cas
derreur et la valeur 0 dans le cas contraire.

Exercice 99
Ecrire un programme qui permet de crer un fichier dtudiants.
Exercice 100
Ecrire une procdure qui permet de modifier les informations dun tudiant.

Solutions des exercices
SOLUTIONS DES EXERCICES
Pascal C
Exercice 1
Ecrire un programme qui permet dafficher le message suivant : mon premier programme.
Program afficher ; #include<stdio.h>
Begin #include<conio.h>
Writeln(mon premier programme) ; void main()
Readln ; {
End . printf("mon premier programme") ;
getch() ;
}
Exercice 2
Ecrire un programme qui demande l'utilisateur les valeurs de 2 entiers x et y, qui permute leurs valeurs et qui
les affiche.
Program Echange; #include<stdio.h>
var x,y,tmp:integer; #include<conio.h>
begin void main()
write('donner deux entiers differents:'); {
readln(x,y); clrscr();
writeln('x=',x,' et y=' ,y); int x,y,tmp;
tmp:=x; printf("entrez deux nombres: ");
x:=y; scanf("%d %d",&x,&y);

y:=tmp; printf("avant echange x=%d et y=%d\n",x,y);

writeln('x=',x,' et y=',y); tmp=x;
readln; x=y;
end. y=tmp;
printf("apres echange x=%d et y=%d",x,y);
getch();
}
Exercice 3
Ecrire un programme qui change 3 entiers.
Program Echange; #include<stdio.h>
var x,y,tmp,z:integer; #include<conio.h>
begin void main()
write('donner trois entiers differents:'); {
readln(x,y,z); int x,y,z,tmp;
writeln('x=',x,' et y=' ,y,et z=,z); printf("entrez trois nombres: ");
tmp:=x; scanf("%d %d %d",&x,&y,&z);
x:=y; printf("avant echange x=%d , y=%d et z=%d
y :=z ; \n",x,y,z);
z:=tmp; tmp=x;
writeln('x=',x,' et y=',y, et z=,z); x=y;
readln; y=z ;
end. z=tmp;
printf("apres echange x=%d , y=%d et z=%d
",x,y,z);
getch();
}

Exercice 4
Ecrire un programme qui demande l'utilisateur les coordonnes de 2 points distincts du plan et qui affiche les
coordonnes du point milieu.
program milieu ; #include<conio.h>

var x1, y1, x2, y2, xm, ym : real ; void main()
begin {
writeln ('Entrez les coordonnes du premier float x1, y1, x2, y2, xm, ym ;
point') ; readln ( x1 ) ; readln ( y1 ); printf ("Entrez les coordonnes du premier point") ;
writeln ('Entrez les coordonnes du deuxime scanf("%f %f ",&x1,&y1) ;
point') ; readln ( x2 ) ; readln ( y2 ); printf ("Entrez les coordonnes du second point") ;
xm := (x1 + x2) / 2 ; ym := (y1 + y2) / 2 ; scanf("%f %f ",&x2,&y2) ;
writeln ('Les coordonnes du point milieu xm =(float) (x1 + x2) / 2 ; ym = (float)(y1 + y2) / 2 ;
sont :', xm :5:2, ym:5:2) ; printf("Les coordonnes du point milieu sont : (%5.2f,
end. %5.2f) ", xm, ym);
getch() ;
}
Exercice 5
Ecrire un programme qui demande l'utilisateur une valeur pour U0, r et n et qui affiche la nime valeur de la
suite arithmtique dfinie par U0 et Un+1 = Un + r. (On rappelle la proprit : Un = U0 + n.r ).
program suite ; #include<conio.h>
var U0, Un, r : real ; n : integer ; void main()
begin {
writeln ('Entrez les valeurs de U0, r et n') ; float U0,Un,r ;
readln ( U0,r, n ); int n ;
Un := U0 + n*r; printf("Entrez les valeurs de U0, r et n") ;

writeln ('La ',n:3,'ime valeur de la suite est :', scanf("%f %f %d",&Uo,&r,&n) ;

Un :5:2) ; Un = U0 + n*r;
end. printf ("La %d ime valeur de la suite est :%5.2f"', Un)
;
getch() ;
}
Exercice 6
Ecrire un programme qui change les contenus de 2 donnes si elles sont de signes contraires.
program signe_contraire; #include<stdio.h>
var tmp,x,y:integer; #include<conio.h>
begin void main()
write('donner deux entiers differents:'); {
if x*y <0 then printf("entrez deux nombres: ");
begin scanf("%d %d",&x,&y);
tmp:=x; printf("avant echange x=%d et y=%d\n",x,y);
x:=y; if(x*y<0){
y:=tmp; tmp=x;
writeln('les deux entiers sont de signes x=y;
contraires donc apres echange'); y=tmp;
writeln('x=',x,' et y=',y); printf("les 2 nombres sont de signes contraires
end donc apres echange x=%d et y=%d",x,y);
else }
writeln('les deux entiers sont de meme signes else
donc pas d''echange'); printf("les 2 nombres sont de meme signes donc

readln; pas de changement");

end. getch();
}
Exercice 7
Ecrire un programme qui change les contenus de 2 donnes si elle sont de signes contraires, sinon, il met leur
produit dans le premier et la somme dans le deuxime
program somme_produit; #include<stdio.h>
var tmp,x,y:integer; #include<conio.h>
begin void main()
write('donner deux entiers:'); {
if x*y<0 then printf("entrez deux nombres: ");
begin scanf("%d %d",&x,&y);
tmp:=x; printf("avant echange x=%d et y=%d\n",x,y);
x:=y; if(x*y<0){
y:=tmp; tmp=x;
end x=y;
else y=tmp;
begin printf("les 2 nombres sont de signes contraires
tmp:=x; donc apres echange x=%d et y=%d",x,y);
x:=y*x; }
y:=y+tmp; else{
end; tmp=x;
writeln('apres operation'); x=x*y;
writeln('x=',x,' et y=',y); y=y+tmp;

readln; printf("les 2 nombres sont de meme signes donc

end. leur produit est x=%d \net leur somme est y=%d",x,y);
}
getch();
}
Exercice 8
Ecrire un programme qui tant donne un mois et son premier jour, affiche le premier jour du mois suivant
program premier_jour; #include<stdio.h>
var nbj,annee,mois,premj:integer; #include<conio.h>
begin void main()
write('entrer une annee de votre choix:'); {
readln(annee); clrscr();
write('entrer un mois et son premier jour:'); int biss,nbj,premj,M,A;
readln(mois,premj); printf("donnez une annee de votre
case mois of choix:");scanf("%d",&A);
1,3,5,7,8,10,12: nbj:=31; printf("donnez un mois et son premier
4,6,9,11: nbj:=30; jours:");scanf("%d %d",&M,&premj);
2: begin if (A % 100==0) A=A/100;
if annee mod 100 = 0 then annee:=annee div if (A % 4==0) biss=0;
100; else biss=1;
if annee mod 4 = 0 then nbj:=29 switch (M){
else nbj :=28; case 1 :
end; case 3 :
end; case 5 :
premj:=(premj+nbj) mod 7; case 7 :
writeln('le premier jour du mois suivant case 8 :

est:',premj); case 10:

case 12: nbj=31;
readln; break;
end. case 4 :
case 6 :
case 9 :
case 11: nbj=30;
break;
case 2 :
if (bissextile(A)) nbj=28;
else nbj=29;
break;
}
premj=(premj+nbj)%7;
printf("\nle premier jour du mois suivant est:
%d",premj) ;
getch();
}
Exercice 9
Ecrire un programme qui calcule la somme des N premiers termes positifs
program somme; #include<stdio.h>
var N,i,s:integer; #include<conio.h>
begin void main()
write('entrer un nombre positif:'); {
readln(N); clrscr();

s:=0; int N,i,S;

if N>0 then printf("donnez un entier positif:
for i:=1 to N do ");scanf("%d",&N);
s:=s+i; S=0;
writeln('la somme de N premiers termes if(N>0) {
positifs:',N);; for(i=1 ;i<=N;i++)
readln S=S+i;
end. }
printf("la somme des %d premiers termes
positifs est:%d ",N,S);
getch();
}
Exercice 10
Ecrire un programme qui calcule la somme des N premiers termes positifs impaires
program som_impaire; include<stdio.h>
var N,i,s:integer; #include<conio.h>
begin void main()
write('entrer un entier positif:'); {
i:=1;s:=0; int N,i,S;
while(i<2*N) do printf("donnez un entier positif:
begin ");scanf("%d",&N);
s:=s+i; S=0;
i:=i+2; i=1;
end; while(i<=2*N-1){

writeln('somme de ',N,' premiers termes positifs S=S+i;

impaires est: ',s); i=i+2;
readln; }
end. printf("la somme des %d premiers termes
positifs impaires est:%d ",N,S);
getch();}
Exercice 11
Ecrire un programme qui calcule la somme des N premiers termes positifs pairs nom multiple de 3
program som_paires; #include<stdio.h>
var N,i,s,cp:integer; #include<conio.h>
begin void main()
write('entrer un entier positif:'); {
i:=0;s:=0;cp:=0; int N,i,S,cp;
while(cp<N) do printf("donnez un entier positif:
begin ");scanf("%d",&N);
i:=i+2; S=0;
if (i mod 3 <> 0) then i=0;
begin cp=0;
s:=s+i; while(cp<N){
cp:=cp+1; i=i+2;
end; if(i%3!=0){
end; S=S+i;
writeln('somme de ',N,' premiers termes positifs cp=cp+1;
non multiples de 3 est: ',s); }
readln; }

end. printf("la somme des %d premiers termes

positifs impaires non multiple de 3 est:%d ",N,S);
getch();
}
Exercice 12
Ecrire un programme qui calcule la somme 1/2 + 1/4 + 1/8 ++1/2n (n N*)
program calcul; #include<stdio.h>
var n,i:integer; #include<conio.h>
s,u:real; #include<math.h>
begin #include<stdlib.h>
s:=0; void main()
u:=1/2; {
i:=1; clrscr();
write('donner un entier non nul: ');readln(n); float s,u;
while i<=n do int i,n;
begin s=0;
s:=s+u; u=(float)1/2;
u:=u/2; i=1;
i:=i+1; printf("donnez un entier positif non
end; nul:");scanf("%d",&n);
writeln('la somme est: ',s:10:5); while(i<=n){
readln; s=s+u;
end. u=u/2;
i=i+1;
}
printf("la somme est: %f",s);

getch();
}
Exercice 13
Ecrire un programme qui calcule la somme 1+1/2-1/4+ 1/8-1/16+1/2n (n N*)
var n,i:integer; #include<conio.h>
s,u:real; void main()
begin {
write('donner un entier non nul: ');readln(n); clrscr();
i:=1; float s,u;
S:=1; int i,n;
u:=1/2; s=1;
while i<=n do u=(float)1/2;
begin i=1;
if i mod 2=0 then printf("donnez un entier positif non
s:=s-u nul:");scanf("%d",&n);
else s:=s+u; while(i<=n){
u:=u/2; if(i%2==0) s=s-u;
i:=i+1; else s=s+u;
u=u/2;
end; i=i+1;
writeln('la somme est: ',s:10:5); }
readln; printf("la somme est: %f",s);
end. getch();
}
Exercice 14

Ecrire un programme qui donne le nombre N tel que la srie 1+1/2-1/3+1/4- 1/5+1/N donne un rsultat gal
( 1/100 prs) 1,33
var S:real; #include<conio.h>
i:longint; #include<math.h>
begin void main()
S:=1; {
i:=1; clrscr();
while abs(S - 1.33) > 0.001 do float s,n;
begin long int i;
if (i mod 2=0) then S:=S-(1/(i+1)) s=1;
else S:=S+(1/(i+1)); i=1;
i:=i+1; while( fabs(s-1.33)>0.001)
end; {
write('le nombre tel que la serie donne un resultat = n=(float)1/(i+1);
1,33 est:',s:10:5) ; if (i%2==0) s=s-n;
readln; else s=s+n;
end. i=i+1;
}
printf("la valeur approche de 1,33 est : %f",s);
getch();
}
Exercice 15
Ecrire un programme qui donne la plus grande valeur infrieure 1000 de la somme 1+2+4+8++2N
var u,s:integer; #include<conio.h>

begin void main()

u:=2; {
s:=1; clrscr();
while s<1000 do int s,u;
begin s=1;
s:=s+u; u=2;
u:=u*2; while(s<1000){
end; s=s+u;
s:=s-(u div 2); u=2*u;
writeln('la plus grande valeur inferieur a 1000 de la }
somme est: ',s); s=s-u/2;
readln; printf("la plus grande valeur inferieur a 1000 est:
end. %d",s);
getch();
}
Exercice 16
Ecrire un programme qui calcule la somme 1+x+x2++xn (x rel et n entier).
var x,s,u:real; #include<conio.h>
n,i:integer; #include<math.h>
begin void main()
write('donner un reel et un entier:'); {
readln(x,n); clrscr();
i:=1; float s,x,u;
s:=1; int n,i;
u:=x; printf("donnez un reel et un entier :");

while i<=n do scanf("%f %d",&x,&n);

begin s=1;
s:=s+u; u=x;
u:=u*x; for(i=1;i<=n;i++){
i:=i+1; s=s+u;
end; u=u*x;
writeln('la somme est: ',s:10:5); }
readln; printf("la Somme est:%f",s);
end. getch();
}
Exercice 17
Calcul approch de x
Soient les deux suites: An+1= (An+Gn)/2 et Gn+1=2AnGn/(An+Gn) avec A0=x et G0=1, on montre que lim An=lim
Gn= x
n n
Ecrire un programme qui donne la valeur de x avec une prcision relative =10-6, cest dire |An-Gn|/|Gn|<
program racine_carre; #include<stdio.h>

var x,A,G,B:real; #include<conio.h>
begin #include<math.h>
write('donner un nombre non nul: '); void main()
readln(x); {
A:=x; clrscr();
G:=1; float x,A,B,G;
while abs((A-G)/G)>0.000001 do printf("donner un nombre non nul:");
begin scanf("%f",&x);

B:=A; A=x;
A:=(A+G)/2; G=1;
G:=2*B*G/(B+G); while(fabs((A-G)/G)>0.000001)
end; {
writeln('la racine de ',x:10:5,' est: ',A:10:5); B=A;
readln; A=(A+G)/2;
end. G=2*B*G/(B+G);
}
printf("la racine de %f est : %f",x,A);
getch();
}
Exercice 18
Sachant que la somme 1-1/3+1/5-1/7+1/9... tend vers /4. crire un programme donnant le nombre 10-6 prs
program pi; #include<stdio.h>
var s,t:real; #include<conio.h>
i:integer; void main()
begin {
s:=4; clrscr();
i:=1; float s,t;
t:=1/3; int i;
while t>0.000001 do s=4;
begin t=(float)1/3;
t:=4/(2*i+1); i=1;
if i mod 2=0 then while(t>0.000001){
s:=s+t t=(float)4/(2*i+1);
else s:=s-t; if (i%2==0) s=s+t;

i:=i+1; else s=s-t;

end; i=i+1;
writeln('pi =',s:10:5); }
readln; printf("la valeur de pi est:%f",s);
end. getch();
}
Exercice 19
Le dveloppement limit de la fonction sinus au voisinage de zro est : sin x= x - x3/3! + x5/5! -+(-1)p x2p+1/
(2p+1)!+
Ecrire un programme qui calcule sin x 10-6 prs.
program sinx; #include<stdio.h>
var s,x,u,t:real; #include<conio.h>
v,i:integer; void main()
begin {
write('donner un nombre:');readln(x); clrscr();
s:=0; float s,u,x,v,t;
u:=x; int i,n;
v:=1; printf("donner un nombre:");scanf("%f",&x);
i:=1; s=0;
t:=u/v; u=x;
while t>0.000001 do v=1;
begin i=1;
if i mod 2=0 then s:=s-(u/v) t=(float)u/v;
else s:=s+(u/v); while (t>0.000001 ){
u:=u*x*x; if (i%2==0) s=s+u/v;
v:=(2*i+1)*2*i*v; else s=s-u/v;

i:=i+1; u=u*x*x;
t:=u/v; v=(2*i+1)*2*i*v;
end; i++;
writeln('le sinus de ',x:10:5,'est: ',s:10:5); t=(float)u/v;
readln; }
end. printf("sinus de %f=%f",x,s);
getch();
}
Exercice 20
Ecrire un programme qui calcule la somme, le produit et la diffrence de deux donnes numriques.
program operation; #include <stdio.h>
var x,y:integer; #include<conio.h>
op:char; void main()
begin {
writeln('donner deux nombres x et y'); int x,y;
readln(x,y); char op;
writeln('donner un oprateur'); printf("donner le premier operande\n");
readln(op); scanf("%d",&x);
case(op) of printf("donner le deusieme operande\n");
'/': begin scanf("%d",&y);
if y<>0 then writeln('la division de x par y est gale printf("donner l'operateur\n");
:',x/y) op=getch();
else writeln(' division par zro'); switch(op)
end; {
'*':writeln('x*y=',x*y); case '+': printf("x+y=%d\n",x+y); break;

'+':writeln('x+y=',x+y); case '-': printf("x-y=%d\n",x-y); break;

'-':writeln('x-y=',x-y); case '*': printf("x*y=%d\n",x*y); break;
end; case '/': if( y!=0) printf("x/y=%f\n",x/y);
readln; else printf(" division par zero\n"); break;
end. }
getch();
}
Exercice 21
crire un programme qui retourne le code dune donne de type CARACTERE.
program code_ASCII; #include <stdio.h>
var c:char; #include<conio.h>
asci:integer; void main()
begin {
writeln('donner un caractre:'); int asci;
readln(c); char c;
asci:=ord(c); printf("donner un caractere\n");
writeln('le code ASCII de ce caractre est:',asci); scanf("%c",&c);
readln; asci='A';
end. printf("%d\n",asci);
getch();
}
Exercice 22
Ecrire un programme qui calcule le salaire net dun employ, sachant que celui-ci a assur un certain nombres
dheures de travail un prix fixe par heure, et que lemployeur doit rduire de son salaire des charges qui sont

calcules avec un coefficient donn.

program salaire_net_employe; #include <stdio.h>
var charges,sb,sn,coef,ph:real; #include<conio.h>
nh:integer; void main()
begin {
writeln('donner le nombre d''heures de travail de cet int NH;
employ:'); float NB,SN,SB,coef,PH,charges;
readln(nh);
writeln('donner le prix d''une heure:'); printf("donner le nombre d'heures de travail:\n");
readln(ph); scanf("%d",&NH);
writeln('donner le coefficient:'); printf("donner le prix de chaque heure:\n");
readln(coef); scanf("%f",&PH);
sb:=nh*ph; printf("donner le coefficient de reduction:\n");
charges:=sb*coef; scanf("%f",&coef);
sn:=sb-charges; SB=NH*PH;
writeln('le salaire net de cet employ est:',sn); charges=SB*coef;
readln; SN=SB-charges;
end. printf("la salaire net de cet employe est egal a %f",SN);
getch();
}
Exercice 23
Ecrire un programme qui permet de reprendre lexercice prcdant en considrant que lemploy a assur des
heures normales, des heures 25% et des heures 50%.
program salaire_net_supplements; include<stdio.h>
var charges,sb,sn,coef,ph:real; #include<conio.h>
nh25,nh50,nhn:integer; void main()

begin {
writeln('donner le nombre d''heures 25% et celui int NHN,NH25,NH50;
50% ainsi que le nombre d''heure normales :'); float NB,SN,SB,coef,PH,charges;
readln(nh25,nh50,nhn);
writeln('donner le prix d''une heure:'); printf("donner le nombre d'heures normales:\n");
readln(ph); scanf("%d",&NHN);
writeln('donner le coefficient:'); printf("donner le nombre d'heures a 25%:\n");
readln(coef); scanf("%d",&NH25);
sb:=nhn*ph+nh25*ph*125/100+nh50*150/100*ph; printf("donner le nombre d'heures a 50%:\n");
charges:=sb*coef; scanf("%d",&NH50);
sn:=sb-charges; printf("donner le prix d'une heure:\n");
writeln('le salaire net de cet employ est:',sn); scanf("%f",&PH);
readln; printf("donner le coefficient de reduction:\n");
end. scanf("%f",&coef);
SB=(NHN+NH25*(125/100)+NH50+(150/100))*PH;
charges=SB*coef;
SN=SB-charges;
printf("la salaire net de cet employe est egal a %f",SN);
getch();
}
Exercice 24
Ecrire un programme qui retourne si une donne numrique est paire ou impaire (utiliser le reste de la division
par 2).
program est_pair; #include<stdio.h>
var n:integer; #include<conio.h>
bp:boolean; void main()

begin {
writeln('donner un entier positif:'); int n;
readln(n); printf("donner un entier positif :\n");
bp:=(n mod 2)=0; scanf("%d",&n);
if bp then writeln('cet entier est pair') if( n % 2 == 0)
else writeln('cet entier n''est pas pair'); printf("cet entier est pair.\n");
readln; else
end. printf("cet entier n'est pas pair.\n");
getch();
}
Exercice 25
Ecrire un programme qui permet de lire trois donnes numriques et retourne si la troisime donne est la
somme des deux autres ou pas.
program est_somme; #include<stdio.h>
var x,y,z:integer; #include<conio.h>
bs:boolean; void main()
begin {int x,y,z;
writeln('donner trois nombres:'); printf("donner trois nombres:\n");
readln(x,y,z); scanf("%d%d%d",&x,&y,&z);
bs:=(x+y)=z; if(z==x+y)
if bs then writeln('la trosime donne est gale la printf("la trosieme donne est egale a la somme des
somme des autres ') autres.\n");
else else printf("la trosieme donne n'est pas egalea la
writeln('la trosime donne n'' est pas gale la somme des autres.\n");
somme des autres '); getch();
readln; }

end.
Exercice 26
Ecrire un programme qui, partir du salaire brut dun employ, dtermine limpt payer sachant que les
rgles de calcul des impts sont comme suit :
salaire brut(SB) limpt payer

SB<1500 0%
1500<=SB<3000 10% du SB
3000<=SB<5000 450+30%(SB-3000)
SB>=5000 750+40%(SB-5000)
program impots; #include<stdio.h>
var sb,impot:real; #include<conio.h>
begin void main()
writeln('donner le salaire brut de cet employ:'); {float sb;
readln(sb); printf("donner le salaire brut de cet employe:\n");
if sb<1500 then writeln('l''impot payer est de 0%') scanf("%f",&sb);
else if (sb<1500)
begin printf("l'impot a payer est de 0%.\n");
if sb<3000 then writeln('l''impot payer est else
de:',sb*0,1) { if (sb<3000) printf("l'impot a payer est de:
else %f\n",sb*0.1);
begin else
if sb<5000 then writeln('l''impot payer est {
de:',450+30/100*(sb-3000)) if (sb<5000) printf("l'impot a payer est de:
else %f\n",450+0.3*(sb-3000));
writeln('l''impot payer est de:',750+40/100*(sb- else printf("l'impot a payer est de:
5000)); %f\n",750+0.4*(sb-5000));

end; }
end; }
readln getch();
end. }
Exercice 27
Ecrire un programme qui fournit les racines de lquation Ax2+Bx+C=0.
program eqation ; #include<stdio.h>
var a,b,c:integer; #include<conio.h>
delta:real; #include<math.h>
begin void main()
writeln('donner a, b et c'); { int a,b,c;
readln(a,b,c); float delta;
if a=0 then printf("donner a, b et c:\n");
begin scanf("%d%d%d",&a,&b,&c);
if b=0 then begin if (a==0)
if c=0 then writeln('S=R') { if(b=0)
else writeln('S=VIDE'); { if (c=0) printf("S=R");
end else printf("S=VIDE");
else writeln('la solution est:',-c/b); }
end else printf("la solution est:%f",-c/b);
else begin }
delta:=b*b-4*a*c; else
if delta>=0 then writeln('les racines de cette {
quation sont: x1=',(-b-sqrt(delta))/(2*a),'x2=', (- delta=b*b-4*a*c;
b+sqrt(delta))/(2*a)) if (delta>=0)
else writeln('pas de solution'); printf("les racines de cette quation sont: x1=%f et x2=

end; %f",(-b-sqrt(delta))/(2*a),(-b+sqrt(delta))/(2*a));
readln; else printf("pas de solution");
end. getch();
}
}
Exercice 28
Ecrire un programme qui, tant donne une date (jour, mois, anne), affiche la date du jour suivant.
program jour_suivant; #include<stdio.h>
var j,m,a,ms,js,as:integer; #include<conio.h>
biss,dj:boolean; void main()
begin {
writeln('donner la date d''aujourd''hui:'); clrscr();
readln(j,m,a); int j,m,a,js,ms,as,dj,biss;
if( a mod 100)=0 then biss:=(a mod 400)=0 printf("donnez la date d'aujourd'hui: ");scanf("%d %d
else biss:=(a mod 4)=0; %d",&j,&m,&a);
case m of if (a % 100==0) a=a/100;
1,3,7,8,10,12:dj:=(j=31); if (a % 4==0) biss=0;
4,6,9,11:dj:=(j=30); else biss=1;
2:if biss then dj:=(j=29) switch (m){
else dj:=(j=28); case 1 :
end; case 3 :
if dj then begin case 5 :
js:=1; case 7 :
if m=12 then begin case 8 :
ms:=1; case 10:
as:=a+1; case 12: dj=(j==31);

end break;
else begin case 4 :
ms:=m+1; case 6 :
as:=a; case 9 :
end; case 11: dj=(j==30);
end break;
else begin case 2 :
js:=j+1; if(biss) dj=(j==28);
ms:=m; else dj=(j==29);
as:=a; break;
end; }
writeln('le jour suivant est :',js,'/',ms,'/',as); if (dj) {
readln; js=1;
end. if(m==12){
ms=1;
as=a+1;
}
else{
ms=m+1;
as=a;
}
}
else{
js=j+1;
ms=m;
as=a;

}
printf("\nle jour suivant est:%d/%d/
%d",js,ms,as) ;
getch();
}
Exercice 29
Ecrire un programme qui, tant donne une date (jour, mois, anne), affiche la date du jour prcdant.
program jour_precedant; #include<stdio.h>
var nj,j,m,a,mp,jp,ap:integer; #include<conio.h>
biss:boolean; void main()
begin { int nj,j,m,a,mp,jp,biss,a,p;
writeln('donner la date d''aujourd''hui:'); printf("donner la date d'aujourd'hui:\n");
readln(j,m,a); scanf("%d%d%d",j,m,a);
if( a mod 100)=0 then biss:=(a mod 400)=0 if(( a % 100)==0))
else biss:=(a mod 4)=0; biss=(a % 400)==0;
if m=1 then m:=13; else biss=(a % 4)==0;
case m-1 of if m==1 m=13;
1,3,7,8,10,12:nj:=31; switch(m-1)
4,6,9,11:nj:=30; { case 1:
2:if biss then nj:=29 case 3:
else nj:=28; case 5:
end; case 7:
if j=1 then begin case 8:
if m=1 then begin case 10:
ap:=a-1; case 12: nj=31;
jp:=nj; case 4:

mp:=12; case 6:
case 9:
end case 11:nj=30;
else begin case 2: if (biss) nj=29;
mp:=m-1; else nb=28;
ap:=a; }
jp:=nj; if (j==1)
end; { if (m==1)
end { ap=a-1;
else begin jp=nj;
jp:=j-1; mp=12;
mp:=m; }
ap:=a; else
end; { mp=m-1;
writeln('le jour prcdant est :',jp,'/',mp,'/',ap); ap=a;
readln; jp=nj;
end. }
else
{ jp=j-1;
mp=m;
ap=a;
}
printf("le jour precedant est :%d/%d/%d",jp,mp,ap);
getch();
}
}

Exercice 30
Ecrire un programme qui calcule la somme 5+6+7+.+N (N>=5).
Program Somme_entiers; #include<stdio.h>
var N,i,S:integer; #include<conio.h>
begin void main()
writeln('donner un entier >=5:'); { int N,i,S;
readln(N); printf("donner un entier >=5:\n");
S:=0;i:=5; scanf("%d",&N);
while i<=N do S=0;
begin i=4;
S:=S+i; while(i<N)
i:=i+1; { i=i+1;
end; S=S+i;
writeln('la somme est gale ,S); }
readln; printf("la somme est egale a :%d" ,S);
end. getch();
}
Exercice 31
Ecrire un programme qui calcule le produit des N (N>0) premiers entiers positifs.
program Produit_Entiers; #include<stdio.h>
var P,i,N:integer; #include<conio.h>
begin void main()
writeln('donner un entier >0:'); {
readln(N); int p,i,n;
if N<=0 then writeln('il faut donner un entier > 0!') printf("Donner un entier >0:");
else scanf("%d",&n);

P:=1; if(n<=0) printf("Il faut donner un entier >0!!");

for i:=1 to N do else{
P:=P*i; p=1;
writeln('le produit des N premiers entiers est :',P); for(i=1;i<=n;i++) p=p*i;
end. printf("le produit des %d premiers entiers
est:%d",n,p);
}
getch();
}
Exercice 32
Ecrire un programme qui calcule la somme 1+1/2+1/4+1/6+1/2N (N>0).
program Serie_Fraction; #include<stdio.h>
var i,N:integer; #include<conio.h>
S:real; void main()
begin {
writeln('donner un entier N>0'); int i,n;
readln(N); float s;
S:=1; printf("Donner un entier >0:");
i:=1; scanf("%d",&n);
repeat s=1;i=1;
begin do{
S:=S+(1/(2*i)); s=s+(float)1/(2*i);
i:=i+1; i=i+1;
end; }while(i<=n);
until i=N+1; printf("la somme est: %f",s);
writeln('S=,'S); getch();

readln; }
end.
Exercice 33
Ecrire un programme qui change les contenus de trois donnes numriques si leur somme est paire, sinon il met
la somme des trois dans la premire donne, leur produit dans la seconde et la valeur zro dans la troisime.
program echange_cond_trois; void main()
uses crt; {
var s,tmp,x,y,z:integer; clrscr();
begin int x,y,z,tmp,s;
clrscr; printf("Donnez trois entiers:");
writeln('donner trois entiers:'); scanf("%d %d %d",&x,&y,&z);
readln(x,y,z); s=x+y+z;
s:=x+y+z; if(s%2==0){
if(s mod 2)=0 then begin tmp=x;
tmp:=x; x=y;
x:=y; y=z;
y:=z; z=tmp;
z:=tmp; printf("x=%d,y=%d,z=%d",x,y,z);
writeln('x=',x,' ','y=',y,' ','z=',z); }
end else{
tmp=x;
else begin x=x+y+z;
tmp:=x; y=y*tmp*z;
x:=x+y+z; z=0;
y:=y*tmp*z; printf("x=%d,y=%d,z=%d",x,y,z);
z:=0; }

writeln('x=',x,' ','y=',y,' ','z=',z); getch();

end; }
readln;
end.
Exercice 34
Ecrire un programme qui calcule la somme :1-1/2+1/3-1/4++/-1/N
program Serie_Alternative; include<stdio.h>
var i,N:integer; #include<conio.h>
S:real; void main()
b:boolean; {
begin int i,n,b;
writeln('donner un entier >0'); float s;
readln(N); printf("Donner un entier >0:");
S:=1; scanf("%d",&n);
for i:=2 to N do s=1;
begin for(i=2;i<=n;i++){
b:=(i mod 2)=0; b=(i%2==0);
if b then S:=S-1/i if(b) s=s-(float)1/i;
else S:=S+1/i; else s=s+(float)1/i;
end; }
writeln('S=',S); printf("la somme est: %f",s);
readln;
end. getch(); }
Les fonctions
Exercice 35
Ecrire une fonction paramtre qui retourne si un nombre donn est premier ou non.

function est_premier(N:integer):boolean; #include<stdio.h>

var i,nb:integer; #include<math.h>
begin int premier(int N)
nb:=0; {
for i:=1 to N do int i=2;
if N mod i =o then nb:=nb+1; int termine=0;
est_premier:=(nb=2); while(i<=sqrt(N)&&(!termine)){
end; termine=(N%i==0);
i=i+1;
}
return(!termine);
}
Exercice 36
Ecrire une fonction paramtre qui rend si un nombre donn est parfait ou non.
function est_parfait(N:integer):boolean; #include<stdio.h>
var S,i:integer; int parfait(int A)
begin {
S:=0; int s=0;
for i:=1 to N-1 do for(int i=1;i<A;i++)
if N mod i = 0 then S:=S+i if(A%i==0) s+=i;
est_parfait:=(N=S); return(A==s);
end; }
Exercice 37
Ecrire une fonction paramtr qui rend si deux nombres donnes sont amis ou non.
function Amis(N:integer;M:integer):boolean; #include<stdio.h>
var S,R,i,j:integer; int amis(int N,int M)

begin {
S:=0;R:=0; int s,r,i,j;
for i:=1 to N-1 do r=0;
if N mod i = 0 then S:=S+i; s=0;
for j:=1 toM-1 do for(i=1;i<N;i++)
if M mod j = 0 then R:=R+j; if(N%i==0) s+=i;
Amis:=((M=S) and (N=R)); for(j=1;j<M;j++)
end; if(M%j==0) r+=j;
return((M==s)&&(N==r));
}
Exercice 38
Ecrire une fonction paramtre qui retourne linverse dun nombre entier donn
function inverse(n:longint):longint; #include<stdio.h>

var r,inv:longint; #include<conio.h>
begin long inverse(long n)
inv:=0; {
while n mod 10 =0 do n:=n div 10; long r,inv;
while n mod 10 <>0 do inv=0;
begin while(n%10==0) n=n/10;
r:=n mod 10; while(n%10!=0){
inv:=(inv*10)+r; r=n%10;
n:=n div 10; inv=(inv*10)+r;
end; n=n/10;
inverse:=inv; }
end; return(inv);

Exercice 39
Ecrire une fonction rcursive permettant de calculer le PGDC de deux nombres entiers positifs A et B.
function pgdc(a,b:integer):integer; #include<stdio.h>
begin int pgdc(int A,int B)
if a>b then pgdc:=pgdc(a-b,b) {
else if a<b then pgdc:=pgdc(a,b-a) if(A>B) return(pgdc(A-B,B));
else pgdc:=a; else if(A<B) return(pgdc(A,B-A));
end; else return A;
}
Exercice 40
Ecrire une fonction rcursive permettant de calculer le PPMC de deux nombres entiers positifs A et B.
function calcul_ppmc(A:integer,B:integer):integer; #include<stdio.h>
var multiple,k:integer; int ppmc(int A,int B)
begin {
if A<B then ppmc:=ppmc(B,A) int multiple,k;
else if(A<B) return(ppmc(B,A));
begin else{
multiple:=A; multiple=A;
k:=2; k=2;
end while(multiple%B!=0){
while multiple mod B<> 0 do multiple=A*k;
begin k++;
multiple:= A*k; }
k:=k+1; return(multiple);

end; }
}
ppmc:=multiple;
end;
end;
Exercice 41
Ecrire une fonction rcursive qui permet de calculer le factoriel dun nombre donn.
function Factoriel(N:integer):integer; include<stdio.h>
begin long fact(int n)
if N=0 then factoriel:=1 {
else if(n>1) return(fact(n-1)*n);
factoriel:= N*factoriel(N-1); else return 1;
end; }
Exercice 42
Ecrire une fonction rcursive qui permet de calculer la puissance dun entier donn.
function puissance(N:integer,k:integer):longint; #include<stdio.h>
begin long puiss(int n,int k)
if k=0 then puissance:=1 {
else if(k==0) return 1;
puissance:=N*puissance(N,k-1); else return (puiss(n,k-1)*n);
end; }
Exercice 43
Ecrire une fonction rcursive qui calcule la valeur de la fonction dAckermann A dfinie pour m>0 et n>0
par :

A(m, n)=A((m-1),A(m,n-1)) pour n>0, m>0 ;

A(0,n)=n+1 pour n>0;
A(m,0)=A(m-1,1) pour m>0 ;
function acker(n,m:integer):integer; #include<stdio.h>
begin #include<conio.h>
if (m<0) or (n<0) then acker:=0 int acker(int n,int m)
else if n=0 then acker:=m+1 {
else if m=0 then acker:= acker(n-1,1) if((m<0)||(n<0)) return 0;
else acker:=acker(n-1,acker(n,m-1)) else if(n==0) return (m+1);
end; else if(m==0) return(acker(n-1,1));
else return(acker(n-1,acker(n,m-1)));
}
Exercice 44
Ecrire une fonction qui fournit le nombre de chiffres dun entier donn.
function NCHIFFRES (N:longint):integer; int NCHIFFRES(long N)
var I:integer; {
begin int I;
If N<0 then N:=N*(-1); if (N<0)
I:=1; N *= -1;
while N>10 do for (I=1; N>10; I++)
begin N /= 10;
N:=N div 10; return I;
I:=I+1; }
end;
NCHIFFRES:=I;

End;
Les procdures
Exercice 45
Ecrire une procdure qui permet de dessiner la lettre X, l'aide d'espaces et d'une "lettre" fournie par l'utilisateur,
auquel on demande aussi la "hauteur" du dessin qu'il dsire obtenir. Avec les rponses : a et 5, elle donnera :
a a
a a
a
a a
a a
procedure DessX(hauteur:integer;lettre:char); void DessX(int hauteur,char lettre)
{ int no_ligne,i;
var no_ligne,i:integer; for(no_ligne=1;no_ligne<((hauteur+1)/2);no_ligne++)
begin {
for no_ligne:=1 to ((hauteur+1) div 2)-1 do for (i=1;i<no_ligne;i++)
begin printf("%c",' ');
for i:=1 to no_ligne-1 do printf("%c",lettre);
write(' '); for(i=0;i<hauteur-2*no_ligne;i++)
write(lettre); printf("%c",' ');
for i:=0 to (hauteur-2*no_ligne)-1 do printf("%c",lettre);
write(' '); printf("\n");
write(lettre); }
writeln; for(i=1;i<(hauteur+1)/2;i++)
end; printf("%c",' ');
for i:=1 to ((hauteur+1) div 2)-1 do printf("%c",lettre);

write(lettre); for(no_ligne=1;no_ligne<((hauteur+1)/2);no_ligne++)
writeln; {
for no_ligne:=1 to ((hauteur+1) div 2)-1 do for (i=0;i<(hauteur-2*no_ligne-1)/2;i++)
begin printf("%c",' ');
for i:=0 to ((hauteur-2*no_ligne-1) div 2)-1 do printf("%c",lettre);
write(' '); for(i=0;i<2*no_ligne-1;i++)
write(lettre); printf("%c",' ');
for i:=0 to (2*no_ligne-1)-1 do printf("%c",lettre);
write(lettre); }
writeln; }
end;
end;
Exercice 46
Soit un programme qui visualise un menu compos de trois rubriques : Hors duvre, plat chaud et dessert.
Ecrire une procdure qui permet deffectuer, chaque fois, un choix exclusif.
program menu; #include<stdio.h>
uses crt; #include<conio.h>
procedure Plat(choix1,choix2,choix3:string); void plat(char choix1[10],char choix2[10],char
var choix:char; choix3[10])
begin {
choix:=readkey; char choix;
writeln; choix=getch();
write('-',choix,'-'); printf("-%c-",choix);
if choix=choix1[1] then writeln(choix1) if(choix==choix1[0]) printf("%s",choix1);
else if choix=choix2[1] then writeln(choix2) if(choix==choix2[0]) printf("%s",choix2);

else if choix=choix3[1] then writeln(choix3); if(choix==choix3[0]) printf("%s",choix3);

end; }
begin
clrscr;
plat('soupe','crudit','oeuf Dur');
plat('steak','poulet','hamburger');
plat('gateau','poire','fromage');
readln;
end.
Exercice 47
Ecrire une procedure paramtre, qui permet lchange des contenus de deux paramtres formels par valeur A et
B. Appeler cette procdure dans un programme principal.On crira les rsultats dans le corps de la procdure, et
dans le programme principal.
program exchange; include<stdio.h>
var A:real; #include<conio.h>
B: real; void echange(float x,float y)
procedure echange(x,y:real); {
var temp:real; float temp;
begin printf("Echange:%10.2f %10.2f",x,y);
writeln('Ecange:',x:10:2,y:10:2); temp=x;
temp:=x; x=y;
x:=y; y=temp;
y:=temp; printf("\nEchange:%10.2f %10.2f",x,y);
writeln('Echange:',x:10:2,y:10:2); }
end; void main()
begin {

readln(A,B); clrscr();
echange(A,B); float A,B;
writeln('Echange:',x:10:2,y:10:2); scanf("%f %f",&A,&B);
readln; echange(A,B);
end. printf("\nEchange:%10.2f %10.2f",A,B);
getch();
}
Exercice 48
Ecrire une procedure paramtre, qui permet lchange des contenus de deux paramtres formels par adresse A et
B. Appeler cette procdure dans un programme principal.On crira les rsultats dans le corps de la procdure, et
dans le programme principal.
program exchange; #include<stdio.h>
var A:real; #include<conio.h>
B:real; void echange(float&x,float&y)
procedure echange(var x,y:real); {
var temp:real; float temp;
begin printf("Echange:%10.2f %10.2f",x,y);
writeln('Ecange:',x:10:2,y:10:2); temp=x;
temp:=x; x=y;
x:=y; y=temp;
y:=temp; printf("\nEchange:%10.2f %10.2f",x,y);
writeln('Echange:',x:10:2,y:10:2); }
end; void main()
begin {
readln(A,B); clrscr();
echange(A,B); float A,B;

writeln('Echange:',x:10:2,y:10:2); scanf("%f %f",&A,&B);

readln; echange(A,B);
end. printf("\nEchange:%10.2f %10.2f",A,B);
getch();
}
Exercice 49
Ecrire une procdure qui affiche tous les nombres premiers qui sont compris entre 1 et 200.
procedure Nombres_premiers; Void Nombres_premiers (void)
var i,j,nb:integer; {
begin int i,j,nb ;
for j:=1 to 200 do for(j=1; i<=200;i++)
begin {
nb:=0; for(nb=0,i=1;i<=j/2;i++)
for i:=1 to (j div 2) do if (!(j %i) nb++;
if( j mod i =0) then nb:=nb+1; if( nb==1 ) printf(%d\n,j);
if nb=1 then writeln(j); }
end; }
end;
Exercice 50
Ecrire une procdure qui affiche tous les nombres parfaits qui sont compris entre 1 et 200.
procedure Nombres_parfaits; Void Nombres_parfaits()
var i,j,nb,S:integer; { int i,j,S ;
begin for(j=1;j<=200;j++)
for j:=1 to 200 do {
begin for (S=0,i=1;i<=j-1;i++)
S:=0; {

for i:=1 to j-1 do if (!(j%i)) s+=i;

if (s==j ) printf(%d\n,j);
if( j mod i =0) then S:=S+I; }
if S=j then writeln(j); }
end;
end;
Exercice 51
Ecrire une procdure qui permet dafficher tous les diviseurs dun entier N ainsi que leur nombre.
procedure Diviseurs(N :integer) ; void Diviseurs(int N)
var i,nb:integer; { int nb=0 ;
begin printf(les diviseurs de % sont \n,N);
nb:=0; for( int i=1 ;i<=N ;i++)
writeln(Les diviseurs de ,N,sont :) ; if (!(N%i )){
for i:=1 to N do printf( %d\n,i);
if N mod i =0 then nb+=1;}
begin printf(le nombre de diviseurs de %d est%d,N,nb);
writeln(i); }
nb:=nb+1;
end;
writeln(Le nombre de diviseurs de ,N,est :,nb);
end ;
Exercice 52
Affichez un triangle isocle form d'toiles de N lignes (N est fourni au clavier):
Nombre de lignes : 8
*
***

*****
*******
*********
***********
*************
***************
procedure DessinerTri(L:integer); void DessinerTri(int L)
var { int i; /* compteur des lignes */
k:integer; {compteur des lignes} int j; /* compteur des caractres */
ESP,I,j:integer; int e; /* nombre d'espaces */
begin for (i=0;i<L;i++)
for k:=1 to L do {
begin e = L-i-1;
ESP := L-k; for (j=0 ; j<e ; j++)
for I:=1 to ESP do putchar(' ');
write(' '); for (j=0 ; j<2*i+1 ; j++)
for j:=1 to 2*k-1 do putchar('*');
write('*'); putchar('\n');
writeln; }
end; getchar() ;
readln; }
end ;
Exercice 53
Calculer pour une valeur X donne du type float la valeur numrique d'un polynme de degr n:
P(X) = AnXn + An-1Xn-1 + ... + A1X + A0
Les valeurs de n, des coefficients An, ..., A0 et de X seront entres au clavier.

Utiliser le schma de Horner qui vite les oprations d'exponentiation lors du calcul:
procedure polynome(N:integer;X:real); void polynome(int N, float X)

var I:integer; {
A,B:real; float A; /* coefficients successifs du polynme */
begin float P; /* coefficient courant du terme Horner */
for I:=1 to N+1 do for(P=0.0 ; N>=0 ; N--)
begin {
writeln('donner le ',I,'eme coefficient'); printf("Entrer le coefficient A%d : ", N);
readln(B); scanf("%f", &A);
A:=A*X+B; P = P*X + A;
end; }
writeln(Valeur du polynme pour X = ,X,est :,A); printf("Valeur du polynme pour X = %.2f : %.2f\n",
readln; end; X, P);
}
Exercice 54
Ecrire une procdure qui affiche la table des produits pour N variant de 1 10 :
X*Y I 0 1 2 3 4 5 6 7 8 9 10
--------------------------------------------------
0 I 0 0 0 0 0 0 0 0 0 0 0

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

CONST MAX= 10; {
var I,J:integer; const int MAX = 10; /* nombre de lignes et de
begin colonnes */
write(' X*Y I'); int I; /* compteur des lignes */
for I:=0 to MAX do int J; /* compteur des colonnes */
write(I:4);
writeln; /* Affichage de l'en-tte */
writeln('-----------------------------------------------); printf(" X*Y I");
for J:=0 to max do for (J=0 ; J<=MAX ; J++)
begin printf("%4d", J);
write(J:7, I); printf("\n");
for I:=0 to Max do printf("------");
write(I*J:4); for (J=0 ; J<=MAX ; J++)
writeln; printf("----");

end; printf("\n");
readln;
end. /* Affichage du tableau */
for (I=0 ; I<=MAX ; I++)
{
printf("%3d I", I);
for (J=0 ; J<=MAX ; J++)
printf("%4d", I*J);
printf("\n");
}
}
Les Tableaux
Exercice 55
Ecrire une procdure qui affiche les nombres ngatifs dune liste relle
Type tab=array[0..50] of real ; void nbre_negatif(float a[],int n)
Procedure nbre_negatif(a:tab;n:integer); {int i;
Var i:integer; for(i=0;i<n;i++)
Begin if(a[i]<0) printf("%f\t",a[i]);
for i:=0 to n-1 do }
if a[i]<0 then writeln(a[i]);
End;
Exercice 56
Ecrire une procdure qui met zro la diagonale dune matrice carre.
type matrice=array[1..50,1..50] of integer; typedef int ligne[50];
procedure mise_zero(var a:matrice;n:integer); typedef ligne matrice[50];
var i:integer; void mise_zero(matrice A,int n)

begin {int I;
for i:=1 to n do for (I=0; I<n; I++)
a[i,i]:=0; A[I][I]=0;
end; }
Exercice 57
Ecrire une procdure qui affiche loccurrence dexistence dun nombre rel dans une liste de nombres rels
Type tab=array[0..50] of real ; void occurrence(float a[],int n,float nbre)
Procedure occurrence(a:tab;n:integer;nbre:real); {int i,cpt;
Var i,cpt:integer; for(i=0,cpt=0;i<n;i++)
Begin if(a[i]==nbre) cpt++;
cpt:=0; printf("L'occurrence d'existence du nombre %f est
for i:=0 to n-1 do %d",nbre,cpt);
if a[i]=nbre then cpt:=cpt+1; }
writeln(Loccurrence dexistence du nombre
,nbre, est ,cpt) ;
End;
Exercice 58
Ecrire une procdure qui met le plus petit lment dune liste au dbut de celle-ci
type tab=Array[0..50] of real; void min_debut(float a[],int n)
procedure min_debut(var a:tab;n:integer); {int i,ind;
var i,ind:integer; float tmp;
tmp: real; for(i=1,ind=0;i<n;i++)
begin if(a[i]<a[ind]) ind=i;
ind:=0; tmp=a[0];
for i:=0 to n-1 do a[0]=a[ind];
if a[i]<a[ind] then ind:=i; a[ind]=tmp;

tmp:=a[0]; }
a[0]:=a[ind];
a[ind]:=tmp;
end;
Exercice 59
Ecrire une procdure qui met les lments ngatifs dune liste gauche et les lments positifs droite de la liste
type tab=Array[0..50] of real; void negatif_gauche(float a[],int n)
procedure negatif_gauche(var a:tab;n:integer); {int i,j;
var i,j:integer; float tmp;
tmp: real; for(i=0,j=0;i<n;i++)
begin if(a[i]<0)
j:=0; { tmp=a[j];
for i:=0 to n-1 do a[j]=a[i];
if a[i]<0 then a[i]=tmp;
begin j++;
tmp:=a[j]; }
a[j]:=a[i]; }
a[i]:=tmp;
j:=j+1;
end;
end;
Exercice 60
Ecrire une procdure qui classe une liste de notes de la plus petite plus grande
type tab=Array[0..50] of real; void tri(float note[],int n)
procedure tri(var note:tab;n:integer); {int i,j,min;
var i,j,min:integer; float tmp;

tmp:real; for(i=0;i<n-1;i++)
begin {
for i:=0 to n-2 do for(min=i,j=i+1;j<n;j++)
begin if(note[j]<note[min]) min=j;
min:=i; if (min!=i)
for j:=i+1 to n-1 do { tmp=note[i];
if note[j]<note[min] then min:=j; note[i]=note[min];
if min<>i then note[min]=tmp;
begin }
tmp:=note[i]; }
note[i]:=note[min]; }
note[min]:=tmp;
end;
end;
end;
Exercice 61
Etant donn N tudiants, leurs notes correspondantes M matires et leur moyenne. Ecrire une procdure qui
affiche ct de chaque tudiant son classement.
type matrice=array[1..50,1..50]of real; void moyenne(float m[50][50],int tl,int tc)
procedure moyenne(var m:matrice;tl,tc:integer); {float s;
var i,j:integer; int i,j;
s:real; for (i=0;i<tl;i++)
begin {s=0;
for i:=1 to tl do for(j=0;j<tc-2;j++)
begin s+=m[i][j];
s:=0; m[i][tc-2]=s/(tc-2);

for j:=1 to tc-2 do }

s:=s+m[i,j]; }
m[i,tc-1]:=s/(tc-2);
end; void classement(float m[50][50],int tl,int tc)
end; {int te,i,cl=1,j,p[50],arret=0;
for(i=0;i<tl;i++)
procedure classement(var m:matrice;tl,tc:integer); m[i][tc-1]=0;
var te,i,j,cl:integer; do
p:array[1..50] of integer; {j=0;te=0;
arret:boolean; while(m[j][tc-1]!=0 && j<tl) j++;
begin if (m[j][tc-1]!=0) arret=1;
for i:=1 to tl do else
m[i,tc]:=0; {p[te++]=j;
arret:=false; for (j=p[te-1]+1;j<tl;j++)
cl:=1; if(m[j][tc-1]==0)
repeat {if(m[j][tc-2]>m[p[te-1]][tc-2])
begin {te=0;
j:=1; p[te++]=j;
te:=0; }
while (m[j,tc]<>0) and (j<=tl) do j:=j+1; else
if m[j,tc]<>0 then arret:=true if (m[j][tc-2]==m[p[te-1]][tc-2]) p[te++]=j; }
else for(i=0;i<te;i++)
begin m[p[i]][tc-1]=cl;
te:=te+1; cl+=te;
p[te]:=j; }
for j:= p[te]+1 to tl do }

if m[j,tc]=0 then while(!arret);

if m[j,tc-1]>m[p[te],tc-1] then }
begin
te:=1;
p[te]:=j;
end
else
if m[j,tc-1] = m[p[te],tc-1] then
begin
te:=te+1;
p[te]:=j;
end;
for i:=1 to te do
m[p[i],tc]:=cl;
cl:=cl+te;
end;
end;
until arret;
end;
Exercice 62
Le tri par bulles est un tri par change. Le principe de base est de rordonner les couples non classs tant quils
en existent. La mthode de tri par bulles consiste parcourir la liste en comparant deux lments successifs en
les permutant sil y a lieu. Ecrire une procdure qui ralise ce tri.
Type tab=array[0..50] of integer ; void echanger(int t[],int i, int j)
Procedure echanger(var t:tab;i,j: integer); {int tmp=t[i];
Var tmp:integer; t[i]=t[j];

Begin t[j]=tmp;
tmp :=t[i]; }
t[i] :=t[j]; void tri_bulles (int t[], int n)
t[j] :=tmp; {int k,p;
End; for(k=0;k<=n-2;k++)
Procedure tri_bulles(var t: tab; n: integer); for(p=n-2;p>=k;p--)
Var p,k:integer; if(t[p+1]<t[p])
Begin echanger(t,p+1,p);
for k:=0 to n-2 do }
for p:=n-2 downto k do
if t[p+1]<t[p] then
echanger(t,p+1,p);
End;
Les chanes de caractres :
Exercice 63
Un palindrome est un mot, ou une phrase, lisible indiffremment de la gauche vers la droite ou inversement.
Ecrire une fonction qui rend si une chane de caractres est un palindrome ou non.
Function palindrome(s:string):boolean; int palindrome (char s[])
Var i,taille :integer; {int i,taille;
miroir:string; char miroir[255];
begin taille=strlen(s);
taille :=length(s) ; for(i=0;i<taille;i++)
miroir:=; miroir[i]=s[taille-i-1];
for i:= 1 to taille do return(!strncmp(miroir,s,taille));
miroir:=miroir+s[taille-i+1]; }
palindrome :=(s=miroir) ; Remarque :

end ; Vous devez ajouter la ligne suivante au dbut de votre

programme : #include <string.h>, pour pouvoir utiliser
les fonctions strlen et strncmp.
Exercice 64
Ecrire une fonction qui retourne la frquence de prsence dun mot dans une phrase.
Function frequence(phrase,mot:string):integer; int frequence (char phrase[],char mot[])
var cpt,debut:integer; {int cpt=0;
begin while (phrase=strstr(phrase,mot))
cpt:=0; {cpt++;
while pos(mot,phrase)<>0 do phrase=phrase+strlen(mot);
begin }
cpt:=cpt+1; return(cpt);
debut:=pos(mot,phrase); }
delete(phrase,1,length(mot)+debut); Remarque :
end; Vous devez ajouter la ligne suivante au dbut de votre
frequence:=cpt; programme : #include <string.h>, pour pouvoir utiliser
end; les fonctions strlen et strstr.
Exercice 65
Ecrire une procdure qui enlve tous les blancs au dbut dune phrase et laisse un seul blanc entre les diffrents
mots de la phrase
procedure blanc(var s:string); void blanc (char s[ ])
var ind:integer; {
tmp:string; while(s[0]==' ') strcpy(s,s+1);
begin while(s=strchr(s,' '))
while s[1]=' ' do delete(s,1,1); { while(*(s+1)==' ') strcpy(s,s+1);
ind:=0; s=s+1;

tmp:=s; }
while pos(' ',tmp)<>0 do }
begin Remarque :
ind:=pos(' ',tmp)+ind; Vous devez ajouter la ligne suivante au dbut de votre
while s[ind+1]=' ' do delete(s,ind+1,1); programme : #include <string.h>, pour pouvoir utiliser
tmp:=copy(s,ind+1,length(s)); les fonctions strcpy et strchr.
end;
end;
Exercice 66
Soit un nombre entier positif N. Ecrire une fonction qui donne son quivalent dans une base donne B (2B16)
Function car(n :word) :char ; char car(int n)
Begin {if (n<=9) return('0'+n);
If n<=9 then car:=chr(n+ord(0)) else return(n+'A'-10);
Else }
car:=chr(n+ord(A)-10);
End; char* dix_b(int n,int b)
{char *s,t[40];
Function dix_b(n,b:word):string; strcpy(s,"");
Var s:string; while(n!=0)
Begin {
s:=; t[0]=car(n%b);
While n<>0 do strcpy(t+1,"");
Begin strcat(t,s);
s:=car(n mod b)+s; strcpy(s,t);
n:=n div b; n=n/b;
End; }

dix_b:=s; return(s);
End; }
Exercice 67
Soit N un nombre donn en base B1 (B 10). Ecrire une fonction qui donne son quivalent en base 10.
Function valeur (c :char) :word ; int valeur(char c)
Begin { if((c<='9') && (c>='0'))
If c IN [0..9] then return(c-'0');
valeur:=ord(c)-ord(0) else
Else if ((toupper(c) >='A') && (toupper(c)<='F'))
If upcase(c) IN [A..F] then return(toupper(c)-'A'+10);
valeur:=ord(upcase(c))-ord(A)+10; }
End;
int b_dix(char n[],int b)
Function b_dix(n:string;b:word):word; {int i,res=0;
Var i:integer; for(i=0;i<strlen(n);i++)
res:word; res=res*b+valeur(n[i]);
Begin return(res);
res:=0; }
For i:=1 to length(n) do Remarque :
res:=res*b+valeur(n[i]) ; Vous devez ajouter les lignes suivantes au dbut de
b_dix :=res ; votre programme : #include <string.h> et #include
End ; <ctype.h>, pour pouvoir utiliser les fonctions strlen et
toupper.
Exercice 68

Soit N un nombre donn en base B1. Ecrire une fonction qui donne son quivalent en base B2.
procedure baseB(n:string;b1,b2:integer;var r:string); void baseB(char n[],int b1,int b2,char r[])
var re:integer; {
begin return(dix_b(b_dix(n,b1),b2));
baseB:=dix_b(b_dix(n,b1),b2); }
end;
Exercice 69
Si on est amen raliser des oprations sur des nombres entiers trs grands, on peut utiliser les chanes de
caractres pour reprsenter ces nombres et ensuite faire lopration par bloc.
Ecrire une procdure pour raliser lopration daddition sur de tels nombres.
Function calcul(N1,N2:String):String; char* calcul(char n1[],char n2[])
var Code,R,V,V1,V2:Integer; {char s1[100],s2[100],s[100],n[100],t[2];
N,S,S1,S2:string; int r,v;
begin r=0;
N:='';
R:=0; strcpy(s1,"");strcpy(s2,"");strcpy(s,"");strcpy(n,"");strc
While ( N1<>'') or (N2<>'') Do py(t,"");
Begin while((strlen(n1)!=0) || (strlen(n2)!=0))
If Length(N1)>4 Then {
Begin if(strlen(n1)>=4)
S1:=Copy(N1,Length(N1)-3,4); {
Delete(N1,Length(N1)-3,4); strcpy(s1,n1+strlen(n1)-4);
End strcpy(n1+strlen(n1)-4,"");
Else }
Begin else
S1:=N1; {

N1:=''; strcpy(s1,n1);
End ; strcpy(n1,"");
If Length(N2)>4 Then }
Begin if(strlen(n2)>=4)
S2:=Copy(N2,Length(N2)-3,4); {
Delete(N2,Length(N2)-3,4); strcpy(s2,n2+strlen(n2)-4);
End strcpy(n2+strlen(n2)-4,"");
Else }
Begin else
S2:=N2; {
N2:=''; strcpy(s2,n2);
End ; strcpy(n2,"");
Val(S1,V1,Code); }
Val(S2,V2,Code); v=atoi(s1)+atoi(s2)+r;
V:=V1+V2+R; strcpy(s1,"");strcpy(s2,"");itoa(v,s,10);
Str(V,S); if(strlen(s)>4)
If Length(S)>4 Then {
Begin strncpy(t,s,1);
Val(Copy(S,1,1),R,Code); r=atoi(t);
S:=Copy(S,2,Length(S)-1); strcpy(s,s+1);
End }
Else R:=0; else
N:=S+N; r=0;
End; strcat(s,n);strcpy(n,s);
Calcul:=N }
end; return(n);

}
Remarque :
Vous devez ajouter les lignes suivantes au dbut de
votre programme : #include <string.h> et #include
<stdlib.h>pour pouvoir utiliser les fonctions strlen,
strcat, strcpy, atoi, itoa et strncpy.
Exercice 70
Ecrire une procdure qui permet de passer de la reprsentation dun nombre en chiffres romains sa
reprsentation dcimale.
function ConvDec1(c:char):integer; int ConvDec1(char c)
begin {
case upcase(c) of switch (toupper(c)) {
'I':ConvDec1:=1; case 'I': return 1;
'V':ConvDec1:=5; case 'V': return 5;
'X':ConvDec1:=10; case 'X': return 10;
'L':ConvDec1:=50; case 'L': return 50;
'C':ConvDec1:=100; case 'C': return 100;
'D':ConvDec1:=500; case 'D': return 500;
'M':ConvDec1:=1000; case 'M': return 1000;
end; }
end; }
procedure ConvDec(rom:string;var dec:integer);
var i,d,dn:integer; void ConvDec(char rom[],int *dec)
begin {
dec:=0; int i, d, dn;
d:=ConvDec1(rom[1]);

for i:=1 to length(rom)-1 do *dec = 0;

begin d = ConvDec1(rom[0]);
dn:=ConvDec1(rom[i+1]); for (i = 0; rom[i+1] != '\0'; i++) {
if(d<dn) then dn = ConvDec1(rom[i+1]);
dec:=dec-d if (d < dn) *dec -= d;
else else *dec += d;
dec:=dec+d; d = dn;
d:=dn; }
end; *dec += d;
dec:=dec+d; }
end; Remarque :
Vous devez ajouter la ligne suivante au dbut de votre
programme : #include <ctype.h> pour pouvoir utiliser
la fonction toupper.
Exercice 71
Ecrire une procdure qui permet de passer de la reprsentation dcimale dun nombre sa reprsentation en
chiffres romains.
procedure ConvRom(var rom:string;dec:integer); void ConvRom(char rom[], int dec)
const ntok=13; {
var tok:integer; int tok;
const romval:array[1..13]of const int ntok = 13;
string[2]=(I,IV,V,IX,X,XL,L,XC,C,CD const char
,D,CM,M); *romval[13]={"I","IV","V","IX","X","XL","L","XC","
const decval:array[1..13]of C",
integer=(1,4,5,9,10,40,50,90,100,400,500,900,1000); "CD","D", "CM", "M"};
begin const int decval[13]

rom:=''; ={1,4,5,9,10,40,50,90,100,400,500,900,1000};
for tok:=ntok downto 2 do rom[0] = '\0';
begin for (tok = ntok-1; tok >= 0; tok--) {
while dec>=decval[tok] do while (dec >= decval[tok]) {
begin strcat(rom, romval[tok]);
rom:=rom+romval[tok]; dec -= decval[tok];
dec:=dec-decval[tok]; }
end; }
end; }
end; Remarque :
Vous devez ajouter la ligne suivante au dbut de votre
programme : #include <string.h> pour pouvoir utiliser
la fonction strcat.
Exercice 72
Ecrire une fonction qui retourne le dterminant dune matrice carre.
const DIM=10; #define DIM 10
type matrice=array[0..DIM-1,0..DIM-1] of real; typedef float ligne[DIM];
procedure det_aux(ma:matrice;var typedef ligne matrice[DIM];
mb:matrice;l,c:integer;n:integer); float expo(int n)
var i,j,d,e:integer; {
begin if(!(n%2)){return (1);}
e:=0; return (-1);
for i:=0 to n-1 do }
begin
d:=0; void det_aux(matrice ma,matrice mb,int l,int c,int n)
if i<>l then {int i,j,d,e=0;

begin for(i=0;i<n;i++)
for j:=0 to n-1 do {
if j<>c then d=0;
begin if(i!=l)
mb[e][d]:=ma[i][j]; {
d:=d+1; for(j=0;j<n;j++)
end; if(j!=c)
e:=e+1; {mb[e][d]=ma[i][j];
end; d++;
end; }
end; e++;
}
function expo(n:integer):real; }
begin }
if n mod 2=0 then expo:=1
else expo:=-1; float determinant(matrice m,int l)
end; {
int i;
function determinant(m:matrice;l:integer):real; matrice m2;
var float x=0;
i:integer; if(l==1)return (m[0][0]);
m2:matrice; for(i=0;i<l;i++)
x:real; {
begin det_aux(m,m2,i,0,l);
x:=0; x=x+(expo(i)*m[i][0]*determinant(m2,(l-1)));
if l=1 then determinant:= m[0][0] }

else return (x);

begin }
for i:=0 to l-1 do
begin
det_aux(m,m2,i,0,l);
x:=x+(expo(i)*m[i][0]*determinant(m2,(l-1)));
end;
determinant:=x;
end;
end;
Exercice 73
Ecrire une procdure qui calcule linverse dune matrice carre.
procedure transp_mat(ma:matrice;var void transp_mat(matrice ma,matrice mb,int n)
mb:matrice;n:integer); {
var i,j:integer; int i,j;
begin for (i=0;i<n;i++)
for i:=0 to n-1 do for (j=0;j<n;j++)
for j:=0 to n-1 do mb[j][i]=ma[i][j];
mb[j][i]:=ma[i][j]; }
end;
void multi_R(float a,matrice ma,matrice mb,int n)
procedure multi_R(a:real;ma:matrice;var {
mb:matrice;n:integer); int i,j;
var i,j:integer; for(i=0;i<n;i++)
begin for(j=0;j<n;j++)
for i:=0 to n-1 do mb[i][j]=ma[i][j]*a;

for j:=0 to n-1 do }

mb[i][j]:=ma[i][j]*a;
end; void coffacteur(matrice ma,matrice mb,int l)
{
procedure coffacteur(ma:matrice;var int i,j;
mb:matrice;l:integer); matrice m2;
var i,j:integer; if (l==1)
m2:matrice; mb[0][0]=1;
begin else
if l=1 then {
mb[0][0]:=1 for (i=0;i<l;i++)
else for (j=0;j<l;j++)
begin {
for i:=0 to l-1 do det_aux(ma,m2,i,j,l);
for j:=0 to l-1 do mb[i][j]=expo(i+j)*determinant(m2,(l - 1));
begin }
det_aux(ma,m2,i,j,l);
mb[i][j]:=expo(i+j)*determinant(m2,(l - 1)); }
end; }
end;
end; void inverse(matrice ma,matrice mb,int l)
{
procedure inverse(ma:matrice;var matrice m1,m2;
mb:matrice;l:integer); float d;
var d=(1/determinant(ma,l));
m1,m2:matrice; coffacteur(ma,m1,l);

d:real; transp_mat(m1,m2,l);
begin multi_R(d,m2,mb,l);
d:=(1/determinant(ma,l)); }
coffacteur(ma,m1,l);
transp_mat(m1,m2,l);
multi_R(d,m2,mb,l);
end;
Exercice 74
Un carr magique est un carr divis en cellules dans lesquelles les nombres entiers, partir de 1 sont disposs
de telle sorte que les sommes de chaque ligne, de chaque colonne et de chaque diagonale soient gales.
Exemple :
6 1 8
7 5 3
2 9 4
Ecrire une procdure qui permet de raliser le carr magique.
const k=11; #define k 11
type magique=array[1..k,1..k]of integer; typedef int ligne[k+1];
procedure CaMag(var carre:magique;n:integer); typedef ligne magique[k+1];
var fin,nombre,l,c:integer; void CaMag(magique carre,int n)
begin {
nombre:=1; int fin,nombre=1,l=1,c;
l:=1; fin=n*n;
fin:=n*n; c=(n+1)/2;
c:=(n+1) div 2; carre[l][c]=nombre;
carre[l,c]:=nombre; while(nombre!=fin)
while nombre<>fin do {

begin if(nombre%n==0) l++;

if nombre mod n =0 then inc(l) else
else {
begin if(l==1) l=n; else l--;
if l=1 then l:=n if(c==1) c=n; else c--;
else dec(l); }
if c=1 then c:=n nombre++;
else dec(c); carre[l][c]=nombre;
end; }
inc(nombre); }
carre[l,c]:=nombre;
end;
end;
Les enregistrements
Exercice 75
Ecrire un programme qui permet de saisir et dafficher les informations dune liste dtudiants.
Program gest; #include <stdio.h>
#include <conio.h>
uses crt; typedef struct{
Type Date=record int j;
J,M,A:Integer; int m;
end; int a;
etud=record }date;
Nom,Prn:string[20]; typedef struct{
CIN:string[10]; char nom[21];

Date_Nais:Date; char prn[21];

End; char cin[11];
Var TEtud:Array[1..100] of etud; date date_naiss;
Te:Integer; }etud;
etud tetud[10];
Procedure Affich_formul(Titre:String); int te=0;
Begin
TextBackground(Blue); void affich_formul(char titre[])
ClrScr; {
TextColor(Yellow); textbackground(BLUE);
Gotoxy(35,4); clrscr();
Write(Titre); textcolor(YELLOW);
Gotoxy(20,7); gotoxy(35,4);
Write('Nom :'); cprintf("%s",titre);
Write('Prnom :'); cprintf("Nom:");
Write('C.I.N :'); cprintf("Prenom");
Write('Date de Naissance :'); cprintf("C.I.N");
End; gotoxy(20,13);
cprintf("Date de naissance");
Procedure saisie(Var E:Etud); }
Begin void saisie(etud *e)
TextColor(White); {
With E, Date_Nais Do textcolor(WHITE);

Begin gotoxy(26,7);
Gotoxy(26,7); clreol();
Clreol; scanf("%s",e->nom);
Readln(Nom); gotoxy(29,9);
Clreol; scanf("%s",e->prn);
Readln(Prn); gotoxy(28,11);
Clreol; scanf("%s",e->cin);
Readln(CIN); gotoxy(40,13);
Clreol; scanf("%d",&e->date_naiss.j);
Readln(J); gotoxy(42,13);
Gotoxy(42,13); printf("/");
Write('/'); scanf("%d",&e->date_naiss.m);
Readln(M); gotoxy(45,13);
Gotoxy(45,13); printf("/");
Write('/'); scanf("%d",&e->date_naiss.a);
Readln(A); }
End; void affich(etud e)
End; {
textcolor(WHITE);
Procedure Saisietout; gotoxy(26,7);clreol();cprintf(e.nom);
Var E:Etud; gotoxy(29,9);clreol();cprintf(e.prn);
Rep:Char; gotoxy(28,11);clreol();cprintf(e.cin);
Begin gotoxy(40,13);clreol();cprintf("%d/%d/

Te:=0; %d",e.date_naiss.j,e.date_naiss.m,e.date_naiss.a);
Affich_formul('S A I S I E'); }
Repeat void saisietout()
Saisie(E); { char rep;
Te:=Te+1; affich_formul("S A I S I E");
TEtud[Te]:=E; do
TextColor(Yellow); {
Gotoxy(45,17); saisie(&tetud[te++]);
Write('Voulez-vous continuez (O/N)?'); textcolor(YELLOW);
Rep:=readkey; gotoxy(45,17);
Gotoxy(45,17); cprintf("Voulez-vous continuez (O/N)?");
Clreol; fflush(stdin);
Until Rep In ['N', 'n']; rep=getchar();
End; gotoxy(45,17);
clreol();
Procedure Affich(Var E:Etud); }
Begin while((rep!='n') && (rep!='N'));
TextColor(White); }
With E, Date_Nais Do void affichtout()
Begin {
Gotoxy(26,7); char rep;
Clreol; int i;
Write(Nom); affich_formul("C O N S U L T A T I O N");
Gotoxy(29,9); for(i=0;i<te;i++)
Clreol; {
Write(Prn); fflush(stdin);

Gotoxy(28,11); affich(tetud[i]);
Clreol; textcolor(YELLOW);
Write(CIN); gotoxy(45,17);
Gotoxy(40,13); cprintf("Taper une touche pour continuer");
Clreol; rep=getchar();
fflush(stdin);
Write(J,'/',M,'/',A); gotoxy(45,17);
End; clreol();
End; }
}
Procedure Affichtout;
Var E:Etud; main()
Rep:Char; {etud e;
I:Integer; saisietout();
Begin affichtout();
Affich_formul('C O N S U L T A T I O N'); clrscr();
For i:=1 To Te Do getch();
Begin }
Affich(TEtud[I]);
TextColor(Yellow);
Gotoxy(45,17);
Write('Taper une touche pour continuer');
Rep:=readkey;
Gotoxy(45,17);
Clreol;
End;

End;
BEGIN
saisietout;
Affichtout;
ClrScr;
Readln;
END.
Exercice 76
Ecrire les procdures qui donnent le calcul sur les nombres complexes au moyen dun type enregistrement.
type complexe=Record typedef struct{
a,b:real; float a;
end; float b;
}complexe;
procedure zsomme(z1,z2:complexe;var z : complexe);
begin void Zsomme(complexe z1,complexe z2,complexe *z)
z.a:=z1.a+z2.a; {z->a=z1.a+z2.a;
z.b:=z1.b+z2.b; z->b=z1.b+z2.b;
end; }
procedure zmoins(z1,z2:complexe;var z : complexe); void Zmoins(complexe z1,complexe z2,complexe *z)

begin {z->a=z1.a-z2.a;
z.a:=z1.a-z2.a; z->b=z1.b-z2.b;
z.b:=z1.b-z2.b; }
end;
void Zmul(complexe z1,complexe z2,complexe *z)
procedure zmul(z1,z2 : complexe; var z:complexe); {z->a=z1.b*z2.b-z1.a*z2.a;

begin z->b=z1.a*z2.b+z2.b*z2.a;
z.a:=z1.b*z2.b-z1.a*z2.a; }
z.b:=z1.a*z2.b+z2.b*z2.a;
end;
Les listes chanes

1. Les listes simples:
type liste=êlement; typedef struct str{
element=record int info;
info:integer; str*suivant;
suivant:liste; }*liste;
end;
Exercice 77
Ecrire une procdure qui permet la cration en file dune liste chane
procedure creation_file(var tete:liste); void creer_file(liste &L)
var p,q:liste; {
x:integer; int x;
begin printf("entrer des entiers (0 pour terminer):");
new(p); scanf("%d",&x);
write('donner des entiers (0 pour terminer) : '); while(x!=0){
readln(x); liste p=(liste)malloc (sizeof(str));
tete:=nil; p->info=x;
while x<>0 do p->suivant=NULL;
begin if(L==NULL) L=p;
p^.info:=x; else{
p^.suivant:=nil; liste q=L;

if tete=nil then while(q->suivant!=NULL) q=q->suivant;

tete:=p q->suivant=p;
else }
begin scanf("%d",&x);
q:=tete; }
while q^.suivant<>nil do }
q:=q^.suivant;
q^.suivant:=p;
end;
new(p);
readln(x);
end;
end;
Exercice 78
Ecrire une procdure qui permet la cration en pile dune liste chane
procedure creation_pile(var tete:liste); void creer_pile(liste &L)
var p:liste; {
x:integer; int x;
begin if(L==NULL) L=p;
p^.info:=x; else{

p^.suivant:=tete; p->suivant=L; L=p;

tete:=p; }
readln(x); }
end; }
end;
Exercice 79
Ecrire une procdure qui recherche un lment dans une liste chane
function rechercher (tete:liste;x:integer) :liste; liste rechercher(liste L,int x)
var p:liste; {
begin if(L!=NULL){
if tete=nil then recherche:=nil if(L->info==x) return L;
else if tete^.info=x then recherche:=tete else return(rechercher(L->suivant,x));
else recherche:=recherche(tete^.suivant,x); }
end; else return NULL;
}
procedure rech_elt (tete:liste;x:integer; var
pred:liste;var pos:liste); void recherch_elt(liste L,int x,liste &pos,liste &pred)
begin {
if tete=nil then if(L!=NULL){
begin if(L->info==x){
pos:=nil; pos=L;
pred:=nil; pred=NULL;
end }
else if tete^.info=x then else{
begin liste p=L;

pos:=tete; while((p->suivant! = NULL)&&(p->info!=x))

pred:=nil; {
end pred=p;
else p=p->suivant;
begin }
p:=tete; if(p->info==x) pos=p;
while (p^.suivant<>nil) and (p^.info<>x) do else pos=NULL;
begin }
pred:=p; }
p:=p^.suivant; }
end;
if p^.info=x then pos:=p
else pos:=nil;
end;
end;
Exercice 80
Ecrire une procdure qui insert un lment dans une liste chane
procedure inserer(var tete:liste;x:integer;position:liste); void inserer(liste &L,liste pos,int x)
var p,q:liste; {
begin liste p;
new(q); p=(liste)malloc(sizeof(str));
q^.info:=x; p->info=x;
q^.suivant:=nil; p->suivant=NULL;
if position=tete then if(L!=NULL){
begin if(pos==L){
q^.suivant:=tete; p->suivant=L;

tete:=q; L=p;
end }
else else{
begin liste q=L;
q^.suivant:=position; while(q->suivant!=pos)
p:=tete; q=q->suivant;
while p^.suivant<>position do p->suivant=pos;
p:=p^.suivant; q->suivant=p;
}
p^.suivant:=q; }
end; }
end;
procedure insere(var
tete:liste;x:integer;position:liste;pred:liste);
var q:liste;
begin void insere(liste &L,liste pos,liste pred,int x)
new(q); {
q^.info:=x; liste p;
q^.suivant:=nil; p=(liste)malloc(sizeof(str));
if position=tete then p->info=x;
begin p->suivant=NULL;
q^.suivant:=tete; if(L!=NULL){
tete:=q; if(pos==L){
end p->suivant=L;
else L=p;

begin }
q^.suivant:=position; else{
pred^.suivant:=q; p->suivant=pos;
end; pred->suivant=p;
end; }
}
}
Exercice 81
Ecrire une procdure qui limine un lment dune liste chane
procedure eliminer(var tete:liste;x:integer); void supprimer(liste &L,int x)
var trouve:boolean; {
q,p:liste; int trouve =1;
begin liste p,q;
p:=tete; p=L;
trouve:=false; q=L;
while(not trouve)and(p<>nil) do while((trouve)&&(p!=NULL)){
begin if(p->info==x) trouve=0;
if p^.info=x then trouve:=true else {
else q=p;
begin p=p->suivant;
q:=p; }
p:=p^.suivant; }
end; if(trouve==0){
end; if(p==L) L=p->suivant;
if trouve then q->suivant=p->suivant;
if p=tete then tete:=p^.suivant free(p);

else q^.suivant:=p^.suivant; }
dispose(p); }
end;
void supprime(liste &L,liste pos,liste pred)
{
procedure elimine(var tete:liste;pos:liste;pred:liste); if(pos==L) L=pos->suivant;
begin else pred->suivant =pos->suivant;
if pos=tete then tete:=pos^.suivant free(pos);
else pred^.suivant:=pos^.suivant; }
dispose(pos);
end;
void afficher(liste L)
procedure afficher_liste(tete:liste); {
var p:liste; liste p=L;
begin printf("\n la liste est:\n");
p:=tete; while(p!=NULL){
while p<>nil do printf("\n%d",p->info);
begin p=p->suivant;
writeln('- ',p^.info); }
p:=p^.suivant; }
end;
end;
Exercice 82
Ecrire une procdure qui empile un lment dans une pile reprsente par une liste chane
procedure empiler(var tete:liste;x:integer); void empiler(liste &L,int x)
var p:liste; {

begin new(p); liste p=(liste)malloc(sizeof(str));

p^.info:=x; p->info=x;
p^.suivant:=tete; p->suivant=L;
tete:=p; L=p;
end; }
Exercice 83
Ecrire une procdure qui dsempile un lment dans une pile reprsente par une liste chane
procedure desempiler(var tete:liste); void desempiler(liste &L)
begin {
if tete<>nil then liste p;
begin p=L;
p:=tete; L=p->suivant;
tete:=tete^.suivant; free(p);
dispose(p); }
end;
end;
2. les listes doublement chaines
suivant,precedent:liste; str*pred;
end; }*liste;
Exercice 84
Ecrire une procdure qui permet la cration dune liste doublement chane

procedure creation(var tete:liste;var Queue:liste); void creation(liste &L,liste &Qu)

var p,q:liste; {
x:integer; int x;
begin Qu=p;
p^.info:=x; if(L==NULL){
p^.suivant:=nil; p->pred=NULL;
Queue:=p; L=p;
if tete=nil then }
begin else{
p^.precedent:=nil; liste q=L;
tete:=p while(q->suivant!=NULL) q=q-
end >suivant;
else q->suivant=p;
begin p->pred=q;
q:=tete; }
while q^.suivant<>nil do scanf("%d",&x);
q:=q^.suivant; }
q^.suivant:=p; }
p^.precedent:=q;
end;

new(p);
readln(x);
end;
end;
Exercice 85
Ecrire une procdure qui recherche un lment dans une liste doublement chane
function rechercher(tete:liste;x:integer) :liste; liste rechercher(liste L,int x)
var p:liste; {
begin if(L!=NULL){
if tete=nil then recherche:=nil if(L->info==x) return L;
else if tete^.info=x then recherche:=tete else return(rechercher(L->suivant,x));
else recherche:=recherche(tete^.suivant,x); }
}
function rechercher (tete:liste;
Queue:liste;x:integer):liste;
begin liste rechercher(liste L,liste Qu,int x)
if tete=nil then rech:=nil {
else if tete^.info=x then rech:=tete if(L->pred!=Qu){
else if Queue^.info=x then rech:=Queue if(L->info==x) return L;
else rech:=rech(tete^.suivant,Queue^.precedent,x); else if(Qu->info==x) return Qu;
end; else return(rechercher(L->suivant , Qu-
>pred,x));
}
else return NULL;

Exercice 86
Ecrire une procdure qui insert un lment dans une liste doublement chane
procedure inserer(var tete:liste;x:integer;position:liste); void inserer(liste&L,int x,liste pos)
var p,q:liste; {
begin liste p=(liste)malloc(sizeof(str));
new(q); p->info=x;
q^.info:=x; if(L!=NULL){
q^.suivant:=nil; if(pos==L){
if position=tete then
begin p->pred=NULL;
q^.precedent:=tete^.precedent; p->suivant=L;
q^.suivant:=tete; L->pred=p;
position^.precedent:=p; L=p;
tete:=q; }
end else{
else if position=nil then p->suivant=pos;
begin p->pred=pos->pred;
p:=tete; pos->pred->suivant=p;
while p^.suivant<>nil do pos->pred=p;
p:=p^.suivant; }
p^.suivant:=q; }
q^.precedent:=p; }
end
else

begin
q^.suivant:=position;
q^.precedent:=position^.precedent;
position^.precedent^.suivant:=q;
position^.precedent:=q;
end;
end;
Exercice 87
Ecrire une procdure qui limine un lment dune liste doublement chane
procedure eliminer(var tete:liste;position:liste); void supprimer(liste &L,liste pos)
var q,p:liste; {
begin if(L!=NULL){
if position=tete then if(pos==L){
begin pos->suivant->pred=NULL;
position^.suivant^.precedent:=nil; L=pos->suivant;
tete:=position^.suivant; free(pos);
end }
else if position^.suivant=nil then else if(pos->suivant==NULL){
position^.precedent^.suivant:=nil pos->pred->suivant=NULL;
else free(pos);
begin }
else{
position^.precedent^.suivant:=position^.suivant; pos->pred->suivant=pos->suivant;
pos->suivant->pred=pos->pred;
position^.suivant^.precedent:=position^.precedent; free(pos);
end;
dispose(position); }
end; }
}
2. Les listes circulaires:
suivant:liste; }*liste;
end;
var l,p:liste;
Exercice 88
Ecrire une procdure qui permet la cration dune liste chane circulaire
procedure creation(var tete:liste); void creer(liste &L)
var p,q:liste; {
x:integer; int x;
while x<>0 do if(L==NULL) L=p;
begin else{
p^.info:=x; liste q=L;
if tete=nil then while(q->suivant!=L) q=q->suivant;
tete:=p q->suivant=p;
else }

begin p->suivant=L;
q:=tete; scanf("%d",&x);
while q^.suivant<>tete do }
q:=q^.suivant; }
q^.suivant:=p;
end;
p^.suivant:=tete;
new(p);
readln(x);
end;
end;
Exercice 89
Ecrire une fonction qui recherche un lment dans une liste chane circulaire
function recherche(tete:liste; x:integer) :liste; liste rechercher(liste L,int x)
var p:liste; {
begin if(L!=NULL){
if tete<>nil then liste p=L;
begin do{
p:=tete; if(p->info==x) return p;
while (p^.suivant<>tete) and (p^.info<>x) do p=p->suivant;
p:=p^.suivant; }while(p!=L);
if p^.info=x then recherche:=p return NULL;
else recherche:=nil; }
end; return NULL;
end; }

Exercice 90
Ecrire une procdure qui insert un lment dans une liste chane circulaire
procedure inserer(var tete:liste;x:integer;position:liste); void inserer(liste &L,liste pos,int x)
var p,q:liste; {
begin liste q;
if tete<>nil then liste p=(liste)malloc(sizeof(str));
begin p->info=x;
new(q); if(L!=NULL){
q^.info:=x; if(pos==L){
if position=tete then q=L;
begin p->suivant=L;
p:=tete;
while p^.suivant<>tete do while(q->suivant!=L) q=q->suivant;
p:=p^.suivant; q->suivant=p;
p^.suivant:=q; L=p;
q^.suivant:=tete; }
tete:=q; else if(pos==NULL){
end q=L;
else if position=nil then while(q->suivant!=L) q=q->suivant;
begin q->suivant=p;
p:=tete; p->suivant=L;
while p^.suivant<>tete do }
p:=p^.suivant; else{
p^.suivant:=q; q=L;
q^.suivant:=tete; while(q->suivant!=pos) q=q-

end >suivant;
else q->suivant=p;
begin p->suivant=pos;
q^.suivant:=position; }
p:=tete; }
while p^.suivant<>position do }
p:=p^.suivant;
p^.suivant:=q;
end;
end; end;
Exercice 91
Ecrire une procdure qui limine un lment dune liste chane circulaire
procedure eliminer(var tete:liste;position:liste); void supprimer(liste &L,liste pos)
var q,p:liste; {
begin liste p;
if tete<>nil then if(L!=NULL){
begin if(pos==L){
if position=tete then p=L;
begin while(p->suivant!=L) p=p->suivant;
p:=tete; p->suivant=pos->suivant;
while p^.suivant<>tete do p:=p^.suivant; L=pos->suivant;
p^.suivant:=tete^.suivant; free(pos);
tete:=tete^.suivant; }
dispose(position); else{
end p=L;
else while(p->suivant!=pos) p=p-

begin >suivant;
p:=tete; p->suivant=pos->suivant;
while p<>position do free(pos);
begin }
q:=p; }
p:=p^.suivant; }
end;
q^.suivant:=position^.suivant;
dispose(position);
end;
end;
end;
Exercice 92
Un paragraphe est une suite de phrases. Une phrase est une suite de mots qui se termine par un point(.). deux
mots sont spars par un blanc( ).
Dans cet exercice on reprsentera un paragraphe par une liste chaine, et aussi une phrase par une liste chainne.
1- Ecrire une procdure qui permet la cration dune telle reprsentation.
2- Ecrire une procdure qui permet la recherche de la premire occurrence dun mot dans le paragraphe. Le
rsultat de la recherche donne la position de ce mot.
3- Ecrire une procdure qui permet linsertion dun mot M1 aprs un mot M2 donne. Si le mot ne se trouve
pas dans le paragraphe, on ne fait pas dinsertion.
4- Ecrire une procdure qui permet llimination dun mot M1 du paragraphe.
5- Ecrire une fonction qui permet la recherche dune phrase, donne par son premier mot, dans le
paragraphe le rsultat de la recherche donne la position de cette phrase dans le paragraphe.
6- Ecrire une procdure qui permet linsertion dune phrase ph1 aprs une phrase ph2 donne. Si la phrase
ph2 ne se trouve pas dans le paragraphe, on insert ph1 la findu paragraphe.

7- Ecrire une procdure qui permet llimination dune phrase ph1 du paragraphe.
PROGRAM paragraphe; #include<stdio.h>
#include<conio.h>
type ligne=êlement; #include<alloc.h>
element=record #include<string.h>
info:string; typedef struct str1{
suivant:ligne; char info[20];
end; str1*suivant;
type para=^str; }*ligne;
str=record typedef struct str2{
line:ligne; ligne line;
suivant:para; str2*suivant;
end; }*para;
var L,q:ligne;
Pa,p:para; void creer_ligne(ligne &L)
{
procedure creation_ligne(var L:ligne); char mot[20];
var p,q:ligne; printf("Entrer une suite de mots ('.' pour
mot:string; terminer):");
begin scanf("%s",mot);
new(p); while(strcmp(mot,".")){
writeln('entrer une suite de mots (point"." pour int n=strlen(mot) ;
terminer):'); //printf("__%d",n);
readln(mot); ligne p=(ligne)malloc(sizeof(str1));
while mot<>'.' do //p->info=(char*)malloc(sizeof(char)*n);
begin strcpy(p->info,mot);

p^.info:=mot; p->info[n]='\0';
p^.suivant:=nil; p->suivant=NULL;
if L=nil then L:=p if(L==NULL) L=p;
else else{
begin ligne q=L;
q:=L; while(q->suivant!=NULL) q=q-
while q^.suivant<>nil do >suivant;
q:=q^.suivant; q->suivant=p;
q^.suivant:=p; }
end; //free(p->info);
readln(mot); scanf("%s",mot);
new(p); }
end; }
end;
void afficher_ligne(ligne L)
procedure afficher_ligne(L:ligne); {
var p:ligne; ligne p=L;
begin while(p->suivant!=NULL){
if L<>nil then // strcat(p->info," ");
begin printf("%s ",p->info);
p:=L; p=p->suivant;
while p^.suivant<>nil do }
begin printf("%s.",p->info);
write(p^.info,' ' ); }
p:=p^.suivant;
end; void creer_paragraphe(para&Pa)

write(p^.info,'.'); {
end; para p,q;
end; ligne L;
char rep;
procedure creation_paragraphe(var Pa:para); do{
var p,q:para; L=NULL;
L:ligne; creer_ligne(L);
rep:string; p=(para)malloc(sizeof(str1));
begin p->line=L;
repeat p->suivant=NULL;
L:=nil; if (Pa==NULL) Pa=p;
creation_ligne(L); else{
new(p); q=Pa;
p^.line:=L; while(q->suivant!=NULL) q=q-
p^.suivant:=nil; >suivant;
if Pa=nil then Pa:=p q->suivant=p;
else }
begin getchar();
q:=Pa; printf("voulez vous continuer(o/n)? ");
while q^.suivant<>nil do q:=q^.suivant; scanf("%c",&rep);
q^.suivant:=p; }while(rep=='o');
end; }
write('voulez vous continuer?(oui/non)
');readln(rep); void afficher_paragraphe(para Pa)
until (rep='non'); {
end; para p=Pa;

while(p!=NULL){
procedure afficher_paragraphe(Pa:para); afficher_ligne(p->line);
var p:para; p=p->suivant;
begin }
if Pa<>nil then }
begin
p:=Pa; void chercher(para Pa,char*mot,para&P, ligne &L)
{
while p<>nil do int trouve=0;
begin para q=Pa;
afficher_ligne(p^.line); while((q!=NULL)&&(!trouve)){
writeln; P=q ;
p:=p^.suivant; ligne l=q->line;
end; while((l!=NULL)&&(!trouve)){
end; if(!strcmp(l->info,mot)) {
end; trouve=1;
L=l;
procedure rechercher(Pa:para;mot:string;var p:para;var }
l:ligne); l=l->suivant;
var q:para; }
r:ligne; q=q->suivant;
trouve:boolean; }
begin }
trouve:=false;
if Pa<>nil then void inserer(para Pa,char*M1,char*M2)
begin {

q:=Pa; ligne q,r,l;

while (q<>nil)and(not trouve) do para p;
begin if(p!=NULL){
r:=q^.line; r=(ligne)malloc(sizeof(str1));
while(r<>nil)and(not trouve) do strcpy(r->info,M2);
begin r->suivant=NULL;
if r^.info = mot then chercher(Pa,M1,p,q);
begin l=p->line;
l:=r; l=q;
p:=q; r->suivant=l->suivant;
trouve:=true; l->suivant=r;
end }
else }
r:=r^.suivant;
end; void supprimer(para &Pa,char*mot)
q:=q^.suivant; {
end; ligne l,q;
end; para p;
end; if(Pa!=NULL){
chercher(Pa,mot,p,q);
procedure inserer(Pa:para;M1,M2:string); if(q==p->line){
var q,r,l:ligne;
p:para; p->line=q->suivant;
begin free(q);
if p<>nil then }
begin else{

new(r); l=p->line;
r^.info:=M2; while(l->suivant!=q) l=l->suivant;
r^.suivant:=nil; l->suivant=q->suivant;
rechercher(Pa,M1,p,q); free(q);
l:=p^.line; }
l:=q; }
r^.suivant:=l^.suivant; }
l^.suivant:=r;
end; para rechercher_phrase(para Pa,char*M1)
end; {
para p;
procedure supprimer(var Pa:para;M1:string); ligne q;
var p:para; p=Pa;
q,l:ligne; if(Pa!=NULL){
begin while(p!=NULL){
if Pa<>nil then q=p->line;
begin if(!strcmp(q->info,M1))
rechercher(Pa,M1,p,q); return(p);
if q=p^.line then p=p->suivant;
p^.line:=q^.suivant }
else return NULL;
begin }
l:=p^.line; return NULL;
while l^.suivant<>q do }
l:=l^.suivant;
l^.suivant:=q^.suivant; void inserer_phrase(para Pa,ligne l,char*M1)

end; {
dispose(q); para p,q,r;
end; if(Pa!=NULL){
end; q=(para)malloc(sizeof(str2));
q->line=l;
function rechercher_phrase(Pa:para;M1:string):para; q->suivant=NULL;
var p:para; p=rechercher_phrase(Pa,M1);
q:ligne; if(p!=NULL){
trouve:boolean; q->suivant=p->suivant;
begin p->suivant=q;
p:=Pa; }
trouve:=false; else{
if p<>nil then r=Pa;
begin while(r->suivant!=NULL) r=r-
while(p<>nil) and (not trouve)do >suivant;
begin r->suivant=q;
if(p^.line^.info=M1) then }
begin }
rechercher_phrase:=p; }
trouve:=true;
end void supprimer_phrase(para&Pa,ligne l)
else {
p:=p^.suivant;
end; para p,q,m;
end; ligne r;
end; p=rechercher_phrase(Pa,l->info);

if(p==Pa){
procedure inserer_phrase ( Pa:para ; l:ligne ; Pa=p->suivant;
M1:string); free(p);
var p,q,r:para; }
begin else{
if Pa<>nil then q=Pa;
begin while((q!=NULL)&&(q->line!=p->line)){
new(q); m=q;
q^.line:=l; q=q->suivant;
q^.suivant:=nil; }
p:=rechercher_phrase(Pa,M1); if(q!=NULL){
if p<>nil then m->suivant=q->suivant;
begin free(p);
q^.suivant:=p^.suivant; }
p^.suivant:=q; }
end }
else
begin
r:=Pa;
while r^.suivant<>nil do r:=r^.suivant;
r^.suivant:=q;
end;
end;
end;
procedure supprimer_phrase(var Pa:para;l:ligne);

var p,q,m:para;
begin
p:=rechercher_phrase(Pa,l^.info);
if p=Pa then Pa:=p^.suivant
else
begin
q:=Pa;
while(q<>nil)and(q^.line<>p^.line) do
begin
m:=q;
q:=q^.suivant;
end;
if q<>nil then
m^.suivant:=q^.suivant;
end;
dispose(p); end;
Les Arbres Binaires
type Noeud=êlement; typedef struct str{
element=record int cle;
cle:integer; str*g,*d;
g:Noeud; }*Noeud;
d:Noeud;
end;
Exercice 93
Ecrire la procdure du parcours dun arbre binaire en prordre.
procedure preordre(A:Noeud); void preordre(Noeud A)

begin {
if A<>nil then if(A!=NULL){
begin printf("%d ",A->cle);
write(A^.cle,' '); preordre(A->g);
preordre(A^.g); preordre(A->d);
preordre(A^.d); }
end; }
end;
Exercice 94
Ecrire la procdure du parcours dun arbre binaire en postordre.
procedure postordre(A:Noeud); void postordre(Noeud A)
begin {
begin postordre(A->g);
postordre(A^.g); postordre(A->d);
postordre(A^.d); printf("%d ",A->cle);
write(A^.cle,' '); }
end; }
end;
Exercice 95
Ecrire la procdure du parcours dun arbre binaire en ordre.
procedure ordre(A:Noeud); void ordre(Noeud A)
begin {
begin ordre(A->g);
ordre(A^.g); printf("%d ",A->cle);

write(A^.cle,' '); ordre(A->d);

ordre(A^.d); }
end; }
end;
Exercice 96
Ecrire une fonction qui recherche un lment dans un arbre ordonn horizontalement
function recherche(A:Noeud;x:integer):Noeud; Noeud recherche(Noeud A,int x)
begin {
begin if(A->cle==x) return A;
if A^.cle=x then recherche:=A else{
else if A^.cle>x then if(A->cle>x) return(recherche(A-
recherche:=recherche(A^.g,x) >g,x));
else recherche:=recherche(A^.d,x); else return(recherche(A->d,x));
end }
else recherche:=nil; }
}
Exercice 97
Ecrire une procdure qui insert un lment dans un arbre ordonn horizontalement
procedure insertion(var A:Noeud;x:integer); void insertion(Noeud &A,int x)
var N:Noeud; {
begin Noeud p=(Noeud)malloc(sizeof(str));
new(N); p->cle=x;

N^.cle:=x; p->g=NULL;
N^.g:=nil; p->d=NULL;
N^.d:=nil; if (A==NULL) A=p;
if A=nil then A:=N else{
else if(A->cle>x) insertion(A->g,x);
begin else insertion(A->d,x);
if x<A^.cle then insertion(A^.g,x) }
else insertion(A^.d,x); }
end;
end;
Exercice 98
Ecrire une procdure qui supprime un lment dans un arbre ordonn horizontalement
procedure suppression(var A:Noeud;x:integer); void suppression(Noeud &A,int x)
var pt,pd,pg:Noeud; {
begin Noeud pt,pg,pd;
if A<>NIL then if(A!=NULL){
begin if(A->cle==x){
if A^.cle=x then pt=A->d;
begin if (pt!=NULL){
pt:=A^.d; while(pt!=NULL){
if pt<>nil then pg=pt;
begin pt=pt->g;
while pt<>nil do }
begin pg->g=A->g;
pg:=pt; A=A->d;

pt:=pt^.g; }
end; else A=A->g;
pg^.g:=A^.g; }
A:=A^.d; else if(x==A->g->cle){
end pt=A->g->d;
else A:=A^.g; if(pt!=NULL){
end while(pt!=NULL){
else pg=pt;
if x=A^.g^.cle then pt=pt->g;
begin }
pt:=A^.g^.d; pg->g=A->g->d;
if pt<>nil then A->g=A->g->d;
begin }
while pt<>nil do else A->g=A->g->g;
begin }
pg:=pt; else if(x==A->d->cle){
pt:=pt^.g; pt=A->d->g;
end; if(pt!=NULL){
pg^.g:=A^.g^.d; while(pt!=NULL){
A^.g:=A^.g^.d; pd=pt;
end pt=pt->d;
else A^.g:=A^.g^.g; }
end pd->d=A->d->d;
else A->d=A->d->g;
if x=A^.d^.cle then }
begin else A->d=A->d->d;

pt:=A^.d^.g; }
if pt<>nil then else{
begin if(x<A->cle) suppression(A->g,x);
while pt<>nil do else suppression(A->d,x);
begin }
pd:=pt; }
pd:=pt^.d; }
end;
pd^.d:=A^.d^.d;
A^.d:=A^.d^.g;
end
else A^.d:=A^.d^.d;
end
else
if x<A^.cle then suppression(A^.g,x)
else suppression(A^.d,x);
end;
end;
Les Fichiers
Exercice 99
Ecrire un programme qui permet de crer un fichier dtudiants.
Program gest_fich; #include<stdio.h>
uses crt; #include<conio.h>
Type Date=record #include<alloc.h>
J,M,A:Integer; #include<string.h>
end; typedef struct{

etud=record int J,M,A;

Nom,Prn:string[20]; }date;
CIN:string[10]; typedef struct{
Date_Nais:Date; char nom[20];
End; char prn[20];
Var FEtud:File of etud; char cin[10];
date date_nais;
Procedure Affich_formul(Titre:String); }etudiant;
Begin
TextBackground(Blue); void affich_formul(char *titre)
ClrScr; {
TextColor(Yellow); textbackground(BLUE);
Gotoxy(35,4); clrscr();
Write(Titre); textcolor(YELLOW);
Write('Nom :'); cprintf("%s",titre);
Write('Prnom :'); cprintf("Nom :");
Write('C.I.N :'); cprintf("Prenom :");
Write('Date de Naissance :'); cprintf("C.I.N :");
End; gotoxy(20,13);
cprintf("Date de naissance :");
Procedure saisie(Var E:Etud); }
Begin

TextColor(White); void saisie(etudiant &E)

With E, Date_Nais Do {
Begin textcolor(WHITE);
Clreol; clreol();
Readln(Nom); scanf("%s",E.nom);
Clreol; clreol();
Readln(Prn); scanf("%s",E.prn);
Clreol; clreol();
Readln(CIN); scanf("%s",E.cin);
Clreol; clreol();
Readln(J); scanf("%d",&E.date_nais.J);
Write('/'); clreol();
Readln(M); cprintf("/");
Gotoxy(45,13); scanf("%d",&E.date_nais.M);
Write('/'); gotoxy(45,13);
Readln(A); cprintf("/");
End; clreol();
End; scanf("%d",&E.date_nais.A);
}
Procedure Ajout;
Var E:Etud; void ajout()

Rep:Char; {
Begin etudiant E;
Assign(Fetud,'C:\Gestion'); int rep;
{$I-} FILE*Fetud=fopen("Gestion","ab");
Reset(Fetud); affich_formul("SAISIE");
{$I+} do{
If IOResult<>0 Then Rewrite(Fetud) saisie(E);
Else Seek(Fetud,FileSize(Fetud)); fwrite(&E,sizeof(etudiant),1,Fetud);
Affich_formul('S A I S I E'); textcolor(YELLOW);
Repeat gotoxy(45,17);
Saisie(E); cprintf("voulez_vous continuez(o/n)?");
Write(Fetud,E); clreol();
TextColor(Yellow); flushall();
Gotoxy(45,17); rep=getchar();
Write('Voulez-vous continuez (O/N)?'); }while(rep=='o' || rep=='O');
Rep:=readkey; fclose(Fetud);
Gotoxy(45,17); }
Clreol; void affich(etudiant &E)
Until Rep In ['N', 'n']; {
Close(Fetud); textcolor(WHITE);
End; gotoxy(26,7);
clreol();
Procedure Affich(Var E:Etud); cprintf("%s",E.nom);
Begin gotoxy(29,9);
TextColor(White); clreol();
With E, Date_Nais Do cprintf("%s",E.prn);

Begin gotoxy(28,11);
Clreol; cprintf("%s",E.cin);
Write(Nom); gotoxy(40,13);
Clreol; cprintf("%d/%d/%d",E.date_nais.J,
Write(Prn); E.date_nais.M,E.date_nais.A);
Gotoxy(28,11); }
Clreol;
Write(CIN); void affichtout()
Gotoxy(40,13); {
Clreol; etudiant E;
Write(J,'/',M,'/',A); FILE*Fetud=fopen("Gestion","rb");
End; if (Fetud==NULL) return;
End; affich_formul("CONSULTATION");
do{
Procedure Affichtout; fread(&E,sizeof(etudiant),1,Fetud);
Var E:Etud; affich(E);
Rep:Char; textcolor(YELLOW);
I:Integer; gotoxy(45,17);
Begin cprintf("Tapez une Entree pour
Assign(Fetud,'C:\Gestion'); continuer");
{$I-} getch();
Reset(Fetud); gotoxy(45,17);
{$I+} }while(!feof(Fetud));
If IOResult<>0 Then write('Probleme de lecture !!!!') fclose(Fetud);

Else }
Begin
Affich_formul('C O N S U L T A T I O N'); void main()
Repeat {
Read(Fetud,E); ajout() ;
Affich(E); affichtout() ;
TextColor(Yellow); clrscr() ;
Gotoxy(45,17); getch() ;
Write('Taper une touche pour continuer'); }
Rep:=readkey;
Gotoxy(45,17);
Clreol;
Until EOF(Fetud);
Close(Fetud);
End;
End;
BEGIN
Ajout;
Affichtout;
ClrScr;
Readln;
END.
Exercice 100
Ecrire une procedure qui permet de modifier les informations dun etudiant
Procedure Modif; void modif()
Var N: Integer; {

E:Etud; int i;
Begin char*CIN;
Assign(Fetud,'C:\Gestion'); char nom[20],prn[20],cin[10];
{$I-} int J,M,A;
Reset(Fetud); etudiant E;
{$I+} etudiant *Et;
If IOResult<>0 Then write('Probleme de lecture !!!!') FILE*Fetud=fopen("Gestion","rb");
Else FILE*f=fopen("tmptmp.$$","wb");
Begin textcolor(YELLOW);
ClrScr; textbackground(BLUE);
Write('Donner le numero d''ordre de l''etudiant a clrscr();
modifier'); if(Fetud==NULL) return;
readln(N); cprintf("Donnez le C.I.N de l'etudiant a modifier:
Seek(Fetud,N-1); ");
Read(Fetud,E); scanf("%s",CIN);
With E do getch();
Begin i=fread(&E,sizeof(etudiant),1,Fetud);
Write('Nom : ',Nom); while((strcmp(E.cin,CIN))&&(i!=0)){
Readln(Nom); fwrite(&E,sizeof(etudiant),1,f);
Write('Prnom : ',Prn); i=fread(&E,sizeof(etudiant),1,Fetud);
Readln(Prn); }
Write('C.I.N : ',CIN); if(!strcmp(E.cin,CIN)){
Readln(CIN); etudiant
End; *Et=(etudiant*)malloc(sizeof(etudiant));
Seek(Fetud,N-1); cprintf("Nom : %s ",E.nom);
Write(Fetud,E); scanf("%s",nom);

Close(Fetud) strcpy(Et->nom,nom);
End; cprintf("Prenom : %s ",E.prn);
End; scanf("%s",prn);
strcpy(Et->prn,prn);
cprintf("C.I.N : %s ",E.cin);
scanf("%s",cin);
strcpy(Et->cin,cin);
getch();
cprintf("Date de naissance :%d/%d/%d
",E.date_nais.J,E.date_nais.M,E.date_nais.A);
scanf("%d",&J);printf("/");Et-
>date_nais.J=J;
scanf("%d",&M);printf("/");Et-
>date_nais.M=M;
scanf("%d",&A);Et->date_nais.A=A;
fwrite(Et,sizeof(etudiant),1,f);
}
i=fread(&E,sizeof(etudiant),1,Fetud);
while(i!=0){
fwrite(&E,sizeof(etudiant),1,f);
i=fread(&E,sizeof(etudiant),1,Fetud);
}
fclose(f);
fclose(Fetud);
remove("Gestion");

rename("tmptmp.$$","Gestion");
}

Annexe
GESTION DE LCRAN
Les fonctions de gestion de lcran sont les mmes en C et en Pascal. Vous

aurez, en ce qui suit, une brve description des instructions les plus
courantes.
Remarque :
En C, toutes ces fonctions se trouvent dans la bibliothque conio.h
I. Notion de fentre
On peut dfinir une fentre dans un cran. Lcran actif sera rduit cette
fentre.
WINDOW(x1,y1,x2,y2) o :
x1 et y1 reprsentent les coordonnes du coin suprieur gauche de la
fentre.
x2 et y2 reprsentent les coordonnes du coin infrieur droit de la
fentre.
II. Gestion du curseur

Linstruction Gotoxy(x,y) positionne le curseur sur le point de
coordonnes (x,y) de la fentre active.
La fonction WhereX retourne la colonne o se trouve le curseur.
La fonction WhereY retourne la ligne o se trouve le curseur.
III. Instructions de gestion de lcran

ClrScr : efface la fentre active et positionne le curseur au point de
coordonnes (1,1).
ClrEol : efface les caractres se trouvant aprs la position du curseur
jusqu la fin de la ligne.
DelLine : limine la ligne pointe par le curseur et dplace toutes les
lignes suivantes vers le haut. La dernire ligne devient vide.
InsLine : insre une ligne vide la place du curseur et dcale les
lignes suivantes vers le bas. La dernire ligne sera perdue.

Annexe
IV. Instructions de gestion des couleurs

TextColor(couleur) : dfinit la couleur du texte (16 couleurs codes de
0 15).
TextBackGround(couleur) : dfint la couleur du fond du texte (8
couleurs codes de 0 7).
Le tableau suivant prsente les 16 couleurs existantes pour lcriture du texte :
N Couleur N Couleur N Couleur N Couleur

0 Noir 4 Rouge 8 Gris fonc 12 Rouge clair
1 Bleu 5 Magenta 9 Bleu clair 13 Magenta
2 Vert 6 Brun 10 Vert clair 14 Jaune
3 Cyan 7 Gris clair 11 Cyan clair 15 Blanc

Conclusion
CONCLUSION
En conclusion, le langage Pascal reste le plus adapt lenseignement

dalgorithmique pour les lves de lenseignement secondaire ou pour les
dbutants en algorithmique.
Malgr sa performance parfois suprieure celle de Pascal, C est plutt

destin des utilisateurs avertis (cole dingnieurs, etc.).
Malgr le nombre trs important dexercices et leur diversit, on pourrait

prvoir quelques problmes de synthse tels que les Tours de Hanoi,
problmes complets de systme (gestion de stock, etc.), gestion trs pousse
de lcran avec par exemple un menu droulant, etc.
On pourrait aussi suggrer pour les promotions venir de complter les

solutions proposes par une analyse du problme consistant mettre en
vidence les donnes du problme et leurs types, ainsi les principales actions
raliser pour calculer les donnes de sortie (rsultats) en partant des
donnes dentre.

Rfrences
RFRENCES
Programmer en langage C Claude Delanoy .
Turbo Pascal manuel de lutilisateur version 5.0 .
Algorithmique : cours et exercices mthodologiques corrigs Guy

CHATY & Jean VICARD.
Turbo Pascal et ses fichiers (version 3) : Jacques BOISGONTIER &

Christophe DNAY.
Manuel dAlgorithmique ralis par Mr LAMHARCHI Brahim.

Exercices en Pascal

Transféré par

Droits d'auteur :

Formats disponibles

Exercices en Pascal

Transféré par

Informations du document

Description originale:

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

Exercices en Pascal

Transféré par

Droits d'auteur :

Formats disponibles

Ecole Normale Suprieure

Encadr par : Mr.Brahim Lamharchi

Nous adressons galement

ENS Rabat Dpartement dInformatique

I.2 Les fonctions........................................................................................................27

ENS Rabat Dpartement dInformatique

Un programme informatique se compose dune srie dinstructions, qui sont

Beaucoup de langages de programmation sont apparus au fil des annes en

Le langage Pascal est un langage de programmation de haut niveau. Il a t

Le langage C a t cr en 1972 par Denis RITCHIE avec un objectif

Une premire version du langage est apparue en 1978 avec louvrage de

Lenseignement de linformatique se rpand de plus en plus dans les

ENS Rabat Dpartement dInformatique 1

En particulier, lenseignement de lalgorithmique et de la programmation est, et

ENS Rabat Dpartement dInformatique 2

LMENTS DE BASE DUN

I- Structure dun programme

1- En-tte qui se compose du mot rserv PROGRAM suivi dun identificateur

Exemple : PROGRAM Operations ;

2- Prambule dclaratif qui comporte :

La dclaration des bibliothques utilises, prcde par le mot rserv

Exemple : USES Crt, Graph, Dos ;

La dclaration des identificateurs de types de donnes, dfinis par

Exemple : TYPE Nombre = 0..99 ;

La dclaration des identificateurs de constantes, prcde par le mot

Exemple : CONST Pi = 3.14 ;

La dclaration des identificateurs de variables, prcde par le mot

Exemple : VAR A : INTEGER ;

3- Dfinition des diffrents sous-programmes (voir chapitre des sous-

ENS Rabat Dpartement dInformatique 3

4- Dfinition du bloc principal du programme : ce bloc commence par le mot

La dclaration des bibliothques utilises, prcde par le mot rserv

Exemple : #include <stdio.h>

La dclaration de lidentificateur de constante, prcde par le mot

Exemple : Define Pi 3.14.

La dclaration des identificateurs de variables, prcde par le type des

2- En-tte : prcise le dbut du programme principal. Il se compose du mot

3- Dfinition du bloc principal du programme : ce bloc commence par une

II- Types de donnes

II-1.1 Les variables

On appelle variable, un emplacement mmoire dans lequel est code une

ENS Rabat Dpartement dInformatique 4

Syntaxe : Var <identificateur> : <type>;

Variables globales et variables locales

Les variables dclares dans la partie dclaration du programme sont dites

ENS Rabat Dpartement dInformatique 5

Le de lidentificateur peut tre compos de chiffres, de lettres et du caractre _.

Exemple : int ident_1

Variables globales et variables locales

II-1.2 Les constantes

Contrairement une variable, une constante ne peut tre modifie

Syntaxe : const <identificateur> = valeur ;

Syntaxe : const <type> <identificateur> = valeur ;

ENS Rabat Dpartement dInformatique 6

II-2. Les types de base

II-2.1 En langage Pascal

ENS Rabat Dpartement dInformatique 7

II-3. Crer un type de donnes

II-3.1 En langage Pascal