Cours Algorithmique Et Programmation 4 Si (Full Permission)

REPUBLIQUE TUNISIENNE
MINISTERE DE L’EDUCATION ET DE LA FORMATION
Cours Algorithmique & Programmation

4ème Science informatique
Exercices et sujets bac corrigés
Prof : Mr. Chraiet Khaled

Lycée El Hawaria (Nabeul)
2014-2015
Edition 2.1
A tous les lecteurs : afin de réussir ce travail n’hésitez pas de me signaler tout type d’erreurs ou de fautes.
e-mail : khaledchraiet@yahoo.fr
Facebook : www.facebook.com/khaled.chraiet.3
1
Chap I Les enregistrement et les fichiers
Rappel du cours de 2ème et 3ème
I- Les types de données:

Algorithme Pascal Valeur Longueur
Octet Byte 0..255 Unsigned 8-bit
Mot Word 0..65535 Unsigned 16-bit
Shortint -128..127 Signed 8-bit
Entier Integer -32768..32767 Signed 16-bit
Longint -2147483648..2147483647 Signed 32-bit
real 2.9e-39..1.7e38 6 Octets
single 1.5e-45..3.4e38 4 Octets
Réel 8 Octets
Double 5.0e-324..1.7e308
extended 3.4e-4932..1.1e4932 10 Octets
caractère Char 'a'..'z','A'..'Z','*','-','(','?','0'..'9' 8 bits
Chaîne String 'Tunisie','info'… 0..255 caractères
booléen boolean Vrai / Faux 1 octet
II- Les actions élémentaires:
Action Algorithme Turbo Pascal

Read (var)
Lecture Lire ( var)
Readln(var)
write(’texte’, var)
Affichage Ecrire (" texte ", var)
writeln(’texte’, var)
Affectation  :=
III- Les structures conditionnelles :

Structure Conditionnelle Structure Conditionnelle
Simple à choix multiple
Si <conditions> Alors Selon <Var> Faire
Traitement 1 Val1 : Action1
Sinon Val2 : Action 2
En algorithme Traitement 2 Val3,val4 : Action 3
FinSi Sinon
Action N
Fin Selon
if <conditions> Then Case <Var> of
begin Val1 : Action1
Traitement 1 ; Val2 : Action 2
End Val3,val4 : Action 3
En Pascal
Else Else
begin Action N
Traitement 2 ; End ;
End ;
2
Rappel cours de 2ème et 3ème
IV- Les structures répétitives :
Structure itérative Structure itérative à condition d'arrêt

Complète Au moins une fois Peut être aucune fois
Init <conditions>
Répéter Init <conditions>
Pour <compteur> de Vi à Vf Faire Tant que <conditions> Faire
Les instructions à répéter
Les instructions à répéter Les instructions à répéter
En
algorithme Fin Pour Jusqu'à <conditions> Fin Tant que
………… ………… ……….. ;{init}

……….. ;{init} ……….. ;{init} While <conditions> Do
For <compteur> : = Vi to Vf Do Repeat begin
Begin ……. ; ………. ;
En Pascal …; {suite d’instructions à {suite d’instructions à répéter}
{suite d’instructions à répéter} répéter} End ;
……….. ; Until <condition-arrêt> ;
End ;
Forme générale d’un programme Pascal
Program nom_prog ;
Uses wincrt ; { une bibliothèque}
Const
Déclaration des constantes
Type
Déclaration des nouveaux types
Var
Déclaration des variables globales
Procedure Nom-proc (liste des paramètres formels)

Var
Déclaration des variables locales
Begin
{Corps de procédure}
End ;
Function nom-fonct (liste des paramètres formels) : type-résultat

Var
Déclaration des variables locales
Begin
{Corps de la fonction}
End ;
{***************** programme principal ************************}
Begin
Corps du programme
Nom-proc (liste des paramètres effectifs) //appel d’une procédure
Nom-var : = nom-fonct (liste des paramètres effectifs) // appel d’une fonction
End.
3
 Les fonctions arithmétiques standard:

(Uses transcend: bibliothèque mathématique)
Nom en Code en Rôle Type du Type du Exemples

algorithme Pascal paramètre résultat
Supprime la partie décimale Entier ou Réel entier Trunc(3.14) vaut 3
Tronc(x) Trunc(x) pour ne laisser que la Trunc(3.50) vaut 3
composante entière de x Trunc(-8.575) vaut -8
Donne un entier qui est la Entier ou Réel entier Round(9.499) vaut 9
Arrondi(x) Round(x) valeur du réel x arrondie à la Round(9.50) vaut 10
plus proche valeur Round(9.99) vaut 10
Donne la valeur absolue de x. Réel/Entier Type du Abs(-5) vaut 5
Abs(x) Abs(x)
paramètre
Donne le carré de x. Réel ou entier Type du Sqr(5) vaut 25
Carré(x) Sqr(x)
paramètre
Donne la racine carrée de x si Entier ou Réel Réel Sqrt(5) vaut 2.236..
RacineCarré(x) Sqrt(x) x n’est pas négatif et
provoque une erreur sinon
Donne le sinus de x (x en Entier ou réel Réel Sin(Pi/2) vaut 1
Sin(x) Sin(x)
radians).
Donne le cosinus de x (x en Entier ou réel Réel Cos(Pi/2) vaut 0
Cos(x) Cos(x)
radians)
Exp(x) Exp(x) Donne l’exponentielle de x. Entier ou réel Réel Exp(0.0) vaut 1
Donne le logarithme Entier ou réel Réel Ln (1.0) vaut 0
népérien de x si x est positif
Ln(x) Ln(x)
et provoque une erreur
sinon.
Renvoi la partie entière de x Entier ou réel Réel Int(5.26) vaut 5.0
Ent (x) Int (x)
Int (-5.5) vaut -5.0
Renvoi la partie fractionnaire réel réel Frac(5.26) vaut 0.26
Frac(x) Frac(x)
de x
Donne un réel aléatoire de 0 - réal
Aléa Random
à 1 exclus.
Donne un entier aleatoire de entier entier
Aléa ( n ) Random( n)
0 à n exclus
 La table de vérité:
X Y NON(x) x ET y x OU y x OUex y
FAUX FAUX VRAI FAUX FAUX FAUX
FAUX VRAI VRAI FAUX VRAI VRAI
VRAI VRAI FAUX VRAI VRAI FAUX
VRAI FAUX FAUX FAUX VRAI VRAI
4
 Les fonctions prédéfinies sur les caractères sont :
Nom Code en Pascal Rôle Exemple

ORD(c) ORD(c) Renvoie le code ASCII du caractère c. le ORD("A") vaut 65
résultat est un entier positif. ORD("a") vaut 97
CHR(n) CHR(n) Renvoie le caractère dont le code ASCII est n. CHR(65) vaut "A"
CHR(97) vaut "a"
SUCC(c) SUCC(c) Renvoie le caractère successeur de c s’il existe SUCC("C") vaut "D"
SUCC("2") vaut "3"
PRED(c) PRED(c) Renvoie le caractère prédécesseur de c s’il PRED("C") vaut "B"
existe PRED("2") vaut "1"
MAJUS(c) UPCASE(c) Convertit le caractère c en majuscule s’il est MAJUS("d") vaut "D"
possible
 Les fonctions et les procédures standards sur les chaînes de caractères
Nom En Pascal rôle Exemple

Fonction qui retourne la
Concat(ch1,ch2,… , chN) CONCAT(ch1, ch2,… chN) concaténation des chaînes "Bac"+"2007" ="Bac2007"
ch1, ch2, …, chN
Fonction qui retourne un
entier représentant la Ch"Bac" , Long(ch)=3
Long(ch) LENGTH ( ch )
longueur en caractères de la Long("Bac 2007")=8
chaîne ch.
Fonction qui retourne une
sous-chaîne d’une longueur
Sous_Chaîne ( ch , p , nbc ) COPY ( ch , p , nbc ) Sous_chaîne("Bonjour",1,3)= "Bon"
nbc à partir de la position p
dans ch.
Fonction qui retourne la
position de la chaîne ch1 Pos("bo","Bonbon")=4
Pos ( ch1 , ch2 ) POS ( ch1 , ch2 ) dans la chaîne ch2, si ch1
n’est pas dans ch2, elle Pos("ON","Bonbon")=0
retourne 0.
Procédure qui enlève n
Ch "Toujour"
Efface ( ch , p , n ) DELETE ( ch , p, n ) caractères de ch à partir de
Efface(ch,1,3)  ch devient "jour"
la position p.
Procédure qui insère la
chaîne ch1 dans la chaîne ch1  "Ben " ch2  "Ali Hmida"
ch2 à partir de la position p. Insère(ch1,ch2,5)
Insère ( ch1 , ch2 , p ) INSERT ( ch1 , ch2 , p )
le caractère numéro p et les
suivants sont décalés vers la  ch2 devient "Ali Ben Hmida"
droite.
Procédure qui convertit un
nombre décimal d en chaîne
Convch ( d, ch ) STR ( d , ch )
de caractère et l’affecte à la Convch(2008,ch)  ch="2008"
variable ch
Procédure qui convertit une
chaîne en une valeur
numérique décimale et
l’affecte à la variable d. le
Valeur("2008",d,e)
paramètre erreur est une
 d=2008 et e=0 (pas d’erreur)
variable de type entier qui
Valeur ( ch , d , erreur) VAL ( ch , d , erreur ) Valeur("15 Mars 2008",d,e)
contiendra 0 si la conversion
 d=0 et
s’est déroulée sans erreur,
e=3 (position de l’erreur)
sinon elle contiendra le
numéro (la position du
caractère qui a déclenché
l’erreur).
5
Les enregistrements et les fichiers
6
Les enregistrements et les fichiers

Objectifs :
• Définir la structure enregistrement.
• Définir les fichiers et les modes d’accès
• Mettre à profit les structures enregistrement et fichiers pour résoudre des problèmes.
Rappel:
En rappel que en 2ème et en 3ème année nous avons vu dans le cours de programmation qu'une donnée
(ou information) peut être que de valeur constante ou de valeur variable et on peut la stocker ou la
garder dans :
• Une constante: si sa vaaleur est stable
• Une variable: si sa valeur change au cour de programme.
• Un tableau: si on a plusieur valeur de même nature.
Donc les structures de données utilisée en 2ème et en 3ème sont:
• Les constantes
• Les variables
• Les tableaux
Question : Est ce que ces informations seront enreistrer d’une façon temporaire ou permanent ?
Réponse : Temporaire car sont enregistrer dans la RAM.
A- Les enregistrements
I- Introduction :
Activité 1:
Un établissement scolaire utilise une application informatique pour saisir, manipuler, et
mémoriser les informations concernant ses élèves (exemple des informations).
Numéro Nom Prénom sexe moyenne
1000 cherni Sihem F 14.25
1001 Barhoumi Mourad M 12.75
1030 Dziri Fahmi M 16.50
Question :
Afin d’écrire ce programme proposer une structure de donnée adéquate a ce problème.
Réponse :
1- Utiliser des variables simples :
Num : pour numéro
Nom : pour nom
Moy : pour la moyenne

Cette proposition valable peut être que pour un seul élève.
2- Utiliser les tableaux : on propose un tableau pour chaque colonne ( ou champs)
- Un tableau pour les Numéros NU 1000 1001 …. …. 1030
- Un tableau pour les noms Cherni Barhoumi …. …. Dziri
7
- Un tableau pour les prénoms

- Un tableau pour les moyennes
Cette proposition à plusieurs anomalies : d’abord elle nécessité beaucoup d’espace
mémoire qui est le plus couteux. De plus a chaque modification dans un tableau doit être
suivit obligatoirement par modification de tous les tableaux pour assurer la cohérence des
informations de chaque élève.
3- Utiliser une nouvelle structure : pour rendre le traitement plus facile on doit grouper
toutes les informations concernant un élève dans une seule structure (qui est impossible
pour un tableau) cette nouvelle structure s’appelle Enregistrement ou Article( en Pascal
s’appelle Record).
On la représente comme suite :
Num Nom Prénom Sexe Moy

(Entier) (Chaine) (Chaine) (caractère) (Réel)
Une seule entité qui s’appelle enregistrement : E
On désigne par : E.Num : un champ qui représente le Numéro

E.Nom : un champ qui représente le Nom
E.Prenom : un champ qui représente le prénom
.
.
E.Moy : un champ qui représente la moyenne
En général :
Champ 1 Champ 2 Champ 3 Champ 4 Champ 5

(type 1) (type 2) (type 3) (type 4) (type 5)
Une seule entité d’une variable enregistrement
Nous venons de voir que les variables simples ou les tableaux ne permettent pas de ranger des
données de types différents.
Si nous voulons établir par exemple une structure comportant en même temps des informations
alphanumériques, numériques, nous devons créer un nouveau TYPE qui permet de les regrouper.
II- Définition et déclaration:

Un enregistrement ou Article (record) est un type de donnée structuré défini par
l'utilisateur qui permet de regrouper un nombre fini des données (champs) de différents types
(alphabétique, numérique, logique,...) sous un nom commun.
Contrairement aux tableaux qui ne permettent de grouper que des éléments du même type, les
enregistrements nous permettent de combiner différents types de données.
8
Déclaration d’une structure enregistrement :

T.D.N.T
Type
Nom_type = Enregistrement
Champ 1 : Type 1
Champ 2 : Type 2 T.D.O
Objet Type/Nature Rôle
Champ 3 : Type n Nom_var Nom_type Enregistrement pour …..

Fin Nom_type
En Pascal
Type
Nom_type = Record
Champ1 : type1 ;
Champ2 : type2 ;
.
.
Champn : type n ;
End ;
Var
Nom_var : Nom_type ;
N.B :
Les types (type1, type2,…, type n) peuvent être soit prédéfinit (entier, réel, booléenne…),
soit définis par l’utilisateur (tableau, semaine,…)
Applications :
Proposer une structure de données adéquate pour chaque objet :
1. Chaque étudiant doit présenter les informations suivantes : CIN (entier), Nom et prénom
(chaine de longueur max 35 cc), date de naissance (sou la forme jj/mois/aaaa), sexe (M/F),
Discipline (chaine), nom de l’établissement (chaine).
2. Chaque voiture a vendre doit possède les informations suivantes : Matricule (chaine),
Marque (chaine), Modèle (chaine), année de modèle, km parcouru, (prix de vente).
3. Chaque médicament dans une pharmacie doit avoir les informations suivantes : Référence,
nom commercial, date de fabrication, durée de validité, et le prix.
4. Dans une annonce publicitaire on trouve la liste suivante des téléphones à vendre.
Référence Marque Modele Prix (€ )
1000 Nokia C2-05 35
1001 Nokia Asha 302 114
1002 Samsung Galaxy S III Mini 250
1003 Sony Xperia Z 407
III- Tableau (Vecteur) d’enregistrement

Activité 2 :
Même activité 1 mais dans le cas ou il y a plusieurs élève (n).
Réponse
Dans le cas ou il ya plusieurs élèves on peut utiliser les tableaux. Chaque case du tableau comporte
un enregistrement. On appelle donc ce tableau, tableau d’enregistrement.
9
Pour n élèves
Num Nom Prénom Sexe Moy Num Nom Prénom Sexe Moy …… Num Nom Prénom Sexe Moy
1 2 …… n
Pour accéder aux informations de l’élève N° 2 on écrit :

T [ 2 ] . Num : pour accéder au Numéro
T [ 2 ] . Nom : pour accéder au nom
T [ 2 ] . Moy : pour accéder au moyenne
Déclaration :
T.D.N.T
Type
Fiche = Enregistrement
Num : entier
Nom : chaine T.D.O
Prénom : chaine Objet Type/Nature Rôle
Sexe : caractère EEL Fiche Enregistrement pour définir un élève
Moy : réel T Tab Tableau de 50 enregistrements d’élèves
Fin fiche
Tab = Tableau [1 .. 50 ] de Fiche
IV- Utilisation des enregistrements:

Rappel sur l’utilisation d’une variable simple
Pour une variable simple on peut faire les actions suivantes :
- La lecture (lire (var))
- L’écriture (écrire (var))
- L’affectation ( var  valeur )
Même chose pour un enregistrement on peut faire la lecture l’affectation et l’écriture mais
autrement
a) La lecture d’un enregistrement :
Puisque l’enregistrement est composé par plusieurs champs la lecture ce faire champs par
champs
Exemple : pour faire la lecture de l’enregistrement EEL
Ou on peut écrire : Et en Pascal :

AVEC EEL Faire With EEL DO
Lire ( EEL. Num) Lire ( Num ) begin
Lire ( EEL . Nom) Lire ( Nom ) readln ( Num ) ;
Lire ( EEL.Prenom) Lire ( Prenom ) readln ( Nom ) ;
Lire ( EEL .sexe ) Lire ( Sexe ) readln ( Prenom );
Lire ( EEL . Moy ) Lire ( Moy ) readln( Sexe );
Fin avec readln ( Moy ) ;
end ;
10
Syntaxe
Au niveau de l’analyse Au niveau de l’algorithme Au niveau du pascal

Venrg.champ = Donnée Lire (venrg.champ) Readln( venrg.champ)
La structure : Avec… Faire
An niveau de l’analyse et de l’algorithme An niveau du Pascal
Avec venrg Faire With venrg Do

Ensemble d’actions Begin
Fin Avec Ensemble d’actions
End;
b) L’écriture ou l’affichage :
Même que la lecture on affiche le contenu d’un enregistrement champ par champ.
Exemple : pour faire l’affichage de l’enregistrement EEL. On écrit
Ou on peut écrire : Et en Pascal on écrit :
Ecrire ( EEL. Num) AVEC EEL Faire With EEL DO

Ecrire ( EEL . Nom) Ecrire ( Num ) begin
Ecrire ( EEL.Prenom) Ecrire ( Nom ) writeln ( Num ) ;
Ecrire ( EEL .sexe ) Ecrire ( Prenom ) writeln ( Nom ) ;
Ecrire ( EEL . Moy ) Ecrire ( Sexe ) writeln ( Prenom );
Ecrire ( Moy ) writeln( Sexe );
Fin avec writeln ( Moy ) ;
end ;
Syntaxe :
Au niveau de l’analyse et l’algforithme Au niveau du Pascal

Ecrire (venrg.champ) Writeln (venrg.champ)
c) L’affectation
1. on peut affecter une valeur a un champ de l’enregistrement
Exemple :
EEL. Num  1000 Avec EEL faire

EEL . Nom  ‘Barhoumi’ Num  1000
EEL.Prenom)  ‘Mourad’ Nom  ‘Barhoumi’
EEL .sexe  ‘M’ Prenom  ‘Mourad’
EEL . Moy  15.25 sexe  ‘M’
Moy  15.25
Fin avec
11
2. on peut aussi affecter un enregistrement E2 a un enregistrement E1. Si les deux de même

type (c.a.d qui ont le même nombre de champs et de même rang de type).
On ecrit donc :
E1  E2
Chaque champ de E1 va recevoir son homologue de E2.
Exemple :
Soit E1, E2 de type Fiche.
On peut écrire :
E1  E2 c.a.d E1.Num  E2.Num ; E1.Nom  E2.Nom, …, et E1.moy  E2.moy
Application :
Dans un établissement scolaire, un élève est identifié par : son matricule (entier), son nom
et prénom (chaine) et sa moyenne (réel).
On se propose d’écrire un programme modulaire permettant de saisir les informations de
N élèves (N<=50) et d’afficher la liste des élèves classé par moyenne (dans l’ordre décroissant).
B- Les fichiers
I- Introduction :
Notons que les constantes, les variables simples, les tableaux et même les enregistrements perdre
leurs contenus dé qu’on ferme le programme en cours d’exécution et sur tout lorsque en éteindre
l’ordinateur puisque ils font partie de la mémoire centrale (RAM). Or dans le plus part des cas on a
besoin de conserver les informations dans des supports de stockage magnétique, ce qui nécessite
l'utilisation des fichiers.
II- Définition :
Un fichier est un ensemble structuré de données de même type, nommé et enregistré sur un
support physique par l’ordinateur ( disque dur, flash disk, CD, DVD,…).
Un fichier peut contenir des caractères (fichiers textes), des programmes, des valeurs (fichiers des
données). Donc On distingue deux types de fichiers :
• Fichiers de données ou typés : se sont des fichiers contenant du code binaire

représentant chaque élément (enregistrement). Ces fichiers ne doivent être manipulés
que par des programmes! (fichier des entiers, fichier de réels, fichier de caractères, mais
généralement fichier d’enregistrements).
• Fichiers textes : (appelés aussi imprimables) contenant des caractères et susceptibles
d'être lus, éditées, imprimés... (généralement on peut l’éditer par un logiciel éditeur de
texte)
N.B :
• La taille d’un fichier peut être quelconque, la seule limitation étant la taille de la mémoire
auxiliaire.
• La fin de fichier est matérialisée par un caractère spécial qui sert de marqueur.
12
III- Organisation et accès :

Les blocs de données formant un fichier sont enregistrer les uns à la suite des autres de façon
linéaire comme indiqué dans le schéma suivant :
Bloc 1 Bloc 2 Bloc 3 Bloc 4 Fin

Enregistrement Enregistrement Enregistrement ……………… Enregistrement fichie
0 1 2 (n-1)
Pointeur
Pour accéder (lire/ modifier) a un bloc (enregistrement) nous devons tout d’abord le localiser c.a.d
le pointer (faire référence).
Organisation séquentielle Organisation relative
L’organisation d’un fichier est la manière dont sont rangés les enregistrements du fichier sur le
support physique.
L’organisation est choisie à la création du fichier (rapidité d’accès et espace mémoire).
Il existe plusieurs types d’organisations des fichiers. Les plus importants sont :
• L’organisation séquentielle : elle ne permet qu’un seul accès le séquentiel (pour accéder
un enregistrement on doit passer par les enregistrements qui le précède).
• L’organisation relative (directe) : les enregistrements sont contigus (touche l’un l’autre) et
identifiés par un numéro d’ordre. L’indication d’un numéro permet donc un accès direct à
l’information ainsi référencée.
IV- Les fichiers typés:
1. Déclaration d’un fichier :

En analyse :
T.D.N.T T.D.O
Type Objet Type/nature Rôle
Nom_fichier = Fichier de type_composants Nom_logique Nom_fichier Fichier pour….
Le type_composants représente le type des composants du fichier, ces composants

doivent être de même type, exemple : entier, réel, enregistrement, etc
13
En pascal
Program test ;
Uses wincrt ;
Type
Nom_fichier = File of type_composants ;
Var
Nom_logique : nom_fichier;
Exemple :
T.D.N.T
Type
fentier = Fichier d’entier
Feleve = fichier de fiche
T.D.O
Objet Type/nature Rôle
Fent Fentier Fichier des entiers
Fel Feleve Fichier pour les fiches élèves
V- Les fichiers a accès séquentiel :

1- Association (ou Assignation) :
Permet la liaison entre le nom logique (ou nom interne) et le nom physique (ou
nom externe) du fichier.
Remarque :
• Le nom interne (ou nom logique) correspond au nom utilise dans le
programme. C'est donc l'identificateur déclare comme variable (ex : var f :
file of ...).
Il s'agit donc du nom de fichier vu par le programmeur et par le programme Pascal.
• Le nom externe (ou nom physique) représente quant a lui le nom utilise sur
le disque, visible dans le répertoire (dossier ou directory).
Il s'agit donc du nom de fichier vu par l'utilisateur et par le système d'exploitation.
Syntaxe :
En analyse et en algorithme En Pascal
Associer (nom logique, nom physique ) ASSIGN (nom logique, nom physique )
14
Exemple:
Soit la declaration suivante:
Type
Eleve = fichier de fiche
Var
Fel : Eleve
Soit les instructions suivantes:
Nom interne Nom externe

En algorithme
Associer ( fel , ‘’ c : \4si\scolaire.dat’’)
En Pascal
Assign ( fel , ‘ c : \4si\scolaire.dat ‘)
2- Ouverture d’un fichier
Après l’association, nous pouvons maintenant ouvrir le fichier soit en lecture, soit
en écriture ou en réécriture.
a- Ouverture et création :
A l’aide de l’instruction « Recréer » on peut créer un fichier s’il n’existe pas, ou
ouvrir et effacer son contenu s’il existe déjà et de remettre son pointeur a zéro
Syntaxe :
Recréer (nom logique ) Rewrite ( nom logique )
b- Ouverture et remise à zéro :

Pour ouvrir un fichier existant et repositionner ou remettre à zéro son pointeur on
utilise la commande « ouvrir (Reset )»
Syntaxe :
Ouvrir (nom logique ) Reset ( nom logique )
3- Ecriture dans un fichier

