Cours Algorithmique

COURS DALGORITHMIQUE
PAR
CHRISTOPHE DARMANGEAT
ENSEIGNANT DESS AIGES
(APPLICATIONS INFORMATIQUES LA GESTION CONOMIQUE ET SOCIALE)
UNIVERSIT PARIS VII DENIS DIDEROT
ii
Cours Algorithmique
Auteur : Christophe Darmangeat
TABLE DES MATIRES

PRAMBULE
(LE CODAGE)--------------------------------------------------------------------------------------- 1
1. Pourquoi les ordinateurs sont-ils binaires ? ----------------------------------------------------------------------- 1

2. La numrotation de position en base dcimale ------------------------------------------------------------------------ 2
3. La numrotation de position en base binaire -------------------------------------------------------------------------- 4
4. Le codage hexadcimal ----------------------------------------------------------------------------------------------------- 6
INTRODUCTION A LALGORITHMIQUE -------------------------------------------------------------------------------- 8

1. Quest-ce que lalgomachin ? --------------------------------------------------------------------------------------------- 8
2. Faut-il tre matheux pour tre bon en algorithmique ? ------------------------------------------------------------- 9
3. LADN, les Shadoks, et les ordinateurs ------------------------------------------------------------------------------- 10
4. Algorithmique et programmation-------------------------------------------------------------------------------------- 10
5. Avec quelles conventions crit-on un algorithme ? ----------------------------------------------------------------- 11
PARTIE 1
(LES VARIABLES) --------------------------------------------------------------------------------------- 12
1. A quoi servent les variables ? ------------------------------------------------------------------------------------------- 12

2. Dclaration des variables ------------------------------------------------------------------------------------------------ 12
2.1. Types numriques classiques----------------------------------------------------------------------------------------------------- 13
2.2. Autres types numriques ---------------------------------------------------------------------------------------------------------- 14
2.3. Type alphanumrique ------------------------------------------------------------------------------------------------------------- 14
2.4. Type boolen ----------------------------------------------------------------------------------------------------------------------- 15
3. Linstruction daffectation ---------------------------------------------------------------------------------------------- 15

3.1. Syntaxe et signification ----------------------------------------------------------------------------------------------------------- 15
3.2. Ordre des instructions ------------------------------------------------------------------------------------------------------------- 17
4. Expressions et oprateurs------------------------------------------------------------------------------------------------ 19
4.1. Oprateurs numriques : ---------------------------------------------------------------------------------------------------------- 20
4.3. Oprateurs logiques (ou boolens) : --------------------------------------------------------------------------------------------- 21
5. Deux remarques pour terminer ---------------------------------------------------------------------------------------- 21
PARTIE
2 (LECTURE ET CRITURE)------------------------------------------------------------------------------- 23
1. De quoi parle-t-on ? ------------------------------------------------------------------------------------------------------- 23

2. Les instructions de lecture et dcriture ------------------------------------------------------------------------------ 24
PARTIE 3
(LES TESTS) --------------------------------------------------------------------------------------------- 26
1. De quoi sagit-il ? ---------------------------------------------------------------------------------------------------------- 26

2. Structure dun test -------------------------------------------------------------------------------------------------------- 27
3. Quest ce quune condition ? -------------------------------------------------------------------------------------------- 28
4. Conditions composes ---------------------------------------------------------------------------------------------------- 29
5. Tests imbriqus ------------------------------------------------------------------------------------------------------------ 31
6. De laiguillage la gare de tri------------------------------------------------------------------------------------------- 32
7. Variables Boolennes ----------------------------------------------------------------------------------------------------- 34
PARTIE 4
(ENCORE DE LA LOGIQUE)----------------------------------------------------------------------------- 35
1. Faut-il mettre un ET ? Faut-il mettre un OU ? --------------------------------------------------------------------- 35
iii
Cours Algorithmique
2. Au-del de la logique : le style ------------------------------------------------------------------------------------------ 37
PARTIE 5
(LES BOUCLES) ----------------------------------------------------------------------------------------- 40
1. A quoi cela sert-il donc ?------------------------------------------------------------------------------------------------- 40

2. Boucler en comptant, ou compter en bouclant ---------------------------------------------------------------------- 43
3. Des boucles dans des boucles-------------------------------------------------------------------------------------------- 45
4. Et encore une btise ne pas faire ! ----------------------------------------------------------------------------------- 46
PARTIE 6
(LES TABLEAUX) ---------------------------------------------------------------------------------------- 49
1. Utilit des tableaux -------------------------------------------------------------------------------------------------------- 49

2. Notation et utilisation algorithmique---------------------------------------------------------------------------------- 49
3. Tableaux dynamiques ---------------------------------------------------------------------------------------------------- 52
PARTIE 7
(TECHNIQUES RUSES )-------------------------------------------------------------------------------- 55
1. Tri dun tableau : le tri par insertion --------------------------------------------------------------------------------- 55

2. Un exemple de flag : la recherche dans un tableau----------------------------------------------------------------- 56
3. Tri de tableau + flag = tri bulles ------------------------------------------------------------------------------------- 58
4. La recherche dichotomique --------------------------------------------------------------------------------------------- 60
PARTIE 8
(TABLEAUX MULTIDIMENSIONNELS)----------------------------------------------------------------- 62
1. Pourquoi plusieurs dimensions ?--------------------------------------------------------------------------------------- 62

2. Tableaux deux dimensions -------------------------------------------------------------------------------------------- 63
3. Tableaux n dimensions------------------------------------------------------------------------------------------------- 66
PARTIE 9
(LES FONCTIONS PRDFINIES)---------------------------------------------------------------------- 67
1. Structure gnrale des fonctions --------------------------------------------------------------------------------------- 67

2. Les fonctions de texte ----------------------------------------------------------------------------------------------------- 68
3. Trois fonctions numriques classiques -------------------------------------------------------------------------------- 70
4. Les fonctions de conversion --------------------------------------------------------------------------------------------- 73
PARTIE 10
1.
(LES FICHIERS) -------------------------------------------------------------------------------------- 74
Organisation des fichiers --------------------------------------------------------------------------------------------- 74
2. Structure des enregistrements ------------------------------------------------------------------------------------------ 75

3. Types daccs --------------------------------------------------------------------------------------------------------------- 76
4. Instructions (fichiers texte en accs squentiel) --------------------------------------------------------------------- 77
5. Stratgies de traitement -------------------------------------------------------------------------------------------------- 80
6. Donnes structures------------------------------------------------------------------------------------------------------- 81
6.1. Donnes structures simples------------------------------------------------------------------------------------------------------ 81
6.2. Tableaux de donnes structures------------------------------------------------------------------------------------------------- 83
7. Rcapitulatif gnral------------------------------------------------------------------------------------------------------ 84
PARTIE 11
(PROCDURES ET FONCTIONS)--------------------------------------------------------------------- 87
1. Fonctions personnalises------------------------------------------------------------------------------------------------- 87
1.1. De quoi s'agit-il ? ------------------------------------------------------------------------------------------------------------------ 87
1.2. Passage d'arguments --------------------------------------------------------------------------------------------------------------- 89
2. Sous-Procdures ----------------------------------------------------------------------------------------------------------- 91
iv
Cours Algorithmique
3. Variables publiques et prives ------------------------------------------------------------------------------------------ 94

4. Algorithmes fonctionnels ------------------------------------------------------------------------------------------------ 94
PARTIE 12
(NOTIONS COMPLMENTAIRES) ----------------------------------------------------------------- 101
1. Programmation structure --------------------------------------------------------------------------------------------- 101

2. Interprtation et compilation ------------------------------------------------------------------------------------------ 102
3. Une logique vicelarde : la programmation rcursive ------------------------------------------------------------- 103
ANNEXE
(CORRIGS DES EXERCICES) --------------------------------------------------------------------------- a
1
Cours Algorithmique
PRAMBULE (LE CODAGE)

Linformation nest pas le savoir. Le savoir nest pas la sagesse. La sagesse nest pas la beaut. La beaut nest
pas lamour. Lamour nest pas la musique, et la musique, cest ce quil y a de mieux.
Frank Zappa
Les ordinateurs sont comme les dieux de lAncien Testament : avec beaucoup de rgles, et sans piti.
Joseph Campbell
Compter en octal, cest comme compter en dcimal, si on nutilise pas ses pouces
Tom Lehrer
Cest bien connu, les ordinateurs sont comme le gros rock qui tche : ils sont binaires.
Mais ce qui est moins connu, cest ce que ce qualificatif de binaire recouvre exactement, et ce quil implique. Aussi,
avant de nous plonger dans les arcanes de lalgorithmique proprement dite, ferons-nous un dtour par la notion de
codage binaire. Contrairement aux apparences, nous ne sommes pas loigns de notre sujet principal. Tout au
contraire, ce que nous allons voir prsent constitue un ensemble de notions indispensables lcriture de
programmes. Car pour parler une machine, mieux vaut connatre son vocabulaire
1. Pourquoi les ordinateurs sont-ils binaires ?

De nos jours, les ordinateurs sont ces machines merveilleuses capables de traiter du texte, dafficher des tableaux de
matre, de jouer de la musique ou de projeter des vidos. On nen est pas encore tout fait HAL, lordinateur de
2001 Odysse de lEspace, lintelligence si dveloppe quil a peur de mourir pardon, dtre dbranch. Mais
lordinateur parat tre une machine capable de tout faire.
Pourtant, les ordinateurs ont beau sembler repousser toujours plus loin les limites de leur champ daction, il ne faut
pas oublier quen ralit, ces fiers--bras ne sont toujours capables que dune seule chose : faire des calculs, et
uniquement cela. Eh oui, ces gros malins dordinateurs sont rests au fond ce quils ont t depuis leur invention : de
vulgaires calculatrices amliores !
Lorsquun ordinateur traite du texte, du son, de limage, de la vido, il traite en ralit des nombres. En fait, dire cela,
cest dj lui faire trop dhonneur. Car mme le simple nombre 3 reste hors de porte de lintelligence dun
ordinateur, ce qui le situe largement en dessous de lattachant chimpanz Bonobo, qui sait, entre autres choses, faire
des blagues ses congnres et jouer au Pac-Man. Un ordinateur manipule exclusivement des informations binaires,
dont on ne peut mme pas dire sans tre tendancieux quil sagit de nombres.
Mais quest-ce quune information binaire ? Cest une information qui ne peut avoir que deux tats : par exemple,
ouvert - ferm, libre occup, militaire civil, assis couch, blanc noir, vrai faux, etc. Si lon pense des dispositifs
physiques permettant de stocker ce genre dinformation, on pourrait citer : charg non charg, haut bas, trou non
trou.
2
Cours Algorithmique
Ne donnons pas derniers exemples au hasard : ce sont prcisment ceux dont se sert un ordinateur pour stocker
lensemble des informations quil va devoir manipuler. En deux mots, la mmoire vive (la RAM ) est forme de
millions de composants lectroniques qui peuvent retenir ou relcher une charge lectrique. La surface dun disque
dur, dune bande ou dune disquette est recouverte de particules mtalliques qui peuvent, grce un aimant, tre
orientes dans un sens ou dans lautre. Et sur un CD-ROM, on trouve un long sillon troit irrgulirement perc de
trous.
Toutefois, la coutume veut quon symbolise une information binaire, quel que soit son support physique, sous la forme
de 1 et de 0. Il faut bien comprendre que ce nest l quune reprsentation, une image commode, que lon utilise pour
parler de toute information binaire. Dans la ralit physique, il ny a pas plus de 1 et de 0 qui se promnent dans les
ordinateurs quil ny a crit, en lettres gantes, Ocan Atlantique sur la mer quelque part entre la Bretagne et les
Antilles. Le 1 et le 0 dont parlent les informaticiens sont des signes, ni plus, ni moins, pour dsigner une information,
indpendamment de son support physique.
Les informaticiens seraient-ils des gens tordus, possdant un got immodr pour labstraction, ou pour les jeux
intellectuels alambiqus ? Non, pas davantage en tout cas que le reste de leurs contemporains non-informaticiens. En
fait, chacun dentre nous pratique ce genre dabstraction tous les jours, sans pour autant trouver cela bizarre ou
difficile. Simplement, nous le faisons dans la vie quotidienne sans y penser. Et force de ne pas y penser, nous ne
remarquons mme plus quel mcanisme subtil dabstraction est ncessaire pour pratiquer ce sport.
Lorsque nous disons que 4+3=7 (ce qui reste, normalement, dans le domaine de comptence mathmatique de tous
ceux qui lisent ce cours !), nous manions de pures abstractions, reprsentes par de non moins purs symboles ! Un
tre humain dil y a quelques millnaires se serait demand longtemps quest-ce que cest que quatre ou trois ,
sans savoir quatre ou trois quoi ? . Mine de rien, le fait mme de concevoir des nombres, cest--dire de pouvoir
considrer, dans un ensemble, la quantit indpendamment de tout le reste, cest dj une abstraction trs hardie, qui
a mis trs longtemps avant de simposer tous comme une vidence. Et le fait de faire des additions sans devoir
prciser des additions de quoi ? , est un pas supplmentaire qui a t encore plus difficile franchir.
Le concept de nombre, de quantit pure, a donc constitu un immense progrs (que les ordinateurs nont quant eux,
toujours pas accompli). Mais si concevoir les nombres, cest bien ; possder un systme de notation performant de
ces nombres, cest encore mieux. Et l aussi, lhumanit a mis un certain temps (et essay un certain nombre de
pistes qui se sont rvles tre des impasses) avant de parvenir au systme actuel, le plus rationnel. Ceux qui ne sont
pas convaincus des progrs raliss en ce domaine peuvent toujours essayer de rsoudre une multiplication comme
587 x 644 en chiffres romains, on leur souhaite bon courage !
2. La numrotation de position en base dcimale

Lhumanit actuelle, pour reprsenter nimporte quel nombre, utilise un systme de numrotation de position, base
dcimale. Quest-ce qui se cache derrire cet obscur jargon ?
Commenons par la numrotation de position. Pour reprsenter un nombre, aussi grand soit-il, nous disposons dun
alphabet spcialis : une srie de 10 signes qui sappellent les chiffres. Et lorsque nous crivons un nombre en
mettant certains de ces chiffres les uns derrire les autres, lordre dans lequel nous mettons les chiffres est capital.
Ainsi, par exemple, 2 569 nest pas du tout le mme nombre que 9 562. Et pourquoi ? Quelle opration, quel
dcodage mental effectuons-nous lorsque nous lisons une suite de chiffres reprsentant un nombre ? Le problme,
cest que nous sommes tellement habitus faire ce dcodage de faon instinctive que gnralement nous nen
3
Cours Algorithmique
connaissons plus les rgles. Mais ce nest pas trs compliqu de les reconstituer Et cest l que nous mettons le
doigt en plein dans la deuxime caractristique de notre systme de notation numrique : son caractre dcimal.
Lorsque nous crivons 9562, de quel nombre est-ce que nous parlons ? Dcomposons la lecture chiffre par chiffre, de
gauche droite :
9562, cest 9000 + 500 + 60 + 2.
Allons plus loin, mme si cela parat un peu bbte :
9000
cest 9 x 1000
parce que le 9 est le quatrime chiffre en partant de la droite
500
cest 5 x 100
parce que le 5 est le troisime chiffre en partant de la droite
60
cest 6 x 10
parce que le 6 est le deuxime chiffre en partant de la droite
cest 2 x 1
parce que le 2 est le premier chiffre en partant de la droite
On peut encore crire ce mme nombre dune manire lgrement diffrente. Au lieu de :
9 562 = 9 x 1 000 + 5 x 100 + 6 x 10 + 2,
On crit que :
9 562 = (9 x 10 x 10 x 10) + (5 x 10 x 10) + (6 x 10) + (2)
Arrivs ce stade de la comptition, toutes nos excuses aux allergiques, mais il nous faut employer un petit peu de
jargon mathmatique. Ce nest pas grand-chose, et on touche au but. Alors, courage ! En fait, ce jargon se rsume au
fait que les matheux notent la ligne ci-dessus laide du symbole de puissance . Cela donne :
9 562 = 9 x 103 + 5 x 102 + 6 x 101 + 2 x 100
Et voil, nous y sommes. Nous avons dgag le mcanisme gnral de la reprsentation par numrotation de position
en base dcimale.
Alors, nous en savons assez pour conclure sur les consquences du choix de la base dcimale. Il y en a deux, qui
nen forment en fin de compte quune seule :
parce que nous sommes en base dcimale, nous utilisons un alphabet numrique de dix symboles. Nous
nous servons de dix chiffres, pas un de plus, pas un de moins.
toujours parce nous sommes en base dcimale, la position dun de ces dix chiffres dans un nombre dsigne
la puissance de dix par laquelle ce chiffre doit tre multipli pour reconstituer le nombre. Si je trouve un 7 en
cinquime position partir de la droite, ce 7 ne reprsente pas 7 mais 7 fois 104, soit 70000.
Un dernier mot concernant le choix de la base dix. Pourquoi celle-l et pas une autre ? Aprs tout, la base dix ntait
pas le seul choix possible. Les babyloniens, qui furent de brillants mathmaticiens, avaient en leur temps adopt la
base 60 (dite sexagsimale). Cette base 60 impliquait certes dutiliser un assez lourd alphabet numrique de 60
chiffres. Mais ctait somme toute un inconvnient mineur, et en retour, elle possdait certains avantages non
ngligeables. 60 tant un nombre divisible par beaucoup dautres (cest pour cette raison quil avait t choisi), on
pouvait, rien quen regardant le dernier chiffre, savoir si un nombre tait divisible par 2, 3, 4, 5, 6, 10, 12, 15, 20 et 30.
Alors quen base 10, nous ne pouvons immdiatement rpondre la mme question que pour les diviseurs 2 et 5. La
base sexagsimale a certes disparu en tant que systme de notation des nombres. Mais Babylone nous a laiss en
hritage sa base sexagsimale dans la division du cercle en soixante parties (pour compter le temps en minutes et
secondes),
et
celle
en
60
parties
(pour
les
degrs
de
la
gomtrie
et
de
lastronomie).
4
Cours Algorithmique
Alors, pourquoi avons-nous adopt la base dcimale, moins pratique bien des gards ? Nul doute que cela tienne au
dispositif matriel grce auquel tout tre humain normalement constitu stocke spontanment une information
numrique : ses doigts !
3. La numrotation de position en base binaire

Les ordinateurs, eux, comme on la vu, ont un dispositif physique fait pour stocker (de multiples faons) des
informations binaires. Alors, lorsquon reprsente une information stocke par un ordinateur, le plus simple est
dutiliser un systme de reprsentation deux chiffres : les fameux 0 et 1. Mais une fois de plus, le choix du 0 et du 1
est une pure convention, et on aurait pu choisir nimporte quelle autre paire de symboles leur place.
Dans un ordinateur, le dispositif qui permet de stocker de linformation est donc rudimentaire, bien plus rudimentaire
que les mains humaines. Avec des mains humaines, on peut coder dix choses diffrentes (en fait bien plus, si lon fait
des acrobaties avec ses doigts, mais cartons ce cas). Avec un emplacement dinformation dordinateur, on est limit
deux choses diffrentes seulement. Avec une telle information binaire, on ne va pas loin. Voil pourquoi, ds leur
invention, les ordinateurs ont t conus pour manier ces informations par paquets de 0 et de 1. Et la taille de ces
paquets a t fixe 8 informations binaires.
Une information binaire (symbolise couramment par 0 ou 1) sappelle un bit. Un groupe de huit bits
sappelle un octet (en anglais, byte)
Combien dtats diffrents un octet possde-t-il ? Le calcul est assez facile (mais il faut nanmoins savoir le refaire).
Chaque bit de loctet peut occuper deux tats. Il y a donc dans un octet :
2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 = 28 = 256 possibilits.
Cela signifie quun octet peut servir coder 256 nombres diffrents : ce peut tre la srie des nombres entiers de 1
256, ou de 0 255, ou de 127 +128. Cest une pure affaire de convention, de choix de codage. Mais ce qui nest
pas affaire de choix, cest le nombre de possibilits : elles sont 256, pas une de plus, pas une de moins, cause de ce
quest, par dfinition, un octet.
Si lon veut coder des nombres plus grands que 256, ou des nombres ngatifs, ou des nombres dcimaux, on va donc
tre contraint de mobiliser plus dun octet. Ce nest pas un problme, et cest trs souvent que les ordinateurs
procdent ainsi.
En effet, avec deux octets, on a 256 x 256 = 65 536 possibilits.
En utilisant trois octets, on passe 256 x 256 x 256 = 16 777 216 possibilits.
Et ainsi de suite, on ne mattardera pas davantage sur les diffrentes manires de coder les nombres avec des octets.
On abordera de nouveau brivement le sujet un peu plus loin.
Cela implique galement quun octet peut servir coder autre chose quun nombre : loctet est trs souvent employ
pour coder du texte. Il y a 26 lettres dans lalphabet. Mme en comptant diffremment les minuscules et les
5
Cours Algorithmique
majuscules, et mme en y ajoutant les chiffres et les signes de ponctuation, on arrive un total infrieur 256. Cela
veut dire que pour coder convenablement un texte, le choix dun caractre par octet est un choix pertinent.
Se pose alors le problme de savoir quel caractre doit tre reprsent par quel tat de loctet. Si ce choix tait
librement laiss chaque informaticien, ou chaque fabricant dordinateur, la communication entre deux ordinateurs
serait un vritable casse-tte. Loctet 10001001 serait par exemple traduit par une machine comme un T majuscule, et
par une autre comme une parenthse fermante ! Aussi, il existe un standard international de codage des caractres et
des signes de ponctuation. Ce standard stipule quel tat de loctet correspond quel signe du clavier. Il sappelle
lASCII (pour American Standard Code for Information Interchange). Et fort heureusement, lASCII est un standard
universellement reconnu et appliqu par les fabricants dordinateurs et de logiciels. Bien sr, se pose le problme des
signes propres telle ou telle langue (comme les lettres accentues en franais, par exemple). LASCII a par le
problme en rservant certains codes doctets pour ces caractres spciaux chaque langue. En ce qui concerne les
langues utilisant un alphabet non latin, un standard particulier de codage a t mis au point. Quant aux langues non
alphabtiques (comme le chinois), elles payent un lourd tribut linformatique pour navoir pas su voluer vers le
systme alphabtique
Revenons-en au codage des nombres sur un octet. Nous avons vu quun octet pouvait coder 256 nombres diffrents,
par exemple (cest le choix le plus spontan) la srie des entiers de 0 255. Comment faire pour, partir dun octet,
reconstituer le nombre dans la base dcimale qui nous est plus familire ? Ce nest pas sorcier ; il suffit dappliquer, si
on les a bien compris, les principes de la numrotation de position, en gardant lesprit que l, la base nest pas
dcimale, mais binaire. Prenons un octet au hasard :
11010011
Daprs les principes vus plus haut, ce nombre reprsente en base dix, en partant de la gauche :
1 x 27 + 1 x 2 6 + 0 x 2 5 + 1 x 2 4 + 0 x 2 3 + 0 x 2 2 + 1 x 2 1 + 1 x 2 0 =
1 x 128 + 1 x 64 + 1 x 16 + 1 x 2 + 1 x 1 =
128 + 64 + 16 + 2 + 1 =
211
Et voil ! Ce nest pas plus compliqu que cela !
Inversement, comment traduire un nombre dcimal en codage binaire ? Il suffit de rechercher dans notre nombre les
puissances successives de deux. Prenons, par exemple, 186.
Dans 186, on trouve 1 x 128, soit 1 x 27. On retranche 128 de 186 et on obtient 58.
Dans 58, on trouve 0 x 64, soit 0 x 26. On ne retranche donc rien.
6
Cours Algorithmique

Il ne nous reste plus qu reporter ces diffrents rsultats (dans lordre !) pour reconstituer loctet. On crit alors quen
binaire, 186 est reprsent par :
10111010
Cest bon ? Alors on passe la suite.
4. Le codage hexadcimal
Pour en finir avec ce prambule (sinon, cela deviendrait de la gourmandise), on va voquer un dernier type de codage,
qui constitue une alternative pratique au codage binaire. Il sagit du codage hexadcimal, autrement dit en base seize.
Pourquoi ce choix bizarre ? Tout dabord, parce que le codage binaire, ce nest tout de mme pas trs conomique, ni
trs lisible. Pas trs conomique : pour reprsenter un nombre entre 1 et 256, il faut utiliser systmatiquement huit
chiffres. Pas trs lisible : parce que dinterminables suites de 1 et de 0, on a dj vu plus folichon.
Alors, une alternative toute naturelle, ctait de reprsenter loctet non comme huit bits (ce que nous avons fait jusque
l), mais comme deux paquets de 4 bits (les quatre de gauche, et les quatre de droite). Voyons voir cela de plus prs.
Avec 4 bits, nous pouvons coder 2 x 2 x 2 x 2 = 16 nombres diffrents. En base seize, 16 nombres diffrents se
reprsentent avec un seul chiffre (de mme quen base 10, dix nombres se reprsentent avec un seul chiffre).
Quels symboles choisir pour les chiffres ? Pour les dix premiers, on na pas t chercher bien loin : on a recycl les dix
chiffres de la base dcimale. Les dix premiers nombres de la base seize scrivent donc tout btement 0, 1, 2, 3, 4, 5,
6, 7, 8, et 9. L, il nous manque encore 6 chiffres, pour reprsenter les nombres que nous crivons en dcimal 10, 11,
12, 13, 14 et 15. Plutt quinventer de nouveaux symboles (ce quon aurait trs bien pu faire), on a recycl les
premires lettres de lalphabet. Ainsi, par convention, A vaut 10, B vaut 11, etc. jusqu F qui vaut 15.
Or, on saperoit que cette base hexadcimale permet une reprsentation trs simple des octets du binaire. Prenons
un octet au hasard :
10011110
Pour convertir ce nombre en hexadcimal, il y a deux mthodes : lune consiste faire un grand dtour, en repassant
par la base dcimale. Cest un peu plus long, mais on y arrive. Lautre mthode consiste faire le voyage direct du
binaire vers lhexadcimal. Avec lhabitude, cest nettement plus rapide !
Premire mthode :
On retombe sur un raisonnement dj abord. Cet octet reprsente en base dix :
1 x 27 + 0 x 2 6 + 0 x 2 5 + 1 x 2 4 + 1 x 2 3 + 1 x 2 2 + 1 x 2 1 + 0 x 2 0 =
1 x 128 + 1 x 16 + 1 x 8 + 1 x 4 + 1 x 2 + 0 x 1 =
7
Cours Algorithmique
128 + 16 + 8 + 4 + 2 =
158
De l, il faut repartir vers la base hexadcimale.
Dans 158, on trouve 9 x 16, cest--dire 9 x 161. On retranche 144 de 158 et on obtient 14.
Dans 14, on trouve 14 x 1, cest--dire 14 x 160. On y est.
Le nombre scrit donc en hexadcimal : 9 E
Deuxime mthode :
Divisons 1 0 0 1 1 1 1 0 en 1 0 0 1 (partie gauche) et 1 1 1 0 (partie droite).
1 0 0 1, cest 8 + 1, donc 9
1 1 1 0, cest 8 + 4 + 2 donc 14
Le nombre scrit donc en hexadcimal : 9 E. Cest la mme conclusion quavec la premire mthode. Encore
heureux !
Le codage hexadcimal est trs souvent utilis quand on a besoin de reprsenter les octets
individuellement, car dans ce codage, tout octet correspond seulement deux signes.
Allez, assez bavard, on passe aux choses srieuses : les arcanes de lalgorithmique
8
Cours Algorithmique
INTRODUCTION A LALGORITHMIQUE
Un langage de programmation est une convention pour donner des ordres un ordinateur. Ce nest pas cens
tre obscur, bizarre et plein de piges subtils. a, ce sont les caractristiques de la magie.
Dave Small
C'est illogique, Capitaine

Mr Spock
Lalgorithmique est un terme dorigine arabe, comme algbre, amiral ou znith. Ce nest pas une excuse pour
massacrer son orthographe, ou sa prononciation.
Ainsi, lalgo nest pas rythmique , la diffrence du bon rockn roll. Lalgo nest pas non plus lagglo .
Alors, ne confondez pas lalgorithmique avec lagglo rythmique, qui consiste poser des parpaings en cadence.
1. Quest-ce que lalgomachin ?

Avez-vous dj ouvert un livre de recettes de cuisine ? Avez vous dj dchiffr un mode demploi traduit directement
du coren pour faire fonctionner un magntoscope ou un rpondeur tlphonique rticent ? Si oui, sans le savoir, vous
avez dj excut des algorithmes.
Plus fort : avez-vous dj indiqu un chemin un touriste gar ? Avez vous fait chercher un objet quelquun par
tlphone ? crit une lettre anonyme stipulant comment procder une remise de ranon ? Si oui, vous avez dj
fabriqu et fait excuter des algorithmes.
Comme quoi, lalgorithmique nest pas un savoir sotrique rserv quelques rares initis touchs par la grce
divine, mais une aptitude partage par la totalit de lhumanit. Donc, pas dexcuses
Un algorithme, cest une suite dinstructions qui, une fois excute correctement, conduit un rsultat donn. Si
lalgorithme est juste, le rsultat est le rsultat voulu, et le touriste se retrouve l o il voulait aller. Si lalgorithme est
faux, le rsultat est, disons, alatoire, et dcidment, cette saloperie de rpondeur ne veut rien savoir.
Compltons toutefois cette dfinition. Aprs tout, en effet, si lalgorithme, comme on vient de le dire, nest quune suite
dinstructions menant celui qui lexcute rsoudre un problme, pourquoi ne pas donner comme instruction unique :
9
Cours Algorithmique
rsous le problme , et laisser linterlocuteur se dbrouiller avec a ? A ce tarif, nimporte qui serait champion
dalgorithmique sans faire aucun effort. Pas de a, ce serait trop facile.
Le malheur (ou le bonheur, tout dpend du point de vue) est que justement, si le touriste vous demande son chemin,
cest quil ne le connat pas. Donc, si on nest pas un goujat intgral, il ne sert rien de lui dire de le trouver tout seul.
De mme les modes demploi contiennent gnralement (mais pas toujours) un peu plus dinformations que
dbrouillez vous pour que a marche .
Pour fonctionner, un algorithme doit donc contenir uniquement des instructions comprhensibles par celui qui devra
lexcuter. Cest dailleurs lun des points dlicats pour les rdacteurs de modes demploi : les rfrences culturelles,
ou lexicales, des utilisateurs, tant variables, un mme mode demploi peut tre trs clair pour certains et parfaitement
abscons pour dautres.
En informatique, heureusement, il ny a pas ce problme : les choses auxquelles on doit donner des instructions sont
les ordinateurs, et ceux-ci ont le bon got dtre tous strictement aussi idiots les uns que les autres.
2. Faut-il tre matheux pour tre bon en algorithmique ?

Consacrons quelques lignes cette question, car cette opinion aussi fortement affirme que faiblement fonde sert
rgulirement dexcuse : moi, de toute faon, je suis mauvais(e) en algo, jai jamais rien pig aux maths . Faut-il
tre bon en maths pour expliquer correctement son chemin quelquun ? Nous vous laissons juge.
La matrise de lalgorithmique requiert deux qualits, trs complmentaires dailleurs :
il faut avoir une certaine intuition, car aucune recette ne permet de savoir a priori quelles instructions
permettront dobtenir le rsultat voulu. Cest l, si lon y tient, quintervient la forme dintelligence requise
pour lalgorithmique. Alors, cest certain, il y a des gens qui possdent au dpart davantage cette intuition que
les autres. Cependant, les rflexes, cela sacquiert. Et ce quon appelle lintuition nest finalement que de
lexprience tellement rpte que le raisonnement, au dpart laborieux, finit par devenir spontan .
il faut tre mthodique et rigoureux. En effet, chaque fois quon crit une srie dinstructions quon croit justes,
il faut systmatiquement se mettre la place de la machine qui va les excuter, pour vrifier si le rsultat
obtenu est bien celui que lon voulait. Cette opration ne requiert pas la moindre once dintelligence. Mais elle
reste nanmoins indispensable, si lon ne veut pas crire laveuglette.
Et petit petit, force de pratique, vous verrez que vous pourrez faire de plus en plus souvent lconomie de cette
dernire tape : lexprience fera que vous verrez le rsultat 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 vrification de chacun de vos algorithmes doit tre considre comme
la moiti du travail accomplir.
10
Cours Algorithmique
3. LADN, les Shadoks, et les ordinateurs

Quel rapport, direz-vous ? Eh bien le point commun est : quatre mots de vocabulaire.
Lunivers lexical Shadok, cest bien connu, se limite aux termes Ga , Bu , Zo , et Meu . Ce qui leur a tout
de mme permis de formuler quelques fortes maximes, telles que : Mieux vaut pomper et quil ne se passe rien,
plutt quarrter de pomper et risquer quil se passe quelque chose de pire.

LADN, qui est en quelque sorte le programme gntique, lalgorithme la base de construction des tres vivants, est
une chane construite partir de quatre lments invariables. Ce nest que le nombre de ces lments, ainsi que
lordre dans lequel ils sont arrangs, qui vont dterminer si on obtient une puce ou un lphant. Et tous autant que
nous sommes, splendides russites de la Nature (nous sommes en Science profane), avons t construits par un
programme constitu uniquement de ces quatre briques, ce qui devrait nous inciter la modestie.
Enfin, les ordinateurs, quels quils soient, ne sont fondamentalement capables de comprendre que quatre catgories
d'ordres (en programmation, on n'emploiera pas le terme d'ordre, mais plutt celui d'instructions). Ces quatre familles
d'instructions sont :
laffectation de variables ;
la lecture / criture ;
les tests ;
les boucles.
Un algorithme informatique se ramne donc toujours au bout du compte la combinaison de ces quatre petites
briques de base. Il peut y en avoir quelques unes, quelques dizaines, et jusqu plusieurs centaines de milliers dans
certains programmes de gestion. Rassurez-vous, nous nirons pas jusque l (cependant, la taille dun algorithme ne
conditionne pas en soi sa complexit : de longs algorithmes peuvent tre finalement assez simples, et de petits trs
compliqus).
4. Algorithmique et programmation
Pourquoi apprendre lalgorithmique pour apprendre programmer ? En quoi a-t-on besoin dun langage spcial,
distinct des langages de programmation comprhensibles par les ordinateurs ?
Parce que lalgorithmique exprime les instructions rsolvant un problme donn indpendamment des particularits de
tel ou tel langage. Pour prendre une image, si un programme tait une dissertation, lalgorithmique serait le plan, une
fois mis de ct la rdaction et lorthographe. Or, vous savez quil vaut mieux faire dabord le plan et rdiger ensuite,
que linverse
Apprendre lalgorithmique, cest apprendre manier la structure logique dun programme informatique. Cette
dimension est prsente quelle que soit le langage de programmation ; mais lorsquon programme dans un langage (en
C, en Visual Basic, etc.) on doit en plus se colleter les problmes de syntaxe, ou de types dinstructions, propres ce
langage. Apprendre lalgorithmique de manire spare, cest donc srier les difficults pour mieux les vaincre.
11
Cours Algorithmique
A cela, il faut ajouter que des gnrations de programmeurs, souvent autodidactes (mais pas toujours, hlas !), ayant
directement appris programmer dans tel ou tel langage, ne font pas mentalement clairement la diffrence entre ce
qui relve de la structure logique gnrale de toute programmation (les rgles fondamentales de lalgorithmique) et ce
qui relve du langage particulier quils ont appris. Ces programmeurs, non seulement ont beaucoup plus de mal
passer ensuite un langage diffrent, mais encore crivent bien souvent des programmes qui mme sils sont justes,
restent laborieux. Car on nignore pas impunment les rgles fondamentales de lalgorithmique Alors, autant
lapprendre en tant que telle !
Bon, maintenant passons au vif du sujet
5. Avec quelles conventions crit-on un algorithme ?

