100exercices en Pascal Amp C

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

Ralis par : Benallou Imane
Lazrak Chamae
Razzoug Milouda
Lamharchi
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
I.2 Les fonctions........................................................................................................27
ENS Rabat Dpartement dInformatique
Sommaire
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
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.
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 sousprogrammes).
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
Type
Description
Shortint
Integer
Entiers courts
Entiers "relatifs"
Longint
Entiers longs
Byte
Word
Entiers sur 1 Bit

(Byte ou Octet)
Entiers sur 2 Bits
(Word ou Mot)
Intervalle
Exemples
Mmoire
requise
1 octet
2 octets
-128 127
-32 768 32 767
-2147483648
2147483647
-125; 0; 32
-30 000; 421;
-12 545 454; 3
257
0 255
12; 157
1 octet
0 65 535
27; 4 589
2 octets
Real
Nombres rels
2.9E-39 1.7E38
Single
Nombres dcimaux
(simple prcision)
1.5E-45 3.4E38
Double
Nombres dcimaux
(double prcision)
5E-324 1.7E308
Extended Nombres rels
3.4E-4932 1.1E4932
Comp
Boolean
Entier
logique sur 1 octet
String
Chane de
caractres
String[n]
Chane de n
caractres
Char
1 caractre
-9.2E18 9.2E18
false ou true
256 caractres au
maximum (0
255)
n caractres
maximum
1 caractre
maximum
3.1415;
789.457851
3.1415926; 178
925.455678
54.5899; 9 897
669
651.45568959
3.14159265458;
9.81
-271; 6 548
false; true
4 octets
6 octets
4 octets
8 octets
10 octets
8 octets
1 octet
'Hello!'; 'Allezvous bien ?'
256
octets
String[6]>'Hello!'
n octets
'R'
1 octet
II-2.2 En langage C
Type de donnes
Signification
Char
Caractre
Caractre non
unsigned char
sign
short int
Entier court
Entier court non
unsigned short int
sign
int
Entier
unsigned int
Entier non sign
long int
unsigned long int
float
double
long double
Entier long
Entier long non
sign
flottant (rel)
flottant double
flottant double
long
Taille (en
octets)
1
-128 127
0 255
-32768 32767
0 65535
2
2
-32768 32767
0 65535
-2 147 483 648 2 147 483
647
Plage de valeurs accepte
0 4 294 967 295
4
8
3.4*10-38 3.4*1038
1.7*10-308 1.7*10308
10
3.4*10-4932 3.4*104932
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
0
1
2
3
4
(,[
OR
AND
NOT
< , >, <= , >= , <> , =
Ordre
5
6
7
8
9
Oprateurs
+,*, /, DIV, MOD
(+),(-)
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.
10
- 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
Oppos
Multiplicati
on
Division
Modulo
(reste)
Addition
Soustraction
/
%
+
-
Nbre
d'oprandes
1
2
2
2
2
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.
Oprateur
Fonction
!
<
<=
NON logique
Infrieur
Infrieur ou
gal
Suprieur
>
Nbre
d'oprandes
1
2
2
2
11
Oprateur
Fonction
>=
Suprieur ou
gal
galit
Ingalit
ET logique
OU logique
==
!=
&&
||
Nbre
d'oprandes
2
2
2
2
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
12
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.
Oprateur
Fonction
Complmentatio
n1
Dcalage
gauche
Dcalage
droite
ET logique
OU exclusif
OU logique
<<
>>
&
^
|
Nbre
d'oprandes
1
2
2
2
2
2
Exemple:
unsigned char val = 1;
val = val << 3;
val = val >> 2;
// 00000001
// 00001000
// 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.
13

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
rfrence
unaire
arithmtique
arithmtique
dcalage
relationnels
relationnels
manip. de bits
manip. de bits
manip. de bits
logique
logique
conditionnel
affectation
Oprateurs
() [ ] -> .
+ - ++ -- | ~ * &
*/%
+<< >>
< <= > >=
== !=
&
^
|
&&
||
?:
= += -= /= %= &= ^= |= <<= >>=
IV- Instructions simples

IV-1. Instructions dentre
Une instruction dentre permet de lire une donne partir du clavier.
En langage Pascal:
14
Syntaxe :
Read (V 1, 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 :
Format
c
d
hd
hu
ld
lu
f
lf
s
u
Type de la Ivalue
correspondant
char
int
short int
unsigned short
long int
unsigned long
Float
double
chane de caractres
unsigned int
Liste_dadresses : liste de "lvalue", spares par des virgules, dun type en

accord avec le code de format correspondant.
La macro getchar()
15
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).
16
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
17
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 ).
18
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
19
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 ]
}
20
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
Tant que
Rpter - jusqu
Pour
En langage Pascal
While <expression>
Do <bloc>
Repeat<instruction>
Until <expression>
For comp :=Vint To Valf
Do <bloc>
For comp :=Vint DownTo
En langage C
While (<expression>)
<instruction>
Do <instruction>
While(<expression>)
For
(<initialisation> ;<condition
de
21
Valf
Do <bloc>
continuation ;<modification>)
<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.
22
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.
23
Exercice 22
Ecrire un programme qui calcule le salaire net dun employ, sachant que celuici 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)
SB<1500
1500<=SB<3000
3000<=SB<5000
SB>=5000
limpt payer
0%
10% du SB
450+30%(SB-3000)
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
24
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.
25
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
26
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
27
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
28
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
int pgcd(int a, int b)
{ if (a = = b) return a;
else if (a>b) return pgcd(a-b,b);
else pgcd(a,b-a);
}
En langage Pascal
Funtion pgcd (a,b : integer): integer;
Begin
If (a=b) then pgcd:=a
Else if (a>b) then pgcd:=pgcd(ab,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.
29
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.
30
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).
31
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
32
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.
33
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
34
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 ;
35
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>
36
Fonctions
strcat(but,source)
strncat(but,source,lgmax)
strcmp(chane1,chane2)
strncmp(chane1,chane2,lgmax)
stricmp(chane1,chane2) et
strnicmp(chane1,chane2,lgmax)
strcpy(destin,source)
strncpy(destin,source,lgmax)
strchr(chane,caractre)
strrchr(chane,caractre)
strstr(chane,sous-chane)
Commentaires
recopie la seconde chane (source) la
suite de la premire (but).
travaille de faon semblable strcat en
offrant en outre un contrle sur le
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 :
Positive si chane1 > chane2
Nulle si chane1 = chane2
Ngative si chane1 < chane2
travaille comme strcmp mais elle limite
la comparaison au nombre maximal de
caractres indiqus par lentier lgmax.
travaillent
respectivement
comme
strcmp et strncmp, mais sans tenir
compte de la diffrence entre
majuscules et minuscules.
recopie la chane situe ladresse
source dans lemplacement dadresse
destin.
procde de manire analogue strcpy,
en limitant la copie au nombre de
caractres prciss par lexpression
entire lgmax.
recherche dans chane la premire
position o apparat le caractre
mentionn.
ralise le mme traitement que strchr,
mais en explorant la chane concerne
partir de la fin.
recherche dans chane la premire
occurrence
de
la
sous-chane
mentionne.
37
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;
...
38
};
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 celleci.
Exercice 59
39
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.
40
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
41
Ecrire les procdures qui donnent le calcul sur les nombres complexes au moyen
dun type enregistrement.
42
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
43
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
New (var p:pointeur)
GetMem (var p:pointeur;
taille:word)
Ptr (seg,dep:word)
Dipose (var p:pointeur)

