Cours Algo Ii - Unikan

1
COURS D’ALGORITHME II
Objectif du cours :
Apprendre aux étudiants les stratégies nécessaire pour résoudre un problème

par voie informatique, en choisissant adéquatement la façon de représenter les
données inhérentes au problème et en construisant un algorithme.
Plan du cours
CHAPITRE I : REVISION ALGO I
I.1. NOTIONS D’ALGORITHME ET DE PROGRAMMATION.
I.2. LES VARIABLES
I.3. LES TESTS
I.4. LES BOUCLES
CHAPITRE II : LES TABLEAUX
CHAPITRE III : LES FONCTIONS PREDEFINIES
CHAPITRE IV : LES FICHIERS
Documentation
1. Christophe Darmangeat ; L’Algorithmique et la programmation, Paris,

2008.
2. Jacques Lonchamp ; Génie logiciel, CNAM – Nancy, 2003.
3. P. André et A. Vailly, Conception des systèmes d'information - Panorama
des méthodes et des techniques, Editions Ellipses, Paris, 2005
4. http://www.pise.info/algo/index.htm ; Patrick Trau ; Données et
Algorithmique.
Assistant Freddy ETSHIKO. Notions d’Algorithmique II.

2
INTRODUCTION
La conception des programmes met en œuvre un ensemble

d'activités qui à partir d'une demande d'informatisation d'un processus
(demande qui peut aller de la simple question orale jusqu'au cahier des charges
complet) permettent la conception, l'écriture et la mise au point des
programmes informatiques jusqu'à sa livraison au demandeur.
Lorsque, par souci de faire vite, le programmeur brule les étapes de la

conception, il y aura de répercutions vers la fin de son projet. L’apparente
rapidité d’un programme est composée par le temps passé à sa mise au point et
la correction des erreurs de logique. Un programme doit, d’autre part, être un
outil adaptable.
Il faut pouvoir modifier et améliorer afin de tenir compte de vos

besoins qui n’étaient pas prévus par l’auteur de la première version du
programme. C’est ce qui est appelé maintenance du programme. S’il est mal
structuré au départ, le programme est difficile à modifier.
Aujourd’hui, la nécessité d’une bonne méthode. Rigoureuse de

conception et d’écriture des programmes sont reconnue. Le BON programmeur
est, celui qui écrit des programmes lisibles dont la structure est claire et qui sont
modifiables en un minimum de temps part n’importe quel autre informaticien.
L’ordinateur est une machine, disons un ensemble des composants

électroniques qui aide l’homme dans l’exécution de ses travaux répétitifs et de
grand volume en lui apportant la fiabilité, la rapidité, la précision, etc.
Cependant, l’ordinateur étant une machine, ne dispose pas de la faculté

de raisonner. L’homme doit donc raisonner seul et communiquer à l’ordinateur
le raisonnement logique qu’il doit suivre pour exécuter le travail qui lui est
confié.

3
Pour cela, il faut bien cerner le problème posé, prévoir toutes les
éventualités qui peuvent se présenter. Toutes les questions prévues doivent
avoir des réponses. L’ordinateur ne peut rien improviser.
Nous avons donc un Objectif : obtenir de la «machine» qu’elle effectue

un travail à notre place. Mais il se pose un Problème : expliquer à la «machine»
comment elle doit s'y prendre.
Mais... comment le lui dire ? Comment le lui apprendre ?
Comment s'assurer qu'elle fait ce travail aussi bien que nous ? Mieux
que nous?
Lorsque nous programmons, nous nous mettons à la place de la

machine, pour :
 résoudre des problèmes «comme» une machine
 savoir expliciter son raisonnement (comment faire un travail sans la

moindre ambiguïté)
 savoir formaliser son raisonnement
 concevoir (et écrire) des algorithmes (un algorithme ne dépend pas ni du

langage dans lequel il est implanté, ni de la machine qui exécutera le
programme correspondant.)
 Savoir codifier notre algorithme dans un langage de programmation.

4
CHAPITRE I : RAPPEL DE L’ALGORITHMIQUE I.

I.1. NOTIONS D’ALGORITHME ET DE PROGRAMMATION
I.1. 1. QU’EST-CE QUE L’ALGORITHME ?
Avez-vous déjà indiqué un chemin à un touriste égaré ? Si oui, vous avez déjà
fabriqué et fait exécuter des algorithmes.
Comme quoi, l’algorithmique n’est pas un savoir ésotérique (mystérieux ou

obscur) réservé à quelques rares initiés touchés par la grâ ce divine, mais une
aptitude partagée par la totalité de l’humanité.
Un algorithme est une suite ordonnée d’opération permettant d’obtenir un

résultat déterminé en un temps fini. La raison d’être d’un algorithme est de
résoudre un problème. La plus grande attention doit être portée à la
compréhension du problème à résoudre qui constitue l’étape la plus critique
dans la conception d’un algorithme. L’algorithmique est la science qui étudie
les algorithmes.
Bref : Un algorithme, c’est une suite d’instructions, qui une fois exécutée
correctement, conduit à un résultat donné.
Pour fonctionner, un algorithme doit donc contenir uniquement des

instructions compréhensibles par celui qui devra l’exécuter.
Pour bien s’adapter à écrire des algorithmes :
 il faut avoir une certaine intuition. Sachez que les réflexes s’acquièrent. Et
ce qu’on appelle l’intuition n’est finalement que de l’expérience tellement
répétée que le raisonnement, au départ laborieux, finit par devenir
« spontané ».
 il faut être méthodique et rigoureux. En effet, chaque fois qu’on écrit une
série d’instructions qu’on croit justes, il faut systématiquement se mettre
mentalement à la place de la machine qui va les exécuter, armé d'un papier

5
et d'un crayon, afin de vérifier si le résultat obtenu est bien celui que l’on
voulait.
Et petit à petit, à force de pratique, vous verrez que vous pourrez faire de plus
en plus souvent l’économie de cette dernière étape : l’expérience fera que vous
« verrez » le résultat produit par vos instructions, au fur et à mesure que vous
les écrirez. Naturellement, cet apprentissage est long, et demande des heures de
travail patient. Aussi, dans un premier temps, évitez de sauter les étapes : la
vérification méthodique, pas à pas, de chacun de vos algorithmes
représente plus de la moitié du travail à accomplir... et le gage de vos
progrès.
I.1.2. ALGORITHMIQUE ET PROGRAMMATION
Pourquoi apprendre l’algorithmique pour apprendre à programmer ? En quoi

a-t-on besoin d’un langage spécial, distinct des langages de programmation
compréhensibles par les ordinateurs ?
Parce que l’algorithmique exprime les instructions résolvant un problème

donné indépendamment des particularités de tel ou tel langage.
Apprendre l’algorithmique, c’est apprendre à manier la structure logique

d’un programme informatique. Cette dimension est présente quelle que soit le
langage de programmation ; mais lorsqu’on programme dans un langage (en
Qbasic, python, C, Visual Basic, etc.) on doit en plus se colleter les problèmes de
syntaxe, ou de types d’instructions, propres à ce langage. Apprendre
l’algorithmique de manière séparée, c’est donc sérier les difficultés pour mieux
les vaincre.
I.1.3. CONVENTION D’ECRITURE D’UN ALGORITHME
Historiquement, plusieurs types de notations ont représenté des algorithmes.
Il y a eu notamment une représentation graphique, avec des carrés, des

losanges, etc. qu’on appelait des organigrammes. Aujourd’hui, cette

6
représentation est quasiment abandonnée, pour deux raisons. D’abord, parce

que dès que l’algorithme commence à grossir un peu, ce n’est plus pratique du
tout. Ensuite parce que cette représentation favorise le glissement vers un
certain type de programmation, dite non structurée, que l’on tente au contraire
d’éviter.
C’est pourquoi on utilise généralement une série de conventions appelée «

pseudo-code », qui ressemble à un langage de programmation authentique dont
on aurait évacué la plupart des problèmes de syntaxe. Ce pseudo-code est
susceptible de varier légèrement d’un livre (ou d’un enseignant) à un autre. C’est
bien normal : le pseudo-code, encore une fois, est purement conventionnel ;
aucune machine n’est censée le reconnaître.
I.1.4. CARACTERISTIQUE D’UN BON ALGORITHME
Un bon algorithme doit être :
- Lisible : compréhensible par d’autres personnes ;

- Précis : sans ambiguïtés, sans confusion entre les éléments ;
- De haut niveau : traduit par n’importe quel langage de programmation ;
- Concis : un algorithme ne doit pas dépasser une page. Si c'est le cas, il faut
décomposer le problème en plusieurs sous-problèmes.
- Structuré : un algorithme doit être composé de différentes parties
facilement identifiables.
- Finis dans le temps : les opérations doivent avoir un début et une fin.
- Résous le problème : un algorithme doit apporter une solution au
problème posé.
I.1.5. LES ETAPES DE RESOLUTION D’UN PROBLEME
De manière générale, une analyse d’un problème dans le but de le résoudre peut
se ramener à une suite d’interrogation qui s’enchaine :
 Quel est le résultat à obtenir ? (Que veut – on ?)

7
 Quelles opérations permettent d’élaborer ce résultat ? (comment s’obtient

ce résultat ?)
 Quelles sont les données nécessaires à la réalisation de ces opérations ?
(De quoi a-t-on besoin ?)
Quel que soit le type de problème qu’on aura en face de soi, l’analyse consistera
à:
 Définir précisément le problème pour identifier le(s) résultat(s)

(Sortie) à obtenir.
 Identifier les traitements permettant d’obtenir le résultat dans le cadre