Historiquement, plusieurs types de notations ont reprsent des algorithmes.
Il y a eu notamment une reprsentation graphique, avec des carrs, des losanges, etc. quon appelait des
organigrammes. Aujourdhui, cette reprsentation est quasiment abandonne, pour deux raisons. Dabord, parce que
ds que lalgorithme commence grossir un peu, ce nest plus pratique du tout du tout. Ensuite parce que cette
reprsentation favorise le glissement vers un certain type de programmation, dite non structure (nous dfinirons ce
terme plus tard), que lon tente au contraire dviter.
Cest pourquoi on utilise gnralement une srie de conventions appele pseudo-code , qui ressemble un
langage de programmation authentique dont on aurait vacu la plupart des problmes de syntaxe. Ce pseudo-code
est susceptible de varier lgrement dun livre (ou dun enseignant) un autre. Cest bien normal : le pseudo-code,
encore une fois, est purement conventionnel ; aucune machine nest cense le reconnatre. Donc, chaque cuisinier
peut faire sa sauce sa guise, avec ses petites pices bien lui, sans que cela prte consquence.
Le pseudo-code que vous dcouvrirez dans les pages qui suivent possde quelques spcificits mineures.
Rassurez-vous cependant, celles-ci restent dans les limites tout fait acceptables.
12
Cours Algorithmique
PARTIE 1 (LES VARIABLES)

Nattribuez jamais la malveillance ce qui sexplique trs bien par lincomptence.
Napolon Bonaparte
A lorigine de toute erreur attribue lordinateur, vous trouverez au moins deux erreurs humaines. Dont
celle consistant attribuer lerreur lordinateur.
Anonyme
1. A quoi servent les variables ?

Dans un programme informatique, on va avoir en permanence besoin de stocker provisoirement des valeurs. Il peut
sagir de donnes issues du disque dur, fournies par lutilisateur (frappes au clavier), etc. Il peut aussi sagir de
rsultats obtenus par le programme, intermdiaires ou dfinitifs. Ces donnes peuvent tre de plusieurs types (on en
reparlera) : elles peuvent tre des nombres, du texte, etc. Toujours est-il que ds que lon a besoin de stocker une
information au cours dun programme, on utilise une variable.
Pour employer une image, une variable est une bote, que le programme (lordinateur) va reprer par une tiquette.
Pour avoir accs au contenu de la bote, il suffit de la dsigner par son tiquette.
En ralit, dans la mmoire vive de lordinateur, il ny a bien sr pas une vraie bote, et pas davantage de vraie
tiquette colle dessus. Dans lordinateur, physiquement, il y a un emplacement de mmoire, repr par une adresse
binaire. Si on programmait dans un langage directement comprhensible par la machine, on devrait se fader de
dsigner nos donnes par de superbes 10011001 et autres 01001001 (enchant !). Mauvaise nouvelle : de tels
langages existent ! Ils portent le doux nom dassembleur. Bonne nouvelle : ce ne sont pas les seuls langages
disponibles.
Les langages informatiques plus volus (ce sont ceux que presque tout le monde emploie) se chargent prcisment,
entre autres rles, dpargner au programmeur la gestion fastidieuse des emplacements mmoire et de leurs
adresses. Et, comme vous commencez le comprendre, il est beaucoup plus facile demployer les tiquettes de son
choix, que de devoir manier des adresses binaires.
2. Dclaration des variables

La premire chose faire avant de pouvoir utiliser une variable est de crer la bote et de lui coller une tiquette. Ceci
se fait tout au dbut de lalgorithme, avant mme les instructions proprement dites. Cest ce quon appelle la
dclaration des variables. Cest un genre de dclaration certes moins romantique quune dclaration damour, mais
dun autre ct moins dsagrable quune dclaration dimpts.
Le nom de la variable (ltiquette de la bote) obit des impratifs changeant selon les langages. Toutefois, une rgle
absolue est quun nom de variable peut comporter des lettres et des chiffres, mais quil exclut la plupart des signes de
ponctuation, en particulier les espaces. Un nom de variable correct commence galement imprativement par une
lettre. Quant au nombre maximal de signes pour un nom de variable, il dpend du langage utilis.
13
Cours Algorithmique
En pseudo-code algorithmique, on est bien sr libre du nombre de signes pour un nom de variable, mme si pour des
raisons purement pratiques, on vite gnralement les noms rallonge.
Lorsquon dclare une variable, il ne suffit pas de crer une bote (rserver un emplacement mmoire) ; encore doit-on
prciser ce que lon voudra mettre dedans, car de cela dpendent la taille de la bote (de lemplacement mmoire) et le
type de codage utilis.
2.1. Types numriques classiques

Commenons par le cas trs frquent, celui dune variable destine recevoir des nombres.
Si lon rserve un octet pour coder un nombre, en rappel on ne pourra coder que 28 = 256 valeurs diffrentes. Cela
peut signifier par exemple les nombres entiers de 1 256, ou de 0 255, ou de 127 +128 Si lon rserve deux
octets, on a droit 65 536 valeurs ; avec trois octets, 16 777 216, etc. Et l se pose un autre problme : ce codage
doit-il reprsenter des nombres dcimaux ? des nombres ngatifs ?
Bref, le type de codage (autrement dit, le type de variable) choisi pour un nombre va dterminer :
les valeurs maximales et minimales des nombres pouvant tre stocks dans la variable
la prcision de ces nombres (dans le cas de nombres dcimaux).
Tous les langages, quels quils soient offrent un bouquet de types numriques, dont le dtail est susceptible de
varier lgrement dun langage lautre. Grosso modo, on retrouve cependant les types suivants :
Type Numrique
Plage
Byte (octet)
0 255
Entier simple
-32 768 32 767
Entier long
-2 147 483 648 2 147 483 647
Rel simple
Rel double
-3,40x1038 -1,40x1045 pour les valeurs ngatives

1,40x10-45 3,40x1038 pour les valeurs positives
1,79x10308 -4,94x10-324 pour les valeurs ngatives
4,94x10-324 1,79x10308 pour les valeurs positives
Pourquoi ne pas dclarer toutes les variables numriques en rel double, histoire de btonner et
dtre certain quil ny aura pas de problme ? En vertu du principe de lconomie de moyens.
Un bon algorithme ne se contente pas de marcher ; il marche en vitant de gaspiller les
ressources de la machine. Sur certains programmes de grande taille, labus de variables
surdimensionnes peut entraner des ralentissements notables lexcution, voire un plantage
pur et simple de lordinateur. Alors, autant prendre ds le dbut de bonnes habitudes dhygine.
En algorithmique, on ne se tracassera pas trop avec les sous-types de variables numriques. On se contentera donc
de prciser qu'il s'agit d'un nombre, en gardant en tte que dans un vrai langage, il faudra tre plus prcis.
14
Cours Algorithmique
En pseudo-code, une dclaration de variables aura ainsi cette tte :

Variable g en Numrique
Ou encore
Variables PrixHT, TauxTVA, PrixTTC en Numrique
2.2. Autres types numriques

Certains langages autorisent dautres types numriques, notamment :
le type montaire (avec strictement deux chiffres aprs la virgule)

le type date (jour / mois / anne).
Nous nemploierons pas ces types dans ce cours ; mais vous ne manquerez pas de les rencontrer en
programmation proprement dite.
2.3. Type alphanumrique

Fort heureusement, les botes que sont les variables peuvent contenir bien dautres informations que des nombres.
Sans cela, on serait un peu embt ds que lon devrait stocker un nom de famille, par exemple.
On dispose donc galement du type alphanumrique (galement appel type caractre, type chane ou en anglais, le
type string ). Dans une variable de ce type, on stocke des caractres, quil sagisse de lettres, de signes de
ponctuation, despaces, ou mme de chiffres. Le nombre maximal de caractres pouvant tre stocks dans une seule
variable string dpend du langage utilis. Un groupe de caractres (y compris un groupe de un, ou de zro
caractres), quil soit ou non stock dans une variable, dailleurs, est donc souvent appel chane de caractres.
En pseudo-code, une chane de caractres est toujours note entre guillemets

Pourquoi ? Pour viter deux sources principales de possibles confusions :
la confusion entre des nombres et des suites de chiffres. Par exemple, 423 peut reprsenter le nombre 423
(quatre cent vingt-trois), ou la suite de caractres 4, 2, et 3. Et ce nest pas du tout la mme chose ! Avec le
premier, on peut faire des calculs, avec le second, point du tout. Ds lors, les guillemets permettent dviter
toute ambigut : sil ny en a pas, 423 est quatre cent vingt trois. Sil y en a, "423" reprsente la suite des
chiffres 4, 2, 3.
Mais ce n'est pas le pire. L'autre confusion, bien plus grave - et bien plus frquente consiste se mlanger
les pinceaux entre le nom d'une variable et son contenu. Pour parler simplement, cela consiste confondre
l'tiquette d'une bote et ce qu'il y a l'intrieur On reviendra sur ce point crucial dans quelques instants.
15
Cours Algorithmique
2.4. Type boolen

Le dernier type de variables est le type boolen : on y stocke uniquement les valeurs logiques VRAI et FAUX.
On peut reprsenter ces notions abstraites de VRAI et de FAUX par tout ce qu'on veut : de l'anglais (TRUE et FALSE)
ou des nombres (0 et 1). Peu importe. Ce qui compte, c'est de comprendre que le type boolen est trs conomique
en termes de place mmoire occupe, puisque pour stocker une telle information binaire, un seul bit suffit.
Le type boolen est trs souvent nglig par les programmeurs, tort.
Il est vrai qu'il n'est pas proprement parler indispensable, et qu'on pourrait crire peu prs
nimporte quel programme en l'ignorant compltement. Pourtant, si le type boolen est mis
disposition des programmeurs dans tous les langages, ce n'est pas pour rien. Le recours aux
variables boolennes s'avre trs souvent un puissant instrument de lisibilit des algorithmes :
il peut faciliter la vie de celui qui crit l'algorithme, comme de celui qui le relit pour le corriger.
Alors, maintenant, c'est certain, en algorithmique, il y a une question de style : c'est exactement
comme dans le langage courant, il y a plusieurs manires de s'exprimer pour dire sur le fond la
mme chose. Nous verrons plus loin diffrents exemples de variations stylistiques autour d'une
mme solution. En attendant, vous tes prvenus : l'auteur de ce cours est un adepte fervent
(mais pas irraisonn) de l'utilisation des variables boolennes.
3. Linstruction daffectation
3.1. Syntaxe et signification
Abordons maintenant nos premires vritables manipulations dalgorithmique. Pas trop tt, certes, mais pas moyen de
faire autrement !
En fait, la variable (la bote) n'est pas un outil bien sorcier manipuler. On ne peut pas faire trente-six mille choses
avec une variable, mais seulement une et une seule.
Cette seule chose quon puisse faire avec une variable, cest laffecter, cest--dire lui attribuer une valeur. Pour
poursuivre la superbe mtaphore file dj employe, on peut remplir la bote.
En pseudo-code, l'instruction d'affectation se note avec le signe

Ainsi :
Toto
24
16
Cours Algorithmique
Attribue la valeur 24 la variable Toto.

Ceci, soit dit en passant, sous-entend imprativement que Toto soit une variable de type numrique. Si Toto a t
dfini dans un autre type, il faut bien comprendre que cette instruction provoquera une erreur. Cest un peu comme si,
en donnant un ordre quelquun, on accolait un verbe et un complment incompatibles, du genre Epluchez la
casserole . Mme dote de la meilleure volont du monde, la mnagre lisant cette phrase ne pourrait quinterrompre
dubitativement sa tche. Alors, un ordinateur, vous pensez bien
On peut en revanche sans aucun problme attribuer une variable la valeur dune autre variable, telle quelle ou
modifie. Par exemple :
Tutu
Toto
Signifie que la valeur de Tutu est maintenant celle de Toto.

Notez bien que cette instruction na en rien modifi la valeur de Toto : une instruction daffectation ne modifie que ce
qui est situ gauche de la flche.
Tutu
Toto + 4
Si Toto contenait 12, Tutu vaut maintenant 16. De mme que prcdemment, Toto vaut toujours 12.
Tutu
Tutu + 1
Si Tutu valait 6, il vaut maintenant 7. La valeur de Tutu est modifie, puisque Tutu est la variable situe gauche de la
flche.
Pour revenir prsent sur le rle des guillemets dans les chanes de caractres et sur la confusion numro 2 signale
plus haut, comparons maintenant deux algorithmes suivants :
Exemple n1
Dbut
Exemple n2
Dbut
Riri
"Loulou"
Riri
"Loulou"
Fifi
"Riri"
Fifi
Riri
Fin
Fin
La seule diffrence entre les deux algorithmes consiste dans la prsence ou dans labsence des guillemets lors de la
seconde affectation. Et l'on voit que cela change tout !
Dans l'exemple n1, ce que l'on affecte la variable Fifi, c'est la suite de caractres R i r - i. Et la fin de
lalgorithme, le contenu de la variable Fifi est donc Riri .
Dans l'exemple n2, en revanche, Riri tant dpourvu de guillemets, n'est pas considr comme une suite de
caractres, mais comme un nom de variable. Le sens de la ligne devient donc : affecte la variable Fifi le contenu
de la variable Riri . A la fin de lalgorithme n2, la valeur de la variable Fifi est donc Loulou . Ici, loubli des
guillemets conduit certes un rsultat, mais un rsultat diffrent.
17
Cours Algorithmique
A noter, car cest un cas trs frquent, que gnralement, lorsquon oublie les guillemets lors dune affectation de
chane, ce qui se trouve droite du signe daffectation ne correspond aucune variable prcdemment dclare et
affecte. Dans ce cas, loubli des guillemets se solde immdiatement par une erreur dexcution.
Ceci est une simple illustration. Mais elle rsume lensemble des problmes qui surviennent lorsquon oublie la rgle
des guillemets aux chanes de caractres.
3.2. Ordre des instructions

Il va de soi que lordre dans lequel les instructions sont crites va jouer un rle essentiel dans le rsultat final.
Considrons les deux algorithmes suivants :
Variable A en Entier
Dbut
Dbut
34
12
12
34
Fin
Fin
Il est clair que dans le premier cas la valeur finale de A est 12, dans lautre elle est 34.
Il est tout aussi clair que ceci ne doit pas nous tonner. Lorsquon indique le chemin quelquun, dire prenez tout
droit sur 1 km, puis droite nenvoie pas les gens au mme endroit que si lon dit prenez droite puis tout droit
pendant 1 km .
Enfin, il est galement clair que si lon met de ct leur vertu pdagogique, les deux algorithmes ci-dessus sont
parfaitement idiots ; tout le moins ils contiennent une incohrence. Il ny a aucun intrt affecter une variable pour
laffecter diffremment juste aprs. En loccurrence, on aurait tout aussi bien atteint le mme rsultat en
crivant simplement :
Dbut
A
Dbut
12
Fin
34
Fin
Tous les lments sont maintenant en votre possession pour que ce soit vous de jouer !
Exercice 1.1
Quelles seront les valeurs des variables A et B aprs excution des instructions
suivantes ?
Variables A, B en Entier
Dbut
A 1
B A + 3
A 3
Fin
18
Cours Algorithmique
Exercice 1.2
Quelles seront les valeurs des variables A, B et C aprs excution des
instructions suivantes ?
Variables A, B, C en Entier
Dbut
A 5
B 3
C A + B
A 2
C B A
Fin
Exercice 1.3
suivantes ?
Dbut
A 5
B A + 4
A A + 1
B A 4
Fin
Exercice 1.4
Quelles seront les valeurs des variables A, B et C aprs excution des
instructions suivantes ?
Variables A, B, C en Entier
Dbut
A 3
B 10
C A + B
B A + B
A C
Fin
Exercice 1.5
suivantes ?
Dbut
A 5
B 2
19
Cours Algorithmique
A B
B A
Fin
Moralit : les deux dernires instructions permettent-elles dchanger les deux

valeurs de B et A ? Si lon inverse les deux dernires instructions, cela changet-il quelque chose ?
Exercice 1.6
Plus difficile, mais cest un classique absolu, quil faut absolument matriser :
crire un algorithme permettant dchanger les valeurs de deux variables A et
B, et ce quel que soit leur contenu pralable.
Exercice 1.7
Une variante du prcdent : on dispose de trois variables A, B et C. Ecrivez un
algorithme transfrant B la valeur de A, C la valeur de B et A la valeur de
C (toujours quels que soient les contenus pralables de ces variables).
4. Expressions et oprateurs
Si on fait le point, on saperoit que dans une instruction daffectation, on trouve :
gauche de la flche, un nom de variable, et uniquement cela. En ce monde empli de doutes quest celui de
lalgorithmique, cest une des rares rgles dor qui marche tous les coups : si on voit gauche dune flche
daffectation autre chose quun nom de variable, on peut tre certain 100% quil sagit dune erreur.
droite de la flche, ce quon appelle une expression. Voil encore un mot qui est trompeur ; en effet, ce mot
existe dans le langage courant, o il revt bien des significations. Mais en informatique, le terme dexpression
ne dsigne quune seule chose, et qui plus est une chose trs prcise :
Une expression est un ensemble de valeurs, relies par des oprateurs, et quivalent une seule
valeur
Cette dfinition vous parat peut-tre obscure. Mais rflchissez-y quelques minutes, et vous verrez quelle recouvre
quelque chose dassez simple sur le fond. Par exemple, voyons quelques expressions de type numrique. Ainsi :
7
5+4
123-45+844
Toto-12+5-Riri
sont des expressions valides, pour peu que Toto et Riri soient bien des nombres. Car dans le cas contraire, la
quatrime expression na pas de sens. En loccurrence, les oprateurs employs sont laddition (+) et la soustraction (-
20
Cours Algorithmique
).
Revenons pour le moment sur laffectation. Une condition supplmentaire (en plus des deux prcdentes) de validit
dune instruction daffectation est que :
lexpression situe droite de la flche soit du mme type que la variable situe gauche. Cest trs
logique : on ne peut pas ranger convenablement des outils dans un sac provision, ni des lgumes dans
une trousse outils sauf provoquer un rsultat catastrophique.
Si lun des trois points numrs ci-dessus nest pas respect, la machine sera incapable dexcuter laffectation, et
dclenchera une erreur (est-il besoin de dire que si aucun de ces points nest respect, il y aura aussi erreur !)
On va maintenant dtailler ce que lon entend par le terme doprateur.
Un oprateur est un signe qui relie deux valeurs, pour produire un rsultat.
Les oprateurs possibles dpendent du type des valeurs qui sont en jeu. Allons-y, faisons le tour, cest un peu
fastidieux, mais comme dit le sage au petit scarabe, quand cest fait, cest plus faire.
4.1. Oprateurs numriques :

Ce sont les quatre oprations arithmtiques, tout ce quil y a de classique.
+
addition ;
soustraction ;
multiplication ;
division.
Mentionnons galement le ^ qui signifie puissance . 45 au carr scrira donc 45 ^ 2.

Enfin, on a le droit dutiliser les parenthses, avec les mmes rgles quen mathmatiques. La multiplication et la
division ont naturellement priorit sur laddition et la soustraction. Les parenthses ne sont ainsi utiles que pour
modifier cette priorit naturelle.
Cela signifie quen informatique, 12 * 3 + 5 et (12 * 3) + 5 valent strictement la mme chose, savoir 41. Pourquoi ds
lors se fatiguer mettre des parenthses inutiles ?
En revanche, 12 * (3 + 5) vaut 12 * 8 soit 96. Rien de difficile l-dedans, que du normal.
4.2. Oprateur alphanumrique : &

Cet oprateur permet de concatner, autrement dit dagglomrer, deux chanes de caractres.
Exemple
Variables A, B, C en Caractre
Dbut
A Gloubi
B Boulga
C A & B
Fin
La valeur de C la fin de lalgorithme est GloubiBoulga
21
Cours Algorithmique
4.3. Oprateurs logiques (ou boolens) :

Il sagit du ET, du OU, du NON et du mystrieux (mais rarissime XOR). Nous les laisserons de ct provisoirement,
soyez-en srs.
Exercice 1.8
Que produit lalgorithme suivant ?
Variables A, B, C en Caractres
Dbut
A 423
B 12
C A + B
Fin
Exercice 1.9
Variables A, B en Caractres
Dbut
A 423
B 12
C A & B
Fin
5. Deux remarques pour terminer

Maintenant que nous sommes familiers des variables et que nous les manipulons les yeux ferms (mais les neurones
en veil, toutefois), nous attirons votre attention sur la trompeuse similitude de vocabulaire entre les mathmatiques et
linformatique. En mathmatiques, une variable est gnralement une inconnue, qui recouvre un nombre non
prcis de valeurs. Lorsquon crit :
y=3x+2
les variables x et y satisfaisant lquation existent en nombre infini (graphiquement, lensemble des solutions
cette quation dessine une droite). Lorsquon crit :
ax + bx + c = 0
la variable x dsigne les solutions cette quation, cest--dire zro, une ou deux valeurs la fois.
22
Cours Algorithmique
En informatique, une variable possde un moment donn une valeur et une seule. A la rigueur, elle peut ne pas
avoir de valeur du tout (une fois quelle a t dclare, et tant quon ne la pas affecte. A signaler que dans certains
langages, les variables non encore affectes sont considres comme valant automatiquement zro). Mais ce qui est
important, cest que cette valeur justement, ne varie pas proprement parler. Du moins ne varie-t-elle que
lorsquelle est lobjet dune instruction daffectation.
La deuxime remarque concerne le signe de laffectation. En algorithmique, comme on la vu, cest le . Mais en
pratique, la quasi totalit des langages emploient le signe gal =. Et l, pour les dbutants, la confusion avec les
maths est galement facile. En maths, A = B et B = A sont deux propositions strictement quivalentes. En
informatique, absolument pas, puisque cela revient crire A B et B A, deux choses bien diffrentes. De mme,
A = A + 1, qui en mathmatiques, constitue une quation sans solution, reprsente en programmation une action tout
fait licite (et de surcrot extrmement courante). Donc, attention ! ! ! La meilleure des vaccinations contre cette
confusion consiste bien employer le signe en pseudo-code, signe qui a le mrite de ne pas laisser place
lambigut. Une fois acquis les bons rflexes avec ce signe, vous naurez plus aucune difficult passer au = des
langages de programmation.
23
Cours Algorithmique
PARTIE 2 (LECTURE ET CRITURE)

Un programme est un sort jet sur un ordinateur, qui transforme tout texte saisi au clavier en message
derreur.
Anonyme
Un clavier Azerty en vaut deux

Anonyme
1. De quoi parle-t-on ?
Trifouiller des variables en mmoire vive par un chouette programme, cest vrai que cest trs marrant, et dailleurs on
a tous bien rigol au chapitre prcdent. Cela dit, la fin de la foire, on peut tout de mme se demander quoi a sert.
En effet. Imaginons que nous ayons fait un programme pour calculer le carr dun nombre, mettons 12. Si on a fait au
plus simple, on a crit un truc du genre :
Variable A en Numrique
Dbut
A
12^2
Fin
Dune part, ce programme nous donne le carr de 12. Cest trs gentil lui. Mais si lon veut le carr dun autre
nombre que 12, il faut rcrire le programme. Bof.
Dautre part, le rsultat est indubitablement calcul par la machine. Mais elle le garde soigneusement pour elle, et le
pauvre utilisateur qui fait excuter ce programme, lui, ne saura jamais quel est le carr de 12. Re-bof.
Cest pourquoi, heureusement, il existe des instructions pour permettre la machine de dialoguer avec lutilisateur (et
au Lyce de Versailles, et ajout lestim Pierre Dac, qui en prcurseur mconnu de lalgorithmique, affirmait tout
aussi profondment que rien ne sert de penser, il faut rflchir avant ).
Dans un sens, ces instructions permettent lutilisateur de rentrer des valeurs au clavier pour quelles soient utilises
par le programme. Cette opration est la lecture.
Dans lautre sens, dautres instructions permettent au programme de communiquer des valeurs lutilisateur en les
affichant lcran. Cette opration est lcriture.
Remarque essentielle : A premire vue, on peut avoir limpression que les informaticiens taient beurrs comme des
petits lus lorsquils ont baptis ces oprations ; puisque quand lutilisateur doit crire au clavier, on appelle a la
lecture, et quand il doit lire sur lcran on appelle lcriture. Mais avant dagonir dinsultes une digne corporation, il
faut rflchir un peu plus loin. Un algorithme, cest une suite dinstructions qui programme la machine, pas lutilisateur !
Donc quand on dit la machine de lire une valeur, cela implique que lutilisateur va devoir crire cette valeur. Et quand
24
Cours Algorithmique
on demande la machine dcrire une valeur, cest pour que lutilisateur puisse la lire. Lecture et criture sont donc
des termes qui comme toujours en programmation, doivent tre compris du point de vue de la machine qui sera
charge de les excuter. Et l, tout devient parfaitement logique.
2. Les instructions de lecture et dcriture

Tout btement, pour que lutilisateur entre la (nouvelle) valeur de Titi, on mettra :
Lire Titi
Ds que le programme rencontre une instruction Lire, lexcution sinterrompt, attendant la frappe
dune valeur au clavier
Ds lors, aussitt que la touche Entre (Enter) a t frappe, lexcution reprend.
Dans le sens inverse, pour crire quelque chose lcran, cest aussi simple que :
Ecrire Toto
Avant de Lire une variable, il est trs fortement conseill dcrire des libells lcran, afin de prvenir lutilisateur de
ce quil doit frapper (sinon, le pauvre utilisateur passe son temps se demander ce que lordinateur attend de lui et
cest trs dsagrable !) :
Ecrire Entrez votre nom :
Lire NomFamille
Lecture et Ecriture sont des instructions algorithmiques qui ne prsentent pas de difficults particulires, une fois quon
a bien assimil ce problme du sens du dialogue (homme machine, ou machine homme).
25
Cours Algorithmique
Exercice 2.1
Quel rsultat produit le programme suivant ?
Variables val, double numriques
Dbut
Val 231
Double Val * 2
Ecrire Val
Ecrire Double
Fin
Exercice 2.2
Ecrire un programme qui demande un nombre lutilisateur, puis qui calcule et affiche le
carr de ce nombre.
Exercice 2.3
Ecrire un programme qui lit le prix HT dun article, le nombre darticles et le taux de TVA,
et qui fournit le prix total TTC correspondant. Faire en sorte que des libells apparaissent
clairement.
Exercice 2.4
Ecrire un algorithme utilisant des variables de type chane de caractres, et affichant
quatre variantes possibles de la clbre belle marquise, vos beaux yeux me font mourir
damour . On ne se soucie pas de la ponctuation, ni des majuscules.
26
Cours Algorithmique
PARTIE 3 (LES TESTS)

Cest assez difficile de trouver une erreur dans son code quand on la cherche. Cest encore bien plus dur quand
on est convaincu que le code est juste.
Steve McConnell
Il nexiste pas, et il nexistera jamais, de langage dans lequel il soit un tant soit peu difficile dcrire de mauvais
programmes .
Anonyme
Si le dboguage est lart denlever les bogues, alors la programmation doit tre lart de les crer.
Anonyme
On avait dit que lalgorithmique, cest la combinaison de quatre structures lmentaires. Nous en avons dj vu deux,
voici la troisime. Autrement dit, on a quasiment fini le programme.
Mais non, on rigole.
1. De quoi sagit-il ?
Reprenons le cas de notre programmation algorithmique du touriste gar . Normalement, lalgorithme ressemblera
quelque chose comme : Allez tout droit jusquau prochain carrefour, puis prenez droite et ensuite la deuxime
gauche, et vous y tes .
Mais en cas de doute lgitime de votre part, cela pourrait devenir : Allez tout droit jusquau prochain carrefour et l
regardez droite. Si la rue est autorise la circulation, alors prenez la et ensuite cest la deuxime gauche. Mais si
en revanche elle est en sens interdit, alors continuez jusqu la prochaine droite, prenez celle-l, et ensuite la
premire droite .
Ce deuxime algorithme a ceci de suprieur au premier quil prvoit, en fonction dune situation pouvant se prsenter
de deux faons diffrentes, deux faons diffrentes dagir. Cela suppose que linterlocuteur (le touriste) sache analyser
la condition que nous avons fixe son comportement ( la rue est-elle en sens interdit ? ) pour effectuer la srie
dactions correspondante.
Eh bien, croyez le ou non, mais les ordinateurs possdent cette aptitude, sans laquelle dailleurs nous aurions bien du
mal les programmer. Nous allons donc pouvoir parler notre ordinateur comme notre touriste, et lui donner des
sries dinstructions effectuer selon que la situation se prsente dune manire ou dune autre. Cette structure
logique rpond au doux nom de test. Toutefois, ceux qui tiennent absolument briller en socit parleront galement
de structure alternative.
27
Cours Algorithmique
2. Structure dun test

Il ny a que deux formes possibles pour un test ; la forme de gauche est la forme complte, celle de droite la forme
simple.
Si boolen Alors
Instructions 1
Sinon
Si boolen Alors
Instructions
Finsi
Instructions 2
Finsi
Ceci appelle quelques explications.

Un boolen est une expression dont la valeur est VRAI ou FAUX. Cela peut donc tre (il ny a que deux possibilits) :
une variable de type boolen ;
une condition.
Nous reviendrons dans quelques instants sur ce quest une condition en informatique.
Toujours est-il que la structure dun test est relativement claire. Arriv la premire ligne (SiAlors) la machine
examine la valeur du boolen. Si ce boolen a pour valeur VRAI, elle excute la srie dinstructions 1. Cette srie
dinstructions peut tre trs brve comme trs longue, cela na aucune importance. A la fin de cette srie
dinstructions, au moment o elle arrive au mot Sinon , la machine saute directement la premire instruction
situe aprs le Finsi . De mme, au cas o le boolen a comme valeur Faux , la machine saute directement la
premire ligne situe aprs le Sinon et excute lensemble des instructions 2 .
La forme simplifie correspond au cas o lune des deux branches du Si est vide. Ds lors, plutt qucrire sinon
ne rien faire du tout , il est plus simple de ne rien crire.
Exprim sous forme de pseudo-code, la programmation de notre touriste de tout lheure donnerait donc quelque
chose du genre :
Allez tout droit jusquau prochain carrefour

Si la rue droite est autorise la circulation Alors
Tournez droite
Avancez
Prenez la deuxime gauche
Sinon
Continuez jusqu la prochaine rue droite
Prenez cette rue
Prenez la premire droite
Finsi
28
Cours Algorithmique
3. Quest ce quune condition ?

Une condition est une comparaison
Cette dfinition est essentielle ! Elle signifie quune condition est compose de trois lments :
une valeur ;
un oprateur de comparaison ;
une autre valeur.
Les valeurs peuvent tre a priori de nimporte quel type (numriques, caractres). Mais si lon veut que la
comparaison ait un sens, il faut que les deux valeurs de la comparaison soient du mme type !
Les oprateurs de comparaison sont :
gal ;
<>
diffrent de ;
<
strictement plus petit que ;
>
strictement plus grand que ;
=<
plus petit ou gal ;
>=
plus grand ou gal
Lensemble des trois lments constituant la condition constitue donc, si lon veut, une affirmation qui, un moment
donn, est VRAIE ou FAUSSE.
A noter que ces oprateurs de comparaison peuvent tout fait semployer avec des caractres. Ceux-ci sont cods
par la machine dans lordre alphabtique (rappelez vous le code ASCII vu dans le prambule), les majuscules tant
systmatiquement places avant les minuscules. Ainsi on a :
t < w
Maman > Papa
maman > Papa
VRAI
FAUX
VRAI
REMARQUE TRS IMPORTANTE

En formulant une condition dans un algorithme, il faut se mfier comme de la peste de certains
raccourcis du langage courant, ou de certaines notations valides en mathmatiques, mais qui
mnent des non-sens informatiques. Prenons par exemple la phrase Toto est compris entre
5 et 8 . On peut tre tent de la traduire par : 5 < Toto < 8.
Or, une telle expression, qui a du sens en franais, comme en mathmatiques, ne veut rien
dire en programmation. En effet, elle comprend deux oprateurs de comparaison, soit un de
trop, et trois valeurs, soit l aussi une de trop. On va voir dans un instant comment traduire
convenablement une telle condition.
29
Cours Algorithmique
Exercice 3.1
Ecrire un algorithme qui demande un nombre lutilisateur, et linforme ensuite si
ce nombre est positif ou ngatif (on laisse de ct le cas o le nombre vaut zro).
4. Conditions composes
Certains problmes exigent parfois de formuler des conditions qui ne peuvent pas tre exprimes sous la forme simple
expose ci-dessus. Reprenons le cas Toto est inclus entre 5 et 8 . En fait cette phrase cache non une, mais deux
conditions. Car elle revient dire que Toto est suprieur 5 et Toto est infrieur 8 . Il y a donc bien l deux
conditions, relies par ce quon appelle un oprateur logique, le mot ET.
Comme on la voqu plus haut, linformatique met notre disposition quatre oprateurs logiques : ET, OU, NON, et
XOR.
Le ET a le mme sens en informatique que dans le langage courant. Pour que :

Condition1 ET Condition2
soit VRAI, il faut imprativement que Condition1 soit VRAI et que Condition2 soit VRAI.
Il faut se mfier 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 est VRAIE. Le OU
informatique ne veut donc pas dire ou bien (sauf dans certaines formes rares, dnommes OU exclusif et
notes XOR).
Le XOR (ou OU exclusif) fonctionne de la manire suivante. Pour que

Condition1 XOR Condition2
soit VRAI, il faut que Condition1 soit VRAI, ou bien que Condition2 soit VRAI. Mais si toutes les deux sont
fausses, ou que toutes les deux sont VRAI, alors le rsultat global est considr comme FAUX.
Nous insistons sur le fait que le XOR est une raret, dont il nest pas strictement indispensable de sencombrer en
programmation.
Enfin, le NON inverse une condition :