FreeMem (var
p:pointeur;taille:word)
Mark (var p:pointeur)
Release (var p:pointeur)
Commentaires
cre un espace mmoire de la taille de la
variable pointe et affecte ladresse de
celui-ci au pointeur
cre une nouvelle variable dynamique de la
taille indique et place son adresse dans une
variable pointeur.
fait pointer la variable pointeur sur une
adresse mmoire spcifique sans faire
intervenir de notion de variable occupant
cet espace. Ptr convertit une adresse format
segment:dplacement en une valeur de type
pointeur.
libre la mmoire dune variable
dynamique.
libre la mmoire dune variable
dynamique dune certaine taille
mmorise la valeur du pointeur de tas dans
une variable de type pointeur.
restaure le tas dans une configuration
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.
44
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
E
G
I
H
J
45
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
46
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 :
2
8
10
1
2
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)
47
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
5
1
0
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
48
4
9
1
0
1
0
5
1
3
Insertion
1
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
6
1
6
1
8
2
4
1
0
1
8
2
4
1
0
Suppression
Reprsentation dun arbre en Pascal
49
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)
1
Pierre
2
0 0
Paul
Louis (9)
3
3 4
Jacques
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 .).
50
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.

Fonctions
void * malloc(size_t taille)
void * calloc(size_t nb_blocs,size_t

taille)
void * realloc(void * pointeur, size_t
taille)
void free(void* adr)
Commentaires
alloue un emplacement de taille octets,
sans linitialiser et fournit ladresse
correspondante lorsque lallocation a
russi ou un pointeur nul dans le cas
contraire.
alloue lemplacement ncessaire
nb_blocs conscutifs, ayant chacun
une taille de taille octets.
permet de modifier la taille dune zone
pralablement alloue (par malloc,
calloc ou realloc).
libre la mmoire dadresse adr. Ce
pointeur doit obligatoirement dsigner
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
51
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
info
g
info
g d
info
g
Exemple :
Pour le cas dun arbre de caractres, la structure est la suivante :
Typedef struct str{
char info ;
str *g, *d ;
} *Arbre p;
52

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.
53
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
54
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.
55
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.
56
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
57
Les fichiers
Expression
Eof(filval)
Filepos(filval)
Commentaires
aprs traitement.
fonction boolenne qui retourne vraie si le pointeur de fichier
est positionn la fin du fichier disque.
fonction entire retournant la position courante du pointeur de
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
Readln(filvar) ou
Commentaires
va au dbut de la ligne suivante, cest--dire
58
Les fichiers
Expressions
Commentaires
readln(filvar,st1,st2,..,stn)
carte tous les caractres jusque et y compris la

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

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

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

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

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

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

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

texte ouvert en mode criture.
SetTextBuf(var
filvar:Text;var
tampon[ ;taille :Word])
assigne un tampon dentre/sortie un fichier

texte. Toute variable fichier de type texte dispose
dun tampon mmoire, dont la taille est de 128
octets par dfaut. Le tampon est utilis lors des
oprations de lecture et dcriture. La taille est
suffisante pour la plupart des applications.
SetTextBuf doit tre utilise juste aprs Assign.
59
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

60
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
nb_elements, fichier)
fwrite(ptr_sur_tableau,
taille_element,
61
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:
62
Les fichiers
#include <stdio.h>
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.
63
Solutions des exercices
SOLUTIONS DES EXERCICES
Pascal
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);
64
y:=tmp;
writeln('x=',x,' et y=',y);
readln;
end.
printf("avant echange x=%d et y=%d\n",x,y);