du problème énoncé.
 Identifier les informations (Entrées) nécessaires à la réalisation des
traitements envisagés.
 Dérouler l’algorithme étape par étape à travers un jeux de tests pour
vérifier s’il produit le résultat demandé.
Ainsi l’algorithme peut se présenter par le schéma classique suivant
Entrées(Données) -----> Traitement(opérations) ----> Sorties(Résultats)
EXERCICE D’APPLICATION
Enoncé : Votre grand père détient un terrain sous forme rectangulaire au village.
Il aimerait connaitre la superficie occupée par son terrain.
Travail à faire : Concevoir un algorithme permettant à votre grand père de

résoudre son problème.
1) Analyse :
- Quel est le résultat recherché ? (Sortie)
On veut obtenir la valeur de la superficie (la surface) occupée par le terrain.
- Comment s’obtient ce résultat ?(Traitement)

8
Le terrain de forme rectangulaire. Un rectangle est une figure géométrique ayant

4 cotés et constitué d’une longueur (L) et d’une largeur (l). Pour obtenir la
surface, il est nécessaire de connaitre la formule c'est-à -dire Surface =
Longueur * largeur et de faire le calcul du produit par la machine.
- Quelles sont les informations nécessaires ? (Entrées)
Dans la formule ci-dessus, on aura besoin de connaitre la longueur du terrain et

sa largeur.
2) Structure de la solution : la solution de l’énoncé implique la structuration

suivante :
- Donner la Longueur (L)
- Donner la largeur (l)
- Calculer la surface (S) en effectuant : S= L*l
- Afficher la surface (S).
I.2. : LES VARIABLES
Dans un programme informatique, on va avoir en permanence besoin de

stocker provisoirement des valeurs. Il peut s’agir de données issues du disque
dur, fournies par l’utilisateur (frappées au clavier), ou que sais-je encore. Il peut
aussi s’agir de résultats obtenus par le programme, intermédiaires ou définitifs.
Ces données peuvent être de plusieurs types : elles peuvent être des nombres,
du texte, etc. Toujours est-il que dès que l’on a besoin de stocker une
information au cours d’un programme, on utilise une variable.
I.2.1. Définition : une variable est un emplacement mémoire repéré par une
étiquette (nom) et dont on définit le type de données à stocker dedans.
I.2.2. DECLARATION DES VARIABLES
La première chose à faire avant de pouvoir utiliser une variable est de créer
la boîte (lui réserver un emplacement mémoire) et de lui coller une

9
étiquette. Ceci se fait tout au début de l’algorithme, avant même les instructions
proprement dites. C’est ce qu’on appelle la déclaration des variables.
Lorsqu’on déclare une variable, il ne suffit pas de créer une boîte (réserver un
emplacement mémoire) ; encore doit-on préciser ce que l’on voudra mettre
dedans, car de cela dépendent la taille de la boîte (de l’emplacement mémoire)
et le type de codage utilisé.
Notation
VARIAVLE Nom_variable en type_variable
Ou VAR Nom_variable : type_variable
En QBasic : Dim nom_variable As Type_Variable
I.2.3. TYPES DE VALEURS
A) Types numériques classiques
Si l’on réserve un octet pour coder un nombre, on ne pourra coder que 2 8 =

256 valeurs différentes. Cela peut signifier par exemple les nombres entiers de 1
à 256, ou de 0 à 255, ou de –127 à +128… Si l’on réserve deux octets, on a droit à
65 536 valeurs ; avec trois octets, 16 777 216, etc. Et là se pose un autre
problème : ce codage doit-il représenter des nombres décimaux ? Des nombres
négatifs ?
Donc le type de variable choisi pour un nombre va déterminer :
 les valeurs maximales et minimales des nombres pouvant être stockés

dans la variable
 la précision de ces nombres (dans le cas de nombres décimaux).
Tous les langages, quels qu’ils soient offrent un « bouquet » de types

numériques, dont le détail est susceptible de varier légèrement d’un langage à
l’autre. Grosso modo, on retrouve cependant les types suivants :

10
Type Numérique Plage

Byte (octet) 0 à 255
Entier simple -32 768 à 32 767
Entier long -2 147 483 648 à 2 147 483 647
-3,40x1038 à -1,40x1045 pour les valeurs négatives
Réel simple
1,40x10-45 à 3,40x1038 pour les valeurs positives
1,79x10308 à -4,94x10-324 pour les valeurs négatives
Réel double
4,94x10-324 à 1,79x10308 pour les valeurs positives
B) Autres types numériques
Certains langages autorisent d’autres types numériques, notamment :
 le type monétaire (avec strictement deux chiffres après la virgule)
 le type date de la forme : jour/mois/année
Nous n’emploierons pas ces types dans ce cours ; mais je les signale, car vous
ne manquerez pas de les rencontrer en programmation proprement dite.
C) Type alphanumérique
On dispose donc également du type alphanumérique (également appelé

type caractère, type chaîne ou en anglais, le type string.
Un groupe de caractères (y compris un groupe de un, ou de zéro caractères),

qu’il soit ou non stocké dans une variable, d’ailleurs, est donc souvent appelé
chaîne de caractères.
En pseudo-code, une chaîne de caractères est toujours notée entre

guillemets
D) Type booléen
Le dernier type de variables est le type booléen : on y stocke uniquement les

valeurs logiques VRAI et FAUX.

11
I.2.4. L’INSTRUCTION D’AFFECTATION
a) Syntaxe et signification
Cette seule chose qu’on puisse faire avec une variable, c’est l’affecter, c’est-à -
dire lui attribuer une valeur.
En pseudo-code, l'instruction d'affectation se note avec le signe ←
Ainsi :
A ← 24
Attribue la valeur 24 à la variable A.
b) Ordre des instructions
Il va de soi que l’ordre dans lequel les instructions sont écrites va jouer un
rô le essentiel dans le résultat final. Considérons les deux algorithmes suivants :
Exemple 1 Exemple 2
Variable A en Numérique Variable A en Numérique
Début Début
A ← 34 A ← 12
A ← 12 A ← 34
Fin Fin
I.2.5. EXPRESSIONS ET OPERATEURS
A. Définition d’une expression :
Une expression est un ensemble de valeurs, reliées par des opérateurs, et

équivalent à une seule valeur
Si on fait le point, on s’aperçoit que dans une instruction d’affectation, on

trouve :
 à gauche de la flèche, un nom de variable, et uniquement cela.

12
 à droite de la flèche, ce qu’on appelle une expression.
 l’expression située à droite de la flèche soit du même type que la variable

située à gauche. C’est très logique : on ne peut pas ranger convenablement
des outils dans un sac à provision, ni des légumes dans une trousse à
outils… sauf à provoquer un résultat catastrophique.
B. Définition d’un opérateur
Un opérateur est un signe qui relie deux valeurs, pour produire un

résultat.
Les opérateurs possibles dépendent du type des valeurs qui sont en jeu.
1) Opérateurs numériques :
Ce sont les quatre opérations arithmétiques tout ce qu’il y a de classique.
+ : addition * : multiplication
- : soustraction / : division
Mentionnons également le ^ qui signifie « puissance ». 45 au carré s’écrira

donc 45 ^ 2.
Enfin, on a le droit d’utiliser les parenthèses, avec les mêmes règles qu’en
mathématiques. La multiplication et la division ont « naturellement » priorité
sur l’addition et la soustraction. Les parenthèses ne sont ainsi utiles que pour
modifier cette priorité naturelle.
Cela signifie qu’en informatique, 12 * 3 + 5 et (12 * 3) + 5 valent strictement la

même chose, à savoir 41. Pourquoi dès lors se fatiguer à mettre des parenthèses
inutiles ?
En revanche, 12 * (3 + 5) vaut 12 * 8 soit 96. Rien de difficile là -dedans, que du

normal.

13
2) Opérateur alphanumérique : &
Cet opérateur permet de concaténer, autrement dit d’agglomérer, deux

chaînes de caractères. Par exemple :
Var A, B, C : Caractère
Début
A ← "Informatique "
B ← "Gestion"
C←A&B
Fin
La valeur de C à la fin de l’algorithme est "InformatiqueGestion"
3) Opérateurs logiques (ou booléens) :
Il s’agit du ET, du OU, du NON et du mystérieux (mais rarissime XOR(OU

exclusif)).
REMARQUES
En mathématiques, une « variable » est généralement une inconnue, qui

recouvre un nombre non précisé de valeurs. Lorsqu’on écrit : y = 3 x + 2, les
« variables » x et y satisfaisant à l’équation existent en nombre infini
(graphiquement, l’ensemble des solutions à cette équation dessine une droite).
En informatique, une variable possède à un moment donné une valeur et