NON(Condition1)
est VRAI si Condition1 est FAUX, et il sera FAUX si Condition1 est VRAI.
Vous vous demandez peut-tre quoi sert ce NON. Aprs tout, plutt qucrire NON(Prix > 20), il serait plus simple
dcrire tout bonnement Prix=<20. Dans ce cas, cest vident quon se complique inutilement la vie avec le NON.
Mais on rencontrera plus loin des situations dans lesquelles il rend de prcieux services.
On reprsente frquemment tout ceci dans des tables de vrit (C1 et C2 reprsentent deux conditions, et on
envisage chaque fois les quatre cas possibles) :
30
Cours Algorithmique
C1 et C2
C2 Vrai
C2 Faux
C1 Vrai
Vrai
Faux
C1 Faux
Faux
Faux
C1 ou C2
C2 Vrai
C2 Faux
C1 Vrai
Vrai
Vrai
C1 Faux
Vrai
Faux
C1 xor C2
C2 Vrai
C2 Faux
C1 Vrai
Faux
Vrai
C1 Faux
Vrai
Faux
Non C1
C1 Vrai
Faux
C1 Faux
Vrai
LE GAG DE LA JOURNE
Il consiste formuler dans un test une condition qui ne pourra jamais tre vraie, ou
jamais tre fausse. Si ce nest pas fait exprs, cest assez rigolo. Si cest fait exprs, cest
encore plus drle, car une condition dont on sait davance quelle sera toujours fausse nest pas
une condition. Dans tous les cas, cela veut dire quon a crit un test qui nen est pas un, et qui
fonctionne comme sil ny en avait pas.
Cela peut tre par exemple : Si Toto < 10 ET Toto > 15 Alors (il est trs difficile de trouver un
nombre qui soit la fois infrieur 10 et suprieur 15 !)
31
Cours Algorithmique
Exercice 3.2
Ecrire un algorithme qui demande deux nombres lutilisateur et linforme ensuite si
leur produit est ngatif ou positif (on laisse de ct le cas o le produit est nul).
Attention toutefois : on ne doit pas calculer le produit des deux nombres.
Exercice 3.3
Ecrire un algorithme qui demande trois noms lutilisateur et linforme ensuite sils
sont rangs ou non dans lordre alphabtique.
5. Tests imbriqus
Graphiquement, on peut trs facilement reprsenter un SI comme un aiguillage de chemin de fer (ou un aiguillage de
train lectrique, cest moins lourd porter). Un SI ouvre donc deux voies, correspondant deux traitements diffrents.
Mais il y a des tas de situations o deux voies ne suffisent pas. Par exemple, un programme devant donner ltat de
leau selon sa temprature doit pouvoir choisir entre trois rponses possibles (solide, liquide ou gazeuse).
Une premire solution serait la suivante :
Variable Temp en Entier
Dbut
Ecrire Entrez la temprature de leau :
Lire Temp
Si Temp =< 0 Alors
Ecrire Cest de la glace
Finsi
Si Temp > 0 Et Temp < 100 Alors
Ecrire Cest du liquide
Finsi
Si Temp > 100 Alors
Ecrire Cest de la vapeur
Finsi
Fin
Vous constaterez que cest un peu laborieux. Les conditions se ressemblent plus ou moins, et surtout on oblige la
machine examiner trois tests successifs alors que tous portent sur une mme chose, la temprature (la valeur de la
variable Temp). Il serait ainsi bien plus rationnel dimbriquer les tests de cette manire :
Dbut
Lire Temp
Si Temp =< 0 Alors
Sinon
Si Temp < 100 Alors
Sinon
Finsi
Finsi
Fin
32
Cours Algorithmique
Nous avons fait des conomies : au lieu de devoir taper trois conditions, dont une compose, nous navons plus que
deux conditions simples. Mais aussi, et surtout, nous avons fait des conomies sur le temps dexcution de
lordinateur. Si la temprature est infrieure zro, celui-ci crit dornavant Cest de la glace et passe directement
la fin, sans tre ralenti par lexamen dautres possibilits (qui sont forcment fausses).
Cette deuxime version nest donc pas seulement plus simple crire et plus lisible, elle est galement plus
performante lexcution.
Les structures de tests imbriqus sont donc un outil indispensable la simplification et loptimisation des
algorithmes.
Exercice 3.4
Ecrire un algorithme qui demande un nombre lutilisateur, et linforme ensuite si ce
nombre est positif ou ngatif (on inclut cette fois le traitement du cas o le nombre vaut
zro).
Exercice 3.5
Ecrire un algorithme qui demande deux nombres lutilisateur et linforme ensuite si le
produit est ngatif ou positif (on inclut cette fois le traitement du cas o le produit peut
tre nul). Attention toutefois, on ne doit pas calculer le produit !
Exercice 3.6
Ecrire un algorithme qui demande lge dun enfant lutilisateur. Ensuite, il linforme
de sa catgorie :
- Poussin de 6 7 ans
- Pupille de 8 9 ans
- Minime de 10 11 ans
- Cadet aprs 12 ans
Peut-on concevoir plusieurs algorithmes quivalents menant ce rsultat ?
6. De laiguillage la gare de tri

J'ai l'me ferroviaire : je regarde passer les vaches (Lo Ferr)
Cette citation napporte peut-tre pas grand chose cet expos, mais nous laimons bien, alors ctait le moment ou
jamais.
En effet, dans un programme, une structure SI peut tre facilement compare un aiguillage de train. La voie
principale se spare en deux, le train devant rouler ou sur lune, ou sur lautre, et les deux voies se rejoignant tt ou
tard pour ne plus en former quune seule, lors du FinSi. On peut schmatiser cela ainsi :
33
Cours Algorithmique
Mais dans certains cas, ce ne sont pas deux voies quil nous faut, mais trois, ou mme plus. Dans le cas de ltat de
leau, il nous faut trois voies pour notre train , puisque leau peut tre solide, liquide ou gazeuse. Alors, nous
navons pas eu le choix : pour deux voies, il nous fallait un aiguillage, pour trois voies il nous en faut deux, imbriqus
lun dans lautre.
Cette structure (telle que nous lavons programme la page prcdente) devrait tre schmatise comme suit :
Soyons bien clairs : cette structure est la seule possible du point de vue logique (mme si on peut toujours mettre le
bas en haut et le haut en bas). Mais du point de vue de lcriture, le pseudo-code algorithmique admet une
simplification supplmentaire. Ainsi, il est possible (mais non obligatoire), que lalgorithme initial :
Dbut
Lire Temp
Si Temp =< 0 Alors
Sinon
Si Temp < 100 Alors
Sinon
Finsi
Finsi
Fin
devienne :
Dbut
Lire Temp
Si Temp =< 0 Alors
SinonSi Temp < 100 Alors
Sinon
Finsi
Fin
34
Cours Algorithmique
Dans le cas de tests imbriqus, le Sinon et le Si peuvent tre fusionns en un SinonSi. On

considre alors quil sagit dun seul bloc de test, conclu par un seul FinSi
Le SinonSi permet en quelque sorte de crer (en ralit, de simuler) des aiguillages plus de deux branches. On peut
ainsi enchaner les SinonSi les uns derrire les autres pour simuler un aiguillage autant de branches que lon
souhaite.
7. Variables Boolennes
Jusquici, nous avons utilis uniquement des conditions pour faire des tests. Mais vous vous rappelez quil existe un
type de variables (les boolennes) susceptibles de stocker les valeurs VRAI ou FAUX. En fait, on peut donc entrer des
conditions dans ces variables, et tester ensuite la valeur de ces variables.
Reprenons lexemple de leau. On peut le rcrire ainsi :
Variables A, B en Boolen
Dbut
Lire Temp
A Temp =< 0
B Temp < 100
Si A Alors
SinonSi B Alors
Sinon
Finsi
Fin
A priori, cette technique ne prsente gure dintrt : on a alourdi plutt quallg lalgorithme de dpart, en ayant
recours deux variables supplmentaires. Mais :
souvenons-nous : une variable boolenne na besoin que dun seul bit pour tre stocke. De ce point de
vue, lalourdissement nest donc pas considrable.
dans certains cas, notamment celui de conditions composes trs lourdes (avec plein de ET et de OU tout
partout) cette technique peut faciliter le travail du programmeur, en amliorant nettement la lisibilit de
lalgorithme. Les variables boolennes peuvent galement savrer trs utiles pour servir de flag, technique
dont on reparlera plus loin.
35
Cours Algorithmique
PARTIE 4 (ENCORE DE LA LOGIQUE)

La programmation peut tre un plaisir ; de mme que la cryptographie. Toutefois, il faut viter de combiner
les deux.
Kreitzberg et Sneidermann
1. Faut-il mettre un ET ? Faut-il mettre un OU ?

Une remarque pour commencer : dans le cas de conditions composes, les parenthses jouent un rle fondamental.
Variables A, B, C, D, E en Boolen
Variable X en Entier
Dbut
Lire X
A X < 2
B X > 12
C X < 6
D (A ET B) OU C
E A ET (B OU C)
Ecrire D, E
Fin
Si X = 3, alors on remarque que D sera VRAI alors que E sera FAUX.

Sil ny a dans une condition que des ET, ou que des OU, en revanche, les parenthses ne changent strictement rien.
Dans une condition compose employant la fois des oprateurs ET et des oprateurs OU, la
prsence de parenthses possde une influence sur le rsultat, tout comme dans le cas dune
expression numrique comportant des multiplications et des additions.
On en arrive une autre proprit des ET et des OU, bien plus intressante.
Spontanment, on pense souvent que ET et OU sexcluent mutuellement, au sens o un problme donn sexprime
soit avec un ET, soit avec un OU. Pourtant, ce nest pas si vident.
Quand faut-il ouvrir la fentre de la salle ? Uniquement si les conditions limposent, savoir :
Si il fait trop chaud ET il ne pleut pas Alors
Ouvrir la fentre
Sinon
Fermer la fentre
Finsi
Cette petite rgle pourrait tout aussi bien tre formule comme suit :
Si il ne fait pas trop chaud OU il pleut Alors
Fermer la fentre
Sinon
Ouvrir la fentre
Finsi
Ces deux formulations sont strictement quivalentes. Ce qui nous amne la conclusion suivante :
36
Cours Algorithmique
Toute structure de test requrant une condition compose faisant intervenir loprateur ET peut tre
exprime de manire quivalente avec un oprateur OU, et rciproquement.
Ceci est moins surprenant quil ny parat au premier abord. Jetez pour vous en convaincre un il sur les tables de
vrit, et vous noterez la symtrie entre celle du ET et celle du OU. Dans les deux tables, il y a trois cas sur quatre qui
mnent un rsultat, et un sur quatre qui mne au rsultat inverse. Alors, rien dtonnant ce quune situation qui
sexprime avec une des tables (un des oprateurs logiques) puisse tout aussi bien tre exprime avec lautre table
(lautre oprateur logique). Toute lastuce consiste savoir effectuer correctement ce passage.
Bien sr, on ne peut pas se contenter de remplacer purement et simplement les ET par des OU ; ce serait un peu
facile. La rgle dquivalence est la suivante (on peut la vrifier sur lexemple de la fentre) :
Si A ET B Alors
Instructions 1
Sinon
Instructions 2
Finsi
Si NON A OU NON B Alors

Instructions 2
Sinon
Instructions 1
Finsi
Cette rgle porte le nom de transformation de Morgan, du nom du mathmaticien anglais qui l'a formule.
Exercice 4.1
Formulez un algorithme quivalent lalgorithme suivant :
Si Tutu > Toto + 4
OU Tata = OK Alors
Tutu
Sinon
Tutu + 1
Tutu
Finsi
Tutu 1
Exercice 4.2
Cet algorithme est destin prdire l'avenir, et il doit tre infaillible !
Il lira au clavier lheure et les minutes, et il affichera lheure quil sera une minute plus tard.
Par exemple, si l'utilisateur tape 21 puis 32, l'algorithme doit rpondre : "Dans une minute, il
sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de la vrifier.
Exercice 4.3
De mme que le prcdent, cet algorithme doit demander une heure et en afficher une autre.
Mais cette fois, il doit grer galement les secondes, et afficher l'heure qu'il sera une seconde
plus tard.
Par exemple, si l'utilisateur tape 21, puis 32, puis 8, l'algorithme doit rpondre : "Dans une
seconde, il sera 21 heure(s), 32 minute(s) et 9 seconde(s)".
NB : l encore, on suppose que l'utilisateur entre une date valide.
37
Cours Algorithmique
Exercice 4.4
Un magasin de reprographie facture 0,10 E les dix premires photocopies, 0,09 E les vingt
suivantes et 0,08 E au-del.
Ecrivez un algorithme qui demande lutilisateur le nombre de photocopies effectues et qui
affiche la facture correspondante.
Exercice 4.5
Les habitants de Zorglub paient limpt selon les rgles suivantes :
les hommes de plus de 20 ans paient limpt
les femmes paient limpt si elles ont entre 18 et 35 ans
les autres ne paient pas dimpt
Le programme demandera donc lge et le sexe du Zorglubien, et se prononcera donc ensuite

sur le fait que lhabitant est imposable.
2. Au-del de la logique : le style

Ce titre un peu provocateur (mais nanmoins justifi) a pour but dattirer maintenant votre attention sur un fait
fondamental en algorithmique, fait que plusieurs remarques prcdentes ont dj d vous faire souponner : il ny a
jamais une seule manire juste de traiter les structures alternatives. Et plus gnralement, il ny a jamais une seule
manire juste de traiter un problme. Entre les diffrentes possibilits, qui ne sont parfois pas meilleures les unes que
les autres, le choix est une affaire de style.
Cest pour cela quavec lhabitude, on reconnat le style dun programmeur aussi srement que sil sagissait de style
littraire.
Reprenons nos oprateurs de comparaison maintenant familiers, le ET et le OU. En fait, on saperoit que lon pourrait
tout fait sen passer ! Par exemple, pour reprendre lexemple de la fentre de la salle :
Si il fait trop chaud ET il ne pleut pas Alors
Ouvrir la fentre
Sinon
Fermer la fentre
Finsi
Possde un parfait quivalent algorithmique sous la forme de :

Si il fait trop chaud Alors
Si il ne pleut pas Alors
Ouvrir la fentre
Sinon
Fermer la fentre
Finsi
Sinon
Fermer la fentre
Finsi
Dans cette dernire formulation, nous navons plus recours une condition compose (mais au prix dun test imbriqu
supplmentaire).
38
Cours Algorithmique
Et comme tout ce qui sexprime par un ET peut aussi tre exprim par un OU, nous en concluons que le OU peut
galement tre remplac par un test imbriqu supplmentaire. On peut ainsi poser cette rgle stylistique gnrale :
Dans une structure alternative complexe, les conditions composes, limbrication des structures
de tests et lemploi des variables boolennes ouvrent la possibilit de choix stylistiques
diffrents. Lalourdissement des conditions allge les structures de tests et le nombre des
boolens ncessaires ; lemploi de boolens supplmentaires permet dallger les conditions et
les structures de tests, et ainsi de suite.
Exercice 4.6
Les lections lgislatives, en Guignolerie Septentrionale, obissent la rgle suivante :
- lorsque l'un des candidats obtient plus de 50% des suffrages, il est lu ds le premier tour.
- en cas de deuxime tour, peuvent participer uniquement les candidats ayant obtenu au
moins 12,5% des voix au premier tour.
Vous devez crire un algorithme qui permette la saisie des scores de quatre candidats au
premier tour. Cet algorithme traitera ensuite le candidat numro 1 (et uniquement lui) : il
dira s'il est lu, battu, s'il se trouve en ballottage favorable (il participe au second tour en
tant arriv en tte l'issue du premier tour) ou dfavorable (il participe au second tour
sans avoir t en tte au premier tour).
Exercice 4.7
Une compagnie d'assurance automobile propose ses clients quatre familles de tarifs
identifiables par une couleur, du moins au plus onreux : tarifs bleu, vert, orange et rouge.
Le tarif dpend de la situation du conducteur :
- un conducteur de moins de 25 ans et titulaire du permis depuis moins de deux ans, se voit
attribuer le tarif rouge, si toutefois il n'a jamais t responsable d'accident. Sinon, la
compagnie refuse de l'assurer.
- un conducteur de moins de 25 ans et titulaire du permis depuis plus de deux ans, ou de
plus de 25 ans mais titulaire du permis depuis moins de deux ans a le droit au tarif orange
s'il n'a jamais provoqu d'accident, au tarif rouge pour un accident, sinon il est refus.
- un conducteur de plus de 25 ans titulaire du permis depuis plus de deux ans bnficie du
tarif vert s'il n'est l'origine d'aucun accident et du tarif orange pour un accident, du tarif
rouge pour deux accidents, et refus au-del
De plus, pour encourager la fidlit des clients accepts, la compagnie propose un contrat
de la couleur immdiatement la plus avantageuse s'il est entr dans la maison depuis plus
d'un an.
Ecrire l'algorithme permettant de saisir les donnes ncessaires (sans contrle de saisie) et
de traiter ce problme. Avant de se lancer corps perdu dans cet exercice, on pourra
rflchir un peu et s'apercevoir qu'ils est plus simple qu'il en a l'air (cela s'appelle faire une
analyse !)
39
Cours Algorithmique
Exercice 4.8
Ecrivez un algorithme qui a prs avoir demand un numro de jour, de mois et d'anne
l'utilisateur, renvoie s'il s'agit ou non d'une date valide.
Cet exercice est certes dun manque doriginalit affligeant, mais aprs tout, en
algorithmique comme ailleurs, il faut connatre ses classiques ! Et quand on a fait cela une
fois dans sa vie, on apprcie pleinement lexistence dun type numrique date dans
certains langages).
Il n'est sans doute pas inutile de rappeler rapidement que le mois de fvrier compte 28
jours, sauf si lanne est bissextile, auquel cas il en compte 29. Lanne est bissextile si elle
est divisible par quatre. Toutefois, les annes divisibles par 100 ne sont pas bissextiles, mais
les annes divisibles par 400 le sont. Ouf !
Un dernier petit dtail : vous ne savez pas, pour linstant, exprimer correctement en
pseudo-code lide quun nombre A est divisible par un nombre B. Aussi, vous vous
contenterez dcrire en bons tlgraphistes que A divisible par B se dit A dp B .
Si vous avez compris ce qui prcde, et que l'exercice de la date ne vous pose plus aucun problme, alors vous savez
tout ce qu'il y a savoir sur les tests pour affronter n'importe quelle situation. Non, ce n'est pas de la dmagogie !
Malheureusement, nous ne sommes pas tout fait au bout de nos peines ; il reste une dernire structure logique
examiner, et pas des moindres
40
Cours Algorithmique
PARTIE 5 (LES BOUCLES)

Les premiers 90% du code prennent les premiers 90% du temps de dveloppement. Les 10% restants prennent
les autres 90% du temps de dveloppement
Tom Cargill
Et a y est, on y est, on est arrivs, la voil, cest Broadway, la quatrime et dernire structure : a est les boucles. Si
vous voulez pater vos amis, vous pouvez galement parler de structures rptitives, voire carrment de structures
itratives. Ici, entre nous, on parlera de boucles.
Les boucles, c'est gnralement le point douloureux de l'apprenti programmeur. C'est l que a coince, car autant il
est assez facile de comprendre comment fonctionnent les boucles, autant il est souvent long d'acqurir les rflexes qui
permettent de les laborer judicieusement pour traiter un problme donn.
On peut dire en fait que les boucles constituent la seule vraie structure logique caractristique de la programmation. Si
vous avez utilis un tableur comme Excel, par exemple, vous avez sans doute pu manier des choses quivalentes aux
variables (les cellules, les formules) et aux tests (la fonction SI). Mais les boucles, a, a n'a aucun quivalent. Cela
n'existe que dans les langages de programmation proprement dits.
Le maniement des boucles, s'il ne diffrencie certes pas l'homme de la bte (il ne faut tout de mme pas exagrer), est
tout de mme ce qui spare en informatique le programmeur de l'utilisateur, mme averti.
Alors, vos futures et invitables - difficults sur le sujet, il y a trois remdes : de la rigueur, de la patience, et encore
de la rigueur !
1. A quoi cela sert-il donc ?

Prenons le cas dune saisie au clavier (une lecture), o par exemple, le programme pose une question laquelle
lutilisateur doit rpondre par O (Oui) ou N (Non). Mais tt ou tard, lutilisateur, factieux ou maladroit, risque de taper
autre chose que la rponse attendue. Ds lors, le programme peut planter soit par une erreur dexcution (parce que
le type de rponse ne correspond pas au type de la variable attendu) soit par une erreur fonctionnelle (il se droule
normalement jusquau bout, mais en produisant des rsultats fantaisistes).
Alors, dans tout programme un tant soit peu srieux, on met en place ce quon appelle un contrle de saisie, afin de
vrifier que les donnes entres au clavier correspondent bien celles attendues par lalgorithme.
A vue de nez, on pourrait essayer avec un SI. Voyons voir ce que a donne :
Variable Rep en Caractre
Dbut
Ecrire Voulez vous un caf ? (O/N)
Lire Rep
Si Rep <> O ET Rep <> N Alors
Ecrire Saisie erronne. Recommencez
Lire Rep
FinSi
Fin
41
Cours Algorithmique
Cest impeccable. Du moins tant que lutilisateur a le bon got de ne se tromper quune seule fois, et dentrer une
valeur correcte la deuxime demande. Si lon veut galement btonner en cas de deuxime erreur, il faudrait
rajouter un SI. Et ainsi de suite, on peut rajouter des centaines de SI, et crire un algorithme aussi lourd quune blague
des Grosses Ttes, on nen sortira pas, il y aura toujours moyen quun acharn flanque le programme par terre.
La solution consistant aligner des SI en pagaille est donc une impasse. La seule issue est donc de flanquer une
structure de boucle, qui se prsente ainsi :
TantQue boolen
Instructions
FinTantQue
Le principe est simple : le programme arrive sur la ligne du TantQue. Il examine alors la valeur du boolen (qui,
rappelons-le, peut tre une variable boolenne ou, plus frquemment, une condition). Si cette valeur est VRAI, le
programme excute les instructions qui suivent, jusqu ce quil rencontre la ligne FinTantQue. Il retourne ensuite sur
la ligne du TantQue, procde au mme examen, et ainsi de suite. Le mange enchant ne sarrte que lorsque le
boolen prend la valeur FAUX.
Illustration avec notre problme de contrle de saisie. Une premire approximation de la solution consiste crire :
Dbut
TantQue Rep <> O ET Rep <> N
Lire Rep
FinTantQue
Fin
L, on a le squelette de lalgorithme correct. Mais de mme quun squelette ne suffit pas pour avoir un tre vivant
viable, il va nous falloir ajouter quelques muscles et organes sur cet algorithme pour quil fonctionne correctement.
Son principal dfaut est de provoquer une erreur chaque excution. En effet, lexpression boolenne qui figure aprs
le TantQue interroge la valeur de la variable Rep. Malheureusement, cette variable, si elle a t dclare, na pas t
affecte avant lentre dans la boucle. On teste donc une variable qui na pas de valeur, ce qui provoque larrt
immdiat de lexcution. Pour viter ceci, on na pas le choix : il faut que la variable Rep ait dj t affecte avant
quon en arrive au premier tour de boucle. Pour cela, on peut faire une premire lecture de Rep avant la boucle. Dans
ce cas, celle-ci ne servira quen cas de mauvaise saisie lors de cette premire lecture. Lalgorithme devient alors :
Dbut
Lire Rep
Lire Rep
FinTantQue
Fin
Une autre possibilit, frquemment employe, consiste ne pas lire, mais affecter arbitrairement la variable avant la
boucle. Arbitrairement ? Pas tout fait, puisque cette affectation doit avoir pour rsultat de provoquer lentre
obligatoire dans la boucle. Laffectation doit donc faire en sorte que le boolen soit mis VRAI pour dclencher le
premier tour de la boucle. Dans notre exemple, on peut donc affecter Rep avec nimporte quelle valeur, hormis O
et N : car dans ce cas, lexcution sauterait la boucle, et Rep ne serait pas du tout lue au clavier. Cela donnera par
exemple :
42
Cours Algorithmique

Dbut
Rep X
Lire Rep
FinTantQue
Fin
Cette manire de procder est connatre, car elle est employe trs frquemment.
Il faut remarquer que les deux solutions (lecture initiale de Rep en dehors de la boucle ou affectation de Rep) rendent
toutes deux lalgorithme satisfaisant, mais prsentent une diffrence assez importante dans leur structure logique.
En effet, si lon choisit deffectuer une lecture pralable de Rep, la boucle ultrieure sera excute uniquement dans
lhypothse dune mauvaise saisie initiale. Si lutilisateur saisit une valeur correcte la premire demande de Rep,
lalgorithme passera sur la boucle sans entrer dedans.
En revanche, avec la deuxime solution (celle dune affectation pralable de Rep), lentre de la boucle est force, et
lexcution de celle-ci, au moins une fois, est rendue obligatoire chaque excution du programme. Du point de vue
de lutilisateur, cette diffrence est tout fait mineure ; et la limite, il ne la remarquera mme pas. Mais du point de
vue du programmeur, il importe de bien comprendre que les cheminements des instructions ne seront pas les mmes
dans un cas et dans lautre.
Pour terminer, remarquons que nous pourrions peaufiner nos solutions en ajoutant des affichages de libells qui font
encore un peu dfaut. Ainsi, si lon est un programmeur zl, la premire solution (celle qui inclut deux lectures de
Rep, une en dehors de la boucle, lautre lintrieur) pourrait devenir :
Dbut
Lire Rep
Ecrire Vous devez rpondre par O ou N. Recommencez
Lire Rep
FinTantQue
Ecrire Saisie accepte
Fin
Quant la deuxime solution, elle pourra devenir :

Dbut
Rep X
Lire Rep
Si Rep <> O ET Rep <> N Alors
Ecrire Saisie Errone, Recommencez
FinSi
FinTantQue
Fin
Bon, eh bien vous allez pouvoir faire de chouettes algorithmes, dj rien quavec a
43
Cours Algorithmique
Exercice 5.1
Ecrire un algorithme qui demande lutilisateur un nombre compris entre 1 et 3 jusqu ce que la
rponse convienne.
Exercice 5.2
Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu ce que la rponse
convienne. En cas de rponse suprieure 20, on fera apparatre un message : Plus petit ! , et
inversement, Plus grand ! si le nombre est infrieur 10.
Exercice 5.3
Ecrire un algorithme qui demande un nombre de dpart, et qui ensuite affiche les dix nombres
suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres de
18 27.
LE GAG DE LA JOURNE
Cest dcrire une structure TantQue dans laquelle le boolen nest jamais VRAI. Le
programme ne rentre alors jamais dans la superbe boucle sur laquelle vous avez tant su !
Mais la faute symtrique est au moins aussi dsopilante.
Elle consiste crire une boucle dans laquelle le boolen ne devient jamais FAUX. Lordinateur
tourne alors dans la boucle comme un drat et nen sort plus. Seule solution, quitter le
programme avec un dmonte-pneu ou un bton de dynamite. La boucle infinie est une des
hantises les plus redoutes des programmeurs. Cest un peu comme le verre baveur, le poil
gratter ou le bleu de mthylne : cest cul, mais a fait toujours rire.
Cette faute de programmation grossire mais frquente - ne manquera pas dgayer
lambiance collective de cette formation et accessoirement dtancher la soif proverbiale de
vos enseignants.
2. Boucler en comptant, ou compter en bouclant

Dans le dernier exercice, vous avez remarqu quune boucle pouvait tre utilise pour augmenter la valeur dune
variable. Cette utilisation des boucles est trs frquente, et dans ce cas, il arrive trs souvent quon ait besoin
deffectuer un nombre dtermin de passages. Or, a priori, notre structure TantQue ne sait pas lavance combien de
tours de boucle elle va effectuer (puisque le nombre de tours dpend de la valeur dun boolen).
44
Cours Algorithmique
Cest pourquoi une autre structure de boucle est notre disposition :

Variable Truc en Entier
Dbut
Truc 0
TantQue Truc < 15
Truc = Truc + 1
Ecrire Passage numro : , Truc
FinTantQue
Fin
Equivaut :
Dbut
Pour Truc = 1 15
Truc Suivant
Fin
Insistons : la structure Pour Suivant nest pas du tout indispensable ; on pourrait fort bien programmer toutes les
situations de boucle uniquement avec un Tant Que . Le seul intrt du Pour est dpargner un peu de fatigue au
programmeur, en lui vitant de grer lui-mme la progression de la variable qui lui sert de compteur (on parle
dincrmentation, encore un mot qui fera forte impression).
Dit dune autre manire, la structure Pour Suivant est un cas particulier de TantQue : celui o le programmeur
peut dnombrer lavance le nombre de tours de boucles ncessaires.
Il faut noter que dans une structure Pour Suivant , la progression du compteur est laisse votre libre disposition.
Dans la plupart des cas, on a besoin dune variable qui augmente de 1 chaque tour de boucle. On ne prcise alors
rien linstruction Pour ; celle-ci, par dfaut, comprend quil va falloir procder cette incrmentation de 1
chaque passage, en commenant par la premire valeur et en terminant par la deuxime.
Mais si vous souhaitez une progression plus spciale, de 2 en 2, ou de 3 en 3, ou en arrire, de 1 en 1, ou de 10 en
10, ce nest pas un problme : il suffira de le prciser votre instruction Pour en lui rajoutant le mot Pas et la
valeur de ce pas (Le pas dont nous parlons, cest le pas du marcheur, step en anglais).
Naturellement, quand on stipule un pas ngatif dans une boucle, la valeur initiale du compteur doit tre suprieure
sa valeur finale si lon veut que la boucle tourne ! Dans le cas contraire, on aura simplement crit une boucle dans
laquelle le programme ne rentrera jamais.
Nous pouvons donc maintenant donner la formulation gnrale dune structure Pour . Sa syntaxe gnrale est :
Pour Compteur = Initial Final Pas ValeurDuPas
Instructions
Compteur suivant
Les structures TantQue sont employes dans les situations o lon doit procder un traitement systmatique sur les
lments dun ensemble dont on ne connat pas davance la quantit, comme par exemple :
le contrle dune saisie ;
la gestion des tours dun jeu (tant que la partie nest pas finie, on recommence) ;
la lecture des enregistrements dun fichier (cf. Partie 9).
45
Cours Algorithmique
Les structures Pour sont employes dans les situations o lon doit procder un traitement systmatique sur les
lments dun ensemble dont on connat davance la quantit.
Nous verrons dans les chapitres suivants des sries dlments appels tableaux (parties 7 et 8) et chanes de
caractres (partie 9). Selon les cas, le balayage systmatique des lments de ces sries pourra tre effectu par un
Pour ou par un TantQue : tout dpend si la quantit dlments balayer (donc le nombre de tours de boucles
ncessaires) peut tre dnombre lavance par le programmeur ou non.
3. Des boucles dans des boucles

( Tout est dans tout, et rciproquement )
On rigole, on rigole !
De mme que les poupes russes contiennent dautres poupes russes, de mme quune structure SI ALORS peut
contenir dautres structures SI ALORS, une boucle peut tout fait contenir dautres boucles. Y a pas de raison.
Variables Truc, Trac en Entier
Pour Truc 1 15
Ecrire Il est pass par ici
Pour Trac 1 6
Ecrire Il repassera par l
Trac Suivant
Truc Suivant
Dans cet exemple, le programme crira une fois il est pass par ici puis six fois de suite il repassera par l, et ceci
quinze fois en tout. A la fin, il y aura donc eu 15 x 6 = 90 passages dans la deuxime boucle (celle du milieu), donc 90
critures lcran du message il repassera par l . Notez la diffrence marquante avec cette structure :
Pour Truc 1 15
Ecrire Il est pass par ici
Truc Suivant
Pour Trac 1 6
Ecrire Il repassera par l
Trac Suivant
Ici, il y aura quinze critures conscutives de il est pass par ici, puis six critures conscutives de il repassera par
l, et ce sera tout.
Des boucles peuvent donc tre imbriques (cas n1) ou successives (cas n2). Cependant, elles ne peuvent jamais,
au grand jamais, tre croises. Cela naurait aucun sens logique, et de plus, bien peu de langages vous autoriseraient
ne serait-ce qu crire cette structure aberrante.
Pour Truc
instructions
Pour Trac
instructions
Truc Suivant
instructions
Trac Suivant
Pourquoi imbriquer des boucles ? Pour la mme raison quon imbrique des tests. La traduction en
46
Cours Algorithmique
bon franais dun test, cest un cas . Eh bien un cas (par exemple, est-ce un homme ou une femme ? ) peut
trs bien se subdiviser en dautres cas ( a-t-il plus ou moins de 18 ans ? ).
De mme, une boucle, cest un traitement systmatique, un examen dune srie dlments un par un (par exemple,
prenons tous les employs de lentreprise un par un ). Eh bien, on peut imaginer que pour chaque lment ainsi
considr (pour chaque employ), on doive procder un examen systmatique dautre chose ( prenons chacune
des commandes que cet employ a traites ). Voil un exemple typique de boucles imbriques : on devra
programmer une boucle principale (celle qui prend les employs un par un) et lintrieur, une boucle secondaire
(celle qui prend les commandes de cet employ une par une).
Dans la pratique de la programmation, la matrise des boucles imbriques est ncessaire, mme si elle nest pas
suffisante. Tout le contraire dAlain Delon, en quelque sorte.
4. Et encore une btise ne pas faire !

Examinons lalgorithme suivant :
Pour Truc
1 15
Truc
Truc * 2