Pour ajouter ou modifier une valeur ou un enregistrement dans un fichier on utilise
la commande « Ecrire ( write) »
Syntaxe :
Ecrire (nom logique , variable ) Write( nom logique , variable )
15
Application :
Toujours avec la même activité, un élève est identifié par :
Son numéro, son nom et son prénom et sa moyenne
Ecrire une suite d’instruction permettant de saisir les informations de n élèves dans un fichier
scolaire.dat.
Solution
Associer ( fel , ‘C:\4si3\scolaire.dat’) Association entre le nom logique fel le nom
physique c:\4si3\scolaire
Recréer ( fel ) Création et ouverture du fichier en mode écriture
Ecrire (' Entrer le nbre des élèves),
Lire (n) Determiner le nombre des élèves
Pour i de 1 à n faire
Avec EEl faire
Ecrire (‘entrer le numero’),lire(num)
Ecrire(‘entrer le nom ‘), lire (nom)

Remplir l’enregistrement
Ecrire (entrer le prenom ‘), lire (pr)
Ecrire (‘entrer la moyenne : ‘), lire( moy)
Fin avec
Ecrire ( fel , EEl )

Ecriture de l’enregistrement dans le fichier
Fin pour
4- Lecture à partir d’un fichier :

La lecture d’une valeur ou d’un enregistrement du fichier se fait par l’instruction
« lire »
Syntaxe :
lire (nom logique , variable ) Read ( nom logique , variable )
Lire( Fcl , Ecl) Read( Fcl , Ecl ) ;
16
5- Fermeture d’un fichier

A la fin du traitement, nous devons fermer le (ou les) fichier(s) ouvert(s)
Syntaxe :
Fermer (nom logique ) Close( nom logique )
6- Test de fin du fichier

Pour tester si la fin de fichier est atteinte ou non on utilise la commande « Fin_fichier » qui
est une fonction booléenne qui retourne vrai si la fin de fichier est atteinte et faux si non.
Syntaxe :
Fin_Fichier (nom logique ) EOF( nom logique )
VI- Les fichiers à accès direct :

Dans les fichiers à accès direct les enregistrements sont numérotés a partir de zero. Ce qui
fait que pour accéder au nème élément il faut se positionner sur le n-1ème enregistrement.
1- Positionner sur un enregistrement :
Syntaxe :
Pointer (nom logique , numéro ) Seek ( nom logique , numéro )
2- Savoir la taille du fichier

Pour savoir combiens d’éléments se trouvent dans le fichier on peut utiliser la
commande « Taille_Fichier (FileSize) ».
Syntaxe :
Taille_Fichier (nom logique ) FileSize( nom logique )
17
VII- Autres fonctions et procédures prédéfinies

Ces fonctions et ces procédure sont valable aussi bien pour l’accès direct que l’accès
séquentiel.
1- Position actuel de pointeur :
Syntaxe :
Position_fichier (nom logique ) FilePos( nom logique )
Fonction qui fournit le numéro d’ordre (la position) de l’élément sur le quel se trouve le
pointeur du fichier.
Application :
Signe fin
Soit le fichier F qui contient les enregistrements suivants : Fichier
Enreg 0 Enreg 1 Enreg 2 Enreg 3 Enreg 4 Enreg 5
Pointeur
- Pour savoir le nombre d’enregistrement dans ce fichier on écrit :
Taille_Fichier ( F )  renvoi 6 c.a.d il existe 6 enregistrements.
- Pour savoir la position actuelle du pointeur on écrit :
Position_Fichier (F)  Renvoi 3 c.a.d enregistrement N° 3.
- Pour positionner le pointeur a la fin du fichier on écrit :
Pointer (F , 6 ) = Pointeur ( F , Taille_Fichier ( F ) )
- Pour positionner le pointeur sur l’enregistrement qui précède la position actuelle de pointeur
Pointer ( F , 2 ) = Pointer ( F , Position_Fichier ( F ) -1 )
2- Effacer un fichier
Syntaxe :
Effacer (nom logique ) Erase( nom logique )
3- Renommer un fichier
Syntaxe :
Renommer (ancien_nom_log , nouveau_nom_log ) Rename(ancien_nom_log , nouveau_nom_log)
18
4- Tronquer un fichier
Tronquer un fichier sa veut dire Tout ce qui se trouve au delà de la position actuelle du pointeur
sera perdu.
Syntaxe :
Tronquer (Nom_logique ) Truncate( Nom_logique )
VIII- Les fichiers texte

Un fichier texte (fichier ASCII) est un fichier dont le contenu représente uniquement une suite de
caractères.
Les fichiers textes constituent une catégorie particulière. En effet à la différence des autres fichiers,
ils contiennent des caractères
- De type retour chariot (CR)
- De fin de ligne (Eoln)
- Fin de texte (code CTRL-Z).
1. Déclaration d’un fichier texte:
En analyse : T.D.O
Objet Type/nature Rôle
Nom_logique texte Fichier texte ….
En pascal
Program test ;
Uses wincrt ;
Var
Nom_logique : text ;
Remarque :
Comme pour les autres fichiers on peut utiliser les commandes suivantes sur les fichiers
texte s: Associer, Ouvrir, Fermer, Fin_fichier, Renommer, Effacer, Tronquer
Sauf les commandes suivantes : FilePos, FileSize et Seek.
2. Tester la fin d’une ligne :
Syntaxe :
Fin_ligne (nom logique ) Eoln( nom logique )
Fonction logique qui retourne Vrai si l’on trouve sur le caractère CR (retour chariot) et Faux
dans le cas contraire.
19
3. Ajouter un élément dans un fichier texte

Syntaxe :
Ajouter (nom logique ) Append( nom logique )
Procédure qui ouvre le fichier texte et positionne son pointeur à la fin de ce dernier afin
d’ajouter un élément.
4. Lecture d’une ligne a partir d’un fichier texte

Syntaxe :
Lire_nl (nom logique , variable_ch ) Readln ( nom logique , variable_ch )
Procédure qui lit le contenu d’une ligne, puis pointe la prochaine ligne.
5. Ecriture une ligne dans un fichier texte
Syntaxe :
Ecrire_nl (nom logique , variable_ch ) Writeln ( nom logique , variable_ch )
Procédure qui introduire dans un fichier texte une ligne de type chaine puis une séquence CR-
LF pour marquer la fin de ligne.
Application 1 : (ex 1 bac blanc 2014)
Soient les tableau de déclaration des types et des objets suivants :

TDNT
Type
Etat = (Celibataire, Marie, Divorce, Veuf)
Renseignement = Enregistrement
Nom : Chaine
Num : Octet
Etat_Civil : Etat
Fin renseignement
TDO
Objet Nature /Type Rôle
F Texte
E Renseignement
B Booléen
P Octet
20
Question :
Recopier le tableau ci-dessous sur la copie de l’examen puis le complèter en mettant dans la 2ème
colonne en mettant Valide si l’instruction donnée dans la 1ère colonne est valide ou en mettant
Invalide dans le cas contraire, tout en justifiant la réponse si l’instruction est Invalide.
Instruction Valide/Invalide Justification

B  Fin_Fichier ( F )
Pointer ( F , P )
Ecrire ( F , E.Etat_Civil)
B  E.Num > 10
P  Taille_Fichier ( F )
E.Etat_Civil  Succ ( Marie )
Application 2: ( Sujet bac pratique 2010 )
On se propose d’écrire un programme qui permet de :
• Remplir un fichier nommé Nombre.dat par n chiffres aléatoires non nuls ( avec 2 < n ≤ 50 )
• Déterminer et afficher le plus petit nombre (pn) et le plus grand nombre (gn) formés par
tous les chiffres de ce fichier.
• Vérifier si les écarts entre tous les chiffres symétriques de gn forment des termes successifs
d’une suite arithmétique, dans l’affirmative, afficher sa raison ( r ).
Deux chiffres Ci et Cj de gn sont dits symétriques si leurs positions respectives i et j dans gn

vérifient : i + j = k + 1, avec k le nombre de chiffres de gn, pour tout i allant de 1 à k div 2.
N.B : Une suite U est dite arithmétique si Un = Un-1 + r
Exemple 1 : soit le fichier Nombres.dat suivant pour n = 7.
8
6
4
Le plus petit nombre (pn) est : 3446789
3
9 et le plus grand nombre (gn) est : 9876443
7
4
Les écarts 6, 4 et 3 calculés entre tous les chiffres symétriques de gn ne forment pas des
termes successifs d’une suite arithmétique. En effet U1=U0 – 2  r1 = - 2
et U2 = U 1 – 1  r2 = -1. Comme r1 <> r2 alors U n’est pas une suite arithmétique.
21
9 8 7 6 4 4 3
U2 = 7 – 4 = 3
U1 = 8 - 4 =4
U0 = 9 - 3 =6
Travail demandé :
• Décomposez le problème en modules et déduisez les analyses de chaque module.

• Déduisez les algorithmes de chaque analyse.
22
Série N° 1
Exercice N°1
Soit l’enregistrement suivant qui définit la facture du Steg
Type
Fact = Enregistrement
Ref : mot
Ancqt : Entier
Nvqt : Entier
Prixkilo : Réel
Fin Fact
Tab = Tableau [ 1 . . 100 ] de Fact
Var
T : Tab
F , F1 : Fact
Question
Rependre aux propositions suivantes par vrai ou faux
Lire ( F) F . Ancqt  33274

F F1 F. Ref  72130
F T Lire ( F . prixkilo )
T[2]F Lire ( T [ 3 ] )
F . Ref  T [ 2 ] . Ref Lire ( T [ 3 ] . prixkilo )
Exercice N° 2
Un club vidéo possède N films (avec 10 <= N <= 200), chaque film est identifier par
- Une référence (un entier de 4 chiffres)
- Le titre de film (une chaine)
- Durée de film en minute
- Année de sortie de film
Ecrire un programme qui permet de saisir les informations de l’ensemble des films, puis d’afficher
la liste du film classé par l’année de sortie (de nouveau a l’ancien).
Exercice N°3
Une société veut informatiser la gestion de ses employés. Elle détient pour chacun les informations
suivantes :
- Le nom et le prénom (chaine de caractères)
- Le grade : uniquement A, B, C, ou D.
- Le code fiscal (un entier non signé)
- L’assurance maladie (O pour oui et N pour non)
Le nombre d’employés est N avec ( 4<= N <= 120).
Questions :
Ecrivez un programme modulaire nommé GESTION qui permet la saisie de toutes les fiches de
renseignements puis d’afficher :
1- Toutes les fiches (une par une et avec une attente jusqu'à l’appui sur la touche ENTREE).
2- Le nombre d’employés ayant un grade donné et leur pourcentage par rapport au nombre total des
employés.
Traduisez ce programme en Pascal et l’enregistrez sous le nom societé.pas.
23
Série N° 2
Exercice N° 1
Dans un kiosque de journaux le plus part des journaux sont connus par :
- Un numéro de série (entier signé)

- Un titre (chaine)
- La période : Q : Quotidien, H : Hebdomadaire, M : Mensuel, T : Trimestriel, et A : Annuel.
- Spécialité : Economique, culturelle, sportif, …
- Le prix : en millième (un entier)
Ecrire un programme modulaire utilisant un menu de choix qui permet de gérer le stock
de journaux dans ce kiosque. Le programme permet de :
• Saisir les informations de tous les journaux vendus dans ce kiosque dans un fichier
Journal.dat sur l’unité C dans un dossier kiosque.
• Ajouter un nouveau journal a la fin de fichier journal.dat.
• Afficher la liste de journaux selon une période donnée.
• Chercher le journal (ou les journaux) dont son nom commence par une chaine donnée.
• Modifier les prix des journaux selon une période donnée et de pourcentage donnée
(exemple tous les journaux Mensuels subit une augmentation de prix de 10%)
Exercice N° 2
Ecrire l’analyse et l’algorithme d’un programme qui permet de :
• Remplir un fichier « nombre.dat » par N entiers aléatoires < 1000 (avec 5 < N < 100).
• Copier le contenu de fichier dans un tableau T.
• Trier le tableau T dans l’ordre croissant.
• Retourner le contenu du Tableau dans le fichier
• Afficher le contenu de fichier avant et après le tri.
24
Exercice N° 3
Un récepteur numérique mémorise les chaines télévisions et radios sous cette forme :
• Nom de la chaine : Tunis TV, Al Jazeera, Dream TV…
• Nom du satellite : Nilesat, Hotbird, Astra …
• Fréquence en Hz un entier de 9000 à inferieur 13000 : exemple 10775, 11995,…
• Symbole : 3/4 , 5 /6, …
• Polarisation : 27500 ,23000 ,…
• Crypté ou Clair : O : pour crypté ou codé et N : pour non codé ou Clair.
Ecrire un programme modulaire utilisant un menu de choix qui permet de gérer les
chaines dans un récepteur. Le programme permet de :
1- Saisir les informations de N chaines ( avec 10 <= N <= 2000) dans un fichier Chaine.dat sur
l’unité C : dans un dossier récepteur.
2- Ajouter les informations d’une chaine a la fin du fichier Chaine.dat.
3- Afficher la liste des chaines d’un satellite donnée.
4- Eclater le fichier Chaine.dat en deux fichiers texte, le premier pour les chaine crypte appelé
Crypté.txt et le deuxième pour les chaine clair appelé Clair.txt.
Exercice N° 4
On se propose d’écrire l’analyse d’un programme pour remplir un fichier texte puis
d’afficher la fréquence de chaque lettre alphabétique (majuscule ou minuscule) du texte. Le
résultat doit être stocké dans un deuxième fichier texte sous la forme suivante :
Fréquence de A = 12
Fréquence de B = 9
…..
Travail demandé :
• Donner la structure de données à utiliser.
• Analyser le problème on le décompose en modules.
• Donner l’analyse de chaque module envisagé
25
Correction d’exercice N° 1 de la série N° 2
1- Analyse programme principal

Nom = kiosque
Résultat = aff
Aff = [ ] Répéter
Clrscr
Ecrire (‘************* Menu *********** ‘)
Ecrire (‘’ 1 - Création de fichier Journal ‘’)
Ecrire (‘’ 2 – Saisir les informations des journaux ‘’)
Ecrire (‘’ 3 – Ajouter un nouveau journal ‘’)
Ecrire (‘’ 4 – Afficher la liste de journaux par période ‘’)
Ecrire (‘’ 5 – Recherche des journaux par une partie de nom ‘’)
Ecrire ( ‘’ 6 – Mise à jour des prix ‘’)
Ecrire (‘’ 7 – Quitter ‘’)
Répéter
Chx= Donnée( ‘’ Entrer votre choix : ‘’ )
Jusqu'à Chx dans [ 1 . . 7 ]
Proc association( Fj )
Selon chx faire
1 : proc Création ( Fj)
2 : proc saisie ( Fj )
3 : proc ajout ( Fj )
4 : proc liste ( Fj )
5 : proc recherche ( Fj)
6 : proc maj (fj )
7 : Exit
Fin Selon
Jusqu'à ( Chx=7 )
Fin kiosque
T.D.N.T T.D.O

Type
Fiche = Enregistrement Ej Fiche Enregistrement pour identifier un journal
Num : mot
Titre : chaine Fj Journal Fichier pour regrouper les informations des
Pr : caractère journaux
Sp : chaine Chx entier choix
Prix : entier
Association Procédure Proc association
Fin Fiche
Journal = Ficher de fiche Création Procédure Proc création du fichier
Saisie Procédure Proc saisie les infos des journaux
Ajout Procédure Proc ajout d’un journal
Liste Procédure Proc affichage de la liste des journaux
Recherche Procédure Proc recherche d’un journal
Maj Procédure Proc mise à jour des prix des journaux
26
2- Analyse procédure association

Def proc association ( VAR Fj : journal )
Résultat = ass
Ass = [ ] associer ( Fj , ‘’C:\ kiosque\ journal.Dat ‘’ )
Fin association
3- Analyse procédure création
Déf Proc Création ( var Fj : journal )
Résultat = FJ
Fj = [ Recréer ( Fj )]
Fin Création
4- Analyse procédure saisie
Déf Proc Saisie ( var Fj : journal )
Résultat = Fj
Fj = [ Ouvrir ( Fj) ]
Répéter
Clrscr
Avec Ej faire
Num = Donnée (‘’ entrer numéro de série : ‘’)
Répéter
Titre = Donnée(‘’ Entrer le titre : ‘’)
Jusqu'à ( long ( titre) > 0)
Repeter
Pr = Donnée ( ‘’Entrer la période : ‘’)
Jusqu'à Majus(pr) dans [ ‘’Q’’, ‘’H’’, ‘’M’’, ‘’T’’, ‘’A’’]
Répéter
Sp = Donnée( ‘’ Entrer le spécialité : ‘’)
Jusqu'à Long ( sp ) > 0
Répéter
Prix= Donnée (‘’ Entrer le prix : ‘’ )
Jusqu'à ( prix > 0 )
Fin Ej
Ecrire ( Fj , Ej )
Répéter
Rep = Donnée ( ‘’ Autre saisie O/N : ‘’)
Jusqu'à ( Majus (rep ) dans [ ‘’O’’ , ‘’N’’ ] )
Jusqu'à ( Majus ( Rep ) = ‘’N’’ )
Fin Saisie
T.D.O
Objet Type / Nature rôle

Ej Fiche Enregistrement identifiant un journal
Rep Caractère réponse
27
5- Analyse procédure Ajout

Déf Proc Ajout ( var Fj : journal )
Résultat = Fj
Fj = [ Ouvrir ( Fj) , Pointer ( Fj , Taille_Fichier ( Fj) )]
Répéter
Clrscr
Avec Ej faire
Num = Donnée (‘’ entrer numéro de série : ‘’)
Répéter
Titre = Donnée(‘’ Entrer le titre : ‘’)
Jusqu'à ( Long ( titre) > 0)
Répéter
Pr = Donnée ( ‘’Entrer la période : ‘’)
Jusqu'à Majus( pr ) dans [ ‘’Q’’, ‘’H’’, ‘’M’’, ‘’T’’, ‘’A’’]
Répéter
Sp = Donnée ( ‘’ Entrer le spécialité : ‘’)
Jusqu'à Long ( sp ) > 0
Répéter
Prix= Donnée (‘’ Entrer le prix : ‘’ )
Jusqu'à ( prix > 0 )
Fin Avec
Ecrire ( Fj , Ej )
Répéter
Rep = Donnée ( ‘’ Autre Ajout O/N : ‘’)
Jusqu'à ( Majus ( rep ) dans [ ‘’O’’ , ‘’N’’ ] )
Jusqu'à ( Majus ( Rep ) = ‘’N’’ )
Fin Ajout
T.D.O

Rep Caractère Réponse
28
6- Analyse procédure affiche

Déf Proc affiche ( var Fj : journal )
Résultat = aff
Aff = [ ouvrir ( Fj ) ] Tant que Non (Fin_Fichier ( FJ ) ) Faire
Lire ( Fj , Ej )
Avec Ej Faire
Si Majus ( pr ) = Majus ( p ) Alors
Ecrire (‘’ le numéro de série est : ‘’, num )
Ecrire (‘’ le titre du journal : ‘’, titre)
Ecrire (‘’ la spécialité est : ‘’ , sp )
Ecrire (‘’ le prix du journal : ‘’, prix)
Fin Si
Fin avec
Fin tant que
P =[ ] Répéter
P = Donnée (‘’ Entrer la période : ‘’ )
Jusqu'à Majus ( p ) dans dans [ ‘’Q’’, ‘’H’’, ‘’M’’, ‘’T’’, ‘’A’’]
Fin affiche
T.D.O
Objet Type / Nature Rôle

p Caractère Désigne la période
7- Analyse procédure recherche

Déf Proc recherche ( var Fj : journal )
Résultat = aff
Aff = [ Ouvrir ( Fj ) ]
Tant que Non (Fin_Fichier ( FJ ) ) Faire
Lire ( Fj , Ej )
Avec Ej Faire
Si Nom = sous_chaine (titre , 1 , Long( nom)) Alors
Ecrire (‘’ le numero de serie est : ‘’, num )
Ecrire (‘’ le titre du journal : ‘’, titre)
Ecrire (‘’ la période est : ‘’, pr )
Ecrire (‘’ la spécialité est : ‘’ , sp )
Ecrire (‘’ le prix du journal : ‘’, prix)
Fin Si
Fin avec
Fin tant que
Nom= [ ] Répéter
Nom = Donnée (‘’ Entrer le nom d’un journal : ‘’ )
Jusqu'à Long (nom ) > 0
fin recherche
T.D.O

Nom Chaine Titre d’un journal
29
8- Analyse procedure mise à jour

Déf Proc Maj ( var Fj : journal )
Résultat = Fj
Fj = [ Ouvrir ( Fj) ]
Tant que Non (Fin_Fichier ( FJ ) ) Faire
Lire ( Fj , Ej )
Avec Ej Faire
Si Majus ( pr ) = Majus ( p ) Alors
Prix  prix + ( ( prix *px) Div 100 )
N  Position_Fichier ( Fj )
Pointer ( Fj , n-1 )
Ecrire ( Fj , Ej )
Fin Si
Fin avec
Fin tant que
P =[ ] Répéter
P = Donnée (‘’ Entrer la période : ‘’ )
Jusqu'à Majus ( p ) dans [ ‘’Q’’, ‘’H’’, ‘’M’’, ‘’T’’, ‘’A’’]
Px =[ ] Répéter
P x= Donnée (‘’ Entrer la valeur de réduction ou d’’augmentation de prix : ‘’)
Jusqu'à Px > - 100
Fin Maj
T.D.O

P Caractère Désigne la période
Px Entier Valeur de réduction ou d’augmentation
30
Correction ex 2 série N° 2
Nom : Ex2
Résultat = aff
Aff =[ ] Répéter
Ecrire (‘’ ************ Menu ******************* ‘’)
Ecrire (‘’1- Remplir le fichier Nombre par N entiers aléatoires : ‘’)
Ecrire (‘’ 2- Trier le contenu du fichier utilisant un tableau ‘’)
Ecrire (‘’3 – Afficher le contenu du fichier Nombre ‘’)
Ecrire (‘’ 4 – Quitter ‘’)
Répéter
Chx = Donnée (‘’ Entrer votre choix : ‘’)
Jusqu'à chx dans [ 1 . . 4 ]
Selon chx faire
1 : Proc remplir ( Fn )
2 : Proc trif ( Fn )
3 : Proc affiche ( fn )
4 : Exit
Fin Selon
Jusqu'à ( Chx = 4 )
Fin Ex2
T.D.N.T
Type
Nombre = Ficher d’entier
T.D.O

Fn Nombre Fichier de n entiers
Chx Entier choix
2- Analyse procédure remplir

Déf Proc Remplir ( var Fn : Nombre )
Résultat = Fn
Fn = [ Recréer ( Fn ) ] Pour i de 1 à N faire
m  Aléatoire(1000)
Ecrire ( Fn , m )
Fin Pour
N = Répéter
N = Donnée ( ‘’ Entrer le nombre des entiers : ‘’ )
Jusqu'à N dans [ 6 . . 99 ]
Fin Remplir
T.D.O

i entier Compteur
m entier Nombre aléatoire
31
3- Analyse procédure trif

Déf Proc trif ( var Fn : nombre )
Résultat = Fn
Fn = [ ] Recréer ( Fn )
Pour i de 1 à n faire
Ecrire ( Fn , T [ i ] )
Fin Pour
T = [ Ouvrir ( FN ) , n  0]
Tant que Non (Fin_Fichier ( Fn ) ) Faire
NN+1
Lire ( Fn , T [ N ] )
Fin Tant que
Répéter
B  faux
Pour i de 1 à (n-1) faire
Si T [ i ] < T [ i + 1 ] Alors
Aux  T [ i ]
T[i]T[i+1]
T [ i + 1 ]  Aux
B  Vrai
Fin Si
Fin Pour
Jusqu'à ( Non (B ) )
Fin trif
T.D.O

I Entier Compteur
b Booléenne Il y a permutation ou non
N Entier Nombre des entiers
Aux Entier Variable temporaire
T Tableau [1 .. 100] d’entier Tableau de 100 entiers

Déf Proc Affiche ( Var Fn : Nombre )
Résultat = Aff
Aff = [ ouvrir( fn) ] Tant que Non (Fin_Fichier ( Fn ) ) Faire
Lire ( Fn , n)
Ecrire ( n )
Fin Tant que
T.D.O

N entier Entier du fichier
32
Traduction en Turbo Pascal

Exercice N° 1
program journal;
uses wincrt;
type
Article = record
num : integer;
titre : string[10];
per : char;
spec : string[10];
prix : longint;
end;
fichier = file of article;
var
Ejour:article;
Fjour:fichier;
choix:integer;
procedure ass (var Fjour:fichier);

begin
assign (Fjour,'C:\journal.dat');
end;
procedure creation ( var Fjour:fichier);

begin
rewrite (Fjour);
end;
procedure saisi (var Fjour:fichier; Ejour:article);

var
rep:char;
begin
reset(Fjour);
repeat
with Ejour do
begin
repeat
write ('Entrer la numéro de serie du journal : ');
readln (num);
until (num>0) ;
repeat
write ('Entrer le titre du journal : ');
readln (titre);
until (length(titre)>0);
repeat
write ('Entrer la periode du journal : ');
readln(per);
until upcase(per) in ['Q','H','M','T','A'];
repeat
33
write ('Entrer la specialité du journal : ');

readln(spec);
until (length (spec)>0);
repeat
write ('Entrer la prix du journal en millimes : ');
readln(prix);
until (prix>0) ;
clrscr
end;
write(Fjour,Ejour);
Repeat
write ('Voulez vous saisi un autre journal (O/N) ? : ');
readln (rep);
until upcase (rep) in ['O','N'];
clrscr;
until upcase (rep) = 'N';
close(Fjour);
end;
procedure ajout (var Fjour:fichier; Ejour:article);

var
rep : char;
p:integer;
begin
reset (Fjour);
seek(Fjour,filesize(Fjour));
repeat
with Ejour do
begin
repeat
write ('Entrer la numéro de serie du journal : ');
readln (num);
until (num>0) ;
repeat
write ('Entrer le titre du journal : ');
readln (titre);
until (length(titre)>0);
repeat
write ('Entrer la periode du journal : ');
readln(per);
until upcase(per) in ['Q','H','M','T','A'];
repeat
write ('Entrer la specialité du journal : ');
readln(spec);
until (length (spec)>0);
repeat
write ('Entrer la prix du journal en millimes : ');
readln(prix);
34
until (prix>0) ;
clrscr
end;
write(Fjour,Ejour);
Repeat
write ('Voulez vous saisi un autre journal (O/N) ? : ');
readln (rep);
until upcase (rep) in ['O','N'];
clrscr;
until upcase (rep) = 'N';
close(Fjour);
clrscr;
end;
procedure affiche (var Fjour:fichier; Ejour:article);

var
periode : char;
begin
reset(Fjour);
repeat
write ('Entrer la periode souhaité : ');
readln(periode);
until upcase(periode) in ['Q','H','M','T','A'];
while not(eof(Fjour)) do
begin
read(Fjour,Ejour);
with Ejour do
begin
if upcase(periode) = upcase(per) then
begin
writeln('numero du serie : ',num);
writeln('titre : ',titre);
writeln('periode : ',per);
writeln ('Specialité : ',spec);
writeln ('prix : ',prix);
writeln;
readln;
end;
end;
end;
clrscr;
close(Fjour);
end;
procedure cherche (var Fjour:fichier; Ejour:article);

var
ch,mot:string;
begin
reset(Fjour);
repeat
35
write ('Entrer le mot qui tu vient le rechcerche : ');

readln(mot);
until (length(mot)>0);
begin
read(Fjour,Ejour);
with Ejour do
begin
ch := copy (titre,1,length(mot));
if ch = mot then
begin
writeln (titre);
readln;
end;
end;
end;
clrscr;
close(Fjour);
end;
procedure misejour (var Fjour:fichier; Ejour:article);

var
p,x:integer;
periode:char;
pour:longint;
begin
reset(Fjour);
repeat
write ('Entrer la periode souhaité : ');
readln(periode);
clrscr;
until upcase(periode) in ['Q','H','M','T','A'];
repeat
write('Entrer la pourcentage : ');
readln(p);
clrscr;
until (p>=-100) and (p<=100);
begin
read(Fjour,Ejour);
with Ejour do
begin
if upcase(periode) = upcase(per) then
begin
pour:= (prix*p) div 100;
prix := prix+pour ;
x := filepos(Fjour);
seek(Fjour,x-1);
write(Fjour,Ejour);
end;
end;
36
end;
clrscr;
close(Fjour);
end;
{programme principale}
begin
clrscr;
repeat
writeln ('**********************************************');
writeln ('******************** Menu ********************');
writeln ('**********************************************');
writeln ('* 1) creation du fichier *');
writeln ('* 2) saisie les informations des journales *');
writeln ('* 3) ajout d''une journale *');
writeln ('* 4) affichage des journeaux *');
writeln ('* 5) chercher les journeux *');
writeln ('* 6) mise à jour des prix *');
writeln ('* 7) exite *');
writeln ('**********************************************');
writeln ('**********************************************');
repeat
write('Entrer votre choix : ');
readln (choix);
clrscr;
until choix in [1..7];
ass(Fjour);
case choix of
1:creation(Fjour);
2:saisi(Fjour,Ejour);
3:ajout(Fjour,Ejour);
4:affiche (Fjour,Ejour);
5:cherche (Fjour,Ejour);
6:misejour (Fjour,Ejour);
7:exit;
end;
until choix = 9 ;
end.
37
Exercice N° 2
program tri_fichier_entier;
uses wincrt;
type
nombre = file of integer;
tab = array [1..100] of integer;
var
FE:nombre;
T:tab;
choix:integer;
n:integer;
procedure ass (var FE:nombre);

begin
assign (FE,'C:\4SI\nombre.dat');
end;
procedure creation (var FE:nombre);

begin
rewrite (FE);
end;
procedure Saisi (var FE:nombre; var n:integer);

var
i,m:integer;
begin
clrscr;
reset(FE);
randomize;
repeat
write ('Enter l''entier n : ');
readln (n);
until (n>5) and (n<100);
for i := 1 to n do
begin
m := random (1000);
write (FE,m);
end;
close(FE);
end;
procedure permute (var a,b:integer);
var
aux : integer;
begin
aux := a;
a := b;
b := aux;
end;
38
procedure copier (var FE:nombre; var T:tab);

var
i,m:integer;
begin
reset (FE);
i:=0;
while not(EOF(FE)) do
begin
i:=i+1;
read(FE,m);
T[i] := m;
end;
close(FE);
end;
procedure TRI (var FE:nombre; var T:tab; n:integer);

var
i,j:integer;
begin
copier (FE,T);
rewrite (FE);
for i := 1 to n-1 do
begin
for j := 1 to n-1 do
begin
if T[j]>T[j+1] then
begin
permute (T[j],T[j+1]);
end;
end;
end;
for i := 1 to n do
begin
write(FE,T[i]);
end;
close(FE);
end;
procedure affichage (var FE:nombre);

var
i,m:integer;
begin
clrscr;
reset(FE);
while not(EOF(FE)) do
begin
read (FE,m);
writeln (m);
end;
readln;
end;
39
begin
repeat
clrscr;
writeln('******************** MENU *********************');
writeln('* 1) Creation du fichier *');
writeln('* 2) Remplir le fichier *');
writeln('* 3) Tri du Fichier *');
writeln('* 4) Affichage du fichier *');
writeln('* 5) Quitter *');
writeln('***********************************************');
repeat
write ('Entrer votre choix : ');
readln (choix);
until choix in [1..5];
ass (FE);
case choix of
1:creation(FE);
2:saisi(FE,n);
3:TRI (FE,T,n);
4:affichage (FE);
5:exit
end;
until choix = 5;
end.
40
Correction exercice N° 4
1- Algorithme procédure Création

0) Def Proc Creation ( var ft , Ffreq : texte )
1) Ft , ffreq = [ ] associer ( ft , ‘’C:\4si3\ source.txt’’)
Associer ( ffreq , ‘’ C:\ 4si3\ frequence.txt’’)
Recreer ( ft )
Recreer ( ffreq )
2) Fin Creation
2- Algorithme procédure remplir
0) Def proc Remplir ( var ft : texte )
1) Ft = [ Ouvrir ( ft ) ]
Répéter
Ecrire (‘’ entrer une chaine : ‘’)
Lire ( ligne )
Si ( ligne ≠ ‘’’’ ) Alors
Ecrire ( ft , ligne )
Finsi
Jusqu'à (ligne = ‘’’’)
2) Fermer ( ft)
3) Fin remplir
3- Algorithme procédure fréquence
0) Def proc fréquence ( var ft , ffreq : texte )

1) T = [ ouvrir ( ft ) ]
Pour c de ‘’A’’ à ‘’Z’’ faire
T[c]0
Fin Pour ]
Tant que Non ( Fin_Fichier ( ft ) ) faire
Lire ( ft , ligne )
Pour i de 1 à Long ( ft ) Faire
c  Majus ( ligne [ i ] )
Si c dans [ ‘’ A ’’ . . ‘’ Z ’’ ] Alors
T[c]T[c]+1
Fin si
Fin Pour
Fin Tant que
2) Ffreq = [ Recreer ( ffreq ) ]
Pour c de ‘’A’’ à ‘’Z’’ faire
Convch ( T [ c ] , stf )
Ligne  ‘’La fréquence de ‘’+ c + ‘’ est : ‘’ + stf
Ecrire ( ffreq , ligne )
Fin Pour
3) Fermer (ft ), fermer (ffreq)
4) Fin fréquence
41
4- Algorithme procédure affiche
0) Def proc affiche ( var f : texte )

1) Aff = [ ouvrir ( f ) ]
Tant que Non ( Fin_Fichier ( f ) ) faire
Lire ( f , ligne )
Ecrire ( ligne )
Fin Tant que
2) Fermer ( f )
3) Fin affiche
5- Algorithme programme principal
0) Debut ex4
1) Proc Creation ( ft , ffreq)
2) Proc remplir ( ft )
3) Proc frequence ( ft , ffreq)
4) Proc Affiche ( ft )
5) Proc affiche ( ffreq )
6) Fin ex4
42
Traduction en Turbo Pascal
program ex4; str( t[c], stf);

uses wincrt; ligne :='La fréquence de ' + c+ ' est : ' +stf;
var writeln(ffreq , ligne);
ft, ffreq: text; end;
procedure creation ( var ft , ffreq : text ); close(ft);
begin close(ffreq);
assign ( ft,'c:\4si\source.txt'); end;
assign(ffreq,'c:\4si\frequence.txt'); procedure affiche ( var f:text);
rewrite(ft); var
rewrite(ffreq); ligne:string;
end; begin
procedure remplir ( var ft :text); reset(f);
var while Not (eof(f)) do
ligne:string; begin
begin readln(f, ligne);
repeat writeln(ligne)
write(' Entrer une chaine : '); end;
readln (ligne); close(f);
if ligne <>'' then end;
begin
write(ft, ligne) begin
end; creation(ft, ffreq);
until ligne=''; remplir(ft);
end; frequence(ft,ffreq);
procedure frequence ( var ft,ffreq : text); affiche(ft);
var readln;
t: array['A'..'Z'] of integer; writeln;
i:integer; affiche(ffreq);
c:char; end.
ligne,stf:string;
begin
reset(ft);
for c := 'A' to 'Z' do
begin
t[ c ] := 0;
end;
while not( eof(ft)) do
begin
readln ( ft , ligne);
for i := 1 to length( ligne) do
begin
c := upcase(ligne[i]);
if c in ['A'.. 'Z'] then
begin
t[c] := t[c] +1;
end;
end;
end;
rewrite (ffreq);
for c := 'A' to 'Z' do
begin
43
Série N° 3
Exercice N°1
Une société de produit laitier décide d’automatiser la gestion de ses produits. On détient
pour chaque produit les informations suivantes :
• Numéro ‘‘ num ‘’ : Numéro unique de l’article
• Désignation ‘‘ design ‘’ : Nom de l’article (YAOURT, LAIT ou FROMAGE)
• Une matricule ‘‘ mat ‘’ : Remplie automatiquement par une chaîne représentée par les
deux remiers caractères de la désignation et le numéro de l’article. Exemple : Pour l’article
dont le numéro est 10, la désignation est "YAOURT" : La matricule sera ‘‘ YA10 »
• Une date de vente qui lui-même formée de trois champs :
o Jour ‘‘ j ’’ (1 à 31)
o Mois ‘‘ m ’’ (1 à 12)
o Année ‘‘ a ‘’ (≥2000)
• Quantité vendue ‘‘ qv ‘’
• Prix unitaire ‘‘ pu ‘’
Travail demandé :
On désire ecrire un programme permettant de :
1. Saisir et enregistrer les articles des différents produits dans un fichier ayant pour nom
logique "FPROD" et qui correspond à un nom physique "Produit.dat" qui sera créer sur la
racine de l’unité C:
La saisie s’arrête à la saisie d’un numéro négatif qui ne sera pas retenue dans le fichier.
2. Afficher le numéro et la date de vente d’un article qui correspond à une matricule donnée.
Si aucun article n’est trouvé, afficher un message d’erreur.
3. Organiser le fichier ‘‘FPROD » dans un autre fichier ‘‘ FPROD_ORD » en rangeant au début
les données relatives à l’article LAIT puis celles du YAOURT puis celle du FROMAGE.
4. Créer un fichier texte dont la structure est la suivante :
• La 1ére ligne comporte le message "Articles vendus le : " suivit par la date donnée (la date
saisie doit respecter la même condition indiquée ci-dessus).
• La 2ème ligne comporte la recette du jour pour la date donné précédée par le message
"Recette du jour : "
• La suite du fichier comporte les matricules des articles vendus à la date donnée précédés
par le message "Matricules des articles vendus : "
Ainsi, le fichier texte prendra la forme présentée par l’exemple suivant :
Articles vendus le : 12/03/2009

Recette du jour : 48.000
Matricule des articles vendus :
LA6
FR3
N.B : Le programme doit afficher le fichier "FPROD_ORD" et le fichier texte créer.

Questions :
1) Analyser le programme principal ainsi que les différents modules envisagés
2) En déduire l’algorithme du programme principal ainsi que ceux des modules envisagés.
44
Correction exercice N°1 de la série N°3

A) Analyse programme principal Ex1s3
Résultat = aff
Aff=[ ] Répéter
Ecrire (‘‘******* Menu *********** ‘‘)
Ecrire (" 1-Création des fichiers " )
Ecrire("2- Saisie des article ‘‘ )
Ecrire(‘‘3- Afficher le numéro et la date de vente ‘‘)
Ecrire (‘‘4- Organiser le fichier FPROD dans un FPROD_ORD ‘‘)
Ecrire(‘‘5- Remplir le fichier Texte»)
Ecrire(‘‘6- Afficher le fichier typé FPROD»)
Ecrire(‘‘7- Afficher le fichier texte FART»)
Ecrire(‘‘8- Quitter ‘‘)
Répéter
Chx=donnée(‘‘ Entrer le choix : ‘‘)
Jusqu'à chx dans [1..8]
Proc association (FPROD,FPROD_ORD,FART)
Selon chx Faire
1: proc Création(FPROD, EPR)
2 : Proc Saisie (FPROD , EPR)
3 : Proc Affiche(FPROD, EPR)
4 : Proc Organiser(FPROD, FPROD_ORD, EPR)
5 : Proc Remplir (FPROD,FART, EPR)
6 : Proc AffichePROD( FPROD, EPR)
7 : Proc AfficheART (FART)
8 : Exit
Fin Selon
Jusqu'à chx = 8
Fin Ex1s3
T.D.N.T
T.D.O
Type
Date = Enregistrement Objet Type/Nature rôle
J :1..31
FROD Prd Fichier de produit
M :1..12
FPROD_ORD Prd Fichier de produit organiser
A :mot
Fart Texte Fichier texte article
Fin Date
EPR Article Enregistrement article
Article = Enregistrement
Num : Entier Création Procédure
Desig : chaine Affiche Procédure
Mat : chaine[4] Organiser Procédure
Datv : Date remplir procédure
Qv : Réel
Pu : Réel
Fin article
Prd = Ficher d’Article
45
Algorithme
0) Début Ex1S3
1) Aff =[ ]Répéter
Ecrire (‘‘******* Menu *********** ‘‘)
Ecrire (‘‘ 1-création des fichiers ‘‘ )
Ecrire(‘‘ 2- saisie des article ‘‘ )
Ecrire(‘‘ 3- afficher le numéro et la date de vente ‘‘)
Ecrire (‘‘4- organiser le fichier FPROD dans un FPROD_ORD ‘‘)
Ecrire(‘‘5- remplir le fichier Texte’’)
Ecrire(‘‘6- Afficher le fichier typé FPROD’’)
Ecrire(‘‘7- Afficher le fichier texte FART’’)
Ecrire(‘‘8- Quitter ‘‘)
Répéter
Chx=donnée(‘‘ Entrer le choix : ‘‘)
Jusqu'à chx dans [ 1 . . 8]
Proc association (FPROD,FPROD_ORD,FART)
Selon chx Faire
1: proc Création(FPROD, EPR)
2 : Proc Saisie (FPROD , EPR)
3 : Proc Affiche(FPROD, EPR)
4 : Proc Organiser(FPROD, FPROD_ORD, EPR)
5 : Proc Remplir (FPROD,FART, EPR)
6 : Proc AffichePROD( FPROD, EPR)
7 : Proc AfficheART (FART)
8 : Exit
Fin Selon
Jusqu'à chx = 8
2) Fin Ex1s3
B) Analyse Proc association ( Var FROD, FPROD_ORD : Prd ; Fart : texte)

Résultat = FPROD,FPROD_ORD,FART
Associer ( FPROD, ‘‘C:\4SI3\Produit.dat’’)

Associer (FROD_ORD, ‘‘C:\4SI3\Produitord.dat’’)
Associer (Fart, ‘‘C:\4SI3\article.txt’’)
Fin association
C) Analyse Proc Création (VAR FPROD :Prd, EPR :Article)

Résultat = FPROD, FPROD_ORD, FART
Recréer (FROD)
Recréer (FPROD_ORD)
Recréer (FART)
Fin création
46
D) Analyse Proc Saisie (Var FPROD :Prd ; EPR : Article)

Résultat = FPROD
FPROD= [ ] Répéter
Avec EPR faire
Num=Donnée(‘‘Entrer Numéro : ‘‘)
Si Num > 0 Alors
Répeter
Design= Donnée(‘’ Entrer Désignation de produit’’)
Jusqu'à Long(Design)>0
Str(num,ch)
Mat copy(desig,1,2)+ch
Avec Datv faire
J= Donnée(‘‘Entrer le jour : ‘‘)
M= Donnée (‘‘Entrer le mois : ‘‘)
Répeter
A=Donnée(‘‘Entrer l’année’’)
Jusqu'à a >2000
Fin avec
Répeter
Qv = Donnée(‘‘Entrer la quantité : ‘‘)
Jusqu'à qv >0
Répeter
Pu = Donnée(‘‘Entrer prix : ‘‘)
Jusqu'à pu >0
FinSi
Fin avec
Ecrire(FPROD, EPR)
Fin Saisie
Algorithme
0) Début Déf Proc Saisie (Var FPROD :Prd ; EPR : Article)
1) FPROD= [ ] Répéter
Avec EPR faire
Ecrire (‘‘Entrer Numéro : ‘‘)
Lire (Num)
Si Num > 0 Alors
Répéter
Ecrire(Entrer Désignation de produit»)
Lire(Design)
Jusqu'à Long(Design)>0
Str(num,ch)
Mat copy(desig,1,2)+ch
Avec Datv faire
Ecrire(‘‘Entrer le jour : ‘‘)
Lire(j)
Ecrire (‘‘Entrer le mois : ‘‘)
Lire (m)
Répéter
Ecrire(‘‘Entrer l’année’’)
Lire (a)
Jusqu'à a >2000
Fin avec
47
Répéter
Ecrire(‘‘Entrer la quantité : ‘‘)
Lire (qv)
Jusqu'à qv >0
Répéter
Ecrire(‘‘Entrer prix : ‘‘)
Lire (pu)
Jusqu'à pu >0
FinSi
Fin avec
Ecrire(FPROD, EPR)
2) Fin Saisie
E) Analyse Proc Affiche (VAR FPROD :Prd ; EPR :Article)
0) Début Déf Proc Affiche (VAR FPROD :Prd ; EPR :Article)
1) Mt =[ ] Répéter
Ecrire(‘‘Entrer un matricule : ‘‘)
lire (mt)
Val (copy(mt,2,2), n, e)
jusqu'à (e=0)
2) Aff =[ Ouvrir(FPROD), i  0 ]
Tant que Non(Fin_Fichier(FPROD)) Faire
lire (FPROD, EPR)
Si mat = mt Alors
Ecrire (‘‘le Numéro est : ‘‘, Num)
Ecrire (‘‘La date de vente : ‘‘, datv . j, ‘‘/ ‘‘ , datv. m , ‘‘/’’, datv . a)
i i+1
Finsi
Fin Tant que
Si i =0 Alors
Ecrire (‘‘Article n’existe pas ‘‘)
FinSi
3) Fin Affiche
F ) analyse Proc Organiser(Var FPROD,FPROD_ORD : Prd ; EPR : Aricle)
0) Début Déf Proc Organiser(Var FPROD,FPROD_ORD : Prd ; EPR : Aricle)
1) Org =[ Ouvrir(FPROD)] Tant Que Non (Fin_Fichier (FPROD)) Faire
Lire (FPROD , EPR)
Si EPR = ‘‘LAIT» Alors
Ecrire (FPROD_ORD, EPR)
Fin si
Fin Tant que
2) [ Ouvrir(FPROD)] Tant Que Non (Fin_Fichier (FPROD)) Faire
Lire (FPROD , EPR)
Si EPR = ‘‘YAOURT’’ Alors
Fin si
Fin Tant que
3) [ Ouvrir(FPROD)] Tant Que Non (Fin_Fichier (FPROD)) Faire
Lire (FPROD , EPR)
Si EPR = ‘‘FROMAGE’’ Alors
Fin si
48
Fin Tant que