une seule. A la rigueur, elle peut ne pas avoir de valeur du tout (une fois qu’elle
a été déclarée, et tant qu’on ne l’a pas affectée.
La deuxième remarque concerne le signe de l’affectation. En algorithmique,

comme on l’a vu, c’est le signe ←. Mais en pratique, la quasi totalité des langages
emploient le signe égal. Et là , pour les débutants, la confusion avec les maths est
également facile.

14
II.6. LECTURE ET ECRITURE
Il existe des d’instructions pour permettre à la machine de dialoguer avec

l’utilisateur
Les instructions permettent à l’utilisateur de rentrer des valeurs au clavier

pour qu’elles soient utilisées par le programme. Cette opération est la lecture.
D’autres instructions permettent au programme de communiquer des valeurs

à l’utilisateur en les affichant à l’écran. Cette opération est l’écriture.
Dès que le programme rencontre une instruction Lire, l’exécution

s’interrompt, attendant la frappe d’une valeur au clavier
Dès lors, aussitô t que la touche Entrée (Enter) a été frappée, l’exécution
reprend. Dans le sens inverse, pour écrire quelque chose à l’écran, c’est aussi
simple.
Avant de Lire une variable, il est très fortement conseillé d’écrire des libellés
à l’écran, afin de prévenir l’utilisateur de ce qu’il doit frapper (sinon, le pauvre
utilisateur passe son temps à se demander ce que l’ordinateur attend de lui… et
c’est très désagréable !) :
Ecrire "Entrez votre nom de la famile : "

Lire NomFamille
Ecrire "Entrez votre annee de naissance "

Lire age
Ecrire "Votre Nom est : "NomFamille "vous êtes né en" age
Lecture et Ecriture sont des instructions algorithmiques qui ne présentent pas

de difficultés particulières, une fois qu’on a bien assimilé ce problème du sens du
dialogue (homme → machine, ou machine ← homme).
EXERCICES

15
I.3. LES TESTS
Le test nous présente en fonction d’une situation pouvant se présenter

de deux façons différentes, deux façons différentes d’agir. Cela suppose que
l’interlocuteur sache analyser la condition que nous avons fixée à son
comportement pour effectuer la série d’actions correspondante.
Cette structure logique répond au doux nom de test ou structure alternative.
I.3.1. STRUCTURE D’UN TEST
Il n’y a que deux formes possibles pour un test ; la première est la plus
simple, la seconde la plus complexe.
Si booléen Alors
Instructions
Finsi
Si booléen Alors
Instructions 1
Sinon
Instructions 2
Finsi
Un booléen est une expression dont la valeur est VRAI ou FAUX. Cela peut
donc être (il n’y a que deux possibilités) :
 une variable (ou une expression) de type booléen
 une condition
Toujours est-il que la structure d’un test est relativement claire. Dans la forme
la plus simple, arrivé à la première ligne (Si… Alors) la machine examine la
valeur du booléen. Si ce booléen a pour valeur VRAI, elle exécute la série
d’instructions. Cette série d’instructions peut être très brève comme très longue,
cela n’a aucune importance. En revanche, dans le cas où le booléen est faux,
l'ordinateur saute directement aux instructions situées après le FinSi.
Dans le cas de la structure complète, c'est à peine plus compliqué. Dans le cas
où le booléen est VRAI, et après avoir exécuté la série d'instructions 1, au
16
moment où elle arrive au mot « Sinon », la machine saute directement à la

première instruction située après le « Finsi ». De même, au cas où le booléen a
comme valeur « Faux », la machine saute directement à la première ligne située
après le « Sinon » et exécute l’ensemble des « instructions 2 ». Dans tous les cas,
les instructions situées juste après le FinSi seront exécutées normalement.
I.3.2. DEFINITION D’UNE CONDITION
Une condition est une comparaison
Cette définition est essentielle ! Elle signifie qu’une condition est composée de
trois éléments :
 une valeur
 un opérateur de comparaison
 une autre valeur
Les valeurs peuvent être a priori de n’importe quel type (numériques,

caractères…). Mais si l’on veut que la comparaison ait un sens, il faut que les
deux valeurs de la comparaison soient du même type !
Les opérateurs de comparaison sont :
 (=) égal à …  (>) strictement plus grand que…
 (< >) différent de…  (<=) plus petit ou égal à …
 (<) strictement plus petit que…  (>=) plus grand ou égal à …
L’ensemble des trois éléments constituant la condition constitue donc, si l’on

veut, une affirmation, qui à un moment donné est VRAIE ou FAUSSE.
Remarque
En formulant une condition dans un algorithme, il faut se méfier de certains

raccourcis du langage courant, ou de certaines notations valides en
mathématiques, mais qui mènent à des non-sens informatiques. Prenons par
exemple la phrase « y est compris entre 5 et 8 ». On peut être tenté de la traduire

17
par : 5 < y < 8. Or, une telle expression, qui a du sens en français, comme en
mathématiques, ne veut rien dire en programmation. En effet, elle comprend
deux opérateurs de comparaison, soit un de trop, et trois valeurs, soit là aussi
une de trop. Pour résoudre ce problème on utilise les autres opérations logiques
qui permettent de mettre ensemble deux conditions (ET, OU, NON, et XOR.).
 Le ET a le même sens en informatique que dans le langage courant. Pour

que "Condition1 ET Condition2" soit VRAI, il faut impérativement que
Condition1 soit VRAI et que Condition2 soit VRAI. Dans tous les autres cas,
"Condition 1 et Condition2" sera faux.
 Il faut se méfier un peu plus du OU. Pour que "Condition1 OU Condition2"

soit VRAI, il suffit que Condition1 soit VRAIE ou que Condition2 soit VRAIE.
Le point important est que si Condition1 est VRAIE et que Condition2 est
VRAIE aussi, Condition1 OU Condition2 reste VRAIE. Le OU informatique ne
veut donc pas dire « ou bien »
 Le XOR (ou OU exclusif) fonctionne de la manière suivante. Pour que

"Condition1 XOR Condition2" soit VRAI, il faut que soit Condition1 soit
VRAI, soit que Condition2 soit VRAI. Si toutes les deux sont fausses, ou que
toutes les deux sont VRAI, alors le résultat global est considéré comme
FAUX. Le XOR est donc l'équivalent du "ou bien" du langage courant.
J’insiste toutefois sur le fait que le XOR est une rareté, dont il n’est pas
strictement indispensable de s’encombrer en programmation.
 Enfin, le NON inverse une condition : NON(Condition1) est VRAI si

Condition1 est FAUX, et il sera FAUX si Condition1 est VRAI. C'est
l'équivalent pour les booléens du signe "moins" que l'on place devant les
nombres. Alors, vous vous demandez peut-être à quoi sert ce NON. Après
tout, plutô t qu’écrire NON(Prix > 20), il serait plus simple d’écrire tout
bonnement Prix=<20. Dans ce cas précis, c’est évident qu’on se complique

18
inutilement la vie avec le NON. Mais si le NON n'est jamais indispensable, il

y a tout de même des situations dans lesquelles il s'avère bien utile.
a) Test si
Le test si est la forme d'alternative la plus simple : si Test est vérifié on exécute
Instruction 1 puis Instruction 2 ; si Test n'est pas vérifié on exécute directement
'Instruction 2
Pseudo code :
SI Test
Instruction 1
FIN SI
Instruction 2
Exemples de mise en œuvre :
 BASIC : IF condition THEN instruction
 Python : if condition : instruction
 Forth : condition IF instruction THEN
 PHP : IF(condition) { instruction(s) } (Note : les accolades ne sont pas

indispensables s'il n'y a qu'une instruction.)
Le mot clef if correspond à si en anglais ; le mot clef then correspond à alors.
b) Test si sinon
SI Test
Instruction 1
SINON
Instruction 2

19
FIN SI Instruction 3
Si Test est vérifié on exécute Instruction 1 puis Instruction 3 ; sinon on exécute

Instruction 2 puis Instruction 3.
 Pascal : if(condition) then instruction else 'instruction ;
 C/C++ : if(condition) instruction ; else 'instruction ;
Le mot clef else correspond à sinon en anglais.
c) Test sinon si
SI Test 1
Instruction 1
SINONSI Test 2
Instruction 2
FIN SI
Instruction 3
Si Test 1 est vérifié on exécute Instruction 1 puis Instruction 3 ; sinon si

Test 2 est vérifié on exécute Instruction 2 puis Instruction 3 ; sinon on exécute
directement Instruction 3.
On peut enchaîner autant d'instructions sinon si que désiré : seule la

première dont la condition sera vérifiée sera exécutée. On peut généralement
associer une clause sinon qui ne sera exécutée que si aucune clause sinon si n'a
été vérifiée.
Dans les langages où la définition des blocs d'instruction est

indépendante des structures de contrô le, cette instruction est redondante
puisqu'elle revient à enchaîner un si après un sinon. Par exemple en langage C on
écrira :
if( test1() ){
Instruction1();

20
} else if ( test2() ){
Instruction2();
Instruction3();
Certains de ces langages définissent tout de même une instruction

sinon si (par exemple elseif en PHP), pour des raisons de performance par
exemple.
d) Test selon (structure de choix)
Le test selon est une spécialisation de l'instruction sinon si, qui permet
de sélectionner le bloc à exécuter en fonction de la valeur d'une variable. Il est
utilisé lorsque l'on doit tester une condition plusieurs fois, en utilisant toujours
la même variable.
SELON Variable 1
CAS Valeur 1:
Instruction 1
CAS Valeur 2:
Instruction 2
FIN SELON
Instruction 3
Structurellement, c'est équivalent à une succession de sinon si, mais le
fait de savoir que la valeur de la variable testée ne changera pas lors de
l'évaluation des conditions permet au compilateur de faire quelques
optimisations.
Suivant les langages, l'expression qui suit le mot clef cas peut être une
simple valeur pour un test d'égalité, une collection, un intervalle, ou une
expression rationnelle par exemple.
Le switch case du langage C s'écarte sensiblement du modèle ci-dessus.

Son comportement fall though (passage à travers) des case non terminé par le
mot clef break, le rapproche plus d'une structure à étiquette.

21
I.4. BOUCLES
Une boucle est une structure de contrô le destinée à exécuter une

portion de code plusieurs fois de suite, la structure de contrô le branchant le
pointeur ordinal au début du code tant qu'une condition de continuation est
remplie ou, selon les boucles, qu'une condition de sortie n'est pas remplie.
Normalement, une boucle s'exécute selon le cas, soit un nombre de fois