Truc Suivant
Vous remarquerez que nous faisons ici grer en double la variable Truc, ces deux gestions tant contradictoires.
Dune part, la ligne Pour augmente la valeur de Truc de 1 chaque passage. Dautre part la ligne Truc Truc *
2 double la valeur de Truc chaque passage. Il va sans dire que de telles manipulations perturbent compltement le
droulement normal de la boucle, et sont causes, sinon de plantages, tout au moins dexcutions erratiques.
LE GAG DE LA JOURNE
Il consiste donc manipuler, au sein dune boucle Pour, la variable qui sert de compteur cette
boucle. Cette technique est proscrire absolument sauf bien sr, si vous cherchez un
prtexte pour rgaler tout le monde au bistrot.
Mais dans ce cas, nayez aucune inhibition, proposez-le directement, pas besoin de prtexte.
47
Cours Algorithmique
Exercice 5.4
Ecrire un algorithme qui demande un nombre de dpart, et qui ensuite crit la table de
multiplication de ce nombre, prsente comme suit (cas o l'utilisateur entre le nombre 7) :
Table de 7 :
7
7
7
x 1 = 7
x 2 = 14
x 3 = 21
x 10 = 70
Exercice 5.5
Ecrire un algorithme qui demande un nombre de dpart, et qui calcule la somme des entiers
jusqu ce nombre. Par exemple, si lon entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
Exercice 5.6
Ecrire un algorithme qui demande un nombre de dpart, et qui calcule sa factorielle.
NB : la factorielle de 8, note 8 !, vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8
Exercice 5.7
Ecrire un algorithme qui demande successivement 20 nombres lutilisateur, et qui lui dise
ensuite quel tait le plus grand parmi ces 20 nombres :
Entrez le nombre numro 1 : 12
Etc.
Le plus grand de ces nombres est
: 14
Modifiez ensuite lalgorithme pour que le programme affiche de surcrot en quelle position
avait t saisie ce nombre :
Ctait le nombre numro 2
48
Cours Algorithmique
Exercice 5.8
Rcrire lalgorithme prcdent, mais cette fois-ci on ne connat pas davance combien
lutilisateur souhaite saisir de nombres. La saisie des nombres sarrte lorsque lutilisateur
entre un zro.
Exercice 5.9
Lire la suite des prix (en euros entiers et termine par zro) des achats dun client. Calculer la
somme quil doit, lire la somme quil paye, et simuler la remise de la monnaie en affichant les
textes 10 E , 5 E et 1 E autant de fois quil y a de coupures de chaque sorte rendre.
Exercice 5.10
Ecrire un algorithme qui permette de connatre ses chances de gagner au tierc, quart,
quint et autres impts volontaires.
On demande lutilisateur le nombre de chevaux partants, et le nombre de chevaux jous.
Les deux messages affichs devront tre :
Dans lordre : une chance sur X de gagner
Dans le dsordre : une chance sur Y de gagner
X et Y nous sont donns par la formule suivante, si n est le nombre de chevaux partants et p
le nombre de chevaux jous :
X = n ! / (n - p) !
Y = n ! / (p ! * (n p) !)
NB : cet algorithme peut tre crit dune manire simple, mais relativement peu performante.
Ses performances peuvent tre singulirement augmentes par une petite astuce. Vous
commencerez par crire la manire la plus simple, puis vous identifierez le problme, et
crirez une deuxime version
49
Cours Algorithmique
PARTIE 6 (LES TABLEAUX)

Si on ment un compilateur, il prendra sa revanche.
Henry Spencer.
Bonne nouvelle ! On vous avait annonc quil y a avait en tout et pour tout quatre structures logiques dans la
programmation. Eh bien, a y est, on les a toutes passes en revue.
Mauvaise nouvelle, il vous reste tout de mme quelques petites choses apprendre
1. Utilit des tableaux

Imaginons que dans un programme, nous ayons besoin simultanment de 12 valeurs (par exemple, des notes pour
calculer une moyenne). videmment, la seule solution dont nous disposons lheure actuelle consiste dclarer
douze variables, appeles par exemple Notea, Noteb, Notec, etc. Bien sr, on peut opter pour une notation un peu
simplifie, par exemple N1, N2, N3, etc. Mais cela ne change pas fondamentalement notre problme, car arriv au
calcul, et aprs 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
Ouf ! Cest tout de mme bigrement laborieux. Et pour un peu que nous soyons dans un programme de gestion avec
quelques centaines ou quelques milliers de valeurs traiter, alors l cest le suicide direct.
Cerise sur le gteau, si en plus on est dans une situation on lon ne peut pas savoir davance combien il y aura de
valeurs traiter, l on est carrment cuits.
Cest pourquoi la programmation nous permet de rassembler toutes ces variables en une seule, au sein de laquelle
chaque valeur sera dsigne par un numro. En bon franais, cela donnerait donc quelque chose du genre la note
numro 1 , la note numro 2 , la note numro 8 . Cest largement plus pratique, vous vous en doutez.
Un ensemble de valeurs portant le mme nom de variable et repres par un nombre, sappelle un
tableau, ou encore une variable indice.
Le nombre qui, au sein dun tableau, sert reprer chaque valeur sappelle surprise lindice.
Chaque fois que lon doit dsigner un lment du tableau, on fait figurer le nom du tableau, suivi de
lindice de llment, entre parenthses.
2. Notation et utilisation algorithmique

Dans notre exemple, nous crerons donc un tableau appel Note. Chaque note individuelle (chaque lment du
tableau Note) sera donc dsigne Note(0), Note(1), etc. Eh oui, attention, les indices des tableaux commencent
gnralement 0, et non 1.
50
Cours Algorithmique
Un tableau doit tre dclar comme tel, en prcisant le plus grand indice et le type de valeurs quil contiendra. Comme
nous venons de voir que les indices commencent zro, consquence imparable, si on veut 12 emplacements, le plus
grand indice sera 11 (au dbut, a droute, mais avec le temps, on se fait tout).
Tableau Note(11) en Entier
On peut crer des tableaux contenant des variables de tous types : tableaux de numriques, bien sr, mais aussi
tableaux de caractres, tableaux de boolens, 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 diffrents de
valeurs au sein dun mme tableau.
Lnorme avantage des tableaux, cest quon va pouvoir les traiter en faisant des boucles. Par exemple, pour effectuer
notre calcul de moyenne, cela donnera par exemple :
Variables i, Som en Entier
Variable Moy en Rel
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
NB : On a fait deux boucles successives pour plus de lisibilit, mais on aurait tout aussi bien pu nen crire quune
seule dans laquelle on aurait tout fait dun seul coup.
Remarque gnrale : lindice qui sert dsigner les lments dun tableau peut tre exprim directement comme un
nombre en clair, mais il peut tre aussi une variable, ou une expression calcule.
La valeur dun indice doit toujours :
tre gale au moins 0 (dans quelques rares langages, le premier lment dun tableau porte lindice 1).
Mais nous avons choisi ici de commencer la numrotation des indices zro, comme cest le cas en
langage C et en Visual Basic. Donc attention, Truc(6) est le septime lment du tableau Truc !
tre un nombre entier. Quel que soit le langage, llment Truc(3,1416) nexiste jamais.
tre infrieure ou gale au nombre dlments du tableau (moins 1, si lon commence la numrotation
zro). Si le tableau Bidule a t dclar comme ayant 25 lments, la prsence dans une ligne, sous une
forme ou sous une autre, de Bidule(32) dclenchera automatiquement une erreur.
NB : Si lon est dans un langage o les indices commencent zro, il faut en tenir compte la dclaration :
crera en fait un tableau de 13 lments, le plus petit indice tant 0 et le plus grand 12.
51
Cours Algorithmique
LE GAG DE LA JOURNE
Il consiste confondre, dans sa tte et / ou dans un algorithme, lindice dun lment dun
tableau avec le contenu de cet lment. La troisime maison de la rue na pas forcment trois
habitants, et la vingtime vingt habitants. En notation algorithmique, il ny a aucun rapport entre i
et truc(i).
Exercice 6.1
Ecrire un algorithme qui dclare et remplisse un tableau de 7 valeurs numriques en les
mettant toutes zro.
Exercice 6.2
Ecrire un algorithme qui dclare et remplisse un tableau contenant les six voyelles de
lalphabet latin.
Exercice 6.3
Ecrire un algorithme qui dclare un tableau de 9 notes, dont on fait ensuite saisir les valeurs
par lutilisateur.
Exercice 6.4
Tableau Nb(5) en Entier
Variable i en Entier
Dbut
Pour i 0 5
Nb(i) i * i
i Suivant
Pour i 0 5
Ecrire Nb(i)
i Suivant
Fin
Peut-on simplifier cet algorithme avec le mme rsultat ?
52
Cours Algorithmique
Exercice 6.5
Tableau N(6) en Entier
Variables i, k en Entier
Dbut
N(0) 1
Pour k 1 6
N(k) N(k-1) + 2
k Suivant
Pour i 0 6
Ecrire N(i)
i Suivant
Fin
Peut-on simplifier cet algorithme avec le mme rsultat ?
Exercice 6.6
Tableau Suite(7) en Entier
Dbut
Suite(0) 1
Suite(1) 1
Pour i 2 7
Suite(i) Suite(i-1) + Suite(i-2)
i suivant
Pour i 0 7
Ecrire Suite(i)
i suivant
Fin
3. Tableaux dynamiques
Il arrive frquemment que lon ne connaisse pas lavance le nombre dlments que devra comporter un tableau.
Bien sr, une solution consisterait dclarer un tableau gigantesque (10 000 lments, pourquoi pas, au diable les
varices) pour tre sr que a rentre . Mais dune part, on nen sera jamais parfaitement sr, dautre part, en raison
de limmensit de la place mmoire rserve et la plupart du temps non utilise, cest un gchis prjudiciable la
rapidit, voire la viabilit, de notre algorithme.
Aussi, pour parer ce genre de situation, a-t-on la possibilit de dclarer le tableau sans prciser au dpart son
nombre dlments. Ce nest que dans un second temps, au cours du programme, que lon va fixer ce nombre via une
instruction de redimensionnement : Redim. Notez que tant quon na pas prcis le nombre dlments dun tableau,
dune manire ou dune 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 dbut de lalgorithme sera quelque chose du genre :
53
Cours Algorithmique
Tableau Notes() en Entier

Variable nb en Entier
Dbut
Ecrire Combien y a-t-il de notes saisir ?
Lire nb
Redim Notes(nb-1)
Cette technique na rien de sorcier, mais elle fait partie de larsenal de base de la programmation en gestion.
Exercice 6.7
Ecrivez la fin de lalgorithme 6.3 afin que le calcul de la moyenne des notes soit effectu et affich
lcran.
Exercice 6.8
Ecrivez un algorithme permettant lutilisateur de saisir un nombre quelconque de valeurs, qui
devront tre stockes dans un tableau. Lutilisateur doit donc commencer par entrer le nombre de
valeurs quil compte saisir. Il effectuera ensuite cette saisie. Enfin, une fois la saisie termine, le
programme affichera le nombre de valeurs ngatives et le nombre de valeurs positives.
Exercice 6.9
Ecrivez un algorithme calculant la somme des valeurs dun tableau (on suppose que le tableau a t
pralablement saisi).
Exercice 6.10
Ecrivez un algorithme constituant un tableau, partir de deux tableaux de mme longueur
pralablement saisis. Le nouveau tableau sera la somme des lments des deux tableaux de dpart.
Exemple :
Tableau 1 :
Tableau 2 :
Tableau constituer :
48791546
76521374
11 14 12 11 2 8 11 - 10
Exercice 6.11
Toujours partir de deux tableaux prcdemment saisis, crivez un algorithme qui calcule le
schtroumpf des deux tableaux. Pour calculer le schtroumpf, il faut multiplier chaque lment du
tableau 1 par chaque lment du tableau 2, et additionner le tout.
54
Cours Algorithmique
Exemple :
Tableau 1 :
4 8 7 - 12
Tableau 2 :
36
Le Schtroumpf :
3*4 + 3*8 + 3*7 + 3*12 + 6*4 + 6*8 + 6*7 + 6*12 = 279
Exercice 6.12
Ecrivez un algorithme qui permette la saisie dun nombre quelconque de valeurs, sur le principe de
lex 6.8. Toutes les valeurs doivent tre ensuite augmentes de 1, et le nouveau tableau sera affich
lcran.
Exercice 6.13
Ecrivez un algorithme permettant, toujours sur le mme principe, lutilisateur de saisir un nombre
dtermin de valeurs. Le programme, une fois la saisie termine, renvoie la plus grande valeur en
prcisant quelle position elle occupe dans le tableau. On prendra soin deffectuer la saisie dans un
premier temps, et la recherche de la plus grande valeur du tableau dans un second temps.
Exercice 6.14
Toujours et encore sur le mme principe, crivez un algorithme permettant, lutilisateur de saisir
les notes d'une classe. Le programme, une fois la saisie termine, renvoie le nombre de ces notes
suprieures la moyenne de la classe.
55
Cours Algorithmique
PARTIE 7 (TECHNIQUES RUSES )

Informatique : alliance d'une science inexacte et d'une activit humaine faillible
Luc Fayard
Une fois nest pas coutume, ce chapitre na pas pour but de prsenter un nouveau type de donnes, un nouveau jeu
dinstructions, ...
Son propos est de dtailler quelques techniques de programmation qui possdent deux grands points communs :
leur connaissance est parfaitement indispensable ;
elles sont un rien finaudes.
Et que valent quelques kilos daspirine, compar lineffable bonheur procur par la comprhension suprme des
arcanes de lalgorithmique ?
1. Tri dun tableau : le tri par insertion

Premire de ces ruses de sioux, et par ailleurs tarte la crme absolue du programmeur, donc : le tri de tableau.
Combien de fois au cours dune carrire (brillante) de dveloppeur a-t-on besoin de ranger des valeurs dans un ordre
donn ? Cest inimaginable. Aussi, plutt quavoir rinventer chaque fois la roue, le fusil tirer dans les coins, le fil
couper le roquefort et la poudre maquiller, vaut-il mieux avoir assimil une ou deux techniques solidement
prouves, mme si elles paraissent un peu ardues au dpart.
Il existe plusieurs stratgies possibles pour trier les lments dun tableau ; nous en verrons deux : le tri par insertion,
et le tri bulles.
Commenons par le tri par insertion.
Admettons que le but de la manuvre soit de trier un tableau de 12 lments dans lordre croissant. La technique du
tri par slection est la suivante : on met en bonne position llment numro 1, cest--dire le plus petit. Puis on met en
bonne position llment suivant. Et ainsi de suite jusquau dernier. Par exemple, si lon part de :
45
122
12
21
78
64
53
89
28
84
46
On commence par rechercher, parmi les 12 valeurs, quel est le plus petit lment, et o il se trouve. On lidentifie en
quatrime position (cest le nombre 3), et on lchange alors avec le premier lment (le nombre 45). Le tableau
devient ainsi :
122
12
45
21
78
64
53
89
28
84
46
On recommence chercher le plus petit lment, mais cette fois, seulement partir du deuxime (puisque le premier
est maintenant correct, on ny touche plus). On le trouve en troisime position (cest le nombre 12). On change donc
le deuxime avec le troisime :
56
Cours Algorithmique
12
122
45
21
78
64
53
89
28
84
46
On recommence chercher le plus petit lment partir du troisime (puisque les deux premiers sont maintenant bien
placs), et on le place correctement, en lchangeant, ce qui donnera in fine :
12
21
45
122
78
64
53
89
28
84
46
Et cetera, et cetera, jusqu lavant dernier.

En bon franais nous pourrions dcrire le processus de la manire suivante :
Boucle principale : prenons comme point de dpart le premier lment, puis le second, etc, jusqu lavant
dernier.
Boucle secondaire : partir de ce point de dpart mouvant, recherchons jusqu la fin du tableau quel est le plus
petit lment. Une fois que nous lavons trouv, nous lchangeons avec le point de dpart.
Cela scrit :
Pour i 0 10 boucle principale : le point de dpart se dcale chaque tour
posmini i on considre provisoirement que t(i) est le plus petit lment
Pour j i + 1 11 on examine tous les lments suivants
Si t(j) < t(posmini) Alors
posmini j
Finsi
j suivant
A cet endroit, on sait maintenant o est le plus petit lment. Il ne reste plus qu' effectuer la permutation.
temp t(posmini)
t(posmini) t(i)
t(i) temp
i suivant
2. Un exemple de flag : la recherche dans un tableau

Nous allons maintenant nous intresser au maniement habile dune variable boolenne : la technique dite du flag .
Le flag, en anglais, est un petit drapeau, qui va rester baiss aussi longtemps que lvnement attendu ne se produit
pas. Et, aussitt que cet vnement a lieu, le petit drapeau se lve (la variable boolenne change de valeur). Ainsi, la
valeur finale de la variable boolenne permet au programmeur de savoir si lvnement a eu lieu ou non.
Tout ceci peut vous sembler un peu fumeux, mais cela devrait sclairer laide dun exemple extrmement frquent :
la recherche de loccurrence dune valeur dans un tableau. On en profitera au passage pour corriger une erreur
particulirement frquente chez le programmeur dbutant.
Soit un tableau comportant, disons, 20 valeurs. Lon doit crire un algorithme saisissant un nombre au clavier, et qui
informe lutilisateur de la prsence ou de labsence de la valeur saisie dans le tableau.
57
Cours Algorithmique
La premire tape, vidente, consiste crire les instructions de lecture / criture, et la boucle car il y en a
manifestement une de parcours du tableau :
Dim Tab(19) en Numrique
Dim N en Numrique
Ecrire "Entrez la valeur rechercher"

Lire N
Pour i 0 19
???
i suivant
Il nous reste combler les points d'interrogation de la boucle Pour. videmment, il va falloir comparer N chaque
lment du tableau : si les deux valeurs sont gales, alors bingo, N fait partie du tableau. Cela va se traduire, bien
entendu, par un Si Alors Sinon. Et voil le programmeur raisonnant htivement qui se vautre en crivant :
Dim N en Numrique

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
Et patatras, cet algorithme est une vritable catastrophe.

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
rponse, quel que soit le nombre d'lments 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'intrieur de la boucle : elle
doit figurer l'extrieur. On sait si la valeur tait dans le tableau ou non uniquement lorsque le balayage du tableau est
entirement accompli.
Nous rcrivons donc cet algorithme en plaant le test aprs la boucle. Faute de mieux, on se contentera de faire
dpendre pour le moment la rponse d'une variable boolenne que nous appellerons Trouv.
Dim N en Numrique

Lire N
Pour i
0 19
???
i suivant
Si Trouv Alors
58
Cours Algorithmique
Sinon
FinSi
Il ne nous reste plus qu' grer 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 rencontre dans le tableau). Et attention : le test est asymtrique. Il ne comporte pas de "sinon".
On reviendra l dessus dans un instant.
Last, but not least, l'affectation par dfaut de la variable Trouv, dont la valeur de dpart doit tre videmment
Faux.
Au total, l'algorithme complet et juste ! donne :

Dim N en Numrique

Lire N
Trouv Faux
Pour i 0 19
Si N = Tab(i) Alors
Trouv Vrai
FinSi
i suivant
Si Trouv Alors
Sinon
FinSi
Mditons un peu sur cette affaire.

La difficult est de comprendre que dans une recherche, le problme ne se formule pas de la mme manire selon
qu'on le prend par un bout ou par un autre. On peut rsumer 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 diffrente de toutes les valeurs de Tab
pour qu'elle n'en fasse pas partie.
Voil la raison qui nous oblige passer par une variable boolenne, un drapeau qui peut se lever, mais jamais se
rabaisser. Et cette technique de flag (que nous pourrions lgamment surnommer gestion asymtrique de variable
boolenne ) doit tre mise en uvre chaque fois que lon se trouve devant pareille situation.
Autrement dit, connatre ce type de raisonnement est indispensable, et savoir le reproduire bon escient ne l'est pas
moins.
3. Tri de tableau + flag = tri bulles

Et maintenant, nous en arrivons la formule magique : tri de tableau + flag = tri bulles.
Lide de dpart du tri bulles consiste se dire quun tableau tri en ordre croissant, cest un tableau dans lequel tout
lment est plus petit que celui qui le suit.
En effet, prenons chaque lment dun tableau, et comparons-le avec llment qui le suit. Si lordre nest pas bon, on
permute ces deux lments. Et on recommence jusqu ce que lon nait plus aucune permutation effectuer. Les
59
Cours Algorithmique
lments les plus grands remontent ainsi peu peu vers les dernires places, ce qui explique la charmante
dnomination de tri bulle . Comme quoi lalgorithmique nexclut pas un minimum syndical de sens potique.
En quoi le tri bulles implique-t-il lutilisation dun flag ? Eh bien, par ce quon ne sait jamais par avance combien de
remontes de bulles on doit effectuer. En fait, tout ce quon peut dire, cest quon devra effectuer le tri jusqu ce quil
ny ait plus dlments qui soient mal classs. Ceci est typiquement un cas de question asymtrique : il suffit que
deux lments soient mal classs pour quun tableau ne soit pas tri. En revanche, il faut que tous les lments soient
bien rangs pour que le tableau soit tri.
Nous baptiserons le flag Yapermute, car cette variable boolenne va nous indiquer si nous venons ou non de procder
une permutation au cours du dernier balayage du tableau (dans le cas contraire, cest signe que le tableau est tri, et
donc quon peut arrter la machine bulles). La boucle principale sera alors :
TantQue Yapermute
FinTantQue
Que va-t-on faire lintrieur de la boucle ? Prendre les lments du tableau, du premier jusqu lavant-dernier, et
procder un change si ncessaire. Cest parti :
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
FinTantQue
Mais il ne faut pas oublier un dtail capital : la gestion de notre flag. Lide, cest que cette variable va nous signaler le
fait quil y a eu au moins une permutation effectue. Il faut donc :
lui attribuer la valeur Vrai ds quune seule permutation a t faite (il suffit quil y en ait eu une seule pour
quon doive tout recommencer encore une fois).
la remettre Faux chaque tour de la boucle principale (quand on recommence un nouveau tour gnral de
bulles, il ny a pas encore eu dlments changs),
dernier point, il ne faut pas oublier de lancer la boucle principale, et pour cela de donner la valeur Vrai au flag
au tout dpart de lalgorithme.
La solution complte donne donc :

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
60
Cours Algorithmique
Au risque de nous rpter, la comprhension et la matrise du principe du flag font partie de larsenal du programmeur
bien arm.
4. La recherche dichotomique
Nous allons terminer ce chapitre migraineux par une technique clbre de recherche, qui rvle toute son utilit
lorsque le nombre d'lments est trs lev. Par exemple, imaginons que nous ayons un programme qui doive vrifier
si un mot existe dans le dictionnaire. Nous pouvons supposer que le dictionnaire a t pralablement entr dans un
tableau ( raison d'un mot par emplacement). Ceci peut nous mener , disons la louche, 40 000 mots.
Une premire manire de vrifier si un mot se trouve dans le dictionnaire consiste examiner successivement tous les
mots du dictionnaire, du premier au dernier, et les comparer avec le mot vrifier. a marche, mais cela risque
d'tre long : si le mot ne se trouve pas dans le dictionnaire, le programme ne le saura qu'aprs 40 000 tours de boucle
! Et mme si le mot figure dans le dictionnaire, la rponse exigera tout de mme en moyenne 20 000 tours de boucle.
C'est beaucoup, mme pour un ordinateur.
Or, il y a une autre manire de chercher, bien plus intelligente pourrait-on dire, et qui met profit le fait que dans un
dictionnaire, les mots sont tris par ordre alphabtique. D'ailleurs, un tre humain qui cherche un mot dans le
dictionnaire ne lit jamais tous les mots, du premier au dernier : il utilise lui aussi le fait que les mots sont tris.
Pour une machine, quelle est la manire la plus rationnelle de chercher dans un dictionnaire ? C'est de comparer le
mot vrifier avec le mot qui se trouve pile poil au milieu du dictionnaire. Si le mot vrifier est antrieur dans l'ordre
alphabtique, on sait qu'on devra le chercher dornavant dans la premire moiti du dico. Sinon, on sait maintenant
qu'on devra le chercher dans la deuxime moiti.
A partir de l, on prend la moiti de dictionnaire qui nous reste, et on recommence : on compare le mot chercher
avec celui qui se trouve au milieu du morceau de dictionnaire restant. On carte la mauvaise moiti, et on
recommence, et ainsi de suite.
A force de couper notre dictionnaire en deux, puis encore en deux, etc. on va finir par se retrouver avec des morceaux
qui ne contiennent plus qu'un seul mot. Et si on n'est pas tomb sur le bon mot un moment ou un autre, c'est que le
mot vrifier ne fait pas partie du dictionnaire.
Regardons ce que cela donne en terme de nombre d'oprations effectuer, en choisissant le pire cas : celui o le mot
est absent du dictionnaire.
Au dpart, on cherche le mot parmi 40 000.
Aprs le test n1, on ne le cherche plus que parmi 20 000.
etc.
Aprs le test n15, on ne le cherche plus que parmi 2.
Aprs le test n16, on ne le cherche plus que parmi 1.
Et l, on sait que le mot n'existe pas.
Moralit : on a obtenu notre rponse en 16 oprations contre 40 000 prcdemment ! Il n'y a pas photo sur l'cart de
performances entre la technique barbare et la technique fute. Attention, toutefois, mme si c'est vident, rptons-le
avec force : la recherche dichotomique ne peut s'effectuer que sur des lments pralablement tris.
61
Cours Algorithmique
Eh bien maintenant quon vous a expliqu comment faire, vous n'avez plus qu' traduire !
Au risque de nous rpter, la comprhension et la matrise du principe du flag font partie de larsenal du programmeur
bien arm.
Exercice 7.1
Ecrivez un algorithme qui permette de saisir un nombre quelconque de valeurs, et qui les
range au fur et mesure dans un tableau. Le programme, une fois la saisie termine, doit dire
si les lments du tableau sont tous conscutifs ou non.
Par exemple, si le tableau est : 12 - 13 - 14 - 15 - 16 - 17 - 18, ses lments sont tous conscutifs.
Si le tableau est : 9 - 10 - 11 - 15 - 16 - 17, ses lments ne sont pas tous conscutifs.
Exercice 7.2
Ecrivez un algorithme qui trie un tableau dans lordre dcroissant
Vous crirez bien entendu deux versions de cet algorithme, l'une employant le tri par
insertion, l'autre le tri bulles.
Exercice 7.3
Ecrivez un algorithme qui inverse lordre des lments dun tableau dont on suppose qu'il a
t pralablement saisi ( les premiers seront les derniers )
Exercice 7.4
Ecrivez un algorithme qui permette lutilisateur de supprimer une valeur dun tableau
pralablement saisi. Lutilisateur donnera lindice de la valeur quil souhaite supprimer.
Attention, il ne sagit pas de remettre une valeur zro, mais bel et bien de la supprimer du
tableau lui-mme ! Si le tableau de dpart tait
12 8 4 45 64 9 2 7
Et que lutilisateur souhaite supprimer la valeur dindice 4, le nouveau tableau sera :
12 8 4 45 9 2 - 7
Exercice 7.5
Ecrivez l'algorithme qui recherche un mot saisi au clavier dans un dictionnaire. Le dictionnaire
est suppos tre cod dans un tableau pralablement rempli et tri.
62
Cours Algorithmique
PARTIE 8 (TABLEAUX MULTIDIMENSIONNELS)

Le vrai problme nest pas de savoir si les machines pensent, mais de savoir si les hommes pensent
B.F.Skinner
La question de savoir si un ordinateur peut penser n'est pas plus intressante que celle de savoir si un sousmarin peut nager
Edgar W. Dijkstra
Ceci nest pas un drglement de votre tlviseur. Nous contrlons tout, nous savons tout, et les phnomnes
paranormaux que vous constatez sont dus au fait que vous tes passs dans la quatrime dimension (musique
angoissante : tintintin ).
Oui, enfin bon, avant dattaquer la quatrime, on va dj se coltiner la deuxime.
1. Pourquoi plusieurs dimensions ?

Une seule ne suffisait-elle pas dj amplement notre bonheur, demanderez-vous ? Certes, mais vous allez voir
quavec deux (et davantage encore) cest carrment le nirvana.
Prenons le cas de la modlisation dun jeu de dames, et du dplacement des pions sur le damier. Rappelons quun
pion qui est sur une case blanche peut se dplacer (pour simplifier) sur les quatre cases blanches adjacentes.
Avec les outils que nous avons abords jusque l, le plus simple serait videmment de modliser le damier sous la
forme dun tableau. Chaque case est un emplacement du tableau, qui contient par exemple 0 si elle est vide, et 1 sil y
a un pion. On attribue comme indices aux cases les numros 1 8 pour la premire ligne, 9 16 pour la deuxime
ligne, et ainsi de suite jusqu 64.
Un pion plac dans la case numro i, autrement dit la valeur 1 de Cases(i), peut bouger vers les cases contigus en
diagonale. Cela va nous obliger de petites acrobaties intellectuelles : la case situe juste au-dessus de la case
numro i ayant comme indice i-8, les cases valables sont celles dindice i-7 et i-9. De mme, la case situe juste en
dessous ayant comme indice i+8, les cases valables sont celles dindice i+7 et i+9.
Bien sr, on peut fabriquer tout un programme comme cela, mais le moins quon puisse dire est que cela ne facilite
pas la clart de lalgorithme.
Il serait videmment plus simple de modliser un damier par un damier !
63
Cours Algorithmique
2. Tableaux deux dimensions

Linformatique nous offre la possibilit de dclarer des tableaux dans lesquels les valeurs ne sont pas repres par
une seule, mais par deux coordonnes.
Un tel tableau se dclare ainsi :
Tableau Cases(7, 7) en Entier
Cela veut dire : rserve moi un espace de mmoire pour 8 x 8 entiers, et quand on aura besoin de lune de ces
valeurs, on les reprera par deux indices (comme la bataille navale, ou Excel, la seule diffrence tant que pour les
coordonnes, on nutilise pas de lettres, juste des chiffres).
Pour notre problme de dames, les choses vont srieusement sclaircir. La case qui contient le pion est dornavant
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 ny a aucune diffrence qualitative entre un tableau deux dimensions ( i, j ) et un tableau
une dimension ( i * j ). De mme que le jeu de dames quon vient dvoquer, tout problme qui
peut tre modlis dune manire peut aussi tre modlis de lautre. Simplement, lune ou
lautre de ces techniques correspond plus spontanment tel ou tel problme, et facilite donc
(ou complique, si on a choisi la mauvaise option) lcriture et la lisibilit de lalgorithme.
Une autre remarque : une question classique propos des tableaux deux dimensions est de savoir si le premier
indice reprsente les lignes ou le deuxime les colonnes, ou linverse. Nous ne rpondrons pas cette question non
parce que nous avons dcid de bouder, mais parce quelle na aucun sens. Lignes et Colonnes sont des
concepts graphiques, visuels, qui sappliquent des objets du monde rel ; les indices des tableaux ne sont que des
coordonnes logiques, pointant sur des adresses de mmoire vive. Si cela ne vous convainc pas, pensez un jeu de
bataille navale classique : les lettres doivent-elles dsigner les lignes et les chiffres les colonnes ? Aucune
importance ! Chaque joueur peut mme choisir une convention diffrente, aucune importance ! Lessentiel est quune
fois une convention choisie, un joueur conserve la mme tout au long de la partie, bien entendu.
64
Cours Algorithmique
Exercice 8.1
Ecrivez un algorithme remplissant un tableau de 6 sur 13, avec des zros.
Exercice 8.2
Quel rsultat produira cet algorithme ?
Tableau X(1, 2) en Entier
Variables i, j, val en Entier
Dbut
Val 1
Pour i 0 1
Pour j 0 2
X(i, j) Val
Val Val + 1
j Suivant
i Suivant
Pour i 0 1
Pour j 0 2
Ecrire X(i, j)
j Suivant
i Suivant
Fin
Exercice 8.3
Tableau X(1, 2) en Entier
Variables i, j, val en Entier
Dbut
Val 1
Pour i 0 1
Pour j 0 2
X(i, j) Val
Val Val + 1
j Suivant
i Suivant
Pour j 0 2
Pour i 0 1
Ecrire X(i, j)
i Suivant
j Suivant
Fin
65
Cours Algorithmique
Exercice 8.4
Tableau T(3, 1) en Entier
Variables k, m, en Entier
Dbut
Pour k 0 3
Pour m 0 1
T(k, m) k + m
m Suivant
k Suivant
Pour k 0 3
Pour m 0 1
Ecrire T(k, m)
m Suivant
k Suivant
Fin
Exercice 8.5
Mmes questions, en remplaant la ligne :
T(k, m)
k + m
a)
T(k, m)
2 * k + (m + 1)
b)
T(k, m)
(k + 1) + 4 * m
par
Exercice 8.6
Soit un tableau T deux dimensions (12, 8) pralablement rempli de valeurs numriques.
Ecrire un algorithme qui recherche la plus grande valeur au sein de ce tableau.
66
Cours Algorithmique
Exercice 8.7
Ecrire un algorithme de jeu de dames trs simplifi.
Lordinateur demande lutilisateur dans quelle case se trouve son pion (quelle ligne,
quelle colonne). On met en place un contrle de saisie afin de vrifier la validit des
valeurs entres.
Ensuite, on demande lutilisateur quel mouvement il veut effectuer : 0 (en haut
gauche), 1 (en haut droite), 2 (en bas gauche), 3 (en bas droite).
Si le mouvement est impossible (i.e. on sort du damier ), on le signale lutilisateur et on
sarrte l . Sinon, on dplace le pion et on affiche le damier rsultant, en affichant un
O pour une case vide et un X pour la case o se trouve le pion.
3. Tableaux n dimensions
Si vous avez compris le principe des tableaux deux dimensions, sur le fond, il ny a aucun problme passer au
maniement de tableaux trois, quatre, ou pourquoi pas neuf dimensions. Cest exactement la mme chose. Si on
dclare un tableau Titi(2, 4, 3, 3), il sagit dun espace mmoire contenant 3 x 5 x 4 x 4 = 240 valeurs. Chaque valeur y
est repre par quatre coordonnes.
Le principal obstacle au maniement systmatique de ces tableaux plus de trois dimensions est que le programmeur,
quand il conoit son algorithme, aime bien faire des petits gribouillis, des dessins immondes, imaginer les boucles
dans sa tte, etc. Or, autant il est facile dimaginer concrtement un tableau une dimension, autant cela reste
faisable pour deux dimensions, autant cela devient lapanage dune minorit privilgie pour les tableaux trois
dimensions et hors de porte de tout mortel au-del. Cest comme a, lesprit humain a du mal se reprsenter les
choses dans lespace, et crie grce ds quil saute dans lhyperespace (oui, cest comme a que a sappelle au del
de trois dimensions).
Donc, pour des raisons uniquement pratiques, les tableaux plus de trois dimensions sont rarement utiliss par des
programmeurs non matheux (car les matheux, de par leur formation, ont une fcheuse propension manier des
espaces n dimensions comme qui rigole, mais ce sont bien les seuls, et laissons les dans leur coin, cest pas des
gens comme nous).
67
Cours Algorithmique
PARTIE 9 (LES FONCTIONS PRDFINIES)

Il y a deux mthodes pour crire des programmes sans erreurs. Mais il ny a que la troisime qui marche
Anonyme
Certains traitements ne peuvent tre effectus par un algorithme, aussi savant soit-il. Dautres ne peuvent ltre quau
prix de souffrances indicibles.
Cest par exemple le cas du calcul du sinus dun angle : pour en obtenir une valeur approche, il faudrait appliquer une
formule dune complexit vous glacer le sang. Aussi, que se passe-t-il sur les petites calculatrices que vous
connaissez tous ? On vous fournit quelques touches spciales, dites touches de fonctions, qui vous permettent par
exemple de connatre immdiatement ce rsultat. Sur votre calculatrice, si vous voulez connatre le sinus de 35, vous
taperez 35, puis la touche SIN, et vous aurez le rsultat.
Tout langage de programmation propose ainsi un certain nombre de fonctions ; certaines sont indispensables, car
elles permettent deffectuer des traitements qui seraient sans elles impossibles. Dautres servent soulager le
programmeur, en lui pargnant de longs et pnibles - algorithmes.
1. Structure gnrale des fonctions