4) Fin Organiser
G) analyse Proc remplir (VAR FPROD : Prd ; FART : texte ; EPR : Article)
0) Début Déf Proc remplir (VAR FPROD : Prd ; FART : texte ; EPR : Article)
1) Avec Dats faire
Ecrire(‘‘Entrer le jour : ‘‘),
Lire(j)
Ecrire (‘‘Entrer le mois : ‘‘)
Lire (m)
Répéter
Ecrire(‘‘Entrer l’année’’)
Lire (a)
Jusqu'à a >2000
Str (j ,chj)
Str (m,chm)
Str(a, cha)
Fin Avec
2) Ch  chj + ‘‘/’’ + chm + ‘‘/’’ + cha
3) Ecrire (FART , “Articles vendus le : ‘‘ + Ch
4) FART = [ Ouvrir(FPROD), Rec  0 ] Tant que Non (Fin_Fichier(FPROD)) Faire
Lire ( FPROD , EPR)
Si EPR . Datv = Dats Alors
Rec  Rec + EPR . qv * EPR . pu
Fin si
Fin Tant que
Str( Rec , ch )
Ch  ‘‘Recette du jour’’ + Ch
Ecrire ( FART , Ch)
5) [ Ouvrir(FPROD) ] Tant que Non (Fin_Fichier(FPROD)) Faire
Lire ( FPROD , EPR)
Si EPR . Datv = Dats Alors
Ecrire (FART, EPR . mat)
Fin si
Fin Tant que
6) Fin Remplir
49
H) Algorithme Affiche fichier typé ‘‘produit»

0) Début Déf Proc afficheProd (Var FPROD : Prd ; EPR : Article)
1) Aff = [ Ouvrir (FPROD)]
Tant Que Non (Fin_Fichier (FPROD)) faire
Lire (FPROD, EPR )
Avec EPR faire
Ecrire (‘‘ Le numéro : ‘‘, Num)
Ecrire (‘‘ Désignation : ‘‘, Desig)
Ecrire (‘‘ Le matricule : ‘‘, mat)
Ecrire (‘‘ La date vente : ‘‘ datv . j , ‘‘/» , datv . m , ‘‘/» , datv.a)
Ecrire(‘‘ la quantité vendue : ‘‘, qv)
Ecrire (‘‘ Le prix unitaire : ‘‘, pu)
Fin avec
2) Fin afficheProd
I) Algorithme affiche fichier texte
0) Début Déf Proc AfficheART (Var FART :texte )

1) Aff =[ Ouvrir (FART)] Tant que Non (Fin_Fichier (FART)) Faire
Lire (FART , Ch)
Ecrire ( ch)
Fin Tant que
2) Fin AfficheART
50
Série N 4
Exercice N°1
Une société de travaux pense d’informatiser la gestion de ses personnels. Elle garde pour
chaque employé les informations suivantes :
• Matricule : entier de 4 chiffres positif
• Nom, prénom : chaines de 30 caractères au maximum pour chacune.
• Grade : peut être seulement A, B, ou C.
• Salaire : réel.
Proposer l’analyse et l’algorithme d’une application informatique qui permet de répondre aux
taches suivantes :
a) Associer le fichier qui comporte les données des personnels dans le fichier
« Personnels.Dat » de dossier « C:\4SI3 ».
b) Créer le fichier
c) Saisir les données de chaque employé, la saisie s’arrêt selon la demande « Autre saisie
O/N : »
d) afficher la liste des personnels, et la liste des personnels d’un grade donnée.
e) Ajouter un nouvel employé dans le fichier « personnels.dat »
f) Mettre à jour les salaires des employés de grade B qui sont augmentés de 15%.
g) Arranger les personnels selon le Grade dans 3 fichiers distincts :
« PA.dat : pour les personnels de grade A »
« PB.dat : pour les personnels de grade B »
« PC.dat : pour les personnels de grade C »
h) Afficher le contenu d’un fichier donné et le nombre de ces éléments (nombre des
employés).
N.B : utiliser un menu de choix pour cette application.
Exercice N° 2 :
Ecrire l’analyse puis l’algorithme d’un programme permettant de :
• Remplir un fichier « nombre.dat » par N entiers aléatoires <1000, ( avec 4 <N <100).
• A partir de fichier « nombre.dat » remplir un fichier typé « conversion.dat » dans le quel
on trouve : Le nombre en décimal, Sa conversion en binaire, Sa conversion en octal, Sa
conversion en Hexadécimal.
• Mettre dans un fichier texte « Convbase.txt » le contenu de fichier « conversion.dat », sur
chaque ligne de fichier texte en trouve le nombre suivi par ses conversions dans les
différents bases sépares par un espace.
N.B : Tous les fichiers sont enregistres dans le dossier « Bac2013 » sur l’unité C .
51
Série N° 5
Exercice N° 1 (sujet Bac pratique 2012 « 24 Mai 2012 »)
A partir d’un fichier nommé « Nombre.dat » contenant N entiers, formé chacun de P

chiffres, on veut former un deuxième fichier nommé « Facteurs.txt » qui contiendra, des chaines,
chaque chaine représente la concaténation de la fréquence de chacun des facteurs premiers d’un
nombre du fichier « Nombres.Dat » suivi du fichier premier lui-même.
Exemple
Pour N=3 et P=4
Le contenu du fichier Les facteurs premiers de chaque Le contenu du fichier

« Nombres.dat » nombre du fichier « Nombres.dat » « Factures.txt »
1912 2 , 2 , 2 , 239 321239
4592 2 , 2 , 2 , 2 , 7 , 41 4217141
3525 3 , 5 , 5 , 47 1325147
En effet :
• 1921 = 2 * 2 * 2 * 239
La chaine générée sera « 321239 » pour dire que 3 est la fréquence du facteur premier 2 et 1 est
la fréquence du facteur premier 239.
• 3525 = 3 * 5 * 5 * 47
La chaine générée sera « 1325147 » pour dire que 1 est la fréquence du facteur premier 3, 2 est la
fréquence du facteur premier 5 et 1 est la fréquence du facteur premier 47.
Travail à faire :
Ecrire un programme Pascal et l’enregistrer sous le nom FactPrem.pas permettant :
• De remplir un fichier nommé « Nombres.dat » par N entiers, formés de P chiffres
( avec 2 < N < 100 et 2 < P < 6).
• De créer, pour chaque entier du fichier « Nombre.dat », une chaine représentant la

concaténation de la fréquence de chacun de ses facteurs premiers suivi du facteur premier
lui-même et l’enregistrer dans une ligne d’un fichier texte nommé « Facteurs.txt ».
• D’afficher le contenu du fichier « Facteurs.txt ».
N.B : tous les fichiers seront enregistrés dans le dossier bac 2013 de l’unité C :
52
Exercice N° 2 ( Ex 5 sujet bac 2012 session contrôle)
Etant donné un fichier texte intitulé « MsgCrypte.txt » contenant un texte crypté d’un
message formé de N lignes, où chaque ligne représente un mot crypté.
Le principe du cryptage est le suivant :
• Chaque mot est crypté caractère par caractère.
• Chaque caractère est crypté par sa représentation binaire, sur 8 bits, de son code ASCII.
On se propose :
• De décrypter les lignes du fichier « MsgCrypte.txt » pour obtenir tous les mots formant le
message initial,
• D’afficher le texte décrypté, en séparant les mots par des espaces.
Exemple :
Pour N = 4 et le contenu du fichier « MsgCrypte.txt » suivant :
01000010 0110000101100011
0110100101101110011001101111
011010100 11101010110100101101110
00110010001100000011000100110010
Après décryptage, le programme affichera le message suivant : Bac info juin 2012
Notons que, le code ASCII du caractère « B » (le premier caractère du premier mot) est 66,
dont la représentation binaire est 01000010 (les huit premiers bits de la premier ligne du fichier
« MsgCrypte.txt »).
Travail à faire :
1. Analyser le problème en le décomposant en modules.
2. Analyser chacun des modules envisagés.
53
Correction exercice N°1 série N° 5
program ex1s5;
uses wincrt;
type
nombre=file of integer;
var
fn:nombre;
ft:text;
procedure creation (var fn:nombre; var ft:text);
begin
assign (fn, 'c:\4si\nombre.dat');
assign(ft,'c:\4si\facteurs.txt');
rewrite(fn);
rewrite(ft);
end;
procedure remplir (var fn:nombre);
var
n,p,k,i:integer;
st:string;
begin
reset(fn);
repeat
write('Entrer le nombre des entiers n: ');
readln(n);
until n in [3 .. 99];
repeat
write('entrer le nombre des chiffres de chaque entier: ');
readln(p);
until p in [3..5];
for i:= 1 to n do
begin
repeat
write(' Entrer l"entier numero ',i,': ');
readln(k);
str(k,st);
until length(st)=p;
write(fn, k);
end;
close(fn);
end;
54
{************* la 1ère methode *********** } {************* la 2ème methode ************* }
procedure facteur1( var fn:nombre ; var ft : text); procedure facteur2(var fn:nombre; var ft:text);
var var
i,nb,n:integer; i,nb,n:integer;
st,sti,ch:string; ch,st,c,k,sti:string;
begin
begin reset (fn);
reset (fn); append(ft);
append(ft); while not (eof(fn)) do
while not (eof(fn)) do begin
begin read(fn,n);
read(fn,n); i:=2;
i:=2; ch:='';
nb:=0 ; repeat
ch:=''; if n mod i =0 then
repeat begin
if n mod i =0 then n:=n div i;
begin str(i,sti);
n:=n div i; ch:=ch+sti+' ';
nb:=nb+1; end
end else
else begin
begin i:=i+1;
if nb >0 then end;
begin
str(nb,st); until n=1;
str(i,sti);
ch:=ch+st+sti; sti:='';
nb:=0;
end; repeat
i:=i+1; st:=copy(ch,1,pos(' ',ch));
end; nb:=0;
until n=1; while (pos(st,ch)<>0) do

str(nb,st); begin
str(i,sti); nb:=nb+1;
ch:=ch+st+sti; delete(ch,1,pos(' ',ch))
writeln( ft,ch); end;
end; str(nb,k);
close(fn); c:=copy(st,1,pos(' ',st)-1);
close(ft); sti:=sti+k+c
end; until ch='';
writeln(ft,sti);
end;
close(fn);
close(ft);
end;
55
procedure affichefn (var fn:nombre);

var
n:integer;
begin
reset(fn);
while not(eof(fn)) do
begin
read(fn,n);
writeln(n);
end;
close(fn);
end;
procedure afficheft(var ft:text);
var
ligne:string;
begin
reset(ft);
while not(eof(ft)) do
begin
readln(ft,ligne);
writeln(ligne);
end;
close(ft);
end;
begin
creation(fn,ft);
remplir(fn);
facteur2(fn,ft); { ou facteur1(fn,ft}
affichefn(fn);
writeln;
afficheft(ft);
end
56
La récursivité
57
Chap II La récursivité
La récursivité
I- Introduction
Activité 1 :
Calcul de la puissance an avec n>=0

52 = 5 * 5 = 25
53 = 5 * 5 * 5
= 5 * (5 * 5 ) = 5 * 52 =5 * 25 = 125
54 = 5 * 5 * 5 * 5
= 5 * (5 * 5 * 5 ) = 5 * 53 = 5 * 125 = 625
55 = 5 * 5 * 5 * 5 * 5
= 5 * (5 * 5 * 5 * 5 ) = 5 * 54 = 5 * 625 = 3125
En général pour calculer an on peut utiliser deux méthodes :
an = a * a * a * a *……….. * a  On appelle ce traitement: traitement itératif

an = a * an-1  on appelle ce traitement: traitement récursif
Traitement itératif Traitement récursif
Arrivée Départ
5 55 =5* 54
5 54 =5* 53
5 53 =5* 52
5 52 =5* 51
5 51 =5* 50
Départ Arrivé
Le traitement itératif : Le traitement récursif :
• Départ : info connue • Départ : info cherchée

• Descendre vers le connue
• Monter vers le résultat • Arrêt en bas : 0
• Monter vers le résultat
• Arrêt en haut : après 5 fois  Comment faire ? ? ?
 boucle Pour … faire
58
0) Def FN Puis ( a , N : entier ) : entier long 0) Def FN Puis ( a , N : entier) : entier long
1) P = [ P  1 ] 1) Si N = 0 Alors
Pour i de 1 à N faire Puis  1
PP*a Sinon
Fin Pour Puis a * Puis ( a , N – 1 )
2) Puis =[ ] Puis  P Fin si
3) Fin Puis 2) Fin Puis
Activité 2 : calcul de la factorielle d’un entier positif
• 2! = 1 * 2 = 2* 1
• 3! =3*2*1
=3*2!
• 4! =4*3*2*1
=4*3!
• 5! =5*4*3*2*1
=5*4!
En général pour calculer la factorielle d’entier n positif on utilise deux méthodes :
• N ! = 1 * 2 * 3 * 4 *…………….. * N  traitement itératif

• N!=N*(N–1)!  traitement récursif
Solution itérative :
0) Def FN Factorielle ( N : entier ) : entier long
1) F = [ F  1 ]
Pour i de 1 à N faire
FF*N
Fin Pour
2) Factorielle =[ ] Factorielle  F
3) Fin Factorielle
59
Solution récursive :
0) Def FN Factorielle ( N : entier) : entier long
1) Si N = 0 Alors
Factorielle  1
Sinon
Factorielle  N * Factorielle ( N – 1 )
Fin si
2) Fin Factorielle
II- Définition
La récursivité est une méthode algorithmique qui consiste à appeler un sous programme
dans son propre corps. Cette méthode permet de résoudre des problèmes où l’on doit itérer un
nombre de fois dépendamment du nombre de données.
Un sous programme récursif est un module qui s’appelle lui-même avec des nouvelles
valeurs des paramètres effectifs dans chaque appel jusqu'à une condition d’arrêt.
La limite technique de la récursivité est la mémoire stockant les données intermédiaires

des sous programmes, que nous appelons la pile. Cette dernière déborde lorsque le nombre des
appels devient important.
Remarque : il existe la récursivité directe et la récursivité croisée.
III- Applications :
Application 1 :
Nous proposons d’écrire un programme permettant de chercher et d’afficher la somme des

n premiers entiers.
1. Proposez une solution itérative et une solution récursive au module somme.
2. Déduirez les algorithmes correspondants.
60
Solution
0) Def Fn somme ( n : entier ) : entier
1) Si n = 0 alors
Somme  0
Sinon
Somme  n + Fn somme ( n – 1)
Finsi
2) Fin Somme
Application 2
Ecrire l’analyse puis l’algorithme d’un module qui permet de vérifier si une chaine donnée
non vide est palindrome ou non. ( exple : radar, été, aziza…)
1. Proposez une solution itérative puis une solution récursive.
Solution
0) Def Fn Palindrome ( ch : chaine ) : booléen
1) Si Long ( ch ) < 2 Alors
Palindrome  Vrai
Sinion
Si ch [ 1 ] = ch [ Long ( ch ) ] Alors
Palindrome  Fn Palindrome ( sous_chaine ( ch , 2 , Long ( ch ) – 2 ) )
Sinon
Palindrome  Faux
Finsi
Finsi
2) Fin Palindrome
61
Application 3
Ecrire l’analyse puis l’algorithme d’un module qui permet d’inverser une chaine donnée.
Proposez une solution itérative puis une solution récursive.
Solution
0) Def Fn inverse ( ch : chaine ) chaine
1) Si Long ( ch ) < 2 alors
Inverse  ch
Sinon
Inverse  ch [ Long ( ch ) ] + fn inverse ( sous_chaine ( ch , 2 , Long ( ch ) – 2 )) + ch [ 1 ]
Finsi
2) Fin inverse
Application 4
Nous proposant de trier un tableau T de n entiers dans l’ordre décroissant et en utilisant la

méthode par sélection.
1. Proposez une analyse au problème en utilisant un procédé itératif puis un procédé récursif.
2. Déduisez les algorithmes correspondants.
Solution
1) Def Proc TriSelect ( deb , Fin : entier var T : tab )
2) Pmax  Fn Max ( deb , fin , T )
3) Si Pmax <> deb alors
Proc Permut ( T , deb , Pmax )
Fin Si
4) Si deb + 1 <> fin alors
Proc triselect ( deb + 1 , fin , T )
Finsi
5) Fin Triselect
62
Application 5
Nous proposons de vérifier l’existence d’un entier k dans un tableau T contenant n entiers, en
utilisant la technique de la recherche dichotomique.
Solution
0) Def Fn dichotomique ( deb , fin , k : entier ; T : tab ) : booléen
1) m  ( deb + fin ) Div 2
2) Si k = T [ m ] Alors
Dichotomique  Vrai
Sinon
Si ( k < T [ m ] ) et ( deb < m ) Alors
Dichotomique  Fn Dichotomique ( deb , m-1, k , T )
Sinon
Si k > T [ m ] et ( m < fin ) Alors
Dichotomique  Fn Dichotomique ( m+1 , fin, k , T )
Sinon
Dichotomique  faux
Finsi
Finsi
Finsi
3) Fin Dichotomique
Application 6
Nous proposons de chercher le PGCD de deux entier positifs a et b.
63
Solution
0) Def Fn Pgcd ( a , b : entier ) : entier
1) Si b = 0 alors
Pgcd  a
Sinon
Pgcd  Fn Pgcd ( b , a mod b )
Finsi
2) Fin Pgcd
Application 7
Nous proposons de vérifier si un entier n positif est premier ou non.
Solution :
0) Def Fn Premier ( n , k : entier ) : boolèene
1) Si ( k <= n Div 2 ) Alors
Si n mod k = 0 Alors
Premier  Faux
Sinon
Premier  fn Premier ( n , k + 1 )
Finsi
Sinon
Premier  Vrai
Finsi
2) FinPremier
64
Série N° 6
Exercice N° 1
Soit l’algorithme de la fonction suivante :
1) Début def FN inconnue( a, b : entier) : entier
2) Si a = 1 Alors
Inconnue  b
Sinon
Si a mod 2 = 1 Alors
Inconnue  b + inconnue( a div 2 , b * 2)
Sinon
Inconnue  inconnue ( a div 2 , b * 2 )
Finsi
Finsi
3) Fin inconnue
Questions :
• Trouver inconnue ( 20 , 30 ) et inconnue ( 6, 6 ) ?
• Quel est le rôle de cette fonction ?
Exercice N° 2 :
Soit l’algorithme de la fonction Inconnue suivant :
0) Début fonction Inconnue ( n : entier ) : chaîne

1) [ i  2 ; ch  "" ] Répéter
Si ( n mod i = 0 ) Alors
Convch( i , ch1)
Ch  ch + ch1 + "."
N  n div I
Sinon
II+1
Finsi
Jusqu’a n =1
2) efface ( ch , long ( ch ) , 1 )
3) Inconnue  ch
4) fin Inconnue
Questions :
1/ Exécuter manuellement la fonction Inconnue pour n = 30 et pour n = 17.

2/ Donner le rôle de cette fonction.
3/ Proposer un algorithme récursif à cette fonction.
Exercice N° 3 :
Soit la suite U définie par :
U0=1
U1=2
Un=Un-1 + 2* Un-2
Ecrire l’analyse puis L’algorithme d’un module récursif qui permet de calculer le nième
terme de la suite U.
65
Exercice N° 4 :
Soit la procédure suivante :
0) Début procédure affichage ( i , n :entier )
1) Ecrire ( i )
2) Si ( i < n ) alors
Répéter
Si ( i = 1 ) alors
Affichage( i + 1 , n )
Finsi
ii+1
Ecrire ( i )
Jusqu’a ( i = n )
Finsi
3) Fin affichage
Questions :
1/ Que fait cette procédure avec l’appel suivant : affichage (1 , 4).

2/ Proposer une solution itérative qui réalise le même traitement.
Exercice N° 5 :
Soit l’algorithme suivant :
0) Début Fonction extraction ( ch1 : chaine ) : ………….
1) S  ""
2) Pour i de 1 à long ( ch1 ) Faire
Si ch1[ i ] dans ["0" . . "9" ] Alors
S  s + ch1 [ i ]
Finsi
FinPour
3) Fin Extraction
Questions
1/ Donner le type de résultat de cette fonction ainsi que les résultats pour les valeurs suivantes :
ch1="123ah5g", ch1="4ee".
2/ Quel est le rôle de cette fonction.
3/ Proposer une solution récursive pour cette fonction ( analyse+algorithme).
Exercice N° 6 :
0) Début procédure Quoi ( Var T : tab ; n : entier )
1) Pour i de 1 à n div 2 faire
Aux  T[ i ]
T[i]T[n–i+1]
T [ n – I + 1 ]  aux
FinPour
2) Fin Quoi
Questions :
1/ Exécuter manuellement l’algorithme de module précédent et donner la structure de tableau
après ce tournage.
2/ Quel est le rôle de cette procédure.
3/ Ecrire une procédure récursive réalisant le même traitement.
66
Exercice N° 7
On définie la suite U pour tout entier naturel n,
1
n≥1 par Un= ∑𝑛𝑛𝑘𝑘=1 𝑘𝑘 (𝑘𝑘 − 1 )
𝑛𝑛
Ecrire l’analyse et l’algorithme de la fonction U permettant de calculer le nème terme

de cette suite. Présenter deux solutions : itérative et récursive.
Exercice N° 8
La suite de Syracuse est définie par :
U0 = a avec a est un entier donnée >0
𝑈𝑈𝑈𝑈
Un+1 = si Un est pair
2
3 𝑈𝑈𝑈𝑈 + 1 Si Un est impair
1) Quel est l’ordre de récurrence de cette suite ? expliquer.

2) Calculer U1, U2, et U3 pour a=2 puis pour a=5 ?
3) Ecrire l’analyse d’un module récursif qui permet de calculer le nème terme de la suite de
Syracuse.
67
Série N° 7
Exercice N° 1
Soit l’algorithme de la fonction Inconnu suivante :

0) Début Def FN Inconnue (n : entier long) : entier
1) S=[S ← 0] Répéter
S ← S + (n Mod 10)
n ← n Div 10
Jusqu’a (n = 0)
2) Inconnue ← S
3) Fin Inconnue
Questions :
1. Exécuter manuellement l’algorithme de la fonction Inconnu, si on appelle cette
fonction avec le paramètre effectif n = 192837, en donnant les valeurs successives des
variables S et n.
2. En déduire le rôle de cette fonction.
3. Ecrire l’algorithme d’une fonction récursive réalisant le même traitement.
Exercice N° 2
Mat est un type utilisateur représentant un tableau d’entiers de 20 lignes et de 20 colonnes. On
donne l’algorithme de la procédure inconnue suivante :
0) DEF PROC Inconnue ( VAR M : MAT ; N ,i, j : Entier )

1) Si i <= N Alors
Si j <= i Alors
Aux  M [ i , j ]
M[ i , j ]  M [ j , i ]
M[ j , i ]  Aux
Proc Inconnue ( M , N i , j + 1 )
Sinon
Proc Inconnue ( M , N , i+1 , 1 )
Fin si
Fin si
2) Fin Inconnue
1. Exécuter manuellement l’algorithme de la procédure Inconnue avec les paramètres effectifs suivants :
N = 3 , i = 1, j = 1 et M =
9 6 0
4 5 2
3 7 1
2. En déduire le rôle de la procédure Inconnue.
68
Série N° 8
Exercice N° 1
On appellera totalgramme une chaîne dont chacun de ses mots commence et se termine
par la même lettre.
Ecrire une analyse et un algorithme d’un module récursif intitulé totalgramme qui permet
de vérifier si une chaîne de caractères est totalgramme
Exemple
La chaîne "ALLALA EMPRUNTE TEMPORAIREMENT À DAOUD SES SOULIERS " est
totalgramme
NOTE
On suppose que deux mots consécutifs sont séparés par un seul espace
Exercice N° 2
0) Fonction scalaire (A, B : tab ; n : entier):entier
1) P← (A[n]*B[n])
2) Pour c de n-1 à 1 faire ( pas = - 1 )
P← p + ( A [ c ] * B [ c ] )
Fin pour
3) Scalaire ← P
4) Fin scalaire
Travails demandés :
1/ Exécuter la fonction pour les valeurs suivantes et compléter la trace de la séquence.
N=4
A 3 0 2 7
B 5 6 7 0
Trace de la séquence
C P
2 / Préciser le rôle de la fonction :

……………………………………………………………………………………………………………………………………………
3/ donner l’algorithme récursif réalisant le même traitement.
……………………………………………………………………………………………………………………………………………
Exercice N°3
69
Soit T un vecteur de n entiers et f une fonction définie de la façon suivante :
f(n,T) = T[ n ] + f (n-1 , T ) pour tout n≠0

f(0,T)=0
1. Donner la trace d’exécution de la fonction f pour le cas suivant :
T 5 7 6 1
1 2 3 4
2. En déduire le rôle de la fonction f.
3. Donner un algorithme récursif de la fonction f.
4. Donner sous forme d’un algorithme la version itérative de la fonction f.
Exercice N°4
Soit la fonction suivante :
0) Fonction Quoi ( n : entier ) : booléen
1) i ← 1
2) Répéter
i←i+1
Jusqu’à ( n mod i = 0 ) ou ( i = n div 2 )
3) Quoi ← ( n mod i <> 0 )
4) Fin Quoi
• Exécuter manuellement la fonction quoi pour n = 17 et pour n = 25
• Quelle est le rôle de la fonction Quoi ?
• Ecrire une fonction récursive réalisant le même traitement.
Exercice N° 5
function Deviner ( CH : string ; K : integer ) : integer ;

var
I , P , C : integer ;
PH : string ;
begin
C:=0;
P:=1 ;
PH := '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' ;
for I := length (CH) downto 1 do
begin
C:=C+ ( pos( CH[ I ] , PH ) – 1 ) * P;
P := P * K ;
end;
Deviner := C ;
end;
Questions:
1. Compléter le tableau suivant, par les résultats de cette fonction, pour les valeurs suivantes de CH
et K
CH=’BAC’ et K=16 CH=’33’ et K=5 CH=’147’ et K=10
C =………………………. C=………………………………. C =……………………….
2. Quel est le rôle de cette fonction
Exercice N° 6
70

1) Début fonction inconnue (ch : chaîne) : booléen
2) Tr vrai
3) Ppos (‘‘ ’’, ch) // un seul espace
4) Tant que (P<>0) et (Tr = vrai)) faire
Si (ch [1] <>ch [P+1]) alors
Tr  faux
Sinon
Ch  sous_chaine (ch, P+1, long (ch)-P)
P  pos (‘‘ ’’, ch) // un seul espace
Finsi
5) Inconnue  Tr
6) Fin inconnue
Question :
Exécuter à la main la fonction inconnue pour chacune des chaînes suivantes :
Ch Résultat de la fonction
‘‘programme Pascal’’
‘‘algorithme’’
‘‘analyse avec algorithme’’
Exercice N° 7
Ecrire un algorithme de module récursif permettant de vérifier si un entier donné est
multiple de 5 en utilisant la méthode de différence.
Exemple :
15 est un multiple de 5 car
15-5 =10
10-5 =5
5-5=0
13 n’est pas multiple de 5 car
13-5
8-5=3
3<5
Exercice N°8
• Ecrire un programme modulaire qui permet de:

• Saisir deux entiers positifs n et m.
• Ecrire un programme calculant la fonction d'Ackerman définie par :
Ack(0,m) =m+1,
Ack(n, 0) = Ack(n-1, 1) si n est non-nul et
Ack(n,m) = Ack(n-1, Ack(n,m- 1)) sinon.
Vous devez utilisez un module récursif.
Traduire le programme en PASCAL.
Exercice N°9
Un nombre d’or est calculé par :
71
Ecrire un programme modulaire qui permet de:

• Saisir un entier positif n.
• Calculer et afficher le nombre d’or nbor(n)
• Vous devez utilisez un module récursif.
• Traduire le programme en PASCAL
Exercice N°10
0) Début Fonction Inconnu (n : entier long) : entier
1) S=[S ← 0] Repeter
S ← S + (n Mo 10)
n ← n Div 10
Jusqu’a (n = 0)
2) Inconnu ← S
3) Fin Inconnu
Questions :
1. Exécuter manuellement l’algorithme de la fonction Inconnu, si on appelle cette fonction avec le
paramètre effectif n = 192837, en donnant les valeurs successives des variables S et n.
3. L’algorithme de cette fonction est-il récurent ? si oui quel est son ordre. ?
Exercice N° 11
Soit la procédure suivante :

1) Procédure inconnu ( ……………….…….)
2) Pour i de 4 a n-1 faire
T[i]  T[i+1]
Finpour
3) Trouve  faux
4) P0
5) Pour i de 1 a n faire
Touve ( t[i] = x )
Si trouve alors
pi
Finsi
Finpour
6) Fin inconnue
Questions :
a) Compléter les paramètres de ce module
b) Exécuter manuellement l’algorithme de la procédure dans les deux cas suivants :
72
n=6 x=1
n=6 x=2
et le tableau T suivant :
3 8 0 1 7 2
Exercice N° 12
1) Fonction ghost ( x , n : entier) :………………………
2) Si (n = 1) alors
ghost  ( n = 1)
Sinon
si (x mod n =0) alors
ghost  (x < n-1)
sinon
ghost  ghost (x,n-1)
finSi
finsi
3) Fin ghost
Questions :
1) Quelle-est le type de la fonction ?
2) Exécuter cette fonction pour x=7 et n=6. Laisser une trace de l’exécution pas à pas.
3) Quelle-est le rôle de cette fonction si les paramètres d’appel sont x et x-1 : ghost (x,x-1)
Exercice N° 13
Soit l’algorithme de la procédure « inconnue » suivante :
0) DEF PROC inconnue (var ch : chaîne)
1) Si ch <> "" Alors
C  ch [ long (ch) ]
Efface ( ch , long(ch) , 1 )
Inconnue (c)
ch  c + ch
Fin Si
2) Fin inconnue
Questions :
a) Tourner à la main cette procédure avec les appels suivants en donnant la trace d’exécution de chaque
appel : inconnue(''elle''), inconnue(''modem'').
b) En déduire le rôle de cette procédure ?
Exercice N° 14
Que fait la fonction suivante ?

Def FN inconnu (c : caractère ; m : chaîne) : booléen ;
[ P  pos(C,M) ]
Si P ≠ 0 alors
Inconnu  Non ( inconnu (c , sous_chaine ( M , p+1 , long(M)-p) ))
Sinon
Inconnu  vrai
Fin si
Fin inconnu
EXERCICE N°15

73
0) Fonction Inconnue1 (X,Y :entier) :entier

1) Tant que (X <> Y) Faire
Si X > Y Alors
XX-Y
Sinon
YY-X
Fin Si
Fin TantQue
2) Inconnue  X
3) Fin Inconnue1
Questions
1°/ Exécuter manuellement cette fonction et trouver la valeur retournée pour :
a. X= 10 et Y=12
b. X= 17 et Y=8
2°/ Quel est le rôle de cette fonction.
3°/ Transformer cette fonction en une autre fonction utilisant un procédé récursif.
EXERCICE N°16
0) Fonction Inconnue2 (Ch :chaîne, C :caractère, N :entier) : Booléen
1) Si long(ch) = 1 Alors
Si ch[1] =C Alors
Inconnue2  ((N+1) MOD 2 =0)
Sinon
Inconnue2  (N MOD 2=0)
Fin Si
Sinon
Si ch[1] =C Alors
N  N+1
Fin Si
Inconnue2  Inconnue2 (Sous-chaine(ch,2, long(ch)-1), C, N)
Fin Si
1) Fin Inconnue2
Questions :
1°/ Exécuter manuellement cette fonction et trouver la valeur retournée pour :
a) ch= "lentement" , C="e" et N=0.
b) ch= "Fonctionnement" , C="n" et N=0.
2°/ Quel est le rôle de cette fonction.
3°/ Transformer cette fonction en une autre fonction utilisant un procédé itératif.
Exercice N°17
74
0) debut Fonction inconnu (n,b:entier) : chaine

1) ch <-- ""
2) Tant Que (n<>0) Alors
convch( n mod b , r)
Si (Long(r)> 1) Alors
Valeur(r,x,e)
r <-- Chr(x+55)
Fin Si
ch <-- r + ch
n <-- n Div b
Fin Tant Que
3) inconnu <-- ch
4) Fin Fonction
N.B : On donne le code ASCII de "A" est 65
Questions:
1- Exécuter la fonction pour les valeurs suivantes de n et b
a) n=94 et b =16
b) n=12 et b =2
2- Quel est le rôle de cette fonction.
3- Proposer une solution récursive pour cette fonction.
Exercice N°18
Soit l’algorithme suivant:
0) DEF FN Inconnue ( ch : chaîne ; c: caractère ): booléen
1) Si position ( c , ch ) = 0 alors
Inconnue vrai
Sinon
Efface (ch, position (c, ch) ,1);
Inconnue non (FN Inconnue (ch, c))
FinSi
2) Fin Inconnue
Questions :
a) Exécuter manuellement cette fonction pour :
- ch = '' pascal '' et c = '' s''
- ch = '' affiche '' et c = '' f ''
b) Donner le rôle de la fonction Inconnue.
Exercice N°19
0) DEFFN Inconnu (n : entier long) : entier
75
1) [ S  0 ] Répéter
S  S + (n Mod 10)
N  n Div 10
Jusqu’a (n = 0)
2) Inconnu  S
3) Fin Inconnu
Questions :
1) Exécuter manuellement l’algorithme de la fonction Inconnu, si on appelle cette fonction
avec le paramètre effectif n = 192837, en donnant les valeurs successives des variables S et
n.
2) En déduire le rôle de cette fonction.
3) Ecrire l’algorithme d’une fonction récursive réalisant le même traitement.
Exercice N°20
0) DEF FN Inconnu (n : entier) : ……………….
1) [ i  1 ] Répéter
i i+1
Jusqu’a ( n mod i = 0 ) ou ( I = n div 2 )
2) Inconnu  (n mod i <> 0 )
3) Fin Inconnu
Questions :
1) Quel type la fonction inconnue pourra-t-elle avoir et pourquoi ?
2) Déterminer : inconnue (9), inconnue (13)
3) En déduire le rôle de la fonction inconnue.
4) Ecrire l’algorithme d’une fonction récursive réalisant le même traitement
Exercice N°21
Ecrire une fonction récursive permettant de vérifier si 2 chaînes ch1 et ch2 sont-elles
«anagrammes » ou non.
NB : ch1 et ch2 sont anagrammes s’ils se composent des mêmes lettres.
Exemple : ch1 = « chien » et ch2 = « niche ».
Exercice N°22
Ecrire une fonction récursive permettant de retourner le PGCD de deux entiers positifs en
utilisant le principe de différence.
76
Les algorithmes de tris
77
Chap III Les algorithmes de tris
Les algorithmes de tris

I. Introduction
Rappel : Le tri à bulle
a) Algorithme itératif
0) Def Proc TriBulle ( Var T : Tab ; n : Entier )

1) Répéter
Ok  Faux
Pour i de 1 à ( n – 1 ) Faire
Si T [ i ] > T [ i + 1 ] Alors
Aux  T [ i ]
T[i]T[i+1]
T [ i + 1 ]  Aux
Ok  Vrai
Finsi
FinPour
Jusqu'à Non ( ok )
2) Fin TriBulle
b) Algorithme récursif
Procedure tribulle( var t : tab ; n , I : integer );

var
aux : integer;
begin
if ( n > 1 ) then
begin
if ( i < n ) then
begin
if ( T [ I ] > T [ i + 1 ] ) then
begin
aux : = T [ i ];
T [ i ] : = T [ i + 1 ];
T [ i + 1 ] : = aux;
end;
tribulle ( T , n , i + 1 )
end
else
Tribulle( T , n – 1 , 1 );
end;
end;
78
II. Tri par insertion :
Principe :
Soit le tableau T suivant :
44 8 5 11 7 15 2
1 2 3 4 5 6 7
8 44
5 8 44
5 8 11 44
5 7 8 11 44
5 7 8 11 15 44
2 5 7 8 11 15 44
a) Algorithme itératif Tri par Insertion
• version 1
0) Déf Proc TriInsertion ( Var T : Tab ;n : entier)
1) Pour i de 2 à n Faire
Si T [ i ] < T [ i – 1] Alors
Temp  T [ i ]
ji–1
Tant que ( j > 0) et ( T [ j ] < Temp ) Faire
T[j+1]T[j]
j  j -1
Fin Tant Que
T [ j + 1 ]  Temp
Fin Si
Fin Pour
2) Fin TriInsertion
79
• version 2
0) Déf Proc TriInsertion ( Var T : Tab ;n : entier)
Si T [ i ] < T [ i – 1] Alors
Temp  T [ i ]
proc Décaler ( T , i , p )
T [ p + 1 ]  Temp
Fin Si
Fin Pour
2) Fin TriInsertion
Algorithme procédure décaler
0) Déf Proc décaler ( Var T : Tab ; deb :entier ; Var fin : entier )
1) fin  deb – 1 , Temp  T [ deb ]
Tant que ( fin > 0 ) et ( T [ fin ] > Temp ) faire
T [ fin + 1]  T [ fin ]
fin  fin – 1
Fin Tant Que
2) Fin Décaler
b) Algorithme récursif Tri insertion
Procedure insert_rec ( var t : tab ; n : integer);