connu à l'avance, soit jusqu'à ce qu'une condition permette de sortir de la
boucle. Il arrive toutefois qu'une erreur de programmation fasse qu'un
programme s'exécute indéfiniment à l'intérieur d'une boucle. On dit que le
programme est en train de boucler.
I.4.1. BOUCLE TANT QUE
TANTQUE Test
Instruction 1
FIN TANTQUE
Instruction 2
Si Test est vérifié on exécute Instruction 1, puis arrivé à la fin du bloc on

évalue à nouveau Test et on recommence. Quand Test renvoie un résultat faux on
quitte la boucle en sautant à instruction 2. Le Test est en général appelé
'condition de continuation' puisque le flot d'exécution continue avec Instruction
1 lorsque le Test est vrai.
 C : while(condition) instruction ;
Le mot clef while en anglais correspond à tant que en français.

22
I.4.2. BOUCLE JUSQU'A CE QUE

REPETE
Instruction 1
JUSQUACEQUE Condition 1
Instruction 2
Cette boucle permet de réitérer une instruction ou un ensemble

d'instructions jusqu'à ce qu'une condition de sortie soit vérifiée (par exemple en
Pascal on boucle jusqu'à ce que la condition devienne vraie, alors qu'en C on
boucle tant que celle-ci est vraie). La série d'instructions est exécutée au moins
une fois, quelle que soit la condition.
 C : do instruction while(condition) ;
 Pascal : repeat instruction until condition ;
Le mot clef until correspond au français jusqu'à ce que, repeat à répète.
I.4.3. BOUCLE POUR
Pour compteur ← vd à vf
Instructions
Compteur suivant (compteur ← compteur + 1)
Insistons : la structure « Pour … Suivant » n’est pas du tout

indispensable ; on pourrait fort bien programmer toutes les situations de
boucle uniquement avec un « Tant Que ». Le seul intérêt du « Pour » est
d’épargner un peu de fatigue au programmeur, en lui évitant de gérer lui-même
la progression de la variable qui lui sert de compteur on parle
d’incrémentation.

23
Dit d’une autre manière, la structure « Pour … Suivant » est un cas particulier
de TantQue : celui où le programmeur peut dénombrer à l’avance le nombre de
tours de boucles nécessaires.
Il faut noter que dans une structure « Pour … Suivant », la progression du

compteur est laissée à votre libre disposition. Dans la plupart des cas, on a
besoin d’une variable qui augmente de 1 à chaque tour de boucle. On ne précise
alors rien à l’instruction « Pour » ; celle-ci, par défaut, comprend qu’il va falloir
procéder à cette incrémentation de 1 à chaque passage, en commençant par la
première valeur et en terminant par la deuxième.

24
CHAPITRE II. LES TABLEAUX

II.1. UTILITE DES TABLEAUX
Imaginons que dans un programme, nous ayons besoin simultanément

de 12 valeurs (par exemple, des notes pour calculer une moyenne). Evidemment,
la seule solution dont nous disposons à l’heure actuelle consiste à déclarer douze
variables, appelées par exemple Notea, Noteb, Notec, etc. Bien sû r, on peut opter
pour une notation un peu simplifiée, par exemple N1, N2, N3, etc. Mais cela ne
change pas fondamentalement notre problème, car arrivé au calcul, et après une
succession de douze instructions « Lire » distinctes, cela donnera
obligatoirement une atrocité du genre :
Moy ← (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10+N11+N12)/12
Avec 12 éléments, c’est encore facile à représenter ces valeurs, mais si

nous sommes dans un programme de gestion avec quelques centaines ou
quelques milliers de valeurs à traiter, alors là les choses se compliquent
d’avantage.
C’est pourquoi la programmation nous permet de rassembler toutes

ces variables en une seule, au sein de laquelle chaque valeur sera désignée par
un numéro. En bon français, cela donnerait donc quelque chose du genre « la
note numéro 1 », « la note numéro 2 », « la note numéro 8 ». C’est largement plus
pratique, vous vous en doutez.
II.2. DEFINITION DU TABLEAU
Un tableau est un ensemble de valeurs portant le même nom de

variable et repérées par un nombre. Chaque fois que l’on doit désigner un
élément du tableau, on fait figurer le nom du tableau, suivi de l’indice de
l’élément, entre parenthèses. T(i)
T : nom du tableau
Assistant Freddy ETSHIKO. Notes de cours : Algorithme II.

25
i : indice : le nombre au sein d’un tableau qui sert à repérer chaque valeur.
II.3. NOTATION ET UTILISATION ALGORITHMIQUE
Dans notre exemple, nous créerons donc un tableau appelé Note.

Chaque note individuelle (chaque élément du tableau Note) sera donc désignée
Note(0), Note(1), etc. Attention, les indices des tableaux commencent
généralement à 0, et non à 1.
Un tableau doit être déclaré comme tel, en précisant le nombre et le

type de valeurs qu’il contiendra (la déclaration des tableaux est susceptible de
varier d'un langage à l'autre. Certains langages réclament le nombre d'éléments,
d'autre le plus grand indice... C'est donc une affaire de conventions).
En nous calquant sur les choix les plus fréquents dans les langages de
programmations, nous déciderons ici arbitrairement et une bonne fois pour
toutes que :
 les "cases" sont numérotées à partir de zéro, autrement dit que le plus
petit indice est zéro.
 lors de la déclaration d'un tableau, on précise la plus grande valeur de

l'indice (différente, donc, du nombre de cases du tableau, puisque si on veut
12 emplacements, le plus grand indice sera 11).
Tableau Note(11) en Entier
On peut créer des tableaux contenant des variables de tous types :

tableaux de numériques, bien sû r, mais aussi tableaux de caractères, tableaux de
booléens, tableaux de tout ce qui existe dans un langage donné comme type de
variables. Par contre, hormis dans quelques rares langages, on ne peut pas faire
un mixage de types différents de valeurs au sein d’un même tableau.
L’énorme avantage des tableaux, c’est qu’on va pouvoir les traiter en

faisant des boucles. Par exemple, pour effectuer notre calcul de moyenne, cela
donnera par exemple :
26
Tableau Note(11) en Numérique

Variables Moy, Som en Numérique
Début
Pour i ← 0 à 11
Ecrire "Entrez la note n°", i
Lire Note(i)
i Suivant
Som ← 0
Pour i ← 0 à 11
Som ← Som + Note(i)
i Suivant
Moy ← Som / 12
Fin
NB : On a fait deux boucles successives pour plus de lisibilité, mais on
aurait tout aussi bien pu n’en écrire qu’une seule dans laquelle on aurait tout fait
d’un seul coup.
Remarque générale : l’indice qui sert à désigner les éléments d’un

tableau peut être exprimé directement comme un nombre en clair, mais il peut
être aussi une variable, ou une expression calculée.
Dans un tableau, la valeur d’un indice doit toujours :
 être égale au moins à 0 (dans quelques rares langages, le premier

élément d’un tableau porte l’indice 1). Mais comme je l'ai déjà écrit plus
haut, nous avons choisi ici de commencer la numérotation des indices à
zéro, comme c’est le cas en langage C et en Visual Basic. Donc attention,
Truc(6) est le septième élément du tableau Truc !
 être un nombre entier Quel que soit le langage, l’élément Truc(3,1416)

n’existe jamais.
 être inférieure ou égale au nombre d’éléments du tableau (moins 1,

si l’on commence la numérotation à zéro). Si le tableau Bidule a été
déclaré comme ayant 25 éléments, la présence dans une ligne, sous une
forme ou sous une autre, de Bidule(32) déclenchera automatiquement
une erreur.
27
N.B. : Si l’on est dans un langage où les indices commencent à zéro, il faut en
tenir compte à la déclaration :
Tableau Note(13) en Numérique
...créera un tableau de 14 éléments, le plus petit indice étant 0 et le plus grand

13.
II.4. TABLEAUX DYNAMIQUES
Il arrive fréquemment que l’on ne connaisse pas à l’avance le nombre

d’éléments que devra comporter un tableau. Bien sû r, une solution consisterait à
déclarer un tableau gigantesque (10 000 éléments ou plus) pour être sû r que
« ça rentre ». Mais d’une part, on n’en sera jamais parfaitement sû r, d’autre part,
en raison de l’immensité de la place mémoire réservée et la plupart du temps
non utilisée, c’est un gâ chis préjudiciable à la rapidité, voire à la viabilité, de
notre algorithme.
Aussi, pour parer à ce genre de situation, a-t-on la possibilité de

déclarer le tableau sans préciser au départ son nombre d’éléments. Ce n’est que
dans un second temps, au cours du programme, que l’on va fixer ce nombre via
une instruction de redimensionnement : Redim.
Notez que tant qu’on n’a pas précisé le nombre d’éléments d’un tableau,
d’une manière ou d’une autre, ce tableau est inutilisable.
Exemple : on veut faire saisir des notes pour un calcul de moyenne, mais on ne
sait pas combien il y aura de notes à saisir. Le début de l’algorithme sera quelque
chose du genre :
Tableau Notes() en Numérique

Variable nb en Numérique
Début
Ecrire "Combien y a-t-il de notes à saisir ?"
Lire nb
Redim Notes(nb-1)
…

28
II.5. TRI D’UN TABLEAU
Il existe plusieurs stratégies possibles pour trier les éléments d’un

tableau ; nous en verrons deux : le tri par sélection, et le tri à bulles.
1) LE TRI PAR SÉLECTION
Admettons que le but de la manœuvre soit de trier un tableau de 12