Reprenons lexemple du sinus. Les langages informatiques, qui se doivent tout de mme de savoir faire la mme
chose quune calculatrice 19F90, proposent gnralement une fonction SIN. Si nous voulons stocker le sinus de 35
dans la variable A, nous crirons :
A
Sin(35)
Une fonction est donc constitue de trois parties :
le nom proprement dit de la fonction. Ce nom ne sinvente pas ! Il doit imprativement correspondre une
fonction propose par le langage. Dans notre exemple, ce nom est SIN.
deux parenthses, une ouvrante, une fermante.
une liste de valeurs, indispensables la bonne excution de la fonction. Ces valeurs sappellent des
arguments, ou des paramtres. Certaines fonctions exigent un seul argument, dautres deux, etc. et dautres
encore aucun. A noter que mme dans le cas de ces fonctions nexigeant aucun argument, les parenthses
restent obligatoires. Le nombre darguments ncessaire pour une fonction donne ne sinvente pas : il est
fix par le langage. Par exemple, la fonction sinus a besoin dun argument (ce nest pas surprenant, cet
argument est la valeur de langle). Si vous essayez de lexcuter en lui donnant deux arguments, ou aucun,
cela dclenchera une erreur lexcution. Notez galement que les arguments doivent tre dun certain
type, et quil faut respecter ces types.
68
Cours Algorithmique
Exercice 9.1
Parmi ces affectations (considres indpendamment les unes des autres), lesquelles
provoqueront des erreurs, et pourquoi ?
Variables A, B, C en Numrique
Variables D, E en Caractre
...
A
...
A
...
B
...
D
...
C
Sin(B)
Sin(A + B * C)
Sin(A) Sin(D)
Sin(A / B)
Cos(Sin(A)
2. Les fonctions de texte

Une catgorie privilgie de fonctions est celle qui nous permet de manipuler des chanes de caractres. Nous avons
dj vu quon pouvait facilement coller deux chanes lune lautre avec loprateur de concatnation &. Mais ce
que nous ne pouvions pas faire, et qui va tre maintenant possible, cest pratiquer des extractions de chanes (moins
douloureuses, il faut le noter, que les extractions dentaires).
Tous les langages proposent peu ou prou les fonctions suivantes, mme si le nom et la syntaxe peuvent varier dun
langage lautre :
Len(chane) : renvoie le nombre de caractres dune chane.
Mid(chane,n1,n2) : renvoie un extrait de la chane, commenant au caractre n1 et faisant n2 caractres de long.
Ce sont les deux seules fonctions de chanes rellement indispensables. Cependant, pour nous pargner des
algorithmes fastidieux, les langages proposent galement :
Left(chane,n) : renvoie les n caractres les plus gauche dans chane.
Right(chane,n) : renvoie les n caractres les plus droite dans chane.
Trouve(chane1,chane2) : renvoie un nombre correspondant la position de chane2 dans chane1. Si chane2 nest
pas comprise dans chane1, la fonction renvoie zro.
Exemples :
Len(Bonjour, a va ?)
Len()
Mid(Zorro is back, 4, 7)
Mid(Zorro is back, 12, 1)
Left(Et pourtant, 8)
Right(Et pourtant, 4)
Trouve(Un pur bonheur, pur)
Trouve(Un pur bonheur, techno)
vaut
vaut
vaut
vaut
vaut
vaut
vaut
vaut
16
0
ro is b
c
Et pourt
t
4
0
69
Cours Algorithmique
Il existe aussi dans tous les langages une fonction qui renvoie le caractre correspondant un code Ascii donn
(fonction Asc), et Lyce de Versailles (fonction Chr) :
Asc(N)
Chr(63)
vaut
vaut
78
?
Nous insistons ; moins de programmer avec un langage un peu particulier, comme le C, qui traite en ralit les
chanes de caractres comme des tableaux, on ne pourrait pas se passer des deux fonctions Len et Mid pour traiter
les chanes. Or, si les programmes informatiques ont frquemment traiter des nombres, ils doivent tout aussi
frquemment grer des sries de caractres (des chanes). Bien vrai que cela devient un refrain, mais connatre les
techniques de base sur les chanes est plus quutile : cest indispensable.
Exercice 9.2
Ecrivez un algorithme qui demande un mot lutilisateur et qui affiche lcran le nombre
de lettres de ce mot (c'est vraiment tout bte).
Exercice 9.3
Ecrivez un algorithme qui demande une phrase lutilisateur et qui affiche lcran le
nombre de mots de cette phrase. On suppose que les mots ne sont spars que par des
espaces (et c'est dj un petit peu moins bte).
Exercice 9.4
nombre de voyelles contenues dans cette phrase.
On pourra crire deux solutions. La premire dploie une condition compose bien
fastidieuse. La deuxime, en utilisant la fonction Trouve, allge considrablement
l'algorithme.
Exercice 9.5
Ecrivez un algorithme qui demande une phrase lutilisateur. Celui-ci entrera ensuite le rang
dun caractre supprimer, et la nouvelle phrase doit tre affiche (on doit rellement
supprimer le caractre dans la variable qui stocke la phrase, et pas uniquement lcran).
70
Cours Algorithmique
Exercice 9.6 - Cryptographie 1

Un des plus anciens systmes de cryptographie (aisment dchiffrable) consiste dcaler les
lettres dun message pour le rendre illisible. Ainsi, les A deviennent des B, les B des C, etc.
Ecrivez un algorithme qui demande une phrase lutilisateur et qui la code selon ce principe.
Comme dans le cas prcdent, le codage doit seffectuer au niveau de la variable stockant la
phrase, et pas seulement lcran.
3. Trois fonctions numriques classiques

Partie Entire
Une fonction extrmement rpandue est celle qui permet de rcuprer la partie entire dun nombre :
Aprs :
Ent(3,228)
A vaut 3
Cette fonction est notamment indispensable pour effectuer le clbrissime test de parit (voir exercice dans pas
longtemps).
Modulo
Cette fonction permet de rcuprer le reste de la division dun nombre par un deuxime nombre. Par exemple :
A
B
C
Mod(10,3)
Mod(12,2)
Mod(44,8)
A vaut 1 car 10 = 3*3 + 1

B vaut 0 car 12 = 6*2
C vaut 4 car 44 = 5*8 + 4
Cette fonction peut paratre un peu bizarre, est rserve aux seuls matheux. Mais vous aurez l aussi loccasion de
voir dans les exercices venir que ce nest pas le cas.
Gnration de nombres alatoires

Une autre fonction classique, car trs utile, est celle qui gnre un nombre choisi au hasard.
Tous les programmes de jeu, ou presque, ont besoin de ce type doutils, quil sagisse de simuler un lancer de ds ou
le dplacement chaotique du vaisseau spatial de lenfer de la mort pilot par linfme Zorglub, qui veut faire main
basse sur lUnivers (heureusement vous tes l pour len empcher, ouf).
Mais il ny a pas que les jeux qui ont besoin de gnrer des nombres alatoires. La modlisation (physique,
gographique, conomique, etc.) a parfois recours des modles dits stochastiques. Ce sont des modles dans
lesquels les variables se dduisent les unes des autres par des relations dterministes (autrement dit des calculs),
mais o lon simule la part dincertitude par une fourchette de hasard.
Par exemple, un modle dmographique supposera quune femme a en moyenne x enfants au cours de sa vie,
mettons 1,5. Mais il supposera aussi que sur une population donne, ce chiffre peut fluctuer entre 1,35 et 1,65 (si on
71
Cours Algorithmique
laisse une part dincertitude de 10%). Chaque anne, cest--dire chaque srie de calcul des valeurs du modle, on
aura ainsi besoin de faire choisir la machine un nombre au hasard compris entre 1,35 et 1,65.
Dans tous les langages, cette fonction existe et produit le rsultat suivant :
Aprs :
Toto
Alea()
On a :
0 =< Toto < 1
En fait, on se rend compte avec un tout petit peu de pratique que cette fonction Ala peut nous servir pour gnrer
nimporte quel nombre compris dans nimporte quelle fourchette. Nous savons bien que nos lecteurs ne sont gure
matheux, mais l, on reste franchement en de du niveau de feu le BEPC :
si Alea gnre un nombre compris entre 0 et 1, Alea multipli par z produit un nombre entre 0 et z. Donc, il
faut estimer la largeur de la fourchette voulue et multiplier Alea par cette largeur dsire.
ensuite, si la fourchette ne commence pas zro, il va suffire dajouter ou de retrancher quelque chose
pour caler la fourchette au bon endroit.
Par exemple, si je veux gnrer un nombre entre 1,35 et 1,65 ; la fourchette mesure 0,30 de large. Donc :
0 =< Alea()*0,30 < 0,30
Il suffit dajouter 1,35 pour obtenir la fourchette voulue. Si on crit que :
Toto Alea()*0,30 + 1,35
Toto aura bien une valeur comprise entre 1,35 et 1,65. Et le tour est jou !
Bon, il est grand temps que vous montriez ce que vous avez appris
Exercice 9.7 - Cryptographie 2 - le chiffre de Csar

Une amlioration (relative) du principe prcdent consiste oprer avec un dcalage non
de 1, mais dun nombre quelconque de lettres. Ainsi, par exemple, si lon choisit un
dcalage de 12, les A deviennent des M, les B des N, etc.
Ralisez un algorithme sur le mme principe que le prcdent, mais qui demande en
plus quel est le dcalage utiliser. Votre sens proverbial de l'lgance vous interdira bien
sr une srie de vingt-six "Si...Alors"

Une technique ultrieure de cryptographie consista oprer non avec un dcalage
systmatique, mais par une substitution alatoire. Pour cela, on utilise un alphabet-cl,
dans lequel les lettres se succdent de manire dsordonne, par exemple :
HYLUJPVREAKBNDOFSQZCWMGITX
Cest cette cl qui va servir ensuite coder le message. Selon notre exemple, les A
deviendront des H, les B des Y, les C des L, etc.
Ecrire un algorithme qui effectue ce cryptage (lalphabet-cl sera saisi par lutilisateur, et
on suppose qu'il effectue une saisie correcte).
72
Cours Algorithmique
Exercice 9.9 - Cryptographie 4 - le chiffre de Vigenre

Un systme de cryptographie beaucoup plus difficile briser que les prcdents fut
invent au XVIe sicle par le franais Vigenre. Il consistait en une combinaison de
diffrents chiffres de Csar.
On peut en effet crire 25 alphabets dcals par rapport lalphabet normal :
-
lalphabet qui commence par B et finit par YZA

lalphabet qui commence par C et finit par ZAB
etc.
Le codage va seffectuer sur le principe du chiffre de Csar : on remplace la lettre

dorigine par la lettre occupant la mme place dans lalphabet dcal.
Mais la diffrence du chiffre de Csar, un mme message va utiliser non un, mais
plusieurs alphabets dcals. Pour savoir quels alphabets doivent tre utiliss, et dans
quel ordre, on utilise une cl.
Si cette cl est VIGENERE et le message Il faut coder cette phrase , on procdera
comme suit :
La premire lettre du message, i , est la 9e lettre de lalphabet normal. Elle doit tre
code en utilisant lalphabet commenant par la premire lettre de la cl, V . Dans cet
alphabet, la 9e lettre est le d . i devient donc d
La deuxime lettre du message, l , est la 11e lettre de lalphabet normal. Elle doit tre
code en utilisant lalphabet commenant par la deuxime lettre de la cl, I . Dans cet
alphabet, la 11e lettre est le s . l devient donc s , etc.
Quand on arrive la dernire lettre de la cl, on recommence la premire.
Ecrire lalgorithme qui effectue un cryptage de Vigenre, en demandant bien sr au
dpart la cl lutilisateur.
Exercice 9.10
Ecrivez un algorithme qui demande un nombre entier lutilisateur. Lordinateur affiche
ensuite le message Ce nombre est pair ou Ce nombre est impair selon le cas.
73
Cours Algorithmique
Exercice 9.11
Ecrivez les algorithmes qui gnrent un nombre Glup alatoire tel que
a) 0 =< Glup < 2
b) 1 =< Glup < 1
c) 1,35 =< Glup < 1,65
d) Glup mule un d six faces
e) 10,5 =< Glup < +6,5
f) Glup mule la somme du jet simultan de deux ds six faces
4. Les fonctions de conversion

Dernire grande catgorie de fonctions, l aussi disponibles dans tous les langages, car leur rle est parfois
incontournable, les fonctions dites de conversion.
Rappelez-vous ce que nous avons vu dans les premires pages de ce cours : il existe diffrents types de variables,
qui dterminent notamment le type de codage qui sera utilis. Prenons le chiffre 3. Si on le stocke dans une variable
de type alphanumrique, il sera cod en tant que caractre, sur un octet. Si en revanche on le stocke dans une
variable de type entier, il sera cod sur deux octets. Et la configuration des bits sera compltement diffrente dans les
deux cas.
Une conclusion vidente, et sur laquelle on a dj eu l'occasion d'insister, c'est qu'on ne peut pas faire n'importe quoi
avec n'importe quoi, et qu'on ne peut pas par exemple multiplier "3" et "5", si 3 et 5 sont stocks dans des variables de
type caractre.
Pourquoi ne pas en tirer les consquences, et stocker convenablement les nombres dans des variables numriques,
les caractres dans des variables alphanumriques, comme nous l'avons toujours fait ?
Parce qu'il y a des situations o on n'a pas le choix ! Nous allons voir ds le chapitre suivant un mode de stockage (les
fichiers textes) o toutes les informations, quelles qu'elles soient, sont obligatoirement stockes sous forme de
caractres. Ds lors, si l'on veut pouvoir rcuprer des nombres et faire des oprations dessus, il va bien falloir tre
capable de convertir ces chanes en numriques.
Aussi, tous les langages proposent-ils une palette de fonctions destines oprer de telles conversions. On trouvera
au moins une fonction destine convertir une chane en numrique (appelons-la Cnum en pseudo-code), et une
convertissant un nombre en caractre (Ccar).
74
Cours Algorithmique
PARTIE 10 (LES FICHIERS)

On ne peut pas davantage crer des fichiers numriques non copiables que crer de leau non humide
Bruce Schneier
Jusqu prsent, les informations utilises dans nos programmes ne pouvaient provenir que de deux sources : soit
elles taient inclues dans lalgorithme lui-mme, par le programmeur, soit elles taient entres en cours de route par
lutilisateur. Mais videmment, cela ne suffit pas combler les besoins rels des informaticiens.
Imaginons que lon veuille crire un programme grant un carnet dadresses. Dune excution du programme
lautre, lutilisateur doit pouvoir retrouver son carnet jour, avec les modifications quil y a apportes la dernire fois
quil a excut le programme. Les donnes du carnet dadresse ne peuvent donc tre inclues dans lalgorithme, et
encore moins tre entres au clavier chaque nouvelle excution !
Les fichiers sont l pour combler ce manque. Ils servent stocker des informations de manire permanente, entre
deux excutions dun programme. Car si les variables, qui sont, rappelons-le des adresses de mmoire vive,
disparaissent chaque fin dexcution, les fichiers, eux sont stocks sur des priphriques mmoire de masse
(disquette, disque dur, CD Rom).
1. Organisation des fichiers

Vous connaissez tous le coup des papous : chez les papous, il y a les papous papas et les papous pas papas. Chez
les papous papas, il y a les papous papas poux et les papous papas pas poux, etc. Eh bien les fichiers, c'est un
peu pareil : il y a des catgories, et dans les catgories, des sortes, et dans les sortes des espces. Essayons donc de
dbroussailler un peu tout cela...
Un premier grand critre, qui diffrencie les deux grandes catgories 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 mme
genre d'information chaque ligne. Ces lignes sont alors appeles des enregistrements.
Afin d'illuminer ces propos obscurs, prenons le cas classique, celui d'un carnet d'adresses. Le fichier est destin
mmoriser les coordonnes (ce sont toujours les plus mal chausses, bien sr) d'un certain nombre de personnes.
Pour chacune, il faudra noter le nom, le prnom, le numro de tlphone et l'email. Dans ce cas, il peut paratre plus
simple de stocker une personne par ligne du fichier (par enregistrement). Dit autrement, quand on prendra une ligne,
on sera sr 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 stocks les octets correspondants aux caractres CR (code Ascii 13) et LF
(code Ascii 10), signifiant un retour au dbut de la ligne suivante. Le plus souvent, le langage de programmation, ds
75
Cours Algorithmique
lors qu'il s'agit d'un fichier texte, grera lui-mme la lecture et l'criture de ces deux caractres 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 ds lors que l'on doit stocker des informations pouvant tre assimiles une
base de donnes.
Le second type de fichier, vous l'aurez devin, se dfinit a contrario : il rassemble les fichiers qui ne possdent pas de
structure de lignes (d'enregistrement). Les octets, quels qu'il soient, sont crits la queue leu leu. Ces fichiers sont
appels des fichiers binaires. Naturellement, leur structure diffrente implique un traitement diffrent par le
programmeur. Tous les fichiers qui ne codent pas une base de donnes sont obligatoirement des fichiers binaires :
cela concerne par exemple un fichier son, une image, un programme excutable, etc. Toutefois, on en dira quelques
mots un peu plus loin, il est toujours possible d'opter pour une structure binaire mme dans le cas o le fichier
reprsente une base de donnes.
Autre diffrence majeure entre fichiers texte et fichiers binaires : dans un fichier texte, toutes les donnes sont crites
sous forme de... texte. Cela veut dire que les nombres y sont reprsents sous forme de suite de chiffres (des chanes
de caractres). Ces nombres doivent donc tre convertis en chanes lors de l'criture dans le fichier. Inversement, lors
de la lecture du fichier, on devra convertir ces chanes en nombre si l'on veut pouvoir les utiliser dans des calculs. En
revanche, dans les fichiers binaires, les donnes sont crites l'image exacte de leur codage en mmoire vive, ce qui
pargne toutes ces oprations de conversion.
Ceci a comme autre implication qu'un fichier texte est lisible, alors qu'un fichier binaire ne l'est pas (sauf bien sr en
crivant soi-mme un programme appropri). Si l'on ouvre un fichier texte via un diteur de textes, comme le blocnotes de Windows, on y reconnatra toutes les informations (ce sont des caractres, stocks comme tels). La mme
chose avec un fichier binaire ne nous produit l'cran qu'un galimatias de scribouillis incomprhensibles.
2. Structure des enregistrements

Savoir que les fichiers peuvent tre structurs en enregistrements, c'est bien. Mais savoir comment sont leur tour
structurs ces enregistrements, c'est mieux. Or, l aussi, il y a deux grandes possibilits. Ces deux grandes variantes
pour structurer les donnes au sein dun fichier texte sont la dlimitation et les champs de largeur fixe.
Reprenons le cas du carnet dadresses, avec dedans le nom, le prnom, le tlphone et l'email. Les donnes, sur le
fichier texte, peuvent tre organises ainsi :
Structure n1
Fonfec;Sophie;0142156487;fonfec@yahoo.fr
Ztofrais;Mlanie;0456912347;ztofrais@free.fr
Herbien;Jean-Philippe;0289765194;vantard@free.fr
Hergbel;Octave;0149875231;rg@aol.fr
ou ainsi :
76
Cours Algorithmique
Structure n2
Fonfec
Sophie
0142156487fonfec@yahoo.fr
Ztofrais
Herbien
Mlanie
Jean-Philippe
0456912347ztofrais@free.fr
0289765194vantard@free.fr
Hergbel
Octave
0149875231rg@aol.fr
La structure n1 est dite dlimite ; Elle utilise un caractre spcial, appel caractre de dlimitation, qui permet de
reprer quand finit un champ et quand commence le suivant. Il va de soi que ce caractre de dlimitation doit tre
strictement interdit lintrieur de chaque champ, faute de quoi la structure devient proprement illisible.
La structure n2, elle, est dite champs de largeur fixe. Il ny a pas de caractre de dlimitation, mais on sait que les x
premiers caractres de chaque ligne stockent le nom, les y suivants le prnom, etc. Cela impose bien entendu de ne
pas saisir un renseignement plus long que le champ prvu pour laccueillir.
Lavantage de la structure n1 est son faible encombrement en place mmoire ; il ny a aucun espace perdu,
et un fichier texte cod de cette manire occupe le minimum de place possible. Mais elle possde en
revanche un inconvnient majeur, qui est la lenteur de la lecture. En effet, chaque fois que lon rcupre une
ligne dans le fichier, il faut alors parcourir un par un tous les caractres pour reprer chaque occurrence du
caractre de sparation avant de pouvoir dcouper cette ligne en diffrents champs.
La structure n2, linverse, gaspille de la place mmoire, puisque le fichier est un vrai gruyre plein de trous.
Mais dun autre ct, la rcupration des diffrents champs est trs rapide. Lorsquon rcupre une ligne, il
suffit de la dcouper en diffrentes chanes de longueur prdfinie, et le tour est jou.
A lpoque o la place mmoire cotait cher, la structure dlimite tait souvent privilgie. Mais depuis bien des
annes, la quasi-totalit des logiciels et des programmeurs optent pour la structure en champs de largeur fixe.
Aussi, sauf mention contraire, nous ne travaillerons quavec des fichiers btis sur cette structure.
Remarque importante : lorsqu'on choisit de coder une base de donnes sous forme de champs de largeur fixe, on peut
alors trs 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 trs facilement rcuprer
les informations : si nous savons que dans notre carnet d'adresse, chaque individu occupe 75 octets, alors dans notre
fichier binaire, nous dduisons que l'individu n1 occupe les octets 1 75, l'individu n2 les octets 76 150, l'individu
n3 les octets 151 225, etc.
3. Types daccs
On vient de voir que lorganisation des donnes au sein des enregistrements du fichier pouvait seffecteur selon deux
grands choix stratgiques. Mais il existe une autre ligne de partage des fichiers : le type daccs, autrement dit la
manire dont la machine va pouvoir aller rechercher les informations contenues dans le fichier.
On distingue :
Laccs squentiel : on ne peut accder qu la donne suivant celle quon vient de lire. On ne peut donc
accder une information qu'en ayant au pralable examin celle qui la prcde. Dans le cas d'un fichier
texte, cela signifie qu'on lit le fichier ligne par ligne (enregistrement par enregistrement).
77
Cours Algorithmique
Laccs direct (ou alatoire) : on peut accder directement lenregistrement de son choix, en prcisant le
numro de cet enregistrement. Mais cela veut souvent dire une gestion fastidieuse des dplacements dans
le fichier.
Laccs index : pour simplifier, il combine la rapidit de l'accs direct et la simplicit de l'accs squentiel
(en restant toutefois plus compliqu). Il est particulirement adapt au traitement des gros fichiers, comme
les bases de donnes importantes.
A la diffrence de la prcdente, cette typologie ne se reflte pas dans la structure elle-mme du fichier. En fait, tout
fichier peut tre utilis avec lun ou lautre des trois types daccs. Le choix du type daccs nest pas un choix qui
concerne le fichier lui-mme, mais uniquement la manire dont il va tre trait par la machine. Cest donc dans le
programme, et seulement dans le programme, que lon choisit le type daccs souhait.
Pour conclure sur tout cela, voici un petit tableau rcapitulatif :
On les utilise pour stocker...

Ils
sont
structurs
Fichiers Texte
Fichiers Binaires
des bases de donnes
tout, y compris des bases de donnes.
sous lignes (enregistrements)
forme de...
Ils n'ont pas de structure apparente. Ce

sont des octets crits la suite les uns
des autres.
Les donnes y sont crites...

Les
enregistrements
exclusivement en tant que caractres
comme en mmoire vive
sont au choix, avec un sparateur ou en en champs de largeur fixe, s'il s'agit d'un
eux-mmes structurs...
champs de largeur fixe
Lisibilit
Le fichier est lisible clairement avec Le

n'importe quel diteur de texte
Lecture du fichier
fichier codant des enregistrements

fichier
l'apparence
d'une
suite
d'octets illisibles
On ne peut lire le fichier que ligne par On peut lire les octets de son choix (y
ligne
compris la totalit du fichier d'un coup)
Dans le cadre de ce cours, on se limitera volontairement au type de base : le fichier texte en accs squentiel. Pour
des informations plus compltes sur la gestion des fichiers binaires et des autres types d'accs, il vous faudra...
chercher ailleurs.
4. Instructions (fichiers texte en accs squentiel)

Si lon veut travailler sur un fichier, la premire chose faire est de louvrir. Cela se fait en attribuant au fichier un
numro de canal. On ne peut ouvrir quun seul fichier par canal, mais quel que soit le langage, on dispose toujours de
plusieurs canaux, donc pas de soucis.
Limportant est que lorsquon ouvre un fichier, on stipule ce quon va en faire : lire, crire ou ajouter.
Si on ouvre un fichier pour lecture, on pourra uniquement rcuprer les informations quil contient, sans les
modifier en aucune manire.
78
Cours Algorithmique
Si on ouvre un fichier pour criture, on pourra mettre dedans toutes les informations que lon veut. Mais les
informations prcdentes, si elles existent, seront intgralement crases. Et on ne pourra pas accder aux
informations qui existaient prcdemment.
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 (rappelons qu'au terme de lignes,
on prfrera celui denregistrements).
Au premier abord, ces limitations peuvent sembler infernales. Au deuxime abord, elles le sont effectivement. Il n'y a
mme pas d'instructions qui permettent de supprimer un enregistrement d'un fichier !
Toutefois, avec un peu dhabitude, on se rend compte que malgr tout, mme si ce nest pas toujours marrant, on peut
quand mme faire tout ce quon veut avec ces fichiers squentiels.
Pour ouvrir un fichier texte, on crira par exemple :
Ouvrir Exemple.txt sur 4 pour Lecture
Ici, Exemple.txt est le nom du fichier sur le disque dur, 4 est le numro de canal, et ce fichier a donc t ouvert en
lecture. Vous laviez sans doute pressenti. Allons plus loin :
Ouvrir Exemple.txt sur 4 en Lecture
Variables Truc, Nom, Prnom, Tel, Mail en Caractres
...
LireFichier 4, Truc
Nom
Prnom
Tel
Mid(Truc, 1, 20)
Mail
Mid(Truc, 21, 15)
Mid(Truc, 36, 10)

Mid(Truc, 46, 20)
Linstruction LireFichier rcupre donc dans la variable spcifie lenregistrement suivant dans le fichier... "suivant",
oui, mais par rapport quoi ? Par rapport au dernier enregistrement lu. Cest en cela que le fichier est dit squentiel.
En loccurrence, on rcupre donc la premire 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 trononner cette variable Truc en
autant de morceaux quil y a de champs dans lenregistrement, et denvoyer ces tronons dans diffrentes variables.
Et le tour est jou.
La suite du raisonnement simpose avec une logique impitoyable : lire un fichier squentiel de bout en bout suppose
de programmer une boucle. Comme on sait rarement lavance combien denregistrements 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 supplmentaire dclencherait une erreur).
Lalgorithme, ultra classique, en pareil cas est donc :
Variable Truc en Caractre
Tantque Non EOF(5)
LireFichier 5, Truc
FinTantQue
79
Cours Algorithmique
Et neuf fois sur dix galement, si lon veut stocker au fur et mesure en mmoire vive les informations lues dans le
fichier, on a recours des tableaux. Et comme on ne savait pas davance combien il y aurait denregistrements dans le
fichier, on ne sait pas davantage combien il doit y avoir demplacements dans les tableaux. Quimporte, les
programmeurs avertis que vous tes connaissent la combine des tableaux dynamiques.
En rassemblant lensemble des connaissances acquises, nous pouvons donc crire le prototype de lecture intgrale
dun fichier squentiel, lecture qui recopie lensemble des informations en mmoire vive :
Tableaux Nom(), Prnom(), Tel(), Mail() en Caractre
i
-1
Tantque Non EOF(5)

LireFichier 5, Truc
i
i + 1
Redim Nom(i)
Redim Prnom(i)
Redim Tel(i)
Redim Mail(i)
Nom(i)
Mid(Truc,
Prnom(i)
Tel(i)
Mail(i)
1, 20)
Mid(Truc, 21, 15)
Mid(Truc, 36, 10)

Mid(Truc, 46, 20)
FinTantQue
Ici, on a fait le choix de recopier le fichier dans quatre tableaux distincts. Comme on va le voir bientt, il y a encore
mieux, mais ne nous impatientons pas, chaque chose en son temps.
Pour une opration dcriture, ou dajout, il faut dabord constituer une chane quivalente la nouvelle ligne du fichier.
Cette chane doit donc tre calibre de la bonne manire, avec les diffrents champs qui tombent aux
emplacements corrects. Le moyen le plus simple pour spargner de longs traitements est de procder avec des
chanes correctement dimensionnes ds leur dclaration (la plupart des langages offrent cette possibilit) :
Ouvrir Exemple.txt sur 3 en Ajout
Variables Nom*20, Prnom*15, Tel*10, Mail*20 en Caractre
une telle dclaration assure que quel que soit le contenu de la variable Nom, par exemple, celle-ci comptera toujours
20 caractres. Si son contenu est plus petit, alors un nombre correct despaces sera automatiquement ajout pour
combler. Si on tente dy entrer un contenu trop long, celui-ci sera automatiquement tronqu.
Nom
Prnom
Tel
Jokers
Midnight
0348946532
Mail
allstars@rockandroll.com
Truc
Nom & Prnom & Tel & Mail
EcrireFichier 3, Truc
80
Cours Algorithmique
Et pour finir, une fois quon en a termin avec un fichier, il ne faut pas oublier de fermer ce fichier. On libre ainsi le
canal quil occupait (et accessoirement, on pourra utiliser ce canal dans la suite du programme pour un autre fichier
ou pour le mme).
Exercice 10.1
Quel rsultat cet algorithme produit-il ?
Tantque Non EOF(5)
LireFichier 5, Truc
Ecrire Truc
FinTantQue
Fermer 5
Exercice 10.2
Ecrivez lalgorithme qui produit un rsultat similaire au prcdent, mais le fichier texte
Exemple.txt est cette fois de type dlimit (caractre de dlimitation : /). On produira
l'cran un affichage o pour des raisons esthtiques, ce caractre sera remplac avec des
espaces.
Exercice 10.3
On travaille avec le fichier du carnet dadresses en champs de largeur fixe.
Ecrivez un algorithme qui permet lutilisateur de saisir au clavier un nouvel individu qui
sera ajout ce carnet dadresses.
5. Stratgies de traitement
Il existe globalement deux manires de traiter les fichiers textes :
lune consiste sen tenir au fichier proprement dit, c'est--dire modifier directement les informations sur
le disque dur. Cest parfois un peu acrobatique, lorsquon veut supprimer un lment dun fichier : on
programme alors une boucle avec un test, qui recopie dans un deuxime fichier tous les lments du
premier fichier sauf un ; et il faut ensuite recopier intgralement le deuxime fichier la place du premier
fichier Ouf.
lautre stratgie consiste, comme on la vu, passer par un ou plusieurs tableaux. En fait, le principe
fondamental de cette approche est de commencer, avant toute autre chose, par recopier lintgralit du
fichier de dpart en mmoire vive. Ensuite, on ne manipule que cette mmoire vive (concrtement, un ou
plusieurs tableaux). Et lorsque le traitement est termin, on recopie nouveau dans l'autre sens, depuis la
mmoire vive vers le fichier dorigine.
81
Cours Algorithmique
Les avantages de la seconde technique sont nombreux, et 99 fois sur 100, c'est ainsi qu'il faudra procder :
la rapidit : les accs en mmoire vive sont des milliers de fois plus rapides (nanosecondes) que les accs
aux mmoires de masse (millisecondes au mieux pour un disque dur). En basculant le fichier du dpart dans
un tableau, on minimise le nombre ultrieur d'accs disque, tous les traitements tant ensuite effectus en
mmoire.
la facilit de programmation : bien quil faille crire les instructions de recopie du fichier dans le tableau, pour
peu quon doive tripoter les informations dans tous les sens, cest largement plus facile de faire cela avec un
tableau quavec des fichiers.
Pourquoi, alors, demanderez-vous haletants, ne fait-on pas cela tous les coups ? Y a-t-il des cas o il vaut mieux en
rester aux fichiers et ne pas passer par des tableaux ?
la recopie dun trs gros fichier en mmoire vive exige des ressources qui peuvent atteindre des dimensions
considrables. Donc, dans le cas d'immenses fichiers (trs rares, cependant), la recopie en mmoire peut
s'avrer problmatique.
si le fichier contient des donnes de type non homognes (chanes, numriques, etc.) cela risque dtre
coton pour le stocker dans un tableau : il va falloir dclarer plusieurs tableaux, dont le maniement au final
peut tre aussi lourd que celui des fichiers de dpart. A moins... d'utiliser une ruse : crer des types de
variables personnaliss, composs dun collage de plusieurs types existants (10 caractres, puis un
numrique, puis 15 caractres, etc.). Ce type de variable s'appelle un type structur. Cette technique, bien
quelle ne soit pas vraiment difficile, exige tout de mme une certaine aisance... Voil pourquoi on va
maintenant en dire quelques mots.
6. Donnes structures
6.1. Donnes structures simples
Nostalgiques du Lego, cette partie va vous plaire. Comment construire des trucs pas possibles et des machins pas
croyables avec juste quelques lments de base ? Vous n'allez pas tarder le savoir...
Jusqu' prsent, voil comment se prsentaient nos possibilits en matire de mmoire vive : nous pouvions rserver
un emplacement pour une information, d'un certain type. Un tel emplacement s'appelle une variable. Nous pouvions
aussi rserver une srie d'emplacements numrots pour une srie d'information de mme type. Un tel emplacement
s'appelle un tableau.
Eh bien toujours plus haut, toujours plus fort, voici maintenant que nous pouvons rserver une srie d'emplacements
pour des donnes de type diffrents. Un tel emplacement s'appelle une variable structure. Son utilit, lorsqu'on traite
des fichiers texte (et mme, des fichiers en gnral), saute aux yeux : car on va pouvoir calquer chacune des lignes du
fichier en mmoire vive, et considrer que chaque enregistrement sera recopi dans une variable et une seule, qui lui
sera adapte. Ainsi, le problme du "dcoupage" de chaque enregistrement en diffrentes variables (le nom, le
prnom, le numro de tlphone, etc.) sera rsolu d'avance, puisqu'on aura une structure, un gabarit, en quelque
sorte, tout prt d'avance pour accueillir et prdcouper nos enregistrements.
82
Cours Algorithmique
Attention toutefois ; lorsque nous utilisions des variables de type prdfini, comme des entiers, des boolens, etc.
nous n'avions qu'une seule opration effectuer : dclarer la variable en utilisant un des types existants. A prsent
que nous voulons crer un nouveau type de variable (par assemblage de types existants), il va falloir faire deux
choses : d'abord, crer le type. Ensuite seulement, dclarer la (les) variable(s) d'aprs ce type.
Reprenons une fois de plus l'exemple du carnet d'adresses.
Nous allons donc, avant mme la dclaration des variables, crer un type, une structure, calque sur celle de nos
enregistrements, et donc prte les accueillir :
Structure Bottin
Nom en Caractre * 20
Prnom en Caractre * 15
Tel en caractre * 10
Mail en Caractre * 20
Fin Structure
Ici, Bottin est le nom de ma structure. Ce mot jouera par la suite dans mon programme exactement le mme rle que
les types prdfinis comme Numrique, Caractre ou Boolen. Maintenant que la structure est dfinie, on va pouvoir,
dans la section du programme o s'effectuent les dclarations, crer une ou des variables correspondant cette
structure :
Variable Individu en Bottin
Et si cela me chantait, nous pourrions remplir les diffrentes informations contenues au sein de la variable Individu de
la manire suivante :
Individu
Joker,Midnight,0348946532,allstars@rock.com
On peut aussi avoir besoin d'accder un seul des champs de la variable structure. Dans ce cas, on emploie le point
:
Individu.Nom
Individu.Prnom
Individu.Tel
Jokers
Individu.Mail
Midnight
0348946532
allstars@rockandroll.com
Ainsi, crire correctement une information dans le fichier est un jeu d'enfant, puisqu'on dispose d'une variable Individu
au bon gabarit. Une fois remplis les diffrents champs de cette variable - ce qu'on vient de faire -, il n'y a plus qu'
envoyer celle-ci directement dans le fichier. Et zou !
EcrireFichier 3, Individu
83
Cours Algorithmique
De la mme manire, dans l'autre sens, lorsquon effectue une opration de lecture dans le fichier Adresses : la
structure tant faite pour cela, on peut dornavant se contenter de recopier une ligne du fichier dans une variable de
type Bottin, et le tour sera jou. Pour charger l'individu suivant du fichier en mmoire vive, il suffira donc d'crire :
LireFichier 5, Individu
Et l, direct, nous avons bien nos quatre renseignements accessibles dans les quatre champs de la variable individu.
Tout cela, videmment, parce que la structure de notre variable Individu correspond parfaitement la structure des
enregistrements de notre fichier. Dans le cas contraire, pour reprendre une expression connue, on ne dcoupera pas
selon les pointills, et alors, imaginez le carnage...
6.2. Tableaux de donnes structures