var
I , j , tmp : integer;
begin
if ( n > 1 ) then
begin
insert_rec ( t , n – 1 );
if ( t [ n ] < t [ n – 1 ] ) then
begin
tmp : = t [ n ];
j:=n–1;
while ( ( j > 0) and ( tmp < t [ j ] ) ) do
begin
t [ j + 1 ] : = t [ j ];
j:=j–1;
end;
t [ j + 1 ] : = tmp;
end;
end;
end;
80
III. Tri Shell
Principe :
Le tri Shell est une amélioration du tri par insertion. Au lieu de faire une rotation de tous
les éléments, nous ferons une rotation par pas de p ce qui permet d’affiner le tri du tableau et de
faire moins de déplacement d’éléments.
Nous commençons donc par un pas assez élevé et nous le diminuons au fur et à mesure
jusqu'à arriver à un pas de 1. Ceci permet d’éliminer les plus grands désordres pour abréger le
travail aux étapes suivantes. Le pas est diminué à l’aide d’une suite, mais il faut construire cette
suite de manière à ce que les valeurs ne soient pas multiples entre elles sinon nous allons traiter
des éléments et pas d’autres. Shell propose la suite d’incréments vérifiant :
P 0 =0
P n =3 * P n-1 +1
Activité :
Trier le tableau suivant dans l’ordre croissant selon la méthode de Shell
-5 30 0 -2 42 22 9 -4 10 15 40 -9 12 28 14
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Selon la suite Pn =3 * Pn + 1
P peut être = 1 ,4 ,13, 40 en déduire que les valeurs de pas sont : 13, 4 et 1.
81
Le tableau initial est :
-5 30 0 -2 42 22 9 -4 10 15 40 -9 12 28 14
• Pour le pas p =13
-5 30 0 -2 42 22 9 -4 10 15 40 -9 12 28 14
Algorithme Tri Shell ( itératif)
-5 14 0 -2 42 22 9 -4 10 15 40 -9 12 28 30
0) Déf Proc Trishell ( Var T : tab ; n : entier)
• Pour le pas p= 4
1) p 0
-5 14 0 -2 42 22 9 -4 10 15 40 -9 12 28 30
Tant Que ( p < n ) Faire
-5 14 0 -2 42 22 9 -4 10 15 40 -9 12 28 30
P 3 * p + 1
-5 14 0 -2 42 22 9 -4 10 15 40 -9 12 28 30
Fin Tant que
-5 14 0 -4 42 22 9 -2 10 15 40 -9 12 28 30
2) Tant que ( p <> 1 ) Faire
-5 14 0 -4 10 22 9 -2 42 15 40 -9 12 28 30
P  p Div 3
-5 14 0 -4 10 15 9 -2 42 22 40 -9 12 28 30
Pour i de (p + 1 ) à n Faire
-5 14 0 -4 10 15 9 -2 42 22 40 -9 12 28 30
Temp  T [ i ]
-5 14 0 -9 10 15 9 -4 42 22 40 -2 12 28 30
ji-p
-5 14 0 -9 10 15 9 -4 12 22 40 -2 42 28 30
Tant Que ( j > 0 ) et ( T [ j ] > Temp ) Faire
-5 14 0 -9 10 15 9 -4 12 22 40 -2 42 28 30
T [ j+p ]  T [ j ]
-5 14 0 -9 10 15 9 -4 12 22 30 -2 42 28 40
jj–p
• Pour le pas p = 1 Fin Tant Que
-5 14 0 -9 10 15 9 -4 12 22 30 -2 42 28 40 T [ j +p ]  Temp
-5 0 14 -9 10 15 9 -4 12 22 30 -2 42 28 40 Fin Pour
-9 -5 0 14 10 15 9 -4 12 22 30 -2 42 28 40 Fin Tant que
-9 -5 0 10 14 15 9 -4 12 22 30 -2 42 28 40 3) Fin TriShell
-9 -5 0 10 14 15 9 -4 12 22 30 -2 42 28 40
-9 -5 0 9 10 14 15 -4 12 22 30 -2 42 28 40
-9 -5 -4 0 9 10 14 15 12 22 30 -2 42 28 40
-9 -5 -4 0 9 10 12 14 15 22 30 -2 42 28 40
-9 -5 -4 0 9 10 12 14 15 22 30 -2 42 28 40
-9 -5 -4 0 9 10 12 14 15 22 30 -2 42 28 40
-9 -5 -4 -2 0 9 10 12 14 15 22 30 42 28 40
82
-9 -5 -4 -2 0 9 10 12 14 15 22 30 42 28 40
-9 -5 -4 -2 0 9 10 12 14 15 22 28 30 42 40
-9 -5 -4 -2 0 9 10 12 14 15 22 28 30 40 42
Algorithme itératif
0) Déf Proc Trishell ( Var T : tab ; n : entier)
1) p 0
Tant Que ( p < n ) Faire
P 3 * p + 1
Fin Tant que
2) Tant que ( p <> 1 ) Faire
P  p Div 3
Pour i de (p + 1 ) à n Faire
Si T [ i ] < T [ i – p ] Alors
Temp  T [ i ]
ji-p
Tant Que ( j > 0 ) et ( T [ j ] > Temp ) Faire
T [ j+p ]  T [ j ]
jj–p
Fin Tant Que
T [ j +p ]  Temp
Fin Si
Fin Pour
Fin Tant que
3) Fin TriShell
Algorithme Shell récursif
procedure shell_rec( var T : tab ; n , I , p : integer);

var
j , tmp : integer;
begin
if ( p > = 1 ) then
begin
if ( i < = n ) then
begin
tmp : = T [ i ];
j:=i;
83
while ( ( j > p ) and ( tmp <t [ j – p ] ) ) do

begin
T [ j ] : = t [ j – p ];
j:=j–p;
end;
t[ j ] : = tmp;
shell_rec( T , n , i + 1 , p );
end
else
begin
p : = p div 3;
i : = p + 1;
shell_rec( T , n , i , p );
end;
end;
end;
IV. Tri par fusion
Principe :
Il s’agit d’un tri suivant le paradigme « Diviser pour régner ». le principe est le suivant :
• Nous divisons le tableau à trier en deux sous tableaux.
• Nous trions chacun d’entre eux.
• Nous fusionnons les deux tableaux obtenus pour reconstituer le tableau trié.
Exemple :
Soit les deux tableaux suivants :
-5 -2 0 4 6 22 40 -7 0 8 8 12 28 35 39
T1 T2
-7 -5 -2 0 0 4 6 8 8 12 22 28 35 39 40
Application :
Ecrire un programme qui permet de :
• Remplir deux tableau triés T1 et T2 de n et m entiers respectivement avec ( n et m sont

deux entiers compris entre [ 2 . . 50 ] )
• Fusionner les deux tableaux T1 et T2 dans un tableau T qui sera tiré.
• Afficher le tableau résultat
84
Solution :
1. Analyse de programme principal T.D.O
Nom : Trifusion Objet Type/Nature Rôle
Résultat = Proc affiche ( T , n+m ) T Tab Tableau fusionné
T = [ ] Proc fusion ( T1 , T2 , n , m , T ) T1 Tab Tableau de n entiers
T2 = [ ] Proc Remplir ( T1 , n ) T2 Tab Tableau de m entiers
T3 = [ ] Proc Remplir ( T2 , m ) N Entier
Fin Trifusion M Entier
Remplir Procedure
T.D.N.T
Fusion Procedure
Type
affiche Procedure
Tab = tableau [ 1 .. 100 ] d’entier
2. Analyse de la procédure remplir

Def proc Remplir ( var V : tab ; var k : entier )
Résultat = V , n
V = [ ] V [ 1 ] = Donnée (‘’ Entrer le 1er element : ‘’)
Pour i de 2 à k faire
Répéter
V [ i ] = Donnée ( ‘’entrer V[ ‘, i , ‘ ] : ’ )
Jusqu'à ( V [ i ] > V [ i – 1 ] )
Fin Pour
k = [ ] Répéter
k = Donnée (‘’ Entrer le nombre d’élément : ‘’ )
Jusqu'à k dans [ 2 .. 100]
Fin Remplir
T.D.O
I Entire Compteur
85
3. Analyse de la procédure fusion
Def Proc fusion ( T1 , T2 :Tab ; n , m : Entier ; Var T : Tab )

Résultat = T
T = [ i 1 ; j  1 , k 0 ]
Répéter
Kk+1
Si T1 [ i ] < T2[ j ] Alors
T [ k ]  T1 [ i ]
ii+1
Sinon
T [ k ]  T2 [ j ]
jj+1
Fin si
Jusqu'à ( i > n ) ou ( j > m )
Si i < = n Alors
Pour r de i à n Faire
Kk+1 T.D.O
T [ k ]  T1 [ r ]
Fin pour Objet Type/Nature Rôle
Fin Si
I Entire Compteur
Si j <= m Alors
Pour r de j à m faire J Entire Compteur
Kk+1
T[ k ]  T2 [ r ] K Entire compteur
Fin pour
Fin Si
Fin fusion
4. Analyse procédure affiche
Déf proc Affiche ( V : Tab ; k : Entier )
Résultat = aff
Aff = [ ] Pour i de 1 à k faire
Ecrire ( V [ i ] )
Fin Pour
T.D.O
Fin Affiche
i Entire Compteur
86
V- Classement
Exercice :
Ecrire l’analyse puis l’algorithme d’un programme qui permet de remplir un tableau T par n
enregistrement qui définie n élèves ( nom et moyenne) avec 2 <= n <= 20 puis chercher le rang de
chaque élève selon leur moyenne.
1. Analyse programme principal
Nom : classement
Résultat = Proc Affiche ( T_El , n )
T_El = [ ] Proc saisie ( T_El , n )
Proc RechercheRang (T_El , n )

T.D.O
Fin Classement
T_El Tab Tableau d’enregistrement

T.D.N.T
Type N Entire Nombre des élèves
Fiche = Enregistrement Saisir Procedure

Nom : Chaine[20]
Moy : reél Ranger Procedure
Rang : entier
Fin fiche Affiche Procedure
Tab = Tableau [ 1 .. 20 ] de fiche
2. Analyse de la procédure saisir

Déf Proc saisie ( Var T_El : tab ; Var n : Entier )
Résultat = T_El , n
T_El = [ ] Pour i de 1 à n faire
El . Nom = Donnée(‘’ Entrer un nom : ‘’)
Répéter
El . moy = Donnée ( ‘’Entrer la moyenne :’’)
Jusqu'à ( El.moy >=0 ) et ( El . moy <= 20 )
T_El [ i ]  El
Fin Pour
N =[ ] Répéter
N = Donnée(‘’Entrer n : ‘’)
Fin saisir
87
3. Analyse de la procédure rang

Déf Proc rechercherang ( T_El : tab ; n : entier )
T.D.O
Résultat = T_El
T_El = [ ] Pour i de 1 à n faire
R  T_El [ i ] . moy
Nb  1 i Entier Compteur
Pour j de 1 à n faire
Si T_El [ j ] . moy > R Alors Nb Entier Le rang
Nb  Nb + 1
Fin Si
Fin Pour
T_El [ i ] . rang  Nb
Fin Pour
Fin rang
4. Analyse procédure affiche

Def Proc affiche ( T_El : Tab ; n : entier )
Résultat = aff
Aff = [ ] Pour i de 1 à n faire
Avec T_El [ i ] Faire
Ecrire ( ‘’Nom de l’élève : ‘’, Nom )
Ecrire (‘’ La moyenne : ‘’ , Moy )
Ecrire (‘’ le rang : ‘’, rang )
Fin avec
Fin Pour
Fin affiche
T.D.O
i Entier Compteur
88
Les tris : itératifs et récursifs
A- Le tri à bulle:
Solution iterative:
procedure bulle_itr(var t:tab;n:integer);
var
echange:boolean;
i,aux:integer;
begin
repeat
echange:=false;
for I : =1 to n-1 do
if ( t [ I ] > t [ I + 1 ] ) then
begin
aux : = t [ I ];
t [ I ] : = t [ I + 1 ];
t [ I + 1 ] : = aux;
echange : = true;
end;
until ( echange = false );
end;
Solution recursive
procedure bulle_rec( var t : tab ; n , I : integer );
var
aux : integer;
begin
if ( n > 1 ) then
begin
if ( I < n ) then
begin
if ( t [ I ] > t [ I + 1 ] ) then
begin
aux : = t [ I ];
t [ I ] : = t [ I + 1 ];
t [ I + 1 ] : = aux;
end;
bulle_rec ( t , n , I + 1 )
end
else
bulle_rec( t , n – 1 , 1 );
end;
end;
89
B- Le tri sélection
Solution itérative:
procedure sel_itr ( var t : tab ; n : integer);
var
aux,i,j,min:integer;
begin
for I : = 1 to n-1 do
begin
min : = i;
for j : = I + 1 to n do
if ( t [ j ] < t [ min ]) then
min:=j;
if(min<>i) then
begin
aux:=t[i];
t[i]:=t[min];
t[min]:=aux;
end;
end;
end;
Solution récursive:
procedure sel_rec(var t:tab;n,deb:integer);
var
i,min,aux:integer;
begin
if(deb <n ) then
begin
{recherche de minimum dans la partie de t(deb-->n) }
min:=deb;
for i:=deb+1 to n do
if (t[i]<t[min])then
min:=i;
{permuter t[min] et t[deb] }
if(min<>deb) then
begin
aux:=t[deb];
t[deb] :=t[min];
t[min]:=aux;
end;
sel_rec(t,n,deb+1);
end;
end;
90
C- Tri insertion
Solution iterative:
procedure insert_itr ( var t : tab ; n : integer );
var
I , j, tmp : integer;
beg in
for I : = 2 to n do
begin
if ( t [ I ] < t [ I – 1 ] ) then
begin
tmp : = t [ I ];
j:=I–1;
while ( ( j > 0 ) and ( tmp < t [ j ] ) ) do
begin
t[j+1]:=t[j];
j:=j–1;
end;
t [ j + 1 ] : = tmp;
end;
end;
end;
Solution recursive:
procedure insert_rec ( var t : tab ; n : integer);
var
I , j , tmp : integer;
begin
if ( n > 1 ) then
begin
insert_rec ( t , n – 1 );
if ( t [ n ] < t [ n – 1 ] ) then
begin
tmp : = t [ n ];
j:=n–1;
while ( ( j > 0) and ( tmp < t [ j ] ) ) do
begin
t [ j + 1 ] : = t [ j ];
j:=j–1;
end;
t [ j + 1 ] : = tmp;
end;
end;
end;
91
D- Tri Shell
Solution iterative:
procedure shell_itr(var t:tab;n:integer);
var
i,j,p,tmp:integer;
begin
p:=1;
while (p<n) do
p:=3*p+1;
while (p>1) do
begin
p:=p div 3;
for i:= p+1 to n do
begin
tmp:=t[i];
j:=i;
while((j>p) and (tmp<t[j-p])) do
begin
t[j]:=t[j-p];
j:=j-p;
end;
t[j]:=tmp;
end;
end;
end;
Solution recursive:
procedure shell_rec ( var t : tab ; n , I , p : integer );
var
j,tmp:integer;
begin
if(p>=1) then
begin
if(i<=n) then
begin
tmp:=t[i];
j:=i;;
while((j>p) and (tmp<t[j-p])) do
begin
t[j]:=t[j-p];
j:=j-p;
end;
t[j]:=tmp;
92
shell_rec(t,n,i+1,p);
end
else
begin
p:=p div 3;
i:=p+1;
shell_rec( t , n , I , p );
end;
end;
end;
93
Les algorithmes récurrents
94
Chap IV Les algorithmes récurrents
Les algorithmes récurrents

I. Introduction
Activité 1
Ecrire l’analyse d’un programme qui permet de calculer le nème terme des suites suivantes :
1- U0 = 1
U n = 2 * U n-1 +2 pour n >0
2- U0 = 1
U1 = 1
U n = 3 * U n-1 – U n-2 pour n > 1
Solution
1- analyse
Def Fn suite ( n : entier ) : entier
Résultat = suite T.D.O
Suite = Suite  U Objets T/N Rôle
U [ U0  1 ] pour i de 1 à n faire I Entier Compteur
U  2 * U0 + 2 U0 Entier Premier terme
U0  U
Fin pour
Fin suite
2 - analyse
Def Fn suite ( n : entier ) : entier
Résultat = suite
T.D.O
Suite = Suite  U
U= [ U0  0 , U1  1 ]
Objets T/N Rôle
Pour i de 2 à n faire I Entier Compteur
U3*U1–U0
U0 Entier Premier terme
U0  U1
U1 entier Deuxième terme
U1  U
Fin pour
Fin suite
95
Constatation :
On constate dans les deux analyses que pour calculer un terme on a besoin soit le terme
précédent ou les deux termes précédents, on appel ses traitements traitement récurent d’ordre 1
dans 1) et d’ordre 2 dans 2)
Retenons :
Un algorithme récurrent d’ordre p est un algorithme donnant un résultat dépendant des p

résultats précédents.
II. Calcul de somme

Activité 2
Nous voulons calculer la somme des éléments d’une matrice carrée d’entiers d’ordre n ( 4≤
n ≤ 20).
Questions :
1) Déterminez si ce traitement est récurrent. Dans l’affirmative donnez son ordre.

2) Proposez une analyse, puis déduisez l’algorithme de la fonction qui calcul la somme des
éléments de la matrice carré.
Solution
Def Fn sommeMat ( M : Mat ; n : entier ) : entier
Résultat = sommeMat T.D.O
sommeMat = [ ] sommeMat  S
S=[S0] pour i de 1 à n Faire Objets T/N Rôle
Pour j de 1 à n Faire
i Entier Compteur
SS+M[i,j]
j Entier compteur
Fin Pour
Fin Pour
Fin SommeMat
III. Algorithme récurrent sur les chaines

Activité 3 Suite thue-morse [Suite de chaine De caractères]
Ecrire l’analyse et l’algorithme d’un programme qui permet de déterminer le nème terme de
la suite définit par
U0 peut être soit ‘’0’’ soit ‘’1’’
Pour définir les autres termes remplacer a chaque fois ‘’0’’ par ‘’01’’ et ‘’1’’ par ‘’10’’.
96
U0 = ‘’0’’
U1=’’01’’
U2=’’0110’’
U3=’’01101001’’
Etc
1- Analyse de programme principal
Nom : suite_thueMorse
Résultat = Ecrire (‘’La suite de Thue Morse à partir de ‘’, A , ‘’est : ‘’, FN ThueMorse ( N , A ) )
N, A = [ ] Proc Saisie ( N , A )
Fin ThueMorse T.D.O
Objets T/N Rôle

A caractère ‘’0’’ ou ‘’1’’
N entier Nème terme
2- Analyse de l’analyse de la fonction ThueMorse
Def Fn ThueMorse ( N : entier ; A : caractère ) : chaine

Résultat = ThueMorse
ThueMorse = [ ] ThueMorse  Ch
Ch = [ Ch  A ] Pour i de 1 à N Faire
j 1
Répéter
Si Ch [ j ] = ‘’0’’ Alors
Insère ( ‘’1’’ , Ch , j + 1 )
Sinon
Insère ( ‘’0’’ , Ch , j + 1 )
Fin Si
T.D.O
L  long ( Ch ) Objets T/N Rôle
jj+2 Ch chaine Resultat
jusqu'à j > L L entier Longueur
J entier Compteur
Fin Pour
I entier compteur
Fin ThueMorse
97
IV. Triangle de Pascal

Activité 4
Nous voulons afficher les n premières ligne du triangle de Pascal ( 2 ≤ n ≤ 100 ).
Nous rappelons que le triangle de Pascal est définie par :
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
Questions :
1. Est-ce que ce traitement est récurrent ? Dans l’affirmative donnez son ordre ?
2. Proposez une analyse au problème en utilisant un procédé itératif puis un procédé
récursif ?
A- Solution itérative
Nom : Triangle_Pascal
Résultat = Proc Affiche ( M , N )
M =[ ] Proc remplir ( M , N ) T.D.O
N = [ ] Proc saisie ( N ) Objets T/N Rôle
Fin Triangle_Pascal M Mat Matrice
T.D.N.T N Entier Nbre elements
Remplir Procédure Remplir triangle de pascal
Type Saisie Procédure Saisir n
Mat = Tableau [ 1.. 100 , 1 . . 100 ] d’entier Affiche Procédure Affiche la matrice
98
2- Analyse procédure Affiche
Def Proc Affiche ( M : Mat ; N : entier )
Résultat = aff
Aff =[ ] Pour i de 1 à N faire
Pour j de 1 à N Faire
Ecrire ( M [ i , j ] ) T.D.O
Fin Pour Objets T/N Rôle
Fin Pour I Entier Compteur
Fin Affiche j Entier Compteur
Déf Proc saisie ( Var N : entier )
Résultat = N
N =[ ] Répéter
N = Donnée (‘’ Entrer le nombre des éléments : ‘’)
Jusqu'à N dans [ 2 .. 100 ]
Fin saisie
4- Analyse procédure remplir
Déf Proc Remplir ( Var M : Mat ; N : entier )

Résultat = M
M = [ M [1 , 1 ]  1 , M [ 2 , 1]  1 , M [ 2 , 2 ]  1 ]
Pour i de 3 à N faire
M[i,1]1
M[i,i]1 T.D.O
Pour j de 2 à ( i – 1 ) Faire
M[i,j]M[i–1,j–1]+M[i–1 ,j]
Fin Pour Objets T/N Rôle
Fin Pour
Fin Remplir I Entier Compteur
j Entier compteur
99
B- Solution récursive
1- Analyse de la procédure remplir
Def Proc Remplir ( Var M : Mat ; N : entier )
Résultat = M
M =[ ] Pour i de 1 à n Faire
Pour j de 1 à i Faire
T.D.O
M [ i , j ]  Fn Val_Triangle ( i , j )
Objets T/N Rôle
Fin Pour
I Entier Compteur
Fin Pour J Entier compteur
Val_Triangle Fonction
Fin Remplir
2- Analyse de la fonction Val_triangle
Def FN Val_Triangle ( x , y : entier ) : entier

Résultat = Val_Triangle
Val_Triangle = [ ]
Si ( x = 1 ) ou ( x = y ) Alors
Val_Triangle  1
Sinon
Val_Triangle  Fn Val_Triangle ( x - 1 , y -1 ) + Fn Val_Triangle ( x – 1 , y – 1 )
Fin Si
Fin Val_Triangle
V. La suite de Fibonacci
Activité 5
La suite de Fibonacci est définit par
U1 =1
U2 =1
Un = Un-1 + Un-2
Ecrire une analyse puis un algorithme qui permet de calculer le nème terme de la suite ?
a- Proposez une solution itérative
b- Proposez une solution récursive
c- utilisez un tableau pour calculer le nème terme de la suite
c- Donnez l’ordre de récurrence de la suite
100
1. Solution itérative
Analyse de la fonction fibo
Déf Fn fibo ( n : entier ) : entier

Résultat = fibo
Fibo = [ ] Fibo  U
U =[ U1  1, U2  1] T.D.O
Pour i de 3 à n Faire Objets T/N Rôle
U  U1 + U 2
U1  U2 I Entier Compteur
U2  U
U1 Entier 1er terme
Fin pour
Fin fibo U2 Entier 2ème terme
2. Solution récursive
U Entier Nème terme
Analyse de la fonction fibo
Déf Fn fibo ( n : entier ) : entier

Résultat = fibo
Fibo = [ ] Si ( n =1 ) ou ( n= 2 ) Alors
fibo  1
Sinon
Fibo  FN Fibo (n-1 ) + FN Fibo ( n- 2 )
Fin si
Fin Fibo
VI. Le nombre d’Or :
Activité 6
Soit U est la suite de fibonacci et V est défini par
U1 = 1
U2 = 1
Un = Un-1 + Un-2 pour n >2
Vn = Un / Un-1 pour tout n >1
1) Ecrire un programme Pascal qui permet de chercher et d’afficher les n premiers termes de
la suite U (utilisez la solution récursive). Remplir la 2ème colonne du tableau au dessous.
2) Modifier le programme pour calculer et afficher les n premiers terme de la suite V. remplir
la 3ème colonne du tableau au dessous.
3) Que remarquez-vous ?
4) Ecrire l’analyse et l’algorithme permettant de chercher le terme et le rang de la suite V
vérifiant │ Vn – Vn-1 │ < e (avec e =10-5).
101
program nombreor;
uses wincrt;
var
N Fibo ( n ) Vn = Fibo ( n ) / fibo (n-1)
i,n : integer;
1 1 -
procedure saisie (var n : integer );
2 1 1 begin
3 2 2 repeat
4 5 1.5 write(' Entrer un entier n : ');
5 8 1.666 readln( n );
6 13 1.600 until n > 0 ;
7 21 1.625 end ;
function fibo ( n : integer ) : integer ;
8 34 1.61538
begin
9 55 1.61904
if ( n = 1 ) or ( n = 0 ) then
10 89 1.61764 begin
11 144 1.61818 fibo := 1 ;
12 233 1.617977 end
13 377 1.61805 else
14 610 1.6802 begin
15 987 1.6803 fibo := fibo ( n - 1) + fibo ( n -2 ) ;
end;
16 1597 1.6803
end;
17 2584 1.6803
begin
18 4181 1.6803 saisie ( n );
19 6765 1.6803 for i := 1 to n do
begin
writeln ( i , ' ', fibo ( i ) , ' ', fibo ( i ) / fibo ( i -1 ) ) ;
end;
end.
Réponse :
1) et 2) voir le tableau au dessus.

3) On remarque que les valeurs de la suite V deviennent stable a partir n = 13 ( 1.618 ). Ce nombre
est appelé Nombre d’or.
Définition
La suite (Vn) définie sur N*
par Vn = Fibo (n+ 1 ) / Fibo ( n )
Semble converger vers (phi)
1+ √5
φ = = 1.618
2
Appelé nombre d’or, dont une valeur approchée est 1.618.
Autrement dit, le nombre d’or est la solution positive de l’équation x2-x-1=0 qui est le nombre
P P
1+ √5
2
102
4) Analyse de la procédure nombreOr

Déf proc NombreOr ( epsilon : réel , var V : réel ; n : entier )
Résultat = V , N
V,N=[ N2,V1]
Répéter
NN+1
V0  V
V  Fibo ( n ) / Fibo ( n – 1 )
Jusqu'à abs ( V – V0 ) < epsilon
Fin nombreOr
T.D.O
Objets T/N Rôle
N Entier Nombre
V0 Entier Premier terme
103
Série N ° 8
Exercice N° 1
Soit la suite de ROBINSON Définie par:
Ui = a ( a est un chiffre)
Ui+1 = Nombre d’apparition de chaque chiffre dans Ui
Chaque terme de la suite se construit ensuite en comptant le nombre d'apparitions des
différents chiffres de 9 à 0 (dans cet ordre) dans le terme précédent. Si un chiffre n'apparaît pas, il
n'est pas pris en compte.
Exemple :
Si U0=0 alors
U1 = 10 « 0 se répète 1 fois dans U0 »
U2 = 1110 « 1 se répète 1 fois dans U1 , 0 se répète 1 fois dans U1»
U3 = 3110 « 1 se répète 3 fois et 0 se répète 1 fois dans U2 »
U4= 132110
U5 = 13123110
U6 = 23124110
U7 = 1413223110
U8 = 1423224110
U9 = 2413323110...
Questions :
1) Quel est l’ordre de récurrence de cette suite
2) Ecrire un algorithme modulaire permettant de déterminer et d’afficher le néme terme de cette
suite (2<N<20)
Exercice N° 2 :
Soit la suite suivante définie par :
U0 = 1
(- 2) n
Un =
2 * Un-1
1) C’est quoi un algorithme récurrent ?

2) Donner la valeur de U 1 et U 2
3) Quel est l’ordre de récurrence de cette suite ?
4) Ecrire l’algorithme d’un module permettant de déterminer pour un entier n le terme U n .
104
Exercice N° 3 :
Soit la suite U définie par :
U0=1
U1=2
Un=Un-1 + 2* Un-2
Ecrire l’analyse puis L’algorithme d’un module récursif qui permet de calculer
le nième terme de la suite U.
Exercice N° 4 :
La suite de Syracuse est définie par :
U0 = a avec a est un entier donnée >0
𝑈𝑈𝑈𝑈
Un+1 = si Un est pair
2
3 𝑈𝑈𝑈𝑈 + 1 Si Un est impair

4) Quel est l’ordre de récurrence de cette suite ? expliquer.
5) Calculer U1, U2, et U3 pour a=2 puis pour a=5 ?
6) Ecrire l’analyse d’un module récursif qui permet de calculer le nème terme de la suite de
Syracuse.
Exercice N° 5 :
On se propose de remplir une matrice M sous la forme d’une pyramide d’entier de la
manière suivante
Exemple : n=5
1
232
34543
4567654
567898765
Ecrire un programme qui permet de remplir et d’afficher une matrice M carré d’ordre n ( avec
2<=n<=10 )
105
Exercice N° 6 :
On appelle masse d’un nombre, la somme du rang dans l’alphabet français de chaque lettre
contenu dans ce nombre. Une lettre a le même rang qu’elle soit écrit en majuscule ou en
minuscule.
UN  21 + 14 = 35
On appelle « nombre autocode », si la somme ainsi formée = le nombre lui-même.
Exemple :
DEUX CENT CINQUANTE HUIT
54 + 42 + 105 + 58 = 258
Ecrire un programme qui permet de saisir n chaine (représentent des nombres) et ses
équivalent numérique (selon l’exemple), vérifié si le nombre est autocode ou non. Enregistrer le
résultat dans un fichier texte selon l’image suivante.
DEUX CENT CINQUANTE HUITE 258 Masse nombre autocode/non autocode.
Exercice N° 7 :
En mathématique, un nombre automorphe est un nombre entier dont le carré se termine par un
même chiffre ou les mêmes chiffres que celui ou ceux du nombre lui-même.
Exemple :
52 = 25
762 = 5776
8906252= 793212890625
Ecrire un programme qui permet de vérifier si un entier donné est automorphe ou non.
106
Les algorithmes d’arithmétique
107
Chap V Les algorithmes d’arithmétique
Les algorithmes d’arithmétique

I. Préambule :
L’arithmétique est une branche des mathématiques qui étudie les relations entre les nombres.
C’est aussi l’étude des nombres et des opérations élémentaires entre eux.
II. Calcule du PGCD (solution récursive) :

Activité :
Il y a deux méthodes pour calculer le PGCD de deux nombres. Il y a la méthode de la

division et la méthode de la différence.
Exemple :
• Méthode de la division
PGCD ( 22 , 6 ) = PGCD ( 6, 22 mod 6) = PGCD ( 6 , 4 ) = PGCD ( 4 , 6 mod 4 )
= PGCD ( 4 , 2 ) = PGCD( 2 , 4 mod 2 ) = PGCD ( 2 , 0) = 2
• Méthode de la différence :
PGCD ( 22 , 6 ) = PGCD ( 22-6 , 6 ) = PGCD (16 , 6 ) = PGCD ( 16 – 6 , 6 ) = PGCD ( 10 , 6 )
= PGCD ( 10-6, 6) = PGCD ( 4 , 6 ) PGCD ( 4 , 6 -4 ) = PGCD ( 4 , 2 )
= PGCD ( 4 – 2 , 2 ) = PGCD ( 2 , 2 ) = 2
Ecrire une analyse, puis déduisez un algorithme d’une fonction permettant de calculer le PGCD de
deux entiers positifs non nuls a et b, en utilisant la méthode de la différence.
Solution :
a- Solution itérative :
Analyse de la fonction PGCD

Déf Fn PGCD ( a, b : entier ) : entier
Résultat = PGCD
PGCD = [ ] PGCD  a
a = [ ] Tant que ( a <> b ) faire
Si a > b Alors
aa–b
Sinon
bb–a
Fin si
Fin tant que
Fin PGCD
108
b- Solution récursive:
Déf Fn PGCD ( a , b : entier ) : entier
Résultat = PGCD
PGCD = [ ] Si a = b Alors
PGCD  a
Sinon
Si a > b Alors
PGCD  Fn PGCD ( a – b , b )
Sinon
PGCD  FN PGCD ( a , b – a )
FinSi
FinSi
Fin PGCD
III. Calcul A p n et C p
n
Définition :
n!
• Arrangement de p éléments parmi n : Ap
n= = n(n-1)(n-2).....(n-p+1)
(n-p)!
C’est le nombre de permutants ordonnés possibles de p éléments parmi n
Exemple avec {a,b,c} : A(2,3)=6
{a,b},{b,a},{a,c},{c,a},{b,c},{c,b}
p Ap
n n!
• Combinaison de p éléments parmi n : C n = =
p! p!(n–p)!
C’est le nombre de permutations sans ordre possibles de p éléments parmi n
Exemple avec {a,b,c} : C(2,3)=3
{a,b}, {a,c}, {b,c}
a- Proposez une analyse puis déduisez les algorithmes correspondants au problème

permettant de chercher puis d’afficher l’arrangement et la combinaison de deux entiers
donnés n et p, avec (1<=p<=n).
b- Proposez une solution récursive sachant que
𝑝𝑝 𝑝𝑝 𝑝𝑝−1
𝐶𝐶𝑛𝑛 = 𝐶𝐶𝑛𝑛−𝑝𝑝 + 𝐶𝐶𝑛𝑛−𝑝𝑝
𝐶𝐶𝑛𝑛0 = 𝐶𝐶𝑛𝑛𝑛𝑛 = 0
109
Corrigé :
Calcul et affichage de l’arrangement de deux entiers positifs
1- Analyse du programme principal
Nom : arrangement
Résultat = Ecrire (‘l’’arrangement de ‘, n ,’ et ‘,p , ‘= ‘ , Fn Arrange ( n ,p ) )
n , p = [ ] Proc Saisie ( n , p )
Fin arrangement
T.D.O
n Entier Donné
p Entier Donné
Saisie Procédure Permet de saisir a et b
arrange Fonction Permet de calculer l’arrangement
2- analyse de la procédure saisie
Déf Proc saisie ( var n , p : entier )

Résultat = n , p
n , p = [ ] Répéter
n = Donnée( ‘ entrer n : ‘)
Jusqu'à (n ≥0)
p = [ ] Répéter
p = Donnée ( ‘ entrer p :’ )
Jusqu'à ( p ≥ 0 ) et ( p ≤ n )
Fin saisie
3- analyse de la fonction Arrange
Déf Fn Arrang ( n , p : Entier ) : Entier T.D.O
Résultat = Arrange Objet Type/Nature Rôle
Arrange = [ ] Arrange  A A Entier Arrangement