éléments dans l’ordre croissant. La technique du tri par sélection est la suivante :
on met en bonne position l’élément numéro 1, c’est-à -dire le plus petit. Puis en
met en bonne position l’élément suivant. Et ainsi de suite jusqu’au dernier. Par
exemple, si l’on part de :
45 122 12 3 21 78 64 53 89 28 84 46
On commence par rechercher, parmi les 12 valeurs, quel est le plus petit élément, et où il se
trouve. On l’identifie en quatrième position (c’est le nombre 3), et on l’échange alors avec le premier
élément (le nombre 45). Le tableau devient ainsi :
3 122 12 45 21 78 64 53 89 28 84 46
On recommence à chercher le plus petit élément, mais cette fois,

seulement à partir du deuxième (puisque le premier est maintenant correct,
on n’y touche plus). On le trouve en troisième position (c’est le nombre 12). On
échange donc le deuxième avec le troisième :
3 12 122 45 21 78 64 53 89 28 84 46
On recommence à chercher le plus petit élément à partir du troisième

(puisque les deux premiers sont maintenant bien placés), et on le place
correctement, en l’échangeant, ce qui donnera in fine :
3 12 21 45 122 78 64 53 89 28 84 46
Et cetera, et cetera, jusqu’à l’avant dernier.

29
En bon français, nous pourrions décrire le processus de la manière suivante :
 Boucle principale : prenons comme point de départ le premier élément,

puis le second, etc, jusqu’à l’avant dernier.
 Boucle secondaire : à partir de ce point de départ mouvant, recherchons

jusqu’à la fin du tableau quel et le plus petit élément. Une fois que nous
l’avons trouvé, nous l’échangeons avec le point de départ.
Boucle principale : le point de départ se décale à chaque tour

Pour i ← 0 à 10
on considère provisoirement que t(i) est le plus petit élément
posmini ← i
on examine tous les éléments suivants
Pour j ← i + 1 à 11
Si t(j) < t(posmini) Alors
posmini ← j
Finsi
j suivant
A cet endroit, on sait maintenant où est le plus petit élément. Il ne reste plus qu'à
effectuer la permutation.
temp ← t(posmini)
t(posmini) ← t(i)
t(i) ← temp
On a placé correctement l'élément numéro i, on passe à présent au suivant.
i suivant
II.6. LA RECHERCHE DANS UN TABLEAU (UN EXEMPLE DE FLAG)

30
Nous allons maintenant nous intéresser au maniement habile d’une

variable booléenne : la technique dite du « flag ».
Le flag, en anglais, est un petit drapeau, qui va rester baissé aussi

longtemps que l’événement attendu ne se produit pas. Et, aussitô t que cet
événement a lieu, le petit drapeau se lève (la variable booléenne change de
valeur). Ainsi, la valeur finale de la variable booléenne permet au programmeur
de savoir si l’événement a eu lieu ou non.
Tout ceci peut vous sembler un peu fumeux, mais cela devrait s’éclairer
à l’aide d’un exemple extrêmement fréquent : la recherche de l’occurrence d’une
valeur dans un tableau. On en profitera au passage pour corriger une erreur
particulièrement fréquente chez le programmeur débutant.
Soit un tableau comportant, disons, 20 valeurs. L’on doit écrire un

algorithme saisissant un nombre au clavier, et qui informe l’utilisateur de la
présence ou de l’absence de la valeur saisie dans le tableau.
La première étape, évidente, consiste à écrire les instructions de

lecture / écriture, et la boucle car il y en a manifestement une de parcours du
tableau :
Tableau Tab(19) en Numérique

Variable N en Numérique
Début
Ecrire "Entrez la valeur à rechercher"
Lire N
Pour i ← 0 à 19
???
i suivant
Fin

31
Il nous reste à combler les points d'interrogation de la boucle Pour.

É videmment, il va falloir comparer N à chaque élément du tableau : si les deux
valeurs sont égales, N fait partie du tableau. Cela va se traduire, bien entendu,
par un Si … Alors … Sinon. Et voilà le programmeur raisonnant hâ tivement qui se
vautre en écrivant :

Début
Lire N
Pour i ← 0 à 19
Si N = Tab(i) Alors
Ecrire N "fait partie du tableau"
Sinon
Ecrire N "ne fait pas partie du tableau"
FinSi
i suivant
Fin
Il suffit d'ailleurs de le faire tourner mentalement pour s'en rendre
compte. De deux choses l'une : ou bien la valeur N figure dans le tableau, ou bien
elle n'y figure pas. Mais dans tous les cas, l'algorithme ne doit produire
qu'une seule réponse, quel que soit le nombre d'éléments que compte le
tableau. Or, l'algorithme ci-dessus envoie à l'écran autant de messages
qu'il y a de valeurs dans le tableau, en l'occurrence pas moins de 20 !
Il y a donc une erreur manifeste de conception : l'écriture du message

ne peut se trouver à l'intérieur de la boucle : elle doit figurer à l'extérieur. On sait
si la valeur était dans le tableau ou non uniquement lorsque le balayage du
tableau est entièrement accompli.
Nous réécrivons donc cet algorithme en plaçant le test après la boucle.

Faute de mieux, on se contentera de faire dépendre pour le moment la réponse
d'une variable booléenne que nous appellerons Trouvé.

32

Début
Lire N
Pour i ← 0 à 19
???
i suivant
Si Trouvé Alors
Ecrire "N fait partie du tableau"
Sinon
Ecrire "N ne fait pas partie du tableau"
FinSi
Fin
Il ne nous reste plus qu'à gérer la variable Trouvé. Ceci se fait en deux étapes.
 un test figurant dans la boucle, indiquant lorsque la variable Trouvé doit

devenir vraie (à savoir, lorsque la valeur N est rencontrée dans le tableau).
Et attention : le test est asymétrique. Il ne comporte pas de "sinon". On
reviendra là dessus dans un instant.
 last, but not least, l'affectation par défaut de la variable Trouvé, dont la
valeur de départ doit être évidemment Faux.
Au total, l'algorithme complet et juste ! donne :

Début
Lire N
Trouvé ← Faux
Pour i ← 0 à 19
Si N = Tab(i) Alors
Trouvé ← Vrai
FinSi
i suivant
Si Trouvé Alors
Ecrire "N fait partie du tableau"
Sinon
Ecrire "N ne fait pas partie du tableau"

33
FinSi
Fin
Méditons un peu sur cette affaire.
La difficulté est de comprendre que dans une recherche, le problème

ne se formule pas de la même manière selon qu'on le prend par un bout ou par
un autre. On peut résumer l'affaire ainsi : il suffit que N soit égal à une seule
valeur de Tab pour qu'elle fasse partie du tableau. En revanche, il faut
qu'elle soit différente de toutes les valeurs de Tab pour qu'elle n'en fasse
pas partie.
Voilà la raison qui nous oblige à passer par une variable booléenne, un
« drapeau » qui peut se lever, mais jamais se rabaisser. Et cette technique de
flag (que nous pourrions élégamment surnommer « gestion asymétrique de
variable booléenne ») doit être mise en œuvre chaque fois que l’on se trouve
devant pareille situation.
Autrement dit, connaître ce type de raisonnement est indispensable, et

savoir le reproduire à bon escient ne l'est pas moins.
II.7. TRI DE TABLEAU + FLAG = TRI A BULLES
Et maintenant, nous en arrivons à la formule magique : tri de tableau +

flag = tri à bulles. L’idée de départ du tri à bulles consiste à se dire qu’un tableau
trié en ordre croissant, c’est un tableau dans lequel tout élément est plus petit
que celui qui le suit. Cette constatation est plus profonde et plus utile.
En effet, prenons chaque élément d’un tableau, et comparons-le avec

l’élément qui le suit. Si l’ordre n’est pas bon, on permute ces deux éléments. Et
on recommence jusqu’à ce que l’on n’ait plus aucune permutation à effectuer.
Les éléments les plus grands « remontent » ainsi peu à peu vers les dernières
places, ce qui explique la charmante dénomination de « tri à bulle ».
En quoi le tri à bulles implique-t-il l’utilisation d’un flag ? Eh bien, par

ce qu’on ne sait jamais par avance combien de remontées de bulles on doit
34
effectuer. En fait, tout ce qu’on peut dire, c’est qu’on devra effectuer le tri jusqu’à
ce qu’il n’y ait plus d’éléments qui soient mal classés. Ceci est typiquement un
cas de question « asymétrique » : il suffit que deux éléments soient mal classés
pour qu’un tableau ne soit pas trié. En revanche, il faut que tous les éléments
soient bien rangés pour que le tableau soit trié.
Nous baptiserons le flag Yapermute, car cette variable booléenne va

nous indiquer si nous venons ou non de procéder à une permutation au cours du
dernier balayage du tableau (dans le cas contraire, c’est signe que le tableau est
trié, et donc qu’on peut arrêter la machine à bulles). La boucle principale sera
alors :
Variable Yapermute en Booléen

Début
…
TantQue Yapermute
…
FinTantQue
Fin
Que va-t-on faire à l’intérieur de la boucle ? Prendre les éléments du
tableau, du premier jusqu’à l’avant-dernier, et procéder à un échange si
nécessaire.

Début
…
TantQue Yapermute
Pour i ← 0 à 10
Si t(i) > t(i+1) Alors
temp ← t(i)
t(i) ← t(i+1)
t(i+1) ← temp
Finsi
i suivant
Fin

35
Mais il ne faut pas oublier un détail capital : la gestion de notre flag.

L’idée, c’est que cette variable va nous signaler le fait qu’il y a eu au moins une
permutation effectuée. Il faut donc :
 lui attribuer la valeur Vrai dès qu’une seule permutation a été faite (il suffit
qu’il y en ait eu une seule pour qu’on doive tout recommencer encore une
fois).
 la remettre à Faux à chaque tour de la boucle principale (quand on

recommence un nouveau tour général de bulles, il n’y a pas encore eu
d’éléments échangés),
 dernier point, il ne faut pas oublier de lancer la boucle principale, et pour