Et encore plus loin, encore plus vite et encore plus fort. Si partir des types simples, on peut crer des variables et
des tableaux de variables, partir des types structurs, on peut crer des variables structures... et des tableaux de
variables structures.
L, bien que pas si difficile que cela, a commence devenir vraiment balze. Parce que cela veut dire que nous
disposons d'une manire de grer la mmoire vive qui va correspondre exactement la structure d'un fichier texte
(d'une base de donnes). Comme les structures se correspondent parfaitement, le nombre de manipulations
effectuer, autrement dit de lignes de programme crire, va tre rduit au minimum. En fait, dans notre tableau
structur, les champs des emplacements du tableau correspondront aux champs du fichier texte, et les indices des
emplacements du tableau correspondront aux diffrentes lignes du fichier.
Voici, titre d'illustration, l'algorithme complet de lecture du fichier Adresses et de sa recopie intgrale en mmoire
vive, en employant un tableau structur.
Structure Bottin
Mail en Carctre * 20
Fin Structure
Tableau Mespotes() en Bottin
Ouvrir Exemple.txt sur 3 en Ajout
i -1
Tantque Non EOF(5)
i i + 1
Redim Mespotes(i)
LireFichier 5, Mespotes(i)
FinTantQue
Une fois que ceci est rgl, on a tout ce qu'il faut ! Si on voulait crire, un moment, le mail de l'individu n13 du fichier
(donc le n12 du tableau) l'cran, il suffirait de passer l'ordre :
Ecrire Mespotes(12).Mail
84
Cours Algorithmique
Et voil le travail. Simplissime, non ?
REMARQUE FINALE SUR LES DONNEES STRUCTUREES

Mme si le domaine de prdilection des donnes structures est la gestion de fichiers, on peut
tout fait y avoir recours dans d'autres contextes, et organiser plus systmatiquement les
variables d'un programme sous la forme de telles structures.
En programmation dite procdurale, celle que nous tudions ici, ce type de stratgie reste
relativement rare. Mais rare ne veut pas dire interdit, ou mme inutile.
Et nous aurons l'occasion de voir qu'en programmation objet, ce type d'organisation des
donnes devient fondamental.
Mais ceci est un autre cours...
7. Rcapitulatif gnral
Lorsqu'on est amen travailler avec des donnes situes dans un fichier, plusieurs choix, en partie indpendants les
uns des autres, doivent tre faits :
sur l'organisation en enregistrements du fichier (choix entre fichier texte ou fichier binaire) ;
sur le mode d'accs aux enregistrements du fichier (direct ou squentiel) ;
sur l'organisation des champs au sein des enregistrements (prsence de sparateurs ou largeur fixe) ;
sur la mthode de traitement des informations (recopie intgrale du fichier en mmoire vive ou non) ;
sur le type de variables utilises pour cette recopie en mmoire vive (plusieurs tableaux de type simple, ou
un seul tableau de type structur).
Chacune de ces options prsente avantages et inconvnients, et il est impossible de donner une rgle de conduite
valable en toute circonstance. Il faut connatre ces techniques, et savoir choisir la bonne option selon le problme
traiter.
Voici une srie de (pas toujours) petits exercices sur les fichiers texte, que l'on pourra traiter en employant les types
structurs (c'est en tout cas le cas dans les corrigs).
85
Cours Algorithmique
Exercice 10.4
Mme question, mais cette fois le carnet est suppos tre tri par ordre alphabtique.
Lindividu doit donc tre insr au bon endroit dans le fichier.
Exercice 10.5
crivez un algorithme qui permette de modifier un renseignement (pour simplifier,
disons uniquement le nom de famille) dun membre du carnet dadresses. Il faut donc
demander lutilisateur quel est le nom modifier, puis quel est le nouveau nom, et
mettre jour le fichier. Si le nom recherch n'existe pas, le programme devra le
signaler.
Exercice 10.6
Ecrivez un algorithme qui trie les individus du carnet dadresses par ordre
alphabtique.
Exercice 10.7
Soient Toto.txt et Tata.txt deux fichiers dont les enregistrements ont la mme structure.
Ecrire un algorithme qui recopie tout le fichier Toto dans le fichier Tutu, puis sa
suite, tout le fichier Tata (concatnation de fichiers).
Exercice 10.8
Ecrire un algorithme qui supprime dans notre carnet d'adresses tous les individus
dont le mail est invalide (pour employer un critre simple, on considrera que sont
invalides les mails ne comportant aucune arobase, ou plus d'une arobase).
Exercice 10.9
Les enregistrements dun fichier contiennent les deux champs Nom (chane de
caractres) et Montant (Entier). Chaque enregistrement correspond une vente
conclue par un commercial dune socit.
On veut mmoriser dans un tableau, puis afficher l'cran, le total de ventes par
vendeur. Pour simplifier, on suppose que le fichier de dpart est dj tri
alphabtiquement par vendeur.
Et en conclusion de la conclusion, voil plusieurs remarques fondamentales :
86
Cours Algorithmique
REMARQUE N1
Lorsqu'on veut rcuprer des donnes numriques inscrites dans un fichier texte, il ne faut
surtout pas oublier que ces donnes se prsentent forcment sous forme de caractres. La
rcupration elle-mme transmettra donc obligatoirement des donnes de type alphanumrique
; pour utiliser ces donnes des fins ultrieures de calcul, il sera donc ncessaire d'employer
une fonction de conversion.
Cette remarque ne s'applique pas aux fichiers binaires.
REMARQUE N1BIS
Voil pourquoi une structure s'appliquant aux fichiers textes est forcment compose
uniquement de types caractres. Une structure traitant de fichiers binaires pourrait en revanche
tre compose de caractres, de numriques et de boolens.
REMARQUE N2
Plusieurs langages interdisent l'criture d'une variable structure dans un fichier texte, ne
l'autorisant que pour un fichier binaire.
Si l'on se trouve dans ce cas, cela signifie qu'on peut certes utiliser une structure, ou un tableau
de structures, mais condition d'crire sur le fichier champ par champ, ce qui annule une partie
du bnfice de la structure.
Nous avons postul ici que cette interdiction n'existait pas ; en tenir compte ne changerait pas
fondamentalement les algorithmes, mais alourdirait un peu le code pour les lignes traitant de
l'criture dans les fichiers.
87
Cours Algorithmique
PARTIE 11 (PROCDURES ET FONCTIONS)

Linformatique semble encore chercher la recette miracle qui permettra aux gens dcrire des programmes corrects
sans avoir rflchir. Au lieu de cela, nous devons apprendre aux gens comment rflchir
Anonyme
1. Fonctions personnalises
1.1. De quoi s'agit-il ?
Une application, surtout si elle est longue, a toutes les chances de devoir procder aux mmes traitements, ou des
traitements similaires, plusieurs endroits de son droulement. Par exemple, la saisie dune rponse par oui ou par
non (et le contrle quelle implique), peuvent tre rpts dix fois des moments diffrents de la mme application.
La manire la plus vidente, mais aussi la moins habile, de programmer ce genre de choses, c'est bien entendu de
rpter le code correspondant autant de fois que ncessaire. Apparemment, on ne se casse pas la tte : quand il faut
que la machine interroge l'utilisateur, on recopie presque mot mot les lignes de codes voulues. Mais en procdant de
cette manire, la pire qui soit, on se prpare des lendemains qui dchantent...
D'abord, parce que si la structure d'un programme crit de cette manire peut paratre simple, elle est en ralit
inutilement lourdingue. Elle contient des rptitions, et pour peu que le programme soit joufflu, il peut devenir
parfaitement illisible. Or, c'est un critre essentiel pour un programme informatique, qu'il soit facilement modifiable
donc lisible, y compris - et surtout - par ceux qui ne l'ont pas crit ! Ds que l'on programme non pour soi-mme, mais
dans le cadre d'une organisation (entreprise ou autre), cette ncessit se fait sentir de manire aigu.
En plus, un autre niveau, une telle structure pose des problmes considrables de maintenance : car en cas de
modification du code, il va falloir traquer toutes les apparitions de ce code pour faire convenablement la modification !
Et si l'on en oublie une, patatras, on a laiss un bug.
Il faut donc opter pour une autre stratgie, qui consiste sparer ce traitement du corps du programme et appeler
ces instructions (qui ne figurent donc plus quen un seul exemplaire) chaque fois quon en a besoin. Ainsi, la lisibilit
est assure ; le programme devient modulaire, et il suffit de faire une seule modification au bon endroit, pour que cette
modification prenne effet dans la totalit de lapplication.
Le corps du programme sappelle alors la procdure principale, et ces groupes dinstructions auxquels on a recours
sappellent des fonctions et des sous-procdures (nous verrons un peu plus loin la diffrence entre ces deux termes).
Reprenons un exemple de question laquelle lutilisateur doit rpondre par oui ou par non.
88
Cours Algorithmique
Mauvaise Structure
Ecrire Etes-vous mari ?

Rep1 ""
TantQue Rep1 <> "Oui" et Rep1 <> "Non"
Ecrire "Tapez Oui ou Non"
Lire Rep1
FinTantQue
Ecrire Avez-vous des enfants ?

Rep2 ""
TantQue Rep2 <> "Oui" et Rep2 <> "Non"
Lire Rep2
FinTantQue
On le voit bien, il y a l une rptition quasi identique du traitement accomplir. A chaque fois, on demande une
rponse par Oui ou Non, avec contrle de saisie. La seule chose qui change, c'est le nom de la variable dans laquelle
on range la rponse. Alors, il doit bien y avoir un truc.
La solution consiste isoler les instructions demandant une rponse par Oui ou Non, et appeler ces instructions
chaque fois que ncessaire. Ainsi, on vite les rptitions inutiles, et on a dcoup notre problme en petits morceaux
autonomes.
Nous allons donc crer une fonction dont le rle sera de renvoyer la rponse (oui ou non) de l'utilisateur. Ce mot de
"fonction", en l'occurrence, ne doit pas nous surprendre : nous avons tudi prcdemment des fonctions fournies
avec le langage, et nous avons vu que le but d'une fonction tait de renvoyer une valeur. Eh bien, c'est exactement la
mme chose ici, sauf que c'est nous qui allons crer notre propre fonction, que nous appellerons RepOuiNon :
Fonction RepOuiNon()
Truc ""
TantQue Truc <> "Oui" et Truc <> "Non"
Lire Truc
FinTantQue
Renvoyer Truc
Fin Fonction
On remarque au passage lapparition dun nouveau mot-cl : Renvoyer, qui indique quelle valeur doit prendre la
fonction lorsqu'elle est utilise par le programme. Cette valeur renvoye par la fonction (ici, la valeur de la variable
Truc) est en quelque sorte contenue dans le nom de la fonction lui-mme, exactement comme ctait le cas dans les
fonctions prdfinies.
Une fonction s'crit toujours en-dehors de la procdure principale. Selon les langages, cela peut prendre diffrentes
formes. Mais ce qu'il faut comprendre, c'est que ces quelques lignes de codes sont en quelque sorte des satellites, qui
existent en dehors du traitement lui-mme. Simplement, elles sont sa disposition, et il pourra y faire appel chaque
fois que ncessaire. Si l'on reprend notre exemple, une fois notre fonction RepOuiNon crite, le programme principale
comprendra les lignes :
Ecrire Etes-vous mari ?

Rep1 RepOuiNon()
Ecrire Avez-vous des enfants ?

Rep2 RepOuiNon()
89
Cours Algorithmique
Et le tour est jou ! On a ainsi vit les rptitions inutiles, et si d'aventure, il y avait un bug dans notre contrle de
saisie, il suffirait de faire une seule correction dans la fonction RepOuiNon pour que ce bug soit limin de toute
l'application.
Toutefois, les plus sagaces d'entre vous auront remarqu, tant dans le titre de la fonction , que dans chacun des
appels, la prsence de parenthses. Celles-ci, ds qu'on cre ou qu'on appelle une fonction, sont obligatoires. Et si
vous avez bien compris tout ce qui prcde, vous devez avoir une petite ide de ce qu'on va pouvoir mettre dedans...
1.2. Passage d'arguments

Reprenons lexemple qui prcde et analysons-le. Nous crivons un message l'cran, puis appelons la fonction
RepOuiNon pour poser une question ; puis, un peu plus loin, on crit un autre message l'cran, et on appelle de
nouveau la fonction pour poser la mme question, etc. Cest une dmarche acceptable, mais qui peut encore tre
amliore : puisque avant chaque question, on doit crire un message, autant que cette criture du message figure
directement dans la fonction appele. Cela implique deux choses :
lorsquon appelle la fonction, on doit lui prciser quel message elle doit afficher avant de lire la rponse ;
la fonction doit tre prvenue quelle recevra un message, et tre capable de le rcuprer pour
lafficher.
En langage algorithmique, on dira que le message devient un argument de la fonction. Cela n'est certes pas une
dcouverte pour vous : nous avons longuement utilis les arguments propos des fonctions prdfinies. Eh bien,
quitte construire nos propres fonctions, nous pouvons donc construire nos propres arguments. Voil comment
laffaire se prsente...
La fonction sera dornavant dclare comme suit :
Fonction RepOuiNon(Msg en Caractre)
Ecrire Msg
Truc ""
TantQue Truc <> "Oui" et Truc <> "Non"
Lire Truc
FinTantQue
Renvoyer Truc
Fin Fonction
Il y a donc maintenant entre les parenthses une variable, Msg, dont on prcise le type, et qui signale la fonction
quun argument doit lui tre envoy chaque appel. Quant ces appels, justement, ils se simplifieront encore dans la
procdure principale, pour devenir :
Rep1
Rep2
RepOuiNon(Etes-vous mari ?)
RepOuiNon(Avez-vous des enfants ?)
Et voil le travail.
Une remarque importante : l, on n'a pass quun seul argument en entre. Mais bien entendu, on peut en passer
autant quon veut, et crer des fonctions avec deux, trois, quatre, etc. arguments ; Simplement, il faut viter d'tre
gourmands, et il suffit de passer ce dont on a besoin, ni plus, ni moins !
90
Cours Algorithmique
Dans le cas que l'on vient de voir, le passage d'un argument la fonction tait lgant, mais pas indispensable. La
preuve, cela marchait dj trs bien lors de la premire version. Nous allons voir maintenant une situation o il faut
absolument passer deux arguments une fonction si l'on veut qu'elle puisse remplir sa tche.
Imaginons qu' plusieurs reprises au cours du programme, on ait calculer la moyenne des lments de diffrents
tableaux. Plutt que rpter le code chaque fois, on va donc crer une fonction Moy, charge spcialement de
calculer cette moyenne. Voyons voir un peu de quoi cette fonction a besoin :
- du tableau, bien sr. Comment calculer la moyenne de ses lments sans cela ?
- mais il faut galement le nombre d'lments du tableau, ou, au choix, l'indice maximal du tableau. Enfin, quelque
chose qui permette la fonction de savoir combien de tours de boucle elle devra faire.
Voil donc une situation o la fonction a absolument besoin de deux arguments. Ecrivons-la, juste histoire de vrifier
qu'on est bien d'accord :
Fonction Moy(T en tableau numrique, n en entier)
Som 0
Pour i 0 n-1
Som Som + T(i)
i suivant
m som / n
Renvoyer m
Fin Fonction
Quant aux diffrents appels dans la procdure principale, si on a un tableau Riri de 43 lments, un tableau Fifi de 5
lments et un tableau Loulou de k lments, et quon range respectivement les moyennes dans les variables M1, M2
et M3, cela donnera :
M1
M2
M2
Moy (Riri, 43)

Moy (Fifi, 5)
Moy (Fifi, k)
En fait, tout cela, c'est simple comme bonjour... Le plus important, c'est d'acqurir le rflexe de constituer
systmatiquement les fonctions adquates quand on doit traiter un problme donn.
Cette partie de la rflexion s'appelle d'ailleurs l'analyse fonctionnelle d'un problme, et c'est toujours par l qu'il faut
commencer : en gros, dans un premier temps, on dcoupe le traitement en modules, et dans un deuxime temps, on
crit chaque module. Cependant, avant d'en venir l, il nous faut dcouvrir un dernier outil, qui prend le relais l o les
fonctions deviennent incapables de nous aider.
Exercice 11.1
Ecrivez une fonction qui renvoie la somme de cinq nombres fournis en argument.
91
Cours Algorithmique
Exercice 11.2
Ecrivez une fonction qui renvoie le nombre de voyelles contenues dans une chane de caractres
passe en argument. Au passage, notez qu'une fonction a tout fait le droit d'appeler une autre
fonction.
Exercice 11.3
Rcrivez la fonction Trouve, vue prcdemment, laide des fonctions Mid et Len (comme quoi,
Trouve, la diffrence de Mid et Len, nest pas une fonction indispensable dans un langage)
2. Sous-Procdures
Les fonctions, c'est bien, mais dans certains cas, a ne nous rend gure service.
Il peut en effet arriver que dans un programme, on ait raliser des tches rptitives, mais que ces tches n'aient
pas pour rle de gnrer une valeur particulire, ou qu'elles aient pour rle d'en gnrer plus d'une la fois. Prenons
deux exemples.
Premier exemple. Imaginons qu'au cours de notre application, on ait plusieurs fois besoin d'effacer l'cran et de
rafficher un bidule comme un petit logo en haut gauche. On pourrait se dire qu'il faut crer une fonction pour faire
cela. Mais quelle serait la valeur renvoye par la fonction ? Aucune ! Effacer l'cran, ce n'est pas produire un rsultat
stockable dans une variable, et afficher un logo non plus. Voil donc une situation o on a besoin de rpter du code,
mais o ce code n'a pas comme rle de produire une valeur.
Deuxime exemple. Au cours de notre application, on doit plusieurs fois faire saisir un tableau d'entiers (mais
chaque fois, un tableau diffrent). L encore, on serait tent d'effectuer toutes ces saisies de tableaux dans une seule
fonction. Mais problme, une fonction ne peut renvoyer qu'une seule valeur la fois. Elle ne peut donc renvoyer un
tableau, qui est une srie de valeurs distinctes.
Alors, dans ces deux cas, faute de pouvoir traiter l'affaire par une fonction, devra-t-on en rester au code rptitif dont
nous venons de dnoncer si vigoureusement les faiblesses ? Vous vous doutez bien que non. Heureusement, tout est
prvu, il y a une solution. Et celle-ci consiste utiliser des sous-procdures.
En fait, les fonctions - que nous avons vues - ne sont qu'un cas particulier des sous-procdures - que nous allons voir :
celui o doit tre renvoy vers la procdure appelante une valeur et une seule. Dans tous les autres cas, il faut donc
avoir recours non la forme particulire et simplifie (la fonction), mais la forme gnrale (la sous-procdure).
Parlons donc de ce qui est commun aux sous-procdures et aux fonctions, mais aussi de ce qui les diffrencie. Voici
comment se prsente une sous-procdure :
92
Cours Algorithmique
Procdure Bidule( ... )

...
Fin Procdure
Dans la procdure principale, lappel la sous-procdure Bidule devient quant lui :

...
Appeler Bidule(...)
...
tablissons un premier tat des lieux.

1. Alors qu'une fonction se caractrisait par les mots-cls Fonction ... Fin Fonction, une sous-procdure est
identifie par les mots-cls Procdure ... Fin Procdure. Oui, c'est un peu trivial comme remarque, mais on ne
sait jamais.
2. Lorsqu'une fonction tait appele, sa valeur (retourne) tait toujours affecte une variable. L'appel une
procdure, lui, est au contraire toujours une instruction autonome. "Excute la procdure Bidule" est un ordre
qui se suffit lui-mme.
3. Toute fonction devait, pour cette raison, comporter l'instruction "Renvoyer". Pour la mme raison, l'instruction
"Renvoyer" n'est jamais utilise dans une sous-procdure. La fonction est une valeur calcule, qui renvoie son
rsultat vers la procdure principale. La sous-procdure, elle, est un traitement ; elle ne "vaut" rien.
4. Mme une fois qu'on a bien compris les trois premiers points, on n'est pas au bout de nos peines.
En effet, il nous reste examiner ce qui peut bien se trouver dans les parenthses, la place des points de
suspension, aussi bien dans la dclaration de la sous-procdure que dans l'appel. Vous vous en doutez bien :
c'est l que vont se trouver les outils qui vont permettre l'change d'informations entre la procdure principale et la
sous-procdure (en fait, cette dernire phrase est trop restrictive : mieux vaudrait dire : entre la procdure
appelante et la procdure appele. Car une sous-procdure peut trs bien en appeler elle-mme une autre afin de
pouvoir accomplir sa tche).
Dans une fonction, les valeurs qui circulaient depuis la procdure (ou la fonction) appelante jusqu' la fonction
portaient le nom d'arguments. L, les valeurs qui circulent depuis la procdure (ou la fonction) appelante vers la sousprocdure appele se nomment des paramtres en entre de la sous-procdure. Mais seul le nom change :
"paramtres en entre" pour les procdures ou "arguments" pour les fonctions, on parle en fait exactement de la
mme chose.
Inversement, dans une fonction, la valeur retourne par la fonction portait le nom de la fonction elle-mme, et elle
faisait l'objet d'une instruction spciale ("renvoyer"). Avec une sous-procdure, les valeurs retournes, quand il y en a,
s'appellent des paramtres en sortie de la sous-procdure, qui doivent tre dclars explicitement comme tels.
Ceci nous permet de reformuler en termes un peu diffrents la vrit fondamentale apprise un peu plus haut : toute
sous-procdure possdant un et un seul paramtre en sortie peut galement tre crite sous forme d'une fonction (et
entre nous, c'est prfrable car un peu plus facile).
93
Cours Algorithmique
Il ne vous reste plus qu'une seule chose savoir avant de pouvoir passer la pratique. C'est que dans la plupart des
langages, on ne parlera pas de paramtres "en entre" ou "en sortie", mais de paramtres transmis :
par valeur (correspondant un paramtre en entre) ;
par rfrence (correspondant un paramtre en sortie).
On peut galement imaginer le cas dun paramtre qui serait pass une procdure la fois en entre et en sortie :
on envoie une variable une procdure, afin quelle la traite et la renvoie modifie. Dans ce cas, le paramtre aura
galement le statut dune transmission par rfrence (qui peut le plus peut le moins).
Tout cela peut sembler un tantinet compliqu. Mais sur le principe, c'est en ralit assez simple, et ds que vous aurez
pratiqu un peu, vous ferez cela les yeux ferms. Reprenons le cas d'un programme au cours duquel on a plusieurs
tableaux d'entiers faire saisir par l'utilisateur. Puisqu'un tableau comporte plusieurs valeurs, nous savons qu'il ne
peut, par dfinition, tre renvoy par une fonction. Mais une sous-procdure, elle, comporte autant de paramtres en
sortie qu'on veut. Elle peut donc sans problme renvoyer un tableau vers la procdure qui l'appelle. Ecrivons donc
notre sous-procdure :
Procdure SaisieTab(T en tableau par rfrence, N en entier par valeur)

Pour i 0 N-1
Ecrire "Saisie de la valeur n " & i + 1
Lire T(i)
i suivant
Fin Procdure
Et son appel :
Tableau Truc(5), Machin(12) en Entier
...
Appeler SaisieTab(Truc, 5)
...
Appeler SaisieTab(Machin, 12)
...
Fin Procdure
La seule chose remarquer, c'est que les variables manipules par la sous-procdure (notamment le tableau T) ne
sont pas celles qui sont manipules dans la procdure appelante (les tableaux Truc et Machin).
Ceci n'est pas une obligation : on pourrait imaginer une architecture o ce seraient les mmes variables qui seraient
tritures dans la procdure appelante et dans la sous-procdure (ces variables porteraient alors le mme nom). Mais
une telle architecture, si elle est possible, doit rester l'exception laquelle on n'a recours qu'en cas de besoin trs
particulier. En effet, pour qu'une telle chose soit possible, il faut que la variable ait la capacit de conserver sa valeur
d'une procdure l'autre ; en quelque sorte, qu'elle survive mme si la procdure qui la manipulait se termine. Ce
genre de variable dope l'EPO existe, on en reparlera dans un instant, mais elle est trs gourmande en ressources
mmoire. Donc, comme toujours, vous connaissez la chanson, on applique le principe de l'conomie de moyens.
Conclusion : une sous-procdure est un morceau de code qui comporte ventuellement des paramtres en entre
(transmis par valeur) et des paramtres en sortie (transmis par rfrence). La sous-procdure manipule donc des
variables qui lui sont propres, et la procdure appelante agit de mme. La prsence des paramtres dans l'appel la
sous-procdure et dans le titre de celle-ci assure le fait que la valeur des uns sera recopie dans les autres
94
Cours Algorithmique
(transmission par valeur) et qu'en retour, celle des autres sera recopie dans les uns (transmission par rfrence).
3. Variables publiques et prives

Lexistence de sous-procdures, de paramtres, pose comme on la vu le problme de la dure de vie des
variables, ce quon appelle leur porte. Pour adopter une classification simple (mais qui devient parfois plus complexe
dans certains langages), une variable peut tre dclare :
Comme prive, ou locale (cest neuf fois sur dix loption par dfaut). Cela signifie que la variable disparat
(et sa valeur avec) ds que prend fin la procdure ou elle a t cre.
Comme publique, ou globale. Ce qui signifie quune telle variable est conserve intacte pour toute
lapplication, au-del des ouvertures et fermetures de procdures. La variable conserve sa valeur et peut
tre traite par diffrentes procdures du programme.
La manire dont ces dclarations doivent tre faites est videmment fonction de chaque langage de programmation.
En pseudo-code algorithmique, vous pourrez utiliser le mot-cl Publique pour dclarer une variable publique :
Variable Publique Toto en Entier
Comment choisir de dclarer une variable en Public ou en Priv ? Cest trs simple : les variables globales
consomment normment de ressources en mmoire. En consquence, le principe qui doit prsider au choix entre
variables publiques et prives doit tre celui de lconomie de moyens : on ne dclare comme publiques que les
variables qui doivent absolument ltre. Et chaque fois que possible, lorsquon cre une sous-procdure, on utilise le
passage de paramtres plutt que des variables publiques.
4. Algorithmes fonctionnels
Pour clore ce chapitre, quelques mots propos de la structure gnrale dune application. Celle-ci va couramment
tre forme dune procdure principale, et de fonctions et de sous-procdures (qui vont au besoin elles-mmes en
appeler dautres, etc.). Lexemple typique est celui dun menu, ou dun sommaire, qui branche sur diffrents
traitements, donc diffrentes sous-procdures.
Lalgorithme fonctionnel de lapplication est le dcoupage et/ou la reprsentation graphique de cette structure
gnrale, ayant comme objectif de faire comprendre dun seul coup dil quelle procdure fait quoi, et quelle
procdure appelle quelle autre. Lalgorithme fonctionnel est donc en quelque sorte la construction du squelette de
lapplication. Il se situe un niveau plus gnral, plus abstrait, que lalgorithme normal, qui lui, dtaille pas pas les
traitements effectus au sein de chaque procdure.
Dans la construction et la comprhension dune application, les deux documents sont indispensables, et constituent
deux tapes successives de llaboration dun projet. La troisime et dernire tape, consiste crire, pour chaque
procdure et fonction, lalgorithme dtaill.
95
Cours Algorithmique
Exemple de ralisation dun algorithme fonctionnel : Le Jeu du Pendu

Vous connaissez tous ce jeu : lutilisateur doit deviner un mot choisi au hasard par lordinateur, en un minimum
dessais. Pour cela, il propose des lettres de lalphabet. Si la lettre figure dans le mot trouver, elle saffiche. Si elle ny
figure pas, le nombre des mauvaises rponses augmente de 1. Au bout de dix mauvaises rponses, la partie est
perdue.
Ce petit jeu va nous permettre de mettre en relief les trois tapes de la ralisation dun algorithme un peu complexe ;
bien entendu, on pourrait toujours ignorer ces trois tapes, et se lancer comme un drat directement dans la gueule
du loup, savoir lcriture de lalgorithme dfinitif. Mais, sauf tre particulirement dou, mieux vaut respecter le
canevas qui suit, car les difficults se rsolvent mieux quand on les saucissonne
Etape 1 : le dictionnaire des donnes

Le but de cette tape est didentifier les informations qui seront ncessaires au traitement du problme, et de choisir
le type de codage qui sera le plus satisfaisant pour traiter ces informations. Cest un moment essentiel de la rflexion,
quil ne faut surtout pas prendre la lgre Or, neuf programmeurs dbutants sur dix bclent cette rflexion, quand
ils ne la zappent pas purement et simplement. La punition ne se fait gnralement pas attendre longtemps ;
lalgorithme tant bti sur de mauvaises fondations, le programmeur se rend compte tout en lcrivant que le choix de
codage des informations, par exemple, mne des impasses. La prcipitation est donc punie par le fait quon est
oblig de tout reprendre depuis le dbut, et quon a au total perdu bien davantage de temps quon en a cru en gagner
Donc, avant mme dcrire quoi que ce soit, les questions quil faut se poser sont les suivantes :
de quelles informations le programme va-t-il avoir besoin pour venir bout de sa tche ?
pour chacune de ces informations, quel est le meilleur codage ? Autrement dit, celui qui, sans gaspiller de la
place mmoire, permettra dcrire lalgorithme le plus simple ?
Encore une fois, il ne faut pas hsiter passer du temps sur ces questions, car certaines erreurs, ou certains oublis,
se payent cher par la suite.
Pour le jeu du pendu, voici la liste des informations dont on va avoir besoin :
1. une liste de mots (si lon veut viter que le programme ne propose toujours le mme mot trouver, ce qui
risquerait de devenir assez rapidement lassant) ;
2. le mot trouver ;
3. la lettre propose par le joueur ;
4. le nombre actuel de mauvaises rponses ;
5. et enfin, last but not least, lensemble des lettres dj trouves par le joueur. Cette information est capitale ; le
programme en aura besoin au moins pour deux choses : dune part, pour savoir si le mot entier a t trouv.
Dautre part, pour afficher chaque tour ltat actuel du mot (rappelons qu chaque tour, les lettres trouves
sont affiches en clair par la machine, les lettres restant deviner tant remplaces par des tirets) ;
96
Cours Algorithmique
6. cela, on pourrait ajouter une liste comprenant lensemble des lettres dj proposes par le joueur, quelles
soient correctes ou non ; ceci permettra dinterdire au joueur de proposer nouveau une lettre prcdemment
joue.
Cette liste dinformations nest peut-tre pas exhaustive ; nous aurons vraisemblablement besoin, au cours de
lalgorithme, de quelques variables supplmentaires (des compteurs de boucles, des variables temporaires, etc.). Mais
les informations essentielles sont bel et bien l. Se pose maintenant le problme de choisir le mode de codage le plus
fut. Si, pour certaines informations, la question va tre vite rgle, pour dautres, il va falloir faire des choix (et si
possible, des choix intelligents !). Cest parti :
1. Pour la liste des mots trouver, il sagit dun ensemble dinformations de type alphanumrique. Ces informations
pourraient faire partie du corps de la procdure principale, et tre ainsi stockes en mmoire vive, sous la forme
dun tableau de chanes. Mais ce nest certainement pas le plus judicieux. Toute cette place occupe risque de
peser lourd inutilement, car il ny a aucun intrt stocker lensemble des mots en mmoire vive. Et si lon
souhaite enrichir la liste des mots trouver, on sera oblig de rcrire des lignes de programme Conclusion, la
liste des mots sera bien plus sa place dans un fichier texte, dans lequel le programme ira piocher un seul mot,
celui quil faudra trouver. Nous constituerons donc un fichier texte, appel dico.txt, dans lequel figurera un mot par
ligne (par enregistrement).
2. Le mot trouver, lui, ne pose aucun problme : il sagit dune information simple de type chane, qui pourra tre
stock dans une variable appele mot, de type caractre.
3. De mme, la lettre propose par le joueur est une information simple de type chane, qui sera stocke dans une
variable appele lettre, de type caractre.
4. Le nombre actuel de mauvaises rponses est une information qui pourra tre stocke dans une variable
numrique de type entier simple appele MovRep.
5. Lensemble des lettres trouves par le joueur est typiquement une information qui peut faire lobjet de plusieurs
choix de codage ; rappelons quau moment de laffichage, nous aurons besoin de savoir pour chaque lettre du mot
deviner si elle a t trouve ou non. Une premire possibilit, immdiate, serait de disposer dune chane de
caractres comprenant lensemble des lettres prcdemment trouves. Cette solution est loin dtre mauvaise, et
on pourrait tout fait ladopter. Mais ici, on fera un autre choix, ne serait-ce que pour varier les plaisirs : on va se
doter dun tableau de boolens, comptant autant demplacements quil y a de lettres dans le mot deviner.
Chaque emplacement du tableau correspondra une lettre du mot trouver, et indiquera par sa valeur si la lettre
a t dcouverte ou non (faux, la lettre na pas t devine, vrai, elle la t). La correspondance entre les
lments du tableau et le mot deviner tant immdiate, la programmation de nos boucles en sera facilite. Nous
baptiserons notre tableau de boolens du joli nom de verif .
6. Enfin, lensemble des lettres proposes sera stock sans soucis dans une chane de caractres nomme Propos.
Nous avons maintenant suffisamment gamberg pour dresser le tableau final de cette tape, savoir le dictionnaire
des donnes proprement dit.
97
Cours Algorithmique
Nom
Type
Description
Dico.txt
Fichier texte
Liste des mots deviner
Mot
Caractre
Mot deviner
Lettre
Caractre
Lettre propose
MovRep
Entier
Nombre de mauvaises rponses
Verif()
Tableau de Boolens
Lettres prcdemment devines, en correspondance avec

Mot
Propos
Caractre
Liste des lettres proposes
Etape 2 : lalgorithme fonctionnel

On peut prsent passer la ralisation de lalgorithme fonctionnel, cest--dire au dcoupage de notre problme en
blocs logiques. Le but de la manuvre est multiple :
faciliter la ralisation de lalgorithme dfinitif en le trononnant en plus petits morceaux.
Gagner du temps et de la lgret en isolant au mieux les sous-procdures et fonctions qui mritent de
ltre. viter ainsi ventuellement des rptitions multiples de code au cours du programme, rptitions
qui ne diffrent les unes des autres qu' quelques variantes prs.
Permettre une division du travail entre programmeurs, chacun se voyant assigner la programmation de
sous-procdures ou de fonctions spcifiques (cet aspect est essentiel ds quon quitte le bricolage
personnel pour entrer dans le monde de la programmation professionnelle, donc collective).
Dans notre cas prcis, un premier bloc se dtache : il sagit de ce quon pourrait appeler les prparatifs du jeu (choix
du mot deviner). Puisque le but est de renvoyer une valeur et une seule (le mot choisi par la machine), nous pouvons
confier cette tche une fonction spcialise ChoixDuMot ( noter que ce dcoupage est un choix de lisibilit, et pas
une ncessit absolue ; on pourrait tout aussi bien faire cela dans la procdure principale).
Cette procdure principale, justement, va ensuite avoir ncessairement la forme dune boucle Tantque : en effet , tant
que la partie nest pas finie, on recommence la srie des traitements qui reprsentent un tour de jeu. Mais comment,
justement, savoir si la partie est finie ? Elle peut se terminer soit parce que le nombre de mauvaises rponses a atteint
10, soit parce que toutes les lettres du mot ont t trouves. Le mieux sera donc de confier lexamen de tout cela
une fonction spcialise, PartieFinie, qui renverra une valeur numrique (0 pour signifier que la partie est en cours, 1
en cas de victoire, 2 en cas de dfaite).
Passons maintenant au tour de jeu.
La premire chose faire, cest dafficher lcran ltat actuel du mot deviner : un mlange de lettres en clair (celles
qui ont t trouves) et de tirets (correspondant aux lettres non encore trouves). Tout ceci pourra tre pris en charge
par une sous-procdure spcialise, appele AffichageMot. Quant linitialisation des diffrentes variables, elle pourra
tre place, de manire classique, dans la procdure principale elle-mme.
Ensuite, on doit procder la saisie de la lettre propose, en veillant effectuer les contrles de saisie adquats. L
encore, une fonction spcialise, SaisieLettre, sera toute indique.
Une fois la proposition faite, il convient de vrifier si elle correspond ou non une lettre deviner, et en tirer les
consquences. Ceci sera fait par une sous-procdure appele VrifLettre.
98
Cours Algorithmique
Enfin, une fois la partie termine, on doit afficher les conclusions lcran ; on dclare cet effet une dernire
procdure, FinDePartie.
Nous pouvons, dans un algorithme fonctionnel complet, dresser un tableau des diffrentes procdures et fonctions,
exactement comme nous lavons fait juste avant pour les donnes (on spargnera cette peine dans le cas prsent, ce
que nous avons crit ci-dessus suffisant amplement. Mais dans le cas dune grosse application, un tel travail serait
ncessaire et nous pargnerait bien des soucis).
On peut aussi schmatiser le fonctionnement de notre application sous forme de blocs, chacun des blocs reprsentant
une fonction ou une sous-procdure :
A ce stade, lanalyse dite fonctionnelle est termine. Les fondations (solides, esprons-le) sont poses pour finaliser
lapplication.
Etape 3 : Algorithmes dtaills
Normalement, il ne nous reste plus qu traiter chaque procdure isolment. On commencera par les sous-procdures
et fonctions, pour terminer par la rdaction de la procdure principale.
Fonction ChoixDuMot
Quelques explications : on lit intgralement le fichier contenant la liste des mots. Au fur et mesure, on
range ces mots dans le tableau Liste, qui est redimensionn chaque tour de boucle. Un tirage alatoire
intervient alors, qui permet de renvoyer un des mots au hasard.
Fonction ChoixDuMot()
Tableau Liste() en Caractre
Variable Nbmots en Numrique
Variable Choisi en Entier
Ouvrir Dico.txt sur 1 pour Lecture
Nbmots -1
Tantque Non EOF(1)
Nbmots Nbmots + 1
Redim Liste(Nbmots)
LireFichier 1, Liste(Nbmots)
FinTantQue
Fermer 1
Choisi Ent(Alea() * Nbmots)
Renvoyer Liste(Choisi)
FinFonction
Fonction PartieFinie
On commence par vrifier le nombre de mauvaise rponses, motif de dfaite. Ensuite, on regarde si la
partie est gagne, traitement qui sapparente une gestion de Flag : il suffit que lune des lettres du mot
deviner nait pas t trouve pour que la partie ne soit pas gagne. La fonction aura besoin, comme
arguments, du tableau Verif, de son nombre dlments et du nombre actuel de mauvaises rponses.
Fonction PartieFinie(t() en Booleen, n, x en Entier)
Variable i, issue en Numerique
Si x = 10 Alors
Renvoyer 2
Sinon
Issue 1
99
Cours Algorithmique
Pour i 0 n
Si Non t(i) Alors
Issue 0
FinSi
i suivant
Renvoyer Issue
FinSi
FinFonction
Procdure AffichageMot
Une mme boucle nous permet de considrer une par une les lettres du mot trouver (variable m), et de
savoir si ces lettres ont t identifies ou non.
Procdure AffichageMot(m en Caractre par Valeur, t() en Boolen par Valeur)
Variable Aff en Caractere
Variable i en Numerique
Aff
Pour i 0 len(m) - 1
Si Non t(i) Alors
Aff Aff & -
Sinon
Aff Aff & Mid(mot, i + 1, 1)
FinSi
i suivant
Ecrire Aff
FinProcdure
Remarque : cette procdure aurait galement pu tre crite sous la forme d'une fonction, qui aurait renvoy
vers la procdure principale la chane de caractres Aff. L'criture l'cran de cette chane Aff aurait alors
t faite par la procdure principale.
Voil donc une situation o on peut assez indiffremment opter pour une sous-procdure ou pour une
fonction.
Procdure SaisieLettre
On vrifie que le signe entr (paramtre b) est bien une seule lettre, qui ne figure pas dans les propositions
prcdemment effectues (paramtre a)
Procdure SaisieLettre(a en caractre par Rfrence, b en Caractre par Rfrence)
Variable Correct en Booleen
Variable Alpha en Caractere
Dbut
Correct Faux
Alpha ABCDEFGHIJKLMNOPQRSTUVWXYZ
TantQue Non Correct
Ecrire Entrez la lettre propose :
Lire b
Si Trouve(alpha, b) = 0 Ou len(b) <> 1 Alors
Ecrire Ce nest pas une lettre !
SinonSi Trouve(a, b) <> 0 Alors
Ecrire Lettre dj propose !
Sinon
Correct Vrai
a a & b
FinSi
FinTantQue
Fin Procdure
100
Cours Algorithmique
Procdure VerifLettre
Les paramtres se multiplient L est la lettre propose, t() le tableau de boolens, M le mot trouver et N
le nombre de mauvaises propositions. Il ny a pas de difficult majeure dans cette procdure : on examine
les lettres de M une une, et on en tire les consquences. Le flag sert savoir si la lettre propose
faisait ou non partie du mot deviner.
Procdure VerifLettre(L, M en Caractre par Valeur, t() en Boolen par Rfrence, N
en Entier par Rfrence)
Variable Correct en Booleen
Dbut
Correct Faux
Pour i 1 Len(M)
Si Mid(M, i, 1) = L Alors
Correct Vrai
T(i - 1) Vrai
FinSi
FinTantQue
Si Non Correct Alors
N N + 1
FinSi
Fin Procdure
Procdure Epilogue
Procdure Epilogue(M en Caractre par
Dbut
Si N = 2 Alors
Ecrire Une mauvaise proposition
Ecrire Le mot deviner tait :
Sinon
Ecrire Bravo ! Vous avez trouv
FinSi
Fin Procdure
Valeur, N en Entier par Valeur)

de trop Partie termine !"
, M
!
Procdure Principale
Procdure Principale
Variables Lettre, Mot, Propos en Caractere
Variables i, MovRep en Numrique
Tableau Verif() en Booleen
Dbut
Mot ChoixDuMot()
Propos ""
Lettre ""
Redim Verif(Len(Mot)-1)
Pour i 0 Len(Mot)-1
Verif(i) Faux
i suivant
k 0
Tantque k = 0
AffichageMot(Mot, Verif())
SaisieLettre(Propos, Lettre)
VerifLettre(Lettre, Mot, Verif(), MovRep)
k PartieFinie(Verif(), len(mot), MovRep)
FinTantQue
Epilogue(Mot, k)
Fin
101
Cours Algorithmique
PARTIE 12 (NOTIONS COMPLMENTAIRES)

Le danger, avec les ordinateurs, ce nest pas tellement quils deviennent aussi intelligents que les hommes, mais cest
que nous tombions daccord avec eux pour les rencontrer mi-chemin
Bernard Avishai
Une fois nest pas coutume, ce chapitre ne sera lobjet daucun exercice. Cela ne veut pas dire pour autant que ce qui
sy trouve nest pas intressant.
Non mais des fois.
1. Programmation structure
Petit retour sur une notion trs rapidement survole plus haut : celle de programmation structure . En fait, nous
avons jusqu prsent, fait de la programmation structure sans le savoir. Aussi, plutt quexpliquer longuement en
quoi cela consiste, il serait prfrable de prendre le problme par l'autre bout : en quoi cela ne consiste pas.
Dans certains langages (historiquement, ce sont souvent des langages anciens), les lignes de programmation portent
des numros. Et les lignes sont excutes par la machine dans lordre de ces numros. Jusquici, en soi, pas de
problme. Mais lastuce est que tous ces langages, il existe une instruction de branchement, note aller en
pseudo-code, instruction qui envoie directement le programme la ligne spcifie. Inversement, ce type de langage
ne comporte pas dinstructions comme FinTantQue, ou FinSi, qui ferment un bloc.
Prenons lexemple dune structure Si Alors Sinon
Programmation Structure
Si condition Alors
instructions 1
Sinon
instructions 2
FinSi
Programmation non structure

1000 Si condition Alors Aller En 1200
1100 instruction 1
1110 etc.
1120 etc.
1190 Aller en 1400
1200 instruction 2
1210 etc.
1220 etc.
1400 suite de lalgorithme
102
Cours Algorithmique
Vous voyez le topo : un programme crit dans ce type de langages se prsente comme une suite de branchements
emmls les uns dans les autres. Dune part, on ne peut pas dire que cela favorise la lisibilit du programme. Dautre
part, cest une source importante derreurs, car tt ou tard on oublie un aller , ou on met un de trop, etc. A fortiori
lorsquon complique un algorithme existant, cela peut devenir une jungle inextricable.
A linverse, la programmation structure, surtout si lon prend soin de rationaliser la prsentation en mettant des lignes
de commentaires et en pratiquant lindentation, vite des erreurs, et rvle sa structure logique de manire trs claire.
Le danger est que si la plupart des langages de programmation utiliss sont structurs, ils offrent tout de mme la
plupart du temps la possibilit de pratiquer la programmation non structure. Dans ce cas, les lignes ne sont pas
dsignes par des numros, mais certaines peuvent tre repres par des noms (dits tiquettes ) et on dispose
dune instruction de branchement.
Une rgle dhygine absolue est de programmer systmatiquement de manire structure, sauf impratif contraire fix
par le langage.
Autrement dit, mme quand un langage vous offre une possibilit de faire des entorses la programmation
structure, il ne faut sen saisir sous aucun prtexte.
2. Interprtation et compilation
Avec ce paragraphe, on sort un peu de lalgorithmique proprement dite pour entrer dans le domaine plus technique de
la ralisation pratique. Ou, si lon prfre, ces dernires lignes sont lapothose, le bouquet final, lextase ultime, la
conscration grandiose, de ce cours.
En toute modestie, bien sr.
Jusquici, nous avons travaill sur la premire tape de la ralisation dun programme :
Si lalgorithme est bien crit, sans faute logique, ltape suivante ne doit normalement poser aucun problme
conceptuel. Cest une simple traduction que vous devez effectuer :
A partir de l, votre travail est virtuellement termin (si lon excepte linvitable phase de tests, corrections, etc.). Mais
pour lordinateur, cest l que les ennuis commencent. En effet, aucun ordinateur nest en soi apte excuter les
instructions telles quelles sont rdiges dans tel ou tel langage ; lordinateur, lui, ne comprend quun seul langage, qui
est un langage cod en binaire ( la rigueur en hexadcimal) et qui sappelle le langage machine (ou assembleur).
103
Cours Algorithmique
Cest cela que sert un langage : vous pargner la programmation en binaire et vous permettre de vous faire
comprendre de lordinateur dune manire (relativement) lisible.
Cest pourquoi tout langage, partir dun programme crit, doit obligatoirement procder une traduction en langage
machine pour que ce programme soit excutable.
Il existe deux stratgies de traduction, ces deux stratgies tant parfois disponibles au sein du mme langage.
le langage traduit les instructions au fur et mesure quelles se prsentent. Cela sappelle la compilation la
vole, ou linterprtation.
le langage commence par traduire lensemble du programme en langage machine, constituant ainsi un
deuxime programme (un deuxime fichier) distinct physiquement et logiquement du premier. Ensuite, et
ensuite seulement, il excute ce second programme. Cela sappelle la compilation.
Il va de soi quun langage interprt est plus maniable : on peut excuter directement son code - et donc le tester - au
fur et mesure quon le tape, sans passer chaque fois par ltape supplmentaire de la compilation. Mais il va aussi
de soi quun programme compil sexcute beaucoup plus rapidement quun programme interprt : le gain est
couramment dun facteur 10, voire 20 ou plus.
Toute application destine un usage professionnel (ou mme, tout simplement srieux) est forcment une
application compile.
3. Une logique vicelarde : la programmation rcursive

Vous savez comment sont les informaticiens : on ne peut pas leur donner quoi que ce soit sans quils essayent de
jouer avec, et le pire, cest quils y russissent.
La programmation des fonctions personnalises a donn lieu l'essor dune logique un peu particulire, adapte en
particulier au traitement de certains problmes mathmatiques (ou de jeux) : la programmation rcursive. Pour vous
expliquer de quoi il retourne, nous allons reprendre un exemple cher vos curs : le calcul dune factorielle.
Rappelez-vous : la formule de calcul de la factorielle dun nombre n scrit :
N!=1x2x3xxn
Nous avions programm cela aussi sec avec une boucle Pour. Mais une autre manire de voir les choses, ni plus
juste, ni moins juste, serait de dire que quel que soit le nombre n :
n ! = n x (n-1) !
En bon franais : la factorielle dun nombre, cest ce nombre multipli par la factorielle du nombre prcdent. Encore
une fois, cest une manire ni plus juste ni moins juste de prsenter les choses ; cest simplement une manire
diffrente.
Si lon doit programmer cela, on peut alors imaginer une fonction Fact, charge de calculer la factorielle. Cette fonction
104
Cours Algorithmique
effectue la multiplication du nombre pass en argument par la factorielle du nombre prcdent. Et cette factorielle du
nombre prcdent va bien entendu tre elle-mme calcule par la fonction Fact.
Autrement dit, on va crer une fonction qui, pour fournir son rsultat, va sappeler elle-mme un certain nombre de
fois. Cest cela, la rcursivit.
Toutefois, il nous manque une chose pour finir : quand ces auto-appels de la fonction Fact vont-ils sarrter ? Cela
naura-t-il donc jamais de fin ? Si, bien sr, rassure-toi, public, la rcursivit, ce nest pas Les Feux de LAmour. On
sarrte quand on arrive au nombre 1, pour lequel la factorielle est par dfinition 1.
Cela produit lcriture suivante, un peu dconcertante certes, mais parfois trs pratique :
(Numrique en N) Fonction Fact
Si N = 0 alors
Renvoyer 1
Sinon
Renvoyer N * (Fact(N-))
Finsi
FinFonction
Vous remarquerez que le processus rcursif remplace en quelque sorte la boucle, cest--dire un processus itratif. Et
en plus, avec tous ces nouveaux mots qui riment, vous allez pouvoir crire de trs chouettes pomes. Vous
remarquerez aussi quon traite le problme lenvers : on part du nombre, et on remonte rebours jusqu 1 pour
pouvoir calculer la factorielle. Cet effet de rebours est caractristique de la programmation rcursive.
Pour conclure sur la rcursivit, trois remarques fondamentales.
la programmation rcursive, pour traiter certains problmes, est trs conomique pour le programmeur ;
elle permet de faire les choses correctement, en trs peu d'instructions.
en revanche, elle est trs dispendieuse de ressources machine. Car lexcution, la machine va tre
oblige de crer autant de variables temporaires que de tours de fonction en attente.
Last but not least, et cest le gag final, tout problme formul en termes rcursifs peut galement tre
formul en termes itratifs ! Donc, si la programmation rcursive peut faciliter la vie du programmeur, elle
nest jamais indispensable. Mais a nous faisait tant plaisir de vous en parler que nous navons pas pu
rsister
a
Cours Algorithmique
ANNEXE
(CORRIGS DES EXERCICES)

PARTIE 1
Exercice 1.1
Aprs :
A
B
A
1
A + 3
3
La valeur des variables est :

A = 1
A = 1
A = 3
B = ?
B = 4
B = 4
Exercice 1.2
Aprs :
A
B
C
A
C
5
3
A + B
2
B A

A
A
A
A
A
=
=
=
=
=
5
5
5
2
2
B = ?
B = 3
B = 3
B = 3
B = 3
C
C
C
C
C =
=
=
=
=
1
?
?
8
8
Exercice 1.3
Aprs :
A
B
A
B
5
A + 4
A + 1
A 4

A
A
A
A
=
=
=
=
5
5
6
6
B
B
B
B
=
=
=
=
?
9
9
2
Exercice 1.4
Aprs :
A
B
C
B
A
3
10
A + B
A + B
C

A
A
A
A
A
=
=
=
=
=
3
3
3
3
13
B = ?
B = 10
B = 10
B = 13
B = 13
C
C
C
C
C =
= ?
= ?
= 13
= 13
13
b
Cours Algorithmique
Exercice 1.5
Aprs :
A
B
A
B
5
2
B
A

A
A
A
A
=
=
=
=
5
5
2
2
B = ?
B = 2
B = 2
B = 2
Les deux dernires instructions ne permettent donc pas dchanger les deux valeurs de B et A,
puisque lune des deux valeurs (celle de A) est ici crase.
Si lon inverse les deux dernires instructions, cela ne changera rien du tout, hormis le fait que
cette fois cest la valeur de B qui sera crase.
Exercice 1.6
Dbut
C A
A B
B C
Fin
On est oblig de passer par une variable dite temporaire (la variable C).
Exercice 1.7
Dbut
D C
C B
B A
A D
Fin
En fait, quel que soit le nombre de variables, une seule variable temporaire suffit
Exercice 1.8
Il ne peut produire quune erreur dexcution, puisquon ne peut pas additionner des caractres.
Exercice 1.9En revanche, on peut les concatner. A la fin de lalgorithme, C vaudra donc
42312.
c
Cours Algorithmique
PARTIE 2
Exercice 2.1
On verra apparatre lcran 231, puis 462 (qui vaut 231 * 2)
Exercice 2.2
Variables nb, carr en Entier
Dbut
Ecrire Entrez un nombre :
Lire nb
carr nb * nb
Ecrire Son carr est : , carr
Fin
En fait, on pourrait tout aussi bien conomiser la variable carr en remplaant les deux avantdernires lignes par :
Ecrire Son carr est : , nb*nb
C'est une question de style ; dans un cas, on privilgie la lisibilit de l'algorithme, dans l'autre, on
privilgie l'conomie d'une variable.
Exercice 2.3
Variables pht, ttva, pttc en Rel
Variable nb en Entier
Dbut
Ecrire Entrez le prix hors taxes :
Lire pht
Ecrire Entrez le nombre darticles :
Lire nb
Ecrire Entrez le taux de TVA :
Lire ttva
pttc nb * pht * (1 + ttva)
Ecrire Le prix toutes taxes est : , pttc
Fin
L aussi, on pourrait squeezer une variable et une ligne en crivant directement. :

Ecrire Le prix toutes taxes est : , nb * pht * (1 + ttva)
C'est plus rapide, plus lger en mmoire, mais plus difficile relire (et crire !)
Exercice 2.4
Variables t1, t2, t3, t4
Dbut
t1 belle Marquise
t2 vos beaux yeux
t3 me font mourir
t4 damour
Ecrire t1 & " " & t2 & "
Ecrire t3 & " " & t2 & "
Ecrire t2 & " " & t3 & "
Ecrire t4 & " " & t1 & "
Fin
en Caractre
"
"
"
"
&
&
&
&
t3
t4
t1
t2
&
&
&
&
"
"
"
"
"
"
"
"
&
&
&
&
t4
t1
t4
t3
d
Cours Algorithmique
PARTIE 3
Exercice 3.1
Variable n en Entier
Dbut
Lire n
Si n > 0 Alors
Ecrire Ce nombre est positif
Sinon
Ecrire Ce nombre est ngatif
Finsi
Fin
Exercice 3.2
Variables m, n en Entier
Dbut
Ecrire Entrez deux nombres :
Lire m, n
Si (m > 0 ET n > 0) OU (m < 0 ET n < 0) Alors
Ecrire Leur produit est positif
Sinon
Ecrire Leur produit est ngatif
Finsi
Fin
Exercice 3.3
Variables a, b, c en Caractre
Dbut
Ecrire Entrez successivement trois noms :
Lire a, b, c
Si a < b et b < c Alors
Ecrire Ces noms sont classs alphabtiquement
Sinon
Ecrire Ces noms ne sont pas classs
Finsi
Fin
Exercice 3.4
Dbut
Lire n
Si n < 0 Alors
Ecrire Ce nombre est ngatif
SinonSi n = 0 Alors
Ecrire Ce nombre est nul
Sinon
Ecrire Ce nombre est positif
Finsi
Fin
Exercice 3.5
Variables m, n en Entier
e
Cours Algorithmique
Dbut
Ecrire Entrez deux nombres :
Lire m, n
Si m = 0 OU n = 0 Alors
Ecrire Le produit est nul
SinonSi (m < 0 ET n < 0) OU (m > 0 ET n > 0) Alors
Ecrire Le produit est positif
Sinon
Ecrire Le produit est ngatif
Finsi
Fin
Si on souhaite simplifier lcriture de la condition lourde du SinonSi, on peut toujours passer par des
variables boolennes intermdiaires. Une astuce de sioux consiste galement employer un Xor
(c'est l'un des rares cas dans lesquels il est pertinent)
Exercice 3.6
Variable age en Entier
Dbut
Ecrire Entrez lge de lenfant :
Lire age
Si age >= 12 Alors
Ecrire Catgorie Cadet
SinonSi age >= 10 Alors
Ecrire Catgorie Minime
Ecrire Catgorie Pupille
Ecrire Catgorie Poussin
Finsi
Fin
On peut videmment crire cet algorithme de diffrentes faons, ne serait-ce quen commenant
par la catgorie la plus jeune.
f
Cours Algorithmique
PARTIE 4
Exercice 4.1
Aucune difficult, il suffit dappliquer la rgle de la transformation du OU en ET vue en cours (loi de
Morgan). Attention toutefois la rigueur dans la transformation des conditions en leur contraire...
Si Tutu <= Toto + 4 et Tata <> OK Alors
Tutu Tutu - 1
Sinon
Tutu Tutu + 1
Finsi
Exercice 4.2
Variables h, m en Entier
Dbut
Ecrire Entrez les heures, puis les minutes :
Lire h, m
m m + 1
Si m = 60 Alors
m 0
h h + 1
FinSi
Si h = 24 Alors
h 0
FinSi
Ecrire Dans une minute il sera , h, heure(s) , m, minute(s)
Fin
Exercice 4.3
Variables h, m, s en Entier
Dbut
Ecrire Entrez les heures, puis les minutes, puis les secondes :
Lire h, m, s
s s + 1
Si s = 60 Alors
s 0
m m + 1
FinSi
Si m = 60 Alors
m 0
h h + 1
FinSi
Si h = 24 Alors
h 0
FinSi
Ecrire Dans une seconde il sera , h, heure(s), m, minute(s) et , s,
seconde(s)
Fin
Exercice 4.4
Variable p en Rel
g
Cours Algorithmique
Dbut
Ecrire Nombre de photocopies :
Lire n
Si n <= 10 Alors
p n * 0,1
SinonSi n <= 30
p 10 * 0,1 + (n 10) * 0,09
Sinon
p 10 * 0,1 + 20 * 0,09 + (n 30) * 0,08
FinSi
Ecrire Le prix total est : , p
Fin
Exercice 4.5
Variable sex en Caractre
Variable age en Entier
Dbut
Ecrire Entrez le sexe (M/F) :
Lire sex
Ecrire Entrez lge :
Lire age
C1 sex = M et age > 20
C2 sex = F et (age > 18 et age < 35)
Si C1 ou C2 Alors
Ecrire Imposable
Sinon
Ecrire Non Imposable
FinSi
Fin
Exercice 4.6
Cet exercice, du pur point de vue algorithmique, n'est pas trs mchant. En revanche, il reprsente
dignement la catgorie des noncs pigs. En effet, rien de plus facile que d'crire : si le candidat
a plus de 50%, il est lu, sinon s'il a plus de 12,5 %, il est au deuxime tour, sinon il est limin. H
h h... mais il ne faut pas oublier que le candidat peut trs bien avoir eu 20 % mais tre tout de
mme limin, tout simplement parce que l'un des autres a fait plus de 50 % et donc qu'il n'y a
pas de deuxime tour !... Moralit : ne jamais se jeter sur la programmation avant d'avoir
soigneusement men l'analyse du problme traiter.
Variables A, B, C, D en Caractre
Dbut
Ecrire Entrez les scores des quatre prtendants :
Lire A, B, C, D
C1 A > 50
C2 B > 50 ou C > 50 ou D > 50
C3 A >= B et A >= B et A >= D
C4 A >= 12,5
Si C1 Alors
Ecrire Elu au premier tour"
Sinonsi C2 ou Non(C4) Alors
Ecrire Battu, limin, sorti !!!
SinonSi C3 Alors
Ecrire "Ballotage favorable"
Sinon
Ecrire "Ballotage dfavorable"
FinSi
Fin
h
Cours Algorithmique
Exercice 4.7
L encore, on illustre l'utilit d'une bonne analyse. Je propose deux corrigs diffrents. Le premier
suit l'nonc pas pas. C'est juste, mais c'est vraiment lourd. La deuxime version s'appuie sur
une vraie comprhension d'une situation pas si embrouille qu'elle n'en a l'air.
Dans les deux cas, un recours aux variables boolennes are srieusement l'criture.
Donc, premier corrig, on suit le texte de l'nonc pas pas :
Variables age, perm, acc, assur en Entier

Variable situ en Caractre
Dbut
Ecrire Entrez lge :
Lire age
Ecrire Entrez le nombre d'annes de permis :
Lire perm
Ecrire Entrez le nombre d'accidents :
Lire acc
Ecrire Entrez le nombre d'annes d'assurance :
Lire assur
C1 age >= 25
C2 perm >= 2
C3 assur > 1
Si Non(C1) et Non(C2) Alors
Si acc = 0 Alors
situ "Rouge"
Sinon Alors
situ "Refus"
FinSi
Sinonsi ((Non(C1) et C2) ou (C1 et Non(C2)) Alors
Si acc = 0 Alors
situ "Orange"
SinonSi acc = 1 Alors
situ "Rouge"
Sinon
situ "Refus"
FinSi
Sinon
Si acc = 0 Alors
situ "Vert"
situ "Orange"
situ "Rouge"
Sinon
situ "Refus"
FinSi
FinSi
Si C3 Alors
Si situ = "Rouge" Alors
situ = "Orange"
SinonSi situ = "Orange" Alors
i
Cours Algorithmique
situ = "Orange"
SinonSi situ = "Vert" Alors
situ = "Bleu"
FinSi
FinSi
Ecrire "Votre situation : ", situ
Fin
Vous trouvez cela compliqu ? Oh, certes oui, a l'est ! Et d'autant plus qu'en lisant entre les lignes,
on pouvait s'apercevoir que ce galimatias de tarifs recouvre en fait une logique trs simple : un
systme points. Et il suffit de comptabiliser les points pour que tout s'claire... Reprenons juste
aprs l'affectation des trois variables boolennes C1, C2, et C3. On crit :
P0
Si Non(C1) Alors
PP+1
FinSi
Si Non(C2) Alors
PP+1
FinSi
P P + acc
Si P < 3 et C3 Alors
PP-1
FinSi
Si P = -1 Alors
situ = "Bleu"
SinonSi P = 0 Alors
situ = "Vert"
SinonSi P = 1 Alors
situ = "Orange"
SinonSi P = 2 Alors
situ = "Rouge"
Sinon
situ = "Refus"
FinSi
Ecrire "Votre situation : ", situ
Fin
Exercice 4.8
En ce qui concerne le dbut de cet algorithme, il ny a aucune difficult. Cest de la saisie bte et
mme pas mchante :
Variables J, M, A, JMax en Entier
Variables VJ, VM, B en Booleen
Dbut
Ecrire "Entrez le numro du jour"
Lire J
Ecrire "Entrez le numro du mois"
Lire M
Ecrire "Entrez l'anne"
Lire A
C'est videmment ensuite que les ennuis commencent La premire manire d'aborder la chose
consiste se dire que fondamentalement, la structure logique de ce problme est trs simple. Si
nous crons deux variables boolennes VJ et VM, reprsentant respectivement la validit du jour et
du mois entrs, la fin de l'algorithme sera d'une simplicit biblique (lanne est valide par dfinition,
si on vacue le dbat byzantin concernant lexistence de lanne zro) :
j
Cours Algorithmique
Si VJ et VM alors
Ecrire "La date est valide"
Sinon
Ecrire "La date n'est pas valide"
FinSi
Toute la difficult consiste affecter correctement les variables VJ et VM, selon les valeurs des
variables J, M et A. Dans l'absolu, VJ et VM pourraient tre les objets d'une affectation
monstrueuse, avec des conditions atrocement composes. Mais franchement, crire ces conditions
en une seule fois est un travail de bndictin sans grand intrt. Pour viter d'en arriver une telle
extrmit, on peut srier la difficult en crant deux variables supplmentaires :
B : variable boolenne qui indique s'il s'agit d'une anne bissextile
JMax : variable numrique qui indiquera le dernier jour valable pour le mois entr.
Avec tout cela, on peut y aller et en ressortir vivant.
On commence par initialiser nos variables boolennes, puis on traite les annes, puis les mois, puis
les jours.
On note "dp" la condition "divisible par" :
B A dp 400 ou (non(A dp 100) et A dp 4)
Jmax 0
VM M >= 1 et M =< 12
Si VM Alors
Si M = 2 et B Alors
JMax = 29
SinonSi M = 2 Alors
JMax = 28
SinonSi M = 4 ou M = 6 ou M = 9 ou M = 11 Alors
JMax = 30
Sinon
JMax = 31
FinSi
VJ J >= 1 et J =< Jmax
FinSi
Cette solution a le mrite de ne pas trop compliquer la structure des tests, et notamment de ne pas
rpter l'criture finale l'cran. Les variables boolennes intermdiaires nous pargnent des
conditions composes trop lourdes, mais celles-ci restent nanmoins srieuses.
Une approche diffrente consisterait limiter les conditions composes, quitte le payer par une
structure beaucoup plus exigeante de tests imbriqus. L encore, on vite de jouer les extrmistes
et l'on s'autorise quelques conditions composes lorsque cela nous simplifie l'existence. On
pourrait aussi dire que la solution prcdente "part de la fin" du problme (la date est elle valide ou
non ?), alors que celle qui suit "part du dbut" (quelles sont les donnes entres au clavier ?) :
Si M < 1 ou M > 12 Alors
Ecrire "Date Invalide"
SinonSi M = 2 Alors
Si A dp 400 Alors
Si J < 1 ou J > 29 Alors
Sinon
Ecrire "Date Valide"
FinSi
SinonSi A dp 100 Alors
Sinon
FinSi
SinonSi A dp 4 Alors
Sinon
FinSi
Sinon
Sinon
FinSi
FinSi
k
Cours Algorithmique
SinonSi M = 4 ou
Si J < 1 ou
Ecrire
Sinon
Ecrire
FinSi
Sinon
Si J < 1 ou
Ecrire
Sinon
Ecrire
FinSi
FinSi
M = 6 ou M = 9 ou M = 11 Alors
J > 30 Alors
"Date Invalide"
"Date Valide"
J > 31 Alors
"Date Invalide"
"Date Valide"
On voit que dans ce cas, l'alternative finale (Date valide ou invalide) se trouve rpte un grand
nombre de fois. Ce n'est en soi ni une bonne, ni une mauvaise chose. C'est simplement une
question de choix stylistique.
Personnellement, j'avoue prfrer assez nettement la premire solution, qui fait ressortir beaucoup
plus clairement la structure logique du problme (il n'y a qu'une seule alternative, autant que cette
alternative ne soit crite qu'une seule fois).
Il convient enfin de citer une solution trs simple et lgante, un peu plus difficile peut-tre
imaginer du premier coup, mais qui avec le recul apparat comme trs immdiate. Sur le fond, cela
consiste dire qu'il y a quatre cas pour qu'une date soit valide : celui d'un jour compris entre 1 et
31 dans un mois 31 jours, celui d'un jour compris entre 1 et 30 dans un mois 30 jours, celui d'un
jour compris entre 1 et 29 en fvrier d'une anne bissextile, et celui d'un jour de fvrier compris
entre 1 et 28. Ainsi :
B (A dp 4 et Non(A dp 100)) ou A dp 400
K1 (m=1 ou m=3 ou m=5 ou m=7 ou m=8 ou m=10 ou m=12) et (J>=1 et J=<31)
K2 (m=4 ou m=6 ou m=9 ou m=11) et (J>=1 et J=<30)
K3 m=2 et B et J>=1 et J=<29
K3 m=2 et J>=1 et J=<28
Si K1 ou K2 ou K3 ou K4 Alors
Ecrire "Date valide"
Sinon
Ecrire "Date non valide"
FinSi
Fin
Tout est alors rgl avec quelques variables boolennes et quelques conditions composes, en un
minimum de lignes de code.
La morale de ce long exercice - et non moins long corrig, c'est qu'un problme de test un peu
compliqu admet une pliade de solutions justes.
l
Cours Algorithmique
PARTIE 5
Exercice 5.1
Variable N en Entier
Debut
N 0
Ecrire Entrez un nombre entre 1 et 3
TantQue N < 1 ou N > 3
Lire N
Si N < 1 ou N > 3 Alors
Ecrire Saisie errone. Recommencez
FinSi
FinTantQue
Fin
Exercice 5.2
Variable N en Entier
Debut
N 0
Ecrire Entrez un nombre entre 10 et 20
TantQue N < 10 ou N > 20
Lire N
Si N < 10 Alors
Ecrire Plus grand !
SinonSi N > 20 Alors
Ecrire Plus petit !
FinSi
FinTantQue
Fin
Exercice 5.3
Variables N, i en Entier
Debut
Lire N
Ecrire Les 10 nombres suivants sont :
Pour i N + 1 N + 10
Ecrire i
i Suivant
Fin
Exercice 5.4
Variables N, i en Entier
Debut
Lire N
Ecrire La table de multiplication de ce nombre est :
Pour i 1 10
Ecrire N, x ,i, = , n*i
i Suivant
Fin
m
Cours Algorithmique
Exercice 5.5
Variables N, i, Som en Entier
Debut
Lire N
Som 0
Pour i 1 N
Som Som + i
i Suivant
Ecrire La somme est : , Som
Fin
Exercice 5.6
Variables N, i, F en Entier
Debut
Lire N
F 1
Pour i 2 N
F F * i
i Suivant
Ecrire La factorielle est : , F
Fin
Exercice 5.7
Variables N, i, PG en Entier
Debut
PG 0
Pour i 1 20
Lire N
Si i = 1 ou N > PG Alors
PG N
FinSi
i Suivant
Ecrire Le nombre le plus grand tait : , PG
Fin
En ligne 3, on peut mettre nimporte quoi dans PG, il suffit que cette variable soit affecte pour que
le premier passage en ligne 7 ne provoque pas d'erreur.
Pour la version amliore, cela donne :
Variables N, i, PG, IPG en Entier
Debut
PG 0
Pour i 1 20
Lire N
PG N
IPG i
FinSi
i Suivant
Ecrire Il a t saisi en position numro , IPG
Fin
n
Cours Algorithmique
Exercice 5.8
Variables N, i, PG, IPG en Entier
Debut
N 1
i 0
PG 0
TantQue N <> 0
Lire N
i i + 1
PG N
IPG i
FinSi
FinTantQue
Ecrire Il a t saisi en position numro , IPG
Fin
Exercice 5.9
Variables FF, somdue, M, IPG, Reste, Nb10F, Nb5F En Entier
Debut
FF 1
somdue 0
TantQue FF <> 0
Ecrire Entrez le montant :
Lire FF
somdue somdue + FF
FinTantQue
Ecrire Vous devez :, FF, francs
Ecrire Montant vers :
Lire M
Reste M - FF
Nb10F 0
TantQue Reste >= 10
Nb10F Nb10F + 1
Reste Reste 10
FinTantQue
Nb5F 0
Si Reste >= 5
Nb5F 1
Reste Reste 5
FinSi
Ecrire Rendu de la monnaie :
Ecrire Pices de 10 F : , Nb10F
Ecrire Pices de 5 F : , Nb5F
Ecrire Pices de 1 F : , reste
Fin
o
Cours Algorithmique
Exercice 5.10
Spontanment, on est tent d'crire l'algorithme suivant :
Variables N, P, i, Num, Dno1, Dno2 en Entier
Debut
Ecrire Entrez le nombre de chevaux partants :
Lire N
Ecrire Entrez le nombre de chevaux jous :
Lire P
Num 1
Pour i 2 N
Num Num * i
i Suivant
Dno1 1
Pour i 2 N-P
Dno1 Dno1 * i
i Suivant
Dno2 1
Pour i 2 P
Dno2 Dno2 * i
i Suivant
Ecrire Dans lordre, une chance sur , Num / Dno1
Ecrire Dans le dsordre, une sur , Num / (Dno1 * Dno2)
Fin
Cette version, formellement juste, comporte tout de mme deux faiblesses.

La premire, et la plus grave, concerne la manire dont elle calcule le rsultat final. Celui-ci est le
quotient d'un nombre par un autre ; or, ces nombres auront rapidement tendance tre trs
grands. En calculant, comme on le fait ici, d'abord le numrateur, puis ensuite le dnominateur, on
prend le risque de demander la machine de stocker des nombres trop grands pour qu'elle soit
capable de les coder (cf. le prambule). C'est d'autant plus bte que rien ne nous oblige procder
ainsi : on n'est pas oblig de passer par la division de deux trs grands nombre pour obtenir le
rsultat voulu.
La deuxime remarque est qu'on a programm ici trois boucles successives. Or, en y regardant
bien, on peut voir qu'aprs simplification de la formule, ces trois boucles comportent le mme
nombre de tours ! (si vous ne me croyez pas, crivez un exemple de calcul et biffez les nombres
identiques au numrateur et au dnominateur). Ce triple calcul (ces trois boucles) peut donc tre
ramen(es) un(e) seul(e). Et voil le travail, qui est non seulement bien plus court, mais aussi
plus performant :
Variables N, P, i, O, F en Entier
Debut
Ecrire Entrez le nombre de chevaux partants :
Lire N
Ecrire Entrez le nombre de chevaux jous :
Lire P
O 1
F 1
Pour i P + 1 N
O O * i
F F * (i P)
i Suivant
Ecrire Dans lordre, une chance sur , O
Ecrire Dans le dsordre, une chance sur , O / F
Fin
p
Cours Algorithmique
PARTIE 6
Exercice 6.1
Tableau Truc(6) en Entier
Debut
Pour i 0 6
Truc(i) 0
i Suivant
Fin
Exercice 6.2
Tableau Truc(5) en Caractre
Debut
Truc(0) a
Truc(1) e
Truc(2) i
Truc(3) o
Truc(4) u
Truc(5) y
Fin
Exercice 6.3
Tableau Notes(8) en Entier
Dbut
Pour i 0 8
Ecrire "Entrez la note numro ", i + 1
Lire Notes(i)
i Suivant
Fin
Exercice 6.4
Cet algorithme remplit un tableau avec six valeurs : 0, 1, 4, 9, 16, 25. Il les crit ensuite lcran.
Simplification :
Tableau Nb(5) en Entier
Dbut
Pour i 0 5
Nb(i) i * i
Ecrire Nb(i)
i Suivant
Fin
Exercice 6.5
q
Cours Algorithmique
Cet algorithme remplit un tableau avec les sept valeurs : 1, 3, 5, 7, 9, 11, 13. Il les crit ensuite
lcran. Simplification :
Tableau N(6) en Entier
Variables i, k en Entier
Dbut
N(0) 1
Ecrire N(0)
Pour k 1 6
N(k) N(k-1) + 2
Ecrire N(k)
k Suivant
Fin
Exercice 6.6
Cet algorithme remplit un tableau de 8 valeurs : 1, 1, 2, 3, 5, 8, 13, 21
Exercice 6.7
Variable S en Entier
Tableau Notes(8) en Entier
Debut
s 0
Pour i 0 8
Ecrire Entrez la note n , i + 1
Lire Notes(i)
s s + Notes(i)
i Suivant
Ecrire Moyenne : , s/9
Fin
Exercice 6.8
Variables Nb, Nbpos, Nbneg en Entier
Tableau T() en Entier
Debut
Ecrire Entrez le nombre de valeurs :
Lire Nb
Redim T(Nb - 1)
Nbpos 0
Nbneg 0
Pour i 0 Nb - 1
Ecrire Entrez le nombre n , i + 1
Lire T(i)
Si T(i) > 0 alors
Nbpos Nbpos + 1
Sinon
Nbneg Nbneg + 1
Finsi
i Suivant
Ecrire Nombre de valeurs positives : , Nbpos
Ecrire Nombre de valeurs ngatives : , Nbneg
Fin
r
Cours Algorithmique
Exercice 6.9
Variables i, Som, N en Entier
Debut
(on ne programme pas la saisie du tableau, dont on suppose quil compte N lments)
Redim T(N - 1)
Som 0
Pour i 0 N - 1
Som Som + T(i)
i Suivant
Ecrire Somme des lments du tableau : , Som
Fin
Exercice 6.10
Variables i, N en Entier
Tableaux T1(), T2(), T3() en Entier
Debut
(on suppose que T1 et T2 comptent N lments, et quils sont dj saisis)

Redim T3(N - 1)
Pour i 0 N - 1
T3(i) T1(i) + T2(i)
i Suivant
Fin
Exercice 6.11
Variables i, j, N1, N2, S en Entier
Tableaux T1(), T2() en Entier
Debut
On ne programme pas la saisie des tableaux T1 et T2.

On suppose que T1 possde N1 lments, et que T2 en possde T2)
S 0
Pour i 0 N1 1
Pour j 0 N2 1
S S + T1(i) * T2(j)
j Suivant
i Suivant
Ecrire "Le schtroumpf est : ", S
Fin
Exercice 6.12
Variables Nb, i en Entier
Debut
Lire Nb
Redim T(Nb - 1)
Pour i 0 Nb - 1
Lire T(i)
s
Cours Algorithmique
i Suivant
Ecrire "Nouveau tableau :"
Pour i 0 Nb 1
T(i) T(i) + 1
Ecrire T(i)
i Suivant
Fin
Exercice 6.13
Variables Nb, Posmaxi en Entier
Lire Nb
Redim T(Nb - 1)
Pour i 0 Nb - 1
Lire T(i)
i Suivant
Posmaxi 0
Pour i 0 Nb - 1
Si T(i) > T(Posmaxi) alors
Posmaxi i
Finsi
i Suivant
Ecrire Element le plus grand : , T(Posmaxi)
Ecrire Position de cet lment : , Posmaxi
Fin
Exercice 6.14
Variables Nb, i, Som, Moy, Nbsup en
Debut
Ecrire Entrez le nombre de notes
Lire Nb
Redim T(Nb - 1)
Pour i 0 Nb - 1
Ecrire Entrez le nombre n ,
Lire T(i)
i Suivant
Som 0
Pour i 0 Nb - 1
Som Som + T(i)
i Suivant
Moy Som / Nb
NbSup 0
Pour i 0 Nb - 1
Si T(i) > Moy Alors
NbSup NbSup + 1
FinSi
i Suivant
Ecrire NbSup, " lves dpassent la
Fin
Entier
saisir :
i + 1
moyenne de la classe"
PARTIE 7
t
Cours Algorithmique
Exercice 7.1
Variables Nb, i en Entier
Variable Flag en Booleen
Debut
Lire Nb
Redim T(Nb - 1)
Pour i 0 Nb - 1
Lire T(i)
i Suivant
Flag Vrai
Pour i 1 Nb - 1
Si T(i) <> T(i 1) + 1 Alors
Flag Faux
FinSi
i Suivant
Si Flag Alors
Ecrire "Les nombres sont conscutifs"
Sinon
Ecrire "Les nombres ne sont pas conscutifs"
FinSi
Fin
Cette programmation est sans doute la plus spontane, mais elle prsente le dfaut d'examiner la
totalit du tableau, mme lorsqu'on dcouvre ds le dpart deux lments non conscutifs. Aussi,
dans le cas d'un grand tableau, est-elle dispendieuse en temps de traitement. Une autre manire
de procder serait de sortir de la boucle ds que deux lments non conscutifs sont dtects.
La deuxime partie de l'algorithme deviendrait donc :
i 1
TantQue T(i) = T(i 1) + 1 et i < Nb - 1
i i + 1
FinTantQue
Si T(i) = T(i 1) + 1 Alors
Ecrire "Les nombres sont conscutifs"
Sinon
Ecrire "Les nombres ne sont pas conscutifs"
FinSi
Exercice 7.2
On suppose que N est le nombre dlments du tableau. Tri par insertion :
Pour i 0 N - 2
posmaxi = i
Pour j i + 1 N - 1
Si t(j) > t(posmaxi) alors
posmaxi j
Finsi
j suivant
temp t(posmaxi)
t(posmaxi) t(i)
t(i) temp
i suivant
Fin
Tri bulles :
Yapermut Vrai
TantQue Yapermut
u
Cours Algorithmique
Yapermut Faux
Pour i 0 N - 2
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
Exercice 7.3
On suppose que n est le nombre dlments du tableau pralablement saisi
Pour i 0 (N-1)/2
Temp T(i)
T(i) T(N-1-i)
T(N-1-i) Temp
i suivant
Fin
Exercice 7.4
Pour un tel traitement, on n'aura pas le choix ; il va falloir passer par un deuxime tableau,
temporaire. L'algorithme qui suit suppose que le tableau T, comptant N lments, a dj t saisi.
Ecrire "Rang de la valeur supprimer ?"

Lire S
Redim Temp(N 2)
Pour i 0 N - 1
Si i < S Alors
Temp(i) T(i)
SinonSi i > S Alors
Temp(i-1) T(i)
Finsi
i suivant
On recopie Temp dans T

Redim T(N 2)
Pour i 0 N - 2
T(i) Temp(i)
i suivant
Fin
Exercice 7.5
v
Cours Algorithmique
N est le nombre d'lments du tableau Dico(), contenant les mots du dictionnaire, tableau
pralablement rempli.
Variables Sup, Inf, Comp en Entier
Variables Fini en Boolen
Dbut
Ecrire "Entrez le mot vrifier"
Lire Mot
On dfinit les bornes de la partie du tableau considrer
Sup N - 1
Inf 0
Fini Faux
TantQue Non Fini
Comp dsigne l'indice de l'lment comparer. En bonne rigueur, il faudra veiller ce que Comp
soit bien un nombre entier, ce qui pourra s'effectuer de diffrentes manires selon les langages.
Comp
(Sup + Inf)/2
Si le mot se situe avant le point de comparaison, alors la borne suprieure change, la borne
infrieure ne bouge pas.
Si Mot < Dico(Comp) Alors
Sup Comp - 1
Sinon, c'est l'inverse

Sinon
Inf
Comp + 1
FinSi
Fini Mot = Dico(Comp) ou Sup < Inf
FinTantQue
Si Mot = Dico(Comp) Alors
Ecrire "le mot existe"
Sinon
Ecrire "Il n'existe pas"
Finsi
Fin
w
Cours Algorithmique
PARTIE 8
Exercice 8.1
Tableau Truc(5, 12) en Entier
Debut
Pour i 0 5
Pour j 0 12
Truc(i, j) 0
j Suivant
i Suivant
Fin
Exercice 8.2
Cet algorithme remplit un tableau de la manire suivante :
X(0,
X(0,
X(0,
X(1,
X(1,
X(1,
0)
1)
2)
0)
1)
2)
=
=
=
=
=
=
1
2
3
4
5
6
Il crit ensuite ces valeurs lcran, dans cet ordre.
Exercice 8.3
X(0,
X(1,
X(0,
X(1,
X(0,
X(1,
0)
0)
1)
1)
2)
2)
=
=
=
=
=
=
1
4
2
5
3
6
Exercice 8.4
T(0,
T(0,
T(1,
T(1,
T(2,
T(2,
T(3,
T(3,
0)
1)
0)
1)
0)
1)
0)
1)
=
=
=
=
=
=
=
=
0
1
1
2
2
3
3
4
x
Cours Algorithmique
Exercice 8.5
Version a : cet algorithme remplit un tableau de la manire suivante :
T(0,
T(0,
T(1,
T(1,
T(2,
T(2,
T(3,
T(3,
0)
1)
0)
1)
0)
1)
0)
1)
=
=
=
=
=
=
=
=
1
2
3
4
5
6
7
8

Version b : cet algorithme remplit un tableau de la manire suivante :
T(0,
T(0,
T(1,
T(1,
T(2,
T(2,
T(3,
T(3,
0)
1)
0)
1)
0)
1)
0)
1)
=
=
=
=
=
=
=
=
1
5
2
6
3
7
4
8
Exercice 8.6
Variables i, j, iMax, jMax en Numrique
Tableau T(12, 8) en Numrique
Le principe de la recherche dans un tableau deux dimensions est strictement le mme que
dans un tableau une dimension, ce qui ne doit pas nous tonner. La seule chose qui change,
c'est qu'ici le balayage requiert deux boucles imbriques, au lieu d'une seule.
Debut
...
iMax 0
jMax 0
Pour i 0 12
Pour j 0 8
Si T(i,j) > T(iMax,jMax) Alors
iMax i
jMax j
FinSi
j Suivant
i Suivant
Ecrire "Le plus grand lment est", T(iMax, jMax)
Ecrire "Il se trouve aux indices", iMax, " ", jMax
Fin
y
Cours Algorithmique
Exercice 8.7
Variables i, j , posi, posj, i2, j2 en Entier
Variables Correct, MoveOK en Boolen
Tableau Damier(7, 7) en Boolen
Tableau Mouv(3, 1) en Entier
Le damier contenant un seul pion, on choisit de le coder l'conomie, en le reprsentant par un

tableau de boolens deux dimensions. Dans chacun des emplacements de ce damier, Faux
signifie l'absence du pion, Vrai sa prsence
Par ailleurs, on emploie une mchante astuce, pas obligatoire, mais bien pratique dans beaucoup
de situations. L'ide est de faire correspondre les choix possibles de l'utilisateur avec les
mouvements du pion. On entre donc dans un tableau Mouv deux dimensions, les dplacements
du pion selon les quatre direction, en prenant soin que chaque ligne du tableau corresponde
une saisie de lutilisateur. La premire valeur tant le dplacement en i, la seconde le
dplacement en j. Ceci nous pargnera par la suite de faire quatre fois les mmes tests.
Debut
Choix 0 : pion en haut droite

Mouv(0, 0)
Mouv(0, 1)
-1
-1
Choix 1 : pion en haut droite

Mouv(1, 0)
Mouv(1, 1)
-1
1
Choix 2 : pion en bas gauche

Mouv(2, 0)
Mouv(2, 1)
1
-1
Choix 3 : pion en bas droite

Mouv(3, 0)
Mouv(3, 1)
1
1
Initialisation du damier ; le pion nest pour le moment nulle part

Pour i 0 7
Pour j 0 7
Damier(i, j)
j suivant
i suivant
Faux
Saisie de la coordonne en i ("posi") avec contrle de saisie

Correct Faux
TantQue Non Correct
Ecrire Entrez la ligne de votre pion :
Lire posi
Si posi >= 0 et posi <= 7 alors
Correct = vrai
Finsi
Fintantque
Saisie de la coordonne en j ("posj") avec contrle de saisie

Correct Faux
TantQue Non Correct
Ecrire Entrez la colonne de votre pion :
Lire posj
Si posj >= 0 et posj <= 7 alors
Correct = vrai
Finsi
Fintantque
Positionnement du pion sur le damier virtuel.

Damier(posi, posj)
Vrai
Saisie du dplacement, avec contrle

Ecrire Quel dplacement ?
Ecrire
- 0 : en haut gauche
Ecrire
- 1 : en haut droite
Ecrire
- 2 : en bas gauche
Ecrire
- 3 : en bas droite
Correct Faux
TantQue Non Correct
z
Cours Algorithmique
Lire Dep
Si Dep >= 0 et Dep <= 3 alors
Correct Vrai
FinSi
FinTantQue
i2 et j2 sont les futures coordonnes du pion. La variable boolenne MoveOK vrifie la validit de
ce futur emplacement
i2 posi + Mouv(Dep, 0)
j2 posj + Mouv(Dep, 1)
MoveOK i2 >= 0 et i2 <= 7 et j2 >= 0 et j2 <= 7
Cas o le dplacement est valide

Si MoveOK Alors
Damier(posi, posj) Faux
Damier(i2, j2) Vrai
Affichage du nouveau damier

Pour i 0 7
Pour j 0 7
Si Damier(i, j) Alors
Ecrire O ;
Sinon
Ecrire X ;
FinSi
j suivant
Ecrire
i suivant
Sinon
Cas o le dplacement nest pas valide

Ecrire Mouvement impossible
FinSi
Fin
aa
Cours Algorithmique
PARTIE 9
Exercice 9.1
Parmi ces affectations (considres indpendamment les unes des autres), lesquelles
provoqueront des erreurs, et pourquoi ?
Variables A, B, C en Numrique
Variables D, E en Caractre
...
A
...
A
...
B
...
D
...
C
Sin(B)
Sin(A + B * C)
Sin(A) Sin(D)
Sin(A / B)
Cos(Sin(A)
Exercice 9.2
Ecrivez un algorithme qui demande un mot lutilisateur et qui affiche lcran le
nombre de lettres de ce mot (c'est vraiment tout bte).
Exercice 9.3
nombre de mots de cette phrase. On suppose que les mots ne sont spars que par des
espaces (et c'est dj un petit peu moins bte).
Exercice 9.4
nombre de voyelles contenues dans cette phrase.
On pourra crire deux solutions. La premire dploie une condition compose bien
fastidieuse. La deuxime, en utilisant la fonction Trouve, allge considrablement
l'algorithme.
Exercice 9.5
Ecrivez un algorithme qui demande une phrase lutilisateur. Celui-ci entrera ensuite le
rang dun caractre supprimer, et la nouvelle phrase doit tre affiche (on doit
rellement supprimer le caractre dans la variable qui stocke la phrase, et pas
uniquement lcran).
bb
Cours Algorithmique

Un des plus anciens systmes de cryptographie (aisment dchiffrable) consiste dcaler
les lettres dun message pour le rendre illisible. Ainsi, les A deviennent des B, les B des
C, etc. Ecrivez un algorithme qui demande une phrase lutilisateur et qui la code selon
ce principe. Comme dans le cas prcdent, le codage doit seffectuer au niveau de la
variable stockant la phrase, et pas seulement lcran.
Exercice 9.7 - Cryptographie 2 - le chiffre de Csar

Une amlioration (relative) du principe prcdent consiste oprer avec un dcalage
non de 1, mais dun nombre quelconque de lettres. Ainsi, par exemple, si lon choisit un
dcalage de 12, les A deviennent des M, les B des N, etc.
Ralisez un algorithme sur le mme principe que le prcdent, mais qui demande en
plus quel est le dcalage utiliser. Votre sens proverbial de l'lgance vous interdira bien
sr une srie de vingt-six "Si...Alors"

Une technique ultrieure de cryptographie consista oprer non avec un dcalage
systmatique, mais par une substitution alatoire. Pour cela, on utilise un alphabet-cl,
dans lequel les lettres se succdent de manire dsordonne, par exemple :
HYLUJPVREAKBNDOFSQZCWMGITX
Cest cette cl qui va servir ensuite coder le message. Selon notre exemple, les A
deviendront des H, les B des Y, les C des L, etc.
Ecrire un algorithme qui effectue ce cryptage (lalphabet-cl sera saisi par lutilisateur, et
on suppose qu'il effectue une saisie correcte).
Exercice 9.9 - Cryptographie 4 - le chiffre de Vigenre

Un systme de cryptographie beaucoup plus difficile briser que les prcdents fut
invent au XVIe sicle par le franais Vigenre. Il consistait en une combinaison de
diffrents chiffres de Csar.
On peut en effet crire 25 alphabets dcals par rapport lalphabet normal :
-
lalphabet qui commence par B et finit par YZA

lalphabet qui commence par C et finit par ZAB
etc.
Le codage va seffectuer sur le principe du chiffre de Csar : on remplace la lettre
cc
Cours Algorithmique
dorigine par la lettre occupant la mme place dans lalphabet dcal.

Mais la diffrence du chiffre de Csar, un mme message va utiliser non un, mais
plusieurs alphabets dcals. Pour savoir quels alphabets doivent tre utiliss, et dans
quel ordre, on utilise une cl.
Si cette cl est VIGENERE et le message Il faut coder cette phrase , on procdera
comme suit :
La premire lettre du message, i , est la 9e lettre de lalphabet normal. Elle doit tre
code en utilisant lalphabet commenant par la premire lettre de la cl, V . Dans cet
alphabet, la 9e lettre est le d . i devient donc d
La deuxime lettre du message, l , est la 11e lettre de lalphabet normal. Elle doit tre
code en utilisant lalphabet commenant par la deuxime lettre de la cl, I . Dans cet
alphabet, la 11e lettre est le s . l devient donc s , etc.
Quand on arrive la dernire lettre de la cl, on recommence la premire.
Ecrire lalgorithme qui effectue un cryptage de Vigenre, en demandant bien sr au
dpart la cl lutilisateur.
Exercice 9.10
Ecrivez un algorithme qui demande un nombre entier lutilisateur. Lordinateur affiche
ensuite le message Ce nombre est pair ou Ce nombre est impair selon le cas.
Exercice 9.11
Ecrivez les algorithmes qui gnrent un nombre Glup alatoire tel que
a) 0 =< Glup < 2
b) 1 =< Glup < 1
c) 1,35 =< Glup < 1,65
d) Glup mule un d six faces
e) 10,5 =< Glup < +6,5
f) Glup mule la somme du jet simultan de deux ds six faces
dd
Cours Algorithmique
PARTIE 10
Exercice 10.1
Cet algorithme crit l'intgralit du fichier "Exemple.txt" l'cran
Exercice 10.2
Debut
Tantque Non EOF(5)
LireFichier 5, Truc
Pour i 1 Len(Truc)
Si Mid(Truc, i, 1) = "/" Alors
Ecrire " "
Sinon
Ecrire Mid(Truc, i, 1)
FinSi
Suivant
FinTantQue
Fermer 5
Exercice 10.3
Variables Nom*20, Prnom*17, Tel*10, Mail*20, Lig en Caractre
Debut
Ecrire "Entrez le nom : "
Lire Nom
Ecrire "Entrez le prnom : "
Lire Prnom
Ecrire "Entrez le tlphone : "
Lire Tel
Lire Mail
Lig Nom & Prnom & Tel & Mail
Ouvrir Adresse.txt sur 1 pour Ajout
EcrireFichier 1, Lig
Fermer 1
Fin
Exercice 10.4
L, comme indiqu dans le cours, on passe par un tableau de strutures en mmoire vive, ce qui
est la technique la plus frquemment employe. Le tri - qui est en fait un simple test - sera
effectu sur le premier champ (nom).
Structure Bottin
Fin Structure
Variables MonPote, Nouveau en Bottin
Variables i, j en Numrique
Debut
Lire Nouveau.Nom
Ecrire "Entrez le prnom : "
ee
Cours Algorithmique
Lire Nouveau.Prnom
Ecrire "Entrez le tlphone : "
Lire Nouveau.Tel
Ecrire "Entrez le mail : "
Lire Nouveau.Mail
On recopie l'intgralit de "Adresses" dans MesPotes(). Et aprs tout, c'est l'occasion : quand on
tombe au bon endroit, on insre subrepticement notre nouveau copain dans le tableau.
Ouvrir Adresse.txt sur 1 pour Lecture
i -1
insr Faux
Tantque Non EOF(1)
i i + 1
Redim MesPotes(i)
LireFichier 1, MonPote
Si MonPote.Nom > Nouveau.Nom et Non Insr Alors
MesPotes(i) Nouveau
Insr Vrai
i i + 1
Redim MesPotes(i)
FinSi
MesPotes(i) MonPote
FinTantQue
Fermer 1
Et le tour est quasiment jou. Il ne reste plus qu' rebalancer tel quel l'intgralit du tableau
MesPotes dans le fichier, en crasant l'ancienne version.
Ouvrir Adresse.txt sur 1 pour Ecriture
Pour j 0 i
EcrireFichier 1, MesPotes(j)
j suivant
Fermer 1
Fin
Exercice 10.5
C'est un peu du mme tonneau que ce qu'on vient de faire, quelques variantes prs. Il y a
essentiellement une petite gestion de flag pour faire bonne mesure.
Structure Bottin
Fin Structure
Variables MonPote en Bottin
Variables Ancien, Nouveau en Caractre*20
Variable Trouv en Boolen
Debut
Ecrire "Entrez le nom modifier : "
Lire Ancien
Ecrire "Entrez le nouveau nom : "
Lire Nouveau
On recopie l'intgralit de "Adresses" dans Fic, tout en recherchant le clampin. Si on le trouve, on