i entier compteur
A = [ ] Pour i de n à ( n-p + 1 ) Faire
AA*i
Fin Pour
110
Calcul de la combinaison :
Version 1 :
1- analyse du programme principal
Nom = combinaison
Résultat = Ecrire (‘ La combinaison de deux entiers ‘, n , ‘ et ‘, p ,’ est = ‘, Fn Comb ( n , p ) )
n , p = [ ] Proc Saisie ( n , p )
Fin combinaison T.D.O
N Entier Nombre
P Entier Nombre
i Entier compteur
Saisie Procedure Lecture n et p
comb Procédure combinaison
2 – Analyse de la fonction Comb
Déf Fn Comb ( n , p : Entier ) : Entier
Résultat = Comb
Comb = [ ] Comb  Fn Fact ( n) / ( Fn Fact (p ) * FN Fact (n – p ))
Fin Comb
T.D.O
Fact Fonction Calcul la factorielle

Version 2
Analyse de la fonction Comb
Déf Fn Comb ( n , p : Entier ) : Entier
Résultat = Comb
Comb = [ ] Si ( p = 0 ) ou ( p = n ) Alors
Comb  1
Sinon
Comb  Comb ( n -1 , p ) + Comb ( n – 1 , p – 1 )
Fin si
Fin Comb
111
IV. Quelques règles de divisibilité :
Dans cette partie du chapitre, les problèmes ne seront pas résolus directement avec l’operateur
arithmétique Mod. Nous allons, par contre, analyser quelques problèmes répondant aux règles de
divisibilité appropriées.
N.B : Ces règles sont généralement applicables pour les grands nombres.
1) Divisibilité par 3
• Définition :
Un entier est divisible par 3, si la somme des chiffres qui le composent est divisible par 3.
• Application 1 :
Ecrire un programme qui permet de vérifier si un entier n est divisible par 3 ou non. Avec n est un
entier très grand.
1- analyse du programme principal
Nom : application1
Résultat = aff
Aff = [ ] Si Fn div3 ( s) Alors
Ecrire (‘l’’entier ‘, s , ‘ est divisible par 3‘)
Sinon
Ecrire (‘’ l’entier ‘,s,’ n’est pas divisible par 3’)
Fin si
S = [ ] Proc saisie ( s) T.D.O
Fin application1
s Chaine Nombre
Div3 Fonction Vérifier si un nombre est divisible par 3 ou non
Saisie Procédure Lecture de s
2- analyse procédure saisie
Def Proc saisie ( var s : chaine )

Résultat = s T.D.O
S=[ ] Répéter
S = donnée (‘’ entrer un nombre : ‘’)
Jusqu'à (Fn Vérif( s) ) verif fonction Vérifier si le nombre est
Fin saisie formé que par des chiffres
112
3- Analyse de la fonction Div3
Déf Fn Vérif ( s : chaine ) : booléen
Résultat = Vérif
Vérif = [ ] Vérif  b
b = [ b  Vrai ] Tant que ( b ) et ( i ≤ long ( s ) ) faire
Si ( Non ( S[ i ] dans [ ‘’0’’ . . ‘’9’’] ) Alors
b  Faux
Fin si
T.D.O
ii+1
Fin Tant que
B Booléen Vrai/faux
Fin Vérif
I Entier compteur
Déf Fn Div3 ( s : string ) : booléen

Résultat = Div3
Div3 = [ ] Div3  ( r mod 3 = 0 )
r = [ r  0] Pour i de 1 à long (s) faire
Val ( s [ i ] , n , e)
r r+n
Fin pour
Définition :
Un entier est divisible par 4, si le nombre composé des deux derniers chiffres est divisible
par 4.
Application 2 :
Ecrire une analyse qui permet de vérifier si un entier donné est divisible par 4 ou non.
Exemple : 4120 est divisible par 4

4121 n’est pas divisible par 4
113
Nom : divisibilite4
Résultat = aff
Aff = [ ] Si Fn div4 ( s) Alors
Sinon
Fin si
S = [ ] Proc saisie ( s)
Fin divisibilité
Déf Proc saisie ( var s : chaine )
Résultat = s
S=[ ] Répéter
T.D.O
Jusqu'à (Fn Vérif( s) )
verif fonction Vérifier si le nombre est
Fin saisie formé que par des chiffres
Résultat = Div4 T.D.O

Div3 = [ ] Div4  b Objet Type/Nature Rôle
b = [ ] val ( sous_chaine( s , long( s ) – 1 , 2) , r , e) b Booléen Divisible ou non

r Entier Nombre
b  ( r mod 4 = 0 )
e Entier erreur
Fin div4
Définition :
Un entier est divisible par 5, si son chiffre des unités est egal à 0 ou à 5.
Exemple : 6287 n’est pas divisible par 5
6570 est divisible par 5
4325 est divisible par 5
114
Application 3 :
Ecrire une analyse puis un algorithme d’un programme qui permet de vérifier si un entier
est divisible par 5 ou non utilisant les règles de divisibilité.
Nom : divisibilite5
Résultat = aff
Aff = [ ] Si Fn div5 ( s ) Alors
Sinon
Fin si
S = [ ] Proc saisie ( s )
Fin divisibilité
Déf Proc saisie ( var s : chaine)
Résultat = s
S=[ ] Répéter
Jusqu'à ( Fn Vérif ( s ) )
Fin saisie
Résultat = Div5
Div5 = [ ] Div5  ( s [ long( s ) ] = ‘’0’’ ou s [ long ( s ) ] = ‘’5’’ )
Fin div4
4) Autre règle de divisibilité

• Un entier est divisible par 2, si son chiffre des unités est divisible par 2.
• Un entier est divisible par 9, si la somme de ses chiffres est divisible par 9.
• Un entier est divisible par 25, si le nombre composé des deux derniers chiffres est divisible
par 25.
115
Application 4
Soit n = 571u où u désigne le chiffre des unités dans l’écriture décimal de n. écrivez un
programme permettant de chercher et d’afficher les valeurs respectives de u et de n pour
lesquelles l’entier n sera divisible par 4 et par 3.
Nom : application4
Résultat = Proc Affiche ( n )
N = [ ] n  ‘’571u’’
Fin application4
Déf Proc affiche ( n : chaine )
Résultat = aff
Aff = [ s  13 ] Pour u de 0 à 9 faire
Si (( s + u ) mod 3 = 0 ) et (( 10 + u ) mod 4 = 0 ) Alors
m  5710 + u
Ecrire (‘’pour n elle peut être ’’,m , ‘’pour u = ‘’, u)
Fin si
Pour
Fin affiche
T.D.O
U Entier Un chiffre
S Entier La somme des chiffres
m entier Résultat
116
V Conversion entre bases de numération :
Rappel sur les bases de numération :
Base 2 ou binaire={0,1}
Base 8 ou octal ={0, 1, 2, 3, 4, 5, 6, 7}
Base 10 ou décimal {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
Base 16 ou hexadécimal = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F}
Conversion entre les bases :
B8
B10 B2
B16
1) Conversion de base 10 à une base b :
Exemple :
Convertir les nombres décimaux à ses équivalents à la base 2, 8 et 16 :
• ( 7 4 ) 10 = ( ) 2 = ( 1 0 0 1 0 1 0 )2
• ( 7 4 ) 10 = ( ) 8 =( 112)8
• ( 7 4 0 ) 10 = ( ) 16 = ( 2 E 4 ) 16
74 2 740 16
74 8
0 37 2
2 9 8 4 46 16
1 18 2
0 9 2 1 1 8 14 2 16
1 4 2 1 0 2 0
0 2 2
0 1 2
1 0
( 740 ) 10 = ( 2 (14) 4 ) 16 = ( 2 E 4)16
( 74 ) 10 = ( 1001010 ) 2 ( 74 ) 10 = ( 112 ) 8
117
Analyse de la fonction convb10_b
Déf Fn convb10_b ( n , b : entier ) : chaine

Résultat = convb10_b
Convb10_b = [ ] convb10_b  Rch
Rch = [ Rch  ‘’’’ ] Répéter
R  n mod b
N  n div b
Str ( R , Ch )
Si R ≤ 9 Alors
RCh  Ch + Rch
Sinon
Rch  Chr ( 55 + R ) + Rch
Fin si
Jusqu'à ( N = 0 )
T.D.O
Fin convb10_b
R Entier Reste de la division
Ch Chaine Conversion du reste a une chaine
Rch chaine Résultat sous forme une chaine
2) Conversion d’une base b à la base 10 :
Convertir les nombres suivants à la base 10 :

• ( 1 0 0 1 0 1 0 ) 2 = ( ) 10
• ( 1 1 2 ) 8 = ( ) 10
• ( 2 E 4 ) 16 = ( ) 10
• ( 1 0 0 1 0 1 0 ) 2 = ( ) 10
( 1 0 0 1 0 1 0 ) 2 = 1 * 2 6+ 0 * 2 5+ 0 * 2 4+ 1 * 2 3+ 0 * 2 2+ 1 * 2 1+ 0 * 2 0
6 5 4 3 2 1 0 = ( 7 4 ) 10
• ( 1 1 2 ) 8 = ( ) 10
( 1 1 2 ) 8 = 1 * 8 2+ 1 * 8 1+ 1 * 8 0
2 1 0 = ( 7 4 ) 10
• ( 2 E 4 ) 16 = ( ) 10
( 2 E 4 ) 16 = 2 * 16 2 + E * 16 1 + 4 * 16 0
2 1 0 = ( 7 4 0 ) 10
118
Analyse de la fonction convb_b10
Déf Fn convb_b10 ( ch : chaine ; b : entier ) : entier
Résultat = convb_b10
Convb_b10 = [ ] convb_b10  R
R= [ R  0 ] Pour i de 1 à long ( ch ) Faire T.D.O
Si ch [ i ] dans [‘0’ .. ‘9’ ] Alors
Val ( ch [ i ] , k , e )
Sinon R Entier Resultat
K  Ord ( ch [ i ] ) – 55
k entier Un chiffre
Fin si
R  R + k * Fn Puis ( b , long( ch ) – i ) i entier Compteur
Fin Pour
e entier erreur
Fin convb_b10
Analyse de la fonction Puis
Déf Fn Puis ( a , p : entier ) : entier

Résultat = Puis
Puis = [ ] Si p = 0 Alors
Puis  1
Sinon
Puis  a * Fn Puis ( a , p – 1 )
Fin si
Fin Puis
119
3) Conversion de base 2 à une base b8 ou b16:
Exemples :
Convertir les nombres binaires à ces équivalents en octal et en hexadécimal.
- (10110)2=()8
- ( 1 0 1 1 0 0 ) 2 = ( ) 16
• (10110)2=()8
(10110)2 =( 010 110 )2
= ( 2 6 )8
2 = 0*22 + 1 * 21 + 0 * 20 6 = 1 * 22 + 1 * 21 + 0 * 20
• ( 1 0 1 1 0 0 ) 2 = ( ) 16
(101100)2 = (0010 1100 )2
= ( 2 C ) 16
2 = 0 * 23 + 0* 22 + 1 * 21 + 0 * 20 C = 12 = 1 * 23 + 1 * 22 + 0 * 21 + 0 * 20
Analyse de la fonction convb2_b8b16
Analyse de la fonction conb2_b8b16
Déf Fn convb2_b8b16 ( ch : chaine , b : entier ) : chaine

Résultat = Convb2_b8b16
Convb2_b8b16 = [ ] convb2_b8b16  Rch
Rch = [ Rch  ‘’’’ ]
Tant long ( ch ) mod p <> 0 ) Faire
Ch  ‘’0’’ + Ch
Fin tant que
Tant que Ch <> ‘’’’ Faire
Rst  sous_chaine ( Ch , 1 , p )
Efface ( ch , 1 , p )
R0
Pour i de 1 à long ( Rst) faire
Val( Rst [ i ] , k , e)
R  R + k * Fn Puis ( 2 , long (Rst ) – i )
Fin pour
120
Si R ≤ 9 Alors
Str ( R , st ) T.D.O
Sinon
St  chr ( 55 + R ) Objet Type/Nature Rôle
Fin si R Entier Un chiffre

Rch  Rch + st k entier Un chiffre
Fin tant i entier Compteur
P =[ ] Si b = 8 Alors e entier Erreur
P3 Rch chaine Résultat
Sinon P entier Nombre de chiffres
P4 Rst chaine Partie du nombre
St chaine Partie du nombre
Fin Si
Fin convb2_b8b16
4) Conversion de base b8 ou base b16 à une base b2:
Exemple :
Convertir les nombres suivants en binaire.
- (215)8=( )2
- (7 3 C ) 16 = ( ) 2
• (215)8=( )2
(215)8 = ( 2 1 5 )8
= ( 010 001 101 ) 2

=(10001101)2
• (7 3 C ) 16 = ( ) 2
(7 3 C ) 16 = ( 7 3 C ) 16
= ( 0111 0011 1100 ) 2
=(11100111100)2
121
Analyse de la fonction convb8b16_b2
Def Fn convb8b16_b2 ( ch : chaine , b : entier ) : chaine

Résultat = convb8b16_b2
Convb8b16_b2 = [ ] convb8b16_b2  Rch
Rch = [ Rch  ‘’’’
Si b = 8 Alors
P 3
Sinon
P4
Fin Si ]
Pour i de 1 à long ( Ch ) faire
Si Ch[ i ] dans [ ‘’0’’ .. ‘’9’’] Alors
Val ( Ch[ i ] , k , e)
Sinon
K  ord ( ch [ i ] ) – 55
Finsi
Rst ’’’’
Répeter
R  k mod 2
K  k div 2
Str ( r , st )
Rst  st + Rst
Jusqu'à k = 0 T.D.O
Tant que long ( Rst ) mod p <> 0 Faire
Rst  ‘’0’’ + Rst
Fin Tantque R Entier Un chiffre
Rch  Rch + Rst
k entier Un chiffre
Fin Pour
Tant que Rch =’’0’’ Faire i entier Compteur
Efface (Rch , 1, 1)
Fin tant que e entier Erreur
Fin convb8b16_b2 Rch chaine Résultat
P entier Nombre de chiffres
St chaine
rst chaine
122
5) Conversion de base b8 ou base b16 à et inversement:
Il n’existe pas une méthode a appliqué pour faire la conversion de la base 8 à la base 16 ou
inversement donc on doit passer obligatoirement par soit la base 10, soit la base 2.
Application :
Ecrire un programme qui permet de convertir un entier N de base b1 a son équivalant dans la base
b2.
123
Série N ° 9
Exercice N° 1
On peut déterminer si un nombre est divisible par 9 par la méthode suivante. On part du premier
chiffre ou de zéro si ce chiffre est 9. On ajoute le deuxième chiffre (s'il y en a un), si le résultat est supérieur
ou égal à 9, on lui soustrait 9 sinon on ne fait rien. On répète ensuite la même opération pour les chiffres
suivants. Le nombre est divisible par 9 si et seulement si le résultat final est nul.
Ecrire un programme modulaire en Turbo Pascal qui indique si le nombre entier positif est divisible
par 9 en mettant en œuvre la méthode décrite ci-dessus. La fonction recevra le nombre entier sous la
forme d'une chaîne de caractères contenant son écriture décimale.
Exemple.
Pour le nombre 78192 (passé en paramètre à la fonction sous la forme de la chaîne "78192") la
fonction effectuera donc les opérations suivantes:
7 est différent de 9
7 + 8 = 15, 15 est supérieur ou égal à 9 on lui soustrait 9 pour obtenir 6
6 + 1 = 7, 7 est strictement inférieur à 9
Le résultat est nul donc 78192 est divisible par 9 (78192 = 9 x 8688).
Exercice N° 2
Le nombre N est divisible par 13 si et seulement si le nombre des dizaines plus 4 * le chiffre
des unités est divisible par 13.
Exemple :
637 est divisible par 13 car
63 + 4 * 7 = 91
9 + 4 * 1 = 13
13 est divisible par 13.
D’une manière plus générale il suffit de répéter l’opération ci-dessus jusqu'à obtenir
comme résultat final 13, 26 ou 39. Ce qui prouvera que le nombre considéré au départ est divisible
par 13.
Soit le nombre 224185. On a :
22418 + 4 * 5 =22438
2243 + 4 * 8 = 2275
227 + 4 * 5 = 247
24 + 4 * 7 = 52
5 + 4 * 2 = 13
Nous obtenons 13 donc 224185 est divisible par 13.
On appliquant ce principe, Ecrire un programme modulaire en Turbo Pascal qui vérifie est ce
qu’un entier long naturel N est divisible par 13 ou non.
124
Exercice N° 3
Un entier est divisible par 11 si la différence entre la somme des chiffres de rang pair et la
somme des chiffres de rang impaire soit divisible par 11
Exemple
752 n’est pas divisible par 11 car ( 7 + 2 ) – 5 = 4 n’est pas divisible par 11
57816 est divisible par 11 car ( 6 + 8 + 5 ) – (1 + 7) = 11 divisible par 11.
Ecrire un programme en Turbo Pascal qui permet de vérifier si un nombre N donné est divisible
par 11 ou non.
N.B : le programme doit contenir au moins deux modules
Exercice N° 4
Soit n un entier positif. On désire tester si n est divisible par 7 ou non en appliquant le principe suivant :
• Multiplier le chiffre de gauche par 3 et l’ajouter au chiffre suivant.

• Remplacer les deux premiers chiffres de l’entier n par le résultat trouvé.
• Répéter les actions précédentes jusqu'à ce que le résultat soit un chiffre.
• Si le résultat obtenu est 7 alors l’entier n est divisible par 7 sinon n ne l’est pas.
Exemple :
N=364 3 * 3 + 6 =15 n devient 154
1*3+5=8 n devient 84
8 * 3 + 4 = 28 n devient 28
2 * 3 + 8 = 14 n devient 14
1*3+4=7 n devient 7 donc l’entier 364 est divisible par 7.
Décomposer le problème en modules, analyser le programme principal ainsi que les modules utilisés et
déduire les algorithmes.
Exercice N°5
Pour savoir si un nombre est divisible par 137, il suffit de séparer ce nombre par tranche de
4 chiffres en partant des unités et d’insérer alternativement des – et des + entre les tranches à
partir du début du nombre en commençant par un - , On effectue l’opération ainsi écrite et si le
résultat est divisible par 137, alors le nombre considéré est divisible par 137.
Exemple
Soit le nombre 2510792736157732104
On le sépare par tranche de quatre chiffres à partir des unités
251| 0792| 7361|5773|2104
On intercale alternativement des + et des – à partir du début en commençant par –
251-0792+7361-5773+2104
On effectue l’opération ainsi écrite
251-0792+7361-5773+2104 =3151
On vérifie aisément que 3151 est divisible par 137 donc le nombre 2510792736157732104
Est divisible par 137
1) Ecrire un algorithme de module qui teste si un nombre donné est divisible par 137
Note : ajouter des zéro à gauche de nombre ne change pas le nombre
125
Exercice N° 6
Un nombre de Kynea est un entier de la forme : 4n + 2n+1 − 1. Les premiers nombres de
Kynea sont : 7, 23, 79, 287, 1087, 4223, 16639, 66047, 263167, 1050623, 4198399, 16785407, …
La représentation binaire du nième nombre de Kynea est un 1, suivi de (n – 1) zéros consécutifs,
suivi de (n + 1) uns consécutifs.
Exemples : 7 est 111 en binaire, 23 est 10111, 79 est 1001111, etc.
Ecrire un programme Pascal qui permet de :
- Créer et remplir un fichier intitulé Kynea.dat par les N (5<N<20) premiers nombres de Kynea
en décimale et en binaire en utilisant la représentation décrite ci-dessus.
- Afficher le contenu de ce fichier.
Exercice N° 7
Soient U n et V n deux suites définies par :
U n+1 = ( U n + V n ) / 2
V n+1 = √𝐔𝐔𝐧𝐧 + 𝐕𝐕𝐧𝐧
Avec U 0 =1 et V 0 = 1/ √𝟐𝟐
𝟒𝟒∗𝐔𝐔𝐧𝐧𝟐𝟐
Et soit W n la suite définie par : W n = , on montre que 𝐥𝐥𝐥𝐥𝐥𝐥𝒏𝒏→∞ 𝑾𝑾𝑾𝑾 = 𝝅𝝅.
𝟏𝟏−𝟐𝟐∗ ∑𝐧𝐧 𝐢𝐢 𝟐𝟐 𝟐𝟐
𝐢𝐢=𝟏𝟏 𝟐𝟐 (𝐔𝐔𝐢𝐢 − 𝐕𝐕𝐢𝐢 )
En utilisant la suite W n Ecrire l’algorithme d’un module qui permet de déterminer une valeur approchée
de 𝝅𝝅 à 10-4 près.
NB : il s’agit de calculer à chaque fois deux termes consécutifs de W n jusqu'à ce que leur différence soit
inferieur à 10-4 .
Exercice N° 8
Ecrire un programme qui permet de :
• Remplir un fichier ‘’Nombre.dat’’ par N entiers aléatoires compris entre 15 et 900, avec n un entier
donné telle que 3 ≤ N ≤ 50.
• A partir du fichier ‘’Nombre.dat’’ remplir un deuxième fichier ‘’Conversion.dat’’ dans le quel
mettre le nombre décimal et ses conversions en binaire, en octal, et en hexadécimal.
• A partir du fichier ‘’Conversion.dat’’ mettre dans un fichier texte ‘’Lettre.txt’’ tous les nombres
hexadécimal qui comporte au moins une lettre (nombre hexadécimal et nombre de lettre dans le
nombre séparé par un espace).
• Afficher le contenu des trois fichiers
Décomposez le problème en modules. Analysez les modules et déduisez les algorithmes.
126
Exercice N° 9 ( Bac pratique 21 Mai 2008 )

Un entier naturel écrit dans la base 10 est dit rond si, dans son équivlent binaire, on trouve au tant
de 1 que de 0.
Exemple: le nombre 611 est rond car 611=(1001100011)2 et il y a autant de 1 que de 0 dans cette écriture
en binaire.
On dispose d’un fichier intitulé naturels.dat composé d’une suite de nombres entiers naturels écrits
dans la base 10. On se propose de remplir à partir de ce fichier deux autres fichiers intitulés nom_rond.dat
et rond.dat comportant respectivement les nombres non ronds et les nombres ronds contenus dans le
premier fichier naturels.dat.
Question:
Ecrire un programme qui crée et remplit le fichier naturels.dat par n entiers inferieurs à 32000
(10<n<100).
Ensuite, il lit de ce fichier les nombres décimaux, affiche et place les nombres ronds dans le fichier rond.dat
et place les autres sans les afficher dans le fichier non_rond.dat.
Exercice N° 10
Ecrire un module récursif qui permet de mettre à zéro la diagonale principale d'une matrice carrée de n*n
entiers.
Exemple : Soit la matrice suivante pour n=3 :
3 5 1
4 2 8
12 9 7
Apres exécution du module, le contenu de la matrice devient :
0 5 1
4 0 8
12 9 0
Exercice N° 11
Une matrice magique, c’est une matrice carrée de dimension impaire si les sommes de
chaque ligne, chaque colonne et chaque diagonale sont tous égaux.
Exemple :
4 9 2 =15
3 5 7 =15
8 1 6 =15
=15 =15 =15 =15
M est une matrice magique
Nous proposons d’écrire un programme qui permet de remplir une matrice carrée par N entiers
(avec N impaire, comprise entre 3 et 9) et de vérifier si la matrice est magique
127
Exercice N° 12
On se propose de remplir aléatoirement une matrice de n lignes et m colonnes par des entiers
compris entre 0 et 1, puis convertir en hexadécimal les nombres binaires formés à partir de chaque ligne et
mettre le résultat de la conversion dans un fichier texte nommé «hex.txt» et enregistré sous la racine C :
Enfin afficher le contenu du fichier.
Exemple :
1 0 1 1
M:
0 1 1 0
Le contenu du fichier « hexa.txt» :
1011 en binaire = B en hexa
0110 en binaire = 6 en hexa
Travail demandé :
Ecrire un programme en Turbo Pascal qui permet de répondre à cette tache.
N.B : le programme doit contenir au moins deux modules
Exercice N° 13
La matrice identité de taille n est une matrice carrée dont les valeurs des cases de la
première diagonale sont égales à 1 alors que celles se trouvant dans les autres cases sont nulles.
Ecrire un programme modulaire en Turbo Pascal permettant de vérifier si une matrice

carrée M de taille n est une matrice identité. On suppose que n est saisie et que M est remplie par
des 0 et des 1.
Exemple :
Soit n = 5 et M =
0 0 0 0 1
0 0 0 1 0
0 0 1 0 0
0 1 0 0 0
1 0 0 0 0
M est une matrice identité de taille 5.
128
Exercice N° 14
Soit la fonction inconnue suivante :
Function inconnue ( n :integer) : string ;
Var
Ch : string ;
Begin
Ch :=’’ ;
While n < > 0 do
Begin
Str ( n mod 5 , aux ) ;
Ch := aux + ch ;
N := n div 5 ;
End ;
Inconnue := ch ;
End ;
Questions:
1. Exécuter manuellement cette fonction sur les valeurs n = 78 et n= 25.
2. Quel est le rôle de cette fonction.
Exercice N° 15
On appelle nombre de Keith un nombre K de n chiffres ayant la propriété suivante : en
partant des nombres composés chacun d'un des n chiffres de K, on compose une sorte de suite en
calculant la somme des n derniers nombres de la suite pour déterminer le suivant. Si cette suite
fournit à un moment le nombre K, ce nombre est dit nombre de Keith.
Exemple : K=197
1+9 +7=17 ; 9+7+17=33 ; 7+17+33=57 ; 17+33+57=107 ; 33+57+107=197 ; 57+107+197=361.
On obtient alors la suite : 1, 9, 7, 17, 33, 57, 107, 197, 361 dans laquelle se trouve le nombre 197,
donc 197 est un nombre de Keith.
Ecrire un programme Pascal qui permet de déterminer et d’afficher tous les nombres de Keith dans
l’intervalle [10..200000].
Exercice N° 16
Soit M une matrice carrée de dimension n remplie par des caractères alphabétiques majuscules. On se
propose de créer le fichier "Zone.Dat" par les zones équilibrés qui peuvent exister dans la matrice M. Pour
réaliser ce travail, on va suivre les étapes suivantes :
1. Remplir d’une manière aléatoire la matrice M, sachant que n est un entier non premier donné
compris entre 6 et 20
2. On fixe d le plus petit diviseur de n afin de diviser la matrice M en carré de dimension d*d (avec
d>=2)
3. Remplir le fichier "Zone.dat" par les zones équilibrées de la matrice M sachant qu’une zone est dite
équilibrée si le nombre de voyelle se trouvant dans cette zone est supérieur ou égale à d. Une zone
du fichier est caractérisée par les coordonnées (ligne, colonne) de la 1ère case de la zone équilibrée
(en haut à gauche) et du nombre de voyelles se trouvant dans cette zone
129
Exemple : Si n=9
1 2 3 4 5 6 7 8 9
1 A D F D F K D C A
2 G I E W I X H G J
3 B A C Y Q R T D X
4 F K M K I E K P S
M
5 B U L J W M G Q D
6 Y V C F U H X K F
7 B O N D J Z U O I
8 C E C V B K A Y S
9 E A H J E N I K E
Le plus petit diviseur de n est d=3

Les zones équilibrées sont :
Zone 1 : Ligne 1 Colonne 1 nombre de voyelle est 4
Zone 2 : Ligne 4 Colonne 4 nombre de voyelles est 3
Travail demandé :
1. Analyser le problème en le décomposant en modules

2. Analyser chacun des modules envisagés précédemment.
130
Exercice N° 17 ( bac pratique 27 mai 2010 de 14 h )
Soit un fichier enregistrer sous le nom ‘’nb_base.dat’’ dans lequel on va enregistrer n chaines de
caractères. Chaque chaine est formée de 5 caractères au maximum. Chacun de ces caractères est soit un
chiffre, soit une lettre majuscule de l’intervalle ‘’A’’ . .’’F’’.
Pour chaque chaine du fichier ‘’nb_base.dat’’, on se propose de réaliser les tâches suivantes :
- Déterminer la plus petite base b à laquelle, peut appartenir le nombre m représenté par la chaine
de caractères.
- Déterminer l’équivalent décimal d du nombre m.
- Ranger dans une ligne d’un fichier texte nommé ‘’nombre.txt’’. la valeur décimale correspondante,
de la façon suivante : ( m ) b = ( d )10.
Exemple :
Si le contenu du fichier ‘’nb_base.dat’’ est le suivant :
FF
1B5
325
Le contenu du fichier ‘’nombre.txt’’ sera :
( FF ) 16 = ( 255 )10
( 1B5 ) 12 = ( 28 ) 10
( 325 ) 6 = ( 125 )10
Remarque :
La plus petit base à laquelle appartient la valeur 1B5 est la base 12. En effet, le plus grand
chiffre de ce nombre est B qui correspond à la valeur décimale 11.
De ce fait, la plus petite base de 1B5 est 11 + 1 = 12
Travail demandé :
Ecrire un programme Pascal et l’enregistrer sous le nom conversion.pas qui permet de :
• Saisir un entier n avec 2 ≤ n ≤ 10.
• Enregistrer dans un fichier nommé nb_base.dat. n chaines de caractères répondant aux
conditions précédemment citées.
• Remplir et afficher le fichier nombre.txt.
131
Correction de l’exercice N° 1
1. Analyse du programme principal
Nom : Ex1
Résultat = aff
Aff = [ ] Si Fn Div9 ( ch ) Alors
Ecrire ( Ch , ‘’ est divisible par 9 ‘’ )
Sinon
Ecrire ( Ch , ‘’ n’est pas divisible par 9 ‘’)
Fin si
Ch =[ ] Répéter
Ch = Donnée(‘’ entrer un nombre décimal ‘’)
Jusqu'à Fn Vérif ( ch )
Fin ex1
T.D.O
O T/N R
Ch chaine Nombre
Div9 fonction Retourne vrai si le nombre est divisible par 9
verif fonction Vérifier si le la chaine est formée que par des chiffres
2. Analyse de la fonction Vérif

Déf Fn Vérif ( ch : chaine ) : booléen
Résultat = Vérif
Vérif = [ ] Vérif  B
B = [ b  Vrai , i  1 ] Tant que ( B ) et ( i ≤ Long ( ch) ) Faire
Si Non ( Ch [ i] dans [ ‘’0’’ . . ‘’9’’ ] ) Alors
B  Faux
finSi
ii+1
fin Tant que T.D.O
fin Vérif
O T/N R
I Entier Compteur
b booléen
3. Analyse de la fonction Div9

Déf Fn Div9 ( Ch : chaine ) : booléen
Résultat = Div9 T.D.O
Div9 =[ S  0 ] Pour i de 1 à Long ( ch ) Faire
Val ( Ch [ i ] , k , e )
O T/N R
SS+k
I Entier Compteur
Si S ≥ 9 Alors
K Entier Chiffre
SS–9
Fin si S entier somme
Fin Pour
Fin Div9
132

Nom : Ex2
Résultat = aff
Aff = [ ] Si Fn Div13 ( N ) Alors
Ecrire (N , ‘’ est divisible par 13 ‘’ )
Sinon
Ecrire ( N , ‘’ n’est pas divisible par 13 ‘’)
Fin si
N =[ ] Répéter
N = Donnée (‘’ entrer un nombre décimal ‘’)
Jusqu'à ( N ≥ 0 )
Fin Ex2
T.D.O
O T/N R
N Entier Long Nombre

Déf Fn Div13 ( N : entier Long ) : booléen
Résultat = Div13
Div13 = [ ] Si N dans [13, 26, 39 ] Alors
Div13  Vrai
Sinon
Div13  Faux
Fin Si
N = [ ] Tant que N > 39 Faire
N  N div 10 + 4 * N mod 10
Fin Tant que
fin Div13
133

Nom : Ex3
Résultat = aff
Aff = [ ] Si Fn Div11 ( N ) Alors
Ecrire (N , ‘’ est divisible par 11 ‘’ )
Sinon
Ecrire ( N , ‘’ n’est pas divisible par 11 ‘’)
Fin si
N =[ ] Répéter
N = Donnée (‘’ entrer un nombre décimal ‘’)
Jusqu'à ( N ≥ 0 )
Fin ex2
T.D.O
O T/N R
N Entier Long Nombre

Déf Fn Div11 ( N : Entier Long ) : booléen
Résultat = Div11
Div11 = [ ConvCh ( N , Ch ), sp 0 , si  0 ]
Pour i de 1 à Long ( Ch ) Faire
Val ( ch [ i ] , k , e )
Si i mod 2 = 0 Alors
sp  sp + k
Sinon
si  si + k
Fin si
Fin Pour
Fin Div11
T.D.O
O T/N R
i Entier Compteur
K Entier Chiffre
Sp Entier Somme des chiffres de rang pair
Si Entier Somme des chiffres de rang impair
Ch chaine nombre
134
Nom : Ex8
Résultat = aff
Aff =[ ] Proc afficheFn( fn )
Proc affichefc( fc )
Proc afficheft ( ft )
Fn , Fc =[ ] Proc Creation ( Fn , Fc )
Proc Remplir ( Fn , n )
Proc conversion ( Fn , Fc )
Ft = [ ] Proc Remplirft ( Fc , ft )
N = [ ] Proc Saisie ( n )
Fin ex 8 T.D.O
T.D.N.T
Objet Type/Nature rôle
Conv = Enregistrement Fn Nombre Fichier d’entier
Nd : entier Fc F_conv Ficher de enregistrement
Nb : chaine ft texte Ficher texte
No : chaine
N Entier
Nh : chaine
Fin conv Saisie Procedure
Nombre = Fichier d’entier Creation Procédure
F_conv = fichier de conv Remplir Procédure
Conversion Procédure
afficheFn Procédure
afficheFC procédure
2. Analyse procédure création
Déf proc Création ( var Fn : nombre ; var Fc : F_conv )
Résultat = Fn , Fc
Fn = [ ] associer ( Fn , ‘’ C:\bac2013\Nombre.dat ‘’)
Récréer ( fn )
Fc = [ ] associer ( Fc , ‘’ C:\bac2013\conversion.dat ‘’)
Récréer ( fc )
Ft = [ ] associer ( Ft , ‘’ C:\bac2013\lettre.txt ‘’)
Récréer ( ft )
Fin Création
3. Analyse de la procédure saisie

Déf Proc saisie ( var n : entier )
Résultat = n
N = [ ] Répéter
N = Donnée ( ‘’Entrer un entier : ‘’)
Fin Saisie
135

Déf Proc Remplir ( var Fn : nombre ; n : entier)
Résultat = Fn
Fn = [ Ouvrir ( Fn) ] Pour i de 1 à n Faire
K  15 + Alea ( 886) T.D.O
Ecrire ( Fn , k )
Fin Pour O T/N R
Fermer ( Fn ) I Entier
Fin Remplir k Entier
5. Analyse de la procédure conversion

Déf Proc Conversion ( var Fn : nombre ; var Fc : F_conv )
Résultat = Fc
Fc = [ ouvrir (Fn ), ouvrir ( Fc ) ]
Tant que Non ( Fin_Fichier ( Fn ) ) Faire
Lire ( Fn , k )
Avec e Faire
Nd  k
Nb  Fn Convb10_b ( k , 2 )
No  Fn convb10_b ( k , 8 )
Nh  Fn convb10_b ( k , 16 )
Fin Avec
Ecrire ( Fc , e )
Fin Tant que
Fermer ( Fn )
Fermer ( Fc )
T.D.O
Fin Conversion
O T/N R
e Conv Enregistrement qui contient nd, nb, no, nh
k Entier Nombre du fichier
Convb10_b Fonction Fonction qui retourne les conversions a une base b
136
6. Analyse de la procédure Convb10_b