cela de donner la valeur Vrai au flag au tout départ de l’algorithme.
La solution complète donne donc :

Début
…
Yapermut ← Vrai
TantQue Yapermut
Yapermut ← Faux
Pour i ← 0 à 10
Si t(i) > t(i+1) alors
temp ← t(i)
t(i) ← t(i+1)
t(i+1) ← temp
Yapermut ← Vrai
Finsi
i suivant
FinTantQue
Fin
II.8. TABLEAUX A DEUX DIMENSIONS
L’informatique nous offre la possibilité de déclarer des tableaux dans

lesquels les valeurs ne sont pas repérées par une seule, mais par deux
coordonnées.

36
Un tel tableau se déclare ainsi :
Tableau Cases(7, 7) en Numérique
Cela veut dire : réserve moi un espace de mémoire pour 8 x 8 entiers,

et quand j’aurai besoin de l’une de ces valeurs, je les repèrerai par deux indices
(comme à la bataille navale, ou Excel, la seule différence étant que pour les
coordonnées, on n’utilise pas de lettres, juste des chiffres).
Pour notre problème de dames, les choses vont sérieusement

s’éclaircir. La case qui contient le pion est dorénavant Cases(i, j). Et les quatre
cases disponibles sont Cases(i-1, j-1), Cases(i-1, j+1), Cases(i+1, j-1) et Cases(i+1,
j+1).
REMARQUE ESSENTIELLE :
Il n’y a aucune différence qualitative entre un tableau à deux dimensions ( i, j
) et un tableau à une dimension ( i * j ). De même que le jeu de dames qu’on
vient d’évoquer, tout problème qui peut être modélisé d’une manière peut
aussi être modélisé de l’autre. Simplement, l’une ou l’autre de ces techniques
correspond plus spontanément à tel ou tel problème, et facilite donc (ou
complique, si on a choisi la mauvaise option) l’écriture et la lisibilité de
l’algorithme.

37
CHAPITRE III : LES FONCTIONS PREDEFINIES

III.1. POURQUOI LES FONCTIONS ?
Certains traitements ne peuvent être effectués par un algorithme, aussi

savant soit-il. D’autres ne peuvent l’être qu’au prix de souffrances indicibles.
C’est par exemple le cas du calcul du sinus d’un angle : pour en obtenir
une valeur approchée, il faudrait appliquer une formule d’une complexité à vous
glacer le sang. Aussi, que se passe-t-il sur les petites calculatrices que vous
connaissez tous ? On vous fournit quelques touches spéciales, dites touches de
fonctions, qui vous permettent par exemple de connaître immédiatement ce
résultat. Sur votre calculatrice, si vous voulez connaître le sinus de 35°, vous
taperez 35, puis la touche SIN, et vous aurez le résultat.
Tout langage de programmation propose ainsi un certain nombre de

fonctions ; certaines sont indispensables, car elles permettent d’effectuer des
traitements qui seraient sans elles impossibles. D’autres servent à soulager le
programmeur, en lui épargnant de longs – et pénibles - algorithmes.
Une fonction est un algorithme autonome, ré alisant une tâ che précise,

auquel on transmet des valeurs lors de son appel et qui retourne une valeur à
la fin de son exécution.
III.2. STRUCTURE GENERALE DES FONCTIONS
Reprenons l’exemple du sinus. Les langages informatiques, qui se

doivent tout de même de savoir faire la même chose qu’une calculatrice à 19F90,
proposent généralement une fonction SIN. Si nous voulons stocker le sinus de 35
dans la variable A, nous écrirons :
A ← Sin(35)
Une fonction est donc constituée de trois parties :

38
 le nom proprement dit de la fonction. Ce nom ne s’invente pas ! Il doit

impérativement correspondre à une fonction proposée par le langage.
Dans notre exemple, ce nom est SIN.
 deux parenthèses, une ouvrante, une fermante. Ces parenthèses sont

toujours obligatoires, même lorsqu'on n'écrit rien à l'intérieur.
 une liste de valeurs, indispensables à la bonne exécution de la fonction.

Ces valeurs s’appellent des arguments, ou des paramètres. Certaines
fonctions exigent un seul argument, d’autres deux, etc. et d’autres encore
aucun. A noter que même dans le cas de ces fonctions n’exigeant aucun
argument, les parenthèses restent obligatoires. Le nombre d’arguments
nécessaire pour une fonction donnée ne s’invente pas : il est fixé par le
langage. Notez également que les arguments doivent être d’un certain
type, et qu’il faut respecter ces types.
Et d'entrée, nous trouvons :
III.3. LES FONCTIONS DE TEXTE
Tous les langages, proposent un certain nombre des fonctions pour

manipuler le texte, même si le nom et la syntaxe peuvent varier d’un langage à
l’autre :
 Len(chaîne) : renvoie le nombre de caractères d’une chaîne

 Mid(chaîne,n1,n2) : renvoie un extrait de la chaîne, commençant au
caractère n1 et faisant n2 caractères de long.
Ce sont les deux seules fonctions de chaînes réellement indispensables.
Cependant, pour nous épargner des algorithmes fastidieux, les langages
proposent également :
 Left(chaîne,n) : renvoie les n caractères les plus à gauche dans
chaîne.

39
 Right(chaîne,n) : renvoie les n caractères les plus à droite dans

chaîne
 Trouve(chaîne1,chaîne2) : renvoie un nombre correspondant à la
position de chaîne2 dans chaîne1. Si chaîne2 n’est pas comprise dans
chaîne1, la fonction renvoie zéro.
Exemples :
Len("Bonjour, ça va ?") vaut 16
Len("") vaut 0
Mid("Zorro is back", 4, 7) vaut "ro is b"
Mid("Zorro is back", 12, 1) vaut "c"
Left("Et pourtant…", 8) vaut "Et pourt"
Right("Et pourtant…", 4) vaut "t…"
Trouve("Un pur bonheur", "pur") vaut 4
Trouve("Un pur bonheur", "techno") vaut 0
III.4. TROIS FONCTIONS NUMERIQUES CLASSIQUES
Partie Entière
Une fonction extrêmement répandue est celle qui permet de récupérer

la partie entière d’un nombre :
Après : A ← Ent(3,228) A vaut 3
Cette fonction est notamment indispensable pour effectuer le

célébrissime test de parité (voir exercice dans pas longtemps).
Modulo
Cette fonction permet de récupérer le reste de la division d’un nombre

par un deuxième nombre. Par exemple :
A ← Mod(10,3) A vaut 1 car 10 = 3*3 + 1

B ← Mod(12,2) B vaut 0 car 12 = 6*2
C ← Mod(44,8) C vaut 4 car 44 = 5*8 + 4
Cette fonction peut paraître un peu bizarre, est réservée aux seuls
matheux. Mais vous aurez là aussi l’occasion de voir dans les exercices à venir

40
que ce n’est pas le cas.
Sqr ( )
Cette fonction permet de renvoyer la racine carrée d’un nombre. Par

exemple :
A ← Sqr(4) A vaut 2
B ← Sqr(9) B vaut 3
IV.5. VARIABLES PUBLIQUES ET PRIVEES
Il existe un troisième et dernier moyen d'échanger des informations

entre différentes procédures et fonctions : c'est de ne pas avoir besoin de les
échanger, en faisant en sorte que ces procédures et fonctions partagent
littéralement les mêmes variables, sous les mêmes noms. Cela suppose d'avoir
recours à des variables particulières, lisibles et utilisables par n'importe quelle
procédure ou fonction de l'application.
Par défaut, une variable est déclarée au sein d'une procédure ou d'une
fonction. Elle est donc créée avec cette procédure, et disparaît avec elle. Durant
tout le temps de son existence, une telle variable n'est visible que par la
procédure qui l'a vu naître. Si je crée une variable Toto dans une procédure
Bidule, et qu'en cours de route, ma procédure Bidule appelle une sous-
procédure Machin, il est hors de question que Machin puisse accéder à Toto, ne
serait-ce que pour connaître sa valeur (et ne parlons pas de la modifier). Voilà
pourquoi ces variables par défaut sont dites privées, ou locales.
Mais à cô té de cela, il est possible de créer des variables qui certes,

seront déclarées dans une procédure, mais qui du moment où elles existeront,
seront des variables communes à toutes les procédures et fonctions de
l'application. Avec de telles variables, le problème de la transmission des valeurs
d'une procédure (ou d'une fonction) à l'autre ne se pose même plus : la variable
Truc, existant pour toute l'application, est accessible et modifiable depuis

41
n'importe quelle ligne de code de cette application. Plus besoin donc de la

transmettre ou de la renvoyer. Une telle variable est alors dite publique, ou
globale.

42
CHAPITRE IV : LES FICHIERS
Jusqu’à présent, les informations utilisées dans nos programmes ne

pouvaient provenir que de deux sources : soit elles étaient inclues dans
l’algorithme lui-même, par le programmeur, soit elles étaient entrées en cours
de route par l’utilisateur. Mais évidemment, cela ne suffit pas à combler les
besoins réels des informaticiens.
Imaginons que l’on veuille écrire un programme gérant un carnet

d’adresses. D’une exécution du programme à l’autre, l’utilisateur doit pouvoir
retrouver son carnet à jour, avec les modifications qu’il y a apportées la dernière
fois qu’il a exécuté le programme. Les données du carnet d’adresse ne peuvent
donc être inclues dans l’algorithme, et encore moins être entrées au clavier à
chaque nouvelle exécution !
Les fichiers sont là pour combler ce manque. Ils servent à stocker