procde la modification.
i -1
Trouv Faux
Tantque Non EOF(1)
i i + 1
Redim MesPotes(i)
ff
Cours Algorithmique
Si MonPote.Nom = Ancien.Nom Alors

Trouv Vrai
MonPote.Nom Nouveau
FinSi
MesPotes(i) MonPote
FinTantQue
Fermer 1
On recopie ensuite l'intgralit de Fic dans "Adresse"

Pour j 0 i
j Suivant
Fermer 1
Et un petit message pour finir !

Si Trouv Alors
Ecrire "Modification effectue"
Sinon
Ecrire "Nom inconnu. Aucune modification effectue"
FinSi
Fin
Exercice 10.6
L, c'est un tri sur un tableau de structures, rien de plus facile. Et on est bien content de disposer
des structures, autrement dit de ne se coltiner qu'un seul tableau...
Structure Bottin
Fin Structure
Variables Mini en Bottin
Debut
On recopie l'intgralit de "Adresses" dans MesPotes...

i -1
Tantque Non EOF(1)
i i + 1
Redim MesPotes(i)
LireFichier 1, MesPotes(i)
FinTantQue
Fermer 1
On trie le tableau selon l'algorithme de tri par insertion dj tudi, en utilisant le champ Nom de
la structure :
Pour j 0 i - 1
Mini MesPotes(j)
posmini = j
Pour k j + 1 i
Si MesPotes(k).Nom < Mini.Nom Alors
mini MesPotes(k)
posmini k
Finsi
k suivant
MesPotes(posmini) MesPotes(j)
MesPotes(j) Mini
j suivant
On recopie ensuite l'intgralit du tableau dans "Adresse"