Déf Fn Convb10_b ( k , b : entier ) : chaine
Résultat = convb10_b
Convb10_b = [ Ch  ‘’’’ ] Répéter
R  k mod b
K  k div b
Si R > 9 Alors
Rst  CHR ( R + 55 )
Sinon
Str ( R ,Rst )
Fin si
Ch  Rst + Ch T.D.O
Jusqu'à ( k = 0 )
Fin Convb10_b O T/N R
R Entier Reste
Rst Chaine Reste
Ch Chaine Résultat
7. Analyse de la procédure AfficheFn
Déf Proc AfficheFn ( var Fn : Nombre)
Résultat = aff
Aff = [ Ouvrir ( Fn ) ] Tant que Non ( Fin_Fichier ( Fn ) ) Faire
Lire ( Fn , k )
Ecrire ( k ) T.D.O
Fin Tant que
Fermer ( Fn ) O T/N R
Fin AfficheFn
k Entier nombre
8. Analyse de la procédure AfficheFc

Déf Proc AfficheFc ( var Fc : F_conv )
Résultat = Fc
Fc = [ ouvrir ( Fc ) ] Tant que Non ( Fin_Fichier ( Fc ) ) Faire
Lire ( Fc , e )
Avec e Faire
Ecrire ( Nd )
Ecrire ( Nb )
Ecrire ( No )
Ecrire ( Nh )
Fin Avec
Fin Tant que T.D.O
Fermer ( fc )
Fin AfficheFc O T/N R
e conv Enregistrement de la conversion
137
9. Analyse de la procédure Remplirft

Déf Proc RemplirFt ( var Fc : F_conv ; var Ft : texte )
Résultat = ft
Ft = [ ouvrir ( Fc ) , Ajouter ( Ft ) ]
Tant que Non ( Fin_Fichier ( Fc ) ) Faire
Lire ( Fc , e )
Avec e Faire
K  Fn NbL ( Nh )
Si k <> 0 Alors
ConvCh ( k , ch )
Ch  Nh + ‘’ ‘’ + ch T.D.O
Ecrire_nl ( Ft , ch )
Fin Si O T/N R
Fin avec K Entier nombre
Fin Tant que e Conv enregistrement
Fermer ( Fc ) ch Chaine contient nh et nbre de
Fermer ( ft ) lettres
Fin Remplirft NbL fonction retourne le nombre des
10. Analyse de la fonction NbL lettres
Déf Fn NbL ( st : chaine ) : nombre
Résultat = NbL
NbL = [ ] NbL  nb
Nb = [ nb  0] Pour i de 1 à Long ( st ) Faire T.D.O
Si st [ i ] dans [‘’A’’ . . ‘’F’’ ] Alors
Nb  nb + 1 O T/N R
Fin Si k Entier nombre
Fin Pour i Entier compteur
Fin NbL nb entier compteur
11. Analyse de la procédure afficheft ( Var ft : texte )

Déf Proc afficheft ( var ft : texte )
Résultat = aff
Aff = [ Ouvrir ( Ft ) ] Tant que Non ( Fin_Ficher ( Ft ) ) faire
Lire_nl ( ft , ch )
Ecrire ( ch ) T.D.O
Fin tant que
Fin afficheft
O T/N R
Ch Chaine Ligne de fichier texte
138
Traduction en turbo Pascal

program Ex8 ;
uses wincrt ;
type
conv= record
nd:integer;
nb: string;
no : string ;
nh:string;
end;
fconv= file of conv;
nombre= file of integer ;
var
fn : nombre;
fc : fconv;
ft : text ;
n : integer ;
procedure creation(var fn:nombre;var fc: fconv );

begin
assign(fn,'c:\bac2013\nombre.dat');
rewrite(fn);
assign(fc,'c:\bac2013\conversion.dat');
rewrite(fc) ;
assign(ft,'c:\bac2013\lettre.txt');
rewrite(ft);
end;
procedure saisie ( var n:integer);
begin
repeat
write(' entrer un entier :');
readln(n);
until n in [3..50] ;
end;
procedure remplir ( var fn : nombre ; n : integer ) ;

var
i,k : integer;
begin
reset( fn ) ;
randomize;
for i:= 1 to n do
begin
k:= random(886)+15 ;
write(fn,k) ;
end;
end;
139
function convb10_b( k , b : integer ) :string;

var
r:integer;
rst,ch:string;
begin
ch:='';
repeat
r:= k mod b;
k:= k div b ;
if r > 9 then
begin
rst:= chr ( r + 55 );
end
else
begin
str( r , rst );
end;
ch := rst + ch;
until k=0 ;
convb10_b := ch;
end;
procedure conversion (var fn:nombre;var fc:fconv);
var
k:integer;
e:conv;
begin
reset (fn);
reset(fc);
while not (eof (fn)) do
begin
read ( fn , k);
with e do
begin
nd := k;
nb := convb10_b( k ,2);
no := convb10_b( k ,8);
nh := convb10_b( k ,16);
end;
write( fc , e );
end;
close( fn);
close ( fc );
end;
140
function nbl ( st : string ) : integer ;

var
nb , i : integer;
begin
nb := 0 ;
for i := 1 to length ( st) do
begin
if st [ i ] in ['A'.. 'F' ] then
begin
nb := nb +1
end;
end;
nbl := nb ;
end;
procedure remplirft ( var fc : fconv ; var ft : text );
var
k : integer;
e: conv ;
ch : string ;
begin
reset( fc );
append( ft );
while not ( eof ( fc ) ) do
begin
read ( fc , e );
with e do
begin
k := nbl ( nh ) ;
if k <> 0 then
begin
str ( k , ch);
ch := nh +' ' + ch ;
writeln( ft , ch )
end;
end
end;
close( fc) ;
close ( ft );
end;
procedure afficheft ( var ft : text );
var
ch : string ;
begin
reset( ft );
while not ( eof ( ft )) do
begin
readln ( ft , ch ) ;
writeln ( ch ) ;
end;
close ( ft);
end;
141
procedure affichefn(var fn:nombre);

var
k:integer;
begin
reset(fn);
while not(eof(fn)) do
begin
read( fn , k );
writeln( k );
end;
close( fn );
end;
procedure afficheFc( var fc: fconv);
var
e:conv;
begin
reset(fc);
while not (eof (fc)) do
begin
read(fc,e);
with e do
begin
writeln('(',nd,')10 = (',nb,')2=(',no,')8=(',nh,')16');
end;
end;
close(fc);
end;
begin
creation(fn,fc);
saisie(n);
remplir(fn,n);
conversion ( fn , fc );
remplirft ( fc , ft);
afficheFn(fn);
afficheFc(fc);
afficheft( ft );
end.
142
program nombre1;
uses wincrt;
type
f_chaine=file of string;
var
f:f_chaine;
f1:text;
m:integer;
procedure creation(var f:f_chaine;var f1:text);
begin
assign( f ,'c:\bac2012\123636\nb_base.dat');
rewrite( f );
assign( f1 ,' c:\bac2012\123636\nombre.txt');
rewrite( f1 );
end;
procedure saisie( var m:integer);
begin
repeat
write('intoduire l''entier: ');
readln(m);
until m in [2..10];
end;
function verif(ch:string):boolean;
var
b:boolean;
i:integer;
begin
i:=1;
b:=true;
while (b) and (i<=length(ch)) do
begin
if ch[i] in ['0'..'9','A'..'F'] then
i:=i+1
else
b:=false;
end;
verif:=b;
end;
procedure remplir(var f:f_chaine ; m:integer);
var
i:integer;
ch:string;
begin
reset(f);
writeln('entrer ', m , ' nombre hexadécimal ');
for i:=1 to m do
begin
repeat
143
write('entrer un nombre hexadécimal: ');

readln(ch);
until (length(ch)<=5) and (verif(ch));
write(f,ch);
end;
close(f)
end;
function puis(a,b:integer):integer;
var
i,p:integer;
begin
p:=1;
for i:= 1 to b do
begin
p:=p*a;
end;
puis:=p;
end;
function convb_b10(ch:string;b:integer):integer;
var
i,e,k,s:integer;
begin
S:=0;
for i:=1 to length(ch) do
begin
if ch[i] in ['0'..'9'] then
begin
val(ch[i],k,e);
end
else
begin
k:=ord(ch[i])-55 ;
end;
s:=s+k* puis(b,length(ch)-i);
end;
convb_b10:=s;
end;
function base(ch:string):integer;
var
k,e,i:integer;
max:char;
begin
max:=ch[1];
for i:=2 to length(ch) do
begin
if ord(max) <ord(ch[i]) then
max:=ch[i];
end;
if max in ['0'..'9'] then
begin
144
val(max,k,e);
end
else
begin
k:=(ord(max)-55);
end;
base:=k+1;
end;
procedure remplirft(var f:f_chaine;var f1:text);
var
b,dec:integer;
ch,st,bch,dch:string;
begin
reset(f);
append(f1);
while not(eof(f)) do
begin
read(f,ch);
b:=base(ch);
dec:=convb_b10(ch,b);
str(b,bch);
str(dec,dch);
st:='('+ch+')'+bch+'='+'('+dch+')'+'10';
writeln(f1,st);
end;
close(f);
close(f1);
end;
procedure affiche(var f1:text);
var
ch:string;
begin
reset(f1) ;
while not (eof(f1)) do
begin
readln(f1,ch);
writeln(ch);
end;
close(f1);
end;
begin
creation(f,f1);
saisie(m);
remplir(f,m);
remplirft(f,f1) ;
affiche(f1);
end.
145
Série N° 10
Exercice N° 1 ( sujet bac pratique jeudi 21 Mai 2009 8h30)
Un nombre est dit super premier s’il est premier et si , en supprimant des chiffres à partir de sa
droite, le nombre restant est aussi premier.
Exemple : le nombre 59399 est super premier car les nombres 59399, 5939, 593, 59 et 5 sont
tous premiers.
Ecrire un programme sup_prem.pas qui permet de :
 Saisir un entier n tel que 40000 < n < 100000

 Chercher tous les nombres premiers inferieurs ou égaux à n, les afficher à raison d’un
nombre par ligne en mentionnant devant chaque nombre super premier la note « super
premier » et de faire la même chose dans un fichier texte intitulé super_p.txt.
Exercice N° 2 :
On vous demande d’écrire un programme qui permet de :
 Remplir au hasard une matrice carrée d’ordre n par les entiers 0 ou 1.

NB : La fonction Random (X), permet de générer un nombre entier aléatoire appartenant à
l’intervalle [0, X-1].
 A partir de cette matrice, créer un fichier d’enregistrements FH stocké physiquement sous

'c:\Hexa.dat', chaque enregistrement renferme les deux champs suivants :
 Hex : représente la conversion en hexadécimale de chaque ligne de la matrice. (La
conversion en hexadécimal se fait directement et sans passer par la base 10)
 nb : représente le nombre de lettres existant dans la conversion Hexadécimale.
 A partir du fichier FH créer un deuxième fichier FD dont le nom physique est
'C:\Div11.dat', qui contient toutes les chaînes hexadécimaux dont le nombre de caractère est
supérieur à 1 (nb ≥ 1) et dont la conversion en décimal est divisible par 11.
NB : vous devez utiliser la méthode suivante pour déterminer la divisibilité par 11 :
Soustraire de N amputé de son chiffre des unités le chiffre supprimé et recommencer
éventuellement avec le nombre ainsi obtenu jusqu’au moment où l’on peut conclure à la divisibilité.
146
Si N = 12345674
1234567 – 4 = 1234563
123456 – 3 = 123453
12345 – 3 = 12342
1234 – 2 = 1232
123 – 2 = 121
12 – 1 = 11
1 – 1 = 0 qui est divisible par 11
Exemple : pour n = 8
M FH FD
1 1 1 0 0 1 1 1
E7 1 E7
1 0 0 0 1 1 1 1
8F 1 8F
1 1 1 1 1 1 1 1
FF 2 FD
0 0 1 1 0 0 0 1
31 0
0 0 0 1 0 0 0 0
10 0
0 1 1 1 0 1 1 1
77 0
0 0 1 0 0 0 0 1
21 0
1 1 1 1 1 1 0 1
FD 2
- La première ligne de la matrice est égal à : 1110 0111.

Hex = E7
- (1110 0111)2
nb = 1
- (E7) 16 = (231) 10
- 231 est divisible par 11 et nb ≥ 1, d’où l’écriture de E7 dans le fichier FD.
Questions :
1. Analyser et déduire l’algorithme du programme principal qui permet de réaliser le
traitement décrit précédemment en le décomposant en modules.
2. Analyser chacun des modules envisagés précédemment et en déduire les algorithmes
correspondants.
147
program suppremier;
begin
uses wincrt;
append(ft);
var
for i:=2 to n do
ft:text;
begin
n:longint;
if premier(i) then
procedure creation(var ft:text);
begin
begin
writeln(i);
assign(ft,'c:\bac2012\0123\super_p.txt');
str(i,rch);
rewrite(ft);
k:=i;
end;
b:=true;
procedure saisie(var n:longint);
repeat
begin
str(k,ch);
repeat
st:=copy(ch,1,length(ch)-1);
write('donner n: ');
val(st,k,e);
readln(n);
if not premier(k) then
until (n>40000) and (n<100000);
begin
end;
b:=false;
function premier(n:longint):boolean;
end;
var
until (k<=9) or not(b);
i:longint;
if (b) then
b:boolean;
begin
begin
writeln('super premier');
b:=true;
rch:=rch+' '+'super premier';
i:=2;
end;
while (i<=(n div 2)) and (b) do
writeln(ft,rch);
begin
end;
if n mod i=0 then
end;
begin
close(ft);
b:=false;
end;
end
procedure affiche(var ft:text);
else
var
begin
ch:string;
i:=i+1;
begin
end;
reset(ft);
end;
while not(EOF(ft)) do
end;
begin
Premier : = b ;
readln(ft,ch);
end;
writeln(ch);
procedure recherche(n:longint; var ft:text);
end;
var
end;
i,k:longint;
begin
e:integer;
creation(ft);
rch,ch,st:string;
saisie(n);
b:boolean;
recherche(n,ft);
affiche(ft);
end.
148
LES ALGORITHMES D’APPROXIMATION
149
Chap VII Les algorithmes d’approximation
LES ALGORITHMES D’APPROXIMATION
I. Introduction
Les problèmes d’optimisation forment un ensemble très riche de possibilités : de la
possibilité d’approcher avec une précision arbitraire, à l’impossibilité de toute garantie sur la
qualité de l’approximation.
II. Recherche du point fixe d’une fonction
1) Présentation
• En mathématiques, pour une application f d’un ensemble E dans lui-même, un élément x
de E est un point fixe de f si f(x) = x
• Exemple :
- Dans le plan, la symétrie par rapport à un point A admet un unique point fixe : A
- l’application inverse (définie sur l’ensemble des réels non nuls) admet deux points
fixes : -1 et 1
• Graphiquement, les points fixes d’une fonction f (où la variable est réelle) s’obtiennent en
traçant la droite d’équation y = x : tous les points d’intersection de la courbe
représentative de f avec cette droite sont alors les points fixes de f.
Toutes les fonctions n’ont pas nécessairement de point fixe ; par exemple, la fonction f telle que
f(x)=x+1 n’en possède pas, car il n’existe aucun nombre réel x égal à x+1.
2) Activité
On désire écrire un programme en Pascal qui permet de résoudre l’équation sin(x)=1-x
a) Décomposer le problème en modules
b) Ecrire les analyses des modules, en déduire les algorithmes
c) Traduire en pascal la solution obtenue
• Sin(x)= 1-x  x= 1-sin(x)
150
a) Analyse du programme principal :
Nom : Point_fixe
Résultat= Ecrire ("le point fixe est : ", x1, "trouvé après ", i, "itérations")
(x1 , i ) = [ i  0 , x1  1 ]
Répéter
i  i+1
x2  x1
x1  F(x1)
Jusqu’à (ABS(x1-x2) <epsilon)
Fin Point_fixe
T.D.O
Objet Type/Nature
i entier
X1, x2 Réel
epsilon Constante = 10-5
F Fonction
b) Algorithme du programme principal

0) Début Point_fixe
1) (x1 , I )= [ i  0 , x1 1 ]
Répéter
i  i+1
x2  x1
x1  F(x1)
Jusqu’à ( ABS ( x1 - x2 ) < epsilon)
2) Ecrire ("le point fixe est : ", x1, "trouvé après ", i, "itérations")
3) Fin Point_Fixe
c) Analyse de la fonction F
Déf Fn f ( x : reel) :reel
Résultat= f
F=[ ] f  1- sin(x)
Fin f
d) Algorithme de la fonction f
0) Déf Fn F (x : réel) : Réel
1) f =[ ] F 1- sin(x)
2) fin F
151
e) Traduction en Pascal
III. Calcul de valeurs approchées de constantes connues

1) Activité
Il existe plusieurs constantes numériques :
• e (nombre de Neper) ≈ 2,718…

• 𝜋𝜋 (nombre Pi) ≈ 3,1416…
• g (constante de pesanteur) ≈ 9.80665
Dans ce qui suit, nous allons présenter des algorithmes permettant de calculer des valeurs
approchées pour les constantes π et e
2) Valeur approchée de 𝝅𝝅
• Il est impossible de connaître la valeur exacte de 𝜋𝜋. En effet, il a été démontré par deux
mathématiciens de la fin du XVIIIème siècle, Lambert et Legendre, qu'il ne peut exister
aucune fraction [de deux entiers] égale à π.
• Les hommes de science - Euler, Gauss, Leibniz, Machin, Newton, Viète - ont recherché
toutes sortes de formules permettant de calculer une approximation de plus ou moins
précise.
152
a) Valeur approchée par la formule d’Euler
Ecrire une analyse, un algorithme et la traduction en Pascal d’un programme intitulé Pi_Euler, qui
permet de calculer et d’afficher une valeur approchée de π en utilisant la formule d’Euler :
𝜋𝜋 2 1 1 1 1 1
= 1+ + + + + ……+
6 22 32 4 2 52 𝑛𝑛 2
Cela signifie que :
𝜋𝜋 2 =6 * ( + + + +
Cela signifie que :
• Analyse :
Nom : Pi_euler
Résultat= Ecrire ("la valeur approchée de Pi est ", RacineCarrée(6 * S2))
S2 = [ S2 1 , i  2 ] Répéter
S1  S2
S2  S1+1/ Carrée ( i )
i i+1
jusqu’à abs(S2 – S1) < epsilon
Fin Pi_Euler
TDO
Objet Type/Nature
i Entier long
S1, S2 Reél
Epsilon Constante = 10-5
• Algorithme
0) Début Pi_Euler
1) s2 = [ S2 1, i2 ]
Répéter
S1  S2
S2  S1+1 / carrée ( i )
i i+1
jusqu’à abs(S2 – S1) < epsilon
2) Ecrire ("la valeur approchée de Pi est ", RacineCarrée(6 * S2))
3) Fin Pi_Euler
153
• Traduction en PASCAL
b) Valeur approchée par la formule de Wallis
Ecrire une analyse, un algorithme et la traduction en Pascal d’un programme intitulé Pi_Wallis, qui
permet de calculer et d’afficher une valeur approchée de Pi en utilisant la formule de Wallis :
Cela signifie :
Cela signifie
• Analyse
Nom : Pi_Wallis
Résultat= Ecrire ("la valeur approchée de Pi est ", 2* p2)
P2= [ i 1, P2  1]
Répéter
P1  P2
P2  p1 * ( ( 2 * i ) / ( 2 * i – 1 ) ) * ( ( 2 * i ) / ( 2 * i + 1 ) )
i i+1
Jusqu’à (abs (p2 - p1) <epsilon)
Fin Pi_walis
154
TDO
Objet Type/Nature
i Entier long
P1, P2 Réel
• Algorithme
0) Début Pi_Wallis
1) p2 = [ i  1 , P21 ]
Répéter
P1  P2
P2  p1 * ( ( 2 * i ) / ( 2 * i – 1 ) ) * ( ( 2 * i ) / ( 2 * i + 1 ) )
i i+1
Jusqu’à (abs (p2 - p1 ) <epsilon
2) Ecrire ("la valeur approchée de Pi est ", 2* p2)
3) Fin Pi_Wallis
Traduction en PASCAL
155
3) Valeur approchée de e
Ecrire une analyse, un algorithme et la traduction en Pascal d’un programme intitulé

calcul_e, qui permet de calculer et d’afficher une valeur approchée de e (nombre d’Euler, ou
nombre Népérien) en utilisant la formule suivante:
* Analyse du programme principal
Nom : calcul_e
Résultat= Ecrire ("la valeur approchée de e est : ", S2)
S2= [ S2  1, i  1 ] Répéter
S1  S2
S2  S2 + 1 / Fn Fact ( i )
i i+1
Jusqu’à abs( s2 - s1 ) <epsilon
Fin calcul_e
T.D.O
Objet Type/Nature
i entier
S1, S2 Réel
Fact Fonction calcul le factoriel d’un entier
* Algorithme du programme principal
0) Début calcul_e
1) S2 =[ S2  1 , I  1 ]
Répéter
S1  S2
S2  S1 + 1/ Fn Fact( i )
i i+1
Jusqu’à abs ( s2 - s1 ) < epsilon
2) Ecrire ("la valeur approchée de e est : ", S2)
3) Fin calcul_e
156
• Analyse de la fonction Fact

Déf Fn Fact ( a : entier ) : entier long
Résultat= Fact
Fact = [ ] Si a = 0 alors
Fact  1
Sinon
Fact  a * Fn Fact ( a – 1 )
Fin Si
Fin fact
• Algorithme de la fonction Fact
0) Déf Fn Fact (a : entier) : entier long
1) Si a = 0 Alors
Fact  1
Sinon
Fact  a * Fn Fact ( a – 1 )
Fin Si
2) Fin Fact
157
IV. Calcul d’aires

1) Introduction
Soit une fonction f continue et croissante dans l'intervalle [ a , b ].
Signifie l'aire sous la courbe de la fonction entre a et b.
En mathématiques, l'intégrale d'une fonction réelle positive est la valeur de l'aire du domaine
délimite par l'axe des abscisses et la courbe représentative de la fonction.
F( b)
F( a )
a b
𝒃𝒃
∫𝒂𝒂 𝒇𝒇( 𝒙𝒙 )𝒅𝒅 𝒙𝒙
Représentation graphique d’une intégrale

L'objectif donc, est d'approcher la valeur de f(t)dt. La plupart des méthodes d'intégration
numérique fonctionnent suivant le même principe :
• Nous commençons par subdiviser l'intervalle [a, b] en n intervalles [ai, ai+1] de diamètres
égaux a h = , avec a 1 = a et a n+1 = b. La subdivision est régulière et plus n est grand, plus
la longueur de chacun des intervalles devient petite. Le diamètre de chaque intervalle, c'est
a dire sa longueur, est notée : h = ai+1 – ai
• Puis, pour chaque intervalle [ai, ai+1], nous essayons de calculer une valeur approchée de
.
Les méthodes les plus utilisées sont : la méthode des rectangles, la méthode des trapèzes, la
méthode de Simpson, la méthode de Romberg, etc.
158
2) Méthodes de rectangles
a) Principe
Consiste à partager l'intervalle d'intégration en intervalles de même amplitude à partir

desquels on construit des rectangles dont on calcule la somme des aires.
La methode des rectangles consiste a remplacer “ l'aire sous la courbe ” par la somme des aires
des rectangles obtenus.
Méthode des rectangles à gauche Méthode des rectangles à droite
𝑏𝑏 − 𝑎𝑎 𝑛𝑛 𝑛𝑛 𝑏𝑏 − 𝑎𝑎 𝑛𝑛 𝑛𝑛
∗ � 𝑓𝑓 ( 𝑥𝑥 𝑖𝑖 ) = ℎ ∗ � 𝑓𝑓(𝑥𝑥 𝑖𝑖 ) ∗ � 𝑓𝑓 ( 𝑥𝑥 𝑖𝑖+1 ) = ℎ ∗ � 𝑓𝑓 (𝑥𝑥 𝑖𝑖+1 )
𝑛𝑛 1 1 𝑛𝑛 1 1
Méthode du point milieux
𝑏𝑏 − 𝑎𝑎 𝑛𝑛 𝑥𝑥 𝑖𝑖 + 𝑥𝑥 𝑖𝑖+1 𝑛𝑛 𝑥𝑥 𝑖𝑖 + 𝑥𝑥 𝑖𝑖+1
∗ � 𝑓𝑓 ( ) = ℎ ∗ � 𝑓𝑓 ( )
𝑛𝑛 1 2159 1 2
b) Application
On se propose de calculer l’aire résultante de la courbe de la fonction f : x  en utilisant la
méthode de rectangles ( du point milieu).
• Analyses
 Analyse du programme principal
Nom : calcul_Air
Résultat = Ecrire ("une valeur approchée de l’intégrale est = ", FN CALCUL (a, b, n))
A , b , n = [ ] Proc saisir (a, b, n)
Fin calcul_Air
T.D.O
Objet Type/Nature
n entier
a, b Réel
calcul Fonction
saisir procédure
 Analyse de la procédure saisir
Déf Proc saisie ( var a ,b , n : Entier )
Résultat= a,b , n
b = [ ] Répéter
b= donnée (" b = ")
Jusqu’à ( b > a )
a = Donnée (" a = ")
n = [ ] Répéter
n = donnée (" n = ")
Jusqu’à (n >0)
Fin saisie
160
 Analyse de la fonction calcul

Déf Fn Caclul ( a , b : réel ; n :entier) : Réel
Résultat = Calcul
Calcul = | ] calcul  somme * h
h=[]h (b–a)/n
Somme = [ Somme  0 , x  a + h / 2 ]
Pour i de 1 à N Faire
somme  somme + f ( x )
x x+h
Fin Pour
Fin calcul
 Analyse de la fonction F
Déf Fn f ( x : réel ) : réel
Résultat = F
F = [ ] f  carré ( x ) / ( 1 + carrée ( x ) )
Fin f
• Algorithmes
 Algorithme du programme principal
0) Début Rectangles
1) Proc saisir (a, b, n)
2) Ecrire ("une valeur approchée de l’intégrale est = ", FN CALCUL (a, b, n))
3) Fin Rectangles
 Algorithme de la procédure saisir
0) Procédure saisir (var a , b : Réel ; var n :entier)
1) a = [ ] Ecrire ( " a = ") , lire ( a )
2) Répéter
Ecrire ( " b = ")
Lire ( b )
Jusqu’à ( b > a )
3) Répéter
Ecrire (" n = ")
Lire ( n )
Jusqu’à ( n > 0 )
4) Fin saisir
161
 Algorithme de la fonction calcul

0) Fonction CALCUL ( a , b : réel ; n :entier) : Réel
1) h = [ ] h  ( b – a ) / n
2) Somme =[ Somme  0 , x a + h / 2 ]
Pour i de 1 à N Faire
somme  somme + f ( x )
x  x+h
Fin Pour
3) Calcul = [ ] calcul  somme * h
4) Fin CALCUL
 Algorithme de la fonction f
0) Fonction f ( x : réel ) : réel
1) f = [ ] F  carré( x ) / ( 1 + carré ( x ) )
2) Fin f
162
3) Méthode de trapèze
On se propose de calculer l’aire résultante de la courbe de la fonction f : x  en
utilisant la méthode de trapèzes.
NB : Même démarche que la méthode précédente, on s’intéresse à écrire l’analyse et l’algorithme

de la fonction CALCUL.
 Analyse de la fonction calcul
Déf Fn Calcul ( a , b : réel ; n : entier ) : réel
Résultat = Calcul
Calcul = [ ] calcul  somme * h
H=[ ]h (b – a ) / n
Somme = [somme  (f(a) + f(a+h))/2, x a]
Pour i de 1 à N - 1 Faire
163
x x+h
somme  somme + ( f ( x ) + f ( x + h ) ) / 2
Fin Pour
Fin Calcul
 Algorithme de la fonction calcul

0) Fonction CALCUL ( a , b : réel ; n : entier ) : Réel
1) h = [ ] h  (b-a)/n
2) Somme = [ Somme  (f(a) + f(a+h))/2 ,x a ]
Pour i de 1 à N-1 Faire
x x+h
somme  somme + ( f ( x ) + f ( x + h ) ) / 2
Fin Pour
3) Caclul = [ ] calcul  somme * h

4) Fin CALCUL
164
165
Série N° 11
Exercice N° 1 (ex 3 bac 2012 sp)
Soit la formule suivante qui permet de déterminer une valeur approchée de Cos(x) :
x 2 x 4 x 6 x8
Cos( x )= 1- + - + -…..
2! 4! 6! 8!
Ecrire un algorithme d’un programme intitulé Calcul_Cos qui permet de :
• Saisir un réel x appartenant à l’intervalle [-1 , 1 ]

• Calculer et afficher une valeur approchée de Cos(x) en utilisant la formule donnée ci-
dessus. Le calcul s’arrêt lorsque la différence entre deux termes consécutifs devient
inferieure à 10-4
Exercice N° 2
Soit la formule suivante qui permet de déterminer une valeur approchée de Sin(x) :
x x3 x5 x7 x9
sin(x) = − + − + − .........
1! 3! 5! 7! 9!
Ecrire un algorithme d’un programme intitulé Calcul_Sin qui permet de :
• Saisir un réel x appartenant à l’intervalle [-1 , 1 ]

• Calculer et afficher une valeur approchée de Sin(x) en utilisant la formule donnée ci-dessus.
Le calcul s’arrêt lorsque la différence entre deux termes consécutifs devient inferieure à
10-4.
Exercice N° 3 ( ex 2 bac 2012 sc)
Soient x et a deux réels donnés strictement positifs. On se propose de calculer la somme S

définie par la formule suivante :
S=
Ecrire un algorithme d’un module intitulé CalSom permettant de calculer une valeur
approchée de S à 10-4 près
166
Exercice N° 3 ( ex 1 bac blanc 2012)
On se propose de calculer une valeur approchée d’arc tangente de x par la formule

suivante :
Arctan ( x ) =
Ecrire un algorithme d’une fonction permettant de retourner une valeur approchée de Arctan(x)
en utilisant la formule donnée ci-dessus. Le calcul s’arrête lorsque la valeur absolue de la
différence entre deux terme successifs devienne inferieure ou égale à une erreur epssilon ( avec x
et epsilon deux réels donnés).
Exercice N° 4
On se propose d'écrire un programme en Pascal qui offre un menu de quatre choix définis
selon la valeur d'une lettre saisie.
10
• La valeur "I", pour calculer une valeur approchée de ∫1 ( x sin 2 ( x))dx en utilisant la
méthode des trapèzes.
• La valeur "C", pour calculer une valeur approchée de la fonction C(x) définie comme suit (x
est un entier >1):
1 1 1
τ (x) = 1+ + + +…..
2 x 3x 4 x
(Avec une précision ε = 10 −4 )
Résultat: τ (x) = 1.644 τ (x) = 1.0823.
Attention, pour x <2, la somme est difficile à calculer.
• La valeur "L", pour calculer une valeur approchée de ln(1+x) donné pâr mla formile de
Taylor au voisinage de 0.
x 2 x3 x 4 x5
Ln( 1+x )= x- + - + -…
2 3 4 5
(Avec une précision ε = 10 −3 et x proche de 0)
• La valeur "Q", pour quitter le programme.
Travail demandé:
Saisir votre programme et l'enregistrer dans C:\Bac\ sous votre nom.
167
Exercice N° 5
On se propose d'écrire un programme en Pascal qui offre un menu de quatre choix définis selon la
valeur d'une lettre saisie.
10
• La valeur "I", pour calculer une valeur approchée de ∫1 ( x sin 2 ( x))dx en utilisant la
méthode des trapèzes.
• La valeur "C", pour calculer une valeur approchée de la "Constante de Catalon" qui
apparaît dans certaines expressions de calcul combinatoire et donnée par la formule
suivante :
∞
(−1) k
C= ∑ (avec une précision ε = 10 −4 )
2
k = 0 ( 2 K + 1)
Résultat: C=0.915966
• La valeur "X", pour calculer une valeur approchée de

x 2 x 4 x 6 x8
Cos( x )= 1- + - + -…..
2! 4! 6! 8!
(Avec une précision ε = 10 −3 )
• La valeur "Q", pour quitter le programme.
Travail demandé:
Exercice N° 6
Saisir votre programme et l'enregistrer dans C:\Bac\ sous votre nom.

Soit l'expression mathématique suivante : π/4 = 1-1/3+1/5-1/7+1/9-………
Ecrire un programme Pascal qui utilise l'expression ci-dessus pour déterminer et afficher une
valeur approchée de π a 10-4 pres.
- Le calcul s'arrête quand la différence entre deux valeurs consécutives de cette expression devient
strictement inferieure a 10-4.
Pour chacun des exercices suivants :
a) Proposez une analyse modulaire au problème,
b) Déduisez les algorithmes correspondants.
168
Exercice N° 7 : (ex 2 bac blanc 2009 )
Un agriculteur désire vendre une parcelle de terrain. Toutefois, la forme de la parcelle ne

lui permet pas de connaître facilement sa surface. Ainsi, il demande l’aide de son fils qui à pu
déterminer une représentation graphique de la parcelle en utilisant la fonction f définie par
f(x) = .
La représentation graphique ci-dessous illustre la surface de parcelle qui est délimitée par les
droites d’équation respectives x = et x = et par la courbe représentant f(x) sur l’intervalle
[ , ]
0 0.25 𝝅𝝅 0.5 𝝅𝝅 0.75 𝝅𝝅 𝝅𝝅
Analyser et déduire l’algorithme d’un module qui permet de calculer une valeur approchée de la
surface de la parcelle en utilisant la méthode des rectangles au point du milieu.
Exercice N° 8
on donne Ln (1+x) = x- x²/2+ x3/3- x4/4+....
Écrire un algorithme log qui permet de saisir un réel x, avec x > -1 et x ≤1 et de calculer une valeur
approchée de ln (1+x) à une précision 10-4.
169
Exercice N° 9 (problème bac 2009 sc )
Le but du problème est de déterminer une valeur approchée de l’intégrale I = .
On se propose d’utiliser deux méthodes et d’en dégager la différence entre les deux valeurs
approchées trouvées.
On choisit dans les deux cas, un entier n tel que 100 < n < 1000. n sera le nombre de subdivisions
qu’on va utiliser dans les deux méthodes.
1) Méthode des trapèzes.

On utilise la méthode des trapèzes pour déterminer une première valeur approchée I 1 de I.
2) Méthode d’une subdivision aléatoire

On remplit un tableau V par n-1 réels distincts générés au hasard de l’intervalle [ 1 , 2 ]. On
utilisera la fonction prédéfinie RANDOM qui génère au hasard un réel entre 0 et 1 au sens strict.
En suite, on trie le tableau V par ordre croissant en utilisant le tri par insertion. On aura formé ainsi
une suite
(x i ) 0 ≤ i ≤ n où x 0 = 1, x i = V [ i ] et x n = 2.
On définit les sommes S 1 et S 2 par :
S1 = ; S2 = avec f(x) =
Une valeur approchée de I = est :
I2 =
On se propose d’écrire un programme qui calcul problème en les les deux méthodes
et affiche les deux valeurs approchées ainsi que la valeur absolue de leur différence.
Question :
1) Analyser le problème en le décomposant en modules et déduire l’algorithme du

programme principal qui permet de réaliser le traitement décrit précédemment.
2) Analyser chacun des modules envisagés précédemment et en déduire les algorithmes
correspondants.
Exercice N° 10
Calculez une valeur approchée de : en utilisant la méthode des trapèzes.
Traduisez et testez la solution obtenue. Enregistrez votre programme sous le nom Trapèze.
170
Correction Exercice N° 1 (ex 3 bac 2012 sp)