des informations de manière permanente, entre deux exécutions d’un
programme. Car si les variables, qui sont je le rappelle des adresses de mémoire
vive, disparaissent à chaque fin d’exécution, les fichiers, eux sont stockés sur des
périphériques à mémoire de masse (disquette, disque dur, CD Rom…).
IV.1. ORGANISATION DES FICHIERS
A ce qui concerne les fichiers, retenons qu’il y a des catégories, et dans

les catégories, des sortes, et dans les sortes des espèces. Essayons donc de
débroussailler un peu tout cela...
Un premier grand critère, qui différencie les deux grandes catégories

de fichiers, est le suivant : le fichier est-il ou non organisé sous forme de
lignes successives ? Si oui, cela signifie vraisemblablement que ce fichier
contient le même genre d'information à chaque ligne. Ces lignes sont alors
appelées des enregistrements.

43
Afin d'illuminer ces propos obscurs, prenons le cas classique, celui d'un
carnet d'adresses. Le fichier est destiné à mémoriser les coordonnées d'un
certain nombre de personnes. Pour chacune, il faudra noter le nom, le prénom, le
numéro de téléphone et l'email. Dans ce cas, il peut paraître plus simple de
stocker une personne par ligne du fichier (par enregistrement). Dit autrement,
quand on prendra une ligne, on sera sû r qu'elle contient les informations
concernant une personne, et uniquement cela. Un fichier ainsi codé sous forme
d'enregistrements est appelé un fichier texte.
En fait, entre chaque enregistrement, sont stockés les octets

correspondants aux caractères CR (code Ascii 13) et LF (code Ascii 10),
signifiant un retour au début de la ligne suivante. Le plus souvent, le langage de
programmation, dès lors qu'il s'agit d'un fichier texte, gèrera lui-même la lecture
et l'écriture de ces deux caractères à chaque fin de ligne : c'est autant de moins
dont le programmeur aura à s'occuper. Le programmeur, lui, n'aura qu'à dire à
la machine de lire une ligne, ou d'en écrire une.
Ce type de fichier est couramment utilisé dès lors que l'on doit stocker
des informations pouvant être assimilées à une base de données.
Le second type de fichier, vous l'aurez deviné, se définit a contrario : il

rassemble les fichiers qui ne possèdent pas de structure de lignes
(d'enregistrement). Les octets, quels qu’ils soient, sont écrits à la queue leu leu.
Ces fichiers sont appelés des fichiers binaires. Naturellement, leur structure
différente implique un traitement différent par le programmeur. Cela concerne
par exemple un fichier son, une image, un programme exécutable, etc.
Autre différence majeure entre fichiers texte et fichiers binaires : dans

un fichier texte, toutes les données sont écrites sous forme de... texte (étonnant,
non ?). Cela veut dire que les nombres y sont représentés sous forme de suite de
chiffres (des chaînes de caractères). Ces nombres doivent donc être convertis
en chaînes lors de l'écriture dans le fichier. Inversement, lors de la lecture du

44
fichier, on devra convertir ces chaînes en nombre si l'on veut pouvoir les
utiliser dans des calculs. En revanche, dans les fichiers binaires, les données sont
écrites à l'image exact de leur codage en mémoire vive, ce qui épargne toutes ces
opérations de conversion.
Ceci a comme autre implication qu'un fichier texte est directement

lisible, alors qu'un fichier binaire ne l'est pas (sauf bien sû r en écrivant soi-
même un programme approprié). Si l'on ouvre un fichier texte via un éditeur de
textes, comme le bloc-notes de Windows, on y reconnaîtra toutes les
informations (ce sont des caractères, stockés comme tels). La même chose avec
un fichier binaire ne nous produit à l'écran qu'un langage incompréhensible.
IV.2. STRUCTURE DES ENREGISTREMENTS
Savoir que les fichiers peuvent être structurés en enregistrements,

c'est bien. Mais savoir comment sont à leur tour structurés ces enregistrements,
c'est mieux. Or, là aussi, il y a deux grandes possibilités. Ces deux grandes
variantes pour structurer les données au sein d’un fichier texte sont la
délimitation et les champs de largeur fixe.
Reprenons le cas du carnet d’adresses, avec dedans le nom, le prénom,

le téléphone et l'email. Les données, sur le fichier texte, peuvent être organisées
ainsi :
Structure n°1
"Etshiko";"Freddy";0822225983;"[email protected]"
"Ngalula";"Mélanie";0991226114;"[email protected]"
"Kayembe";"Jean-Philippe";0898288123;"[email protected]"
"Lusamba";"Olive";0851110022;"[email protected]"
ou ainsi :
Structure n°2

45
Etshiko Freddy [email protected]

Ngalula Mélanie [email protected]
Kayembe Jean-Philippe [email protected]
Lusamba Olive [email protected]
La structure n°1 est dite délimitée ; Elle utilise un caractère spécial,

appelé caractère de délimitation, qui permet de repérer quand finit un champ
et quand commence le suivant. Il va de soi que ce caractère de délimitation doit
être strictement interdit à l’intérieur de chaque champ, faute de quoi la structure
devient proprement illisible.
La structure n°2, elle, est dite à champs de largeur fixe. Il n’y a pas de
caractère de délimitation, mais on sait que les x premiers caractères de chaque
ligne stockent le nom, les y suivants le prénom, etc. Cela impose bien entendu de
ne pas saisir un renseignement plus long que le champ prévu pour l’accueillir.
 L’avantage de la structure n°1 est son faible encombrement en place

mémoire ; il n’y a aucun espace perdu, et un fichier texte codé de cette
manière occupe le minimum de place possible. Mais elle possède en
revanche un inconvénient majeur, qui est la lenteur de la lecture. En
effet, chaque fois que l’on récupère une ligne dans le fichier, il faut alors
parcourir un par un tous les caractères pour repérer chaque occurrence
du caractère de séparation avant de pouvoir découper cette ligne en
différents champs.
 La structure n°2, à l’inverse, gaspille de la place mémoire, puisque le

fichier est un vrai gruyère plein de trous. Mais d’un autre cô té, la
récupération des différents champs est très rapide. Lorsqu’on récupère
une ligne, il suffit de la découper en différentes chaînes de longueur
prédéfinie, et le tour est joué.
A l’époque où la place mémoire coû tait cher, la structure délimitée

était souvent privilégiée. Mais depuis bien des années, la quasi-totalité des
46
logiciels – et des programmeurs – optent pour la structure en champs de largeur

fixe. Aussi, sauf mention contraire, nous ne travaillerons qu’avec des fichiers
bâ tis sur cette structure.
Remarque importante : lorsqu'on choisit de coder une base de données

sous forme de champs de largeur fixe, on peut alors très bien opter pour un
fichier binaire. Les enregistrements y seront certes à la queue leu leu, sans que
rien ne nous signale la jointure entre chaque enregistrement. Mais si on sait
combien d'octets mesure invariablement chaque champ, on sait du coup
combien d'octets mesure chaque enregistrement. Et on peut donc très
facilement récupérer les informations : si je sais que dans mon carnet d'adresse,
chaque individu occupe mettons 75 octets, alors dans mon fichier binaire, je
déduis que l'individu n°1 occupe les octets 1 à 75, l'individu n°2 les octets 76 à
150, l'individu n°3 les octets 151 à 225, etc.
IV.3. TYPES D’ACCES
Le type d’accès est la manière dont la machine va pouvoir aller

rechercher les informations contenues dans le fichier.
On distingue :
 L’accès séquentiel : on ne peut accéder qu’à la donnée suivant celle

qu’on vient de lire. On ne peut donc accéder à une information qu'en ayant
au préalable examiné celle qui la précède. Dans le cas d'un fichier texte,
cela signifie qu'on lit le fichier ligne par ligne (enregistrement par
enregistrement).
 L’accès direct (ou aléatoire) : on peut accéder directement à

l’enregistrement de son choix, en précisant le numéro de cet
enregistrement. Mais cela veut souvent dire une gestion fastidieuse des
déplacements dans le fichier.

47
 L’accès indexé : pour simplifier, il combine la rapidité de l'accès direct et

la simplicité de l'accès séquentiel (en restant toutefois plus compliqué). Il
est particulièrement adapté au traitement des gros fichiers, comme les
bases de données importantes.
C’est dans le programme, et seulement dans le programme, que l’on

choisit le type d’accès souhaité.
IV.4. INSTRUCTIONS (FICHIERS TEXTE EN ACCES SEQUENTIEL)
Si l’on veut travailler sur un fichier, la première chose à faire est de

l’ouvrir. Cela se fait en attribuant au fichier un numéro de canal. On ne peut
ouvrir qu’un seul fichier par canal, mais quel que soit le langage, on dispose
toujours de plusieurs canaux, donc pas de soucis.
L’important est que lorsqu’on ouvre un fichier, on stipule ce qu’on va

en faire : lire, écrire ou ajouter.
 Si on ouvre un fichier pour lecture, on pourra uniquement récupérer les

informations qu’il contient, sans les modifier en aucune manière.
 Si on ouvre un fichier pour écriture, on pourra mettre dedans toutes les

informations que l’on veut. Mais les informations précédentes, si elles
existent, seront intégralement écrasées Et on ne pourra pas accéder aux
informations qui existaient précédemment.
 Si on ouvre un fichier pour ajout, on ne peut ni lire, ni modifier les

