COURS ALGORITHMIQUE

Préambule : Le Codage
« L’information n’est pas le savoir. Le savoir n’est pas la sagesse. La sagesse n’est pas la
beauté. La beauté n’est pas l’amour. L’amour n’est pas la musique, et la musique, c’est ce
qu’il y a de mieux. » - Frank Zappa
« Les ordinateurs sont comme les dieux de l’Ancien Testament : avec beaucoup de règles, et
sans pitié. » - Joseph Campbell
« Compter en octal, c’est comme compter en décimal, si on n’utilise pas ses pouces » - Tom
Lehrer
« Il y a 10 sortes de gens au monde : ceux qui connaissent le binaire et les autres » -
Anonyme

C’est bien connu, les ordinateurs sont comme le gros rock qui tâche : ils sont binaires.
Mais ce qui est moins connu, c’est ce que ce qualificatif de « binaire » recouvre exactement,
et ce qu’il implique. Aussi, avant de nous plonger dans les arcanes de l’algorithmique
proprement dite, ferons-nous un détour par la notion de codage binaire. Contrairement aux
apparences, nous ne sommes pas éloignés de notre sujet principal. Tout au contraire, ce que
nous allons voir à présent constitue un ensemble de notions indispensables à l’écriture de
programmes. Car pour parler à une machine, mieux vaut connaître son vocabulaire…

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

De nos jours, les ordinateurs sont ces machines merveilleuses capables de traiter du texte,
d’afficher des tableaux de maître, de jouer de la musique ou de projeter des vidéos. On n’en
est pas encore tout à fait à HAL, l’ordinateur de 2001 Odyssée de l’Espace, à
« l’intelligence » si développée qu’il a peur de mourir… pardon, d’être débranché. Mais
l’ordinateur paraît être une machine capable de tout faire.
Pourtant, les ordinateurs ont beau sembler repousser toujours plus loin les limites de leur
champ d’action, il ne faut pas oublier qu’en réalité, ces fiers-à-bras ne sont toujours capables
que d’une seule chose : faire des calculs, et uniquement cela. Eh oui, ces gros malins
d’ordinateurs sont restés au fond ce qu’ils ont été depuis leur invention : de vulgaires
calculatrices améliorées !
Lorsqu’un ordinateur traite du texte, du son, de l’image, de la vidéo, il traite en réalité des
nombres. En fait, dire cela, c’est déjà lui faire trop d’honneur. Car même le simple nombre
« 3 » reste hors de portée de l’intelligence d’un ordinateur, ce qui le situe largement en
dessous de l’attachant chimpanzé Bonobo, qui sait, entre autres choses, faire des blagues à ses
congénères et jouer au Pac-Man. Un ordinateur manipule exclusivement des informations
binaires, dont on ne peut même pas dire sans être tendancieux qu’il s’agit de nombres.
Mais qu’est-ce qu’une information binaire ? C’est 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 l’on pense à des dispositifs physiques permettant de stocker ce genre
d’information, on pourrait citer : chargé – non chargé, haut – bas, troué – non troué.
Je ne donne pas ces derniers exemples au hasard : ce sont précisément ceux dont se sert un
ordinateur pour stocker l’ensemble des informations qu’il va devoir manipuler. En deux mots,
la mémoire vive (la « RAM ») est formée de millions de composants électroniques qui
peuvent retenir ou relâcher une charge électrique. La surface d’un disque dur, d’une bande ou
d’une disquette est recouverte de particules métalliques qui peuvent, grâce à un aimant, être
orientées dans un sens ou dans l’autre. Et sur un CD-ROM, on trouve un long sillon étroit
irrégulièrement percé de trous.
Toutefois, la coutume veut qu’on symbolise une information binaire, quel que soit son support
physique, sous la forme de 1 et de 0. Il faut bien comprendre que ce n’est là qu’une
représentation, une image commode, que l’on utilise pour parler de toute information binaire.
Dans la réalité physique, il n’y a pas plus de 1 et de 0 qui se promènent dans les ordinateurs
qu’il n’y a écrit, en lettres géantes, « Océan 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 désigner une information, indépendamment de son support physique.
Les informaticiens seraient-ils des gens tordus, possédant un goût immodéré pour
l’abstraction, ou pour les jeux intellectuels alambiqués ? Non, pas davantage en tout cas que le
reste de leurs contemporains non-informaticiens. En fait, chacun d’entre nous pratique ce
genre d’abstraction 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 même plus quel mécanisme subtil d’abstraction est nécessaire
pour pratiquer ce sport.
Lorsque nous disons que 4+3=7 (ce qui reste, normalement, dans le domaine de compétence
mathématique de tous ceux qui lisent ce cours !), nous manions de pures abstractions,
représentées par de non moins purs symboles ! Un être humain d’il y a quelques millénaires
se serait demandé longtemps qu’est-ce que c’est que « quatre » ou « trois », sans savoir quatre
ou trois « quoi ? ». Mine de rien, le fait même de concevoir des nombres, c’est-à-dire de
pouvoir considérer, dans un ensemble, la quantité indépendamment de tout le reste, c’est déjà
une abstraction très hardie, qui a mis très longtemps avant de s’imposer à tous comme une
évidence. Et le fait de faire des additions sans devoir préciser des additions « de quoi ? », est
un pas supplémentaire qui a été encore plus difficile à franchir.
Le concept de nombre, de quantité pure, a donc constitué un immense progrès (que les
ordinateurs n’ont quant à eux, je le répète, toujours pas accompli). Mais si concevoir les
nombres, c’est bien, posséder un système de notation performant de ces nombres, c’est encore
mieux. Et là aussi, l’humanité a mis un certain temps (et essayé un certain nombre de pistes
qui se sont révélées être des impasses) avant de parvenir au système actuel, le plus rationnel.
Ceux qui ne sont pas convaincus des progrès réalisés en ce domaine peuvent toujours essayer
de résoudre une multiplication comme 587 x 644 en chiffres romains, on leur souhaite bon
courage !

2. La numérotation de position en base décimale

L’humanité actuelle, pour représenter n’importe quel nombre, utilise un système de
numérotation de position, à base décimale. Qu’est-ce qui se cache derrière cet obscur jargon ?
Commençons par la numérotation de position. Pour représenter un nombre, aussi grand soit-il,
nous disposons d’un alphabet spécialisé : une série de 10 signes qui s’appellent les chiffres. Et
lorsque nous écrivons un nombre en mettant certains de ces chiffres les uns derrière les
autres, l’ordre dans lequel nous mettons les chiffres est capital. Ainsi, par exemple, 2 569
n’est pas du tout le même nombre que 9 562. Et pourquoi ? Quel opération, quel décodage
mental effectuons-nous lorsque nous lisons une suite de chiffres représentant un nombre ? Le
problème, c’est que nous sommes tellement habitués à faire ce décodage de façon instinctive
que généralement nous n’en connaissons plus les règles. Mais ce n’est pas très compliqué de
les reconstituer… Et c’est là que nous mettons le doigt en plein dans la deuxième
caractéristique de notre système de notation numérique : son caractère décimal.
Lorsque j’écris 9562, de quel nombre est-ce que je parle ? Décomposons la lecture chiffre par
chiffre, de gauche à droite :
9562, c’est 9000 + 500 + 60 + 2.
Allons plus loin, même si cela paraît un peu bébête :
 9000, c’est 9 x 1000, parce que le 9 est le quatrième chiffre en partant de la droite
 500, c’est 5 x 100, parce que le 5 est le troisième chiffre en partant de la droite

 60, c’est 6 x 10, parce que le 6 est le deuxième chiffre en partant de la droite
 2, c’est 2 x 1, parce que le 2 est le premier chiffre en partant de la droite

On peut encore écrire ce même nombre d’une manière légèrement différente. 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)
Arrivés à ce stade de la compétition, je prie les allergiques de m’excuser, mais il nous faut
employer un petit peu de jargon mathématique. Ce n’est pas grand-chose, et on touche au but.
Alors, courage ! En fait, ce jargon se résume au fait que les matheux notent la ligne ci-dessus
à l’aide 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 dégagé le mécanisme général de la représentation par
numérotation de position en base décimale.
Alors, nous en savons assez pour conclure sur les conséquences du choix de la base décimale.
Il y en a deux, qui n’en forment en fin de compte qu’une seule :
 parce que nous sommes en base décimale, nous utilisons un alphabet numérique de dix
symboles. Nous nous servons de dix chiffres, pas un de plus, pas un de moins.
 toujours parce nous sommes en base décimale, la position d’un de ces dix chiffres
dans un nombre désigne la puissance de dix par laquelle ce chiffre doit être multiplié
pour reconstituer le nombre. Si je trouve un 7 en cinquième position à partir de la
droite, ce 7 ne représente pas 7 mais 7 fois 104, soit 70 000.

Un dernier mot concernant le choix de la base dix. Pourquoi celle-là et pas une autre ? Après
tout, la base dix n’était pas le seul choix possible. Les babyloniens, qui furent de brillants
mathématiciens, avaient en leur temps adopté la base 60 (dite sexagésimale). Cette base 60
impliquait certes d’utiliser un assez lourd alphabet numérique de 60 chiffres. Mais c’était
somme toute un inconvénient mineur, et en retour, elle possédait certains avantages non
négligeables. 60 étant un nombre divisible par beaucoup d’autres (c’est pour cette raison qu’il
avait été choisi), on pouvait, rien qu’en regardant le dernier chiffre, savoir si un nombre était
divisible par 2, 3, 4, 5, 6, 10, 12, 15, 20 et 30. Alors qu’en base 10, nous ne pouvons
immédiatement répondre à la même question que pour les diviseurs 2 et 5. La base
sexagésimale a certes disparu en tant que système de notation des nombres. Mais Babylone
nous a laissé en héritage sa base sexagésimale dans la division du cercle en soixante parties
(pour compter le temps en minutes et secondes), et celle en 6 x 60 parties (pour les degrés de
la géométrie et de l’astronomie).
Alors, pourquoi avons-nous adopté la base décimale, moins pratique à bien des égards ? Nul
doute que cela tienne au dispositif matériel grâce auquel tout être humain normalement
constitué stocke spontanément une information numérique : ses doigts !
Profitons-en pour remarquer que le professeur Shadoko avait inventé exactement le même
système, la seule différence étant qu'il avait choisi la base 4 (normal, les shadoks n'avaient
que 4 mots). Regardez donc cette video - ou comment faire rigoler les gens en ne disant
(presque) que des choses vraies :
J'ajoute que c'est l'ensemble des videos des shadoks, et en particulier celles traitant de la
logique et des mathématiques, qui vaut son pesant de cacahuètes interstellaires. Mais hélas
cela nous éloignerait un peu trop de notre propos (c'est pas grave, on y reviendra à la
prochaine pause).

3. La numérotation de position en base binaire

Les ordinateurs, eux, comme on l’a vu, ont un dispositif physique fait pour stocker (de
multiples façons) des informations binaires. Alors, lorsqu’on représente une information
stockée par un ordinateur, le plus simple est d’utiliser un système de représentation à deux
chiffres : les fameux 0 et 1. Mais une fois de plus, je me permets d’insister, le choix du 0 et du
1 est une pure convention, et on aurait pu choisir n’importe quelle autre paire de symboles à
leur place.
Dans un ordinateur, le dispositif qui permet de stocker de l’information est donc rudimentaire,
bien plus rudimentaire que les mains humaines. Avec des mains humaines, on peut coder dix
choses différentes (en fait bien plus, si l’on fait des acrobaties avec ses doigts, mais écartons
ce cas). Avec un emplacement d’information d’ordinateur, on est limité à deux choses
différentes seulement. Avec une telle information binaire, on ne va pas loin. Voilà pourquoi,
dès leur invention, les ordinateurs ont été conçus pour manier ces informations par paquets de
0 et de 1. Et la taille de ces paquets a été fixée à 8 informations binaires.
Une information binaire (symbolisée couramment par 0 ou 1) s’appelle un bit (en anglais...
bit).
Un groupe de huit bits s’appelle un octet (en anglais, byte)
Donc, méfiance avec le byte (en abrégé, B majuscule), qui vaut un octet, c'est-à-dire huit bits
(en abrégé, b minuscule).
Dans combien d’états différents un octet peut-il se trouver ? Le calcul est assez facile (mais il
faut néanmoins savoir le refaire). Chaque bit de l’octet 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 possibilités
Cela signifie qu’un octet peut servir à coder 256 nombres différents : ce peut être la série des
nombres entiers de 1 à 256, ou de 0 à 255, ou de –127 à +128. C’est une pure affaire de
convention, de choix de codage. Mais ce qui n’est pas affaire de choix, c’est le nombre de
possibilités : elles sont 256, pas une de plus, pas une de moins, à cause de ce qu’est, par
définition, un octet.
Si l’on veut coder des nombres plus grands que 256, ou des nombres négatifs, ou des nombres
décimaux, on va donc être contraint de mobiliser plus d’un octet. Ce n’est pas un problème, et
c’est très souvent que les ordinateurs procèdent ainsi.
En effet, avec deux octets, on a 256 x 256 = 65 536 possibilités.
En utilisant trois octets, on passe à 256 x 256 x 256 = 16 777 216 possibilités.
Et ainsi de suite, je ne m’attarderai pas davantage sur les différentes manières de coder les
nombres avec des octets. On abordera de nouveau brièvement le sujet un peu plus loin.
Cela implique également qu’un octet peut servir à coder autre chose qu’un nombre : l’octet est
très souvent employé pour coder du texte. Il y a 26 lettres dans l’alphabet. Même en comptant
différemment les minuscules et les majuscules, et même en y ajoutant les chiffres et les signes
de ponctuation, on arrive à un total inférieur à 256. Cela veut dire que pour coder
convenablement un texte, le choix d’un caractère par octet est un choix pertinent.
Se pose alors le problème de savoir quel caractère doit être représenté par quel état de l’octet.
Si ce choix était librement laissé à chaque informaticien, ou à chaque fabricant d’ordinateur,
la communication entre deux ordinateurs serait un véritable casse-tête. L’octet 10001001
serait par exemple traduit par une machine comme un T majuscule, et par une autre comme
une parenthèse fermante ! Aussi, il existe un standard international de codage des caractères et
des signes de ponctuation. Ce standard stipule quel état de l’octet correspond à quel signe du
clavier. Il s’appelle l’ASCII (pour American Standard Code for Information Interchange). Et
fort heureusement, l’ASCII est un standard universellement reconnu et appliqué par les
fabricants d’ordinateurs et de logiciels. Bien sûr, se pose le problème des signes propres à
telle ou telle langue (comme les lettres accentuées en français, par exemple). L’ASCII a paré
le problème en réservant certains codes d’octets pour ces caractères spéciaux à 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 alphabétiques (comme le chinois), elles
payent un lourd tribut à l’informatique pour n’avoir pas su évoluer vers le système
alphabétique…
Revenons-en au codage des nombres sur un octet. Nous avons vu qu’un octet pouvait coder
256 nombres différents, par exemple (c’est le choix le plus spontané) la série des entiers de 0
à 255. Comment faire pour, à partir d’un octet, reconstituer le nombre dans la base
décimale qui nous est plus familière ? Ce n’est pas sorcier ; il suffit d’appliquer, si on les a
bien compris, les principes de la numérotation de position, en gardant à l’esprit que là, la base
n’est pas décimale, mais binaire. Prenons un octet au hasard :
11010011
D'après les principes vus plus haut, ce nombre représente en base dix, en partant de la
gauche :
1 x 27 + 1 x 26 + 0 x 25 + 1 x 24 + 0 x 23 + 0 x 22 + 1 x 21 + 1 x 20 =
1 x 128 + 1 x 64 + 1 x 16 + 1 x 2 + 1 x 1 =
128 + 64 + 16 + 2 + 1 =
211
Et voilà ! Ce n’est pas plus compliqué que cela !
Inversement, comment traduire un nombre décimal 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. Je retranche 128 de 186 et j’obtiens 58.
Dans 58, on trouve 0 x 64, soit 0 x 26. Je ne retranche donc rien.
Dans 58, on trouve 1 x 32, soit 1 x 25. Je retranche 32 de 58 et j’obtiens 26.
Dans 26, on trouve 1 x 16, soit 1 x 24. Je retranche 16 de 26 et j’obtiens 10.
Dans 10, on trouve 1 x 8, soit 1 x 23. Je retranche 8 de 10 et j’obtiens 2.
Dans 2, on trouve 0 x 4, soit 0 x 22. Je ne retranche donc rien.
Dans 2, on trouve 1 x 2, soit 1 x 21. Je retranche 2 de 2 et j’obtiens 0.
Dans 0, on trouve 0 x 1, soit 0 x 20. Je ne retranche donc rien.
Il ne me reste plus qu’à reporter ces différents résultats (dans l’ordre !) pour reconstituer
l’octet. J’écris alors qu’en binaire, 186 est représenté par :
10111010
C’est bon ? Alors on passe à la suite.