tmp=x;
x=y;
y=tmp;
printf("apres echange x=%d et y=%d",x,y);
getch();
}
Exercice 3
Ecrire un programme qui change 3 entiers.
Program Echange;
var x,y,tmp,z:integer;
begin
write('donner trois entiers differents:');
readln(x,y,z);
writeln('x=',x,' et y=' ,y,et z=,z);
tmp:=x;
x:=y;
y :=z ;
z:=tmp;
writeln('x=',x,' et y=',y, et z=,z);
readln;
end.
#include<stdio.h>
#include<conio.h>
void main()
{
int x,y,z,tmp;
printf("entrez trois nombres: ");
scanf("%d %d %d",&x,&y,&z);
printf("avant echange x=%d , y=%d et z=%d
\n",x,y,z);
tmp=x;
x=y;
y=z ;
z=tmp;
printf("apres echange x=%d , y=%d et z=%d
",x,y,z);
getch();
}
65
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 ;
var x1, y1, x2, y2, xm, ym : real ;
begin
writeln ('Entrez les coordonnes du premier
point') ; readln ( x1 ) ; readln ( y1 );
writeln ('Entrez les coordonnes du deuxime
point') ; readln ( x2 ) ; readln ( y2 );
xm := (x1 + x2) / 2 ; ym := (y1 + y2) / 2 ;
writeln ('Les coordonnes du point milieu
sont :', xm :5:2, ym:5:2) ;
end.
#include<conio.h>
void main()
{
float x1, y1, x2, y2, xm, ym ;
printf ("Entrez les coordonnes du premier point") ;
scanf("%f %f ",&x1,&y1) ;
printf ("Entrez les coordonnes du second point") ;
scanf("%f %f ",&x2,&y2) ;
xm =(float) (x1 + x2) / 2 ; ym = (float)(y1 + y2) / 2 ;
printf("Les coordonnes du point milieu sont : (%5.2f,
%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") ;
66
writeln ('La ',n:3,'ime valeur de la suite est :',

Un :5:2) ;
end.
scanf("%f %f %d",&Uo,&r,&n) ;
Un = U0 + n*r;
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:');
{
readln(x,y);
clrscr();
int x,y,tmp;
if x*y <0 then
begin
tmp:=x;
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;
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
67
readln;
end.
pas de changement");
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:');
{
readln(x,y);
clrscr();
int x,y,tmp;
if x*y<0 then
begin
tmp:=x;
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;
y=y+tmp;
68
readln;
end.
printf("les 2 nombres sont de meme signes donc

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 :
69
est:',premj);
case 10:
case 12: nbj=31;
readln;
end.
break;
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();
70
s:=0;
if N>0 then
for i:=1 to N do
s:=s+i;
writeln('la somme de N premiers termes
positifs:',N);;
readln
end.
int N,i,S;
printf("donnez un entier positif:
");scanf("%d",&N);
S=0;
if(N>0) {
for(i=1 ;i<=N;i++)
S=S+i;
}
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:');
{
readln(N);
clrscr();
i:=1;s:=0;
int N,i,S;
while(i<2*N) do
begin
");scanf("%d",&N);
s:=s+i;
S=0;
i:=i+2;
i=1;
end;
while(i<=2*N-1){
71
writeln('somme de ',N,' premiers termes positifs

impaires est: ',s);
readln;
end.
S=S+i;
i=i+2;
}
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:');
{
readln(N);
clrscr();
i:=0;s:=0;cp:=0;
int N,i,S,cp;
while(cp<N) do
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;
}
72
end.

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);
73
getch();
}
Exercice 13
Ecrire un programme qui calcule la somme 1+1/2-1/4+ 1/8-1/16+1/2n (n N*)
program calcul;
#include<stdio.h>
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;
}
readln;
end.
getch();
}
Exercice 14
74
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
program calcul;
#include<stdio.h>
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
program calcul;
#include<stdio.h>
var u,s:integer;
#include<conio.h>
75
begin
u:=2;
s:=1;
while s<1000 do
begin
s:=s+u;
u:=u*2;
end;
s:=s-(u div 2);
writeln('la plus grande valeur inferieur a 1000 de la
somme est: ',s);
readln;
end.
void main()
{
clrscr();
int s,u;
s=1;
u=2;
while(s<1000){
s=s+u;
u=2*u;
}
s=s-u/2;
printf("la plus grande valeur inferieur a 1000 est:
%d",s);
getch();
}
Exercice 16
Ecrire un programme qui calcule la somme 1+x+x2++xn (x rel et n entier).
program calcul;
#include<stdio.h>
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 :");
76
while i<=n do
begin
s:=s+u;
u:=u*x;
i:=i+1;
end;
readln;
end.
scanf("%f %d",&x,&n);
s=1;
u=x;
for(i=1;i<=n;i++){
s=s+u;
u=u*x;
}
printf("la Somme est:%f",s);
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;
var x,A,G,B:real;
begin
write('donner un nombre non nul: ');
readln(x);
A:=x;
G:=1;
while abs((A-G)/G)>0.000001 do
begin
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
clrscr();
float x,A,B,G;
printf("donner un nombre non nul:");
scanf("%f",&x);
77
B:=A;
A:=(A+G)/2;
G:=2*B*G/(B+G);
end;
writeln('la racine de ',x:10:5,' est: ',A:10:5);
readln;
end.
A=x;
G=1;
while(fabs((A-G)/G)>0.000001)
{
B=A;
A=(A+G)/2;
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;
78
i:=i+1;
end;
writeln('pi =',s:10:5);
readln;
end.
else s=s-t;
i=i+1;
}
printf("la valeur de pi est:%f",s);
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;
79
i:=i+1;
t:=u/v;
end;
writeln('le sinus de ',x:10:5,'est: ',s:10:5);
readln;
end.
u=u*x*x;
v=(2*i+1)*2*i*v;
i++;
t=(float)u/v;
}
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;
80
'+':writeln('x+y=',x+y);
'-':writeln('x-y=',x-y);
end;
readln;
end.
case '-': printf("x-y=%d\n",x-y); break;

case '*': printf("x*y=%d\n",x*y); break;
case '/': if( y!=0) printf("x/y=%f\n",x/y);
else printf(" division par zero\n"); break;
}
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
81
calcules avec un coefficient donn.

program salaire_net_employe;
var charges,sb,sn,coef,ph:real;
nh:integer;
begin
writeln('donner le nombre d''heures de travail de cet
employ:');
readln(nh);
writeln('donner le prix d''une heure:');
readln(ph);
writeln('donner le coefficient:');
readln(coef);
sb:=nh*ph;
charges:=sb*coef;
sn:=sb-charges;
writeln('le salaire net de cet employ est:',sn);
readln;
end.
#include <stdio.h>
#include<conio.h>
void main()
{
int NH;
float NB,SN,SB,coef,PH,charges;
printf("donner le nombre d'heures de travail:\n");
scanf("%d",&NH);
printf("donner le prix de chaque heure:\n");
scanf("%f",&PH);
printf("donner le coefficient de reduction:\n");
scanf("%f",&coef);
SB=NH*PH;
charges=SB*coef;
SN=SB-charges;
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()
82
begin
writeln('donner le nombre d''heures 25% et celui
50% ainsi que le nombre d''heure normales :');
readln(nh25,nh50,nhn);
writeln('donner le prix d''une heure:');
readln(ph);
writeln('donner le coefficient:');
readln(coef);
sb:=nhn*ph+nh25*ph*125/100+nh50*150/100*ph;
charges:=sb*coef;
sn:=sb-charges;
writeln('le salaire net de cet employ est:',sn);
readln;
end.
{
int NHN,NH25,NH50;
float NB,SN,SB,coef,PH,charges;
printf("donner le nombre d'heures normales:\n");
scanf("%d",&NHN);
printf("donner le nombre d'heures a 25%:\n");
scanf("%d",&NH25);
printf("donner le nombre d'heures a 50%:\n");
scanf("%d",&NH50);
printf("donner le prix d'une heure:\n");
scanf("%f",&PH);
printf("donner le coefficient de reduction:\n");
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()
83
begin
writeln('donner un entier positif:');
readln(n);
bp:=(n mod 2)=0;
if bp then writeln('cet entier est pair')
else writeln('cet entier n''est pas pair');
readln;
end.
{
int n;
printf("donner un entier positif :\n");
scanf("%d",&n);
if( n % 2 == 0)
printf("cet entier est pair.\n");
else
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;
}
84
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)
SB<1500
1500<=SB<3000
3000<=SB<5000
SB>=5000
limpt payer
0%
10% du SB
450+30%(SB-3000)
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*(sbelse printf("l'impot a payer est de:
85
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)
86
else writeln('pas de solution');

end;
readln;
end.
printf("les racines de cette quation sont: x1=%f et x2=

%f",(-b-sqrt(delta))/(2*a),(-b+sqrt(delta))/(2*a));
else printf("pas de solution");
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:
87
as:=a+1;
end
else begin
ms:=m+1;
as:=a;
end;
end
else begin
js:=j+1;
ms:=m;
as:=a;
end;
writeln('le jour suivant est :',js,'/',ms,'/',as);
readln;
end.
case 12: dj=(j==31);

break;
case 4 :
case 6 :
case 9 :
case 11: dj=(j==30);
break;
case 2 :
if(biss) dj=(j==28);
else dj=(j==29);
break;
}
if (dj) {
js=1;
if(m==12){
ms=1;
as=a+1;
}
else{
ms=m+1;
as=a;
}
}
else{
js=j+1;
ms=m;
88
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;
89
jp:=nj;
mp:=12;
end
else begin
mp:=m-1;
ap:=a;
jp:=nj;
end;
end
else begin
jp:=j-1;
mp:=m;
ap:=a;
end;
writeln('le jour prcdant est :',jp,'/',mp,'/',ap);
readln;
end.
case 4:
case 6:
case 9:
case 11:nj=30;
case 2: if (biss) nj=29;
else nb=28;
}
if (j==1)
{ if (m==1)
{ ap=a-1;
jp=nj;
mp=12;
}
else
{ mp=m-1;
ap=a;
jp=nj;
}
else
{ jp=j-1;
mp=m;
ap=a;
}
printf("le jour precedant est :%d/%d/%d",jp,mp,ap);
getch();
}
90
}
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:");
91
else
P:=1;
for i:=1 to N do
P:=P*i;
writeln('le produit des N premiers entiers est :',P);
end.
scanf("%d",&n);
if(n<=0) printf("Il faut donner un entier >0!!");
else{
p=1;
for(i=1;i<=n;i++) p=p*i;
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;
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;
92
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);
93
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);
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);
readln;
end.
getch(); }
Les fonctions
Exercice 35
94
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>
95
var S,R,i,j:integer;
begin
S:=0;R:=0;
for i:=1 to N-1 do
if N mod i = 0 then S:=S+i;
for j:=1 toM-1 do
if M mod j = 0 then R:=R+j;
Amis:=((M=S) and (N=R));
end;
int amis(int N,int M)

{
int s,r,i,j;
r=0;
s=0;
for(i=1;i<N;i++)
if(N%i==0) s+=i;
for(j=1;j<M;j++)
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;
var r,inv:longint;
begin
inv:=0;
while n mod 10 =0 do n:=n div 10;
while n mod 10 <>0 do
begin
r:=n mod 10;
inv:=(inv*10)+r;
n:=n div 10;
end;
inverse:=inv;
#include<stdio.h>
#include<conio.h>
long inverse(long n)
{
long r,inv;
inv=0;
while(n%10==0) n=n/10;
while(n%10!=0){
r=n%10;
inv=(inv*10)+r;
n=n/10;
}
96
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;
}
97
k:=k+1;
end;
return(multiple);
}
}
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
98
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;
begin
if (m<0) or (n<0) then acker:=0
else if n=0 then acker:=m+1
else if m=0 then acker:= acker(n-1,1)
else acker:=acker(n-1,acker(n,m-1))
end;
#include<stdio.h>
#include<conio.h>
int acker(int n,int m)
{
if((m<0)||(n<0)) return 0;
else if(n==0) return (m+1);
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;
99
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
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
100
write(' ');
printf("\n");
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
write(' ');
for(i=0;i<2*no_ligne-1;i++)
write(lettre);
printf("%c",' ');
for i:=0 to (2*no_ligne-1)-1 do
write(' ');
printf("\n");
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);
101
else if choix=choix2[1] then writeln(choix2)

else if choix=choix3[1] then writeln(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()
102
begin
readln(A,B);
echange(A,B);
readln;
end.
{
clrscr();
float A,B;
scanf("%f %f",&A,&B);
echange(A,B);
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);
}
end;
void main()
begin
{
readln(A,B);
clrscr();
103
echange(A,B);
readln;
end.
float A,B;
scanf("%f %f",&A,&B);
echange(A,B);
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++)
104
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
*
105
***
*****
*******
*********
***********
*************
***************
void DessinerTri(int L)
{ int i; /* compteur des lignes */
int j; /* compteur des caractres */
int e; /* nombre d'espaces
*/
for (i=0;i<L;i++)
{
e = L-i-1;
for (j=0 ; j<e ; j++)
putchar(' ');
for (j=0 ; j<2*i+1 ; j++)
putchar('*');
putchar('\n');
}
getchar() ;
}
procedure DessinerTri(L:integer);
var
k:integer; {compteur des lignes}
ESP,I,j:integer;
begin
for k:=1 to L do
begin
ESP := L-k;
for I:=1 to ESP do
write(' ');
for j:=1 to 2*k-1 do
write('*');
writeln;
end;
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
106
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);
var I:integer;
A,B:real;
begin
for I:=1 to N+1 do
begin
writeln('donner le ',I,'eme coefficient');
readln(B);
A:=A*X+B;
end;
writeln(Valeur du polynme pour X = ,X,est :,A);
readln; end;
void polynome(int N, float X)

{
float A; /* coefficients successifs du polynme */
float P; /* coefficient courant du terme Horner */
for(P=0.0 ; N>=0 ; N--)
{
printf("Entrer le coefficient A%d : ", N);
scanf("%f", &A);
P = P*X + A;
}
printf("Valeur du polynme pour X = %.2f : %.2f\n",
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
-------------------------------------------------ENS Rabat Dpartement dInformatique
107
0 I 0
1 I 0
2 I 0
3 I 0
4 I 0
5 I 0
6 I 0
7 I 0
8 I 0
9 I 0
10 I 0
0 0 0 0 0 0 0 0 0 0
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
program tabMul;
CONST MAX= 10;
var I,J:integer;
begin
write(' X*Y I');
for I:=0 to MAX do
write(I:4);
writeln;
writeln('-----------------------------------------------);
for J:=0 to max do
begin
write(J:7, I);
for I:=0 to Max do
write(I*J:4);
void tabMul(void)
{
const int MAX = 10; /* nombre de lignes et de
colonnes */
int I;
/* compteur des lignes */
int J;
/* compteur des colonnes */
/* Affichage de l'en-tte */
printf(" X*Y I");
for (J=0 ; J<=MAX ; J++)
printf("%4d", J);
printf("\n");
printf("------");
for (J=0 ; J<=MAX ; J++)
108
writeln;
end;
readln;
end.
printf("----");
printf("\n");
/* Affichage du tableau */
for (I=0 ; I<=MAX ; I++)
{
printf("%3d I", I);
for (J=0 ; J<=MAX ; J++)
printf("%4d", I*J);
printf("\n");
}
}
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];
109
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];
110
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
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
void tri(float note[],int n)
procedure tri(var note:tab;n:integer);
{int i,j,min;
111
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];
112
s:=0;
for j:=1 to tc-2 do
s:=s+m[i,j];
m[i,tc-1]:=s/(tc-2);
end;
end;
procedure classement(var m:matrice;tl,tc:integer);
var te,i,j,cl:integer;
p:array[1..50] of integer;
arret:boolean;
begin
for i:=1 to tl do
m[i,tc]:=0;
arret:=false;
cl:=1;
repeat
begin
j:=1;
te:=0;
while (m[j,tc]<>0) and (j<=tl) do j:=j+1;
if m[j,tc]<>0 then arret:=true
else
begin
te:=te+1;
p[te]:=j;
m[i][tc-2]=s/(tc-2);
}
}
void classement(float m[50][50],int tl,int tc)
{int te,i,cl=1,j,p[50],arret=0;
for(i=0;i<tl;i++)
m[i][tc-1]=0;
do
{j=0;te=0;
while(m[j][tc-1]!=0 && j<tl) j++;
if (m[j][tc-1]!=0) arret=1;
else
{p[te++]=j;
for (j=p[te-1]+1;j<tl;j++)
if(m[j][tc-1]==0)
{if(m[j][tc-2]>m[p[te-1]][tc-2])
{te=0;
p[te++]=j;
}
else
if (m[j][tc-2]==m[p[te-1]][tc-2]) p[te++]=j; }
for(i=0;i<te;i++)
m[p[i]][tc-1]=cl;
cl+=te;
}
113
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];
114
Var tmp:integer;
Begin
tmp :=t[i];
t[i] :=t[j];
t[j] :=tmp;
End;
Procedure tri_bulles(var t: tab; n: integer);
Var p,k:integer;
Begin
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;
t[i]=t[j];
t[j]=tmp;
}
void tri_bulles (int t[], int n)
{int k,p;
for(k=0;k<=n-2;k++)
for(p=n-2;p>=k;p--)
if(t[p+1]<t[p])
echanger(t,p+1,p);
}
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];
}
115
palindrome :=(s=miroir) ;
end ;
Remarque :
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;
frequence:=cpt;
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);
116
ind:=0;
s=s+1;
tmp:=s;
}
while pos(' ',tmp)<>0 do
}
begin
Remarque :
ind:=pos(' ',tmp)+ind;
while s[ind+1]=' ' do delete(s,ind+1,1);
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;
117
End;
dix_b:=s;
End;
}
return(s);
}
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.
118
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
119
S1:=N1;
N1:='';
End ;
If Length(N2)>4 Then
Begin
S2:=Copy(N2,Length(N2)-3,4);
Delete(N2,Length(N2)-3,4);
End
Else
Begin
S2:=N2;
N2:='';
End ;
Val(S1,V1,Code);
Val(S2,V2,Code);
V:=V1+V2+R;
Str(V,S);
If Length(S)>4 Then
Begin
Val(Copy(S,1,1),R,Code);
S:=Copy(S,2,Length(S)-1);
End
Else R:=0;
N:=S+N;
End;
Calcul:=N
{
strcpy(s1,n1);
strcpy(n1,"");
}
if(strlen(n2)>=4)
{
strcpy(s2,n2+strlen(n2)-4);
strcpy(n2+strlen(n2)-4,"");
}
else
{
strcpy(s2,n2);
strcpy(n2,"");
}
v=atoi(s1)+atoi(s2)+r;
strcpy(s1,"");strcpy(s2,"");itoa(v,s,10);
if(strlen(s)>4)
{
strncpy(t,s,1);
r=atoi(t);
strcpy(s,s+1);
}
else
r=0;
strcat(s,n);strcpy(n,s);
}
120
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;
121
d:=ConvDec1(rom[1]);
for i:=1 to length(rom)-1 do
begin
dn:=ConvDec1(rom[i+1]);
if(d<dn) then
dec:=dec-d
else
dec:=dec+d;
d:=dn;
end;
dec:=dec+d;
end;
*dec = 0;
d = ConvDec1(rom[0]);
for (i = 0; rom[i+1] != '\0'; i++) {
dn = ConvDec1(rom[i+1]);
if (d < dn) *dec -= d;
else *dec += d;
d = dn;
}
*dec += d;
}
Remarque :
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"};
122
begin
rom:='';
for tok:=ntok downto 2 do
begin
while dec>=decval[tok] do
begin
rom:=rom+romval[tok];
dec:=dec-decval[tok];
end;
end;
end;
const int decval[13]