Nom : Calcul_Cos
Résultat = Ecrire ( Fn Calcul ( x ) )
X= [ ] Répéter
X = donnée (‘’Donner un réel : ‘’ ) T.D.O
Jusqu'à ( x ≥ -1 ) et ( x ≤ 1 )
Fin Calcul_Cos O T/N R
X Réel Donné
Calcul Fonction Retourne
2. Analyse de la fonction Calcul
cosinus
Déf Fn Calcul ( x : Réel ) : Réel
Résultat = Calcul
Calcul = [ ] Calcul  C
C =[ C  1 , i 0 , p  1, f  1 ] Répéter
Cp  C
ii+2
p  - p * Carré ( x )
FF *i*(i–1)
CC+P/F
Jusqu’a Abs ( C – Cp ) < 10-4
Fin Calcul
T.D.O
O T/N R
C Réel
I Entier
P Entier
F Entier
Cp réel
171
Correction Exercice N° 8
Program log ;
uses wincrt;
const
EPSILON = 0.0001;
var
X: real;
function logdl(x: real):real;
var
Som,Xn,A,B: real;
i: integer;
begin
Xn := - 1;
i := 0;
Som := 0;
repeat
i : = i + 1;
Xn : = -Xn * X ;
A := Xn / i ;
i := i + 1;
Xn : = -Xn * X;
B : = Xn / i;
Som := Som + A + B;
until (I > 100) or (abs( A – B ) <= EPSILON );
logdl := Som;
end;
procedure Saisie ( var x : real ) ;

begin
repeat
write('Donner un réel positif X : ');
readln ( x );
until (x > - 1 ) and ( x < = 1 );
end;
begin
Saisie( X );
Writeln('Approximation de Ln(1+X) = ', logdl(X) : 2 : 5 );
end.
172
Correction Exercice N° 9 (problème bac 2009 sc )

Nom : Calcul_integral
Résultat = Ecrire (‘’ VI1 par la méthode des trapèzes : ‘’, VI1 , ‘’ VI2 par la méthode d’une
subdivision aléatoire : ‘’, VI2 , ‘’ la valeur absolue de la différence est ‘’ , abs ( VI1 – VI 2 ) )
VI1 = [ ] VI1  FN trapèzes ( N )
VI2 =[ ] VI2  FN subdivisions ( N )
N= [ ] Répéter
N = Donnée (‘’ Introduire le nombre de subdivisions : ‘’)
Jusqu'à N dans [ 101 .. 999 ]
Fin Calcul_intégral
T.D.O
O T/N R
VI1 Réel Valeur de l’intégral par la méthode des trapèzes
VI2 Réel Valeur de l’intégral par la méthode d’une subdivision aléatoire
N EntierNombre de subdivisions
Trapèzes Fonction
Fonction qui calcul selon la méthode des trapèze une valeur approchée de l’aire en
question
subdivisions Fonction Fonction qui calcul selon la méthode des subdivisions aléatoire une valeur
approchée de l’aire en question
2. Analyse de la fonction trapèzes

Déf fn trapèze ( n : entier ) : réel
Résultat = trapèzes  VI
VI = [ VI  ( ( exp ( - 1 ) + exp ( - 4 ) ) / 2 ) / n ] Pour 1 de 1 à n – 1 Faire
VI  VI + ( exp ( - ( 1 + i / n )2 ) ) / n
Fin Pour
Fin trapèzes
T.D.O
O T/N R
I entier compteur
173
3. Analyse de la fonction subdivisions

Déf Fn subdivisions ( n : entier ) : Réel
Résultat = subdivisions
Subdivisions = [ ] subdivisions  VI
VI =[ ] VI  ( S1 + S2 ) / 2
S1 =[ S1  0 ] Pour i de 0 à n – 1 Faire
S1  S1 + ( V[ i + 1 ] – V[ i ] ) * exp ( - ( V[ i ] )2 )
Fin Pour
S2 = [ S2  0 ] Pour I de 0 à n – 1 Faire
S2  S2 + ( V[ i + 1 ] – V [ i ] ) * exp ( - (V[ i + 1 ] )2 )
Fin Pour
V =[ ] Proc Remplissage ( n , V )
Proc Tri ( n , V )
Fin subdivision
T.D.N.T
Type
Vect = Tableau [ 1 . . 999 ] de réel
T.D.O
O T/N R
I Entier Compteur
S1 Réel Valeur de la somme S1
S2 Réel Valeur de la somme S2
V Vect Tableau contenant les valeurs des xi
Tri procédure Une procédure qui permet de trier les éléments de V par la méthode d’insertion
Une procédure qui permet de remplir le tableau V.
Remplissage Procedure
4. Analyse de la procédure Tri

Déf Proc Tri ( n : entier ; var T : Vect )
Résultat = T
T = [ ] Pour i de 1 à n Faire
Aux  T [ i ]
Ji
Tant que ( T [ j - 1 ] > aux ) et ( j > 1 ) Faire
T[j]T[j–1]
Jj–1 T.D.O
Fin Tant que
T [ j ]  aux O T/N R
Fin Pour I Entier Compteur
Fin Tri J Entier Compteur
aux réel Variable auxiliaire
174
5. Analyse de la procédure Remplissage

Déf Proc Remplissage ( n : entier ; var T : vect )
Résultat = T
T = [ T [ 0 ]  1 ; T [ n ]  2 ] Pour i de 1 à n – 1 Faire
Répéter
T [ i ]  1 + Random
Jusqu'à ( Fn Verif ( i , T ) )
Fin Pour
Fin Remplissage
T.D.O
O T/N R
I Entier Compteur
x Entier Le réel à déterminer au hasard
Vérif Fonction Fonction qui vérifie l’existence d’un élément dans les I premiers éléments
de T.
6. Analyse de la fonction Vérif

Déf Fn Vérif ( j : entier ; T : vect ) : booléen
Résultat = Verif
Vérif = [ ] Vérif  V T.D.O
V =[ V  Vrai , x  T [ j ] ] Répéter
Si x = T [ j -1 ] Alors O T/N R
V  faux X Réel
Sinon V booléen
Jj–1
Fin Si
Jusqu'à ( V = faux ) ou ( j = 1 )
Fin Verif
175
Annexe
176
Exercices et problèmes Annexe
Série N° 1
Exercice N° 1 ( exercice 4 bac 2012 sc)

Exemple :
Ecrire une analyse d’un module intitulé Symétrique
Pour N = 5 la matrice M est
permettant de remplir une matrice M de (2*N-1) ligne et de N
1 2 3 4 5
colonnes, comme le montre l’exemple ci-contre.
-4 1 4 6 4 1
Sachant que :
-3 1 3 3 1
La partie inferieure de la matrice M (de la ligne 0 à la -2 1 2 1
ligne N-1) représente les valeurs du triangle de Pascal. -1 1 1
La partie supérieure de la matrice M (de la ligne 1-N à 0 1
la ligne 0) représente la symétrique de la partie inferieure par 1 1 1
rapport à la ligne 0. 2 1 2 1
3 1 3 3 1
4 1 4 6 4 1
Exercice N° 2 ( exercice 2 bac blanc 2012 )
Mat est un type utilisateur représentant un tableau
d’entiers de 20 lignes et de 20 colonnes. On donne l’algorithme de la procédure inconnue
suivante :
0) DEF PROC Inconnue ( VAR M : MAT ; N ,i, j : Entier )

1) Si i <= N Alors
Si j <= i Alors
Aux  M [ i , j ]
M[ i , j ]  M [ j , i ]
M[ j , i ]  Aux
Proc Inconnue ( M , N i , j + 1 )
Sinon
Proc Inconnue ( M , N , i+1 , 1 )
Fin si
Fin si
2) Fin Inconnue
1. Exécuter manuellement l’algorithme de la procédure Inconnue avec les paramètres effectifs

suivants :
9 6 0
N = 3 , i = 1, j = 1 et M =
4 5 2
3 7 1
2. En déduire le rôle de la procédure Inconnue.
177
Exercice N° 3 ( bac pratique 2012 24 mai 2012 à 14 h 30 mn)

La suite de robinson est définie par :
U0 = 0
Un se construit en concaténant le nombre d’apparitions de chacun des chiffres constituant
le terme Un-1 suivi du chiffre lui-même, selon l’ordre décroissant des chiffres, pour tout n >0.
Exemple :
Pour n = 5, U5 = 13123110
En effet :
U0 = 0
U1 = 10 car il y a une apparition ( 1 ) du chiffre 0 dans U0
U2 = 1110 car il y a une apparition (1) du chiffre 1 et une apparition (1) du chiffre 0 dans U1.
U3 = 3110 car il y a trois apparitions ( 3) du chiffre 1 et une apparition (1) du chiffre 0 dans U2.
U4 = 132110 car il y a une apparition (1) du chiffre 3, deux apparition (2) du chiffre 1 et une
apparition (1) du chiffre 0 dans U3.
U5 = 13123110
On se propose d’écrire un programme qui permet de remplir et afficher un fichier texte
nommé ‘’Robinson.txt’’ contenant les k premiers terme de la suite de robinson ( avec 2<= k <= 15)
sachant que chaque terme de la suite occupera une ligne dans le fichier ‘’Robinson.txt’’.
Décomposez le problème en modules et déduisez les algorithmes correspondants.
Exercice N° 4 ( exercice 1 bac 2009 sp )

On donne ci-dessous, l’algorithme de la procédure TRI dont le rôle est de trier par ordre
croissant les éléments d’un tableau T de type W, vecteur de réels.
0) Procédure TRI (n : entier ; Var T : W )

Si ( T[ i – 1 ] > T [ i ] ) Alors DECALER est une procédure dont le rôle est de décaler d’un
Aux  T [ i ] pas vers l’avant et à partir de l’indice i-1 les éléments de T
DECAER ( i , j , T ) jusqu’à trouver la position j où il faudra placer l’ancienne
T [ j ]  Aux valeur T[i] sauvegardée dans aux.
FinSi
FinPour
2) Fin TRI
a) Comment appelle-t-on cette méthode de tri ?

b) Rappeler brièvement le principe de cette méthode.
c) Donner un algorithme de la procédure et préciser le type de transfert des paramètres
utilisés.
178
Exercice N° 5 (exercice 2 bac 2010 sp )

On considère une suite U définie par :
U1 = 1
U2 = 2
Un = Un-1 + k * Un-2 pour n >= 3, et k un entier donné ( k > 0)
a) Quel est l’ordre de récurrence de cette suite ? Justifiez votre réponse.

b) Ecrire une analyse d’une fonction qui vérifie si un entier p donné est un terme de la suite U
ou non. Si p est un terme de la suite U, la fonction retourne le rang r et p, sinon, elle
retourne -1.
c) En déduire l’algorithme correspondant de cette fonction.
Exercice N° 6
On se donne un entier naturel non nul U0, on se propose de construire la séquence d’entier (Un)
définie par :
Un = U0 n = 0,
Un = est la somme des carres des chiffres de Un-1 pour n > 0
Exemple : si Un= 423 alors Un+1=42+22+32=29

Questions :
1. Est-ce que ce traitement est récurrent ? si oui quel est l’ordre de récurrence.
2. Ecrire l’analyse d’un module qui permet de calculer le nème terme de la suite U ?
Exercice N° 7
Un nombre d'Armstrong est un entier naturel qui est égal a la somme des cubes de ces
chiffres. ainsi 153 est un nombre d'Armstrong car 13 + 53 + 33 = 1 + 125 + 27 = 153.
Proposez un module récursif qui permet de vérifier si un entier N est un nombre d'Armstrong ou
non.
Exercice N° 8
On veut compresser un fichier d'entiers binaires (contenant des 0 et des 1). Le principe de
compression est le suivant :
Si le fichier contient : 00000011111000, La compression nous donne : 605130
On lit se nombre : on a 6 zéros, 5 uns et 3 zéros.
Ecrire un programme Pascal qui permet de créer et remplir un fichier nomme "source.fch" par N
entiers binaires (N est un nombre aléatoire compris entre 4 et 100), puis compresser ce fichier
dans un fichier résultat nomme "compress.fch" en utilisant le principe ci-dessus et l'afficher.
179
Exercice N°9
0) Déf Fn Inconnue (n , b : entier ) : chaine
1) ch <-- ""
2) Tant Que ( n < > 0 ) Alors
convch( n mod b , r)
Si (Long( r ) > 1 ) Alors
Valeur( r , x , e )
r  Chr( x + 55 )
Fin Si
ch  r + ch
n n Div b
Fin Tant Que
3) inconnue  ch
4) Fin Fonction
N.B : On donne le code ASCII de "A" est 65
Questions:
1- Exécuter la fonction pour les valeurs suivantes de n et b
a) n = 94 et b =16
b) n = 12 et b = 2
2- Quel est le rôle de cette fonction.
3- Proposer une solution récursive pour cette fonction.
Exercice N° 10
Function Deviner ( CH : string ; K : integer ) : integer ;
var
I , P , C : integer ;
PH : string ;
begin
C:=0;
P:=1 ;
PH := '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' ;
for I := length (CH) downto 1 do
begin
C:=C+ ( pos( CH[ I ] , PH ) – 1 ) * P;
P := P * K ;
end;
Deviner := C ;
end;
Questions:
1. Compléter le tableau suivant, par les résultats de cette fonction, pour les valeurs suivantes
de CH et K
CH=’BAC’ et K=16 CH=’33’ et K=5 CH=’147’ et K=10
C =………………………. C=………………………………. C =……………………….
2. Quel est le rôle de cette fonction
180
Exercice N° 11

0) Début Fonction Inconnue (n : entier long) : entier
1) S=[S ← 0] Repeter
S ← S + (n Mod 10)
n ← n Div 10
Jusqu’a (n = 0)
2) Inconnue ← S
3) Fin Inconnue
Questions :
1. Exécuter manuellement l’algorithme de la fonction Inconnu, si on appelle cette fonction
avec le paramètre effectif n = 192837, en donnant les valeurs successives des variables S et
n.
3. L’algorithme de cette fonction est-il récurent ? si oui quel est son ordre. ?
Exercice N° 12 (bac pratique 21 mai 2009 à 14h 30 mn)

Soit p et q deux entiers naturels tel que 10 < p < q < 100000. On se propose d’enregistrer
dans un fichier texte decomp.txt la décomposition en facteurs premiers de tous les entiers
compris entre p et q. La première ligne du fichier decomp.txt contiendra le naturel p suivi d’une
espace, suivi du naturel q. chacune des autres lignes contiendra l’entier à décomposer suivi du
signe égal suivi de sa décomposition.
Exemple :
Si p = 34 et q = 36 le fichier decomp.txt contiendra les informations suivantes :
34 36
34 = 2 . 17
35 = 5 . 7
36 = 2 . 2 . 3 . 3
Ecrire un programme decomp.pas qui permet d’afficher à l’écran la décomposition en
facteurs premiers de tous les entiers compris entre p et q et de remplir le fichier decomp.txt
comme décrit précédemment.
N.B : Tous les fichiers seront enregistrés dans le dossier qui porte comme nom « votre nom
et prénom » de l’unité C
Exercice N° 13 ( exercice 2 bac 2010 sc )
Un entier n ( n ≥ 10) est divisible par 25, si le nombre formé par ses deux derniers chiffres
les plus à droites est égal à 00 ou 25 ou 50 ou 75.
Exemple : 679775 est divisible par 25 car le nombre formé par ces deux derniers chiffres est égal à
75.
Ecrire une analyse s’une fonction qui vérifie si un entier n est divisible par 25 en utilisant le
principe décrit précédemment.
181
Série N° 2
Exercice N°1
0) Def fn Inconnue( n : entier ) : entier
1) Convch ( n , ch )
2) X  long ( ch ) - 1
3) Si n < 10 Alors
Inconnue  n
Sinon
x
Inconnue  FN Inconnue ( n div 10 ) + ( n mod 10 ) * 10
Fin si
4) Fin inconnue
Questions :
1. Exécuter manuellement cette fonction pour les appels suivants et donner les valeurs
retournées Pour n = 25 et n = 214
2. ................................................ Quel est le rôle de cette fonction :
Exercice N° 2
Soit l’algorithme de la procédure suivante :

1) Déf Proc Inconnue( Ch : Chaine )
2) Si long( Ch) > 1 Alors
Ecrire( ch )
Proc Inconnue ( copy( Ch , 2 , Long( Ch ) – 2 ) )
Ecrire ( Ch )
Sinon
Ecrire ( ch)
finSi
3) Fin inconnue
a) Faire le tournage à la main avec la chaine Ch =’’ Tableau’’.
b) Proposer une solution itérative à cette procédure ?
Exercice N° 3
Soit l’algorithme de tri suivant :
0) Def Proc Tri ( Var T : Tab ; n : Entier )
Temp  T [ i ]
Proc Décaler ( i , j , T )
T [ j ]  Temp
Fin Pour
2) Fin Tri
Question :
1. Quel est le type de tri utilisé dans cet algorithme ?
2. Donner l’algorithme de la procédure Décaler
3. Proposer un algorithme récursif de ce tri.
182
Exercice N° 4
0) Def Fn Inconnue ( Ch : chaine ) : Chaine
1) Si long ( Ch ) = 0 Alors
Ch  ‘’’’
Sinon
Inconnue  Ch [ long ( Ch ) ] + Fn Inconnue ( sous_Chaine ( Ch , 1 , long ( Ch ) -1 )
Fin Si
2) Fin Inconnue
Questions :
1. Exécuter manuellement la fonction Inconnue avec Ch =’’Modem’’
2. Déduire le rôle de cette fonction ?
3. Proposer une solution itérative ?
Exercice N°5 (ex 1 bac 2013 sc)

Soit l’algorithme de la fonction Inconnue suivante :
0) DEF FN Inconnue ( A, B : Entier ) : ………………..
1) Si A = B Alors
Inconnue  A
Sinon
Si A > B Alors
Inconnue  FN Inconnue ( A – B , B ) * A DIV ( A – B )
Sinon
Inconnue  FN Inconnue (A , B – A ) * B DIV ( B – A )
Finsi
FinSi
2) Fin Inconnue
Travail demandé :
1. Déterminer le type de retour de la fonction Inconnue.

2. Donner la trace d’exécution ainsi que les résultats retournés par la fonction Inconnue pour
les valeurs de A et B suivantes :
A = 6 et B = 15
A = 8 et B = 3
3. Déduire le rôle de la fonction Inconnue.
183
Exercice N° 6 (ex 1 bac 2013 sp)

0) DEF FN Inconnue ( Ch : Chaine ) : ………………………….
1) Si Pos ( ‘’+’’ , Ch ) = 0 Alors
Valeur (Ch , n , e )
Inconnue  n
Sinon
Valeur ( sous-chaine ( Ch , 1 , Pos ( ‘’+’’ , Ch ) – 1 ) , n , e )
Efface ( Ch , 1 , Pos (‘’+’’ , Ch ) )
Inconnue  n + FN Inconnue ( Ch )
FinSi
2) Fin Inconnue
Travail demandé
1. Déterminer le type de retour de la fonction Inconnue.

2. Donner la trace d’exécution ainsi que le résultat retourné par la fonction Inconnue pour
Ch=’’5+3+14+7’’.
Problème 1 ( problème bac blanc Monastir 2012 )

On se propose ce calculer et d’afficher le Pgcd de n entiers, exemple Pgcd(84,72,56,22)=2
utilisant la technique suivante :
• Remplir un fichier « Nombre.dat » par N entiers aléatoire < 100 ( avec 2<= N <= 50).
• Utilisant une matrice M pour chercher le pgcd des nombres du fichier.
- Copier les entiers du fichier ‘’Nombre.dat’’ dans la 1ère ligne de matrice M.
- La 2ème ligne de matrice sera remplie par les pgcd de chaque deux entier adjacent de la 1ère
ligne.
- La 3ème ligne de matrice sera remplie par les pgcd de chaque deux entier adjacent de la 2ème
ligne.
- Appliquer le même principe pour les autres lignes jusqu'à arrivé a une ligne qui à un seul
nombre, qui est le pgcd chercher.
Exemple :
22 84 72 56 22 12 = Pgcd( 84, 72) , 8 = Pgcd( 72,56) , 2 = Pgcd(56,22)

56 12 8 2 4 = Pgcd( 12,8) , 2 = Pgcd( 8 , 2)
72 4 2
2 = Pgcd (4 , 2)
84 2
Fichier « Nombre.dat » Matrice M Comment calculer les pgcd

Questions :
1. Analyser le problème en le décomposant en modules et déduire l’algorithme du programme
principal.
correspondants.
184
Problème 2 ( problème bac 2012 )

Deux chercheurs scientifiques travaillent sur un projet top secret. Ils échangent des lettres
cryptés (codés) pour des raisons de sécurité.
Chaque lettre envoyée ou reçue est sous forme d’un fichier texte « Lettre.txt » formée par
des mots cryptés, et un mot par ligne. Les deux chercheurs se sont mis d’accord sur un fichier de
codage « Code.dat » dans le quel est enregistré tous les caractères avec leurs codes, chaque
caractère est codé sur 6 signes (des « * » et des « - » ).
On se propose d’écrire un programme qui permet de décrypter une lettre reçue pour
devenir lisible.
Exemple :
A *-----
*---*-*-**-**-----*-**--*---*-*-***- EXAMEN
B **----
*--**-*-*--* DU
C *--*--
BAC
**----*-----*--*--
D *--*-
Code.dat lettre.txt les mots décryptés
…..
Le message reçu est : EXAMEN DU BAC
N.B : Les fichiers ‘’Lettre.txt’’ et ‘’Code.dat’’ sont existe déjà. L’élève n’est pas appelé de les
remplir.
Questions :
principal.
correspondants.
185
Correction de série N° 2
Exercice N° 1
1. Pour N = 25
• Exécution de Inconnue ( 25 )
N 25
X 1
Ch ‘’25’’
Inconnue Inconnue( 2)  2 + 5 * 101 = 52
N 2
X 0
Ch ‘’2’’
Inconnue 2
2. Pour N = 214
N 214
X 2
Ch ‘’214’’
Inconnue Inconnue( 21)  12+ 4 * 10 2 = 412
N 21
X 1
Ch ‘’21’’
N 2
X 0
Ch ‘’2’’
Inconnue 2
2. Le rôle de la fonction Inconnue est d’inverser les chiffres d’un nombre donné.
186
Exercice N° 2
1. Inconnue ( ‘’Tableau’’)
Ch Tableau
Inconnue ( ‘’ablea’’ )
Tableau
2. Inconnue ( ‘’ablea’’’)
Ch ‘’ablea’’ ablea
Inconnue ( ‘’ble’’ )
3. Inconnue ( ‘’ble’’) ble
Ch ‘’ble’’
l
Inconnue ( ‘’l’’ )
ble
4. Inconnue (‘’l’’)
Ch ‘’l ‘’ ablea
Tableau
0) Def Proc affiche ( ch : chaine)
1) i  1 , p  0
2) Tant Que ( i <= long ( ch ) div 2 ) faire
Ecrire ( copy ( ch , i , long (ch ) – p )
II+1
Pp+2
Fin Tant que
3) Si long ( ch ) mod 2 <> 0 Alors
Ecrire ( ch [ (long ( ch ) div 2) + 1 ] )
Fin si
4) [ p  p – 2 , i  i – 1 ]
Tant que ( I > 0 )faire
Ecrire ( copy ( ch , i , long ( ch ) – p )
Pp–2
II-1
Fin Tant que
5) Fin affiche
Exercice N° 3
1. Le tri utilisé est le tri par Insertion.
2. Algorithme de la Procédure Décaler
0) Def Proc decaler ( i : entier ; Var p : entier ; Var T : Tab)

1) [ Temp  T [ i ] , p  i ]
Tant que ( T [ p -1 ] > Temp ) et ( p > 1 ) Faire
T[ p ]  T[ p – 1 ]
P  p -1
Fin Tant Que
2) Fin Decaler
187
3. Algorithme récursif
0) Def Proc Tri ( VAR T : Tab ; n , i : entier)
1) Si n > 1 Alors
Proc tri ( T , n – 1 )
Si T [ n ] < T [ n - 1] Alors
Temp  T[ n ]
Proc Decaler ( i , j , T )
T [ j ]  Temp
Fin Si
FinSi
2) Fin Tri
Exercice N° 4
1. Exécution manuelle avec Ch =’’Modem’’

• Exécution Inconnue ( ‘’Modem’’)
Ch ‘’Modem’’
Inconnue ‘’m’’+ Inconnue(‘’Mode’’)  ‘’m’’ + ‘’edoM’’ = ‘’medoM’’
• Exécution Inconnue ( ‘’Mode’’)
Ch ‘’Mode’’
Inconnue ‘’e’’+ Inconnue(‘’Mod’’) ’’e’’+’’doM’’ = ‘’edoM’’
• Execution Inconnue ( ‘’Mod’’)

Ch ‘’Mod’’
Inconnue ‘’d’’+ Inconnue(‘’Mo’’)  ‘’d’’+’’oM’’ = ‘’doM’’
• Execution Inconnue ( ‘’Mo’’)

Ch ‘’Mo’’
Inconnue ‘’o’’+ Inconnue(‘’M’’)  ‘’o’’+’’M’’ = ‘’oM’’
• Execution Inconnue ( ‘’M’’)

Ch ‘’M’’
Inconnue ‘’M’’+ Inconnue(‘’’’)  ‘’M’’+’’’’ =’’M’’
• Execution Inconnue ( ‘’’)
Ch ‘’’’
Inconnue ‘’’’
2. Cette fonction permet d’inverser une chaine donnée

0) Def Fn Inverse ( ch : chaine ) : chaine
1) Pour i de 1 à long ( ch ) div 2 Faire
Aux  Ch [ i ]
Ch [ i ]  Ch [ long ( ch ) – i + 1 ]
Ch [ long ( ch ) – I + 1 ]  Aux
Fin Pour
2) Inverse  Ch
3) Fin Inverse
188
Correction de Problème 2
Nom : Problème2
Résultat = Ecrire (‘’la lettre reçue est : ‘’, Fn Message ( FL , Fc ) )
Fc , FL = [ ] Proc Creation ( FL , Fc )
Proc RremplirLc( Fc )
Proc RemplirFc ( FL )
Fin Problème
T.D.N.T T.D.O
Type Objet Type/Nature Role
Mcode = Enregistrement FL Texte Fihier textec
Car : Caractère Fc Crypte Fichier de Mcode
Code : chaine Creation Procédure
Fin RemplirLc Procédure
Crypte = Fichier de Mcode RemplirFL Procédure
Message Fonction
2. Analyse de la fonction Message

Def FN Message ( Var FL :texte ; Var Fc : Crypte ) : Chaine
Résultat = Message
Message = [ ] Message  ChR
ChR = [ ouvrir ( FL ) , ChR ’’‘’ ]
Tant que Non ( Fin_Fichier ( FL ) ) faire
Lire_nl ( FL , motc )
Ch ’’’’
Tant que ( long ( motc ) <> 0 ) faire
St  sous_chaine ( motc , 1 , 6 )
Ouvrir ( Fc )
Tant que Non ( Fin_Fichier ( Fc ) ) faire
Lire_nl ( Fc , Ec )
Si Ec . code = st Alors
Ch  Ch + Ec . car
Fin si
Fin Tant que
Efface ( motc , 1 , 6 )
Fin Tant que
ChR  ChR + ‘’ ‘’ + Ch
Fin Tant Que
Fin Message T.D.O
Objet Type/Nature Role
Ec Mcode Enregistrement de code
Ch Chaine
Motc Chaine
ChR Chaine
St chaine
189
Correction Problème 2

Nom : problème2
Résultat = Ecrire (‘’Le Pgcd est : ‘’, Fn Recherche ( Fn ) )
Fn = [ ] Proc Création ( Fn )
Proc Remplir (Fn )
Fin problème2 T.D.O
T.D.N.T Fn Nombre
Type Recherche Procedure
Nombre = Fichier d’entier Creation Procedure
Remplir Procedure
2. Analyse procédure Création

Def Proc Création (var Fn : Nombre)
Résultat = Fn
Fn = [ ] Associer ( Fn , ‘’C:\4SI\Nombre.dat’’)
Recréer ( Fn )
Fin Création

Def Proc Remplir ( Var Fn : Nombre )
Resultat = Fn
Fn = [ ] Pour i de 1 à N faire
K  Random ( 100 )
Ecrire ( Fn , k )
Fin Pour
N = [ ] Repeter
N = Donnée ( ‘‘Entrer le nombre des entier ‘’)
Fin Remplir
4. Analyse de la function Pgcd

Def Fn Pgcd ( a , b : entier ) : entier
Resultat = Pgcd
Pgcd = [ ] Pgcd  a
a =[ ] Repeter T.D.O
r  a mod b
ab Objet Type/Nature Role
br A Entier
jusqu’a ( b = 0 ) B Entier
Fin Pgcd R Entier
190
5. Analyse de la Fonction recherche

Def Fn Recherche ( Var Fn : Nombre ) : entier
Résultat = Recherche
Recherche = [ ] Recherche  M [ n , 1 ] T.D.O
M = [ ouvrir ( Fn ) , i  1 , n 0 ] Objet Type/Nature Role
Tant que Non ( Fin_Fichier ( Fn ) ) faire K Entier
Lire ( Fn , k ) I Entier
NN+1 N Entier
M[ i , N ]  K
Fin Tant que
PN
Répéter
Ii+1,j1
Tant que ( j < p ) faire
M [ i , j ]  Pgcd( M [ i – 1 , j ] , M[ I – 1 , j + j ] )
Jj+1
Fin Tant Que T.D.O
PP–1 Objet Type/Nature Rôle
Jusqu’a ( I = N ) N Entier
Fin Recherche I Entier
K Entier
M Tableau [ 1..50 , 1..50 ] d’entier
P Entier
191
Série N° 3
Exercice N° 1 :
Soit les déclarations suivantes :
Type
Fiche = Enregistrement
Rib : long Entier
Nom : chaine
Prénom : chaine
Solde : réel
Fin Fiche
Compte = Ficher de Fiche
Tab = Tableau [1.. 100] de fiche
Nbre = Ficher d’Entier
Objets Type/Nature Rôle

E1 Fiche Enregistrement de Fiche
E2 Fiche Enregistrement de Fiche
E3 Entier Un nombre
T Tab Tableau de 100 Fiche
Ft Texte Ficher texte
Fn Fichier Nbre Fichier d’entiers
Fc Compte Ficher de client
En se basant sur les déclarations précédentes, dire pour chacune des instructions suivantes
si elle est correcte ou non. Dans le cas ou elle ne l’est pas, justifier votre réponse.
a- E1  E2
b- E1  E2 . Rib
c- E1  T [ 3 ]
d- Ecrire ( T [ 3 ] )
e- E1  T [ 4 ] . solde
f- Lire ( fn , E3)
g- Ecrire_nl ( Ft , E2 )
h- Ecrire ( Fn , E2 . solde )
192
Exercice N° 2 :

0) Début Def FN Inconnue ( st : chaine) : chaine
1) Si Long ( st ) > 0 Alors
Si ( st [ 1] dans [ ‘a’ . . ‘z’ ] ) Alors
Inconnue  CHR (ORD ( st[ 1 ] ) – 32 ) + Inconnue ( Sous_chaine ( st , 2 , Long ( st ) – 1 ) )
Sinon
Inconnue  st[ 1 ] + Inconnue ( Sous_chaine ( st , 2 , Long ( st ) – 1 ) )
Fin si
Finsi
2) Fin Inconnue
Questions:
a) Exécuter à la main l’algorithme de la fonction Inconnue avec st = ‘bac2011’ et
st=’Algorithme’ ?
b) Déduire le rôle de cette fonction ?
Exercice N° 3 :
Pour vérifier la divisibilité d’un entier N par 11 on peut procéder comme suit :
Soustraire de N amputé de son chiffre des unités, le chiffre supprimé et recommencer
éventuellement avec le nombre ainsi obtenu jusqu'à :
- Trouver un zéro on dit que N est divisible par 11.
- Un entier < 11 on dit que N n’est pas divisible par 11.
Exemple
N= 1049818
104981-8=104973
10497-3=10494
1049-4=1045
104-5=99
9-9=0
Le nombre N est divisible par 11
N=12345
1234-5=1229
122-9=113
11-3=8
0-8=-8<0
N n’est pas divisible par 11
QUESTION:
Ecrire l’algorithme d’un module qui permet de vérifier si un entier donné est divisible par
11 ou non.
193
Exercice N° 4 :
On désire écrire un programme qui permet de réaliser le traitement suivant :

• Faire la lecture d’un entier décimal à partir d’un fichier d’entiers.
• Convertir l’entier décimal à son équivalent a une base donnée b (qui peut être 2, 8
ou 16).
• Inverser le nombre trouvé.
• Convertir le résultat de la base b a la base décimale
• Retourner le nombre décimal obtenu finalement au fichier et à la place de l’entier
initial.
• Répéter les mêmes étapes pour tous les entiers du fichier.
Exemple :
Soit la base b =16 et Fn : fichier d’entier
Contenu du fichier
Contenu du fichier Fn Equivalant en
Inverse de l’Hexadécimal Fn finalement en
initialement Hexadécimal
décimal
30 1E E1 225
162 A2 2A 42
2988 BAC CAB 3243
Pour cela on vous demande d’écrire :

1- L’analyse puis l’algorithme d’un module qui permet de remplir un fichier nombres.dat par
n entiers aléatoires < 1000. (Avec 10 < n <200)
2- L’analyse puis l’algorithme d’un module qui permet de convertir un entier décimal à son
équivalent à une base b. (solution récursive).
3- L’analyse puis l’algorithme d’un module qui permet d’inverser une chaine donnée (solution
récursive).
4- L’analyse puis l’algorithme d’un (ou des) module (s) qui répondre aux taches cités au
début.
5- Déduire l’analyse et l’algorithme du programme principal.
(N.B : dans cette solution n’utiliser qu’un seul fichier nombre.dat)
194
Exercices N° 5
• Remplir une matrice M de degré 4 par des entiers binaires (0 et 1 seulement).
• Chaque ligne de la matrice M représente la conversion binaire d’un entier X de la base 10 ;
o Trouver la valeur de X pour chaque ligne de M,
o Associer les valeurs de X dans un tableau T,
• Trier puis afficher (en ordre décroissant ) les éléments du tableau T.
Exemple :
Si M =
1 2 3 4 T
1 1 0 1 0  10
2 0 1 1 1  7
3 1 0 0 1  9
4 1 0 1 1  11
( 1010 ) 2 = ( 10 ) 10 Comment ?
23 22 21 20
1 0 1 0
1010 = 1*23 + 0 *22 + 1*21 + 0*20 = 1*8 + 0*4 + 1*2 + 0*1 = 10
Le programme affichera : 11-10-9-7
Question :
1) Analyser le problème en le décomposant en modules.

2) Analyser chacun des modules envisagés dans l’analyse du programme principal.
3) Déduire de ce qui précède l’algorithme du programme principal ainsi que les algorithmes des
modules envisagés.
195
Exercice N° 6
Le mot de passe
Une application informatique génère automatiquement un mot de passe de la manière suivante :
Il s’agit de remplir aléatoirement une matrice carrée M de taille ( NL x NC) avec (5< NL <13 et 5
<NC<13) par des chiffres binaires ;
Convertir le contenu de chaque ligne en son équivalent décimal ; si le nombre trouvé correspond à un
code ASCII alors le caractère correspondant fera partie du mot de passe sinon le caractère dont le code
ASCII est le reste de la division du nombre trouvé par 256 en fera partie ;
Le mot de passe final est obtenu en triant la chaine constituée dans l’ordre décroissant en employant la
méthode du tri à bulles dans sa version récursive.
Exemple
Pour NL=4, NC=10
M=
1 0 0 1 0 0 0 0 0 1
0 0 0 1 1 0 0 0 1 0
1 0 0 1 0 1 1 1 0 1
0 0 0 0 1 1 0 0 0 1
L’application générera le mot de passe suivant : b]A1
Questions :
1) Quelles sont les structures de données adéquates à ce problème ? justifier le choix de chaque
structure proposée.
2) Analyser et déduire l’algorithme du programme principal qui permet de réaliser le traitement décrit
précédemment en le décomposant en modules.
3) Analyser chacun des modules envisagés précédemment et en déduire les algorithmes
correspondants.
196
Série N° 4
Exercice 1 (problème bac 2011 s. contrôle)
Dans le cadre de la réalisation d’un projet scientifique, deux chercheurs résidants dans deux pays
différents, s’échangent des données sur Internet. Pour assurer la confidentialité de leur projet, les
messages échangés sont cryptés.
Le message initial se compose au maximum de 50 lignes et chaque ligne contient 50 caractères au