Pour j 0 i
gg
Cours Algorithmique
j suivant
Fermer 1
Fin
Exercice 10.7
Bon, celui-l est tellement idiot qu'on n'a mme pas besoin de passer par des tableaux en
mmoire vive.
Variable Lig en Caractre
Debut
Ouvrir "Tutu.txt" sur 1 pour Ajout
Ouvrir Toto.txt sur 2 pour Lecture
Tantque Non EOF(2)
LireFichier 2, Lig
FinTantQue
Fermer 2
Ouvrir Tata.txt sur 3 pour Lecture
Tantque Non EOF(3)
LireFichier 2, Lig
FinTantQue
Fermer 3
Fermer 1
Exercice 10.8
On va liminer les mauvaises entres ds la recopie : si l'enregistrement ne prsente pas un mail
valide, on l'ignore, sinon on le copie dans le tableau.
Structure Bottin
Mail en Caractre * 20
Fin Structure
Variable MonPote en Bottin
Debut
On recopie "Adresses" dans MesPotes en testant le mail...

i -1
Tantque Non EOF(1)
nb 0
Pour i 1 Len(MonPote.Mail)
Si Mid(MonPote.Mail, i, 1) = "@" Alors
nb nb + 1
FinSi
i suivant
Si nb = 1 Alors
i i + 1
Redim MesPotes(i)
MesPotes(i) MonPote
FinSi
FinTantQue
Fermer 1
On recopie ensuite l'intgralit de Fic dans "Adresse"

Pour j 0 i
hh
Cours Algorithmique
j Suivant
Fermer 1
Fin
Exercice 10.9
Une fois de plus, le passage par un tableau de structures est une stratgie commode. Attention
toutefois, comme il s'agit d'un fichier texte, tout est stock en caractre. Il faudra donc convertir
en numrique les caractres reprsentant les ventes, pour pouvoir effectuer les calculs
demands.
Pour le traitement, il y a deux possibilits.
Soit on recopie le fichier l'identique dans un premier tableau, et on traite ensuite ce tableau pour
faire la somme par vendeur. Soit on fait le traitement directement, ds la lecture du fichier. C'est
cette option qui est choisie dans ce corrig.
Structure Vendeur
Montant en Numrique
Fin Structure
Tableau MesVendeurs() en Vendeur
Variables NomPrec * 20, Lig, Nom en caractre
Variables Somme, Vente en Numrique
On balaye le fichier en faisant nos additions. Ds que le nom a chang (on est pass au vendeur
suivant), on range le rsultat et on remet tout zro
Debut
Ouvrir Ventes.txt sur 1 pour Lecture
i -1
Somme 0
NomPrc ""
Tantque Non EOF(1)
LireFichier 1, Lig
Nom Mid(Lig, 1, 20)
Vente CNum(Mid(Lig, 21, 10)
Si Nom = NomPrec Alors
Somme Somme + Vente
Sinon
i i + 1
Redim MesVendeurs(i)
MesVendeurs(i).Nom NomPrec
MesVendeurs(i).Montant Somme
Somme 0
NomPrec Nom
FinSi
FinTantQue
Et n'oublions pas un petit tour de plus pour le dernier de ces messieurs

i i + 1
Redim MesVendeurs(i)
MesVendeurs(i).Nom NomPrec
MesVendeurs(i).Montant Somme
Fermer 1
Pour terminer, on affiche le tableau l'cran

Pour j 0 i
Ecrire MesVendeurs(j)
j suivant
Fin

Cours Algorithmique

Transféré par

Informations du document

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 Algorithmique

Transféré par

Droits d'auteur :

Formats disponibles

COURS DALGORITHMIQUE

(APPLICATIONS INFORMATIQUES LA GESTION CONOMIQUE ET SOCIALE)

UNIVERSIT PARIS VII DENIS DIDEROT

Auteur : Christophe Darmangeat

TABLE DES MATIRES

1. Pourquoi les ordinateurs sont-ils binaires ? ----------------------------------------------------------------------- 1

INTRODUCTION A LALGORITHMIQUE -------------------------------------------------------------------------------- 8

(LES VARIABLES) --------------------------------------------------------------------------------------- 12

1. A quoi servent les variables ? ------------------------------------------------------------------------------------------- 12

3. Linstruction daffectation ---------------------------------------------------------------------------------------------- 15

5. Deux remarques pour terminer ---------------------------------------------------------------------------------------- 21

1. De quoi parle-t-on ? ------------------------------------------------------------------------------------------------------- 23

(LES TESTS) --------------------------------------------------------------------------------------------- 26

1. De quoi sagit-il ? ---------------------------------------------------------------------------------------------------------- 26

1. Faut-il mettre un ET ? Faut-il mettre un OU ? --------------------------------------------------------------------- 35

Auteur : Christophe Darmangeat

2. Au-del de la logique : le style ------------------------------------------------------------------------------------------ 37

(LES BOUCLES) ----------------------------------------------------------------------------------------- 40

1. A quoi cela sert-il donc ?------------------------------------------------------------------------------------------------- 40

(LES TABLEAUX) ---------------------------------------------------------------------------------------- 49

1. Utilit des tableaux -------------------------------------------------------------------------------------------------------- 49

(TECHNIQUES RUSES )-------------------------------------------------------------------------------- 55

1. Tri dun tableau : le tri par insertion --------------------------------------------------------------------------------- 55

1. Pourquoi plusieurs dimensions ?--------------------------------------------------------------------------------------- 62

(LES FONCTIONS PRDFINIES)---------------------------------------------------------------------- 67

1. Structure gnrale des fonctions --------------------------------------------------------------------------------------- 67

(LES FICHIERS) -------------------------------------------------------------------------------------- 74

Organisation des fichiers --------------------------------------------------------------------------------------------- 74

2. Structure des enregistrements ------------------------------------------------------------------------------------------ 75

Auteur : Christophe Darmangeat

3. Variables publiques et prives ------------------------------------------------------------------------------------------ 94

(NOTIONS COMPLMENTAIRES) ----------------------------------------------------------------- 101

1. Programmation structure --------------------------------------------------------------------------------------------- 101

(CORRIGS DES EXERCICES) --------------------------------------------------------------------------- a

Auteur : Christophe Darmangeat

PRAMBULE (LE CODAGE)

1. Pourquoi les ordinateurs sont-ils binaires ?

Auteur : Christophe Darmangeat

2. La numrotation de position en base dcimale

Auteur : Christophe Darmangeat

parce que le 9 est le quatrime chiffre en partant de la droite

parce que le 5 est le troisime chiffre en partant de la droite

parce que le 6 est le deuxime chiffre en partant de la droite

parce que le 2 est le premier chiffre en partant de la droite

Auteur : Christophe Darmangeat

3. La numrotation de position en base binaire

Auteur : Christophe Darmangeat

Auteur : Christophe Darmangeat

Dans 2, on trouve 1 x 2, soit 1 x 21. On retranche 2 de 2 et on obtient 0.

Cest bon ? Alors on passe la suite.

Auteur : Christophe Darmangeat

Auteur : Christophe Darmangeat

C'est illogique, Capitaine

1. Quest-ce que lalgomachin ?

Auteur : Christophe Darmangeat

2. Faut-il tre matheux pour tre bon en algorithmique ?

La matrise de lalgorithmique requiert deux qualits, trs complmentaires dailleurs :

Auteur : Christophe Darmangeat

3. LADN, les Shadoks, et les ordinateurs

plutt quarrter de pomper et risquer quil se passe quelque chose de pire.

Auteur : Christophe Darmangeat

Bon, maintenant passons au vif du sujet

5. Avec quelles conventions crit-on un algorithme ?

Auteur : Christophe Darmangeat