={1,4,5,9,10,40,50,90,100,400,500,900,1000};
rom[0] = '\0';
for (tok = ntok-1; tok >= 0; tok--) {
while (dec >= decval[tok]) {
strcat(rom, romval[tok]);
dec -= decval[tok];
}
}
}
Remarque :
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)
123
if i<>l then
begin
for j:=0 to n-1 do
if j<>c then
begin
mb[e][d]:=ma[i][j];
d:=d+1;
end;
e:=e+1;
end;
end;
end;
function expo(n:integer):real;
begin
if n mod 2=0 then expo:=1
else expo:=-1;
end;
function determinant(m:matrice;l:integer):real;
var
i:integer;
m2:matrice;
x:real;
begin
x:=0;
{int i,j,d,e=0;
for(i=0;i<n;i++)
{
d=0;
if(i!=l)
{
for(j=0;j<n;j++)
if(j!=c)
{mb[e][d]=ma[i][j];
d++;
}
e++;
}
}
}
float determinant(matrice m,int l)
{
int i;
matrice m2;
float x=0;
if(l==1)return (m[0][0]);
for(i=0;i<l;i++)
{
det_aux(m,m2,i,0,l);
x=x+(expo(i)*m[i][0]*determinant(m2,(l-1)));
124
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++)
125
for i:=0 to n-1 do

for j:=0 to n-1 do
mb[i][j]:=ma[i][j]*a;
end;
procedure coffacteur(ma:matrice;var
mb:matrice;l:integer);
var i,j:integer;
m2:matrice;
begin
if l=1 then
mb[0][0]:=1
else
begin
for i:=0 to l-1 do
for j:=0 to l-1 do
begin
det_aux(ma,m2,i,j,l);
mb[i][j]:=expo(i+j)*determinant(m2,(l - 1));
end;
end;
end;
procedure inverse(ma:matrice;var
mb:matrice;l:integer);
var
mb[i][j]=ma[i][j]*a;
}
void coffacteur(matrice ma,matrice mb,int l)
{
int i,j;
matrice m2;
if (l==1)
mb[0][0]=1;
else
{
for (i=0;i<l;i++)
for (j=0;j<l;j++)
{
det_aux(ma,m2,i,j,l);
mb[i][j]=expo(i+j)*determinant(m2,(l - 1));
}
}
}
void inverse(matrice ma,matrice mb,int l)
{
matrice m1,m2;
float d;
d=(1/determinant(ma,l));
126
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)
127
while nombre<>fin do
begin
if nombre mod n =0 then inc(l)
else
begin
if l=1 then l:=n
else dec(l);
if c=1 then c:=n
else dec(c);
end;
inc(nombre);
carre[l,c]:=nombre;
end;
end;
{
if(nombre%n==0) l++;
else
{
if(l==1) l=n; else l--;
if(c==1) c=n; else c--;
}
nombre++;
carre[l][c]=nombre;
}
}
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{
128
CIN:string[10];
Date_Nais:Date;
End;
Var TEtud:Array[1..100] of etud;
Te:Integer;
Procedure Affich_formul(Titre:String);
Begin
TextBackground(Blue);
ClrScr;
TextColor(Yellow);
Gotoxy(35,4);
Write(Titre);
Gotoxy(20,7);
Write('Nom :');
Gotoxy(20,9);
Write('Prnom :');
Gotoxy(20,11);
Write('C.I.N :');
Gotoxy(20,13);
Write('Date de Naissance :');
End;
Procedure saisie(Var E:Etud);
Begin
TextColor(White);
char nom[21];
char prn[21];
char cin[11];
date date_naiss;
}etud;
etud tetud[10];
int te=0;
void affich_formul(char titre[])
{
textbackground(BLUE);
clrscr();
textcolor(YELLOW);
gotoxy(35,4);
cprintf("%s",titre);
gotoxy(20,7);
cprintf("Nom:");
gotoxy(20,9);
cprintf("Prenom");
gotoxy(20,11);
cprintf("C.I.N");
gotoxy(20,13);
cprintf("Date de naissance");
}
void saisie(etud *e)
{
129
With E, Date_Nais Do
Begin
Gotoxy(26,7);
Clreol;
Readln(Nom);
Gotoxy(29,9);
Clreol;
Readln(Prn);
Gotoxy(28,11);
Clreol;
Readln(CIN);
Gotoxy(40,13);
Clreol;
Readln(J);
Gotoxy(42,13);
Write('/');
Readln(M);
Gotoxy(45,13);
Write('/');
Readln(A);
End;
End;
Procedure Saisietout;
Var E:Etud;
Rep:Char;
textcolor(WHITE);
gotoxy(26,7);
clreol();
scanf("%s",e->nom);
gotoxy(29,9);
clreol();
scanf("%s",e->prn);
gotoxy(28,11);
clreol();
scanf("%s",e->cin);
gotoxy(40,13);
clreol();
scanf("%d",&e->date_naiss.j);
gotoxy(42,13);
printf("/");
scanf("%d",&e->date_naiss.m);
gotoxy(45,13);
printf("/");
scanf("%d",&e->date_naiss.a);
}
void affich(etud e)
{
textcolor(WHITE);
gotoxy(26,7);clreol();cprintf(e.nom);
gotoxy(29,9);clreol();cprintf(e.prn);
gotoxy(28,11);clreol();cprintf(e.cin);
130
Begin
Te:=0;
Affich_formul('S A I S I E');
Repeat
Saisie(E);
Te:=Te+1;
TEtud[Te]:=E;
TextColor(Yellow);
Gotoxy(45,17);
Write('Voulez-vous continuez (O/N)?');
Rep:=readkey;
Gotoxy(45,17);
Clreol;
Until Rep In ['N', 'n'];
End;
Procedure Affich(Var E:Etud);
Begin
TextColor(White);
Begin
Gotoxy(26,7);
Clreol;
Write(Nom);
Gotoxy(29,9);
Clreol;
gotoxy(40,13);clreol();cprintf("%d/%d/
%d",e.date_naiss.j,e.date_naiss.m,e.date_naiss.a);
}
void saisietout()
{ char rep;
affich_formul("S A I S I E");
do
{
saisie(&tetud[te++]);
textcolor(YELLOW);
gotoxy(45,17);
cprintf("Voulez-vous continuez (O/N)?");
fflush(stdin);
rep=getchar();
gotoxy(45,17);
clreol();
}
while((rep!='n') && (rep!='N'));
}
void affichtout()
{
char rep;
int i;
affich_formul("C O N S U L T A T I O N");
for(i=0;i<te;i++)
{
131
Write(Prn);
Gotoxy(28,11);
Clreol;
Write(CIN);
Gotoxy(40,13);
Clreol;
fflush(stdin);
affich(tetud[i]);
textcolor(YELLOW);
gotoxy(45,17);
cprintf("Taper une touche pour continuer");
rep=getchar();
fflush(stdin);
gotoxy(45,17);
clreol();
}
Write(J,'/',M,'/',A);
End;
End;
}
Procedure Affichtout;
Var E:Etud;
Rep:Char;
I:Integer;
Begin
Affich_formul('C O N S U L T A T I O N');
For i:=1 To Te Do
Begin
Affich(TEtud[I]);
TextColor(Yellow);
Gotoxy(45,17);
Write('Taper une touche pour continuer');
Rep:=readkey;
Gotoxy(45,17);
Clreol;
main()
{etud e;
saisietout();
affichtout();
clrscr();
getch();
}
132
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);
begin
z.a:=z1.a-z2.a;
z.b:=z1.b-z2.b;
end;
void Zmoins(complexe z1,complexe z2,complexe *z)

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