informations existantes. Mais on pourra, comme vous commencez à vous
en douter, ajouter de nouvelles lignes (je rappelle qu'au terme de lignes,
on préférera celui d’enregistrements.
Pour ouvrir un fichier texte, on écrira par exemple :
Ouvrir "Exemple.txt" sur 4 en Lecture

48
Ici, "Exemple.txt" est le nom du fichier sur le disque dur, 4 est le

numéro de canal, et ce fichier a donc été ouvert en lecture. Vous l’aviez sans
doute pressenti. Allons plus loin :
Variables Truc, Nom, Prénom, Tel, Mail en Caractères

Début
LireFichier 4, Truc
Nom ← Mid(Truc, 1, 20)
Prénom ← Mid(Truc, 21, 15)
Tel ← Mid(Truc, 36, 10)
Mail ← Mid(Truc, 46, 20)
L’instruction LireFichier récupère donc dans la variable spécifiée

l’enregistrement suivant dans le fichier... "suivant", oui, mais par rapport à quoi ?
Par rapport au dernier enregistrement lu. C’est en cela que le fichier est dit
séquentiel. En l’occurrence, on récupère donc la première ligne, donc, le premier
enregistrement du fichier, dans la variable Truc. Ensuite, le fichier étant organisé
sous forme de champs de largeur fixe, il suffit de tronçonner cette variable Truc
en autant de morceaux qu’il y a de champs dans l’enregistrement, et d’envoyer
ces tronçons dans différentes variables. Et le tour est joué.
La suite du raisonnement s’impose avec une logique impitoyable : lire

un fichier séquentiel de bout en bout suppose de programmer une boucle.
Comme on sait rarement à l’avance combien d’enregistrements comporte le
fichier, la combine consiste neuf fois sur dix à utiliser la fonction EOF (acronyme
pour End Of File). Cette fonction renvoie la valeur Vrai si on a atteint la fin du
fichier (auquel cas une lecture supplémentaire déclencherait une erreur).
L’algorithme, ultra classique, en pareil cas est donc :
Variable Truc en Caractère

Début

49

Tantque Non EOF(5)
LireFichier 5, Truc
…
FinTantQue
Fermer 5
Fin
Et neuf fois sur dix également, si l’on veut stocker au fur et à mesure en
mémoire vive les informations lues dans le fichier, on a recours à un ou
plusieurs tableaux. Et comme on ne sait pas d’avance combien il y aurait
d’enregistrements dans le fichier, on ne sait pas davantage combien il doit y
avoir d’emplacements dans les tableaux. Qu’importe, les programmeurs avertis
que vous êtes connaissent la combine des tableaux dynamiques.
En rassemblant l’ensemble des connaissances acquises, nous pouvons

donc écrire le prototype du code qui effectue la lecture intégrale d’un fichier
séquentiel, tout en recopiant l’ensemble des informations en mémoire vive :
Tableaux Nom(), Prénom(), Tel(), Mail() en Caractère

Début
i ← -1
Tantque Non EOF(5)
LireFichier 5, Truc
i←i+1
Redim Nom(i)
Redim Prénom(i)
Redim Tel(i)
Redim Mail(i)
Nom(i) ← Mid(Truc, 1, 20)
Prénom(i) ← Mid(Truc, 21, 15)
Tel(i) ← Mid(Truc, 36, 10)
Mail(i) ← Mid(Truc, 46, 20)
FinTantQue
Fermer 5
Fin

50
Ici, on a fait le choix de recopier le fichier dans quatre tableaux

distincts. On aurait pu également tout recopier dans un seul tableau : chaque
case du tableau aurait alors été occupée par une ligne complète (un
enregistrement) du fichier. Cette solution nous aurait fait gagner du temps au
départ, mais elle alourdit ensuite le code, puisque chaque fois que l'on a besoin
d'une information au sein d'une case du tableau, il faudra aller procéder à une
extraction via la fonction MID. Ce qu'on gagne par un bout, on le perd donc par
l'autre.
Mais surtout, comme on va le voir bientô t, il y a autre possibilité, bien

meilleure, qui cumule les avantages sans avoir aucun des inconvénients.
Néanmoins, ne nous impatientons pas, chaque chose en son temps, et

revenons pour le moment à la solution que nous avons employée ci-dessus.
Pour une opération d’écriture, ou d’ajout, il faut d’abord

impérativement, sous peine de semer la panique dans la structure du fichier,
constituer une chaîne équivalente à la nouvelle ligne du fichier. Cette chaîne doit
donc être « calibrée » de la bonne manière, avec les différents champs qui
« tombent » aux emplacements corrects. Le moyen le plus simple pour
s’épargner de longs traitements est de procéder avec des chaînes correctement
dimensionnées dès leur déclaration (la plupart des langages offrent cette
possibilité) :
Ouvrir "Exemple.txt" sur 3 en Ajout

Variable Truc en Caractère
Variables Nom*20, Prénom*15, Tel*10, Mail*20 en Caractère
Une telle déclaration assure que quel que soit le contenu de la variable
Nom, par exemple, celle-ci comptera toujours 20 caractères. Si son contenu est
plus petit, alors un nombre correct d’espaces sera automatiquement ajouté pour
combler. Si on tente d’y entrer un contenu trop long, celui-ci sera
automatiquement tronqué. Voyons la suite :
51
Nom ← "Jokers"
Prénom ← "Midnight"
Tel ← "0348946532"
Mail ← "[email protected]"
Truc ← Nom & Prénom & Tel & Mail
EcrireFichier 3, Truc
Et pour finir, une fois qu’on en a terminé avec un fichier, il ne faut pas
oublier de fermer ce fichier. On libère ainsi le canal qu’il occupait (et
accessoirement, on pourra utiliser ce canal dans la suite du programme pour un
autre fichier… ou pour le même).

Cours Algo Ii - Unikan

Transféré par

Informations du documentcliquez pour développer les informations du document

Informations du documentcliquez pour développer les informations du document

Droits d'auteur :

Formats disponibles

Cours Algo Ii - Unikan

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Algo Ii - Unikan

Transféré par

Droits d'auteur :

Formats disponibles

1

Apprendre aux étudiants les stratégies nécessaire pour résoudre un problème

CHAPITRE I : REVISION ALGO I

I.1. NOTIONS D’ALGORITHME ET DE PROGRAMMATION.

I.2. LES VARIABLES

I.3. LES TESTS

I.4. LES BOUCLES

CHAPITRE II : LES TABLEAUX

CHAPITRE III : LES FONCTIONS PREDEFINIES

CHAPITRE IV : LES FICHIERS

1. Christophe Darmangeat ; L’Algorithmique et la programmation, Paris,

Assistant Freddy ETSHIKO. Notions d’Algorithmique II.

La conception des programmes met en œuvre un ensemble

Lorsque, par souci de faire vite, le programmeur brule les étapes de la

Il faut pouvoir modifier et améliorer afin de tenir compte de vos

Aujourd’hui, la nécessité d’une bonne méthode. Rigoureuse de

L’ordinateur est une machine, disons un ensemble des composants

Cependant, l’ordinateur étant une machine, ne dispose pas de la faculté

Assistant Freddy ETSHIKO. Notions d’Algorithmique II.

Nous avons donc un Objectif : obtenir de la «machine» qu’elle effectue

Mais... comment le lui dire ? Comment le lui apprendre ?

Lorsque nous programmons, nous nous mettons à la place de la

 résoudre des problèmes «comme» une machine

 savoir expliciter son raisonnement (comment faire un travail sans la

 savoir formaliser son raisonnement

 concevoir (et écrire) des algorithmes (un algorithme ne dépend pas ni du

 Savoir codifier notre algorithme dans un langage de programmation.

Assistant Freddy ETSHIKO. Notions d’Algorithmique II.

CHAPITRE I : RAPPEL DE L’ALGORITHMIQUE I.

I.1. 1. QU’EST-CE QUE L’ALGORITHME ?

Comme quoi, l’algorithmique n’est pas un savoir ésotérique (mystérieux ou

Un algorithme est une suite ordonnée d’opération permettant d’obtenir un

Pour fonctionner, un algorithme doit donc contenir uniquement des

Pour bien s’adapter à écrire des algorithmes :

Assistant Freddy ETSHIKO. Notions d’Algorithmique II.

I.1.2. ALGORITHMIQUE ET PROGRAMMATION

Pourquoi apprendre l’algorithmique pour apprendre à programmer ? En quoi

Parce que l’algorithmique exprime les instructions résolvant un problème

Apprendre l’algorithmique, c’est apprendre à manier la structure logique

I.1.3. CONVENTION D’ECRITURE D’UN ALGORITHME

Historiquement, plusieurs types de notations ont représenté des algorithmes.

Il y a eu notamment une représentation graphique, avec des carrés, des

Assistant Freddy ETSHIKO. Notions d’Algorithmique II.

représentation est quasiment abandonnée, pour deux raisons. D’abord, parce

C’est pourquoi on utilise généralement une série de conventions appelée «

I.1.4. CARACTERISTIQUE D’UN BON ALGORITHME

Un bon algorithme doit être :

- Lisible : compréhensible par d’autres personnes ;

I.1.5. LES ETAPES DE RESOLUTION D’UN PROBLEME

 Quel est le résultat à obtenir ? (Que veut – on ?)

Assistant Freddy ETSHIKO. Notions d’Algorithmique II.

 Quelles opérations permettent d’élaborer ce résultat ? (comment s’obtient

 Définir précisément le problème pour identifier le(s) résultat(s)

Ainsi l’algorithme peut se présenter par le schéma classique suivant

Entrées(Données) -----> Traitement(opérations) ----> Sorties(Résultats)

Travail à faire : Concevoir un algorithme permettant à votre grand père de

- Quel est le résultat recherché ? (Sortie)