maximum. Ce message est stocké dans un fichier texte intitulé « TxtInit.txt » sur la racine du
lecteur C. en supposant que ce texte est déjà saisi, on se propose de créer un deuxième fichier
texte intitulé « TxtCryp.txt » contenant le message qui sera crypté de la manière suivante :
1ère étape :
Remplir un e matrice d’entiers MC par les codes ASCII (en base 10) des caractères du message
initial. Chaque ligne de la matrice contiendra les codes ASCII des caractères d’une ligne du fichier
« TxtInit.txt ». le nombre de lignes de la matrice MC est égal au nombre de lignes du fichier
« TxtInit.txt » et le nombre de colonnes de la matrice MC est égal à la longueur (long_max) de la
plus longue ligne du fichier.
Pour les lignes ayant une longueur inferieure à long_max, on complète les cases restées vides par
le code ASCII du caractère espace (qui est égal à 32).
2ème étape :
Convertir, dans la même matrice, tous les éléments de MC en base 8.
3ème étape :
Stoker dans « TxtCryp.txt », les colonnes de la matrice MC, de la colonne la plus à gauche à la
colonne la plus à droite. Chaque colonne de la matrice MC occupera une ligne et les éléments de
cette ligne seront séparés par le caractère espace.
Exemple : Bonjour
Si le fichier « TxtInit.txt » contient le texte suivant, Test1
Merci
alors les étapes de détermination du fichier « TxtCryp.txt » seront les suivantes :
197
1ère étape : A partir du fichier « TxtInit.txt » précédent, on obtient la matrice MC suivante :
1 2 3 4 5 6 7
1 66 111 110 106 110 117 114 Où 66 est le code ASCII de « B », 111
MC celui de « o », … et 32 le code ASCII du
2 84 101 115 116 49 32 32
caractère espace.
3 77 101 114 99 105 32 32
2ème étape : Après la conversion en base 8, on obtient la matrice MC suivante :
1 2 3 4 5 6 7
162 est la conversion en
1 102 157 156 152 110 165 162 base 8 de (114)10
MC 2 124 145 163 164 61 40 40
3 115 145 162 143 151 40 40
ème
3 étape : A partir de la matrice MC précédente, on obtient le fichier « TxtCyp.txt » suivant :
102 124 115

157 145 145
La ligne n°4 du fichier
156 163 162
« TxtCryp.txt » correspond
152 164 143
à la colonne n° 4 de la
156 61 151 matrice MC
165 40 40
162 40 40
Travail demandé :
1. Analyser le problème en le décomposant en module et en déduire l’algorithme du
programme principal.
correspondants.
198
Correction d’exercice N°1 série 4

Nom : sujetbac2011sc
Résultat = Proc Affiche ( Fc )
Fc = [ ] Proc RemplirFc ( Fc , MC , L , C )
MC , L , C = [ ] Proc Creation ( FC , Finit )
Proc RemplirMC ( Finit , MC , L , C )
Fin Sujetbac2011sc
T.D.N.T
Type
Mat = tableau [ 1 .. 50 , 1 .. 50 ] d’entier
T.D.O
Objet Type / Rôle
Nature
Fc Texte Fichier texte crypté
Finit Texte Fichier texte initial
MC Mat Matrice de 50x50 entier
L Entier Ligne
C Entier Colonne
Affiche Procédure Affiche le contenu d’un fichier texte
Création Procédure
remplirFC Procédure
remplirMC Procédure
2. Analyse de la procédure Affiche

Def Proc Affiche ( var FC : texte )
Résultat = aff
Aff =[ Ouvrir (FC) ] Tant que Non ( Fin_Fichier ( FC ) ) Faire
Lire_nl ( FC , Ligne )
Ecrire ( ligne )
Fin Tant que
Fin Affiche
T.D.O
Objet Type / Rôle
Nature
ligne chaine Ligne du fichier
199
3. Analyse de la procédure RemplirFc

Déf Proc RemplirFc ( var FC : texte ; MC : Mat ; L , M : entier )
Résultat = FC
FC = [ Ajouter ( FC ) ]
Pour i de 1 à C Faire
Ch  ‘’ ‘’
Pour j de 1 à L Faire
Convch ( MC [ j , i ] , st )
Ch  Ch + st + ‘’ ‘’
Fin Pour
Efface ( Ch , Long ( Ch ) , 1 )
Ecrire_nl ( FC , Ch )
Fin Pour
Fin RemplirFC
T.D.O
Objet Type / Rôle
Nature
i Entier Compteur
j Entier Compteur
Ch Chaine Ligne du fichier
St chaine Un entier sous forme une chaine
4. Analyse de la procedure RemplirMC

Déf Proc RemplirMC ( Var MC : Mat ; var L , Cmax : entier )
Résultat = MC , L , C
T.D.O
MC = [ Ouvrir ( Finit ) , L  0 ]
Tant que Non ( Fin_Fichier ( Finit ) ) Faire Objet Type / Nature Rôle
Lire_nl ( Finit , Ch )
LL+1 i Entier Compteur
Pour i de 1 à Long ( Ch ) Faire
J Entier Compteur
MC [ L , i ]  Ord ( Ch [ i ] )
Fin Pour Ch Chaine Une ligne d’un fichier texte
Pour j de ( i+1 ) à Cmax Faire
MC [ L , j ]  32 L Entier Nombre de ligne
Fin Pour
Cmax entier Nombre de colonne maximal
Fin Tant que
conversion fonction Conversion d’un entier décimal en binair
Pour i de 1 à L Faire
Pour j de 1 à Cmax Faire
MC [ i , j ]  FN conversion ( MC [ I , j ] , 8 )
Fin Pour
Fin Pour
Cmax= [ Ouvrir ( Finit ) , Cmax  0 ]
Tant que Non ( Fin_Fichier ( Finit ) ) Faire
Lire_nl ( Finit , Ch )
Si Cmax < Long ( Ch ) Alors
Cmax  Long ( Ch )
Fin Si
Fin Tant que
Fin RemplirMC
200
5. Analyse de la fonction conversion

Déf Proc Conversion ( N , b : entier ) : entier
Résultat = Conversion
Conversion = [ ] Conversion  k
K = [ Ch  ‘’‘’ ]
Répeter
R  N mod b
N  N div b
Convch ( R , st )
Ch  st + Ch
Jusqu'à ( N = 0 )
Val ( Ch , k , e )
Fin conversion
T.D.O
Objet Type / Rôle
Nature
R Entier Reste de la division
Ch Chaine Résultat de conversion
St Chaine Conversion du reste à une chaine
K Entier Résultat sous forme entier
E Entier Erreur
201
Serie N° 5
Exercice N° 1 ( ex 1 bac 2012 sp)
Soient les tableau de déclaration des types et des objets suivants :
TDNT
Type
Jours = (Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche)
Enreg = Enregistrement
Jrs : Jours
CodeArt : Chaine [10]
QteVendue : Réel
Fin Enreg
Article = Fichier de Enreg
Fiche = Fichier d’entier
Vect = Tableau [ Lundi . . Dimanche ] de Enreg
TDO
Objet Nature /Type Rôle
Va Vect Vecteur d’aricles vendu
Fa Article Fichier d’articles vendus
Fe Fiche Fichier d’entier
Avend Enreg Les données d’un article vendu
Test Booléen Variable booléenne
R Réel Variable réelle
Cj Jours Compteur
Ft texte Fichier contenant les noms des
articles
Recopier le tableau suivant sur votre feuille de copie puis le complèter en mettant dans la 2ème
colonne la lettre « V » si l’instruction donnée dans la 1ère colonne est valide ou par « F » dans le cas
contraire, tout en justifiant la réponse si l’instruction est non valide.
Instruction Validité de l’instruction Justification ( si faux)

Pour Cj de Mardi à Samedi Faire
Va[ Cj ] . Jrs  Cj
Fin Pour
Ecrire ( Fa , Avend . CodeArt )
Lire (Avend.Jrs )
Test  Fin_Fichier ( Ft ) = Faux
Ecrire ( FE , R )
Test  Va [ Lundi ] > Va [ Jeudi ]
202
Exercice N° 2 ( ex 1 bac 2012 sc )

Soit Temps un type enregistrement, composé des trois champs suivants :
• Heures ( avec 0≤ Heures ≤ 23 )
• Minutes ( avec 0≤ Minutes ≤ 59)
• Secondes ( avec 0≤ secondes ≤ 59)
Questions
1. Dresser le tableau de déclaration du type Temps.
2. Recopier le tableau ci-dessous sur votre feuille de copie et le complèter par les instructions
algorithmes correspondant aux traitement proposés, sachant que T1 et T2 sont deux
variables de type Temps.
Traitement Instructions algorithmes

Saisir la variable T1, en respectant les contraintes
nécessaires
Affecter le contenu de la variable T1 à la variable T2
Afficher le contenu de la variable T2
Exercice N°3 ( ex 1 bac 2010 sp)

Soit les déclarations suivantes :
TDNT
Type
TEmploye = Enregistrement
Mat : Chaine [30]
Age : Octet
Genre : caractère
Fin TEmploye
FEmp = fichier de TEmploye
FEnt = fichier d’entiers
TDO
F FEnt Fichier d’entier
F1 FEmp Fichiers des employés
F2 Texte Fchier texte
E TEmploye Enregistrement d’un employé
Ch Chaine Chaine de caractère
En se basant sur les déclarations précédeentes, dire pour chacune des instructions
suivantes si elle est correcte ou non. Dans le cas où elle ne l’est pas, justifier votre réponse.
a) Lire ( F1 , E )
b) Ecrire ( F , Ch )
c) Pointer ( F2 , 4 )
d) Ecrire ( F1 , E . Age )
203
Serie N° 6
Exercice N° 1 ( ex1 bac 2013 sp)

0) DEF FN Inconne ( ch : chaine ) : ……………………..
1) Si Pos ( ‘’ + ‘’ , ch ) = 0 Alors
Valeur ( ch , n , e )
Inconnue  n
Sinon
Valeur ( Sous-chaine ( ch , 1 , Pos ( ‘’ + ‘’ , ch ) – 1 ) , n , e )
Efface ( ch , 1 , Pos ( ‘’ + ‘’ , ch ) )
Inconnue  n + Fn Inconnue ( ch )
FinSi
2) Fin Inconnue
Travail demandé
1. Déterminer le type de la fonction Inconnue.
2. Donner la trace d’execution ainsi que le résultat retourné par la fonction Inconnue pour
ch= ‘’5+3+14+7’’.
Exercice N° 2 ( ex 3 bac 2013 sp)

Dans le but de creuser une rivière de largeur Larg métres, d’une rive A à une rive B, et de
longueur Long métres, une société de travaux publics veut déterminer le volume approximatif de
sable à enlever. La forme de la partie enlevée est obtenue par la représentation graphique de la
fonction f définie par f(x)=-3 * sin (x), comme illustré ci-dessous :
Long
Larg
A B
Travail demandé
Ecrire un algorithme d’un module qui permet de calculer une valeur approchée du volume
de sable à enlever entre les deux rives A et B pour creuser la rivère, pour un nombre de
subdivisions N.
204
Exercice N° 3 ( problème bac 2013 sp )
Etant donné un fichier texte nommé ‘’F_IPV4.txt’’ contenant dans chaque ligne une adresse
IPV4. On se propose de vérifier la validité des adresses IP4 stockées dans ce fichier, de déterminer
la classe à laquelle appartient chacune des adresse valides, de les faire migrer vers le système IPV6
et de stocker dans un fichier d’enregistrements nommé ‘’F_IPV6.dat’’ chaque adresse IPV4 valide
ainsi que la classe à laquelle elle appartient et son équivlent en IPV6.
Pour ce faire, on dispose des informations suivantes :
1. Une adresse IPV4 valide est codée par quatre octets ( 32 bits) et répresentée sous la forme
W.X.Y.Z avec W, X, Y et Z sont quatres entiers naturels appartenant chacun à l’intervalle
[0,255] et séparés par le caractère ‘’.’’.
N.B : pour vérifier la validité d’une adresse IPV4, le candidat est appelé uniquement à vérifier si W,
X, Y et Z sont dans l’intervalle [0,255].
2. Chaque adresse IPV4 valide appartient à une classe :
• Classe A, si la valeur du premier bit à gauche de la répresentation en b inaire de W est 0.
• Classe B, si la valeur des deux premiers bits à gauche de la répresentation en binaire de W
est 10.
• Classe C, si la valeur des trois premiers bits à gauche de la répresentation en binaire de W
est 110.
• Classe D, si la valeur des quatre premiers bits à gauche de la répresentation en binaire de
W est 1110.
• Classe E, si la valeur des quatre premiers bits à gauche de la répresentation en binaire de
W est 1111.
3. Une adresse IPV6 est codée sur 16 octets ( 128 bits). Pour faire migrer une adresse IPV4
valide vers le système IPV6, on va s’intéresser uniquement au bloc de 32 bits dans
l’adresse IPV6 valide qui représente la conversion en hexadécimal de l’adresse IPV4.
Pour ce faire, on convertit chacun des nombres W, X, Y et Z en hexadécimal, puis les
concatener en insérant le caractère ‘’ :’’ au milieu du résultat obtenu.
Exemple :
L’adresse 155.105.50.68 est valide et elle appartient à la classe B cal la valeur des deux
premiers bits à gauche de la representation en binaire de 155 qui est 10011011 est 10.
L’equivalant du nombre décimal 155 en hexadécimal est 9B
L’equivalant du nombre décimal 105 en hexadécimal est 69
Donc, le bloc de 32 bits dans l’adresse IPV6 qui répresente la conversion en hexadécimal de
l’adresse IPV4 est 9B69 :3245
N.B :
• le candidat n’est pas appelé à remplir le fichier ‘’F_IPV4.txt’’
• Tous les fichiers utilisés sont enregistrés sur la racine C.
Travail demandé
1. Analyser le problème en le décomposant en modules.
2. Analyser chacun des modules envisagés.
205
REPUBLIQUE TUNISIENNE Section : S.info Classe : 4ème SI 3

**** Epreuve : Algo & prog Prof : Khaled Chraiet
Circonscription Régionale Nabeul Durée : 2 heures
Lycée El Hawaria
2012-2013 Devoir de Synthèse N°1
5 Décembre 2012
Note : L’élève doit choisir deux exercices parmi les 4 exercices ( ex1 , ex 2, ex3, et ex 4)
+
Un problème parmi les deux problèmes (problème 1 et problème 2 )
Exercice N° 1 ( 5pts)
0) Def fn Inconnue( n : entier ) : entier
1) Convch ( n , ch )
2) X  long ( ch ) - 1
3) Si n < 10 Alors
Inconnue  n
Sinon
x
Inconnue  FN Inconnue ( n div 10 ) + ( n mod 10 ) * 10
Fin si
4) Fin inconnue
Questions :
1. Exécuter manuellement cette fonction pour les appels suivants et donner les valeurs
retournées Pour n = 25 et n = 214
2. Quel est le rôle de cette fonction :.
Exercice N° 2 ( 5 pts)
Soit l’algorithme de la procédure suivante :
4) Déf Proc Inconnue( Ch : Chaine )

5) Si long( Ch) > 1 Alors
Ecrire( ch )
Proc Inconnue ( copy( Ch , 2 , Long( Ch ) – 2 ) )
Ecrire ( Ch )
Sinon
Ecrire ( ch)
finSi
6) Fin inconnue
a) Faire le tournage à la main avec la chaine Ch =’’ Tableau’’.
206
b) Proposer une solution itérative à cette procédure ?
Exercice N° 3 (5 pts)
Soit l’algorithme de tri suivant :
0) Def Proc Tri ( Var T : Tab ; n : Entier )
Temp  T [ i ]
Proc Décaler ( i , j , T )
T [ j ]  Temp
Fin Pour
2) Fin Tri
Question :
1. Quel est le type de tri utilisé dans cet algorithme ?
2. Donner l’algorithme de la procédure Décaler
3. Proposer un algorithme récursif de ce tri.
Exercice N° 4 ( 5 pts)

0) Def Fn Inconnue ( Ch : chaine ) : Chaine
1) Si long ( Ch ) = 0 Alors
Ch  ‘’’’
Sinon
Inconnue  Ch [ long ( Ch ) ] + Fn Inconnue ( sous_Chaine ( Ch , 1 , long ( Ch ) -1 )
Fin Si
2) Fin Inconnue
Questions :
4. Exécuter manuellement la fonction Inconnue avec Ch =’’Modem’’
5. Déduire le rôle de cette fonction ?
6. Proposer une solution itérative ?
207
Problème 1 ( 10 pts)
On se propose ce calculer et d’afficher le Pgcd de n entiers, exemple Pgcd(84,72,56,22)=2
utilisant la technique suivante :
• Remplir un fichier « Nombre.dat » par N entiers aléatoire < 100 ( avec 2<= N <= 50).
• Utilisant une matrice M pour chercher le pgcd des nombres du fichier.
- Copier les entiers du fichier ‘’Nombre.dat’’ dans la 1ère ligne de matrice M.
- La 2ème ligne de matrice sera remplie par les pgcd de chaque deux entier adjacent de la 1ère
ligne.
- La 3ème ligne de matrice sera remplie par les pgcd de chaque deux entier adjacent de la 2ème
ligne.
- Appliquer le même principe pour les autres lignes jusqu'à arrivé a une ligne qui à un seul
nombre, qui est le pgcd chercher.
Exemple :
22 84 72 56 22
56 12 8 2 12 = Pgcd( 84, 72) , 8 = Pgcd( 72,56) , 2 = Pgcd(56,22)
72 4 2 4 = Pgcd( 12,8) , 2 = Pgcd( 8 , 2)
84 2 2 = Pgcd (4 , 2)
Fichier « Nombre.dat » Matrice M Comment calculer les pgcd

Questions :
principal.
correspondants.
208
Problème 2 ( 10 pts )
Deux chercheurs scientifiques travaillent sur un projet top secret. Ils échangent des lettres
cryptés (codés) pour des raisons de sécurité.
Chaque lettre envoyée ou reçue est sous forme d’un fichier texte « Lettre.txt » formée par
des mots cryptés, et un mot par ligne. Les deux chercheurs se sont mis d’accord sur un fichier de
codage « Code.dat » dans le quel est enregistré tous les caractères avec leurs codes, chaque
caractère est codé sur 6 signes (des « * » et des « - » ).
On se propose d’écrire un programme qui permet de décrypter une lettre reçue pour
devenir lisible.
Exemple :
A *-----
*---*-*-**-**-----*-**--*---*-*-***- EXAMEN
B **----
*--**-*-*--* DU
C *--*--
BAC
**----*-----*--*--
D *--*-
…..
Code.dat lettre.txt les mots décryptés
Le message reçu est : EXAMEN DU BAC
N.B : Les fichiers ‘’Lettre.txt’’ et ‘’Code.dat’’ sont existe déjà. L’élève n’est pas appelé de les
remplir.
Questions :
principal.
correspondants.
209
Correction de devoir de synthèse N°1
Exercice N° 1 ( 5 pts= 4+1)
3. Pour N = 25
N 25
X 1
Ch ‘’25’’
N 2
X 0
Ch ‘’2’’
Inconnue 2
2. Pour N = 214
N 214
X 2
Ch ‘’214’’
Inconnue Inconnue( 21)  12+ 4 * 10 2 = 412
N 21
X 1
Ch ‘’21’’
N 2
X 0
210
Ch ‘’2’’
Inconnue 2
4. Le rôle de la fonction Inconnue est d’inverser les chiffres d’un nombre donné.
211
Exercice N° 2 (5pts = 2 +3)

Tableau
1. Inconnue ( ‘’Tableau’’)
ablea
Ch Tableau
ble
Inconnue ( ‘’ablea’’ )
l
2. Inconnue ( ‘’ablea’’’)
ble
Ch ‘’ablea’’
ablea
Inconnue ( ‘’ble’’ )
Tableau
3. Inconnue ( ‘’ble’’)
Ch ‘’ble’’
Inconnue ( ‘’l’’ )
4. Inconnue (‘’l’’)
Ch ‘’l ‘’
0) Def Proc affiche ( ch : chaine)
1) i  1 , p  0
2) Tant Que ( i <= long ( ch ) div 2 ) faire
Ecrire ( copy ( ch , i , long (ch ) – p )
II+1
Pp+2
Fin Tant que
3) Si long ( ch ) mod 2 <> 0 Alors
Ecrire ( ch [ (long ( ch ) div 2) + 1 ] )
Fin si
4) [ p  p – 2 , i  i – 1 ]
Tant que ( I > 0 )faire
Ecrire ( copy ( ch , i , long ( ch ) – p )
212
Pp–2
II-1
Fin Tant que
5) Fin affiche
Exercice N° 3 ( 5pts = 1+2+2)

4. Le tri utilisé est le tri par Insertion.
5. Algorithme de la Procédure Décaler
0) Def Proc decaler ( i : entier ; Var p : entier ; Var T : Tab)
1) [ Temp  T [ i ] , p  i ]
Tant que ( T [ p -1 ] > Temp ) et ( p > 1 ) Faire
T[ p ]  T[ p – 1 ]
P  p -1
Fin Tant Que
2) Fin Decaler
6. Algorithme récursif
0) Def Proc Tri ( VAR T : Tab ; n , i : entier)
1) Si n > 1 Alors
Proc tri ( T , n – 1 )
Si T [ n ] < T [ n - 1] Alors
Temp  T[ n ]
Proc Decaler ( i , j , T )
T [ j ]  Temp
Fin Si
FinSi
2) Fin Tri
213
Exercice N° 4 ( 5pts = 2+1+2)
4. Exécution manuelle avec Ch =’’Modem’’

• Exécution Inconnue ( ‘’Modem’’)
Ch ‘’Modem’’
inconnue ‘’m’’+ Inconnue(‘’Mode’’)  ‘’m’’ + ‘’edoM’’ = ‘’medoM’’
• Exécution Inconnue ( ‘’Mode’’)

Ch ‘’Mode’’
inconnue ‘’e’’+ Inconnue(‘’Mod’’) ’’e’’+’’doM’’ = ‘’edoM’’
• Execution Inconnue ( ‘’Mod’’)

Ch ‘’Mod’’
inconnue ‘’d’’+ Inconnue(‘’Mo’’)  ‘’d’’+’’oM’’ = ‘’doM’’
• Execution Inconnue ( ‘’Mo’’)

Ch ‘’Mo’’
inconnue ‘’o’’+ Inconnue(‘’M’’)  ‘’o’’+’’M’’ = ‘’oM’’
• Execution Inconnue ( ‘’M’’)

Ch ‘’M’’
inconnue ‘’M’’+ Inconnue(‘’’’)  ‘’M’’+’’’’ =’’M’’
• Execution Inconnue ( ‘’’)

Ch ‘’’’
inconnue ‘’’’
5. Cette fonction permet d’inverser une chaine donnée

0) Def Fn Inverse ( ch : chaine ) : chaine
1) Pour i de 1 à long ( ch ) div 2 Faire
Aux  Ch [ i ]
Ch [ i ]  Ch [ long ( ch ) – i + 1 ]
Ch [ long ( ch ) – I + 1 ]  Aux
214
Fin Pour
2) Inverse  Ch
3) Fin Inverse
Problème 2 ( 10 pts = 2+8)

Nom : Problème2
Résultat = Ecrire (‘’la lettre reçue est : ‘’, Fn Message ( FL , Fc ) )
Fc , FL = [ ] Proc Creation ( FL , Fc )
Proc RremplirLc( Fc )
Proc RemplirFc ( FL )
Fin Problème
T.D.O
T.D.N.T
Type
FL Texte Fihier textec
Mcode = Enregistrement
Fc Crypte Fichier de Mcode
Car : Caractère
Creation Procédure
Code : chaine
RemplirLc Procédure
Fin
Crypte = Fichier de Mcode
215
4. Analyse de la fonction Message

Def FN Message ( Var FL :texte ; Var Fc : Crypte ) : Chaine
Résultat = Message
Message = [ ] Message  ChR
ChR = [ ouvrir ( FL ) , ChR ’’‘’ ]
Tant que Non ( Fin_Fichier ( FL ) ) faire
Lire_nl ( FL , motc )
Ch ’’’’
Tant que ( long ( motc ) <> 0 ) faire
St  sous_chaine ( motc , 1 , 6 )
Ouvrir ( Fc )
Tant que Non ( Fin_Fichier ( Fc ) ) faire
Lire_nl ( Fc , Ec )
Si Ec . code = st Alors
Ch  Ch + Ec . car
Fin si
Fin Tant que
Efface ( motc , 1 , 6 )
Fin Tant que
ChR  ChR + ‘’ ‘’ + Ch
Fin Tant Que
Fin Message
T.D.O
Ec Mcode Enregistrement de code
Ch Chaine
216
Problème 1 (10pts = 2+1+2+3+2)
1. Analyse programme principal ( 2 pts)

Nom : problème2
Résultat = Ecrire (‘’Le Pgcd est : ‘’, Fn Recherche ( Fn ) )
Fn = [ ] Proc Création ( Fn ) T.D.O

Proc Remplir (Fn ) Objet Type/Nature Role
Fin problème2 Fn Nombre
Recherche Procedure
T.D.N.T
Type
Nombre = Fichier d’entier
2. Analyse procédure Création (1pts)
Def Proc Création (var Fn : Nombre)
Résultat = Fn
Fn = [ ] Associer ( Fn , ‘’C:\4SI\Nombre.dat’’)
Recréer ( Fn )
Fin Création
3. Analyse de la procédure remplir (2pts)

Def Proc Remplir ( Var Fn : Nombre )
Resultat = Fn
Fn = [ ] Pour i de 1 à N faire
K  Random ( 100 )
Ecrire ( Fn , k )
Fin Pour
N = [ ] Repeter
N = Donnée ( ‘‘Entrer le nombre des entier ‘’) T.D.O
Jusqu'à N dans [ 2 . . 50 ] Objet Type/Nature Role

Fin Remplir K Entier
I E i
217
4. Analyse de la Fonction recherche ( 3pts)

Def Fn Recherche ( Var Fn : Nombre ) : entier
Résultat = Recherche
Recherche = [ ] Recherche  M [ n , 1 ]
M = [ ouvrir ( Fn ) , i  1 , n 0 ]
Tant que Non ( Fin_Fichier ( Fn ) ) faire
Lire ( Fn , k )
NN+1
M[ i , N ]  K
Fin Tant que
PN
Répéter
Ii+1,j1
Tant que ( j < p ) faire
M [ i , j ]  Pgcd( M [ i – 1 , j ] , M[ I – 1 , j + j ] )
Jj+1 T.D.O
Fin Tant Que Objet Type/Nature Rôle
PP–1 N Entier
Jusqu’a ( I = N ) I Entier
Fin Recherche
5. Analyse de la function Pgcd ( 2pts)

Def Fn Pgcd ( a , b : entier ) : entier
Resultat = Pgcd
Pgcd = [ ] Pgcd  a T.D.O
a =[ ] Repeter Objet Type/Nature Role

r  a mod b A Entier
ab
B Entier
br
jusqu’a ( b = 0 )
Fin Pgcd
218
Problème (devoir de contrôle N°1 nov 2012)
Pendant le tour de France de bicyclette, chaque jour les organisateurs de la course saisirent
les résultats journaliers dans un fichier « Resultat.dat ». Le résultat est formé par
• Le numéro de la journée : 1er , 2ème, 3ème…

• Le numéro de cycliste : un nombre strictement positif et au maximum de trois chiffres.
• Le temps fait par le cycliste : formé par
- nombre d’heures : entier positif
- Nombre Minutes : entier positif
- Nombre de secondes : entier positif
Exemple : pendant le 5ème journée le cycliste Numéro 715 fait 4 h , 45 mn et 33 s
N.B : La saisie s’arrêt lorsqu’on saisie un numéro de la journée = 0.
Chaque jour il y a un prix pour le (les) gagnant qui a (ont) le temps minimal. Les donnes de (des)
gagnant(s) seront enregistrés dans un fichier texte « gagnant.txt ».
On désire d’écrire un programme qui permet de résoudre ce problème et d’afficher le contenu de

deux fichiers.
Travail demandé :
1- Ecrire l’analyse du programme principale ainsi que les différents modules envisagés.
2- Déduire les différents algorithmes.
219
Correction de devoir de controle

5/ Analyse de la procédure RemplirC
Def Proc RemplirC( Var Fc : Resultat )
Résultat = Fc
Fc = [ ] Avec Ec faire
Répéter
Répéter
Numj=donnée (‘’entrer le N° de journée : ‘’)
jusqu'à Numj dans [ 0 . . 40 ]
Si Numj <> 0 Alors
Répéter
NumC = Donnée (‘’Entrer le N° de cycliste : ‘’)
Jusqu'à Numc dans [ 1 . . 999 ]
Avec Et faire
Répéter
H= Donnée (‘’Entrer nbre d’heure : ‘’)
Jusqu'à H dans [ 0 . . 24 ]
Répéter
M = Donnée (‘’Entrer nbre de minute : ‘’)
Jusqu'à M dans [ 0 .. 59]
Répéter
S= Donnée (‘’Entrer nbre de seconde : ‘’)
Jusqu'à s dans [0 .. 59]
Fin Avec
Ecrire ( Fc , Ec )
FinSi
Jusqu'à Ec . Num = 0
Fin Avec
Fin RemplirC
T.D.O
Objet T/N Role

Ec Fiche
Et Temp
220
4/ analyse de la procedure remplirG

Def Proc RemplirG ( Var Fc : esultat ; Var Fg : Texte )
Résultat = Fg
2) Fg = [ Ouvrir (Fc), Ajouter ( Fg ) ]
Tant Que Non ( Fin_Fichier ( Fc) ) Faire
Lire ( Fc , Ec )
Avec Ec Faire
Si ( Et . H ) = Hmin ) et (Et . M = Mmin ) Et ( Et . S = Smin ) Alors
convch ( NumJ , Stj )
convch ( NumC , StC)
convch (Et . H , StH )
convch ( Et . M , StM)
convch (Et . S , StS)
ligne  Stj + StC + Sth + StM + StS
finSi
Fin Avec
Ecrire_nl ( Fg , ligne )
Fin Tant Que
1) Hmin , Mmin , Smin = [ Hmin  24 , Ouvrir (Fc)]
Tant que Non ( Fin_Fichier ( Fc) ) Faire
Lire ( Fc , Ec )
Avec Ec faire
avec Et faire
Si Hmin > H Alors
Hmin  H
Mmin  m
Smin s
sinon
Si Hmin = H Alors
si Mmin > M Alors
Mmin  M
smin s
Sinon
Si Smin >S Alors
Smin S
FinSi
FinSi
FinSi
FinSi
Fin Avec
Fin Avec
Fin Tant Que
3) Fin RemplirG
221
REPUBLIQUE TUNISIENNE Section : S.info Classe : 4ème SI 2

**** Epreuve : Algo & prog Prof : Khaled Chraiet
Circonscription Régionale Nabeul Durée : 1 heure
Lycée El Hawaria
2012-2013 Devoir de Contrôle N°1
31 octobre 2013
Chez une société de télécommunication les abonnés (clients) sont identifiés par plusieurs
informations, les plus importantes sont :
• Numéro de téléphone (entier de 8 chiffres).

• Nom et prénom de l’abonné (chaine)
• Solde : le montant de recharge
• Bonus : le montant de bonus sur recharge.
D’un temps à l’autre la société offre des bonus de 100% sur les recharges avec des montants
>5000 millimes. L’opération de recharge se fait par une machine, le client doit saisir seulement son
numéro et le montant de recharge.
• Saisir les informations des nouveaux abonnés et l’enregistrer dans un fichier

« Abonnés.dat » dans un dossier Télécom de l’unité C :
• Mettre à jour les soldes et les bonus des clients après chaque opération de recharge.
• Afficher la liste des abonnés qui ont des bonus non nul.
Questions :

principal.
correspondants.
222

Cours Algorithmique Et Programmation 4 Si (Full Permission)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cours Algorithmique Et Programmation 4 Si (Full Permission)

Uploaded by

Copyright:

Available Formats

REPUBLIQUE TUNISIENNE

MINISTERE DE L’EDUCATION ET DE LA FORMATION

Cours Algorithmique & Programmation

Prof : Mr. Chraiet Khaled

Rappel du cours de 2ème et 3ème

I- Les types de données:

II- Les actions élémentaires:

Action Algorithme Turbo Pascal

III- Les structures conditionnelles :

IV- Les structures répétitives :

Structure itérative Structure itérative à condition d'arrêt

………… ………… ……….. ;{init}

Forme générale d’un programme Pascal

Procedure Nom-proc (liste des paramètres formels)

Function nom-fonct (liste des paramètres formels) : type-résultat

 Les fonctions arithmétiques standard:

Nom en Code en Rôle Type du Type du Exemples

 Les fonctions prédéfinies sur les caractères sont :

Nom Code en Pascal Rôle Exemple

 Les fonctions et les procédures standards sur les chaînes de caractères

Nom En Pascal rôle Exemple

Les enregistrements et les fichiers

Les enregistrements et les fichiers

1000 cherni Sihem F 14.25

1001 Barhoumi Mourad M 12.75

1030 Dziri Fahmi M 16.50

Moy : pour la moyenne

- Un tableau pour les noms Cherni Barhoumi …. …. Dziri

- Un tableau pour les prénoms

On la représente comme suite :

Num Nom Prénom Sexe Moy

Une seule entité qui s’appelle enregistrement : E

On désigne par : E.Num : un champ qui représente le Numéro

Champ 1 Champ 2 Champ 3 Champ 4 Champ 5

Une seule entité d’une variable enregistrement

II- Définition et déclaration:

Déclaration d’une structure enregistrement :

Champ 3 : Type n Nom_var Nom_type Enregistrement pour …..

III- Tableau (Vecteur) d’enregistrement

Pour accéder aux informations de l’élève N° 2 on écrit :

T [ 2 ] . Moy : pour accéder au moyenne

IV- Utilisation des enregistrements:

Ou on peut écrire : Et en Pascal :

Au niveau de l’analyse Au niveau de l’algorithme Au niveau du pascal

La structure : Avec… Faire

An niveau de l’analyse et de l’algorithme An niveau du Pascal

Avec venrg Faire With venrg Do

Exemple : pour faire l’affichage de l’enregistrement EEL. On écrit

Ou on peut écrire : Et en Pascal on écrit :

Ecrire ( EEL. Num) AVEC EEL Faire With EEL DO

Au niveau de l’analyse et l’algforithme Au niveau du Pascal

EEL. Num  1000 Avec EEL faire

2. on peut aussi affecter un enregistrement E2 a un enregistrement E1. Si les deux de même

• Fichiers de données ou typés : se sont des fichiers contenant du code binaire

III- Organisation et accès :

Bloc 1 Bloc 2 Bloc 3 Bloc 4 Fin

Organisation séquentielle Organisation relative

IV- Les fichiers typés:

1. Déclaration d’un fichier :

Le type_composants représente le type des composants du fichier, ces composants

Feleve = fichier de fiche

Fel Feleve Fichier pour les fiches élèves

V- Les fichiers a accès séquentiel :