begin
z.a:=z1.b*z2.b-z1.a*z2.a;
z.b:=z1.a*z2.b+z2.b*z2.a;
end;
{z->a=z1.b*z2.b-z1.a*z2.a;
z->b=z1.a*z2.b+z2.b*z2.a;
}
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{
134
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
new(p);
scanf("%d",&x);
while(x!=0){
readln(x);
tete:=nil;
p->info=x;
while x<>0 do
p->suivant=NULL;
begin
if(L==NULL) L=p;
135
p^.info:=x;
else{
p^.suivant:=tete;
p->suivant=L;
L=p;
tete:=p;
}
new(p);
scanf("%d",&x);
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{
136
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){
137
q^.suivant:=tete;
tete:=q;
end
else
begin
q^.suivant:=position;
p:=tete;
while p^.suivant<>position do
p:=p^.suivant;
p^.suivant:=q;
end;
end;
procedure insere(var
tete:liste;x:integer;position:liste;pred:liste);
var q:liste;
begin
new(q);
q^.info:=x;
q^.suivant:=nil;
begin
q^.suivant:=tete;
tete:=q;
end
p->suivant=L;
L=p;
}
else{
liste q=L;
while(q->suivant!=pos)
q=q->suivant;
p->suivant=pos;
q->suivant=p;
}
}
}
void insere(liste &L,liste pos,liste pred,int x)