4. Le codage hexadécimal
Pour en finir avec ce préambule (sinon, cela deviendrait de la gourmandise) , on va évoquer
un dernier type de codage, qui constitue une alternative pratique au codage binaire. Il s’agit du
codage hexadécimal, autrement dit en base seize.
Pourquoi ce choix bizarre ? Tout d’abord, parce que le codage binaire, ce n’est tout de même
pas très économique, ni très lisible. Pas très économique : pour représenter un nombre entre 1
et 256, il faut utiliser systématiquement huit chiffres. Pas très lisible : parce que
d’interminables suites de 1 et de 0, on a déjà vu plus folichon.
Alors, une alternative toute naturelle, c’était de représenter l’octet 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 près.
Avec 4 bits, nous pouvons coder 2 x 2 x 2 x 2 = 16 nombres différents. En base seize, 16
nombres différents se représentent avec un seul chiffre (de même qu’en base 10, dix nombres
se représentent avec un seul chiffre).
Quels symboles choisir pour les chiffres ? Pour les dix premiers, on n’a pas été chercher bien
loin : on a recyclé les dix chiffres de la base décimale. Les dix premiers nombres de la base
seize s’écrivent donc tout bêtement 0, 1, 2, 3, 4, 5, 6, 7, 8, et 9. Là, il nous manque encore 6
chiffres, pour représenter les nombres que nous écrivons en décimal 10, 11, 12, 13, 14 et 15.
Plutôt qu’inventer de nouveaux symboles (ce qu’on aurait très bien pu faire), on a recyclé les
premières lettres de l’alphabet. Ainsi, par convention, A vaut 10, B vaut 11, etc. jusqu’à F qui
vaut 15.
Or, on s’aperçoit que cette base hexadécimale permet une représentation très simple des octets
du binaire. Prenons un octet au hasard :
10011110
Pour convertir ce nombre en hexadécimal, il y a deux méthodes : l’une consiste à faire un
grand détour, en repassant par la base décimale. C’est un peu plus long, mais on y arrive.
L’autre méthode consiste à faire le voyage direct du binaire vers l’hexadécimal. Avec
l’habitude, c’est nettement plus rapide !
Première méthode :
On retombe sur un raisonnement déjà abordé. Cet octet représente en base dix :
1 x 27 + 0 x 26 + 0 x 25 + 1 x 24 + 1 x 23 + 1 x 22 + 1 x 21 + 0 x 20 =
1 x 128 + 1 x 16 + 1 x 8 + 1 x 4 + 1 x 2 + 0 x 1 =
128 + 16 + 8 + 4 + 2 =
158
De là, il faut repartir vers la base hexadécimale.
Dans 158, on trouve 9 x 16, c’est-à-dire 9 x 161. Je retranche 144 de 158 et j’obtiens 14.
Dans 14, on trouve 14 x 1, c’est-à-dire 14 x 160. On y est.
Le nombre s’écrit donc en hexadécimal : 9E
Deuxième méthode :
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, c’est 8 + 1, donc 9
1 1 1 0, c’est 8 + 4 + 2 donc 14
Le nombre s’écrit donc en hexadécimal : 9E. C’est la même conclusion qu’avec la première
méthode. Encore heureux !
Le codage hexadécimal est très souvent utilisé quand on a besoin de représenter les octets
individuellement, car dans ce codage, tout octet correspond à seulement deux signes.
Allez, assez bavardé, on passe aux choses sérieuses : les arcanes de l’algorithmique…
Introduction a l’Algorithmique
« Un langage de programmation est une convention pour donner des ordres à un ordinateur.
Ce n’est pas censé être obscur, bizarre et plein de pièges subtils. Ca, ce sont les
caractéristiques de la magie. » - Dave Small

« C'est illogique, Capitaine » - Mr Spock

L’algorithmique est un terme d’origine arabe, comme algèbre, amiral ou zénith. Ce n’est pas
une excuse pour massacrer son orthographe, ou sa prononciation.
Ainsi, l’algo n’est pas « rythmique », à la différence du bon rock’n roll. L’algo n’est pas non
plus « l’agglo ».
Alors, ne confondez pas l’algorithmique avec l’agglo rythmique, qui consiste à poser des
parpaings en cadence.
1. Qu’est-ce que l’algomachin ?
Avez-vous déjà ouvert un livre de recettes de cuisine ? Avez vous déjà déchiffré un mode
d’emploi traduit directement du coréen pour faire fonctionner un magnétoscope ou un
répondeur téléphonique réticent ? Si oui, sans le savoir, vous avez déjà exécuté des
algorithmes.
Plus fort : avez-vous déjà indiqué un chemin à un touriste égaré ? Avez vous fait chercher un
objet à quelqu’un par téléphone ? Ecrit une lettre anonyme stipulant comment procéder à une
remise de rançon ? Si oui, vous avez déjà fabriqué – et fait exécuter – des algorithmes.
Comme quoi, l’algorithmique n’est pas un savoir ésotérique réservé à quelques rares initiés
touchés par la grâce divine, mais une aptitude partagée par la totalité de l’humanité. Donc, pas
d’excuses…
Un algorithme, c’est une suite d’instructions, qui une fois exécutée correctement, conduit à un
résultat donné. Si l’algorithme est juste, le résultat est le résultat voulu, et le touriste se
retrouve là où il voulait aller. Si l’algorithme est faux, le résultat est, disons, aléatoire, et
décidément, cette saloperie de répondeur ne veut rien savoir.
Complétons toutefois cette définition. Après tout, en effet, si l’algorithme, comme on vient de
le dire, n’est qu’une suite d’instructions menant celui qui l’exécute à résoudre un problème,
pourquoi ne pas donner comme instruction unique : « résous le problème », et laisser
l’interlocuteur se débrouiller avec ça ? A ce tarif, n’importe qui serait champion
d’algorithmique sans faire aucun effort. Pas de ça Lisette, ce serait trop facile.
Le malheur (ou le bonheur, tout dépend du point de vue) est que justement, si le touriste vous
demande son chemin, c’est qu’il ne le connaît pas. Donc, si on n’est pas un goujat intégral, il
ne sert à rien de lui dire de le trouver tout seul. De même les modes d’emploi contiennent
généralement (mais pas toujours) un peu plus d’informations que « débrouillez vous pour que
ça marche ».
Pour fonctionner, un algorithme doit donc contenir uniquement des instructions
compréhensibles par celui qui devra l’exécuter. C’est d’ailleurs l’un des points délicats pour
les rédacteurs de modes d’emploi : les références culturelles, ou lexicales, des utilisateurs,
étant variables, un même mode d’emploi peut être très clair pour certains et parfaitement
abscons pour d’autres.
En informatique, heureusement, il n’y a pas ce problème : les choses auxquelles ont doit
donner des instructions sont les ordinateurs, et ceux-ci ont le bon goût d’être tous strictement
aussi idiots les uns que les autres.
2. Faut-il être matheux pour être bon en algorithmique ?
Je consacre quelques lignes à cette question, car cette opinion aussi fortement affirmée que
faiblement fondée sert régulièrement d’excuse : « moi, de toute façon, je suis mauvais(e) en
algo, j’ai jamais rien pigé aux maths ». Faut-il être « bon en maths » pour expliquer
correctement son chemin à quelqu’un ? Je vous laisse juge.
La maîtrise de l’algorithmique requiert deux qualités, très complémentaires d’ailleurs :
 il faut avoir une certaine intuition, car aucune recette ne permet de savoir a priori
quelles instructions permettront d’obtenir le résultat voulu. C’est là, si l’on y tient,
qu’intervient la forme « d’intelligence » requise pour l’algorithmique. Alors, c’est
certain, il y a des gens qui possèdent au départ davantage cette intuition que les
autres. Cependant, et j’insiste sur ce point, les réflexes, cela s’acquiert. Et ce qu’on
appelle l’intuition n’est finalement que de l’expérience tellement répétée que le
raisonnement, au départ laborieux, finit par devenir « spontané ».
 il faut être méthodique et rigoureux. En effet, chaque fois qu’on écrit une série
d’instructions qu’on croit justes, il faut systématiquement se mettre mentalement à la
place de la machine qui va les exécuter, armé d'un papier et d'un crayon, afin de
vérifier si le résultat obtenu est bien celui que l’on voulait. Cette opération ne requiert
pas la moindre once d’intelligence. Mais elle reste néanmoins indispensable, si l’on ne
veut pas écrire à l’aveuglette.

Et petit à petit, à force de pratique, vous verrez que vous pourrez faire de plus en plus souvent
l’économie de cette dernière étape : l’expérience fera que vous « verrez » le résultat produit
par vos instructions, au fur et à mesure que vous les écrirez. Naturellement, cet apprentissage
est long, et demande des heures de travail patient. Aussi, dans un premier temps, évitez de
sauter les étapes : la vérification méthodique, pas à pas, de chacun de vos algorithmes
représente plus de la moitié du travail à accomplir... et le gage de vos progrès.

3. L’ADN, les Shadoks, et les ordinateurs

Quel rapport me direz-vous ? Eh bien le point commun est : quatre mots de vocabulaire.
L’univers lexical Shadok, c’est bien connu, se limite aux termes « Ga », « Bu », « Zo », et
« Meu ». Ce qui leur a tout de même permis de formuler quelques fortes maximes, telles que :
« Mieux vaut pomper et qu’il ne se passe rien, plutôt qu’arrêter de pomper et risquer qu’il se
passe quelque chose de pire » (pour d’autres fortes maximes Shadok, n’hésitez pas à visiter
leur site Internet, il y en a toute une collection qui vaut le détour).
L’ADN, qui est en quelque sorte le programme génétique, l’algorithme à la base de
construction des êtres vivants, est une chaîne construite à partir de quatre éléments
invariables. Ce n’est que le nombre de ces éléments, ainsi que l’ordre dans lequel ils sont
arrangés, qui vont déterminer si on obtient une puce ou un éléphant. Et tous autant que nous
sommes, splendides réussites de la Nature, avons été construits par un « programme »
constitué uniquement de ces quatre briques, ce qui devrait nous inciter à la modestie.
Enfin, les ordinateurs, quels qu’ils soient, ne sont fondamentalement capables de comprendre
que quatre catégories d'ordres (en programmation, on n'emploiera pas le terme d'ordre, mais
plutôt celui d'instructions). Ces quatre familles d'instructions sont :
 l’affectation de variables
 la lecture / écriture

 les tests
 les boucles
Un algorithme informatique se ramène 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,
dans le cadre de ce cours, nous n’irons pas jusque là (cependant, la taille d’un algorithme ne
conditionne pas en soi sa complexité : de longs algorithmes peuvent être finalement assez
simples, et de petits très compliqués).

4. Algorithmique et programmation
Pourquoi apprendre l’algorithmique pour apprendre à programmer ? En quoi a-t-on besoin
d’un langage spécial, distinct des langages de programmation compréhensibles par les
ordinateurs ?
Parce que l’algorithmique exprime les instructions résolvant un problème donné
indépendamment des particularités de tel ou tel langage. Pour prendre une image, si un
programme était une dissertation, l’algorithmique serait le plan, une fois mis de côté la
rédaction et l’orthographe. Or, vous savez qu’il vaut mieux faire d’abord le plan et rédiger
ensuite que l’inverse…
Apprendre l’algorithmique, c’est apprendre à manier la structure logique d’un programme
informatique. Cette dimension est présente quelle que soit le langage de programmation ;
mais lorsqu’on programme dans un langage (en C, en Visual Basic, etc.) on doit en plus se
colleter les problèmes de syntaxe, ou de types d’instructions, propres à ce langage. Apprendre
l’algorithmique de manière séparée, c’est donc sérier les difficultés pour mieux les vaincre.
A cela, il faut ajouter que des générations de programmeurs, souvent autodidactes (mais pas
toujours, hélas !), ayant directement appris à programmer dans tel ou tel langage, ne font pas
mentalement clairement la différence entre ce qui relève de la structure logique générale de
toute programmation (les règles fondamentales de l’algorithmique) et ce qui relève du langage
particulier qu’ils ont appris. Ces programmeurs, non seulement ont beaucoup plus de mal à
passer ensuite à un langage différent, mais encore écrivent bien souvent des programmes qui
même s’ils sont justes, restent laborieux. Car on n’ignore pas impunément les règles
fondamentales de l’algorithmique… Alors, autant l’apprendre en tant que telle !
Bon, maintenant que j’ai bien fait l’article pour vendre ma marchandise, on va presque
pouvoir passer au vif du sujet…

5. Avec quelles conventions écrit-on un algorithme ?

Historiquement, plusieurs types de notations ont représenté des algorithmes.
Il y a eu notamment une représentation graphique, avec des carrés, des losanges, etc. qu’on
appelait des organigrammes. Aujourd’hui, cette représentation est quasiment abandonnée,
pour deux raisons. D’abord, parce que dès que l’algorithme commence à grossir un peu, ce
n’est plus pratique du tout du tout. Ensuite parce que cette représentation favorise le
glissement vers un certain type de programmation, dite non structurée (nous définirons ce
terme plus tard), que l’on tente au contraire d’éviter.
C’est pourquoi on utilise généralement une série de conventions appelée « pseudo-code », qui
ressemble à un langage de programmation authentique dont on aurait évacué la plupart des
problèmes de syntaxe. Ce pseudo-code est susceptible de varier légèrement d’un livre (ou
d’un enseignant) à un autre. C’est bien normal : le pseudo-code, encore une fois, est purement
conventionnel ; aucune machine n’est censée le reconnaître. Donc, chaque cuisinier peut faire
sa sauce à sa guise, avec ses petites épices bien à lui, sans que cela prête à conséquence.
Comme je n’ai pas moins de petites manies que la majorité de mes semblables, le pseudo-
code que vous découvrirez dans les pages qui suivent possède quelques spécificités mineures
qui ne doivent qu’à mes névroses personnelles.
Rassurez-vous cependant, celles-ci restent dans les limites tout à fait acceptables.
En tout cas, personnellement, je les accepte très bien.
Partie 1
Les Variables
« N’attribuez jamais à la malveillance ce qui s’explique très bien par l’incompétence. » -
Napoléon Bonaparte

« A l’origine de toute erreur attribuée à l’ordinateur, vous trouverez au moins deux erreurs
humaines. Dont celle consistant à attribuer l’erreur à l’ordinateur. » - Anonyme

1. A quoi servent les variables ?

Dans un programme informatique, on va avoir en permanence besoin de stocker
provisoirement des valeurs. Il peut s’agir de données issues du disque dur, fournies par
l’utilisateur (frappées au clavier), ou que sais-je encore. Il peut aussi s’agir de résultats
obtenus par le programme, intermédiaires ou définitifs. Ces données peuvent être de plusieurs
types (on en reparlera) : elles peuvent être des nombres, du texte, etc. Toujours est-il que dès
que l’on a besoin de stocker une information au cours d’un programme, on utilise une
variable.
Pour employer une image, une variable est une boîte, que le programme (l’ordinateur) va
repérer par une étiquette. Pour avoir accès au contenu de la boîte, il suffit de la désigner par
son étiquette.
En réalité, dans la mémoire vive de l’ordinateur, il n’y a bien sûr pas une vraie boîte, et pas
davantage de vraie étiquette collée dessus (j’avais bien prévenu que la boîte et l’étiquette,
c’était une image). Dans l’ordinateur, physiquement, il y a un emplacement de mémoire,
repéré par une adresse binaire. Si on programmait dans un langage directement
compréhensible par la machine, on devrait se fader de désigner nos données par de superbes
10011001 et autres 01001001 (enchanté !). Mauvaise nouvelle : de tels langages existent ! Ils
portent le doux nom d’assembleur. Bonne nouvelle : ce ne sont pas les seuls langages
disponibles.
Les langages informatiques plus évolués (ce sont ceux que presque tout le monde emploie) se
chargent précisément, entre autres rôles, d’épargner au programmeur la gestion fastidieuse des
emplacements mémoire et de leurs adresses. Et, comme vous commencez à le comprendre, il
est beaucoup plus facile d’employer les étiquettes de son choix, que de devoir manier des
adresses binaires.

2. Déclaration des variables

La première chose à faire avant de pouvoir utiliser une variable est de créer la boîte et de lui
coller une étiquette. Ceci se fait tout au début de l’algorithme, avant même les instructions
proprement dites. C’est ce qu’on appelle la déclaration des variables. C’est un genre de
déclaration certes moins romantique qu’une déclaration d’amour, mais d’un autre côté moins
désagréable qu’une déclaration d’impôts.
Le nom de la variable (l’étiquette de la boîte) obéit à des impératifs changeant selon les
langages. Toutefois, une règle absolue est qu’un nom de variable peut comporter des lettres et
des chiffres, mais qu’il exclut la plupart des signes de ponctuation, en particulier les espaces.
Un nom de variable correct commence également impérativement par une lettre. Quant au
nombre maximal de signes pour un nom de variable, il dépend du langage utilisé.
En pseudo-code algorithmique, on est bien sûr libre du nombre de signes pour un nom de
variable, même si pour des raisons purement pratiques, et au grand désespoir de Stéphane
Bern, on évite généralement les noms à rallonge.
Lorsqu’on déclare une variable, il ne suffit pas de créer une boîte (réserver un emplacement
mémoire) ; encore doit-on préciser ce que l’on voudra mettre dedans, car de cela dépendent la
taille de la boîte (de l’emplacement mémoire) et le type de codage utilisé.

2.1 Types numériques classiques

Commençons par le cas très fréquent, celui d’une variable destinée à recevoir des nombres.
Si l’on réserve un octet pour coder un nombre, je rappelle pour ceux qui dormaient en lisant le
chapitre précédent qu’on ne pourra coder que 28 = 256 valeurs différentes. Cela peut signifier
par exemple les nombres entiers de 1 à 256, ou de 0 à 255, ou de –127 à +128… Si l’on
réserve deux octets, on a droit à 65 536 valeurs ; avec trois octets, 16 777 216, etc. Et là se
pose un autre problème : ce codage doit-il représenter des nombres décimaux ? des nombres
négatifs ?
Bref, le type de codage (autrement dit, le type de variable) choisi pour un nombre va
déterminer :
 les valeurs maximales et minimales des nombres pouvant être stockés dans la variable
 la précision de ces nombres (dans le cas de nombres décimaux).