{
liste p;
p=(liste)malloc(sizeof(str));
p->info=x;
p->suivant=NULL;
if(L!=NULL){
if(pos==L){
p->suivant=L;
138
else
begin
pred^.suivant:=q;
end;
end;
L=p;
}
else{
p->suivant=pos;
pred->suivant=p;
}
}
}
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;
139
if p=tete then tete:=p^.suivant

else q^.suivant:=p^.suivant;
dispose(p);
free(p);
}
}
end;
procedure elimine(var tete:liste;pos:liste;pred:liste);
begin
if pos=tete then tete:=pos^.suivant
else pred^.suivant:=pos^.suivant;
dispose(pos);
end;
void supprime(liste &L,liste pos,liste pred)

{
if(pos==L) L=pos->suivant;
else pred->suivant =pos->suivant;
free(pos);
}
void afficher(liste L)
{
liste p=L;
printf("\n la liste est:\n");
while(p!=NULL){
printf("\n%d",p->info);
p=p->suivant;
}
}
procedure afficher_liste(tete:liste);
var p:liste;
begin
p:=tete;
while p<>nil do
begin
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)
140
var p:liste;
begin new(p);
p^.info:=x;
p^.suivant:=tete;
tete:=p;
end;
{
liste p=(liste)malloc(sizeof(str));
p->info=x;
p->suivant=L;
L=p;
}
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
typedef struct str{
element=record
int info;
info:integer;
str*suivant;
suivant,precedent:liste;
str*pred;
end;
}*liste;
Exercice 84
141
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
new(p);
scanf("%d",&x);
while(x!=0){
readln(x);
tete:=nil;
p->info=x;
while x<>0 do
p->suivant=NULL;
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=qend
>suivant;
else
q->suivant=p;
begin
p->pred=q;
q:=tete;
}
scanf("%d",&x);
q:=q^.suivant;
}
q^.suivant:=p;
}
p^.precedent:=q;
142
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;
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;
}
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));
}
143
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
new(q);
p->info=x;
q^.info:=x;
if(L!=NULL){
q^.suivant:=nil;
if(pos==L){
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
144
else
begin
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(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;
145
end;
dispose(position);
end;
free(pos);
}
}
}
2. Les listes circulaires:

typedef struct str{
element=record
int info;
info:integer;
str*suivant;
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;
begin
new(p);
scanf("%d",&x);
while(x!=0){
readln(x);
tete:=nil;
p->info=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;
146
else
begin
q:=tete;
while q^.suivant<>tete do
q:=q^.suivant;
q^.suivant:=p;
end;
p^.suivant:=tete;
new(p);
readln(x);
end;
end;
}
p->suivant=L;
scanf("%d",&x);
}
}
Exercice 89
Ecrire une fonction qui recherche un lment dans une liste chane circulaire
function recherche(tete:liste; x:integer) :liste;
var p:liste;
{
begin
if(L!=NULL){
if tete<>nil then
liste p=L;
begin
do{
p:=tete;
if(p->info==x)
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;
return p;
147
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
begin
p->info=x;
new(q);
if(L!=NULL){
q^.info:=x;
if(pos==L){
q=L;
begin
p->suivant=L;
p:=tete;
while p^.suivant<>tete do
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
begin
q->suivant=p;
p:=tete;
p->suivant=L;
while p^.suivant<>tete do
}
p:=p^.suivant;
else{
p^.suivant:=q;
q=L;
148
q^.suivant:=tete;
while(q->suivant!=pos) q=qend
>suivant;
else
q->suivant=p;
begin
p->suivant=pos;
}
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){
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;
149
else
while(p->suivant!=pos) p=pbegin
>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
150
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);
151
begin
p^.info:=mot;
p^.suivant:=nil;
if L=nil then L:=p
else
begin
q:=L;
q:=q^.suivant;
q^.suivant:=p;
end;
readln(mot);
new(p);
end;
end;
procedure afficher_ligne(L:ligne);
var p:ligne;
begin
if L<>nil then
begin
p:=L;
while p^.suivant<>nil do
begin
write(p^.info,' ' );
p:=p^.suivant;
strcpy(p->info,mot);
p->info[n]='\0';
p->suivant=NULL;
if(L==NULL) L=p;
else{
ligne q=L;
while(q->suivant!=NULL) q=q>suivant;
q->suivant=p;
}
//free(p->info);
scanf("%s",mot);
}
}
void afficher_ligne(ligne L)
{
ligne p=L;
while(p->suivant!=NULL){
// strcat(p->info," ");
printf("%s ",p->info);
p=p->suivant;
}
printf("%s.",p->info);
}
152
end;
write(p^.info,'.');
end;
end;
procedure creation_paragraphe(var Pa:para);
var p,q:para;
L:ligne;
rep:string;
begin
repeat
L:=nil;
creation_ligne(L);
new(p);
p^.line:=L;
p^.suivant:=nil;
if Pa=nil then Pa:=p
else
begin
q:=Pa;
while q^.suivant<>nil do q:=q^.suivant;
q^.suivant:=p;
end;
write('voulez vous continuer?(oui/non)
');readln(rep);
until (rep='non');
void creer_paragraphe(para&Pa)
{
para p,q;
ligne L;
char rep;
do{
L=NULL;
creer_ligne(L);
p=(para)malloc(sizeof(str1));
p->line=L;
p->suivant=NULL;
if (Pa==NULL) Pa=p;
else{
q=Pa;
while(q->suivant!=NULL) q=q>suivant;
q->suivant=p;
}
getchar();
printf("voulez vous continuer(o/n)? ");
scanf("%c",&rep);
}while(rep=='o');
}
void afficher_paragraphe(para Pa)
{
153
end;
procedure afficher_paragraphe(Pa:para);
var p:para;
begin
if Pa<>nil then
begin
p:=Pa;
para p=Pa;
while(p!=NULL){
afficher_ligne(p->line);
p=p->suivant;
}
}
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)
154
begin
q:=Pa;
while (q<>nil)and(not trouve) do
begin
r:=q^.line;
while(r<>nil)and(not trouve) do
begin
if r^.info = mot then
begin
l:=r;
p:=q;
trouve:=true;
end
else
r:=r^.suivant;
end;
q:=q^.suivant;
end;
end;
end;
procedure inserer(Pa:para;M1,M2:string);
var q,r,l:ligne;
p:para;
begin
if p<>nil then
{
ligne q,r,l;
para p;
if(p!=NULL){
r=(ligne)malloc(sizeof(str1));
strcpy(r->info,M2);
r->suivant=NULL;
chercher(Pa,M1,p,q);
l=p->line;
l=q;
r->suivant=l->suivant;
l->suivant=r;
}
}
void supprimer(para &Pa,char*mot)
{
ligne l,q;
para p;
if(Pa!=NULL){
chercher(Pa,mot,p,q);
if(q==p->line){
p->line=q->suivant;
free(q);
}
155
begin
new(r);
r^.info:=M2;
r^.suivant:=nil;
rechercher(Pa,M1,p,q);
l:=p^.line;
l:=q;
r^.suivant:=l^.suivant;
l^.suivant:=r;
end;
end;
procedure supprimer(var Pa:para;M1:string);
var p:para;
q,l:ligne;
begin
if Pa<>nil then
begin
rechercher(Pa,M1,p,q);
if q=p^.line then
p^.line:=q^.suivant
else
begin
l:=p^.line;
while l^.suivant<>q do
l:=l^.suivant;
else{
l=p->line;
while(l->suivant!=q) l=l->suivant;
l->suivant=q->suivant;
free(q);
}
}
}
para rechercher_phrase(para Pa,char*M1)
{
para p;
ligne q;
p=Pa;
if(Pa!=NULL){
while(p!=NULL){
q=p->line;
if(!strcmp(q->info,M1))
return(p);
p=p->suivant;
}
return NULL;
}
return NULL;
}
156
l^.suivant:=q^.suivant;
end;
dispose(q);
end;
end;
function rechercher_phrase(Pa:para;M1:string):para;
var p:para;
q:ligne;
trouve:boolean;
begin
p:=Pa;
trouve:=false;
if p<>nil then
begin
while(p<>nil) and (not trouve)do
begin
if(p^.line^.info=M1) then
begin
rechercher_phrase:=p;
trouve:=true;
end
else
p:=p^.suivant;
end;
end;
void inserer_phrase(para Pa,ligne l,char*M1)

{
para p,q,r;
if(Pa!=NULL){
q=(para)malloc(sizeof(str2));
q->line=l;
q->suivant=NULL;
p=rechercher_phrase(Pa,M1);
if(p!=NULL){
q->suivant=p->suivant;
p->suivant=q;
}
else{
r=Pa;
while(r->suivant!=NULL) r=r>suivant;
r->suivant=q;
}
}
}
void supprimer_phrase(para&Pa,ligne l)
{
para p,q,m;
ligne r;
157
end;
procedure inserer_phrase ( Pa:para ; l:ligne ;
M1:string);
var p,q,r:para;
begin
if Pa<>nil then
begin
new(q);
q^.line:=l;
q^.suivant:=nil;
p:=rechercher_phrase(Pa,M1);
if p<>nil then
begin
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;
p=rechercher_phrase(Pa,l->info);
if(p==Pa){
Pa=p->suivant;
free(p);
}
else{
q=Pa;
while((q!=NULL)&&(q->line!=p->line)){
m=q;
q=q->suivant;
}
if(q!=NULL){
m->suivant=q->suivant;
free(p);
}
}
}
158
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.
159
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
{
if A<>nil then
if(A!=NULL){
begin
postordre(A->g);
postordre(A^.g);
postordre(A->d);
postordre(A^.d);
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
{
if A<>nil then
if(A!=NULL){
begin
ordre(A->g);
160
ordre(A^.g);
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
{
if A<>nil then
if(A!=NULL){
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(Arecherche:=recherche(A^.g,x)
>g,x));
else recherche:=recherche(A^.d,x);
else return(recherche(A->d,x));
end
}
else recherche:=nil;
}
end;
else return NULL;
}
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));
161
new(N);
N^.cle:=x;
N^.g:=nil;
N^.d:=nil;
if A=nil then A:=N
else
begin
if x<A^.cle then insertion(A^.g,x)
else insertion(A^.d,x);
end;
end;
p->cle=x;
p->g=NULL;
p->d=NULL;
if (A==NULL) A=p;
else{
if(A->cle>x) insertion(A->g,x);
else insertion(A->d,x);
}
}
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;
162
pg:=pt;
pt:=pt^.g;
end;
pg^.g:=A^.g;
A:=A^.d;
end
else A:=A^.g;
end
else
if x=A^.g^.cle then
begin
pt:=A^.g^.d;
if pt<>nil then
begin
while pt<>nil do
begin
pg:=pt;
pt:=pt^.g;
end;
pg^.g:=A^.g^.d;
A^.g:=A^.g^.d;
end
else A^.g:=A^.g^.g;
end
else
if x=A^.d^.cle then
A=A->d;
}
else A=A->g;
}
else if(x==A->g->cle){
pt=A->g->d;
if(pt!=NULL){
while(pt!=NULL){
pg=pt;
pt=pt->g;
}
pg->g=A->g->d;
A->g=A->g->d;
}
else A->g=A->g->g;
}
else if(x==A->d->cle){
pt=A->d->g;
if(pt!=NULL){
while(pt!=NULL){
pd=pt;
pt=pt->d;
}
pd->d=A->d->d;
A->d=A->d->g;
}
163
begin
pt:=A^.d^.g;
if pt<>nil then
begin
while pt<>nil do
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);
else A->d=A->d->d;
}
else{
if(x<A->cle) 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>
164
end;
etud=record
Nom,Prn:string[20];
CIN:string[10];
Date_Nais:Date;
End;
Var FEtud:File of etud;
Procedure Affich_formul(Titre:String);
Begin
TextBackground(Blue);
ClrScr;
TextColor(Yellow);
Gotoxy(35,4);
Write(Titre);
Gotoxy(20,7);
Write('Nom :');
Gotoxy(20,9);
Write('Prnom :');
Gotoxy(20,11);
Write('C.I.N :');
Gotoxy(20,13);
Write('Date de Naissance :');
End;
Procedure saisie(Var E:Etud);
typedef struct{
int J,M,A;
}date;
typedef struct{
char nom[20];
char prn[20];
char cin[10];
date date_nais;
}etudiant;
void affich_formul(char *titre)
{
clrscr();
textcolor(YELLOW);
gotoxy(35,4);
cprintf("%s",titre);
gotoxy(20,7);
cprintf("Nom :");
gotoxy(20,9);
cprintf("Prenom :");
gotoxy(20,11);
cprintf("C.I.N :");
gotoxy(20,13);
cprintf("Date de naissance :");
}
165
Begin
TextColor(White);
Begin
Gotoxy(26,7);
Clreol;
Readln(Nom);
Gotoxy(29,9);
Clreol;
Readln(Prn);
Gotoxy(28,11);
Clreol;
Readln(CIN);
Gotoxy(40,13);
Clreol;
Readln(J);
Gotoxy(42,13);
Write('/');
Readln(M);
Gotoxy(45,13);
Write('/');
Readln(A);
End;
End;
void saisie(etudiant &E)

{
textcolor(WHITE);
gotoxy(26,7);
clreol();
scanf("%s",E.nom);
gotoxy(29,9);
clreol();
scanf("%s",E.prn);
gotoxy(28,11);
clreol();
scanf("%s",E.cin);
gotoxy(40,13);
clreol();
scanf("%d",&E.date_nais.J);
gotoxy(42,13);
clreol();
cprintf("/");
scanf("%d",&E.date_nais.M);
gotoxy(45,13);
cprintf("/");
clreol();
scanf("%d",&E.date_nais.A);
}
Procedure Ajout;
166
Var E:Etud;
Rep:Char;
Begin
Assign(Fetud,'C:\Gestion');
{$I-}
Reset(Fetud);
{$I+}
If IOResult<>0 Then Rewrite(Fetud)
Else Seek(Fetud,FileSize(Fetud));
Affich_formul('S A I S I E');
Repeat
Saisie(E);
Write(Fetud,E);
TextColor(Yellow);
Gotoxy(45,17);
Write('Voulez-vous continuez (O/N)?');
Rep:=readkey;
Gotoxy(45,17);
Clreol;
Until Rep In ['N', 'n'];
Close(Fetud);
End;
Procedure Affich(Var E:Etud);
Begin
TextColor(White);
void ajout()
{
etudiant E;
int rep;
FILE*Fetud=fopen("Gestion","ab");
affich_formul("SAISIE");
do{
saisie(E);
fwrite(&E,sizeof(etudiant),1,Fetud);
textcolor(YELLOW);
gotoxy(45,17);
cprintf("voulez_vous continuez(o/n)?");
clreol();
flushall();
rep=getchar();
}while(rep=='o' || rep=='O');
fclose(Fetud);
}
void affich(etudiant &E)
{
textcolor(WHITE);
gotoxy(26,7);
clreol();
cprintf("%s",E.nom);
gotoxy(29,9);
clreol();
167
Begin
Gotoxy(26,7);
Clreol;
Write(Nom);
Gotoxy(29,9);
Clreol;
Write(Prn);
Gotoxy(28,11);
Clreol;
Write(CIN);
Gotoxy(40,13);
Clreol;
Write(J,'/',M,'/',A);
End;
End;
Procedure Affichtout;
Var E:Etud;
Rep:Char;
I:Integer;
Begin
{$I-}
Reset(Fetud);
{$I+}
cprintf("%s",E.prn);
gotoxy(28,11);
clreol();
cprintf("%s",E.cin);
gotoxy(40,13);
clreol();
cprintf("%d/%d/%d",E.date_nais.J,
E.date_nais.M,E.date_nais.A);
}
void affichtout()
{
etudiant E;
FILE*Fetud=fopen("Gestion","rb");
if (Fetud==NULL) return;
affich_formul("CONSULTATION");
do{
fread(&E,sizeof(etudiant),1,Fetud);
affich(E);
textcolor(YELLOW);
gotoxy(45,17);
cprintf("Tapez une Entree pour
continuer");
getch();
gotoxy(45,17);
}while(!feof(Fetud));
168
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()
169
Var N: Integer;
E:Etud;
Begin
{$I-}
Reset(Fetud);
{$I+}
If IOResult<>0 Then write('Probleme de lecture !!!!')
Else
Begin
ClrScr;
Write('Donner le numero d''ordre de l''etudiant a
modifier');
readln(N);
Seek(Fetud,N-1);
Read(Fetud,E);
With E do
Begin
Write('Nom : ',Nom);
Readln(Nom);
Write('Prnom : ',Prn);
Readln(Prn);
Write('C.I.N : ',CIN);
Readln(CIN);
End;
Seek(Fetud,N-1);
{
int i;
char*CIN;
char nom[20],prn[20],cin[10];
int J,M,A;
etudiant E;
etudiant *Et;
FILE*Fetud=fopen("Gestion","rb");
FILE*f=fopen("tmptmp.$$","wb");
textcolor(YELLOW);
clrscr();
if(Fetud==NULL) return;
cprintf("Donnez le C.I.N de l'etudiant a modifier:
");
scanf("%s",CIN);
getch();
i=fread(&E,sizeof(etudiant),1,Fetud);
while((strcmp(E.cin,CIN))&&(i!=0)){
fwrite(&E,sizeof(etudiant),1,f);
}
if(!strcmp(E.cin,CIN)){
etudiant
*Et=(etudiant*)malloc(sizeof(etudiant));
cprintf("Nom : %s ",E.nom);
170
Write(Fetud,E);
Close(Fetud)
End;
End;
scanf("%s",nom);
strcpy(Et->nom,nom);
cprintf("Prenom : %s ",E.prn);
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);
}
while(i!=0){
fwrite(&E,sizeof(etudiant),1,f);
}
fclose(f);
fclose(Fetud);
171
remove("Gestion");
rename("tmptmp.$$","Gestion");
}
172
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.
173
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
0
1
2
3
Couleur
Noir
Bleu
Vert
Cyan
N
4
5
6
7
Couleur
Rouge
Magenta
Brun
Gris clair
N
8
9
10
11
Couleur
Gris fonc
Bleu clair
Vert clair
Cyan clair
N
12
13
14
15
Couleur
Rouge clair
Magenta
Jaune
Blanc
174
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.
175
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.
176

100exercices en Pascal Amp C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

100exercices en Pascal Amp C

Transféré par

Droits d'auteur :

Formats disponibles

Ecole Normale Suprieure

Encadr par : Mr.Brahim

ENS Rabat Dpartement dInformatique

Un programme informatique se compose dune srie dinstructions, qui sont

ENS Rabat Dpartement dInformatique

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

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

LMENTS DE BASE DUN

I- Structure dun programme

USES. Les identificateurs des bibliothques sont spars par des

lutilisateur, prcde par le mot rserv TYPE.

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

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

variables et suivie du point virgule ;.

II- Types de donnes

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

Syntaxe : Var <identificateur> : <type>;

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

const <type> <identificateur> = valeur ;

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

II-2. Les types de base

Entiers sur 1 Bit

Extended Nombres rels

ENS Rabat Dpartement dInformatique

'Hello!'; 'Allezvous bien ?'

Elments de base dun programme en Pascal et en C

Plage de valeurs accepte

0 4 294 967 295

II-3. Crer un type de donnes

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

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

III- Oprateurs et expressions

Elments de base dun programme en Pascal et en C

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

Remarque : (+) et (-) deux oprateurs unaires.

Elments de base dun programme en Pascal et en C

- NOT oprateur unaire, NOT oprateur de ngation.

Remarque : L'oprateur modulo ne peut s'appliquer qu' deux entiers, le rsultat

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

Remarque : Les oprateurs d'galit et logiques ne doivent pas s'appliquer sur

Syntaxe : <variable> OP ou OP <variable>

Cet oprateur ncessite trois oprandes et s'apparente un "si".

Elments de base dun programme en Pascal et en C

Loprateur sizeof fournit

ENS Rabat Dpartement dInformatique

Elments de base dun programme en Pascal et en C

IV- Instructions simples

Elments de base dun programme en Pascal et en C

scanf (format, liste_dadresses)

Format : constante chane (entre ""),

Liste_dadresses : liste de "lvalue", spares par des virgules, dun type en

Elments de base dun programme en Pascal et en C

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

IV-2. Instructions de sortie

printf (format, liste_dexpressions)

Format : constante chane (entre ""),