Tous les langages, quels qu’ils soient offrent un « bouquet » de types numériques, dont le détail est
susceptible de varier légèrement d’un langage à l’autre. Grosso modo, on retrouve cependant les
types suivants :

Type Numérique Plage

Byte (octet) 0 à 255
Entier simple -32 768 à 32 767
Entier long -2 147 483 648 à 2 147 483 647
-3,40x1038 à -1,40x1045 pour les valeurs négatives
Réel simple
1,40x10-45 à 3,40x1038 pour les valeurs positives
1,79x10308 à -4,94x10-324 pour les valeurs négatives
Réel double
4,94x10-324 à 1,79x10308 pour les valeurs positives
Pourquoi ne pas déclarer toutes les variables numériques en réel double, histoire de bétonner
et d’être certain qu’il n’y aura pas de problème ? En vertu du principe de l’économie 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, l’abus de
variables surdimensionnées peut entraîner des ralentissements notables à l’exécution, voire un
plantage pur et simple de l’ordinateur. Alors, autant prendre dès le début de bonnes habitudes
d’hygiène.
En algorithmique, on ne se tracassera pas trop avec les sous-types de variables numériques
(sachant qu'on aura toujours assez de soucis comme ça, allez). On se contentera donc de
préciser qu'il s'agit d'un nombre, en gardant en tête que dans un vrai langage, il faudra être
plus précis.
En pseudo-code, une déclaration de variables aura ainsi cette tête :
Variable g en Numérique
ou encore
Variables PrixHT, TauxTVA, PrixTTC en Numérique
2.2 Autres types numériques
Certains langages autorisent d’autres types numériques, notamment :
 le type monétaire (avec strictement deux chiffres après la virgule)
 le type date (jour/mois/année).

Nous n’emploierons pas ces types dans ce cours ; mais je les signale, car vous ne manquerez
pas de les rencontrer en programmation proprement dite.

2.3 Type alphanumérique

Fort heureusement, les boîtes que sont les variables peuvent contenir bien d’autres
informations que des nombres. Sans cela, on serait un peu embêté dès que l’on devrait stocker
un nom de famille, par exemple.
On dispose donc également du type alphanumérique (également appelé type caractère, type
chaîne ou en anglais, le type string – mais ne fantasmez pas trop vite, les string, c’est loin
d’être aussi excitant que le nom le suggère. Une étudiante qui se reconnaîtra si elle lit ces
lignes a d'ailleurs mis le doigt - si j'ose m'exprimer ainsi - sur le fait qu'il en va de même en ce
qui concerne les bytes).
Dans une variable de ce type, on stocke des caractères, qu’il s’agisse de lettres, de signes de
ponctuation, d’espaces, ou même de chiffres. Le nombre maximal de caractères pouvant être
stockés dans une seule variable string dépend du langage utilisé.
Un groupe de caractères (y compris un groupe de un, ou de zéro caractères), qu’il soit ou non
stocké dans une variable, d’ailleurs, est donc souvent appelé chaîne de caractères.
En pseudo-code, une chaîne de caractères est toujours notée entre guillemets
Pourquoi diable ? Pour éviter deux sources principales de possibles confusions :
 la confusion entre des nombres et des suites de chiffres. Par exemple, 423 peut
représenter le nombre 423 (quatre cent vingt-trois), ou la suite de caractères 4, 2, et 3.
Et ce n’est pas du tout la même chose ! Avec le premier, on peut faire des calculs,
avec le second, point du tout. Dès lors, les guillemets permettent d’éviter toute
ambiguïté : s’il n’y en a pas, 423 est quatre cent vingt trois. S’il y en a, "423"
représente la suite des chiffres 4, 2, 3.
 …Mais ce n'est pas le pire. L'autre confusion, bien plus grave - et bien plus fréquente
– consiste à se mélanger les pinceaux entre le nom d'une variable et son contenu. Pour
parler simplement, cela consiste à confondre l'étiquette d'une boîte et ce qu'il y a à
l'intérieur… On reviendra sur ce point crucial dans quelques instants.

2.4 Type booléen

Le dernier type de variables est le type booléen : on y stocke uniquement les valeurs logiques
VRAI et FAUX.
On peut représenter 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 booléen est très économique en termes de place mémoire occupée,
puisque pour stocker une telle information binaire, un seul bit suffit.
Le type booléen est très souvent négligé par les programmeurs, à tort.

Il est vrai qu'il n'est pas à proprement parler indispensable, et qu'on pourrait écrire à peu près
n’importe quel programme en l'ignorant complètement. Pourtant, si le type booléen est mis à
disposition des programmeurs dans tous les langages, ce n'est pas pour rien. Le recours aux
variables booléennes s'avère très 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 manières de s'exprimer pour dire
sur le fond la même chose. Nous verrons plus loin différents exemples de variations
stylistiques autour d'une même solution. En attendant, vous êtes prévenus : l'auteur de ce
cours est un adepte fervent (mais pas irraisonné) de l'utilisation des variables booléennes.

3. L’instruction d’affectation
3.1 Syntaxe et signification
Ouf, après tout ce baratin préliminaire, on aborde enfin nos premières véritables
manipulations d’algorithmique. Pas trop tôt, certes, mais pas moyen de faire autrement !
En fait, la variable (la boîte) n'est pas un outil bien sorcier à manipuler. A la différence du
couteau suisse ou du superbe robot ménager vendu sur Télé Boutique Achat, on ne peut pas
faire trente-six mille choses avec une variable, mais seulement une et une seule.
Cette seule chose qu’on puisse faire avec une variable, c’est l’affecter, c’est-à-dire lui
attribuer une valeur. Pour poursuivre la superbe métaphore filée déjà employée, on peut
remplir la boîte.
En pseudo-code, l'instruction d'affectation se note avec le signe ←
Ainsi :
Toto ← 24
Attribue la valeur 24 à la variable Toto.
Ceci, soit dit en passant, sous-entend impérativement que Toto soit une variable de type
numérique. Si Toto a été défini dans un autre type, il faut bien comprendre que cette
instruction provoquera une erreur. C’est un peu comme si, en donnant un ordre à quelqu’un,
on accolait un verbe et un complément incompatibles, du genre « Epluchez la casserole ».
Même dotée de la meilleure volonté du monde, la ménagère lisant cette phrase ne pourrait
qu’interrompre dubitativement sa tâche. Alors, un ordinateur, vous pensez bien…
On peut en revanche sans aucun problème attribuer à une variable la valeur d’une autre
variable, telle quelle ou modifiée. Par exemple :
Tutu ← Toto
Signifie que la valeur de Tutu est maintenant celle de Toto.
Notez bien que cette instruction n’a en rien modifié la valeur de Toto : une instruction
d’affectation ne modifie que ce qui est situé à gauche de la flèche.
Tutu ← Toto + 4
Si Toto contenait 12, Tutu vaut maintenant 16. De même que précédemment, Toto vaut
toujours 12.
Tutu ← Tutu + 1
Si Tutu valait 6, il vaut maintenant 7. La valeur de Tutu est modifiée, puisque Tutu est la
variable située à gauche de la flèche.
Pour revenir à présent sur le rôle des guillemets dans les chaînes de caractères et sur la
confusion numéro 2 signalée plus haut, comparons maintenant deux algorithmes suivants :
Exemple n°1
Début
Riri ← "Loulou"
Fifi ← "Riri"
Fin
Exemple n°2
Début
Riri ← "Loulou"
Fifi ← Riri
Fin
La seule différence entre les deux algorithmes consiste dans la présence ou dans l’absence des
guillemets lors de la seconde affectation. Et l'on voit que cela change tout !
Dans l'exemple n°1, ce que l'on affecte à la variable Fifi, c'est la suite de caractères R – i – r -
i. Et à la fin de l’algorithme, le contenu de la variable Fifi est donc « Riri ».
Dans l'exemple n°2, en revanche, Riri étant dépourvu de guillemets, n'est pas considéré
comme une suite de caractères, 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 l’algorithme n°2,
la valeur de la variable Fifi est donc « Loulou ». Ici, l’oubli des guillemets conduit certes à un
résultat, mais à un résultat différent.
A noter, car c’est un cas très fréquent, que généralement, lorsqu’on oublie les guillemets lors
d’une affectation de chaîne, ce qui se trouve à droite du signe d’affectation ne correspond à
aucune variable précédemment déclarée et affectée. Dans ce cas, l’oubli des guillemets se
solde immédiatement par une erreur d’exécution.
Ceci est une simple illustration. Mais elle résume l’ensemble des problèmes qui surviennent
lorsqu’on oublie la règle des guillemets aux chaînes de caractères.

3.2 Ordre des instructions

Il va de soi que l’ordre dans lequel les instructions sont écrites va jouer un rôle essentiel dans
le résultat final. Considérons les deux algorithmes suivants :
Exemple 1
Variable A en Numérique
Début
A ← 34
A ← 12
Fin

Exemple 2
Variable A en Numérique
Début
A ← 12
A ← 34
Fin
Il est clair que dans le premier cas la valeur finale de A est 12, dans l’autre elle est 34 .
Il est tout aussi clair que ceci ne doit pas nous étonner. Lorsqu’on indique le chemin à
quelqu’un, dire « prenez tout droit sur 1km, puis à droite » n’envoie pas les gens au même
endroit que si l’on dit « prenez à droite puis tout droit pendant 1 km ».
Enfin, il est également clair que si l’on met de côté leur vertu pédagogique, les deux
algorithmes ci-dessus sont parfaitement idiots ; à tout le moins ils contiennent une
incohérence. Il n’y a aucun intérêt à affecter une variable pour l’affecter différemment juste
après. En l’occurrence, on aurait tout aussi bien atteint le même résultat en
écrivant simplement :

Exemple 1
Variable A en Numérique
Début
A ← 12
Fin

Exemple 2
Variable A en Numérique
Début
A ← 34
Fin
Tous les éléments sont maintenant en votre possession pour que ce soit à vous de jouer !

Exercice 1.1
Quelles seront les valeurs des variables A et B après exécution des instructions suivantes ?
Variables A, B en Entier
Début
A←1
B←A+3
A←3
Fin

Corrigé Exercice 1.1

Après La valeur des variables est :
A←1 A=1 B=?
B←A+3 A=1 B=4
A←3 A=3 B=4

Exercice 1.2
Quelles seront les valeurs des variables A, B et C après exécution des instructions suivantes ?
Variables A, B, C en Entier
Début
A←5
B←3
C←A+B
A←2
C←B–A
Fin

Corrigé Exercice 1.2

Après La valeur des variables est :
A←5 A=5 B=? C=?
B←3 A=5 B=3 C=?
C←A+B A=5 B=3 C=8
A←2 A=2 B=3 C=8
C←B–A A=2 B=3 C=1

Exercice 1.3
Quelles seront les valeurs des variables A et B après exécution des instructions suivantes ?
Variables A, B en Entier
Début
A←5
B←A+4
A←A+1
B←A–4
Fin

Corrigé Exercice 1.3

Après La valeur des variables est :

A←5 A=5 B=?
B←A+4 A=5 B=9
A←A+1 A=6 B=9
B←A–4 A=6 B=2

Exercice 1.4
Quelles seront les valeurs des variables A, B et C après exécution des instructions suivantes ?
Variables A, B, C en Entier
Début
A←3
B ← 10
C←A+B
B←A+B
A←C
Fin

Corrigé Exercice 1.4

Après La valeur des variables est :

A←3 A=3 B=? C=?
B ← 10 A=3 B = 10 C=?
C←A+B A=3 B = 10 C = 13
B←A+B A=3 B = 13 C = 13
A←C A = 13 B = 13 C = 13

Exercice 1.5
Quelles seront les valeurs des variables A et B après exécution des instructions suivantes ?
Variables A, B en Entier
Début
A←5
B←2
A←B
B←A
Fin
Moralité : les deux dernières instructions permettent-elles d’échanger les deux valeurs de B et
A ? Si l’on inverse les deux dernières instructions, cela change-t-il quelque chose ?

Corrigé Exercice 1.5

Après La valeur des variables est :
A←5 A=5 B=?
B←2 A=5 B=2
A←B A=2 B=2
B←A A=2 B=2

Les deux dernières instructions ne permettent donc pas d’échanger les deux valeurs de B et A,
puisque l’une des deux valeurs (celle de A) est ici écrasée.
Si l’on inverse les deux dernières instructions, cela ne changera rien du tout, hormis le fait que cette
fois c’est la valeur de B qui sera écrasée.

Exercice 1.6
Plus difficile, mais c’est un classique absolu, qu’il faut absolument maîtriser : écrire un
algorithme permettant d’échanger les valeurs de deux variables A et B, et ce quel que soit leur
contenu préalable.

Corrigé Exercice 1.6

Début
…
C←A
A←B
B←C
Fin

On est obligé de passer par une variable dite temporaire (la variable C).

Exercice 1.7
Une variante du précédent : on dispose de trois variables A, B et C. Ecrivez un algorithme
transférant à B la valeur de A, à C la valeur de B et à A la valeur de C (toujours quels que
soient les contenus préalables de ces variables).

Corrigé Exercice 1.7

Début
…
D←C
C←B
B←A
A←D
Fin

En fait, quel que soit le nombre de variables, une seule variable temporaire suffit…
4. Expressions et opérateurs
Si on fait le point, on s’aperçoit que dans une instruction d’affectation, on trouve :
 à gauche de la flèche, un nom de variable, et uniquement cela. En ce monde empli de
doutes qu’est celui de l’algorithmique, c’est une des rares règles d’or qui marche à
tous les coups : si on voit à gauche d’une flèche d’affectation autre chose qu’un nom
de variable, on peut être certain à 100% qu’il s’agit d’une erreur.
 à droite de la flèche, ce qu’on appelle une expression. Voilà encore un mot qui est
trompeur ; en effet, ce mot existe dans le langage courant, où il revêt bien des
significations. Mais en informatique, le terme d’expression ne désigne qu’une seule
chose, et qui plus est une chose très précise :

Une expression est un ensemble de valeurs, reliées par des opérateurs, et équivalent à une
seule valeur
Cette définition vous paraît peut-être obscure. Mais réfléchissez-y quelques minutes, et vous
verrez qu’elle recouvre quelque chose d’assez simple sur le fond. Par exemple, voyons
quelques expressions de type numérique. Ainsi :
7
5+4
123-45+844
Toto-12+5-Riri
…sont toutes des expressions valides, pour peu que Toto et Riri soient bien des nombres. Car
dans le cas contraire, la quatrième expression n’a pas de sens. En l’occurrence, les opérateurs
que j’ai employés sont l’addition (+) et la soustraction (-).
Revenons pour le moment sur l’affectation. Une condition supplémentaire (en plus des deux
précédentes) de validité d’une instruction d’affectation est que :
 l’expression située à droite de la flèche soit du même type que la variable située à
gauche. C’est très logique : on ne peut pas ranger convenablement des outils dans un
sac à provision, ni des légumes dans une trousse à outils… sauf à provoquer un
résultat catastrophique.

Si l’un des trois points énumérés ci-dessus n’est pas respecté, la machine sera incapable
d’exécuter l’affectation, et déclenchera une erreur (est-il besoin de dire que si aucun de ces
points n’est respecté, il y aura aussi erreur !)
On va maintenant détailler ce que l’on entend par le terme d’ opérateur.
Un opérateur est un signe qui relie deux valeurs, pour produire un résultat.
Les opérateurs possibles dépendent du type des valeurs qui sont en jeu. Allons-y, faisons le
tour, c’est un peu fastidieux, mais comme dit le sage au petit scarabée, quand c’est fait, c’est
plus à faire.

4.1 Opérateurs numériques :

Ce sont les quatre opérations arithmétiques tout ce qu’il y a de classique.
+ : addition
- : soustraction
* : multiplication
/ : division
Mentionnons également le ^ qui signifie « puissance ». 45 au carré s’écrira donc 45 ^ 2.
Enfin, on a le droit d’utiliser les parenthèses, avec les mêmes règles qu’en mathématiques. La
multiplication et la division ont « naturellement » priorité sur l’addition et la soustraction. Les
parenthèses ne sont ainsi utiles que pour modifier cette priorité naturelle.
Cela signifie qu’en informatique, 12 * 3 + 5 et (12 * 3) + 5 valent strictement la même chose,
à savoir 41. Pourquoi dès lors se fatiguer à mettre des parenthèses inutiles ?
En revanche, 12 * (3 + 5) vaut 12 * 8 soit 96. Rien de difficile là-dedans, que du normal.

4.2 Opérateur alphanumérique : &

Cet opérateur permet de concaténer, autrement dit d’agglomérer, deux chaînes de caractères.
Par exemple :
Variables A, B, C en Caractère
Début
A ← "Gloubi"
B ← "Boulga"
C←A&B
Fin
La valeur de C à la fin de l’algorithme est "GloubiBoulga"

4.3 Opérateurs logiques (ou booléens) :

Il s’agit du ET, du OU, du NON et du mystérieux (mais rarissime XOR). Nous les laisserons
de côté… provisoirement, soyez-en sûrs.

Exercice 1.8
Que produit l’algorithme suivant ?
Variables A, B, C en Caractères
Début
A ← "423"
B ← "12"
C←A+B
Fin

Corrigé Exercice 1.8

Il ne peut produire qu’une erreur d’exécution, puisqu’on ne peut pas additionner des caractères.

Exercice 1.9
Que produit l’algorithme suivant ?
Variables A, B, C en Caractères
Début
A ← "423"
B ← "12"
C←A&B
Fin

Corrigé Exercice 1.9

…En revanche, on peut les concaténer. A la fin de l’algorithme, C vaudra donc "42312".

5. Deux remarques pour terminer

Maintenant que nous sommes familiers des variables et que nous les manipulons les yeux
fermés (mais les neurones en éveil, toutefois), j’attire votre attention sur la trompeuse
similitude de vocabulaire entre les mathématiques et l’informatique. En mathématiques, une
« variable » est généralement une inconnue, qui recouvre un nombre non précisé de valeurs.
Lorsque j’écris :
y=3x+2
les « variables » x et y satisfaisant à l’équation existent en nombre infini (graphiquement,
l’ensemble des solutions à cette équation dessine une droite). Lorsque j’écris :
ax² + bx + c = 0
la « variable » x désigne les solutions à cette équation, c’est-à-dire zéro, une ou deux valeurs à
la fois…
En informatique, une variable possède à un moment donné une valeur et une seule. A la
rigueur, elle peut ne pas avoir de valeur du tout (une fois qu’elle a été déclarée, et tant qu’on
ne l’a pas affectée. A signaler que dans certains langages, les variables non encore affectées
sont considérées comme valant automatiquement zéro). Mais ce qui est important, c’est que
cette valeur justement, ne « varie » pas à proprement parler. Du moins ne varie-t-elle que
lorsqu’elle est l’objet d’une instruction d’affectation.
La deuxième remarque concerne le signe de l’affectation. En algorithmique, comme on l’a vu,
c’est le signe ←. Mais en pratique, la quasi totalité des langages emploient le signe égal. Et là,
pour les débutants, la confusion avec les maths est également facile. 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 différentes. De même, A = A + 1, qui
en mathématiques, constitue une équation sans solution, représente en programmation une
action tout à fait licite (et de surcroît extrêmement courante). Donc, attention ! ! ! La
meilleure des vaccinations contre cette confusion consiste à bien employer le signe ← en
pseudo-code, signe qui a le mérite de ne pas laisser place à l’ambiguïté. Une fois acquis les
bons réflexes avec ce signe, vous n’aurez plus aucune difficulté à passer au = des langages de
programmation.
Partie 2
Lecture et Ecriture
« Un programme est un sort jeté sur un ordinateur, qui transforme tout texte saisi au clavier
en message d’erreur. » - Anonyme

« Un clavier Azerty en vaut deux » - Anonyme

1. De quoi parle-t-on ?
Trifouiller des variables en mémoire vive par un chouette programme, c’est vrai que c’est très
marrant, et d’ailleurs on a tous bien rigolé au chapitre précédent. Cela dit, à la fin de la foire,
on peut tout de même se demander à quoi ça sert.
En effet. Imaginons que nous ayons fait un programme pour calculer le carré d’un nombre,
mettons 12. Si on a fait au plus simple, on a écrit un truc du genre :
Variable A en Numérique
Début
A ← 12^2
Fin
D’une part, ce programme nous donne le carré de 12. C’est très gentil à lui. Mais si l’on veut
le carré d’un autre nombre que 12, il faut réécrire le programme. Bof.
D’autre part, le résultat est indubitablement calculé par la machine. Mais elle le garde
soigneusement pour elle, et le pauvre utilisateur qui fait exécuter ce programme, lui, ne saura
jamais quel est le carré de 12. Re-bof.
C’est pourquoi, heureusement, il existe des d’instructions pour permettre à la machine de
dialoguer avec l’utilisateur (et Lycée de Versailles, eût ajouté l’estimé Pierre Dac, qui en
précurseur méconnu de l’algorithmique, affirmait tout aussi profondément que « rien ne sert
de penser, il faut réfléchir avant »).
Dans un sens, ces instructions permettent à l’utilisateur de rentrer des valeurs au clavier pour
qu’elles soient utilisées par le programme. Cette opération est la lecture.
Dans l’autre sens, d’autres instructions permettent au programme de communiquer des
valeurs à l’utilisateur en les affichant à l’écran. Cette opération est l’écriture.
Remarque essentielle : A première vue, on peut avoir l’impression que les informaticiens
étaient beurrés comme des petits lus lorsqu’ils ont baptisé ces opérations ; puisque quand
l’utilisateur doit écrire au clavier, on appelle ça la lecture, et quand il doit lire sur l’écran on
appelle çà l’écriture. Mais avant d’agonir d’insultes une digne corporation, il faut réfléchir un
peu plus loin. Un algorithme, c’est une suite d’instructions qui programme la machine, pas
l’utilisateur ! Donc quand on dit à la machine de lire une valeur, cela implique que
l’utilisateur va devoir écrire cette valeur. Et quand on demande à la machine d’écrire une
valeur, c’est pour que l’utilisateur 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 chargée de les exécuter. Et là, tout devient parfaitement logique. Et toc.

2. Les instructions de lecture et d’écriture

Tout bêtement, pour que l’utilisateur entre la (nouvelle) valeur de Titi, on mettra :
Lire Titi
Dès que le programme rencontre une instruction Lire, l’exécution s’interrompt, attendant la
frappe d’une valeur au clavier
Dès lors, aussitôt que la touche Entrée (Enter) a été frappée, l’exécution reprend. Dans le sens
inverse, pour écrire quelque chose à l’écran, c’est aussi simple que :
Ecrire Toto
Avant de Lire une variable, il est très fortement conseillé d’écrire des libellés à l’écran, afin
de prévenir l’utilisateur de ce qu’il doit frapper (sinon, le pauvre utilisateur passe son temps à
se demander ce que l’ordinateur attend de lui… et c’est très désagréable !) :
Ecrire "Entrez votre nom : "
Lire NomFamille
Lecture et Ecriture sont des instructions algorithmiques qui ne présentent pas de difficultés
particulières, une fois qu’on a bien assimilé ce problème du sens du dialogue (homme →
machine, ou machine ← homme).
Et ça y est, vous savez d’ores et déjà sur cette question tout ce qu’il y a à savoir…

Exercice 2.1
Quel résultat produit le programme suivant ?
Variables val, double numériques
Début
Val ← 231
Double ← Val * 2
Ecrire Val
Ecrire Double
Fin

Corrigé Exercice 2.1

On verra apparaître à l’écran 231, puis 462 (qui vaut 231 * 2)

Exercice 2.2
Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et affiche le
carré de ce nombre.

Corrigé Exercice 2.2

Variables nb, carr en Entier

Début
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 remplaçant les deux avant-
dernières lignes par :
Ecrire "Son carré est : ", nb*nb
C'est une question de style ; dans un cas, on privilégie la lisibilité de l'algorithme, dans l'autre,
on privilégie l'économie d'une variable.

Equivalent javascipt :
var nb=0 ;
var carr=0 ;
nb = prompt("Entrez un nombre : ", "") ;
carr = nb * nb ;
alert("Son carré est :"+carr ) ;

Exercice 2.3
Ecrire un programme qui lit le prix HT d’un article, le nombre d’articles et le taux de TVA, et
qui fournit le prix total TTC correspondant. Faire en sorte que des libellés apparaissent
clairement.

Corrigé Exercice 2.3

Variables nb, pht, ttva, pttc en Numérique

Début
Ecrire "Entrez le prix hors taxes :"
Lire pht
Ecrire "Entrez le nombre d’articles :"
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 léger en mémoire, mais un peu plus difficile à relire (et à écrire !)

Equivalent javascipt :

var nb=0 ;
var pht =0 ;
var ttva =0 ;
var pttc =0 ;

pht = prompt("Entrez le prix hors taxes : ", "") ;

nb = prompt("Entrez le nombre d’articles: ", "") ;
ttva = prompt("Entrez le taux de TVA: ", "") ;

pttc = nb * pht * (1 + ttva) ;

alert("Le prix toutes taxes est : "+ pttc) ;

Exercice 2.4
Ecrire un algorithme utilisant des variables de type chaîne de caractères, et affichant quatre
variantes possibles de la célèbre « belle marquise, vos beaux yeux me font mourir d’amour ».
On ne se soucie pas de la ponctuation, ni des majuscules.

Corrigé Exercice 2.4

Variables t1, t2, t3, t4 en Caractère
Début
t1 ← "belle Marquise"
t2 ← "vos beaux yeux"
t3 ← "me font mourir"
t4 ← "d’amour"
Ecrire t1 & " " & t2 & " " & t3 & " " & t4
Ecrire t3 & " " & t2 & " " & t4 & " " & t1
Ecrire t2 & " " & t3 & " " & t1 & " " & t4
Ecrire t4 & " " & t1 & " " & t2 & " " & t3
Fin

Equivalent javascipt :

var t1= "";

var t2= "";
var t3= "";
var t4= "";

t1 = "belle Marquise" ;
t2 = "vos beaux yeux" ;
t3 = "me font mourir" ;
t4 = "d’amour" ;
alert (t1 + " " + t2 + " " + t3 + " " + t4) ;
alert( t3 + " " + t2 + " " + t4 + " " + t1) ;
alert (t2 + " " + t3 + " " + t1 + " " + t4) ;
alert (t4 + " " + t1 + " " + t2 + " " + t3) ;
Partie 3
Les Tests
« Il est assez difficile de trouver une erreur dans son code quand on la cherche. C’est encore
bien plus dur quand on est convaincu que le code est juste. » - Steve McConnell

« Il n’existe pas, et il n’existera jamais, de langage dans lequel il soit un tant soit peu difficile
d’écrire de mauvais programmes ». - Anonyme

« Si le déboguage est l’art d’enlever les bogues, alors la programmation doit être l’art de les
créer. » - Anonyme

Je vous avais dit que l’algorithmique, c’est la combinaison de quatre structures élémentaires.
Nous en avons déjà vu deux, voici la troisième. Autrement dit, on a quasiment fini le
programme.
Mais non, je rigole.

1. De quoi s’agit-il ?
Reprenons le cas de notre « programmation algorithmique du touriste égaré ». Normalement,
l’algorithme ressemblera à quelque chose comme : « Allez tout droit jusqu’au prochain
carrefour, puis prenez à droite et ensuite la deuxième à gauche, et vous y êtes ».
Mais en cas de doute légitime de votre part, cela pourrait devenir : « Allez tout droit jusqu’au
prochain carrefour et là regardez à droite. Si la rue est autorisée à la circulation, alors
prenez la et ensuite c’est la deuxième à gauche. Mais si en revanche elle est en sens interdit,
alors continuez jusqu’à la prochaine à droite, prenez celle-là, et ensuite la première à
droite ».
Ce deuxième algorithme a ceci de supérieur au premier qu’il prévoit, en fonction d’une
situation pouvant se présenter de deux façons différentes, deux façons différentes d’agir. Cela
suppose que l’interlocuteur (le touriste) sache analyser la condition que nous avons fixée à
son comportement (« la rue est-elle en sens interdit ? ») pour effectuer la série d’actions
correspondante.
Eh bien, croyez le ou non, mais les ordinateurs possèdent cette aptitude, sans laquelle
d’ailleurs nous aurions bien du mal à les programmer. Nous allons donc pouvoir parler à notre
ordinateur comme à notre touriste, et lui donner des séries d’instructions à effectuer selon que
la situation se présente d’une manière ou d’une autre. Cette structure logique répond au doux
nom de test. Toutefois, ceux qui tiennent absolument à briller en société parleront également
de structure alternative.

2. Structure d’un test

Il n’y a que deux formes possibles pour un test ; la première est la plus simple, la seconde la
plus complexe.
Si booléen Alors
Instructions
Finsi
Si booléen Alors
Instructions 1
Sinon
Instructions 2
Finsi
Ceci appelle quelques explications.
Un booléen est une expression dont la valeur est VRAI ou FAUX. Cela peut donc être (il n’y
a que deux possibilités) :
 une variable (ou une expression) de type booléen
 une condition

Nous reviendrons dans quelques instants sur ce qu’est une condition en informatique.
Toujours est-il que la structure d’un test est relativement claire. Dans la forme la plus simple,
arrivé à la première ligne (Si… Alors) la machine examine la valeur du booléen. Si ce booléen
a pour valeur VRAI, elle exécute la série d’instructions. Cette série d’instructions peut être
très brève comme très longue, cela n’a aucune importance. En revanche, dans le cas où le
booléen est faux, l'ordinateur saute directement aux instructions situées après le FinSi.
Dans le cas de la structure complète, c'est à peine plus compliqué. Dans le cas où le booléen
est VRAI, et après avoir exécuté la série d'instructions 1, au moment où elle arrive au mot
« Sinon », la machine saute directement à la première instruction située après le « Finsi ». De
même, au cas où le booléen a comme valeur « Faux », la machine saute directement à la
première ligne située après le « Sinon » et exécute l’ensemble des « instructions 2 ». Dans
tous les cas, les instructions situées juste après le FinSi seront exécutées normalement.
En fait, la forme simplifiée correspond au cas où l’une des deux « branches » du Si est vide.
Dès lors, plutôt qu’écrire « sinon ne rien faire du tout », il est plus simple de ne rien écrire. Et
laisser un Si... complet, avec une des deux branches vides, est considéré comme une très
grosse maladresse pour un programmeur, même si cela ne constitue pas à proprement parler
une faute.
Exprimé sous forme de pseudo-code, la programmation de notre touriste de tout à l’heure
donnerait donc quelque chose du genre :
Allez tout droit jusqu’au prochain carrefour
Si la rue à droite est autorisée à la circulation Alors
Tournez à droite
Avancez
Prenez la deuxième à gauche
Sinon
Continuez jusqu’à la prochaine rue à droite
Prenez cette rue
Prenez la première à droite
Finsi

3. Qu’est ce qu’une condition ?

Une condition est une comparaison
Cette définition est essentielle ! Elle signifie qu’une condition est composée de trois
éléments :
 une valeur
 un opérateur de comparaison

 une autre valeur

Les valeurs peuvent être a priori de n’importe quel type (numériques, caractères…). Mais si
l’on veut que la comparaison ait un sens, il faut que les deux valeurs de la comparaison soient
du même type !
Les opérateurs de comparaison sont :
 égal à…
 différent de…

 strictement plus petit que…

 strictement plus grand que…
 plus petit ou égal à…
 plus grand ou égal à…

L’ensemble des trois éléments constituant la condition constitue donc, si l’on veut, une
affirmation, qui a un moment donné est VRAIE ou FAUSSE.
A noter que ces opérateurs de comparaison peuvent tout à fait s’employer avec des caractères.
Ceux-ci sont codés par la machine dans l’ordre alphabétique (rappelez vous le code ASCII vu
dans le préambule), les majuscules étant systématiquement placées avant les minuscules.
Ainsi on a :
“t” < “w” VRAI
“Maman” > “Papa“ FAUX
“maman” > “Papa” VRAI
Remarque très importante

En formulant une condition dans un algorithme, il faut se méfier comme de la peste de

certains raccourcis du langage courant, ou de certaines notations valides en mathématiques,
mais qui mènent à des non-sens informatiques. Prenons par exemple la phrase « 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 français, comme en mathématiques, ne veut rien
dire en programmation. En effet, elle comprend deux opérateurs de comparaison, soit un de
trop, et trois valeurs, soit là aussi une de trop. On va voir dans un instant comment traduire
convenablement une telle condition.

Exercice 3.1

Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce nombre est
positif ou négatif (on laisse de côté le cas où le nombre vaut zéro).

Corrigé Exercice 3.1

Variable n en Entier
Début
Ecrire "Entrez un nombre : "
Lire n
Si n > 0 Alors
Ecrire "Ce nombre est positif”
Sinon
Ecrire "Ce nombre est négatif"
Finsi
Fin
Equivalent javascript :

var n=0 ;

n = prompt("Entrez un nombre : ", "") ;

if (n > 0) {

Alert("Ce nombre est positif”) ;

} else {

Alert("Ce nombre est négatif ”) ;

4. Conditions composées
Certains problèmes exigent parfois de formuler des conditions qui ne peuvent pas être
exprimées sous la forme simple exposée 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 supérieur à 5 et Toto est inférieur à 8 ». Il y a donc bien là deux conditions, reliées
par ce qu’on appelle un opérateur logique, le mot ET.
Comme on l’a évoqué plus haut, l’informatique met à notre disposition quatre opérateurs
logiques : ET, OU, NON, et XOR.
 Le ET a le même sens en informatique que dans le langage courant. Pour que
"Condition1 ET Condition2" soit VRAI, il faut impérativement que Condition1 soit
VRAI et que Condition2 soit VRAI. Dans tous les autres cas, "Condition 1 et
Condition2" sera faux.
 Il faut se méfier un peu plus du OU. Pour que "Condition1 OU Condition2" soit
VRAI, il suffit que Condition1 soit VRAIE ou que Condition2 soit VRAIE. Le point
important est que si Condition1 est VRAIE et que Condition2 est VRAIE aussi,
Condition1 OU Condition2 reste VRAIE. Le OU informatique ne veut donc pas dire «
ou bien »
 Le XOR (ou OU exclusif) fonctionne de la manière suivante. Pour que "Condition1
XOR Condition2" soit VRAI, il faut que soit Condition1 soit VRAI, soit que
Condition2 soit VRAI. Si toutes les deux sont fausses, ou que toutes les deux sont
VRAI, alors le résultat global est considéré comme FAUX. Le XOR est donc
l'équivalent du "ou bien" du langage courant.
J’insiste toutefois sur le fait que le XOR est une rareté, dont il n’est pas strictement
indispensable de s’encombrer en programmation.
 Enfin, le NON inverse une condition : NON(Condition1)est VRAI si Condition1 est
FAUX, et il sera FAUX si Condition1 est VRAI. C'est l'équivalent pour les booléens
du signe "moins" que l'on place devant les nombres.
Alors, vous vous demandez peut-être à quoi sert ce NON. Après tout, plutôt qu’écrire
 NON(Prix > 20), il serait plus simple d’écrire tout bonnement Prix=<20. Dans ce cas
précis, c’est évident qu’on se complique inutilement la vie avec le NON. Mais si le
NON n'est jamais indispensable, il y a tout de même des situations dans lesquelles il
s'avère bien utile.

On représente fréquemment tout ceci dans des tables de vérité (C1 et C2 représentent deux
conditions, et on envisage à chaque fois les quatre cas possibles)

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 JOURNÉE...

...Consiste à formuler dans un test une condition qui ne pourra jamais être vraie, ou
jamais être fausse. Si ce n’est pas fait exprès, c’est assez rigolo. Si c’est fait exprès, c’est
encore plus drôle, car une condition dont on sait d’avance qu’elle sera toujours fausse n’est
pas une condition. Dans tous les cas, cela veut dire qu’on a écrit un test qui n’en est pas un, et
qui fonctionne comme s’il n’y en avait pas.
Cela peut être par exemple : Si Toto < 10 ET Toto > 15 Alors… (il est très difficile de trouver
un nombre qui soit à la fois inférieur à 10 et supérieur à 15 !)
Bon, ça, c’est un motif immédiat pour payer une tournée générale, et je sens qu’on ne restera
pas longtemps le gosier sec.

Exercice 3.2

Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si leur produit est
négatif ou positif (on laisse de côté le cas où le produit est nul). Attention toutefois : on ne doit pas
calculer le produit des deux nombres.

Corrigé Exercice 3.2

Variables m, n en Entier
Début
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 négatif"
Finsi
Fin

Equivalent javascript :

var m=0 ;

var n=0 ;

m = prompt("Entrez un nombre : ", "") ;

n = prompt("Entrez un nombre : ", "") ;

if (m > 0 && n > 0) || (m < 0 && n < 0) {

Alert("Leur produit est positif") ;

Exercice 3.3
Ecrire un algorithme qui demande trois noms à l’utilisateur et l’informe ensuite s’ils sont
rangés ou non dans l’ordre alphabétique.

Corrigé Exercice 3.3

Variables a, b, c en Caractère
Début
Ecrire "Entrez successivement trois noms : "
Lire a, b, c
Si a < b ET b < c Alors
Ecrire "Ces noms sont classés alphabétiquement"
Sinon
Ecrire "Ces noms ne sont pas classés"
Finsi
Fin

Equivalent javascript :

var a="" ;
var b="" ;
var c="" ;
a = prompt("Entrez un nom : ", "") ;
b = prompt("Entrez un nom : ", "") ;
c = prompt("Entrez un nom : ", "") ;

if (a < b && b < c ) {

Alert("Ces noms sont classés alphabétiquement ") ;

Else {

Alert("Ces noms ne sont pas classés ") ;

5. Tests imbriqués
Graphiquement, on peut très facilement représenter un SI comme un aiguillage de chemin de
fer (ou un aiguillage de train électrique, c’est moins lourd à porter). Un SI ouvre donc deux
voies, correspondant à deux traitements différents. Mais il y a des tas de situations où deux
voies ne suffisent pas. Par exemple, un programme devant donner l’état de l’eau selon sa
température doit pouvoir choisir entre trois réponses possibles (solide, liquide ou gazeuse).
Une première solution serait la suivante :
Variable Temp en Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
FinSi
Si Temp > 0 Et Temp < 100 Alors
Ecrire "C’est du liquide"
Finsi
Si Temp > 100 Alors
Ecrire "C’est de la vapeur"
Finsi
Fin
Vous constaterez que c’est 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
même chose, la température de l'eau (la valeur de la variable Temp). Il serait ainsi bien plus
rationnel d’imbriquer les tests de cette manière :
Variable Temp en Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
Sinon
Si Temp < 100 Alors
Ecrire "C’est du liquide"
 Sinon
Ecrire "C’est de la vapeur"
Finsi
Finsi
Fin
Nous avons fait des économies : au lieu de devoir taper trois conditions, dont une composée,
nous n’avons plus que deux conditions simples. Mais aussi, et surtout, nous avons fait des
économies sur le temps d’exécution de l’ordinateur. Si la température est inférieure à zéro,
celui-ci écrit dorénavant « C’est de la glace » et passe directement à la fin, sans être ralenti par
l’examen d’autres possibilités (qui sont forcément fausses).
Cette deuxième version n’est donc pas seulement plus simple à écrire et plus lisible, elle est
également plus performante à l’exécution.
Les structures de tests imbriqués sont donc un outil indispensable à la simplification et à
l’optimisation des algorithmes.

Exercice 3.4

Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce nombre est
positif ou négatif (on inclut cette fois le traitement du cas où le nombre vaut zéro).

Corrigé Exercice 3.4

Variable n en Entier
Début
Ecrire "Entrez un nombre : "
Lire n
Si n < 0 Alors
Ecrire "Ce nombre est négatif"
SinonSi n = 0 Alors
Ecrire "Ce nombre est nul"
Sinon
Ecrire "Ce nombre est positif"
Finsi
Fin

Equivalent javascript

var n=0 ;
n = prompt("Entrez un nombre : ", "") ;
if (n < 0) {
alert("Ce nombre est négatif") ;
}
Else if (n == 0) {
alert("Ce nombre est nul") ;

}
Else {
alert("Ce nombre est positif ") ;
}

Exercice 3.5
Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si le
produit est négatif 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 !

Corrigé Exercice 3.5

Variables m, n en Entier
Début
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 négatif"
Finsi
Fin
Si on souhaite simplifier l’écriture de la condition lourde du SinonSi, on peut toujours passer
par des variables booléennes intermédiaires. Une astuce de sioux consiste également à
employer un Xor (c'est l'un des rares cas dans lesquels il est pertinent)

Equivalent javascript

var m=0 ;
var n=0 ;

m = prompt("Entrez un nombre : ", "") ;

n = prompt("Entrez un nombre : ", "") ;

if (m == 0 || n == 0) {
alert("Le produit est nul ") ;
}
Else if ((m < 0 && n < 0) || (m > 0 && n > 0)) {
alert("Le produit est positif ") ;
}
Else {
alert("Le produit est négatif ") ;
}

Exercice 3.6
Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur. Ensuite, il l’informe de sa
catégorie :
 "Poussin" de 6 à 7 ans
 "Pupille" de 8 à 9 ans

 "Minime" de 10 à 11 ans
 "Cadet" après 12 ans

Peut-on concevoir plusieurs algorithmes équivalents menant à ce résultat ?

Corrigé Exercice 3.6

Variable age en Entier

Début
Ecrire "Entrez l’âge de l’enfant : "
Lire age
Si age >= 12 Alors
Ecrire "Catégorie Cadet"
SinonSi age >= 10 Alors
Ecrire "Catégorie Minime"
SinonSi age >= 8 Alors
Ecrire "Catégorie Pupille"
SinonSi age >= 6 Alors
Ecrire "Catégorie Poussin"
Finsi
Fin
On peut évidemment écrire cet algorithme de différentes façons, ne serait-ce qu’en
commençant par la catégorie la plus jeune.

Equivalent javascript

var age=0 ;

age = prompt("Entrez l’âge de l’enfant : ", "") ;

if (age >= 12) {
alert("Catégorie Cadet ") ;
}
Else if (age >= 10) {
alert("Catégorie Minime ") ;
}
Else if (age >= 8) {
alert("Catégorie Pupille ") ;
}
Else if (age >= 6) {
 alert("Catégorie Poussin ") ;
}

6. De l’aiguillage à la gare de tri

« J'ai l'âme ferroviaire : je regarde passer les vaches » (Léo Ferré)
Cette citation n’apporte peut-être pas grand chose à cet exposé, mais je l’aime bien, alors
c’était le moment ou jamais.
En effet, dans un programme, une structure SI peut être facilement comparée à un aiguillage
de train. La voie principale se sépare en deux, le train devant rouler ou sur l’une, ou sur
l’autre, et les deux voies se rejoignant tôt ou tard pour ne plus en former qu’une seule, lors du
FinSi. On peut schématiser cela ainsi :

Mais dans certains cas, ce ne sont pas deux voies qu’il nous faut, mais trois, ou même plus.
Dans le cas de l’état de l’eau, il nous faut trois voies pour notre « train », puisque l’eau peut
être solide, liquide ou gazeuse. Alors, nous n’avons pas eu le choix : pour deux voies, il nous
fallait un aiguillage, pour trois voies il nous en faut deux, imbriqués l’un dans l’autre.
Cette structure (telle que nous l’avons programmée à la page précédente) devrait être
schématisée comme suit :

Soyons bien clairs : cette structure est la seule possible du point de vue logique (même si on
peut toujours mettre le bas en haut et le haut en bas). Mais du point de vue de l’écriture, le
pseudo-code algorithmique admet une simplification supplémentaire. Ainsi, il est possible
(mais non obligatoire, que l’algorithme initial :
Variable Temp en Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C'est de la glace"
Sinon
Si Temp < 100 Alors
 Ecrire "C’est du liquide"
Sinon
Ecrire "C’est de la vapeur"
Finsi
Finsi
Fin
devienne :
Variable Temp en Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
SinonSi Temp < 100 Alors
Ecrire "C’est du liquide"
Sinon
Ecrire "C’est de la vapeur"
Finsi
Fin
Dans le cas de tests imbriqués, le Sinon et le Si peuvent être fusionnés en un SinonSi. On
considère alors qu’il s’agit d’un seul bloc de test, conclu par un seul FinSi
Le SinonSi permet en quelque sorte de créer (en réalité, de simuler) des aiguillages à plus de
deux branches. On peut ainsi enchaîner les SinonSi les uns derrière les autres pour simuler un
aiguillage à autant de branches que l’on souhaite.

7. Variables Booléennes
Jusqu’ici, pour écrire nos des tests, nous avons utilisé uniquement des conditions. Mais vous
vous rappelez qu’il existe un type de variables (les booléennes) 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 l’exemple de l’eau. On pourrait le réécrire ainsi :
Variable Temp en Entier
Variables A, B en Booléen
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
A ← Temp =< 0
B ← Temp < 100
Si A Alors
Ecrire "C’est de la glace"
SinonSi B Alors
Ecrire "C’est du liquide"
Sinon
Ecrire "C’est de la vapeur"
Finsi
Fin
A priori, cette technique ne présente guère d’intérêt : on a alourdi plutôt qu’allégé
l’algorithme de départ, en ayant recours à deux variables supplémentaires.
 Mais souvenons-nous : une variable booléenne n’a besoin que d’un seul bit pour être
stockée. De ce point de vue, l’alourdissement n’est donc pas considérable.
 dans certains cas, notamment celui de conditions composées très lourdes (avec plein
de ET et de OU tout partout) cette technique peut faciliter le travail du programmeur,
en améliorant nettement la lisibilité de l’algorithme. Les variables booléennes peuvent
également s’avérer très utiles pour servir de flag, technique dont on reparlera plus loin
(rassurez-vous, rien à voir avec le flagrant délit des policiers).
Partie 4
Encore de la Logique
« La programmation peut être un plaisir ; de même 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 composées, les parenthèses jouent
un rôle fondamental.
Variables A, B, C, D, E en Booléen
Variable X en Entier
Début
Lire X
A ← X > 12
B←X>2
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.
S’il n’y a dans une condition que des ET, ou que des OU, en revanche, les parenthèses ne
changent strictement rien.
Dans une condition composée employant à la fois des opérateurs ET et des opérateurs OU, la
présence de parenthèses possède une influence sur le résultat, tout comme dans le cas d’une
expression numérique comportant des multiplications et des additions.
On en arrive à une autre propriété des ET et des OU, bien plus intéressante.
Spontanément, on pense souvent que ET et OU s’excluent mutuellement, au sens où un
problème donné s’exprime soit avec un ET, soit avec un OU. Pourtant, ce n’est pas si évident.
Quand faut-il ouvrir la fenêtre de la salle ? Uniquement si les conditions l’imposent, à savoir :
Si il fait trop chaud ET il ne pleut pas Alors
Ouvrir la fenêtre
Sinon
Fermer la fenêtre
Finsi
Cette petite règle pourrait tout aussi bien être formulée comme suit :
Si il ne fait pas trop chaud OU il pleut Alors
Fermer la fenêtre
Sinon
Ouvrir la fenêtre
Finsi
Ces deux formulations sont strictement équivalentes. Ce qui nous amène à la conclusion
suivante :
Toute structure de test requérant une condition composée faisant intervenir l’opérateur ET
peut être exprimée de manière équivalente avec un opérateur OU, et réciproquement.
Ceci est moins surprenant qu’il n’y paraît au premier abord. Jetez pour vous en convaincre un
œil sur les tables de vérité, et vous noterez la symétrie entre celle du ET et celle du OU. Dans
les deux tables, il y a trois cas sur quatre qui mènent à un résultat, et un sur quatre qui mène
au résultat inverse. Alors, rien d’étonnant à ce qu’une situation qui s’exprime avec une des
tables (un des opérateurs logiques) puisse tout aussi bien être exprimée avec l’autre table
(l’autre opérateur logique). Toute l’astuce consiste à savoir effectuer correctement ce passage.
Bien sûr, on ne peut pas se contenter de remplacer purement et simplement les ET par des
OU ; ce serait un peu facile. La règle d’équivalence est la suivante (on peut la vérifier sur
l’exemple de la fenêtre) :
Si A ET B Alors
Instructions 1
Sinon
Instructions 2
Finsi

équivaut à :

Si NON A OU NON B Alors

Instructions 2
Sinon
Instructions 1
Finsi

Cette règle porte le nom de transformation de Morgan, du nom du mathématicien anglais qui
l'a formulée.

Exercice 4.1
Formulez un algorithme équivalent à l’algorithme suivant :
Si Tutu > Toto + 4 OU Tata = "OK" Alors
Tutu ← Tutu + 1
Sinon
Tutu ← Tutu – 1
Finsi

Corrigé Exercice 4.1

Aucune difficulté, il suffit d’appliquer la règle 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

Equivalent javascript :

if ((Tutu <= Toto + 4) && (Tata <> "OK")) {

Tutu = Tutu - 1 ;
}
Else {
Tutu = Tutu + 1 ;
}
Exercice 4.2

Cet algorithme est destiné à prédire l'avenir, et il doit être infaillible !

Il lira au clavier l’heure et les minutes, et il affichera l’heure qu’il sera une minute plus tard.
Par exemple, si l'utilisateur tape 21 puis 32, l'algorithme doit répondre :
"Dans une minute, il sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de la vérifier.

Corrigé Exercice 4.2

Variables h, m en Numérique
Début
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

Equivalent javascript :

var h=0 ;
var m=0 ;

h = prompt("Entrez les heures : ", "") ;

m = prompt("Entrez les minutes: ", "") ;

m=m+1;
if (m == 60) {
m = 0;
h = h + 1;
}
if (h == 24) {
h = 0;
}
Alert("Dans une minute il sera "+ h + "heure(s) " + m + "minute(s)");

Exercice 4.3
De même que le précédent, cet algorithme doit demander une heure et en afficher une autre.
Mais cette fois, il doit gérer é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 répondre : "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.

Corrigé Exercice 4.3

Variables h, m, s en Numérique
Début
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, "h", m, "m et ", s, "s"
Fin

Equivalent javascript :

var h=0 ;
var m=0 ;
var s=0 ;

h = prompt("Entrez les heures : ", "") ;

m = prompt("Entrez les minutes: ", "") ;
s = prompt("Entrez les minutes: ", "") ;

s=s+1;
if (s == 60) {
s = 0;
m = m + 1;
}
if (m == 60) {
m = 0;
h = h + 1;
}
if (h == 24) {
h = 0;
}
Alert("Dans une seconde il sera "+ h+ "h"+ m+ "m et "+ s+ "s");

Exercice 4.4

Un magasin de reprographie facture 0,10 E les dix premières photocopies, 0,09 E les vingt
suivantes et 0,08 E au-delà. Ecrivez un algorithme qui demande à l’utilisateur le nombre de
photocopies effectuées et qui affiche la facture correspondante.

Corrigé Exercice 4.4

Variables n, p en Numérique
Début
Ecrire "Nombre de photocopies : "
Lire n
Si n <= 10 Alors
p ← n * 0,1
SinonSi n <= 30 Alors
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

Equivalent javascript :

var n=0 ;
var p=0 ;

n = prompt("Nombre de photocopies: ", "") ;

if (n <= 10) {
p = n *0.1;
}
Else if (n <=30) {
p = 10 * 0,1 + (n – 10) * 0,09;
}
Else {
p = 10 * 0,1 + 20 * 0,09 + (n – 30) * 0,08
}
Alert("Le prix total est: "+ p) ;

Exercice 4.5

Les habitants de Zorglub paient l’impôt selon les règles suivantes :

 les hommes de plus de 20 ans paient l’impôt
 les femmes paient l’impôt si elles ont entre 18 et 35 ans
  les autres ne paient pas d’impôt

Le programme demandera donc l’âge et le sexe du Zorglubien, et se prononcera donc ensuite

sur le fait que l’habitant est imposable.

Corrigé Exercice 4.5

Variable sex en Caractère

Variable age en Numérique
Variables C1, C2 en Booléen
Début
Ecrire "Entrez le sexe (M/F) : "
Lire sex
Ecrire "Entrez l’âge: "
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

Equivalent javascript :

var sex="" ;
var age=0 ;

sex = prompt("Entrez le sexe (M/F): ", "") ;

age = prompt("Entrez l’âge :", "") ;

if ((sex = "M" && age > 20) || (sex = "F" && (age > 18 && age < 35))) {
alert("Imposable");
}
Else {
alert("Non Imposable");
}

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

Ce titre un peu provocateur (mais néanmoins justifié) a pour but d’attirer maintenant votre
attention sur un fait fondamental en algorithmique, fait que plusieurs remarques précédentes
ont déjà dû vous faire soupçonner : il n’y a jamais une seule manière juste de traiter les
structures alternatives. Et plus généralement, il n’y a jamais une seule manière juste de traiter
un problème. Entre les différentes possibilités, qui ne sont parfois pas meilleures les unes que
les autres, le choix est une affaire de style.
C’est pour cela qu’avec l’habitude, on reconnaît le style d’un programmeur aussi sûrement
que s’il s’agissait de style littéraire.
Reprenons nos opérateurs de comparaison maintenant familiers, le ET et le OU. En fait, on
s’aperçoit que l’on pourrait tout à fait s’en passer ! Par exemple, pour reprendre l’exemple de
la fenêtre de la salle :
Si il fait trop chaud ET il ne pleut pas Alors
Ouvrir la fenêtre
Sinon
Fermer la fenêtre
Finsi
Possède un parfait équivalent algorithmique sous la forme de :
Si il fait trop chaud Alors
Si il ne pleut pas Alors
Ouvrir la fenêtre
Sinon
Fermer la fenêtre
Finsi
Sinon
Fermer la fenêtre
Finsi
Dans cette dernière formulation, nous n’avons plus recours à une condition composée (mais
au prix d’un test imbriqué supplémentaire)
Et comme tout ce qui s’exprime par un ET peut aussi être exprimé par un OU, nous en
concluons que le OU peut également être remplacé par un test imbriqué supplémentaire. On
peut ainsi poser cette règle stylistique générale :
Dans une structure alternative complexe, les conditions composées, l’imbrication des
structures de tests et l’emploi des variables booléennes ouvrent la possibilité de choix
stylistiques différents. L’alourdissement des conditions allège les structures de tests et le
nombre des booléens nécessaires ; l’emploi de booléens supplémentaires permet d’alléger les
conditions et les structures de tests, et ainsi de suite.

Exercice 4.6
Les élections législatives, en Guignolerie Septentrionale, obéissent à la règle suivante :
 lorsque l'un des candidats obtient plus de 50% des suffrages, il est élu dès le premier
tour.
 en cas de deuxième 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 numéro 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 tête à l'issue du premier tour) ou défavorable (il participe au second tour sans avoir
été en tête au premier tour).

Corrigé Exercice 4.6

Cet exercice, du pur point de vue algorithmique, n'est pas très méchant. En revanche, il
représente dignement la catégorie des énoncés piégés.
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 deuxième tour, sinon il est éliminé. Hé hé hé... mais il ne faut pas
oublier que le candidat peut très bien avoir eu 20 % mais être tout de même éliminé, tout
simplement parce que l'un des autres a fait plus de 50 % et donc qu'il n'y a pas de deuxième
tour !...
Moralité : ne jamais se jeter sur la programmation avant d'avoir soigneusement mené l'analyse
du problème à traiter.
Variables A, B, C, D en Numérique
Début
Ecrire "Entrez les scores des quatre prétendants :"
Lire A, B, C, D
C1 ← A > 50
C2 ← B > 50 ou C > 50 ou D > 50
C3 ← A >= B et A >= C 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 défavorable"
FinSi
Fin

Equivalent javascript :

var A=0 ;
var B=0 ;
var C=0 ;
var D=0 ;

A = prompt("Entrez le score de A ", "") ;

B = prompt("Entrez le score de B ", "") ;
C = prompt("Entrez le score de C ", "") ;
D = prompt("Entrez le score de D ", "") ;

if (A > 50){
alert("Elu au premier tour ");
}
Else if ((B > 50 || C > 50 || D > 50) || !(A >= 12,5)) {
alert("Battu, éliminé, sorti !!!”);
}
Else if (A >= B && A >= C && A >= D) {
alert("Ballotage favorable ”);
}
Else {
alert("Ballotage défavorable ”);
}
Exercice 4.7
Une compagnie d'assurance automobile propose à ses clients quatre familles de tarifs
identifiables par une couleur, du moins au plus onéreux : tarifs bleu, vert, orange et rouge. Le
tarif dépend 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 bénéficie
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 fidélité des clients acceptés, la compagnie propose un
contrat de la couleur immédiatement la plus avantageuse s'il est entré dans la maison
depuis plus d'un an.

Ecrire l'algorithme permettant de saisir les données nécessaires (sans contrôle de saisie) et de
traiter ce problème. Avant de se lancer à corps perdu dans cet exercice, on pourra réfléchir un
peu et s'apercevoir qu'il est plus simple qu'il n'en a l'air (cela s'appelle faire une analyse !)

Corrigé Exercice 4.7

Là encore, on illustre l'utilité d'une bonne analyse. Je propose deux corrigés différents. Le
premier suit l'énoncé pas à pas. C'est juste, mais c'est vraiment lourd. La deuxième version
s'appuie sur une vraie compréhension d'une situation pas si embrouillée qu'elle n'en a l'air.
Dans les deux cas, un recours aux variables booléennes aère sérieusement l'écriture.
Donc, premier corrigé, on suit le texte de l'énoncé pas à pas :
Variables age, perm, acc, assur en Numérique
Variables C1, C2, C3 en Booléen
Variable situ en Caractère
Début
Ecrire "Entrez l’âge: "
Lire age
Ecrire "Entrez le nombre d'années de permis: "
Lire perm
Ecrire "Entrez le nombre d'accidents: "
Lire acc
Ecrire "Entrez le nombre d'années 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
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"
SinonSi acc = 1 Alors
situ ← "Orange"
SinonSi acc = 2 Alors
situ ← "Rouge"
Sinon
situ ← "Refusé"
FinSi
FinSi
Si C3 Alors
Si situ = "Rouge" Alors
situ ← "Orange"
SinonSi situ = "Orange" Alors
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 très
simple : un système à points. Et il suffit de comptabiliser les points pour que tout s'éclaire...
Reprenons juste après l'affectation des trois variables booléennes C1, C2, et C3. On écrit :
P←0
Si Non(C1) Alors
P←P+1
FinSi
Si Non(C2) Alors
P←P+1
FinSi
P ← P + acc
Si P < 3 et C3 Alors
P←P-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
Cool, non ?

Exercice 4.8

Ecrivez un algorithme qui a près avoir demandé un numéro de jour, de mois et d'année à
l'utilisateur, renvoie s'il s'agit ou non d'une date valide.
Cet exercice est certes d’un manque d’originalité affligeant, mais après tout, en algorithmique
comme ailleurs, il faut connaître ses classiques ! Et quand on a fait cela une fois dans sa vie,
on apprécie pleinement l’existence d’un type numérique « date » dans certains langages…).
Il n'est sans doute pas inutile de rappeler rapidement que le mois de février compte 28 jours,
sauf si l’année est bissextile, auquel cas il en compte 29. L’année est bissextile si elle est
divisible par quatre. Toutefois, les années divisibles par 100 ne sont pas bissextiles, mais les
années divisibles par 400 le sont. Ouf !
Un dernier petit détail : vous ne savez pas, pour l’instant, exprimer correctement en pseudo-
code l’idée qu’un nombre A est divisible par un nombre B. Aussi, vous vous contenterez
d’écrire en bons télégraphistes que A divisible par B se dit « A dp B ».

Exercice 4.8

En ce qui concerne le début de cet algorithme, il n’y a aucune difficulté. C’est de la saisie bête
et même pas méchante:
Variables J, M, A, JMax en Numérique
Variables VJ, VM, B en Booleen
Début
Ecrire "Entrez le numéro du jour"
Lire J
Ecrire "Entrez le numéro du mois"
Lire M
Ecrire "Entrez l'année"
Lire A
C'est évidemment ensuite que les ennuis commencent… La première manière d'aborder la
chose consiste à se dire que fondamentalement, la structure logique de ce problème est très
simple. Si nous créons deux variables booléennes VJ et VM, représentant respectivement la
validité du jour et du mois entrés, la fin de l'algorithme sera d'une simplicité biblique (l’année
est valide par définition, si on évacue le débat byzantin concernant l’existence de l’année
zéro) :
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 composées. Mais franchement, écrire ces
conditions en une seule fois est un travail de bénédictin sans grand intérêt. Pour éviter d'en
arriver à une telle extrémité, on peut sérier la difficulté en créant deux variables
supplémentaires :

B : variable booléenne qui indique s'il s'agit d'une année bissextile

JMax : variable numérique 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 booléennes, puis on traite les années, 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 mérite de ne pas trop compliquer la structure des tests, et notamment de ne
pas répéter l'écriture finale à l'écran. Les variables booléennes intermédiaires nous épargnent
des conditions composées trop lourdes, mais celles-ci restent néanmoins sérieuses.

Une approche différente consisterait à limiter les conditions composées, quitte à le payer par
une structure beaucoup plus exigeante de tests imbriqués. Là encore, on évite de jouer les
extrémistes et l'on s'autorise quelques conditions composées lorsque cela nous simplifie
l'existence. On pourrait aussi dire que la solution précédente "part de la fin" du problème (la
date est elle valide ou non ?), alors que celle qui suit "part du début" (quelles sont les données
entrées 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
Ecrire "Date Invalide"
Sinon
Ecrire "Date Valide"
 FinSi
SinonSi A dp 100 Alors
Si J < 1 ou J > 28 Alors
Ecrire "Date Invalide"
Sinon
Ecrire "Date Valide"
FinSi
SinonSi A dp 4 Alors
Si J < 1 ou J > 28 Alors
Ecrire "Date Invalide"
Sinon
Ecrire "Date Valide"
FinSi
Sinon
Si J < 1 ou J > 28 Alors
Ecrire "Date Invalide"
Sinon
Ecrire "Date Valide"
FinSi
FinSi
SinonSi M = 4 ou M = 6 ou M = 9 ou M = 11 Alors
Si J < 1 ou J > 30 Alors
Ecrire "Date Invalide"
Sinon
Ecrire "Date Valide"
FinSi
Sinon
Si J < 1 ou J > 31 Alors
Ecrire "Date Invalide"
Sinon
Ecrire "Date Valide"
FinSi
FinSi
On voit que dans ce cas, l'alternative finale (Date valide ou invalide) se trouve répétée 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 préférer assez nettement la première solution, qui fait ressortir
beaucoup plus clairement la structure logique du problème (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 très simple et élégante, un peu plus difficile peut-être à
imaginer du premier coup, mais qui avec le recul apparaît comme très immédiate. 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 février d'une année bissextile, et celui d'un jour
de février 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
K4 ← 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 réglé avec quelques variables booléennes et quelques conditions composées, en
un minimum de lignes de code.
La morale de ce long exercice - et non moins long corrigé, c'est qu'un problème de test un peu
compliqué admet une pléiade de solutions justes...
...Mais que certaines sont plus astucieuses que d'autres !

Si vous avez compris ce qui précède, et que l'exercice de la date ne vous pose plus aucun
problème, 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 démagogie !
Malheureusement, nous ne sommes pas tout à fait au bout de nos peines ; il reste une dernière
structure logique à examiner, et pas des moindres…
Partie 5
Les Boucles
« Les premiers 90% du code prennent les premiers 90% du temps de développement. Les 10%
restants prennent les autres 90% du temps de développement » - Tom Cargill

Et ça y est, on y est, on est arrivés, la voilà, c’est Broadway, la quatrième et dernière

structure : ça est les boucles. Si vous voulez épater vos amis, vous pouvez également parler de
structures répétitives, voire carrément de structures itératives. Ca calme, hein ? Bon, vous
faites ce que vous voulez, ici on est entre nous, on parlera de boucles.
Les boucles, c'est généralement 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'acquérir les réflexes qui permettent de les élaborer judicieusement
pour traiter un problème donné.
On peut dire en fait que les boucles constituent la seule vraie structure logique caractéristique
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 différencie certes pas l'homme de la bête (il ne faut tout de
même pas exagérer), est tout de même ce qui sépare en informatique le programmeur de
l'utilisateur, même averti.
Alors, à vos futures – et inévitables - difficultés sur le sujet, il y a trois remèdes : de la rigueur,
de la patience, et encore de la rigueur !

1. A quoi cela sert-il donc ?

Prenons le cas d’une saisie au clavier (une lecture), où par exemple, le programme pose une
question à laquelle l’utilisateur doit répondre par O (Oui) ou N (Non). Mais tôt ou tard,
l’utilisateur, facétieux ou maladroit, risque de taper autre chose que la réponse attendue. Dès
lors, le programme peut planter soit par une erreur d’exécution (parce que le type de réponse
ne correspond pas au type de la variable attendu) soit par une erreur fonctionnelle (il se
déroule normalement jusqu’au bout, mais en produisant des résultats fantaisistes).
Alors, dans tout programme un tant soit peu sérieux, on met en place ce qu’on appelle un
contrôle de saisie, afin de vérifier que les données entrées au clavier correspondent bien à
celles attendues par l’algorithme.
A vue de nez, on pourrait essayer avec un SI. Voyons voir ce que ça donne :
Variable Rep en Caractère
Début
Ecrire "Voulez vous un café ? (O/N)"
Lire Rep
Si Rep <> "O" et Rep <> "N" Alors
Ecrire "Saisie erronnée. Recommencez"
Lire Rep
FinSi
Fin
C’est impeccable. Du moins tant que l’utilisateur a le bon goût de ne se tromper qu’une seule
fois, et d’entrer une valeur correcte à la deuxième demande. Si l’on veut également bétonner
en cas de deuxième erreur, il faudrait rajouter un SI. Et ainsi de suite, on peut rajouter des
centaines de SI, et écrire un algorithme aussi lourd qu’une blague des Grosses Têtes, on n’en
sortira pas, il y aura toujours moyen qu’un 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 présente ainsi :
TantQue booléen
…
Instructions
…
FinTantQue
Le principe est simple : le programme arrive sur la ligne du TantQue. Il examine alors la
valeur du booléen (qui, je le rappelle, peut être une variable booléenne ou, plus fréquemment,
une condition). Si cette valeur est VRAI, le programme exécute les instructions qui suivent,
jusqu’à ce qu’il rencontre la ligne FinTantQue. Il retourne ensuite sur la ligne du TantQue,
procède au même examen, et ainsi de suite. Le manège enchanté ne s’arrête que lorsque le
booléen prend la valeur FAUX.
Illustration avec notre problème de contrôle de saisie. Une première approximation de la
solution consiste à écrire :
Variable Rep en Caractère
Début
Ecrire "Voulez vous un café ? (O/N)"
TantQue Rep <> "O" et Rep <> "N"
Lire Rep
FinTantQue
Fin
Là, on a le squelette de l’algorithme correct. Mais de même qu’un squelette ne suffit pas pour
avoir un être vivant viable, il va nous falloir ajouter quelques muscles et organes sur cet
algorithme pour qu’il fonctionne correctement.
Son principal défaut est de provoquer une erreur à chaque exécution. En effet, l’expression
booléenne qui figure après le TantQue interroge la valeur de la variable Rep.
Malheureusement, cette variable, si elle a été déclarée, n’a pas été affectée avant l’entrée dans
la boucle. On teste donc une variable qui n’a pas de valeur, ce qui provoque une erreur et
l’arrêt immédiat de l’exécution. Pour éviter ceci, on n’a pas le choix : il faut que la variable
Rep ait déjà été affectée avant qu’on en arrive au premier tour de boucle. Pour cela, on peut
faire une première lecture de Rep avant la boucle. Dans ce cas, celle-ci ne servira qu’en cas de
mauvaise saisie lors de cette première lecture. L’algorithme devient alors :
Variable Rep en Caractère
Début
Ecrire "Voulez vous un café ? (O/N)"
Lire Rep
TantQue Rep <> "O" et Rep <> "N"
Lire Rep
FinTantQue
Fin
Une autre possibilité, fréquemment employée, consiste à ne pas lire, mais à affecter
arbitrairement la variable avant la boucle. Arbitrairement ? Pas tout à fait, puisque cette
affectation doit avoir pour résultat de provoquer l’entrée obligatoire dans la boucle.
L’affectation doit donc faire en sorte que le booléen soit mis à VRAI pour déclencher le
premier tour de la boucle. Dans notre exemple, on peut donc affecter Rep avec n’importe
quelle valeur, hormis « O » et « N » : car dans ce cas, l’exécution sauterait la boucle, et Rep
ne serait pas du tout lue au clavier. Cela donnera par exemple :
Variable Rep en Caractère
Début
Rep ← "X"
Ecrire "Voulez vous un café ? (O/N)"
TantQue Rep <> "O" et Rep <> "N"
Lire Rep
FinTantQue
Fin
Cette manière de procéder est à connaître, car elle est employée très fréquemment.
Il faut remarquer que les deux solutions (lecture initiale de Rep en dehors de la boucle ou
affectation de Rep) rendent toutes deux l’algorithme satisfaisant, mais présentent une
différence assez importante dans leur structure logique.
En effet, si l’on choisit d’effectuer une lecture préalable de Rep, la boucle ultérieure sera
exécutée uniquement dans l’hypothèse d’une mauvaise saisie initiale. Si l’utilisateur saisit une
valeur correcte à la première demande de Rep, l’algorithme passera sur la boucle sans entrer
dedans.
En revanche, avec la deuxième solution (celle d’une affectation préalable de Rep), l’entrée de
la boucle est forcée, et l’exécution de celle-ci, au moins une fois, est rendue obligatoire à
chaque exécution du programme. Du point de vue de l’utilisateur, cette différence est tout à
fait mineure ; et à la limite, il ne la remarquera même pas. Mais du point de vue du
programmeur, il importe de bien comprendre que les cheminements des instructions ne seront
pas les mêmes dans un cas et dans l’autre.
Pour terminer, remarquons que nous pourrions peaufiner nos solutions en ajoutant des
affichages de libellés qui font encore un peu défaut. Ainsi, si l’on est un programmeur zélé, la
première solution (celle qui inclut deux lectures de Rep, une en dehors de la boucle, l’autre à
l’intérieur) pourrait devenir :
Variable Rep en Caractère
Début
Ecrire "Voulez vous un café ? (O/N)"
Lire Rep
TantQue Rep <> "O" et Rep <> "N"
Ecrire "Vous devez répondre par O ou N. Recommencez"
Lire Rep
FinTantQue
Ecrire "Saisie acceptée"
Fin
Quant à la deuxième solution, elle pourra devenir :
Variable Rep en Caractère
Début
Rep ← "X"
Ecrire "Voulez vous un café ? (O/N)"
TantQue Rep <> "O" et Rep <> "N"
Lire Rep
Si Rep <> "O" et Rep <> "N" Alors
Ecrire "Saisie Erronée, Recommencez"
FinSi
FinTantQue
Fin
Le Gag De La Journée
C’est d’écrire une structure TantQue dans laquelle le booléen n’est jamais VRAI. Le
programme ne rentre alors jamais dans la superbe boucle sur laquelle vous avez tant sué !
Mais la faute symétrique est au moins aussi désopilante.
Elle consiste à écrire une boucle dans laquelle le booléen ne devient jamais FAUX.
L’ordinateur tourne alors dans la boucle comme un dératé et n’en sort plus. Seule solution,
quitter le programme avec un démonte-pneu ou un bâton de dynamite. La « boucle infinie »
est une des hantises les plus redoutées des programmeurs. C’est un peu comme le verre
baveur, le poil à gratter ou le bleu de méthylène : c’est éculé, mais ça fait toujours rire.
Cette faute de programmation grossière – mais fréquente - ne manquera pas d’égayer
l’ambiance collective de cette formation… et accessoirement d’étancher la soif proverbiale de
vos enseignants.
Bon, eh bien vous allez pouvoir faire de chouettes algorithmes, déjà rien qu’avec ça…

Exercice 5.1
Ecrire un algorithme qui demande à l’utilisateur un nombre compris entre 1 et 3 jusqu’à ce
que la réponse convienne.

Corrigé 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 erronée. Recommencez”
FinSi
FinTantQue
Fin

Equivalent javascript :

var n = 0 ;

while (n != 2) {
n = prompt("Entrez un nombre entre 1 et 3") ;
if (n <1 || n > 3) {
Alert("Saisie erronée. Recommencez”) ;
}
}

Exercice 5.2
Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la
réponse convienne. En cas de réponse supérieure à 20, on fera apparaître un message : « Plus
petit ! », et inversement, « Plus grand ! » si le nombre est inférieur à 10.
Corrigé 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

Equivalent javascript :

var n = 0 ;
var reponse = 1 ;
while (reponse != 0) {
n = prompt("Entrez un nombre entre 10 et 20") ;
if (n <10) {
Alert("Plus grand”) ;
}
Else if (n > 20) {
Alert("Plus petit !”) ;
}
Else {
reponse= 0 ;
}
}

Exercice 5.3

Ecrire un algorithme qui demande un nombre de départ, 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.

Corrigé Exercice 5.3

Variables N, i en Entier
Debut
Ecrire "Entrez un nombre : "
Lire N
Ecrire "Les 10 nombres suivants sont : "
Pour i ← N + 1 à N + 10
Ecrire i
i Suivant
Fin

Equivalent javascript :

var N = 0 ;

N = prompt("Entrez un nombre :") ;

Alert("Les 10 nombres suivants sont : ") ;

for (var i=N ;i<N+10 ;i++) {

alert(i) ;
}

2. Boucler en comptant, ou compter en bouclant

Dans le dernier exercice, vous avez remarqué qu’une boucle pouvait être utilisée pour
augmenter la valeur d’une variable. Cette utilisation des boucles est très fréquente, et dans ce
cas, il arrive très souvent qu’on ait besoin d’effectuer un nombre déterminé de passages. Or,
a priori, notre structure TantQue ne sait pas à l’avance combien de tours de boucle elle va
effectuer (puisque le nombre de tours dépend de la valeur d’un booléen).
C’est pourquoi une autre structure de boucle est à notre disposition :
Variable Truc en Entier
Début
Truc ← 0
TantQue Truc < 15
Truc ← Truc + 1
Ecrire "Passage numéro : ", Truc
FinTantQue
Fin
Equivaut à :
Variable Truc en Entier
Début
Pour Truc ← 1 à 15
Ecrire "Passage numéro : ", Truc
Truc Suivant
Fin
Insistons : la structure « Pour … Suivant » n’est pas du tout indispensable ; on pourrait fort
bien programmer toutes les situations de boucle uniquement avec un « Tant Que ». Le seul
intérêt du « Pour » est d’épargner un peu de fatigue au programmeur, en lui évitant de gérer
lui-même la progression de la variable qui lui sert de compteur (on parle d’incrémentation,
encore un mot qui fera forte impression sur votre entourage).
Dit d’une autre manière, la structure « Pour … Suivant » est un cas particulier de TantQue :
celui où le programmeur peut dénombrer à l’avance le nombre de tours de boucles
nécessaires.
Il faut noter que dans une structure « Pour … Suivant », la progression du compteur est
laissée à votre libre disposition. Dans la plupart des cas, on a besoin d’une variable qui
augmente de 1 à chaque tour de boucle. On ne précise alors rien à l’instruction « Pour » ;
celle-ci, par défaut, comprend qu’il va falloir procéder à cette incrémentation de 1 à chaque
passage, en commençant par la première valeur et en terminant par la deuxième.
Mais si vous souhaitez une progression plus spéciale, de 2 en 2, ou de 3 en 3, ou en arrière, de
–1 en –1, ou de –10 en –10, ce n’est pas un problème : il suffira de le préciser à votre
instruction « Pour » en lui rajoutant le mot « Pas » et la valeur de ce pas (Le « pas » dont nous
parlons, c’est le « pas » du marcheur, « step » en anglais).
Naturellement, quand on stipule un pas négatif dans une boucle, la valeur initiale du compteur
doit être supérieure à sa valeur finale si l’on 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 générale d’une structure « Pour ». Sa
syntaxe générale est :
Pour Compteur ← Initial à Final Pas ValeurDuPas
…
Instructions
…
Compteur suivant
Les structures TantQue sont employées dans les situations où l’on doit procéder à un
traitement systématique sur les éléments d’un ensemble dont on ne connaît pas d’avance la
quantité, comme par exemple :
 le contrôle d’une saisie
 la gestion des tours d’un jeu (tant que la partie n’est pas finie, on recommence)

 la lecture des enregistrements d’un fichier de taille inconnue(cf. Partie 9)

Les structures Pour sont employées dans les situations où l’on doit procéder à un traitement
systématique sur les éléments d’un ensemble dont le programmeur connaît d’avance la
quantité.
Nous verrons dans les chapitres suivants des séries d’éléments appelés tableaux (parties 7 et
8) et chaînes de caractères (partie 9). Selon les cas, le balayage systématique des éléments de
ces séries pourra être effectué par un Pour ou par un TantQue : tout dépend si la quantité
d’éléments à balayer (donc le nombre de tours de boucles nécessaires) peut être dénombrée à
l’avance par le programmeur ou non.

3. Des boucles dans des boucles

(« tout est dans tout... et réciproquement »)
On rigole, on rigole !
De même que les poupées russes contiennent d’autres poupées russes, de même qu’une
structure SI … ALORS peut contenir d’autres structures SI … ALORS, une boucle peut tout à
fait contenir d’autres boucles. Y a pas de raison.
Variables Truc, Trac en Entier
Début
Pour Truc ← 1 à 15
Ecrire "Il est passé par ici"
Pour Trac ← 1 à 6
Ecrire "Il repassera par là"
Trac Suivant
Truc Suivant
Fin
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 deuxième boucle (celle du milieu), donc 90 écritures à l’écran du message « il
repassera par là ». Notez la différence marquante avec cette structure :
Variables Truc, Trac en Entier
Début
Pour Truc ← 1 à 15
Ecrire "Il est passé par ici"
Truc Suivant
Pour Trac ← 1 à 6
Ecrire "Il repassera par là"
Trac Suivant
Fin
Ici, il y aura quinze écritures consécutives de "il est passé par ici", puis six écritures
consécutives de "il repassera par là", et ce sera tout.
Des boucles peuvent donc être imbriquées (cas n°1) ou successives (cas n°2). Cependant,
elles ne peuvent jamais, au grand jamais, être croisées. Cela n’aurait aucun sens logique, et de
plus, bien peu de langages vous autoriseraient ne serait-ce qu’à écrire cette structure
aberrante.
Variables Truc, Trac en Entier
Pour Truc ← …
instructions
Pour Trac ← …
instructions
Truc Suivant
instructions
Trac Suivant
Pourquoi imbriquer des boucles ? Pour la même raison qu’on imbrique des tests. La
traduction en bon français d’un test, c’est un « cas ». Eh bien un « cas » (par exemple, « est-ce
un homme ou une femme ? ») peut très bien se subdiviser en d’autres cas (« a-t-il plus ou
moins de 18 ans ? »).
De même, une boucle, c’est un traitement systématique, un examen d’une série d’éléments un
par un (par exemple, « prenons tous les employés de l’entreprise un par un »). Eh bien, on
peut imaginer que pour chaque élément ainsi considéré (pour chaque employé), on doive
procéder à un examen systématique d’autre chose (« prenons chacune des commandes que cet
employé a traitées »). Voilà un exemple typique de boucles imbriquées : on devra
programmer une boucle principale (celle qui prend les employés un par un) et à l’intérieur,
une boucle secondaire (celle qui prend les commandes de cet employé une par une).
Dans la pratique de la programmation, la maîtrise des boucles imbriquées est nécessaire,
même si elle n’est pas suffisante. Tout le contraire d’Alain Delon, en quelque sorte.

4. Et encore une bêtise à ne pas faire !

Examinons l’algorithme suivant :
Variable Truc en Entier
Début
Pour Truc ← 1 à 15
Truc ← Truc * 2
Ecrire "Passage numéro : ", Truc
Truc Suivant
Fin
Vous remarquerez que nous faisons ici gérer « en double » la variable Truc, ces deux gestions
étant contradictoires. D’une part, la ligne
Pour…
augmente la valeur de Truc de 1 à chaque passage. D’autre part la ligne
Truc ← Truc * 2
double la valeur de Truc à chaque passage. Il va sans dire que de telles manipulations
perturbent complètement le déroulement normal de la boucle, et sont causes, sinon de
plantages, tout au moins d’exécutions erratiques.
Le Gag De La Journée
Il consiste donc à manipuler, au sein d’une boucle Pour, la variable qui sert de compteur à
cette boucle. Cette technique est à proscrire absolument… sauf bien sûr, si vous cherchez un
prétexte pour régaler tout le monde au bistrot.
Mais dans ce cas, n’ayez aucune inhibition, proposez-le directement, pas besoin de prétexte.

Exercice 5.4
Ecrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la table de
multiplication de ce nombre, présentée comme suit (cas où l'utilisateur entre le nombre 7) :
Table de 7 :
7x1=7
7 x 2 = 14
7 x 3 = 21
…
7 x 10 = 70

Corrigé Exercice 5.4

Variables N, i en Entier
Debut
Ecrire "Entrez un nombre : "
Lire N
Ecrire "La table de multiplication de ce nombre est : "
Pour i ← 1 à 10
Ecrire N, " x ", i, " = ", n*i
i Suivant
Fin

Equivalent javascript :

var N = 0 ;

N = prompt("Entrez un nombre :") ;

Alert("La table de multiplication de ce nombre est : ") ;

for (var i=1 ;i<=10 ;i++) {

alert(N+" x "+ i+ " = "+ N*i) ;
}

Exercice 5.5
Ecrire un algorithme qui demande un nombre de départ, et qui calcule la somme des entiers
jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
NB : on souhaite afficher uniquement le résultat, pas la décomposition du calcul.

Corrigé Exercice 5.5

Variables N, i, Som en Entier

Debut
Ecrire "Entrez un nombre : "
Lire N
Som ← 0
Pour i ← 1 à N
Som ← Som + i
i Suivant
Ecrire "La somme est : ", Som
Fin

Equivalent javascript :

var N = 0 ;
var Som = 0 ;

N = prompt("Entrez un nombre :") ;

for (var i=1 ;i<=N ;i++) {
Som = Som + i ;
}
alert("La somme est : "+ Som) ;

Exercice 5.6
Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle.
NB : la factorielle de 8, notée 8 !, vaut
1x2x3x4x5x6x7x8

Corrigé Exercice 5.6

Variables N, i, F en Entier
Debut
Ecrire "Entrez un nombre : "
Lire N
F←1
Pour i ← 2 à N
F←F*i
i Suivant
Ecrire "La factorielle est : ", F
Fin

Equivalent javascript :
var N = 0 ;
var F = 0 ;

N = prompt("Entrez un nombre :") ;

for (var i=2 ;i<=N ;i++) {
F=F*i;
}
alert("La factorielle est : "+ F) ;

Exercice 5.7
Ecrire un algorithme qui demande successivement 20 nombres à l’utilisateur, et qui lui dise
ensuite quel était le plus grand parmi ces 20 nombres :
Entrez le nombre numéro 1 : 12
Entrez le nombre numéro 2 : 14
etc.
Entrez le nombre numéro 20 : 6
Le plus grand de ces nombres est : 14
Modifiez ensuite l’algorithme pour que le programme affiche de surcroît en quelle position
avait été saisie ce nombre :
C’était le nombre numéro 2

Corrigé Exercice 5.7

Variables N, i, PG en Entier
Debut
PG ← 0
Pour i ← 1 à 20
Ecrire "Entrez un nombre : "
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 n’importe quoi dans PG, il suffit que cette variable soit affectée
pour que le premier passage en ligne 7 ne provoque pas d'erreur.

Pour la version améliorée, cela donne :

Variables N, i, PG, IPG en Entier
Debut
PG ← 0
Pour i ← 1 à 20
Ecrire "Entrez un nombre : "
Lire N
Si i = 1 ou N > PG Alors
PG ← N
 IPG ← i
FinSi
i Suivant
Ecrire "Le nombre le plus grand était : ", PG
Ecrire "Il a été saisi en position numéro ", IPG
Fin

Exercice 5.8

Réécrire l’algorithme précédent, mais cette fois-ci on ne connaît pas d’avance combien l’utilisateur
souhaite saisir de nombres. La saisie des nombres s’arrête lorsque l’utilisateur entre un zéro.

Corrigé Exercice 5.8

Variables N, i, PG, IPG en Entier

Debut
N←1
i←0
PG ← 0
TantQue N <> 0
Ecrire "Entrez un nombre : "
Lire N
i←i+1
Si i = 1 ou N > PG Alors
PG ← N
IPG ← i
FinSi
FinTantQue
Ecrire "Le nombre le plus grand était : ", PG
Ecrire "Il a été saisi en position numéro ", IPG
Fin

Exercice 5.9

Lire la suite des prix (en euros entiers et terminée par zéro) des achats d’un client. Calculer la somme
qu’il doit, lire la somme qu’il paye, et simuler la remise de la monnaie en affichant les textes "10
Euros", "5 Euros" et "1 Euro" autant de fois qu’il y a de coupures de chaque sorte à rendre.

Corrigé Exercice 5.9

Variables E, somdue, M, Reste, Nb10E, Nb5E En Entier

Debut
E←1
somdue ← 0
TantQue E <> 0
 Ecrire "Entrez le montant : "
Lire E
somdue ← somdue + E
FinTantQue
Ecrire "Vous devez :", somdue, " euros"
Ecrire "Montant versé :"
Lire M
Reste ← M - somdue
Nb10E ← 0
TantQue Reste >= 10
Nb10E ← Nb10E + 1
Reste ← Reste – 10
FinTantQue
Nb5E ← 0
Si Reste >= 5
Nb5E ← 1
Reste ← Reste – 5
FinSi
Ecrire "Rendu de la monnaie :"
Ecrire "Billets de 10 E : ", Nb10E
Ecrire "Billets de 5 E : ", Nb5E
Ecrire "Pièces de 1 E : ", reste
Fin

Exercice 5.10

Écrire un algorithme qui permette de connaître ses chances de gagner au tiercé, quarté, quinté et
autres impôts volontaires.

On demande à l’utilisateur le nombre de chevaux partants, et le nombre de chevaux joués. Les deux
messages affichés devront être :

Dans l’ordre : une chance sur X de gagner

Dans le désordre : une chance sur Y de gagner

X et Y nous sont donnés par la formule suivante, si n est le nombre de chevaux partants et p le
nombre de chevaux joués (on rappelle que le signe ! signifie "factorielle", comme dans l'exercice 5.6
ci-dessus) :

X = n ! / (n - p) !
Y = n ! / (p ! * (n – p) !)

NB : cet algorithme peut être écrit d’une manière simple, mais relativement peu performante. Ses
performances peuvent être singulièrement augmentées par une petite astuce. Vous commencerez
par écrire la manière la plus simple, puis vous identifierez le problème, et écrirez une deuxième
version permettant de le résoudre.
Corrigé Exercice 5.10

Spontanément, on est tenté d'écrire l'algorithme suivant :

Variables N, P, i, Numé, Déno1, Déno2 en Entier
Debut Ecrire "Entrez le nombre de chevaux partants : "
Lire N
Ecrire "Entrez le nombre de chevaux joués : "
Lire P
Numé ← 1
Pour i ← 2 à N
Numé ← Numé * i
i Suivant
Déno1 ← 1
Pour i ← 2 à N-P
Déno1 ← Déno1 * i
i Suivant
Déno2 ← 1
Pour i ← 2 à P
Déno2 ← Déno2 * i
i Suivant
Ecrire "Dans l’ordre, une chance sur ", Numé / Déno1
Ecrire "Dans le désordre, une sur ", Numé / (Déno1 * Déno2)
Fin
Cette version, formellement juste, comporte tout de même deux faiblesses.

La première, et la plus grave, concerne la manière dont elle calcule le résultat final. Celui-ci
est le quotient d'un nombre par un autre ; or, ces nombres auront rapidement tendance à être
très grands. En calculant, comme on le fait ici, d'abord le numérateur, puis ensuite le
dénominateur, on prend le risque de demander à la machine de stocker des nombres trop
grands pour qu'elle soit capable de les coder (cf. le préambule). C'est d'autant plus bête que
rien ne nous oblige à procéder ainsi : on n'est pas obligé de passer par la division de deux très
grands nombres pour obtenir le résultat voulu.

La deuxième remarque est qu'on a programmé ici trois boucles successives. Or, en y regardant
bien, on peut voir qu'après simplification de la formule, ces trois boucles comportent le même
nombre de tours ! (si vous ne me croyez pas, écrivez un exemple de calcul et biffez les
nombres identiques au numérateur et au dénominateur). 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 joués : "
Lire P
A←1
B←1
Pour i ← 1 à P
A ← A * (i + N - P)
B←B*i
i Suivant
Ecrire "Dans l’ordre, une chance sur ", A
Ecrire "Dans le désordre, une chance sur ", A / B
Fin

Partie 6
Les Tableaux

« Si on ment à un compilateur, il prendra sa revanche. » - Henry Spencer.

Bonne nouvelle ! Je vous avais annoncé qu’il y a avait en tout et pour tout quatre structures logiques
dans la programmation. Eh bien, ça y est, on les a toutes passées en revue.
Mauvaise nouvelle, il vous reste tout de même quelques petites choses à apprendre…

1. Utilité des tableaux

Imaginons que dans un programme, nous ayons besoin simultanément de 12 valeurs (par exemple,
des notes pour calculer une moyenne). Evidemment, la seule solution dont nous disposons à l’heure
actuelle consiste à déclarer douze variables, appelées par exemple Notea, Noteb, Notec, etc. Bien
sûr, on peut opter pour une notation un peu simplifiée, par exemple N1, N2, N3, etc. Mais cela ne
change pas fondamentalement notre problème, car arrivé au calcul, et après une succession de
douze instructions « Lire » distinctes, cela donnera obligatoirement une atrocité du genre :

Moy ← (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10+N11+N12)/12

Ouf ! C’est tout de même 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à c’est le suicide
direct.

Cerise sur le gâteau, si en plus on est dans une situation on l’on ne peut pas savoir d’avance combien
il y aura de valeurs à traiter, là on est carrément cuits.

C’est pourquoi la programmation nous permet de rassembler toutes ces variables en une seule, au
sein de laquelle chaque valeur sera désignée par un numéro. En bon français, cela donnerait donc
quelque chose du genre « la note numéro 1 », « la note numéro 2 », « la note numéro 8 ». C’est
largement plus pratique, vous vous en doutez.

Un ensemble de valeurs portant le même nom de variable et repérées par un nombre, s’appelle un
tableau, ou encore une variable indicée.
Le nombre qui, au sein d’un tableau, sert à repérer chaque valeur s’appelle – ô surprise – l’indice.
Chaque fois que l’on doit désigner un élément du tableau, on fait figurer le nom du tableau, suivi de
l’indice de l’élément, entre parenthèses.

2. Notation et utilisation algorithmique

Dans notre exemple, nous créerons donc un tableau appelé Note. Chaque note individuelle (chaque
élément du tableau Note) sera donc désignée Note(0), Note(1), etc. Eh oui, attention, les indices des
tableaux commencent généralement à 0, et non à 1.

Un tableau doit être déclaré comme tel, en précisant le nombre et le type de valeurs qu’il contiendra
(la déclaration des tableaux est susceptible de varier d'un langage à l'autre. Certains langages
réclament le nombre d'éléments, d'autre le plus grand indice... C'est donc une affaire de
conventions).

En nous calquant sur les choix les plus fréquents dans les langages de programmations, nous
déciderons ici arbitrairement et une bonne fois pour toutes que :

 les "cases" sont numérotées à partir de zéro, autrement dit que le plus petit indice est zéro.
 lors de la déclaration d'un tableau, on précise la plus grande valeur de l'indice (différente,
donc, du nombre de cases du tableau, puisque si on veut 12 emplacements, le plus grand
indice sera 11). Au début, ça déroute, mais vous verrez, avec le temps, on se fait à tout,
même au pire.

Tableau Note(11) en Entier

On peut créer des tableaux contenant des variables de tous types : tableaux de numériques, bien
sûr, mais aussi tableaux de caractères, tableaux de booléens, tableaux de tout ce qui existe dans un
langage donné comme type de variables. Par contre, hormis dans quelques rares langages, on ne
peut pas faire un mixage de types différents de valeurs au sein d’un même tableau.

L’énorme avantage des tableaux, c’est qu’on va pouvoir les traiter en faisant des boucles. Par
exemple, pour effectuer notre calcul de moyenne, cela donnera par exemple :

Tableau Note(11) en Numérique

Variables Moy, Som en Numérique
Début
Pour i ← 0 à 11
Ecrire "Entrez la note n°", i
Lire Note(i)
i Suivant
Som ← 0
Pour i ← 0 à 11
Som ← Som + Note(i)
i Suivant
Moy ← Som / 12
Fin

NB : On a fait deux boucles successives pour plus de lisibilité, mais on aurait tout aussi bien pu n’en
écrire qu’une seule dans laquelle on aurait tout fait d’un seul coup.

Remarque générale : l’indice qui sert à désigner les éléments d’un tableau peut être exprimé
directement comme un nombre en clair, mais il peut être aussi une variable, ou une expression
calculée.

Dans un tableau, la valeur d’un indice doit toujours :

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

 être inférieure ou égale au nombre d’éléments du tableau (moins 1, si l’on commence la

numérotation à zéro). Si le tableau Bidule a été déclaré comme ayant 25 éléments, la
présence dans une ligne, sous une forme ou sous une autre, de Bidule(32) déclenchera
automatiquement une erreur.

Je le re-re-répète, si l’on est dans un langage où les indices commencent à zéro, il faut en tenir
compte à la déclaration :
Tableau Note(13) en Numérique

...créera un tableau de 14 éléments, le plus petit indice étant 0 et le plus grand 13.

LE GAG DE LA JOURNEE
Il consiste à confondre, dans sa tête et / ou dans un algorithme, l’indice d’un élément d’un tableau
avec le contenu de cet élément. La troisième maison de la rue n’a pas forcément trois habitants, et la
vingtième vingt habitants. En notation algorithmique, il n’y a aucun rapport entre i et truc(i).

Holà, Tavernier, prépare la cervoise !

Exercice 6.1
Ecrire un algorithme qui déclare et remplisse un tableau de 7 valeurs numériques en les
mettant toutes à zéro.

Corrigé Exercice 6.1

Tableau Truc(6) en Numérique

Variable i en Numérique
Debut
Pour i ← 0 à 6
Truc(i) ← 0
i Suivant
Fin

Equivalent javascript :
var Truc = new array() ;

for (var i=0 ;i<7 ;i++) {

Truc[i] = 0 ;
}
Exercice 6.2

Ecrire un algorithme qui déclare et remplisse un tableau contenant les six voyelles de l’alphabet latin.

Corrigé Exercice 6.2

Tableau Truc(5) en Caractère

Debut
Truc(0) ← "a"
Truc(1) ← "e"
Truc(2) ← "i"
Truc(3) ← "o"
Truc(4) ← "u"
Truc(5) ← "y"
Fin

Equivalent javascript :
var Truc = new array() ;
Truc[0] = "a" ;
Truc[1] = "e" ;
Truc[2] = "i" ;
Truc[3] = "o" ;
Truc[4] = "u" ;
Truc[5] = "y" ;

Exercice 6.3
Ecrire un algorithme qui déclare un tableau de 9 notes, dont on fait ensuite saisir les valeurs
par l’utilisateur.

Corrigé Exercice 6.3

Tableau Notes(8) en Numérique

Variable i en Numérique
Pour i ← 0 à 8
Ecrire "Entrez la note numéro ", i + 1
Lire Notes(i)
i Suivant
Fin

Equivalent javascript :
var Notes = new array() ;
var num=0 ;
for (var i=0 ;i<9 ;i++) {
 num = i + 1 ;
Notes [i] = prompt("Entrez la note numéro "+ num, "") ;
}

Exercice 6.4

Que produit l’algorithme suivant ?

Tableau Nb(5) en Entier

Variable i en Entier
Début
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 même résultat ?

Corrigé Exercice 6.4

Cet algorithme remplit un tableau avec six valeurs : 0, 1, 4, 9, 16, 25.

Il les écrit ensuite à l’écran. Simplification :
Tableau Nb(5) en Numérique
Variable i en Numérique
Début
Pour i ← 0 à 5
Nb(i) ← i * i
Ecrire Nb(i)
i Suivant
Fin

Exercice 6.5

Que produit l’algorithme suivant ?

Tableau N(6) en Entier

Variables i, k en Entier
Début
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 même résultat ?

Corrigé Exercice 6.5

Cet algorithme remplit un tableau avec les sept valeurs : 1, 3, 5, 7, 9, 11, 13.
Il les écrit ensuite à l’écran. Simplification :
Tableau N(6) en Numérique
Variables i, k en Numérique
Début
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

Que produit l’algorithme suivant ?

Tableau Suite(7) en Entier

Variable i en Entier
Début
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

Corrigé Exercice 6.6

Cet algorithme remplit un tableau de 8 valeurs : 1, 1, 2, 3, 5, 8, 13, 21

Exercice 6.7

Ecrivez la fin de l’algorithme 6.3 afin que le calcul de la moyenne des notes soit effectué et affiché à
l’écran.
Corrigé Exercice 6.7

Variable S en Numérique
Tableau Notes(8) en Numérique
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

3. Tableaux dynamiques

Il arrive fréquemment que l’on ne connaisse pas à l’avance le nombre d’éléments que devra
comporter un tableau. Bien sûr, une solution consisterait à déclarer un tableau gigantesque (10 000
éléments, pourquoi pas, au diable les varices) pour être sûr que « ça rentre ». Mais d’une part, on
n’en sera jamais parfaitement sûr, d’autre part, en raison de l’immensité de la place mémoire
réservée – et la plupart du temps non utilisée, c’est un gâchis préjudiciable à la rapidité, voire à la
viabilité, de notre algorithme.

Aussi, pour parer à ce genre de situation, a-t-on la possibilité de déclarer le tableau sans préciser au
départ son nombre d’éléments. Ce n’est que dans un second temps, au cours du programme, que
l’on va fixer ce nombre via une instruction de redimensionnement : Redim.

Notez que tant qu’on n’a pas précisé le nombre d’éléments d’un tableau, d’une manière ou d’une
autre, ce tableau est inutilisable.

Exemple : on veut faire saisir des notes pour un calcul de moyenne, mais on ne sait pas combien il y
aura de notes à saisir. Le début de l’algorithme sera quelque chose du genre :

Tableau Notes() en Numérique

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

Cette technique n’a rien de sorcier, mais elle fait partie de l’arsenal de base de la programmation en
gestion.

Exercice 6.8
Ecrivez un algorithme permettant à l’utilisateur de saisir un nombre quelconque de valeurs, qui
devront être stockées dans un tableau. L’utilisateur doit donc commencer par entrer le nombre de
valeurs qu’il compte saisir. Il effectuera ensuite cette saisie. Enfin, une fois la saisie terminée, le
programme affichera le nombre de valeurs négatives et le nombre de valeurs positives.

Corrigé Exercice 6.8

Variables Nb, Nbpos, Nbneg en Numérique

Tableau T() en Numérique
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 négatives : ", Nbneg
Fin

Exercice 6.9

Ecrivez un algorithme calculant la somme des valeurs d’un tableau (on suppose que le tableau a été
préalablement saisi).

Corrigé Exercice 6.9

Variables i, Som, N en Numérique

Tableau T() en Numérique
Debut

… (on ne programme pas la saisie du tableau, dont on suppose qu’il compte N éléments)

Redim T(N-1)
…
Som ← 0
Pour i ← 0 à N - 1
Som ← Som + T(i)
i Suivant
Ecrire "Somme des éléments du tableau : ", Som
Fin

Exercice 6.10

Ecrivez un algorithme constituant un tableau, à partir de deux tableaux de même longueur

préalablement saisis. Le nouveau tableau sera la somme des éléments des deux tableaux de départ.

Tableau 1 :

4 8 7 9 1 5 4 6

Tableau 2 :

7 6 5 2 1 3 7 4

Tableau à constituer :

11 14 12 11 2 8 11 10

Corrigé Exercice 6.10

Variables i, N en Numérique
Tableaux T1(), T2(), T3() en Numérique
Debut

… (on suppose que T1 et T2 comptent N éléments, et qu’ils sont déjà saisis)

Redim T3(N-1)
…
Pour i ← 0 à N - 1
T3(i) ← T1(i) + T2(i)
i Suivant
Fin

Exercice 6.11
Toujours à partir de deux tableaux précédemment saisis, écrivez un algorithme qui calcule le
schtroumpf des deux tableaux. Pour calculer le schtroumpf, il faut multiplier chaque élément du
tableau 1 par chaque élément du tableau 2, et additionner le tout. Par exemple si l'on a :

Tableau 1 :

4 8 7 12

Tableau 2 :

3 6

Le Schtroumpf sera :

3 * 4 + 3 * 8 + 3 * 7 + 3 * 12 + 6 * 4 + 6 * 8 + 6 * 7 + 6 * 12 = 279

Corrigé Exercice 6.11

Variables i, j, N1, N2, S en Numérique

Tableaux T1(), T2() en Numérique
Debut

… On ne programme pas la saisie des tableaux T1 et T2.

On suppose que T1 possède N1 éléments, et que T2 en possède 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

Ecrivez un algorithme qui permette la saisie d’un nombre quelconque de valeurs, sur le principe de
l’ex 6.8. Toutes les valeurs doivent être ensuite augmentées de 1, et le nouveau tableau sera affiché à
l’écran.

Corrigé Exercice 6.12

Variables Nb, i en Numérique
Tableau T() en Numérique
Debut
Ecrire "Entrez le nombre de valeurs : "
Lire Nb
Redim T(Nb-1)
Pour i ← 0 à Nb - 1
Ecrire "Entrez le nombre n° ", i + 1
Lire T(i)
i Suivant
Ecrire "Nouveau tableau : "
Pour i ← 0 à Nb – 1
T(i) ← T(i) + 1
Ecrire T(i)
i Suivant
Fin

Exercice 6.13

Ecrivez un algorithme permettant, toujours sur le même principe, à l’utilisateur de saisir un nombre
déterminé de valeurs. Le programme, une fois la saisie terminée, renvoie la plus grande valeur en
précisant quelle position elle occupe dans le tableau. On prendra soin d’effectuer la saisie dans un
premier temps, et la recherche de la plus grande valeur du tableau dans un second temps.

Corrigé Exercice 6.13

Variables Nb, Posmaxi en Numérique

Tableau T() en Numérique
Ecrire "Entrez le nombre de valeurs :"
Lire Nb
Redim T(Nb-1)
Pour i ← 0 à Nb - 1
Ecrire "Entrez le nombre n° ", i + 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 élément : ", Posmaxi
Fin
Exercice 6.14

Toujours et encore sur le même principe, écrivez un algorithme permettant, à l’utilisateur de saisir
les notes d'une classe. Le programme, une fois la saisie terminée, renvoie le nombre de ces notes
supérieures à la moyenne de la classe.

Corrigé Exercice 6.14

Variables Nb, i, Som, Moy, Nbsup en Numérique

Tableau T() en Numérique
Debut
Ecrire "Entrez le nombre de notes à saisir : "
Lire Nb
Redim T(Nb-1)
Pour i ← 0 à Nb - 1
Ecrire "Entrez le nombre n° ", i + 1
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, " élèves dépassent la moyenne de la classe"
Fin